"
+ }
+ ],
+ "keywords": [
+ "underscore",
+ "string"
+ ],
+ "main": "./lib/underscore.string",
+ "directories": {
+ "lib": "./lib"
+ },
+ "engines": {
+ "node": "*"
+ },
+ "repository": {
+ "type": "git",
+ "url": "https://github.com/epeli/underscore.string.git"
+ },
+ "bugs": {
+ "url": "https://github.com/epeli/underscore.string/issues"
+ },
+ "licenses": [
+ {
+ "type": "MIT"
+ }
+ ],
+ "_id": "underscore.string@2.3.3",
+ "dist": {
+ "shasum": "71c08bf6b428b1133f37e78fa3a21c82f7329b0d",
+ "tarball": "http://registry.npmjs.org/underscore.string/-/underscore.string-2.3.3.tgz"
+ },
+ "_from": "underscore.string@~2.3.3",
+ "_npmVersion": "1.2.32",
+ "_npmUser": {
+ "name": "epeli",
+ "email": "esa-matti@suuronen.org"
+ },
+ "maintainers": [
+ {
+ "name": "edtsech",
+ "email": "edtsech@gmail.com"
+ },
+ {
+ "name": "rwz",
+ "email": "rwz@duckroll.ru"
+ },
+ {
+ "name": "epeli",
+ "email": "esa-matti@suuronen.org"
+ }
+ ],
+ "_shasum": "71c08bf6b428b1133f37e78fa3a21c82f7329b0d",
+ "_resolved": "https://registry.npmjs.org/underscore.string/-/underscore.string-2.3.3.tgz",
+ "readme": "ERROR: No README data found!",
+ "scripts": {}
+}
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/grunt-legacy-log/node_modules/underscore.string/test/run-qunit.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/grunt-legacy-log/node_modules/underscore.string/test/run-qunit.js
new file mode 100644
index 0000000..44a2167
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/grunt-legacy-log/node_modules/underscore.string/test/run-qunit.js
@@ -0,0 +1,45 @@
+function waitFor(test, complete, timeout) {
+ var result, start = new Date().getTime()
+ setInterval(function interval() {
+ if ((new Date().getTime() - start < timeout) && !result) {
+ result = test()
+ } else {
+ if (!result) {
+ phantom.exit(1)
+ } else {
+ complete()
+ clearInterval(interval)
+ }
+ }
+ }, 100)
+}
+
+
+var fs = require('fs'), page = require('webpage').create();
+var url = 'file://localhost' + fs.workingDirectory + '/' + phantom.args[0];
+
+page.onConsoleMessage = function(msg) {
+ console.log(msg)
+}
+
+page.open(url, function(status) {
+ waitFor(function() {
+ return page.evaluate(function(){
+ var el = document.getElementById('qunit-testresult')
+ return el && el.innerText.match('completed')
+ })
+ }, function() {
+ var failures = page.evaluate(function() {
+ var el = document.getElementById('qunit-testresult'),
+ fails = document.getElementsByClassName('fail')
+
+ for (var i = 0; i < fails.length; i++)
+ console.log(fails[i].innerText)
+
+ console.log(el.innerText)
+
+ return parseInt(el.getElementsByClassName('failed')[0].innerHTML)
+ })
+ phantom.exit(failures > 0 ? 1 : 0)
+ }, 10000)
+})
\ No newline at end of file
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/grunt-legacy-log/node_modules/underscore.string/test/speed.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/grunt-legacy-log/node_modules/underscore.string/test/speed.js
new file mode 100644
index 0000000..9ceeea7
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/grunt-legacy-log/node_modules/underscore.string/test/speed.js
@@ -0,0 +1,148 @@
+(function() {
+
+ JSLitmus.test('levenshtein', function() {
+ return [
+ _.levenshtein('pineapple', 'potato'),
+ _.levenshtein('seven', 'eight'),
+ _.levenshtein('the very same string', 'the very same string'),
+ _.levenshtein('very very very long string', 'something completely different')
+ ];
+ });
+
+
+ JSLitmus.test('trimNoNative', function() {
+ return _.trim(" foobar ", " ");
+ });
+
+ JSLitmus.test('trim', function() {
+ return _.trim(" foobar ");
+ });
+
+ JSLitmus.test('trim object-oriented', function() {
+ return _(" foobar ").trim();
+ });
+
+ JSLitmus.test('trim jQuery', function() {
+ return jQuery.trim(" foobar ");
+ });
+
+ JSLitmus.test('ltrimp', function() {
+ return _.ltrim(" foobar ", " ");
+ });
+
+ JSLitmus.test('rtrimp', function() {
+ return _.rtrim(" foobar ", " ");
+ });
+
+ JSLitmus.test('startsWith', function() {
+ return _.startsWith("foobar", "foo");
+ });
+
+ JSLitmus.test('endsWith', function() {
+ return _.endsWith("foobar", "xx");
+ });
+
+ JSLitmus.test('chop', function(){
+ return _('whitespace').chop(2);
+ });
+
+ JSLitmus.test('count', function(){
+ return _('Hello worls').count('l');
+ });
+
+ JSLitmus.test('insert', function() {
+ return _('Hello ').insert(6, 'world');
+ });
+
+ JSLitmus.test('splice', function() {
+ return _('https://edtsech@bitbucket.org/edtsech/underscore.strings').splice(30, 7, 'epeli');
+ });
+
+ JSLitmus.test('succ', function(){
+ var let = 'a', alphabet = [];
+
+ for (var i=0; i < 26; i++) {
+ alphabet.push(let);
+ let = _(let).succ();
+ }
+
+ return alphabet;
+ });
+
+ JSLitmus.test('titleize', function(){
+ return _('the titleize string method').titleize();
+ });
+
+ JSLitmus.test('truncate', function(){
+ return _('Hello world').truncate(5);
+ });
+
+ JSLitmus.test('prune', function(){
+ return _('Hello world').prune(5);
+ });
+
+ JSLitmus.test('isBlank', function(){
+ return _('').isBlank();
+ });
+
+ JSLitmus.test('escapeHTML', function(){
+ _('Blah blah blah
').escapeHTML();
+ });
+
+ JSLitmus.test('unescapeHTML', function(){
+ _('<div>Blah blah blah</div>').unescapeHTML();
+ });
+
+ JSLitmus.test('reverse', function(){
+ _('Hello World').reverse();
+ });
+
+ JSLitmus.test('pad default', function(){
+ _('foo').pad(12);
+ });
+
+ JSLitmus.test('pad hash left', function(){
+ _('foo').pad(12, '#');
+ });
+
+ JSLitmus.test('pad hash right', function(){
+ _('foo').pad(12, '#', 'right');
+ });
+
+ JSLitmus.test('pad hash both', function(){
+ _('foo').pad(12, '#', 'both');
+ });
+
+ JSLitmus.test('pad hash both longPad', function(){
+ _('foo').pad(12, 'f00f00f00', 'both');
+ });
+
+ JSLitmus.test('toNumber', function(){
+ _('10.232323').toNumber(2);
+ });
+
+ JSLitmus.test('strRight', function(){
+ _('aaa_bbb_ccc').strRight('_');
+ });
+
+ JSLitmus.test('strRightBack', function(){
+ _('aaa_bbb_ccc').strRightBack('_');
+ });
+
+ JSLitmus.test('strLeft', function(){
+ _('aaa_bbb_ccc').strLeft('_');
+ });
+
+ JSLitmus.test('strLeftBack', function(){
+ _('aaa_bbb_ccc').strLeftBack('_');
+ });
+
+ JSLitmus.test('join', function(){
+ _('separator').join(1, 2, 3, 4, 5, 6, 7, 8, 'foo', 'bar', 'lol', 'wut');
+ });
+
+ JSLitmus.test('slugify', function(){
+ _("Un éléphant à l'orée du bois").slugify();
+ });
+
+})();
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/grunt-legacy-log/node_modules/underscore.string/test/strings.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/grunt-legacy-log/node_modules/underscore.string/test/strings.js
new file mode 100644
index 0000000..77364f2
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/grunt-legacy-log/node_modules/underscore.string/test/strings.js
@@ -0,0 +1,685 @@
+$(document).ready(function() {
+
+ // Include Underscore.string methods to Underscore namespace
+ _.mixin(_.str.exports());
+
+ module('String extensions');
+
+ test('Strings: naturalSort', function() {
+ var arr = ['foo2', 'foo1', 'foo10', 'foo30', 'foo100', 'foo10bar'],
+ sorted = ['foo1', 'foo2', 'foo10', 'foo10bar', 'foo30', 'foo100'];
+ deepEqual(arr.sort(_.naturalCmp), sorted);
+ });
+
+ test('Strings: trim', function() {
+ equal(_.trim(123), '123', 'Non string');
+ equal(_(' foo').trim(), 'foo');
+ equal(_('foo ').trim(), 'foo');
+ equal(_(' foo ').trim(), 'foo');
+ equal(_(' foo ').trim(), 'foo');
+ equal(_(' foo ').trim(' '), 'foo', 'Manually set whitespace');
+ equal(_('\t foo \t ').trim(/\s/), 'foo', 'Manually set RegExp /\\s+/');
+
+ equal(_('ffoo').trim('f'), 'oo');
+ equal(_('ooff').trim('f'), 'oo');
+ equal(_('ffooff').trim('f'), 'oo');
+
+
+ equal(_('_-foobar-_').trim('_-'), 'foobar');
+
+ equal(_('http://foo/').trim('/'), 'http://foo');
+ equal(_('c:\\').trim('\\'), 'c:');
+
+ equal(_(123).trim(), '123');
+ equal(_(123).trim(3), '12');
+ equal(_('').trim(), '', 'Trim empty string should return empty string');
+ equal(_(null).trim(), '', 'Trim null should return empty string');
+ equal(_(undefined).trim(), '', 'Trim undefined should return empty string');
+ });
+
+ test('String: levenshtein', function() {
+ equal(_.levenshtein('Godfather', 'Godfather'), 0);
+ equal(_.levenshtein('Godfather', 'Godfathe'), 1);
+ equal(_.levenshtein('Godfather', 'odfather'), 1);
+ equal(_.levenshtein('Godfather', 'Gdfthr'), 3);
+ equal(_.levenshtein('seven', 'eight'), 5);
+ equal(_.levenshtein('123', 123), 0);
+ equal(_.levenshtein(321, '321'), 0);
+ equal(_.levenshtein('lol', null), 3);
+ equal(_.levenshtein('lol'), 3);
+ equal(_.levenshtein(null, 'lol'), 3);
+ equal(_.levenshtein(undefined, 'lol'), 3);
+ equal(_.levenshtein(), 0);
+ });
+
+ test('Strings: ltrim', function() {
+ equal(_(' foo').ltrim(), 'foo');
+ equal(_(' foo').ltrim(), 'foo');
+ equal(_('foo ').ltrim(), 'foo ');
+ equal(_(' foo ').ltrim(), 'foo ');
+ equal(_('').ltrim(), '', 'ltrim empty string should return empty string');
+ equal(_(null).ltrim(), '', 'ltrim null should return empty string');
+ equal(_(undefined).ltrim(), '', 'ltrim undefined should return empty string');
+
+ equal(_('ffoo').ltrim('f'), 'oo');
+ equal(_('ooff').ltrim('f'), 'ooff');
+ equal(_('ffooff').ltrim('f'), 'ooff');
+
+ equal(_('_-foobar-_').ltrim('_-'), 'foobar-_');
+
+ equal(_(123).ltrim(1), '23');
+ });
+
+ test('Strings: rtrim', function() {
+ equal(_('http://foo/').rtrim('/'), 'http://foo', 'clean trailing slash');
+ equal(_(' foo').rtrim(), ' foo');
+ equal(_('foo ').rtrim(), 'foo');
+ equal(_('foo ').rtrim(), 'foo');
+ equal(_('foo bar ').rtrim(), 'foo bar');
+ equal(_(' foo ').rtrim(), ' foo');
+
+ equal(_('ffoo').rtrim('f'), 'ffoo');
+ equal(_('ooff').rtrim('f'), 'oo');
+ equal(_('ffooff').rtrim('f'), 'ffoo');
+
+ equal(_('_-foobar-_').rtrim('_-'), '_-foobar');
+
+ equal(_(123).rtrim(3), '12');
+ equal(_('').rtrim(), '', 'rtrim empty string should return empty string');
+ equal(_(null).rtrim(), '', 'rtrim null should return empty string');
+ });
+
+ test('Strings: capitalize', function() {
+ equal(_('fabio').capitalize(), 'Fabio', 'First letter is upper case');
+ equal(_.capitalize('fabio'), 'Fabio', 'First letter is upper case');
+ equal(_.capitalize('FOO'), 'FOO', 'Other letters unchanged');
+ equal(_(123).capitalize(), '123', 'Non string');
+ equal(_.capitalize(''), '', 'Capitalizing empty string returns empty string');
+ equal(_.capitalize(null), '', 'Capitalizing null returns empty string');
+ equal(_.capitalize(undefined), '', 'Capitalizing undefined returns empty string');
+ });
+
+ test('Strings: join', function() {
+ equal(_.join('', 'foo', 'bar'), 'foobar', 'basic join');
+ equal(_.join('', 1, 'foo', 2), '1foo2', 'join numbers and strings');
+ equal(_.join(' ','foo', 'bar'), 'foo bar', 'join with spaces');
+ equal(_.join('1', '2', '2'), '212', 'join number strings');
+ equal(_.join(1, 2, 2), '212', 'join numbers');
+ equal(_.join('','foo', null), 'foo', 'join null with string returns string');
+ equal(_.join(null,'foo', 'bar'), 'foobar', 'join strings with null returns string');
+ equal(_(' ').join('foo', 'bar'), 'foo bar', 'join object oriented');
+ });
+
+ test('Strings: reverse', function() {
+ equal(_.str.reverse('foo'), 'oof' );
+ equal(_.str.reverse('foobar'), 'raboof' );
+ equal(_.str.reverse('foo bar'), 'rab oof' );
+ equal(_.str.reverse('saippuakauppias'), 'saippuakauppias' );
+ equal(_.str.reverse(123), '321', 'Non string');
+ equal(_.str.reverse(123.45), '54.321', 'Non string');
+ equal(_.str.reverse(''), '', 'reversing empty string returns empty string' );
+ equal(_.str.reverse(null), '', 'reversing null returns empty string' );
+ equal(_.str.reverse(undefined), '', 'reversing undefined returns empty string' );
+ });
+
+ test('Strings: clean', function() {
+ equal(_(' foo bar ').clean(), 'foo bar');
+ equal(_(123).clean(), '123');
+ equal(_('').clean(), '', 'claning empty string returns empty string');
+ equal(_(null).clean(), '', 'claning null returns empty string');
+ equal(_(undefined).clean(), '', 'claning undefined returns empty string');
+ });
+
+ test('Strings: sprintf', function() {
+ // Should be very tested function already. Thanks to
+ // http://www.diveintojavascript.com/projects/sprintf-for-javascript
+ equal(_.sprintf('Hello %s', 'me'), 'Hello me', 'basic');
+ equal(_('Hello %s').sprintf('me'), 'Hello me', 'object');
+ equal(_('hello %s').chain().sprintf('me').capitalize().value(), 'Hello me', 'Chaining works');
+ equal(_.sprintf('%.1f', 1.22222), '1.2', 'round');
+ equal(_.sprintf('%.1f', 1.17), '1.2', 'round 2');
+ equal(_.sprintf('%(id)d - %(name)s', {id: 824, name: 'Hello World'}), '824 - Hello World', 'Named replacements work');
+ equal(_.sprintf('%(args[0].id)d - %(args[1].name)s', {args: [{id: 824}, {name: 'Hello World'}]}), '824 - Hello World', 'Named replacements with arrays work');
+ });
+
+
+ test('Strings: vsprintf', function() {
+ equal(_.vsprintf('Hello %s', ['me']), 'Hello me', 'basic');
+ equal(_('Hello %s').vsprintf(['me']), 'Hello me', 'object');
+ equal(_('hello %s').chain().vsprintf(['me']).capitalize().value(), 'Hello me', 'Chaining works');
+ equal(_.vsprintf('%.1f', [1.22222]), '1.2', 'round');
+ equal(_.vsprintf('%.1f', [1.17]), '1.2', 'round 2');
+ equal(_.vsprintf('%(id)d - %(name)s', [{id: 824, name: 'Hello World'}]), '824 - Hello World', 'Named replacement works');
+ equal(_.vsprintf('%(args[0].id)d - %(args[1].name)s', [{args: [{id: 824}, {name: 'Hello World'}]}]), '824 - Hello World', 'Named replacement with arrays works');
+ });
+
+ test('Strings: startsWith', function() {
+ ok(_('foobar').startsWith('foo'), 'foobar starts with foo');
+ ok(!_('oobar').startsWith('foo'), 'oobar does not start with foo');
+ ok(_(12345).startsWith(123), '12345 starts with 123');
+ ok(!_(2345).startsWith(123), '2345 does not start with 123');
+ ok(_('').startsWith(''), 'empty string starts with empty string');
+ ok(_(null).startsWith(''), 'null starts with empty string');
+ ok(!_(null).startsWith('foo'), 'null starts with foo');
+ });
+
+ test('Strings: endsWith', function() {
+ ok(_('foobar').endsWith('bar'), 'foobar ends with bar');
+ ok(_.endsWith('foobar', 'bar'), 'foobar ends with bar');
+ ok(_.endsWith('00018-0000062.Plone.sdh264.1a7264e6912a91aa4a81b64dc5517df7b8875994.mp4', 'mp4'), 'endsWith .mp4');
+ ok(!_('fooba').endsWith('bar'), 'fooba does not end with bar');
+ ok(_.endsWith(12345, 45), '12345 ends with 45');
+ ok(!_.endsWith(12345, 6), '12345 does not end with 6');
+ ok(_('').endsWith(''), 'empty string ends with empty string');
+ ok(_(null).endsWith(''), 'null ends with empty string');
+ ok(!_(null).endsWith('foo'), 'null ends with foo');
+ });
+
+ test('Strings: include', function() {
+ ok(_.str.include('foobar', 'bar'), 'foobar includes bar');
+ ok(!_.str.include('foobar', 'buzz'), 'foobar does not includes buzz');
+ ok(_.str.include(12345, 34), '12345 includes 34');
+ ok(!_.str.contains(12345, 6), '12345 does not includes 6');
+ ok(!_.str.include('', 34), 'empty string includes 34');
+ ok(!_.str.include(null, 34), 'null includes 34');
+ ok(_.str.include(null, ''), 'null includes empty string');
+ });
+
+ test('String: chop', function(){
+ ok(_('whitespace').chop(2).length === 5, 'output [wh, it, es, pa, ce]');
+ ok(_('whitespace').chop(3).length === 4, 'output [whi, tes, pac, e]');
+ ok(_('whitespace').chop()[0].length === 10, 'output [whitespace]');
+ ok(_(12345).chop(1).length === 5, 'output [1, 2, 3, 4, 5]');
+ });
+
+ test('String: clean', function(){
+ equal(_.clean(' foo bar '), 'foo bar');
+ equal(_.clean(''), '');
+ equal(_.clean(null), '');
+ equal(_.clean(1), '1');
+ });
+
+ test('String: count', function(){
+ equal(_('Hello world').count('l'), 3);
+ equal(_('Hello world').count('Hello'), 1);
+ equal(_('Hello world').count('foo'), 0);
+ equal(_('x.xx....x.x').count('x'), 5);
+ equal(_('').count('x'), 0);
+ equal(_(null).count('x'), 0);
+ equal(_(undefined).count('x'), 0);
+ equal(_(12345).count(1), 1);
+ equal(_(11345).count(1), 2);
+ });
+
+ test('String: insert', function(){
+ equal(_('Hello ').insert(6, 'Jessy'), 'Hello Jessy');
+ equal(_('Hello ').insert(100, 'Jessy'), 'Hello Jessy');
+ equal(_('').insert(100, 'Jessy'), 'Jessy');
+ equal(_(null).insert(100, 'Jessy'), 'Jessy');
+ equal(_(undefined).insert(100, 'Jessy'), 'Jessy');
+ equal(_(12345).insert(6, 'Jessy'), '12345Jessy');
+ });
+
+ test('String: splice', function(){
+ equal(_('https://edtsech@bitbucket.org/edtsech/underscore.strings').splice(30, 7, 'epeli'),
+ 'https://edtsech@bitbucket.org/epeli/underscore.strings');
+ equal(_.splice(12345, 1, 2, 321), '132145', 'Non strings');
+ });
+
+ test('String: succ', function(){
+ equal(_('a').succ(), 'b');
+ equal(_('A').succ(), 'B');
+ equal(_('+').succ(), ',');
+ equal(_(1).succ(), '2');
+ });
+
+ test('String: titleize', function(){
+ equal(_('the titleize string method').titleize(), 'The Titleize String Method');
+ equal(_('the titleize string method').titleize(), 'The Titleize String Method');
+ equal(_('').titleize(), '', 'Titleize empty string returns empty string');
+ equal(_(null).titleize(), '', 'Titleize null returns empty string');
+ equal(_(undefined).titleize(), '', 'Titleize undefined returns empty string');
+ equal(_('let\'s have some fun').titleize(), 'Let\'s Have Some Fun');
+ equal(_('a-dash-separated-string').titleize(), 'A-Dash-Separated-String');
+ equal(_('A-DASH-SEPARATED-STRING').titleize(), 'A-Dash-Separated-String');
+ equal(_(123).titleize(), '123');
+ });
+
+ test('String: camelize', function(){
+ equal(_('the_camelize_string_method').camelize(), 'theCamelizeStringMethod');
+ equal(_('-the-camelize-string-method').camelize(), 'TheCamelizeStringMethod');
+ equal(_('the camelize string method').camelize(), 'theCamelizeStringMethod');
+ equal(_(' the camelize string method').camelize(), 'theCamelizeStringMethod');
+ equal(_('the camelize string method').camelize(), 'theCamelizeStringMethod');
+ equal(_('').camelize(), '', 'Camelize empty string returns empty string');
+ equal(_(null).camelize(), '', 'Camelize null returns empty string');
+ equal(_(undefined).camelize(), '', 'Camelize undefined returns empty string');
+ equal(_(123).camelize(), '123');
+ });
+
+ test('String: underscored', function(){
+ equal(_('the-underscored-string-method').underscored(), 'the_underscored_string_method');
+ equal(_('theUnderscoredStringMethod').underscored(), 'the_underscored_string_method');
+ equal(_('TheUnderscoredStringMethod').underscored(), 'the_underscored_string_method');
+ equal(_(' the underscored string method').underscored(), 'the_underscored_string_method');
+ equal(_('').underscored(), '');
+ equal(_(null).underscored(), '');
+ equal(_(undefined).underscored(), '');
+ equal(_(123).underscored(), '123');
+ });
+
+ test('String: dasherize', function(){
+ equal(_('the_dasherize_string_method').dasherize(), 'the-dasherize-string-method');
+ equal(_('TheDasherizeStringMethod').dasherize(), '-the-dasherize-string-method');
+ equal(_('thisIsATest').dasherize(), 'this-is-a-test');
+ equal(_('this Is A Test').dasherize(), 'this-is-a-test');
+ equal(_('thisIsATest123').dasherize(), 'this-is-a-test123');
+ equal(_('123thisIsATest').dasherize(), '123this-is-a-test');
+ equal(_('the dasherize string method').dasherize(), 'the-dasherize-string-method');
+ equal(_('the dasherize string method ').dasherize(), 'the-dasherize-string-method');
+ equal(_('téléphone').dasherize(), 'téléphone');
+ equal(_('foo$bar').dasherize(), 'foo$bar');
+ equal(_('').dasherize(), '');
+ equal(_(null).dasherize(), '');
+ equal(_(undefined).dasherize(), '');
+ equal(_(123).dasherize(), '123');
+ });
+
+ test('String: camelize', function(){
+ equal(_.camelize('-moz-transform'), 'MozTransform');
+ equal(_.camelize('webkit-transform'), 'webkitTransform');
+ equal(_.camelize('under_scored'), 'underScored');
+ equal(_.camelize(' with spaces'), 'withSpaces');
+ equal(_('').camelize(), '');
+ equal(_(null).camelize(), '');
+ equal(_(undefined).camelize(), '');
+ equal(_("_som eWeird---name-").camelize(), 'SomEWeirdName');
+ });
+
+ test('String: join', function(){
+ equal(_.join(1, 2, 3, 4), '21314');
+ equal(_.join('|', 'foo', 'bar', 'baz'), 'foo|bar|baz');
+ equal(_.join('',2,3,null), '23');
+ equal(_.join(null,2,3), '23');
+ });
+
+ test('String: classify', function(){
+ equal(_.classify(1), '1');
+ equal(_('some_class_name').classify(), 'SomeClassName');
+ equal(_('my wonderfull class_name').classify(), 'MyWonderfullClassName');
+ equal(_('my wonderfull.class.name').classify(), 'MyWonderfullClassName');
+ });
+
+ test('String: humanize', function(){
+ equal(_('the_humanize_string_method').humanize(), 'The humanize string method');
+ equal(_('ThehumanizeStringMethod').humanize(), 'Thehumanize string method');
+ equal(_('the humanize string method').humanize(), 'The humanize string method');
+ equal(_('the humanize_id string method_id').humanize(), 'The humanize id string method');
+ equal(_('the humanize string method ').humanize(), 'The humanize string method');
+ equal(_(' capitalize dash-CamelCase_underscore trim ').humanize(), 'Capitalize dash camel case underscore trim');
+ equal(_(123).humanize(), '123');
+ equal(_('').humanize(), '');
+ equal(_(null).humanize(), '');
+ equal(_(undefined).humanize(), '');
+ });
+
+ test('String: truncate', function(){
+ equal(_('Hello world').truncate(6, 'read more'), 'Hello read more');
+ equal(_('Hello world').truncate(5), 'Hello...');
+ equal(_('Hello').truncate(10), 'Hello');
+ equal(_('').truncate(10), '');
+ equal(_(null).truncate(10), '');
+ equal(_(undefined).truncate(10), '');
+ equal(_(1234567890).truncate(5), '12345...');
+ });
+
+ test('String: prune', function(){
+ equal(_('Hello, cruel world').prune(6, ' read more'), 'Hello read more');
+ equal(_('Hello, world').prune(5, 'read a lot more'), 'Hello, world');
+ equal(_('Hello, world').prune(5), 'Hello...');
+ equal(_('Hello, world').prune(8), 'Hello...');
+ equal(_('Hello, cruel world').prune(15), 'Hello, cruel...');
+ equal(_('Hello world').prune(22), 'Hello world');
+ equal(_('Привет, жестокий мир').prune(6, ' read more'), 'Привет read more');
+ equal(_('Привет, мир').prune(6, 'read a lot more'), 'Привет, мир');
+ equal(_('Привет, мир').prune(6), 'Привет...');
+ equal(_('Привет, мир').prune(8), 'Привет...');
+ equal(_('Привет, жестокий мир').prune(16), 'Привет, жестокий...');
+ equal(_('Привет, мир').prune(22), 'Привет, мир');
+ equal(_('alksjd!!!!!!....').prune(100, ''), 'alksjd!!!!!!....');
+ equal(_(123).prune(10), '123');
+ equal(_(123).prune(1, 321), '321');
+ equal(_('').prune(5), '');
+ equal(_(null).prune(5), '');
+ equal(_(undefined).prune(5), '');
+ });
+
+ test('String: isBlank', function(){
+ ok(_('').isBlank());
+ ok(_(' ').isBlank());
+ ok(_('\n').isBlank());
+ ok(!_('a').isBlank());
+ ok(!_('0').isBlank());
+ ok(!_(0).isBlank());
+ ok(_('').isBlank());
+ ok(_(null).isBlank());
+ ok(_(undefined).isBlank());
+ });
+
+ test('String: escapeRegExp', function(){
+ equal(_.escapeRegExp(/hello(?=\sworld)/.source), 'hello\\(\\?\\=\\\\sworld\\)', 'with lookahead');
+ equal(_.escapeRegExp(/hello(?!\shell)/.source), 'hello\\(\\?\\!\\\\shell\\)', 'with negative lookahead');
+ });
+
+ test('String: escapeHTML', function(){
+ equal(_('Blah & "blah" & \'blah\'
').escapeHTML(),
+ '<div>Blah & "blah" & 'blah'</div>');
+ equal(_('<').escapeHTML(), '<');
+ equal(_(5).escapeHTML(), '5');
+ equal(_('').escapeHTML(), '');
+ equal(_(null).escapeHTML(), '');
+ equal(_(undefined).escapeHTML(), '');
+ });
+
+ test('String: unescapeHTML', function(){
+ equal(_('<div>Blah & "blah" & 'blah'</div>').unescapeHTML(),
+ 'Blah & "blah" & \'blah\'
');
+ equal(_('<').unescapeHTML(), '<');
+ equal(_(''').unescapeHTML(), '\'');
+ equal(_(''').unescapeHTML(), '\'');
+ equal(_(''').unescapeHTML(), '\'');
+ equal(_('J').unescapeHTML(), 'J');
+ equal(_('J').unescapeHTML(), 'J');
+ equal(_('J').unescapeHTML(), 'J');
+ equal(_('&_#39;').unescapeHTML(), '&_#39;');
+ equal(_(''_;').unescapeHTML(), ''_;');
+ equal(_('&').unescapeHTML(), '&');
+ equal(_('&').unescapeHTML(), '&');
+ equal(_('').unescapeHTML(), '');
+ equal(_(null).unescapeHTML(), '');
+ equal(_(undefined).unescapeHTML(), '');
+ equal(_(5).unescapeHTML(), '5');
+ // equal(_(undefined).unescapeHTML(), '');
+ });
+
+ test('String: words', function() {
+ deepEqual(_('I love you!').words(), ['I', 'love', 'you!']);
+ deepEqual(_(' I love you! ').words(), ['I', 'love', 'you!']);
+ deepEqual(_('I_love_you!').words('_'), ['I', 'love', 'you!']);
+ deepEqual(_('I-love-you!').words(/-/), ['I', 'love', 'you!']);
+ deepEqual(_(123).words(), ['123'], '123 number has one word "123".');
+ deepEqual(_(0).words(), ['0'], 'Zero number has one word "0".');
+ deepEqual(_('').words(), [], 'Empty strings has no words.');
+ deepEqual(_(' ').words(), [], 'Blank strings has no words.');
+ deepEqual(_(null).words(), [], 'null has no words.');
+ deepEqual(_(undefined).words(), [], 'undefined has no words.');
+ });
+
+ test('String: chars', function() {
+ equal(_('Hello').chars().length, 5);
+ equal(_(123).chars().length, 3);
+ equal(_('').chars().length, 0);
+ equal(_(null).chars().length, 0);
+ equal(_(undefined).chars().length, 0);
+ });
+
+ test('String: swapCase', function(){
+ equal(_('AaBbCcDdEe').swapCase(), 'aAbBcCdDeE');
+ equal(_('Hello World').swapCase(), 'hELLO wORLD');
+ equal(_('').swapCase(), '');
+ equal(_(null).swapCase(), '');
+ equal(_(undefined).swapCase(), '');
+ });
+
+ test('String: lines', function() {
+ equal(_('Hello\nWorld').lines().length, 2);
+ equal(_('Hello World').lines().length, 1);
+ equal(_(123).lines().length, 1);
+ equal(_('').lines().length, 1);
+ equal(_(null).lines().length, 0);
+ equal(_(undefined).lines().length, 0);
+ });
+
+ test('String: pad', function() {
+ equal(_('1').pad(8), ' 1');
+ equal(_(1).pad(8), ' 1');
+ equal(_('1').pad(8, '0'), '00000001');
+ equal(_('1').pad(8, '0', 'left'), '00000001');
+ equal(_('1').pad(8, '0', 'right'), '10000000');
+ equal(_('1').pad(8, '0', 'both'), '00001000');
+ equal(_('foo').pad(8, '0', 'both'), '000foo00');
+ equal(_('foo').pad(7, '0', 'both'), '00foo00');
+ equal(_('foo').pad(7, '!@$%dofjrofj', 'both'), '!!foo!!');
+ equal(_('').pad(2), ' ');
+ equal(_(null).pad(2), ' ');
+ equal(_(undefined).pad(2), ' ');
+ });
+
+ test('String: lpad', function() {
+ equal(_('1').lpad(8), ' 1');
+ equal(_(1).lpad(8), ' 1');
+ equal(_('1').lpad(8, '0'), '00000001');
+ equal(_('1').lpad(8, '0', 'left'), '00000001');
+ equal(_('').lpad(2), ' ');
+ equal(_(null).lpad(2), ' ');
+ equal(_(undefined).lpad(2), ' ');
+ });
+
+ test('String: rpad', function() {
+ equal(_('1').rpad(8), '1 ');
+ equal(_(1).lpad(8), ' 1');
+ equal(_('1').rpad(8, '0'), '10000000');
+ equal(_('foo').rpad(8, '0'), 'foo00000');
+ equal(_('foo').rpad(7, '0'), 'foo0000');
+ equal(_('').rpad(2), ' ');
+ equal(_(null).rpad(2), ' ');
+ equal(_(undefined).rpad(2), ' ');
+ });
+
+ test('String: lrpad', function() {
+ equal(_('1').lrpad(8), ' 1 ');
+ equal(_(1).lrpad(8), ' 1 ');
+ equal(_('1').lrpad(8, '0'), '00001000');
+ equal(_('foo').lrpad(8, '0'), '000foo00');
+ equal(_('foo').lrpad(7, '0'), '00foo00');
+ equal(_('foo').lrpad(7, '!@$%dofjrofj'), '!!foo!!');
+ equal(_('').lrpad(2), ' ');
+ equal(_(null).lrpad(2), ' ');
+ equal(_(undefined).lrpad(2), ' ');
+ });
+
+ test('String: toNumber', function() {
+ deepEqual(_('not a number').toNumber(), NaN);
+ equal(_(0).toNumber(), 0);
+ equal(_('0').toNumber(), 0);
+ equal(_('0.0').toNumber(), 0);
+ equal(_('0.1').toNumber(), 0);
+ equal(_('0.1').toNumber(1), 0.1);
+ equal(_(' 0.1 ').toNumber(1), 0.1);
+ equal(_('0000').toNumber(), 0);
+ equal(_('2.345').toNumber(), 2);
+ equal(_('2.345').toNumber(NaN), 2);
+ equal(_('2.345').toNumber(2), 2.35);
+ equal(_('2.344').toNumber(2), 2.34);
+ equal(_('2').toNumber(2), 2.00);
+ equal(_(2).toNumber(2), 2.00);
+ equal(_(-2).toNumber(), -2);
+ equal(_('-2').toNumber(), -2);
+ equal(_('').toNumber(), 0);
+ equal(_(null).toNumber(), 0);
+ equal(_(undefined).toNumber(), 0);
+ });
+
+ test('String: numberFormat', function() {
+ equal(_.numberFormat(9000), '9,000');
+ equal(_.numberFormat(9000, 0), '9,000');
+ equal(_.numberFormat(9000, 0, '', ''), '9000');
+ equal(_.numberFormat(90000, 2), '90,000.00');
+ equal(_.numberFormat(1000.754), '1,001');
+ equal(_.numberFormat(1000.754, 2), '1,000.75');
+ equal(_.numberFormat(1000.754, 0, ',', '.'), '1.001');
+ equal(_.numberFormat(1000.754, 2, ',', '.'), '1.000,75');
+ equal(_.numberFormat(1000000.754, 2, ',', '.'), '1.000.000,75');
+ equal(_.numberFormat(1000000000), '1,000,000,000');
+ equal(_.numberFormat(100000000), '100,000,000');
+ equal(_.numberFormat('not number'), '');
+ equal(_.numberFormat(), '');
+ equal(_.numberFormat(null, '.', ','), '');
+ equal(_.numberFormat(undefined, '.', ','), '');
+ equal(_.numberFormat(new Number(5000)), '5,000');
+ });
+
+ test('String: strRight', function() {
+ equal(_('This_is_a_test_string').strRight('_'), 'is_a_test_string');
+ equal(_('This_is_a_test_string').strRight('string'), '');
+ equal(_('This_is_a_test_string').strRight(), 'This_is_a_test_string');
+ equal(_('This_is_a_test_string').strRight(''), 'This_is_a_test_string');
+ equal(_('This_is_a_test_string').strRight('-'), 'This_is_a_test_string');
+ equal(_('This_is_a_test_string').strRight(''), 'This_is_a_test_string');
+ equal(_('').strRight('foo'), '');
+ equal(_(null).strRight('foo'), '');
+ equal(_(undefined).strRight('foo'), '');
+ equal(_(12345).strRight(2), '345');
+ });
+
+ test('String: strRightBack', function() {
+ equal(_('This_is_a_test_string').strRightBack('_'), 'string');
+ equal(_('This_is_a_test_string').strRightBack('string'), '');
+ equal(_('This_is_a_test_string').strRightBack(), 'This_is_a_test_string');
+ equal(_('This_is_a_test_string').strRightBack(''), 'This_is_a_test_string');
+ equal(_('This_is_a_test_string').strRightBack('-'), 'This_is_a_test_string');
+ equal(_('').strRightBack('foo'), '');
+ equal(_(null).strRightBack('foo'), '');
+ equal(_(undefined).strRightBack('foo'), '');
+ equal(_(12345).strRightBack(2), '345');
+ });
+
+ test('String: strLeft', function() {
+ equal(_('This_is_a_test_string').strLeft('_'), 'This');
+ equal(_('This_is_a_test_string').strLeft('This'), '');
+ equal(_('This_is_a_test_string').strLeft(), 'This_is_a_test_string');
+ equal(_('This_is_a_test_string').strLeft(''), 'This_is_a_test_string');
+ equal(_('This_is_a_test_string').strLeft('-'), 'This_is_a_test_string');
+ equal(_('').strLeft('foo'), '');
+ equal(_(null).strLeft('foo'), '');
+ equal(_(undefined).strLeft('foo'), '');
+ equal(_(123454321).strLeft(3), '12');
+ });
+
+ test('String: strLeftBack', function() {
+ equal(_('This_is_a_test_string').strLeftBack('_'), 'This_is_a_test');
+ equal(_('This_is_a_test_string').strLeftBack('This'), '');
+ equal(_('This_is_a_test_string').strLeftBack(), 'This_is_a_test_string');
+ equal(_('This_is_a_test_string').strLeftBack(''), 'This_is_a_test_string');
+ equal(_('This_is_a_test_string').strLeftBack('-'), 'This_is_a_test_string');
+ equal(_('').strLeftBack('foo'), '');
+ equal(_(null).strLeftBack('foo'), '');
+ equal(_(undefined).strLeftBack('foo'), '');
+ equal(_(123454321).strLeftBack(3), '123454');
+ });
+
+ test('Strings: stripTags', function() {
+ equal(_('a link').stripTags(), 'a link');
+ equal(_('a link
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/grunt-legacy-log/node_modules/underscore.string/test/test_standalone.html b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/grunt-legacy-log/node_modules/underscore.string/test/test_standalone.html
new file mode 100644
index 0000000..9854c17
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/grunt-legacy-log/node_modules/underscore.string/test/test_standalone.html
@@ -0,0 +1,18 @@
+
+
+
+ Underscore.strings Test Suite
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/grunt-legacy-log/node_modules/underscore.string/test/test_underscore/arrays.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/grunt-legacy-log/node_modules/underscore.string/test/test_underscore/arrays.js
new file mode 100644
index 0000000..32252a3
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/grunt-legacy-log/node_modules/underscore.string/test/test_underscore/arrays.js
@@ -0,0 +1,200 @@
+$(document).ready(function() {
+
+ module("Arrays");
+
+ test("first", function() {
+ equal(_.first([1,2,3]), 1, 'can pull out the first element of an array');
+ equal(_([1, 2, 3]).first(), 1, 'can perform OO-style "first()"');
+ equal(_.first([1,2,3], 0).join(', '), "", 'can pass an index to first');
+ equal(_.first([1,2,3], 2).join(', '), '1, 2', 'can pass an index to first');
+ equal(_.first([1,2,3], 5).join(', '), '1, 2, 3', 'can pass an index to first');
+ var result = (function(){ return _.first(arguments); })(4, 3, 2, 1);
+ equal(result, 4, 'works on an arguments object.');
+ result = _.map([[1,2,3],[1,2,3]], _.first);
+ equal(result.join(','), '1,1', 'works well with _.map');
+ result = (function() { return _.take([1,2,3], 2); })();
+ equal(result.join(','), '1,2', 'aliased as take');
+
+ equal(_.first(null), undefined, 'handles nulls');
+ });
+
+ test("rest", function() {
+ var numbers = [1, 2, 3, 4];
+ equal(_.rest(numbers).join(", "), "2, 3, 4", 'working rest()');
+ equal(_.rest(numbers, 0).join(", "), "1, 2, 3, 4", 'working rest(0)');
+ equal(_.rest(numbers, 2).join(', '), '3, 4', 'rest can take an index');
+ var result = (function(){ return _(arguments).tail(); })(1, 2, 3, 4);
+ equal(result.join(', '), '2, 3, 4', 'aliased as tail and works on arguments object');
+ result = _.map([[1,2,3],[1,2,3]], _.rest);
+ equal(_.flatten(result).join(','), '2,3,2,3', 'works well with _.map');
+ result = (function(){ return _(arguments).drop(); })(1, 2, 3, 4);
+ equal(result.join(', '), '2, 3, 4', 'aliased as drop and works on arguments object');
+ });
+
+ test("initial", function() {
+ equal(_.initial([1,2,3,4,5]).join(", "), "1, 2, 3, 4", 'working initial()');
+ equal(_.initial([1,2,3,4],2).join(", "), "1, 2", 'initial can take an index');
+ var result = (function(){ return _(arguments).initial(); })(1, 2, 3, 4);
+ equal(result.join(", "), "1, 2, 3", 'initial works on arguments object');
+ result = _.map([[1,2,3],[1,2,3]], _.initial);
+ equal(_.flatten(result).join(','), '1,2,1,2', 'initial works with _.map');
+ });
+
+ test("last", function() {
+ equal(_.last([1,2,3]), 3, 'can pull out the last element of an array');
+ equal(_.last([1,2,3], 0).join(', '), "", 'can pass an index to last');
+ equal(_.last([1,2,3], 2).join(', '), '2, 3', 'can pass an index to last');
+ equal(_.last([1,2,3], 5).join(', '), '1, 2, 3', 'can pass an index to last');
+ var result = (function(){ return _(arguments).last(); })(1, 2, 3, 4);
+ equal(result, 4, 'works on an arguments object');
+ result = _.map([[1,2,3],[1,2,3]], _.last);
+ equal(result.join(','), '3,3', 'works well with _.map');
+
+ equal(_.last(null), undefined, 'handles nulls');
+ });
+
+ test("compact", function() {
+ equal(_.compact([0, 1, false, 2, false, 3]).length, 3, 'can trim out all falsy values');
+ var result = (function(){ return _(arguments).compact().length; })(0, 1, false, 2, false, 3);
+ equal(result, 3, 'works on an arguments object');
+ });
+
+ test("flatten", function() {
+ if (window.JSON) {
+ var list = [1, [2], [3, [[[4]]]]];
+ equal(JSON.stringify(_.flatten(list)), '[1,2,3,4]', 'can flatten nested arrays');
+ equal(JSON.stringify(_.flatten(list, true)), '[1,2,3,[[[4]]]]', 'can shallowly flatten nested arrays');
+ var result = (function(){ return _.flatten(arguments); })(1, [2], [3, [[[4]]]]);
+ equal(JSON.stringify(result), '[1,2,3,4]', 'works on an arguments object');
+ }
+ });
+
+ test("without", function() {
+ var list = [1, 2, 1, 0, 3, 1, 4];
+ equal(_.without(list, 0, 1).join(', '), '2, 3, 4', 'can remove all instances of an object');
+ var result = (function(){ return _.without(arguments, 0, 1); })(1, 2, 1, 0, 3, 1, 4);
+ equal(result.join(', '), '2, 3, 4', 'works on an arguments object');
+
+ var list = [{one : 1}, {two : 2}];
+ ok(_.without(list, {one : 1}).length == 2, 'uses real object identity for comparisons.');
+ ok(_.without(list, list[0]).length == 1, 'ditto.');
+ });
+
+ test("uniq", function() {
+ var list = [1, 2, 1, 3, 1, 4];
+ equal(_.uniq(list).join(', '), '1, 2, 3, 4', 'can find the unique values of an unsorted array');
+
+ var list = [1, 1, 1, 2, 2, 3];
+ equal(_.uniq(list, true).join(', '), '1, 2, 3', 'can find the unique values of a sorted array faster');
+
+ var list = [{name:'moe'}, {name:'curly'}, {name:'larry'}, {name:'curly'}];
+ var iterator = function(value) { return value.name; };
+ equal(_.map(_.uniq(list, false, iterator), iterator).join(', '), 'moe, curly, larry', 'can find the unique values of an array using a custom iterator');
+
+ var iterator = function(value) { return value +1; };
+ var list = [1, 2, 2, 3, 4, 4];
+ equal(_.uniq(list, true, iterator).join(', '), '1, 2, 3, 4', 'iterator works with sorted array');
+
+ var result = (function(){ return _.uniq(arguments); })(1, 2, 1, 3, 1, 4);
+ equal(result.join(', '), '1, 2, 3, 4', 'works on an arguments object');
+ });
+
+ test("intersection", function() {
+ var stooges = ['moe', 'curly', 'larry'], leaders = ['moe', 'groucho'];
+ equal(_.intersection(stooges, leaders).join(''), 'moe', 'can take the set intersection of two arrays');
+ equal(_(stooges).intersection(leaders).join(''), 'moe', 'can perform an OO-style intersection');
+ var result = (function(){ return _.intersection(arguments, leaders); })('moe', 'curly', 'larry');
+ equal(result.join(''), 'moe', 'works on an arguments object');
+ });
+
+ test("union", function() {
+ var result = _.union([1, 2, 3], [2, 30, 1], [1, 40]);
+ equal(result.join(' '), '1 2 3 30 40', 'takes the union of a list of arrays');
+
+ var result = _.union([1, 2, 3], [2, 30, 1], [1, 40, [1]]);
+ equal(result.join(' '), '1 2 3 30 40 1', 'takes the union of a list of nested arrays');
+ });
+
+ test("difference", function() {
+ var result = _.difference([1, 2, 3], [2, 30, 40]);
+ equal(result.join(' '), '1 3', 'takes the difference of two arrays');
+
+ var result = _.difference([1, 2, 3, 4], [2, 30, 40], [1, 11, 111]);
+ equal(result.join(' '), '3 4', 'takes the difference of three arrays');
+ });
+
+ test('zip', function() {
+ var names = ['moe', 'larry', 'curly'], ages = [30, 40, 50], leaders = [true];
+ var stooges = _.zip(names, ages, leaders);
+ equal(String(stooges), 'moe,30,true,larry,40,,curly,50,', 'zipped together arrays of different lengths');
+ });
+
+ test('object', function() {
+ var result = _.object(['moe', 'larry', 'curly'], [30, 40, 50]);
+ var shouldBe = {moe: 30, larry: 40, curly: 50};
+ ok(_.isEqual(result, shouldBe), 'two arrays zipped together into an object');
+
+ result = _.object([['one', 1], ['two', 2], ['three', 3]]);
+ shouldBe = {one: 1, two: 2, three: 3};
+ ok(_.isEqual(result, shouldBe), 'an array of pairs zipped together into an object');
+
+ var stooges = {moe: 30, larry: 40, curly: 50};
+ ok(_.isEqual(_.object(_.pairs(stooges)), stooges), 'an object converted to pairs and back to an object');
+
+ ok(_.isEqual(_.object(null), {}), 'handles nulls');
+ });
+
+ test("indexOf", function() {
+ var numbers = [1, 2, 3];
+ numbers.indexOf = null;
+ equal(_.indexOf(numbers, 2), 1, 'can compute indexOf, even without the native function');
+ var result = (function(){ return _.indexOf(arguments, 2); })(1, 2, 3);
+ equal(result, 1, 'works on an arguments object');
+ equal(_.indexOf(null, 2), -1, 'handles nulls properly');
+
+ var numbers = [10, 20, 30, 40, 50], num = 35;
+ var index = _.indexOf(numbers, num, true);
+ equal(index, -1, '35 is not in the list');
+
+ numbers = [10, 20, 30, 40, 50]; num = 40;
+ index = _.indexOf(numbers, num, true);
+ equal(index, 3, '40 is in the list');
+
+ numbers = [1, 40, 40, 40, 40, 40, 40, 40, 50, 60, 70]; num = 40;
+ index = _.indexOf(numbers, num, true);
+ equal(index, 1, '40 is in the list');
+
+ numbers = [1, 2, 3, 1, 2, 3, 1, 2, 3];
+ index = _.indexOf(numbers, 2, 5);
+ equal(index, 7, 'supports the fromIndex argument');
+ });
+
+ test("lastIndexOf", function() {
+ var numbers = [1, 0, 1];
+ equal(_.lastIndexOf(numbers, 1), 2);
+
+ numbers = [1, 0, 1, 0, 0, 1, 0, 0, 0];
+ numbers.lastIndexOf = null;
+ equal(_.lastIndexOf(numbers, 1), 5, 'can compute lastIndexOf, even without the native function');
+ equal(_.lastIndexOf(numbers, 0), 8, 'lastIndexOf the other element');
+ var result = (function(){ return _.lastIndexOf(arguments, 1); })(1, 0, 1, 0, 0, 1, 0, 0, 0);
+ equal(result, 5, 'works on an arguments object');
+ equal(_.indexOf(null, 2), -1, 'handles nulls properly');
+
+ numbers = [1, 2, 3, 1, 2, 3, 1, 2, 3];
+ index = _.lastIndexOf(numbers, 2, 2);
+ equal(index, 1, 'supports the fromIndex argument');
+ });
+
+ test("range", function() {
+ equal(_.range(0).join(''), '', 'range with 0 as a first argument generates an empty array');
+ equal(_.range(4).join(' '), '0 1 2 3', 'range with a single positive argument generates an array of elements 0,1,2,...,n-1');
+ equal(_.range(5, 8).join(' '), '5 6 7', 'range with two arguments a & b, a<b generates an array of elements a,a+1,a+2,...,b-2,b-1');
+ equal(_.range(8, 5).join(''), '', 'range with two arguments a & b, b<a generates an empty array');
+ equal(_.range(3, 10, 3).join(' '), '3 6 9', 'range with three arguments a & b & c, c < b-a, a < b generates an array of elements a,a+c,a+2c,...,b - (multiplier of a) < c');
+ equal(_.range(3, 10, 15).join(''), '3', 'range with three arguments a & b & c, c > b-a, a < b generates an array with a single element, equal to a');
+ equal(_.range(12, 7, -2).join(' '), '12 10 8', 'range with three arguments a & b & c, a > b, c < 0 generates an array of elements a,a-c,a-2c and ends with the number not less than b');
+ equal(_.range(0, -10, -1).join(' '), '0 -1 -2 -3 -4 -5 -6 -7 -8 -9', 'final example in the Python docs');
+ });
+
+});
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/grunt-legacy-log/node_modules/underscore.string/test/test_underscore/chaining.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/grunt-legacy-log/node_modules/underscore.string/test/test_underscore/chaining.js
new file mode 100644
index 0000000..16cf7bf
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/grunt-legacy-log/node_modules/underscore.string/test/test_underscore/chaining.js
@@ -0,0 +1,59 @@
+$(document).ready(function() {
+
+ module("Chaining");
+
+ test("map/flatten/reduce", function() {
+ var lyrics = [
+ "I'm a lumberjack and I'm okay",
+ "I sleep all night and I work all day",
+ "He's a lumberjack and he's okay",
+ "He sleeps all night and he works all day"
+ ];
+ var counts = _(lyrics).chain()
+ .map(function(line) { return line.split(''); })
+ .flatten()
+ .reduce(function(hash, l) {
+ hash[l] = hash[l] || 0;
+ hash[l]++;
+ return hash;
+ }, {}).value();
+ ok(counts['a'] == 16 && counts['e'] == 10, 'counted all the letters in the song');
+ });
+
+ test("select/reject/sortBy", function() {
+ var numbers = [1,2,3,4,5,6,7,8,9,10];
+ numbers = _(numbers).chain().select(function(n) {
+ return n % 2 == 0;
+ }).reject(function(n) {
+ return n % 4 == 0;
+ }).sortBy(function(n) {
+ return -n;
+ }).value();
+ equal(numbers.join(', '), "10, 6, 2", "filtered and reversed the numbers");
+ });
+
+ test("select/reject/sortBy in functional style", function() {
+ var numbers = [1,2,3,4,5,6,7,8,9,10];
+ numbers = _.chain(numbers).select(function(n) {
+ return n % 2 == 0;
+ }).reject(function(n) {
+ return n % 4 == 0;
+ }).sortBy(function(n) {
+ return -n;
+ }).value();
+ equal(numbers.join(', '), "10, 6, 2", "filtered and reversed the numbers");
+ });
+
+ test("reverse/concat/unshift/pop/map", function() {
+ var numbers = [1,2,3,4,5];
+ numbers = _(numbers).chain()
+ .reverse()
+ .concat([5, 5, 5])
+ .unshift(17)
+ .pop()
+ .map(function(n){ return n * 2; })
+ .value();
+ equal(numbers.join(', '), "34, 10, 8, 6, 4, 2, 10, 10", 'can chain together array functions.');
+ });
+
+});
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/grunt-legacy-log/node_modules/underscore.string/test/test_underscore/collections.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/grunt-legacy-log/node_modules/underscore.string/test/test_underscore/collections.js
new file mode 100644
index 0000000..e089626
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/grunt-legacy-log/node_modules/underscore.string/test/test_underscore/collections.js
@@ -0,0 +1,426 @@
+$(document).ready(function() {
+
+ module("Collections");
+
+ test("each", function() {
+ _.each([1, 2, 3], function(num, i) {
+ equal(num, i + 1, 'each iterators provide value and iteration count');
+ });
+
+ var answers = [];
+ _.each([1, 2, 3], function(num){ answers.push(num * this.multiplier);}, {multiplier : 5});
+ equal(answers.join(', '), '5, 10, 15', 'context object property accessed');
+
+ answers = [];
+ _.forEach([1, 2, 3], function(num){ answers.push(num); });
+ equal(answers.join(', '), '1, 2, 3', 'aliased as "forEach"');
+
+ answers = [];
+ var obj = {one : 1, two : 2, three : 3};
+ obj.constructor.prototype.four = 4;
+ _.each(obj, function(value, key){ answers.push(key); });
+ equal(answers.join(", "), 'one, two, three', 'iterating over objects works, and ignores the object prototype.');
+ delete obj.constructor.prototype.four;
+
+ answer = null;
+ _.each([1, 2, 3], function(num, index, arr){ if (_.include(arr, num)) answer = true; });
+ ok(answer, 'can reference the original collection from inside the iterator');
+
+ answers = 0;
+ _.each(null, function(){ ++answers; });
+ equal(answers, 0, 'handles a null properly');
+ });
+
+ test('map', function() {
+ var doubled = _.map([1, 2, 3], function(num){ return num * 2; });
+ equal(doubled.join(', '), '2, 4, 6', 'doubled numbers');
+
+ doubled = _.collect([1, 2, 3], function(num){ return num * 2; });
+ equal(doubled.join(', '), '2, 4, 6', 'aliased as "collect"');
+
+ var tripled = _.map([1, 2, 3], function(num){ return num * this.multiplier; }, {multiplier : 3});
+ equal(tripled.join(', '), '3, 6, 9', 'tripled numbers with context');
+
+ var doubled = _([1, 2, 3]).map(function(num){ return num * 2; });
+ equal(doubled.join(', '), '2, 4, 6', 'OO-style doubled numbers');
+
+ if (document.querySelectorAll) {
+ var ids = _.map(document.querySelectorAll('#map-test *'), function(n){ return n.id; });
+ deepEqual(ids, ['id1', 'id2'], 'Can use collection methods on NodeLists.');
+ }
+
+ var ids = _.map($('#map-test').children(), function(n){ return n.id; });
+ deepEqual(ids, ['id1', 'id2'], 'Can use collection methods on jQuery Array-likes.');
+
+ var ids = _.map(document.images, function(n){ return n.id; });
+ ok(ids[0] == 'chart_image', 'can use collection methods on HTMLCollections');
+
+ var ifnull = _.map(null, function(){});
+ ok(_.isArray(ifnull) && ifnull.length === 0, 'handles a null properly');
+ });
+
+ test('reduce', function() {
+ var sum = _.reduce([1, 2, 3], function(sum, num){ return sum + num; }, 0);
+ equal(sum, 6, 'can sum up an array');
+
+ var context = {multiplier : 3};
+ sum = _.reduce([1, 2, 3], function(sum, num){ return sum + num * this.multiplier; }, 0, context);
+ equal(sum, 18, 'can reduce with a context object');
+
+ sum = _.inject([1, 2, 3], function(sum, num){ return sum + num; }, 0);
+ equal(sum, 6, 'aliased as "inject"');
+
+ sum = _([1, 2, 3]).reduce(function(sum, num){ return sum + num; }, 0);
+ equal(sum, 6, 'OO-style reduce');
+
+ var sum = _.reduce([1, 2, 3], function(sum, num){ return sum + num; });
+ equal(sum, 6, 'default initial value');
+
+ var ifnull;
+ try {
+ _.reduce(null, function(){});
+ } catch (ex) {
+ ifnull = ex;
+ }
+ ok(ifnull instanceof TypeError, 'handles a null (without inital value) properly');
+
+ ok(_.reduce(null, function(){}, 138) === 138, 'handles a null (with initial value) properly');
+ equal(_.reduce([], function(){}, undefined), undefined, 'undefined can be passed as a special case');
+ raises(function() { _.reduce([], function(){}); }, TypeError, 'throws an error for empty arrays with no initial value');
+ });
+
+ test('reduceRight', function() {
+ var list = _.reduceRight(["foo", "bar", "baz"], function(memo, str){ return memo + str; }, '');
+ equal(list, 'bazbarfoo', 'can perform right folds');
+
+ var list = _.foldr(["foo", "bar", "baz"], function(memo, str){ return memo + str; }, '');
+ equal(list, 'bazbarfoo', 'aliased as "foldr"');
+
+ var list = _.foldr(["foo", "bar", "baz"], function(memo, str){ return memo + str; });
+ equal(list, 'bazbarfoo', 'default initial value');
+
+ var ifnull;
+ try {
+ _.reduceRight(null, function(){});
+ } catch (ex) {
+ ifnull = ex;
+ }
+ ok(ifnull instanceof TypeError, 'handles a null (without inital value) properly');
+
+ var sum = _.reduceRight({a: 1, b: 2, c: 3}, function(sum, num){ return sum + num; });
+ equal(sum, 6, 'default initial value on object');
+
+ ok(_.reduceRight(null, function(){}, 138) === 138, 'handles a null (with initial value) properly');
+
+ equal(_.reduceRight([], function(){}, undefined), undefined, 'undefined can be passed as a special case');
+ raises(function() { _.reduceRight([], function(){}); }, TypeError, 'throws an error for empty arrays with no initial value');
+
+ // Assert that the correct arguments are being passed.
+
+ var args,
+ memo = {},
+ object = {a: 1, b: 2},
+ lastKey = _.keys(object).pop();
+
+ var expected = lastKey == 'a'
+ ? [memo, 1, 'a', object]
+ : [memo, 2, 'b', object];
+
+ _.reduceRight(object, function() {
+ args || (args = _.toArray(arguments));
+ }, memo);
+
+ deepEqual(args, expected);
+
+ // And again, with numeric keys.
+
+ object = {'2': 'a', '1': 'b'};
+ lastKey = _.keys(object).pop();
+ args = null;
+
+ expected = lastKey == '2'
+ ? [memo, 'a', '2', object]
+ : [memo, 'b', '1', object];
+
+ _.reduceRight(object, function() {
+ args || (args = _.toArray(arguments));
+ }, memo);
+
+ deepEqual(args, expected);
+ });
+
+ test('find', function() {
+ var array = [1, 2, 3, 4];
+ strictEqual(_.find(array, function(n) { return n > 2; }), 3, 'should return first found `value`');
+ strictEqual(_.find(array, function() { return false; }), void 0, 'should return `undefined` if `value` is not found');
+ });
+
+ test('detect', function() {
+ var result = _.detect([1, 2, 3], function(num){ return num * 2 == 4; });
+ equal(result, 2, 'found the first "2" and broke the loop');
+ });
+
+ test('select', function() {
+ var evens = _.select([1, 2, 3, 4, 5, 6], function(num){ return num % 2 == 0; });
+ equal(evens.join(', '), '2, 4, 6', 'selected each even number');
+
+ evens = _.filter([1, 2, 3, 4, 5, 6], function(num){ return num % 2 == 0; });
+ equal(evens.join(', '), '2, 4, 6', 'aliased as "filter"');
+ });
+
+ test('reject', function() {
+ var odds = _.reject([1, 2, 3, 4, 5, 6], function(num){ return num % 2 == 0; });
+ equal(odds.join(', '), '1, 3, 5', 'rejected each even number');
+
+ var context = "obj";
+
+ var evens = _.reject([1, 2, 3, 4, 5, 6], function(num){
+ equal(context, "obj");
+ return num % 2 != 0;
+ }, context);
+ equal(evens.join(', '), '2, 4, 6', 'rejected each odd number');
+ });
+
+ test('all', function() {
+ ok(_.all([], _.identity), 'the empty set');
+ ok(_.all([true, true, true], _.identity), 'all true values');
+ ok(!_.all([true, false, true], _.identity), 'one false value');
+ ok(_.all([0, 10, 28], function(num){ return num % 2 == 0; }), 'even numbers');
+ ok(!_.all([0, 11, 28], function(num){ return num % 2 == 0; }), 'an odd number');
+ ok(_.all([1], _.identity) === true, 'cast to boolean - true');
+ ok(_.all([0], _.identity) === false, 'cast to boolean - false');
+ ok(_.every([true, true, true], _.identity), 'aliased as "every"');
+ ok(!_.all([undefined, undefined, undefined], _.identity), 'works with arrays of undefined');
+ });
+
+ test('any', function() {
+ var nativeSome = Array.prototype.some;
+ Array.prototype.some = null;
+ ok(!_.any([]), 'the empty set');
+ ok(!_.any([false, false, false]), 'all false values');
+ ok(_.any([false, false, true]), 'one true value');
+ ok(_.any([null, 0, 'yes', false]), 'a string');
+ ok(!_.any([null, 0, '', false]), 'falsy values');
+ ok(!_.any([1, 11, 29], function(num){ return num % 2 == 0; }), 'all odd numbers');
+ ok(_.any([1, 10, 29], function(num){ return num % 2 == 0; }), 'an even number');
+ ok(_.any([1], _.identity) === true, 'cast to boolean - true');
+ ok(_.any([0], _.identity) === false, 'cast to boolean - false');
+ ok(_.some([false, false, true]), 'aliased as "some"');
+ Array.prototype.some = nativeSome;
+ });
+
+ test('include', function() {
+ ok(_.include([1,2,3], 2), 'two is in the array');
+ ok(!_.include([1,3,9], 2), 'two is not in the array');
+ ok(_.contains({moe:1, larry:3, curly:9}, 3) === true, '_.include on objects checks their values');
+ ok(_([1,2,3]).include(2), 'OO-style include');
+ });
+
+ test('invoke', function() {
+ var list = [[5, 1, 7], [3, 2, 1]];
+ var result = _.invoke(list, 'sort');
+ equal(result[0].join(', '), '1, 5, 7', 'first array sorted');
+ equal(result[1].join(', '), '1, 2, 3', 'second array sorted');
+ });
+
+ test('invoke w/ function reference', function() {
+ var list = [[5, 1, 7], [3, 2, 1]];
+ var result = _.invoke(list, Array.prototype.sort);
+ equal(result[0].join(', '), '1, 5, 7', 'first array sorted');
+ equal(result[1].join(', '), '1, 2, 3', 'second array sorted');
+ });
+
+ // Relevant when using ClojureScript
+ test('invoke when strings have a call method', function() {
+ String.prototype.call = function() {
+ return 42;
+ };
+ var list = [[5, 1, 7], [3, 2, 1]];
+ var s = "foo";
+ equal(s.call(), 42, "call function exists");
+ var result = _.invoke(list, 'sort');
+ equal(result[0].join(', '), '1, 5, 7', 'first array sorted');
+ equal(result[1].join(', '), '1, 2, 3', 'second array sorted');
+ delete String.prototype.call;
+ equal(s.call, undefined, "call function removed");
+ });
+
+ test('pluck', function() {
+ var people = [{name : 'moe', age : 30}, {name : 'curly', age : 50}];
+ equal(_.pluck(people, 'name').join(', '), 'moe, curly', 'pulls names out of objects');
+ });
+
+ test('where', function() {
+ var list = [{a: 1, b: 2}, {a: 2, b: 2}, {a: 1, b: 3}, {a: 1, b: 4}];
+ var result = _.where(list, {a: 1});
+ equal(result.length, 3);
+ equal(result[result.length - 1].b, 4);
+ result = _.where(list, {b: 2});
+ equal(result.length, 2);
+ equal(result[0].a, 1);
+ });
+
+ test('max', function() {
+ equal(3, _.max([1, 2, 3]), 'can perform a regular Math.max');
+
+ var neg = _.max([1, 2, 3], function(num){ return -num; });
+ equal(neg, 1, 'can perform a computation-based max');
+
+ equal(-Infinity, _.max({}), 'Maximum value of an empty object');
+ equal(-Infinity, _.max([]), 'Maximum value of an empty array');
+
+ equal(299999, _.max(_.range(1,300000)), "Maximum value of a too-big array");
+ });
+
+ test('min', function() {
+ equal(1, _.min([1, 2, 3]), 'can perform a regular Math.min');
+
+ var neg = _.min([1, 2, 3], function(num){ return -num; });
+ equal(neg, 3, 'can perform a computation-based min');
+
+ equal(Infinity, _.min({}), 'Minimum value of an empty object');
+ equal(Infinity, _.min([]), 'Minimum value of an empty array');
+
+ var now = new Date(9999999999);
+ var then = new Date(0);
+ equal(_.min([now, then]), then);
+
+ equal(1, _.min(_.range(1,300000)), "Minimum value of a too-big array");
+ });
+
+ test('sortBy', function() {
+ var people = [{name : 'curly', age : 50}, {name : 'moe', age : 30}];
+ people = _.sortBy(people, function(person){ return person.age; });
+ equal(_.pluck(people, 'name').join(', '), 'moe, curly', 'stooges sorted by age');
+
+ var list = [undefined, 4, 1, undefined, 3, 2];
+ equal(_.sortBy(list, _.identity).join(','), '1,2,3,4,,', 'sortBy with undefined values');
+
+ var list = ["one", "two", "three", "four", "five"];
+ var sorted = _.sortBy(list, 'length');
+ equal(sorted.join(' '), 'one two four five three', 'sorted by length');
+
+ function Pair(x, y) {
+ this.x = x;
+ this.y = y;
+ }
+
+ var collection = [
+ new Pair(1, 1), new Pair(1, 2),
+ new Pair(1, 3), new Pair(1, 4),
+ new Pair(1, 5), new Pair(1, 6),
+ new Pair(2, 1), new Pair(2, 2),
+ new Pair(2, 3), new Pair(2, 4),
+ new Pair(2, 5), new Pair(2, 6),
+ new Pair(undefined, 1), new Pair(undefined, 2),
+ new Pair(undefined, 3), new Pair(undefined, 4),
+ new Pair(undefined, 5), new Pair(undefined, 6)
+ ];
+
+ var actual = _.sortBy(collection, function(pair) {
+ return pair.x;
+ });
+
+ deepEqual(actual, collection, 'sortBy should be stable');
+ });
+
+ test('groupBy', function() {
+ var parity = _.groupBy([1, 2, 3, 4, 5, 6], function(num){ return num % 2; });
+ ok('0' in parity && '1' in parity, 'created a group for each value');
+ equal(parity[0].join(', '), '2, 4, 6', 'put each even number in the right group');
+
+ var list = ["one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten"];
+ var grouped = _.groupBy(list, 'length');
+ equal(grouped['3'].join(' '), 'one two six ten');
+ equal(grouped['4'].join(' '), 'four five nine');
+ equal(grouped['5'].join(' '), 'three seven eight');
+
+ var context = {};
+ _.groupBy([{}], function(){ ok(this === context); }, context);
+
+ grouped = _.groupBy([4.2, 6.1, 6.4], function(num) {
+ return Math.floor(num) > 4 ? 'hasOwnProperty' : 'constructor';
+ });
+ equal(grouped.constructor.length, 1);
+ equal(grouped.hasOwnProperty.length, 2);
+
+ var array = [{}];
+ _.groupBy(array, function(value, index, obj){ ok(obj === array); });
+ });
+
+ test('countBy', function() {
+ var parity = _.countBy([1, 2, 3, 4, 5], function(num){ return num % 2 == 0; });
+ equal(parity['true'], 2);
+ equal(parity['false'], 3);
+
+ var list = ["one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten"];
+ var grouped = _.countBy(list, 'length');
+ equal(grouped['3'], 4);
+ equal(grouped['4'], 3);
+ equal(grouped['5'], 3);
+
+ var context = {};
+ _.countBy([{}], function(){ ok(this === context); }, context);
+
+ grouped = _.countBy([4.2, 6.1, 6.4], function(num) {
+ return Math.floor(num) > 4 ? 'hasOwnProperty' : 'constructor';
+ });
+ equal(grouped.constructor, 1);
+ equal(grouped.hasOwnProperty, 2);
+
+ var array = [{}];
+ _.countBy(array, function(value, index, obj){ ok(obj === array); });
+ });
+
+ test('sortedIndex', function() {
+ var numbers = [10, 20, 30, 40, 50], num = 35;
+ var indexForNum = _.sortedIndex(numbers, num);
+ equal(indexForNum, 3, '35 should be inserted at index 3');
+
+ var indexFor30 = _.sortedIndex(numbers, 30);
+ equal(indexFor30, 2, '30 should be inserted at index 2');
+
+ var objects = [{x: 10}, {x: 20}, {x: 30}, {x: 40}];
+ var iterator = function(obj){ return obj.x; };
+ strictEqual(_.sortedIndex(objects, {x: 25}, iterator), 2);
+ strictEqual(_.sortedIndex(objects, {x: 35}, 'x'), 3);
+
+ var context = {1: 2, 2: 3, 3: 4};
+ iterator = function(obj){ return this[obj]; };
+ strictEqual(_.sortedIndex([1, 3], 2, iterator, context), 1);
+ });
+
+ test('shuffle', function() {
+ var numbers = _.range(10);
+ var shuffled = _.shuffle(numbers).sort();
+ notStrictEqual(numbers, shuffled, 'original object is unmodified');
+ equal(shuffled.join(','), numbers.join(','), 'contains the same members before and after shuffle');
+ });
+
+ test('toArray', function() {
+ ok(!_.isArray(arguments), 'arguments object is not an array');
+ ok(_.isArray(_.toArray(arguments)), 'arguments object converted into array');
+ var a = [1,2,3];
+ ok(_.toArray(a) !== a, 'array is cloned');
+ equal(_.toArray(a).join(', '), '1, 2, 3', 'cloned array contains same elements');
+
+ var numbers = _.toArray({one : 1, two : 2, three : 3});
+ equal(numbers.join(', '), '1, 2, 3', 'object flattened into array');
+ });
+
+ test('size', function() {
+ equal(_.size({one : 1, two : 2, three : 3}), 3, 'can compute the size of an object');
+ equal(_.size([1, 2, 3]), 3, 'can compute the size of an array');
+
+ var func = function() {
+ return _.size(arguments);
+ };
+
+ equal(func(1, 2, 3, 4), 4, 'can test the size of the arguments object');
+
+ equal(_.size('hello'), 5, 'can compute the size of a string');
+
+ equal(_.size(null), 0, 'handles nulls');
+ });
+
+});
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/grunt-legacy-log/node_modules/underscore.string/test/test_underscore/functions.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/grunt-legacy-log/node_modules/underscore.string/test/test_underscore/functions.js
new file mode 100644
index 0000000..a529658
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/grunt-legacy-log/node_modules/underscore.string/test/test_underscore/functions.js
@@ -0,0 +1,259 @@
+$(document).ready(function() {
+
+ module("Functions");
+
+ test("bind", function() {
+ var context = {name : 'moe'};
+ var func = function(arg) { return "name: " + (this.name || arg); };
+ var bound = _.bind(func, context);
+ equal(bound(), 'name: moe', 'can bind a function to a context');
+
+ bound = _(func).bind(context);
+ equal(bound(), 'name: moe', 'can do OO-style binding');
+
+ bound = _.bind(func, null, 'curly');
+ equal(bound(), 'name: curly', 'can bind without specifying a context');
+
+ func = function(salutation, name) { return salutation + ': ' + name; };
+ func = _.bind(func, this, 'hello');
+ equal(func('moe'), 'hello: moe', 'the function was partially applied in advance');
+
+ var func = _.bind(func, this, 'curly');
+ equal(func(), 'hello: curly', 'the function was completely applied in advance');
+
+ var func = function(salutation, firstname, lastname) { return salutation + ': ' + firstname + ' ' + lastname; };
+ func = _.bind(func, this, 'hello', 'moe', 'curly');
+ equal(func(), 'hello: moe curly', 'the function was partially applied in advance and can accept multiple arguments');
+
+ func = function(context, message) { equal(this, context, message); };
+ _.bind(func, 0, 0, 'can bind a function to `0`')();
+ _.bind(func, '', '', 'can bind a function to an empty string')();
+ _.bind(func, false, false, 'can bind a function to `false`')();
+
+ // These tests are only meaningful when using a browser without a native bind function
+ // To test this with a modern browser, set underscore's nativeBind to undefined
+ var F = function () { return this; };
+ var Boundf = _.bind(F, {hello: "moe curly"});
+ equal(new Boundf().hello, undefined, "function should not be bound to the context, to comply with ECMAScript 5");
+ equal(Boundf().hello, "moe curly", "When called without the new operator, it's OK to be bound to the context");
+ });
+
+ test("bindAll", function() {
+ var curly = {name : 'curly'}, moe = {
+ name : 'moe',
+ getName : function() { return 'name: ' + this.name; },
+ sayHi : function() { return 'hi: ' + this.name; }
+ };
+ curly.getName = moe.getName;
+ _.bindAll(moe, 'getName', 'sayHi');
+ curly.sayHi = moe.sayHi;
+ equal(curly.getName(), 'name: curly', 'unbound function is bound to current object');
+ equal(curly.sayHi(), 'hi: moe', 'bound function is still bound to original object');
+
+ curly = {name : 'curly'};
+ moe = {
+ name : 'moe',
+ getName : function() { return 'name: ' + this.name; },
+ sayHi : function() { return 'hi: ' + this.name; }
+ };
+ _.bindAll(moe);
+ curly.sayHi = moe.sayHi;
+ equal(curly.sayHi(), 'hi: moe', 'calling bindAll with no arguments binds all functions to the object');
+ });
+
+ test("memoize", function() {
+ var fib = function(n) {
+ return n < 2 ? n : fib(n - 1) + fib(n - 2);
+ };
+ var fastFib = _.memoize(fib);
+ equal(fib(10), 55, 'a memoized version of fibonacci produces identical results');
+ equal(fastFib(10), 55, 'a memoized version of fibonacci produces identical results');
+
+ var o = function(str) {
+ return str;
+ };
+ var fastO = _.memoize(o);
+ equal(o('toString'), 'toString', 'checks hasOwnProperty');
+ equal(fastO('toString'), 'toString', 'checks hasOwnProperty');
+ });
+
+ asyncTest("delay", 2, function() {
+ var delayed = false;
+ _.delay(function(){ delayed = true; }, 100);
+ setTimeout(function(){ ok(!delayed, "didn't delay the function quite yet"); }, 50);
+ setTimeout(function(){ ok(delayed, 'delayed the function'); start(); }, 150);
+ });
+
+ asyncTest("defer", 1, function() {
+ var deferred = false;
+ _.defer(function(bool){ deferred = bool; }, true);
+ _.delay(function(){ ok(deferred, "deferred the function"); start(); }, 50);
+ });
+
+ asyncTest("throttle", 2, function() {
+ var counter = 0;
+ var incr = function(){ counter++; };
+ var throttledIncr = _.throttle(incr, 100);
+ throttledIncr(); throttledIncr(); throttledIncr();
+ setTimeout(throttledIncr, 70);
+ setTimeout(throttledIncr, 120);
+ setTimeout(throttledIncr, 140);
+ setTimeout(throttledIncr, 190);
+ setTimeout(throttledIncr, 220);
+ setTimeout(throttledIncr, 240);
+ _.delay(function(){ equal(counter, 1, "incr was called immediately"); }, 30);
+ _.delay(function(){ equal(counter, 4, "incr was throttled"); start(); }, 400);
+ });
+
+ asyncTest("throttle arguments", 2, function() {
+ var value = 0;
+ var update = function(val){ value = val; };
+ var throttledUpdate = _.throttle(update, 100);
+ throttledUpdate(1); throttledUpdate(2); throttledUpdate(3);
+ setTimeout(function(){ throttledUpdate(4); }, 120);
+ setTimeout(function(){ throttledUpdate(5); }, 140);
+ setTimeout(function(){ throttledUpdate(6); }, 250);
+ _.delay(function(){ equal(value, 1, "updated to latest value"); }, 40);
+ _.delay(function(){ equal(value, 6, "updated to latest value"); start(); }, 400);
+ });
+
+ asyncTest("throttle once", 2, function() {
+ var counter = 0;
+ var incr = function(){ return ++counter; };
+ var throttledIncr = _.throttle(incr, 100);
+ var result = throttledIncr();
+ _.delay(function(){
+ equal(result, 1, "throttled functions return their value");
+ equal(counter, 1, "incr was called once"); start();
+ }, 220);
+ });
+
+ asyncTest("throttle twice", 1, function() {
+ var counter = 0;
+ var incr = function(){ counter++; };
+ var throttledIncr = _.throttle(incr, 100);
+ throttledIncr(); throttledIncr();
+ _.delay(function(){ equal(counter, 2, "incr was called twice"); start(); }, 220);
+ });
+
+ asyncTest("throttle repeatedly with results", 9, function() {
+ var counter = 0;
+ var incr = function(){ return ++counter; };
+ var throttledIncr = _.throttle(incr, 100);
+ var results = [];
+ var saveResult = function() { results.push(throttledIncr()); };
+ saveResult(); saveResult(); saveResult();
+ setTimeout(saveResult, 70);
+ setTimeout(saveResult, 120);
+ setTimeout(saveResult, 140);
+ setTimeout(saveResult, 190);
+ setTimeout(saveResult, 240);
+ setTimeout(saveResult, 260);
+ _.delay(function() {
+ equal(results[0], 1, "incr was called once");
+ equal(results[1], 1, "incr was throttled");
+ equal(results[2], 1, "incr was throttled");
+ equal(results[3], 1, "incr was throttled");
+ equal(results[4], 2, "incr was called twice");
+ equal(results[5], 2, "incr was throttled");
+ equal(results[6], 2, "incr was throttled");
+ equal(results[7], 3, "incr was called thrice");
+ equal(results[8], 3, "incr was throttled");
+ start();
+ }, 400);
+ });
+
+ asyncTest("debounce", 1, function() {
+ var counter = 0;
+ var incr = function(){ counter++; };
+ var debouncedIncr = _.debounce(incr, 50);
+ debouncedIncr(); debouncedIncr(); debouncedIncr();
+ setTimeout(debouncedIncr, 30);
+ setTimeout(debouncedIncr, 60);
+ setTimeout(debouncedIncr, 90);
+ setTimeout(debouncedIncr, 120);
+ setTimeout(debouncedIncr, 150);
+ _.delay(function(){ equal(counter, 1, "incr was debounced"); start(); }, 220);
+ });
+
+ asyncTest("debounce asap", 5, function() {
+ var a, b, c;
+ var counter = 0;
+ var incr = function(){ return ++counter; };
+ var debouncedIncr = _.debounce(incr, 50, true);
+ a = debouncedIncr();
+ b = debouncedIncr();
+ c = debouncedIncr();
+ equal(a, 1);
+ equal(b, 1);
+ equal(c, 1);
+ equal(counter, 1, 'incr was called immediately');
+ setTimeout(debouncedIncr, 30);
+ setTimeout(debouncedIncr, 60);
+ setTimeout(debouncedIncr, 90);
+ setTimeout(debouncedIncr, 120);
+ setTimeout(debouncedIncr, 150);
+ _.delay(function(){ equal(counter, 1, "incr was debounced"); start(); }, 220);
+ });
+
+ asyncTest("debounce asap recursively", 2, function() {
+ var counter = 0;
+ var debouncedIncr = _.debounce(function(){
+ counter++;
+ if (counter < 5) debouncedIncr();
+ }, 50, true);
+ debouncedIncr();
+ equal(counter, 1, 'incr was called immediately');
+ _.delay(function(){ equal(counter, 1, "incr was debounced"); start(); }, 70);
+ });
+
+ test("once", function() {
+ var num = 0;
+ var increment = _.once(function(){ num++; });
+ increment();
+ increment();
+ equal(num, 1);
+ });
+
+ test("wrap", function() {
+ var greet = function(name){ return "hi: " + name; };
+ var backwards = _.wrap(greet, function(func, name){ return func(name) + ' ' + name.split('').reverse().join(''); });
+ equal(backwards('moe'), 'hi: moe eom', 'wrapped the saluation function');
+
+ var inner = function(){ return "Hello "; };
+ var obj = {name : "Moe"};
+ obj.hi = _.wrap(inner, function(fn){ return fn() + this.name; });
+ equal(obj.hi(), "Hello Moe");
+
+ var noop = function(){};
+ var wrapped = _.wrap(noop, function(fn){ return Array.prototype.slice.call(arguments, 0); });
+ var ret = wrapped(['whats', 'your'], 'vector', 'victor');
+ deepEqual(ret, [noop, ['whats', 'your'], 'vector', 'victor']);
+ });
+
+ test("compose", function() {
+ var greet = function(name){ return "hi: " + name; };
+ var exclaim = function(sentence){ return sentence + '!'; };
+ var composed = _.compose(exclaim, greet);
+ equal(composed('moe'), 'hi: moe!', 'can compose a function that takes another');
+
+ composed = _.compose(greet, exclaim);
+ equal(composed('moe'), 'hi: moe!', 'in this case, the functions are also commutative');
+ });
+
+ test("after", function() {
+ var testAfter = function(afterAmount, timesCalled) {
+ var afterCalled = 0;
+ var after = _.after(afterAmount, function() {
+ afterCalled++;
+ });
+ while (timesCalled--) after();
+ return afterCalled;
+ };
+
+ equal(testAfter(5, 5), 1, "after(N) should fire after being called N times");
+ equal(testAfter(5, 4), 0, "after(N) should not fire unless called N times");
+ equal(testAfter(0, 0), 1, "after(0) should fire immediately");
+ });
+
+});
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/grunt-legacy-log/node_modules/underscore.string/test/test_underscore/index.html b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/grunt-legacy-log/node_modules/underscore.string/test/test_underscore/index.html
new file mode 100644
index 0000000..064fa98
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/grunt-legacy-log/node_modules/underscore.string/test/test_underscore/index.html
@@ -0,0 +1,45 @@
+
+
+
+ Underscore Test Suite
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A representative sample of the functions are benchmarked here, to provide
+ a sense of how fast they might run in different browsers.
+ Each iteration runs on an array of 1000 elements.
+ For example, the 'intersection' test measures the number of times you can
+ find the intersection of two thousand-element arrays in one second.
+
+
+
+
+
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/grunt-legacy-log/node_modules/underscore.string/test/test_underscore/objects.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/grunt-legacy-log/node_modules/underscore.string/test/test_underscore/objects.js
new file mode 100644
index 0000000..22949c3
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/grunt-legacy-log/node_modules/underscore.string/test/test_underscore/objects.js
@@ -0,0 +1,548 @@
+$(document).ready(function() {
+
+ module("Objects");
+
+ test("keys", function() {
+ equal(_.keys({one : 1, two : 2}).join(', '), 'one, two', 'can extract the keys from an object');
+ // the test above is not safe because it relies on for-in enumeration order
+ var a = []; a[1] = 0;
+ equal(_.keys(a).join(', '), '1', 'is not fooled by sparse arrays; see issue #95');
+ raises(function() { _.keys(null); }, TypeError, 'throws an error for `null` values');
+ raises(function() { _.keys(void 0); }, TypeError, 'throws an error for `undefined` values');
+ raises(function() { _.keys(1); }, TypeError, 'throws an error for number primitives');
+ raises(function() { _.keys('a'); }, TypeError, 'throws an error for string primitives');
+ raises(function() { _.keys(true); }, TypeError, 'throws an error for boolean primitives');
+ });
+
+ test("values", function() {
+ equal(_.values({one: 1, two: 2}).join(', '), '1, 2', 'can extract the values from an object');
+ equal(_.values({one: 1, two: 2, length: 3}).join(', '), '1, 2, 3', '... even when one of them is "length"');
+ });
+
+ test("pairs", function() {
+ deepEqual(_.pairs({one: 1, two: 2}), [['one', 1], ['two', 2]], 'can convert an object into pairs');
+ deepEqual(_.pairs({one: 1, two: 2, length: 3}), [['one', 1], ['two', 2], ['length', 3]], '... even when one of them is "length"');
+ });
+
+ test("invert", function() {
+ var obj = {first: 'Moe', second: 'Larry', third: 'Curly'};
+ equal(_.keys(_.invert(obj)).join(' '), 'Moe Larry Curly', 'can invert an object');
+ ok(_.isEqual(_.invert(_.invert(obj)), obj), 'two inverts gets you back where you started');
+
+ var obj = {length: 3};
+ ok(_.invert(obj)['3'] == 'length', 'can invert an object with "length"')
+ });
+
+ test("functions", function() {
+ var obj = {a : 'dash', b : _.map, c : (/yo/), d : _.reduce};
+ ok(_.isEqual(['b', 'd'], _.functions(obj)), 'can grab the function names of any passed-in object');
+
+ var Animal = function(){};
+ Animal.prototype.run = function(){};
+ equal(_.functions(new Animal).join(''), 'run', 'also looks up functions on the prototype');
+ });
+
+ test("extend", function() {
+ var result;
+ equal(_.extend({}, {a:'b'}).a, 'b', 'can extend an object with the attributes of another');
+ equal(_.extend({a:'x'}, {a:'b'}).a, 'b', 'properties in source override destination');
+ equal(_.extend({x:'x'}, {a:'b'}).x, 'x', 'properties not in source dont get overriden');
+ result = _.extend({x:'x'}, {a:'a'}, {b:'b'});
+ ok(_.isEqual(result, {x:'x', a:'a', b:'b'}), 'can extend from multiple source objects');
+ result = _.extend({x:'x'}, {a:'a', x:2}, {a:'b'});
+ ok(_.isEqual(result, {x:2, a:'b'}), 'extending from multiple source objects last property trumps');
+ result = _.extend({}, {a: void 0, b: null});
+ equal(_.keys(result).join(''), 'ab', 'extend does not copy undefined values');
+ });
+
+ test("pick", function() {
+ var result;
+ result = _.pick({a:1, b:2, c:3}, 'a', 'c');
+ ok(_.isEqual(result, {a:1, c:3}), 'can restrict properties to those named');
+ result = _.pick({a:1, b:2, c:3}, ['b', 'c']);
+ ok(_.isEqual(result, {b:2, c:3}), 'can restrict properties to those named in an array');
+ result = _.pick({a:1, b:2, c:3}, ['a'], 'b');
+ ok(_.isEqual(result, {a:1, b:2}), 'can restrict properties to those named in mixed args');
+
+ var Obj = function(){};
+ Obj.prototype = {a: 1, b: 2, c: 3};
+ ok(_.isEqual(_.pick(new Obj, 'a', 'c'), {a:1, c: 3}), 'include prototype props');
+ });
+
+ test("omit", function() {
+ var result;
+ result = _.omit({a:1, b:2, c:3}, 'b');
+ ok(_.isEqual(result, {a:1, c:3}), 'can omit a single named property');
+ result = _.omit({a:1, b:2, c:3}, 'a', 'c');
+ ok(_.isEqual(result, {b:2}), 'can omit several named properties');
+ result = _.omit({a:1, b:2, c:3}, ['b', 'c']);
+ ok(_.isEqual(result, {a:1}), 'can omit properties named in an array');
+
+ var Obj = function(){};
+ Obj.prototype = {a: 1, b: 2, c: 3};
+ ok(_.isEqual(_.omit(new Obj, 'b'), {a:1, c: 3}), 'include prototype props');
+ });
+
+ test("defaults", function() {
+ var result;
+ var options = {zero: 0, one: 1, empty: "", nan: NaN, string: "string"};
+
+ _.defaults(options, {zero: 1, one: 10, twenty: 20});
+ equal(options.zero, 0, 'value exists');
+ equal(options.one, 1, 'value exists');
+ equal(options.twenty, 20, 'default applied');
+
+ _.defaults(options, {empty: "full"}, {nan: "nan"}, {word: "word"}, {word: "dog"});
+ equal(options.empty, "", 'value exists');
+ ok(_.isNaN(options.nan), "NaN isn't overridden");
+ equal(options.word, "word", 'new value is added, first one wins');
+ });
+
+ test("clone", function() {
+ var moe = {name : 'moe', lucky : [13, 27, 34]};
+ var clone = _.clone(moe);
+ equal(clone.name, 'moe', 'the clone as the attributes of the original');
+
+ clone.name = 'curly';
+ ok(clone.name == 'curly' && moe.name == 'moe', 'clones can change shallow attributes without affecting the original');
+
+ clone.lucky.push(101);
+ equal(_.last(moe.lucky), 101, 'changes to deep attributes are shared with the original');
+
+ equal(_.clone(undefined), void 0, 'non objects should not be changed by clone');
+ equal(_.clone(1), 1, 'non objects should not be changed by clone');
+ equal(_.clone(null), null, 'non objects should not be changed by clone');
+ });
+
+ test("isEqual", function() {
+ function First() {
+ this.value = 1;
+ }
+ First.prototype.value = 1;
+ function Second() {
+ this.value = 1;
+ }
+ Second.prototype.value = 2;
+
+ // Basic equality and identity comparisons.
+ ok(_.isEqual(null, null), "`null` is equal to `null`");
+ ok(_.isEqual(), "`undefined` is equal to `undefined`");
+
+ ok(!_.isEqual(0, -0), "`0` is not equal to `-0`");
+ ok(!_.isEqual(-0, 0), "Commutative equality is implemented for `0` and `-0`");
+ ok(!_.isEqual(null, undefined), "`null` is not equal to `undefined`");
+ ok(!_.isEqual(undefined, null), "Commutative equality is implemented for `null` and `undefined`");
+
+ // String object and primitive comparisons.
+ ok(_.isEqual("Curly", "Curly"), "Identical string primitives are equal");
+ ok(_.isEqual(new String("Curly"), new String("Curly")), "String objects with identical primitive values are equal");
+ ok(_.isEqual(new String("Curly"), "Curly"), "String primitives and their corresponding object wrappers are equal");
+ ok(_.isEqual("Curly", new String("Curly")), "Commutative equality is implemented for string objects and primitives");
+
+ ok(!_.isEqual("Curly", "Larry"), "String primitives with different values are not equal");
+ ok(!_.isEqual(new String("Curly"), new String("Larry")), "String objects with different primitive values are not equal");
+ ok(!_.isEqual(new String("Curly"), {toString: function(){ return "Curly"; }}), "String objects and objects with a custom `toString` method are not equal");
+
+ // Number object and primitive comparisons.
+ ok(_.isEqual(75, 75), "Identical number primitives are equal");
+ ok(_.isEqual(new Number(75), new Number(75)), "Number objects with identical primitive values are equal");
+ ok(_.isEqual(75, new Number(75)), "Number primitives and their corresponding object wrappers are equal");
+ ok(_.isEqual(new Number(75), 75), "Commutative equality is implemented for number objects and primitives");
+ ok(!_.isEqual(new Number(0), -0), "`new Number(0)` and `-0` are not equal");
+ ok(!_.isEqual(0, new Number(-0)), "Commutative equality is implemented for `new Number(0)` and `-0`");
+
+ ok(!_.isEqual(new Number(75), new Number(63)), "Number objects with different primitive values are not equal");
+ ok(!_.isEqual(new Number(63), {valueOf: function(){ return 63; }}), "Number objects and objects with a `valueOf` method are not equal");
+
+ // Comparisons involving `NaN`.
+ ok(_.isEqual(NaN, NaN), "`NaN` is equal to `NaN`");
+ ok(!_.isEqual(61, NaN), "A number primitive is not equal to `NaN`");
+ ok(!_.isEqual(new Number(79), NaN), "A number object is not equal to `NaN`");
+ ok(!_.isEqual(Infinity, NaN), "`Infinity` is not equal to `NaN`");
+
+ // Boolean object and primitive comparisons.
+ ok(_.isEqual(true, true), "Identical boolean primitives are equal");
+ ok(_.isEqual(new Boolean, new Boolean), "Boolean objects with identical primitive values are equal");
+ ok(_.isEqual(true, new Boolean(true)), "Boolean primitives and their corresponding object wrappers are equal");
+ ok(_.isEqual(new Boolean(true), true), "Commutative equality is implemented for booleans");
+ ok(!_.isEqual(new Boolean(true), new Boolean), "Boolean objects with different primitive values are not equal");
+
+ // Common type coercions.
+ ok(!_.isEqual(true, new Boolean(false)), "Boolean objects are not equal to the boolean primitive `true`");
+ ok(!_.isEqual("75", 75), "String and number primitives with like values are not equal");
+ ok(!_.isEqual(new Number(63), new String(63)), "String and number objects with like values are not equal");
+ ok(!_.isEqual(75, "75"), "Commutative equality is implemented for like string and number values");
+ ok(!_.isEqual(0, ""), "Number and string primitives with like values are not equal");
+ ok(!_.isEqual(1, true), "Number and boolean primitives with like values are not equal");
+ ok(!_.isEqual(new Boolean(false), new Number(0)), "Boolean and number objects with like values are not equal");
+ ok(!_.isEqual(false, new String("")), "Boolean primitives and string objects with like values are not equal");
+ ok(!_.isEqual(12564504e5, new Date(2009, 9, 25)), "Dates and their corresponding numeric primitive values are not equal");
+
+ // Dates.
+ ok(_.isEqual(new Date(2009, 9, 25), new Date(2009, 9, 25)), "Date objects referencing identical times are equal");
+ ok(!_.isEqual(new Date(2009, 9, 25), new Date(2009, 11, 13)), "Date objects referencing different times are not equal");
+ ok(!_.isEqual(new Date(2009, 11, 13), {
+ getTime: function(){
+ return 12606876e5;
+ }
+ }), "Date objects and objects with a `getTime` method are not equal");
+ ok(!_.isEqual(new Date("Curly"), new Date("Curly")), "Invalid dates are not equal");
+
+ // Functions.
+ ok(!_.isEqual(First, Second), "Different functions with identical bodies and source code representations are not equal");
+
+ // RegExps.
+ ok(_.isEqual(/(?:)/gim, /(?:)/gim), "RegExps with equivalent patterns and flags are equal");
+ ok(!_.isEqual(/(?:)/g, /(?:)/gi), "RegExps with equivalent patterns and different flags are not equal");
+ ok(!_.isEqual(/Moe/gim, /Curly/gim), "RegExps with different patterns and equivalent flags are not equal");
+ ok(!_.isEqual(/(?:)/gi, /(?:)/g), "Commutative equality is implemented for RegExps");
+ ok(!_.isEqual(/Curly/g, {source: "Larry", global: true, ignoreCase: false, multiline: false}), "RegExps and RegExp-like objects are not equal");
+
+ // Empty arrays, array-like objects, and object literals.
+ ok(_.isEqual({}, {}), "Empty object literals are equal");
+ ok(_.isEqual([], []), "Empty array literals are equal");
+ ok(_.isEqual([{}], [{}]), "Empty nested arrays and objects are equal");
+ ok(!_.isEqual({length: 0}, []), "Array-like objects and arrays are not equal.");
+ ok(!_.isEqual([], {length: 0}), "Commutative equality is implemented for array-like objects");
+
+ ok(!_.isEqual({}, []), "Object literals and array literals are not equal");
+ ok(!_.isEqual([], {}), "Commutative equality is implemented for objects and arrays");
+
+ // Arrays with primitive and object values.
+ ok(_.isEqual([1, "Larry", true], [1, "Larry", true]), "Arrays containing identical primitives are equal");
+ ok(_.isEqual([(/Moe/g), new Date(2009, 9, 25)], [(/Moe/g), new Date(2009, 9, 25)]), "Arrays containing equivalent elements are equal");
+
+ // Multi-dimensional arrays.
+ var a = [new Number(47), false, "Larry", /Moe/, new Date(2009, 11, 13), ['running', 'biking', new String('programming')], {a: 47}];
+ var b = [new Number(47), false, "Larry", /Moe/, new Date(2009, 11, 13), ['running', 'biking', new String('programming')], {a: 47}];
+ ok(_.isEqual(a, b), "Arrays containing nested arrays and objects are recursively compared");
+
+ // Overwrite the methods defined in ES 5.1 section 15.4.4.
+ a.forEach = a.map = a.filter = a.every = a.indexOf = a.lastIndexOf = a.some = a.reduce = a.reduceRight = null;
+ b.join = b.pop = b.reverse = b.shift = b.slice = b.splice = b.concat = b.sort = b.unshift = null;
+
+ // Array elements and properties.
+ ok(_.isEqual(a, b), "Arrays containing equivalent elements and different non-numeric properties are equal");
+ a.push("White Rocks");
+ ok(!_.isEqual(a, b), "Arrays of different lengths are not equal");
+ a.push("East Boulder");
+ b.push("Gunbarrel Ranch", "Teller Farm");
+ ok(!_.isEqual(a, b), "Arrays of identical lengths containing different elements are not equal");
+
+ // Sparse arrays.
+ ok(_.isEqual(Array(3), Array(3)), "Sparse arrays of identical lengths are equal");
+ ok(!_.isEqual(Array(3), Array(6)), "Sparse arrays of different lengths are not equal when both are empty");
+
+ // Simple objects.
+ ok(_.isEqual({a: "Curly", b: 1, c: true}, {a: "Curly", b: 1, c: true}), "Objects containing identical primitives are equal");
+ ok(_.isEqual({a: /Curly/g, b: new Date(2009, 11, 13)}, {a: /Curly/g, b: new Date(2009, 11, 13)}), "Objects containing equivalent members are equal");
+ ok(!_.isEqual({a: 63, b: 75}, {a: 61, b: 55}), "Objects of identical sizes with different values are not equal");
+ ok(!_.isEqual({a: 63, b: 75}, {a: 61, c: 55}), "Objects of identical sizes with different property names are not equal");
+ ok(!_.isEqual({a: 1, b: 2}, {a: 1}), "Objects of different sizes are not equal");
+ ok(!_.isEqual({a: 1}, {a: 1, b: 2}), "Commutative equality is implemented for objects");
+ ok(!_.isEqual({x: 1, y: undefined}, {x: 1, z: 2}), "Objects with identical keys and different values are not equivalent");
+
+ // `A` contains nested objects and arrays.
+ a = {
+ name: new String("Moe Howard"),
+ age: new Number(77),
+ stooge: true,
+ hobbies: ["acting"],
+ film: {
+ name: "Sing a Song of Six Pants",
+ release: new Date(1947, 9, 30),
+ stars: [new String("Larry Fine"), "Shemp Howard"],
+ minutes: new Number(16),
+ seconds: 54
+ }
+ };
+
+ // `B` contains equivalent nested objects and arrays.
+ b = {
+ name: new String("Moe Howard"),
+ age: new Number(77),
+ stooge: true,
+ hobbies: ["acting"],
+ film: {
+ name: "Sing a Song of Six Pants",
+ release: new Date(1947, 9, 30),
+ stars: [new String("Larry Fine"), "Shemp Howard"],
+ minutes: new Number(16),
+ seconds: 54
+ }
+ };
+ ok(_.isEqual(a, b), "Objects with nested equivalent members are recursively compared");
+
+ // Instances.
+ ok(_.isEqual(new First, new First), "Object instances are equal");
+ ok(!_.isEqual(new First, new Second), "Objects with different constructors and identical own properties are not equal");
+ ok(!_.isEqual({value: 1}, new First), "Object instances and objects sharing equivalent properties are not equal");
+ ok(!_.isEqual({value: 2}, new Second), "The prototype chain of objects should not be examined");
+
+ // Circular Arrays.
+ (a = []).push(a);
+ (b = []).push(b);
+ ok(_.isEqual(a, b), "Arrays containing circular references are equal");
+ a.push(new String("Larry"));
+ b.push(new String("Larry"));
+ ok(_.isEqual(a, b), "Arrays containing circular references and equivalent properties are equal");
+ a.push("Shemp");
+ b.push("Curly");
+ ok(!_.isEqual(a, b), "Arrays containing circular references and different properties are not equal");
+
+ // More circular arrays #767.
+ a = ["everything is checked but", "this", "is not"];
+ a[1] = a;
+ b = ["everything is checked but", ["this", "array"], "is not"];
+ ok(!_.isEqual(a, b), "Comparison of circular references with non-circular references are not equal");
+
+ // Circular Objects.
+ a = {abc: null};
+ b = {abc: null};
+ a.abc = a;
+ b.abc = b;
+ ok(_.isEqual(a, b), "Objects containing circular references are equal");
+ a.def = 75;
+ b.def = 75;
+ ok(_.isEqual(a, b), "Objects containing circular references and equivalent properties are equal");
+ a.def = new Number(75);
+ b.def = new Number(63);
+ ok(!_.isEqual(a, b), "Objects containing circular references and different properties are not equal");
+
+ // More circular objects #767.
+ a = {everything: "is checked", but: "this", is: "not"};
+ a.but = a;
+ b = {everything: "is checked", but: {that:"object"}, is: "not"};
+ ok(!_.isEqual(a, b), "Comparison of circular references with non-circular object references are not equal");
+
+ // Cyclic Structures.
+ a = [{abc: null}];
+ b = [{abc: null}];
+ (a[0].abc = a).push(a);
+ (b[0].abc = b).push(b);
+ ok(_.isEqual(a, b), "Cyclic structures are equal");
+ a[0].def = "Larry";
+ b[0].def = "Larry";
+ ok(_.isEqual(a, b), "Cyclic structures containing equivalent properties are equal");
+ a[0].def = new String("Larry");
+ b[0].def = new String("Curly");
+ ok(!_.isEqual(a, b), "Cyclic structures containing different properties are not equal");
+
+ // Complex Circular References.
+ a = {foo: {b: {foo: {c: {foo: null}}}}};
+ b = {foo: {b: {foo: {c: {foo: null}}}}};
+ a.foo.b.foo.c.foo = a;
+ b.foo.b.foo.c.foo = b;
+ ok(_.isEqual(a, b), "Cyclic structures with nested and identically-named properties are equal");
+
+ // Chaining.
+ ok(!_.isEqual(_({x: 1, y: undefined}).chain(), _({x: 1, z: 2}).chain()), 'Chained objects containing different values are not equal');
+ equal(_({x: 1, y: 2}).chain().isEqual(_({x: 1, y: 2}).chain()).value(), true, '`isEqual` can be chained');
+
+ // Custom `isEqual` methods.
+ var isEqualObj = {isEqual: function (o) { return o.isEqual == this.isEqual; }, unique: {}};
+ var isEqualObjClone = {isEqual: isEqualObj.isEqual, unique: {}};
+
+ ok(_.isEqual(isEqualObj, isEqualObjClone), 'Both objects implement identical `isEqual` methods');
+ ok(_.isEqual(isEqualObjClone, isEqualObj), 'Commutative equality is implemented for objects with custom `isEqual` methods');
+ ok(!_.isEqual(isEqualObj, {}), 'Objects that do not implement equivalent `isEqual` methods are not equal');
+ ok(!_.isEqual({}, isEqualObj), 'Commutative equality is implemented for objects with different `isEqual` methods');
+
+ // Objects from another frame.
+ ok(_.isEqual({}, iObject));
+ });
+
+ test("isEmpty", function() {
+ ok(!_([1]).isEmpty(), '[1] is not empty');
+ ok(_.isEmpty([]), '[] is empty');
+ ok(!_.isEmpty({one : 1}), '{one : 1} is not empty');
+ ok(_.isEmpty({}), '{} is empty');
+ ok(_.isEmpty(new RegExp('')), 'objects with prototype properties are empty');
+ ok(_.isEmpty(null), 'null is empty');
+ ok(_.isEmpty(), 'undefined is empty');
+ ok(_.isEmpty(''), 'the empty string is empty');
+ ok(!_.isEmpty('moe'), 'but other strings are not');
+
+ var obj = {one : 1};
+ delete obj.one;
+ ok(_.isEmpty(obj), 'deleting all the keys from an object empties it');
+ });
+
+ // Setup remote variables for iFrame tests.
+ var iframe = document.createElement('iframe');
+ jQuery(iframe).appendTo(document.body);
+ var iDoc = iframe.contentDocument || iframe.contentWindow.document;
+ iDoc.write(
+ ""
+ );
+ iDoc.close();
+
+ test("isElement", function() {
+ ok(!_.isElement('div'), 'strings are not dom elements');
+ ok(_.isElement($('html')[0]), 'the html tag is a DOM element');
+ ok(_.isElement(iElement), 'even from another frame');
+ });
+
+ test("isArguments", function() {
+ var args = (function(){ return arguments; })(1, 2, 3);
+ ok(!_.isArguments('string'), 'a string is not an arguments object');
+ ok(!_.isArguments(_.isArguments), 'a function is not an arguments object');
+ ok(_.isArguments(args), 'but the arguments object is an arguments object');
+ ok(!_.isArguments(_.toArray(args)), 'but not when it\'s converted into an array');
+ ok(!_.isArguments([1,2,3]), 'and not vanilla arrays.');
+ ok(_.isArguments(iArguments), 'even from another frame');
+ });
+
+ test("isObject", function() {
+ ok(_.isObject(arguments), 'the arguments object is object');
+ ok(_.isObject([1, 2, 3]), 'and arrays');
+ ok(_.isObject($('html')[0]), 'and DOM element');
+ ok(_.isObject(iElement), 'even from another frame');
+ ok(_.isObject(function () {}), 'and functions');
+ ok(_.isObject(iFunction), 'even from another frame');
+ ok(!_.isObject(null), 'but not null');
+ ok(!_.isObject(undefined), 'and not undefined');
+ ok(!_.isObject('string'), 'and not string');
+ ok(!_.isObject(12), 'and not number');
+ ok(!_.isObject(true), 'and not boolean');
+ ok(_.isObject(new String('string')), 'but new String()');
+ });
+
+ test("isArray", function() {
+ ok(!_.isArray(arguments), 'the arguments object is not an array');
+ ok(_.isArray([1, 2, 3]), 'but arrays are');
+ ok(_.isArray(iArray), 'even from another frame');
+ });
+
+ test("isString", function() {
+ ok(!_.isString(document.body), 'the document body is not a string');
+ ok(_.isString([1, 2, 3].join(', ')), 'but strings are');
+ ok(_.isString(iString), 'even from another frame');
+ });
+
+ test("isNumber", function() {
+ ok(!_.isNumber('string'), 'a string is not a number');
+ ok(!_.isNumber(arguments), 'the arguments object is not a number');
+ ok(!_.isNumber(undefined), 'undefined is not a number');
+ ok(_.isNumber(3 * 4 - 7 / 10), 'but numbers are');
+ ok(_.isNumber(NaN), 'NaN *is* a number');
+ ok(_.isNumber(Infinity), 'Infinity is a number');
+ ok(_.isNumber(iNumber), 'even from another frame');
+ ok(!_.isNumber('1'), 'numeric strings are not numbers');
+ });
+
+ test("isBoolean", function() {
+ ok(!_.isBoolean(2), 'a number is not a boolean');
+ ok(!_.isBoolean("string"), 'a string is not a boolean');
+ ok(!_.isBoolean("false"), 'the string "false" is not a boolean');
+ ok(!_.isBoolean("true"), 'the string "true" is not a boolean');
+ ok(!_.isBoolean(arguments), 'the arguments object is not a boolean');
+ ok(!_.isBoolean(undefined), 'undefined is not a boolean');
+ ok(!_.isBoolean(NaN), 'NaN is not a boolean');
+ ok(!_.isBoolean(null), 'null is not a boolean');
+ ok(_.isBoolean(true), 'but true is');
+ ok(_.isBoolean(false), 'and so is false');
+ ok(_.isBoolean(iBoolean), 'even from another frame');
+ });
+
+ test("isFunction", function() {
+ ok(!_.isFunction([1, 2, 3]), 'arrays are not functions');
+ ok(!_.isFunction('moe'), 'strings are not functions');
+ ok(_.isFunction(_.isFunction), 'but functions are');
+ ok(_.isFunction(iFunction), 'even from another frame');
+ });
+
+ test("isDate", function() {
+ ok(!_.isDate(100), 'numbers are not dates');
+ ok(!_.isDate({}), 'objects are not dates');
+ ok(_.isDate(new Date()), 'but dates are');
+ ok(_.isDate(iDate), 'even from another frame');
+ });
+
+ test("isRegExp", function() {
+ ok(!_.isRegExp(_.identity), 'functions are not RegExps');
+ ok(_.isRegExp(/identity/), 'but RegExps are');
+ ok(_.isRegExp(iRegExp), 'even from another frame');
+ });
+
+ test("isFinite", function() {
+ ok(!_.isFinite(undefined), 'undefined is not Finite');
+ ok(!_.isFinite(null), 'null is not Finite');
+ ok(!_.isFinite(NaN), 'NaN is not Finite');
+ ok(!_.isFinite(Infinity), 'Infinity is not Finite');
+ ok(!_.isFinite(-Infinity), '-Infinity is not Finite');
+ ok(!_.isFinite('12'), 'Strings are not numbers');
+ var obj = new Number(5);
+ ok(_.isFinite(obj), 'Number instances can be finite');
+ ok(_.isFinite(0), '0 is Finite');
+ ok(_.isFinite(123), 'Ints are Finite');
+ ok(_.isFinite(-12.44), 'Floats are Finite');
+ });
+
+ test("isNaN", function() {
+ ok(!_.isNaN(undefined), 'undefined is not NaN');
+ ok(!_.isNaN(null), 'null is not NaN');
+ ok(!_.isNaN(0), '0 is not NaN');
+ ok(_.isNaN(NaN), 'but NaN is');
+ ok(_.isNaN(iNaN), 'even from another frame');
+ ok(_.isNaN(new Number(NaN)), 'wrapped NaN is still NaN');
+ });
+
+ test("isNull", function() {
+ ok(!_.isNull(undefined), 'undefined is not null');
+ ok(!_.isNull(NaN), 'NaN is not null');
+ ok(_.isNull(null), 'but null is');
+ ok(_.isNull(iNull), 'even from another frame');
+ });
+
+ test("isUndefined", function() {
+ ok(!_.isUndefined(1), 'numbers are defined');
+ ok(!_.isUndefined(null), 'null is defined');
+ ok(!_.isUndefined(false), 'false is defined');
+ ok(!_.isUndefined(NaN), 'NaN is defined');
+ ok(_.isUndefined(), 'nothing is undefined');
+ ok(_.isUndefined(undefined), 'undefined is undefined');
+ ok(_.isUndefined(iUndefined), 'even from another frame');
+ });
+
+ if (window.ActiveXObject) {
+ test("IE host objects", function() {
+ var xml = new ActiveXObject("Msxml2.DOMDocument.3.0");
+ ok(!_.isNumber(xml));
+ ok(!_.isBoolean(xml));
+ ok(!_.isNaN(xml));
+ ok(!_.isFunction(xml));
+ ok(!_.isNull(xml));
+ ok(!_.isUndefined(xml));
+ });
+ }
+
+ test("tap", function() {
+ var intercepted = null;
+ var interceptor = function(obj) { intercepted = obj; };
+ var returned = _.tap(1, interceptor);
+ equal(intercepted, 1, "passes tapped object to interceptor");
+ equal(returned, 1, "returns tapped object");
+
+ returned = _([1,2,3]).chain().
+ map(function(n){ return n * 2; }).
+ max().
+ tap(interceptor).
+ value();
+ ok(returned == 6 && intercepted == 6, 'can use tapped objects in a chain');
+ });
+});
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/grunt-legacy-log/node_modules/underscore.string/test/test_underscore/speed.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/grunt-legacy-log/node_modules/underscore.string/test/test_underscore/speed.js
new file mode 100644
index 0000000..05e3f2a
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/grunt-legacy-log/node_modules/underscore.string/test/test_underscore/speed.js
@@ -0,0 +1,75 @@
+(function() {
+
+ var numbers = [];
+ for (var i=0; i<1000; i++) numbers.push(i);
+ var objects = _.map(numbers, function(n){ return {num : n}; });
+ var randomized = _.sortBy(numbers, function(){ return Math.random(); });
+ var deep = _.map(_.range(100), function() { return _.range(1000); });
+
+ JSLitmus.test('_.each()', function() {
+ var timesTwo = [];
+ _.each(numbers, function(num){ timesTwo.push(num * 2); });
+ return timesTwo;
+ });
+
+ JSLitmus.test('_(list).each()', function() {
+ var timesTwo = [];
+ _(numbers).each(function(num){ timesTwo.push(num * 2); });
+ return timesTwo;
+ });
+
+ JSLitmus.test('jQuery.each()', function() {
+ var timesTwo = [];
+ jQuery.each(numbers, function(){ timesTwo.push(this * 2); });
+ return timesTwo;
+ });
+
+ JSLitmus.test('_.map()', function() {
+ return _.map(objects, function(obj){ return obj.num; });
+ });
+
+ JSLitmus.test('jQuery.map()', function() {
+ return jQuery.map(objects, function(obj){ return obj.num; });
+ });
+
+ JSLitmus.test('_.pluck()', function() {
+ return _.pluck(objects, 'num');
+ });
+
+ JSLitmus.test('_.uniq()', function() {
+ return _.uniq(randomized);
+ });
+
+ JSLitmus.test('_.uniq() (sorted)', function() {
+ return _.uniq(numbers, true);
+ });
+
+ JSLitmus.test('_.sortBy()', function() {
+ return _.sortBy(numbers, function(num){ return -num; });
+ });
+
+ JSLitmus.test('_.isEqual()', function() {
+ return _.isEqual(numbers, randomized);
+ });
+
+ JSLitmus.test('_.keys()', function() {
+ return _.keys(objects);
+ });
+
+ JSLitmus.test('_.values()', function() {
+ return _.values(objects);
+ });
+
+ JSLitmus.test('_.intersection()', function() {
+ return _.intersection(numbers, randomized);
+ });
+
+ JSLitmus.test('_.range()', function() {
+ return _.range(1000);
+ });
+
+ JSLitmus.test('_.flatten()', function() {
+ return _.flatten(deep);
+ });
+
+})();
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/grunt-legacy-log/node_modules/underscore.string/test/test_underscore/utility.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/grunt-legacy-log/node_modules/underscore.string/test/test_underscore/utility.js
new file mode 100644
index 0000000..c9be20a
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/grunt-legacy-log/node_modules/underscore.string/test/test_underscore/utility.js
@@ -0,0 +1,249 @@
+$(document).ready(function() {
+
+ var templateSettings;
+
+ module("Utility", {
+
+ setup: function() {
+ templateSettings = _.clone(_.templateSettings);
+ },
+
+ teardown: function() {
+ _.templateSettings = templateSettings;
+ }
+
+ });
+
+ test("#750 - Return _ instance.", 2, function() {
+ var instance = _([]);
+ ok(_(instance) === instance);
+ ok(new _(instance) === instance);
+ });
+
+ test("identity", function() {
+ var moe = {name : 'moe'};
+ equal(_.identity(moe), moe, 'moe is the same as his identity');
+ });
+
+ test("uniqueId", function() {
+ var ids = [], i = 0;
+ while(i++ < 100) ids.push(_.uniqueId());
+ equal(_.uniq(ids).length, ids.length, 'can generate a globally-unique stream of ids');
+ });
+
+ test("times", function() {
+ var vals = [];
+ _.times(3, function (i) { vals.push(i); });
+ ok(_.isEqual(vals, [0,1,2]), "is 0 indexed");
+ //
+ vals = [];
+ _(3).times(function (i) { vals.push(i); });
+ ok(_.isEqual(vals, [0,1,2]), "works as a wrapper");
+ });
+
+ test("mixin", function() {
+ _.mixin({
+ myReverse: function(string) {
+ return string.split('').reverse().join('');
+ }
+ });
+ equal(_.myReverse('panacea'), 'aecanap', 'mixed in a function to _');
+ equal(_('champ').myReverse(), 'pmahc', 'mixed in a function to the OOP wrapper');
+ });
+
+ test("_.escape", function() {
+ equal(_.escape("Curly & Moe"), "Curly & Moe");
+ equal(_.escape("Curly & Moe"), "Curly & Moe");
+ equal(_.escape(null), '');
+ });
+
+ test("_.unescape", function() {
+ var string = "Curly & Moe";
+ equal(_.unescape("Curly & Moe"), string);
+ equal(_.unescape("Curly & Moe"), "Curly & Moe");
+ equal(_.unescape(null), '');
+ equal(_.unescape(_.escape(string)), string);
+ });
+
+ test("template", function() {
+ var basicTemplate = _.template("<%= thing %> is gettin' on my noives!");
+ var result = basicTemplate({thing : 'This'});
+ equal(result, "This is gettin' on my noives!", 'can do basic attribute interpolation');
+
+ var sansSemicolonTemplate = _.template("A <% this %> B");
+ equal(sansSemicolonTemplate(), "A B");
+
+ var backslashTemplate = _.template("<%= thing %> is \\ridanculous");
+ equal(backslashTemplate({thing: 'This'}), "This is \\ridanculous");
+
+ var escapeTemplate = _.template('<%= a ? "checked=\\"checked\\"" : "" %>');
+ equal(escapeTemplate({a: true}), 'checked="checked"', 'can handle slash escapes in interpolations.');
+
+ var fancyTemplate = _.template("<% \
+ for (key in people) { \
+ %>- <%= people[key] %>
<% } %>
");
+ result = fancyTemplate({people : {moe : "Moe", larry : "Larry", curly : "Curly"}});
+ equal(result, "", 'can run arbitrary javascript in templates');
+
+ var escapedCharsInJavascriptTemplate = _.template("<% _.each(numbers.split('\\n'), function(item) { %>- <%= item %>
<% }) %>
");
+ result = escapedCharsInJavascriptTemplate({numbers: "one\ntwo\nthree\nfour"});
+ equal(result, "", 'Can use escaped characters (e.g. \\n) in Javascript');
+
+ var namespaceCollisionTemplate = _.template("<%= pageCount %> <%= thumbnails[pageCount] %> <% _.each(thumbnails, function(p) { %>\">
<% }); %>");
+ result = namespaceCollisionTemplate({
+ pageCount: 3,
+ thumbnails: {
+ 1: "p1-thumbnail.gif",
+ 2: "p2-thumbnail.gif",
+ 3: "p3-thumbnail.gif"
+ }
+ });
+ equal(result, "3 p3-thumbnail.gif ");
+
+ var noInterpolateTemplate = _.template("Just some text. Hey, I know this is silly but it aids consistency.
Just some text. Hey, I know this is silly but it aids consistency.
+(This page uses big5 character set.)
+charset=big5
+
+
+
\ No newline at end of file
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/iconv-lite/test/cyrillic-test.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/iconv-lite/test/cyrillic-test.js
new file mode 100644
index 0000000..259d283
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/iconv-lite/test/cyrillic-test.js
@@ -0,0 +1,86 @@
+var vows = require('vows'),
+ assert = require('assert'),
+ iconv = require(__dirname+'/../');
+
+var baseStrings = {
+ empty: "",
+ hi: "Привет!",
+ ascii: '\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f'+
+ ' !"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\x7f',
+ rus: "АБВГДЕЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯабвгдежзийклмнопрстуфхцчшщъыьэюя",
+ additional1: "ЂЃ‚ѓ„…†‡€‰Љ‹ЊЌЋЏђ‘’“”•–—™љ›њќћџ ЎўЈ¤Ґ¦§Ё©Є«¬\xAD®Ї°±Ііґµ¶·ё№є»јЅѕї",
+ additional2: "─│┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥ ⌡°²·÷═║╒ё╓╔╕╖╗╘╙╚╛╜╝╞╟╠╡Ё╢╣╤╥╦╧╨╩╪╫╬©",
+ additional3: " ЁЂЃЄЅІЇЈЉЊЋЌЎЏ№ёђѓєѕіїјљњћќ§ўџ",
+ untranslatable: "£Åçþÿ¿",
+};
+
+var encodings = [{
+ name: "Win-1251",
+ variations: ['win1251', 'Windows-1251', 'windows1251', 'CP1251', 1251],
+ encodedStrings: {
+ empty: new Buffer(''),
+ hi: new Buffer('\xcf\xf0\xe8\xe2\xe5\xf2!', 'binary'),
+ ascii: new Buffer(baseStrings.ascii, 'binary'),
+ rus: new Buffer('\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff', 'binary'),
+ additional1: new Buffer('\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x99\x9a\x9b\x9c\x9d\x9e\x9f\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf','binary'),
+ }
+}, {
+ name: "Koi8-R",
+ variations: ['koi8r', 'KOI8-R', 'cp20866', 20866],
+ encodedStrings: {
+ empty: new Buffer(''),
+ hi: new Buffer('\xf0\xd2\xc9\xd7\xc5\xd4!', 'binary'),
+ ascii: new Buffer(baseStrings.ascii, 'binary'),
+ rus: new Buffer('\xe1\xe2\xf7\xe7\xe4\xe5\xf6\xfa\xe9\xea\xeb\xec\xed\xee\xef\xf0\xf2\xf3\xf4\xf5\xe6\xe8\xe3\xfe\xfb\xfd\xff\xf9\xf8\xfc\xe0\xf1\xc1\xc2\xd7\xc7\xc4\xc5\xd6\xda\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0\xd2\xd3\xd4\xd5\xc6\xc8\xc3\xde\xdb\xdd\xdf\xd9\xd8\xdc\xc0\xd1', 'binary'),
+ additional2: new Buffer('\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf', 'binary'),
+ }
+}, {
+ name: "ISO 8859-5",
+ variations: ['iso88595', 'ISO-8859-5', 'ISO 8859-5', 'cp28595', 28595],
+ encodedStrings: {
+ empty: new Buffer(''),
+ hi: new Buffer('\xbf\xe0\xd8\xd2\xd5\xe2!', 'binary'),
+ ascii: new Buffer(baseStrings.ascii, 'binary'),
+ rus: new Buffer('\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef', 'binary'),
+ additional3: new Buffer('\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff', 'binary'),
+ }
+}];
+
+var testsBatch = {};
+encodings.forEach(function(encoding) {
+ var enc = encoding.variations[0];
+ var key = "hi";
+ var tests = {
+ "Convert to empty buffer": function() {
+ assert.strictEqual(iconv.toEncoding("", enc).toString('binary'), new Buffer('').toString('binary'));
+ },
+ "Convert from empty buffer": function() {
+ assert.strictEqual(iconv.fromEncoding(new Buffer(''), enc), "");
+ },
+ "Convert from buffer": function() {
+ for (var key in encoding.encodedStrings)
+ assert.strictEqual(iconv.fromEncoding(encoding.encodedStrings[key], enc),
+ baseStrings[key]);
+ },
+ "Convert to buffer": function() {
+ for (var key in encoding.encodedStrings)
+ assert.strictEqual(iconv.toEncoding(baseStrings[key], enc).toString('binary'),
+ encoding.encodedStrings[key].toString('binary'));
+ },
+ "Try different variations of encoding": function() {
+ encoding.variations.forEach(function(enc) {
+ assert.strictEqual(iconv.fromEncoding(encoding.encodedStrings[key], enc), baseStrings[key]);
+ assert.strictEqual(iconv.toEncoding(baseStrings[key], enc).toString('binary'), encoding.encodedStrings[key].toString('binary'));
+ });
+ },
+ "Untranslatable chars are converted to defaultCharSingleByte": function() {
+ var expected = baseStrings.untranslatable.split('').map(function(c) {return iconv.defaultCharSingleByte; }).join('');
+ assert.strictEqual(iconv.toEncoding(baseStrings.untranslatable, enc).toString('binary'), expected); // Only '?' characters.
+ }
+ };
+
+ testsBatch[encoding.name+":"] = tests;
+});
+
+vows.describe("Test Cyrillic encodings").addBatch(testsBatch).export(module);
+
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/iconv-lite/test/gbk-test.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/iconv-lite/test/gbk-test.js
new file mode 100644
index 0000000..7b2e47b
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/iconv-lite/test/gbk-test.js
@@ -0,0 +1,38 @@
+var vows = require('vows'),
+ fs = require('fs'),
+ assert = require('assert'),
+ iconv = require(__dirname+'/../');
+
+var testString = "中国abc",//unicode contains GBK-code and ascii
+ testStringGBKBuffer = new Buffer([0xd6,0xd0,0xb9,0xfa,0x61,0x62,0x63]);
+
+vows.describe("GBK tests").addBatch({
+ "Vows is working": function() {},
+ "Return values are of correct types": function() {
+ assert.ok(iconv.toEncoding(testString, "utf8") instanceof Buffer);
+ var s = iconv.fromEncoding(new Buffer(testString), "utf8");
+ assert.strictEqual(Object.prototype.toString.call(s), "[object String]");
+ },
+ "GBK correctly encoded/decoded": function() {
+ assert.strictEqual(iconv.toEncoding(testString, "GBK").toString('binary'), testStringGBKBuffer.toString('binary'));
+ assert.strictEqual(iconv.fromEncoding(testStringGBKBuffer, "GBK"), testString);
+ },
+ "GB2312 correctly encoded/decoded": function() {
+ assert.strictEqual(iconv.toEncoding(testString, "GB2312").toString('binary'), testStringGBKBuffer.toString('binary'));
+ assert.strictEqual(iconv.fromEncoding(testStringGBKBuffer, "GB2312"), testString);
+ },
+ "GBK file read decoded,compare with iconv result": function() {
+ var contentBuffer = fs.readFileSync(__dirname+"/gbkFile.txt");
+ var str = iconv.fromEncoding(contentBuffer, "GBK");
+ var iconvc = new (require('iconv').Iconv)('GBK','utf8');
+ assert.strictEqual(iconvc.convert(contentBuffer).toString(), str);
+ },
+ "GBK correctly decodes and encodes characters · and ×": function() {
+ // https://github.com/ashtuchkin/iconv-lite/issues/13
+ // Reference: http://www.unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WINDOWS/CP936.TXT
+ var chars = "·×";
+ var gbkChars = new Buffer([0xA1, 0xA4, 0xA1, 0xC1]);
+ assert.strictEqual(iconv.toEncoding(chars, "GBK").toString('binary'), gbkChars.toString('binary'));
+ assert.strictEqual(iconv.fromEncoding(gbkChars, "GBK"), chars)
+ },
+}).export(module)
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/iconv-lite/test/gbkFile.txt b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/iconv-lite/test/gbkFile.txt
new file mode 100644
index 0000000..345b5d0
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/iconv-lite/test/gbkFile.txt
@@ -0,0 +1,14 @@
+ٶһ£֪
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/iconv-lite/test/greek-test.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/iconv-lite/test/greek-test.js
new file mode 100644
index 0000000..0394ee6
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/iconv-lite/test/greek-test.js
@@ -0,0 +1,79 @@
+var vows = require('vows'),
+ assert = require('assert'),
+ iconv = require(__dirname+'/../');
+
+var baseStrings = {
+ empty: "",
+ hi: "Γειά!",
+ ascii: '\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f'+
+ ' !"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\x7f',
+ greek: "αβγδεζηθικλμνξοπρστυφχψωΑΒΓΔΕΖΗΘΙΚΛΜΝΞΟΠΡΣΤΥΦΧΨΩάέήίόύώΆΈΉΊΌΎΏϊϋΪΫ",
+ untranslatable: "Åçþÿ¿"
+};
+
+var encodings = [{
+ name: "windows1253",
+ variations: ['windows-1253', 'win-1253', 'win1253', 'cp1253', 'cp-1253', 1253],
+ encodedStrings: {
+ empty: new Buffer(''),
+ hi: new Buffer('\xc3\xe5\xe9\xdc!', 'binary'),
+ ascii: new Buffer(baseStrings.ascii, 'binary'),
+ greek: new Buffer('\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0\xf1\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0\xd1\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xdc\xdd\xde\xdf\xfc\xfd\xfe\xa2\xb8\xb9\xba\xbc\xbe\xbf\xfa\xfb\xda\xdb', 'binary'),
+ }
+}, {
+ name: "iso88597",
+ variations: ['iso-8859-7', 'greek', 'greek8', 'cp28597', 'cp-28597', 28597],
+ encodedStrings: {
+ empty: new Buffer(''),
+ hi: new Buffer('\xc3\xe5\xe9\xdc!', 'binary'),
+ ascii: new Buffer(baseStrings.ascii, 'binary'),
+ greek: new Buffer('\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0\xf1\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0\xd1\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xdc\xdd\xde\xdf\xfc\xfd\xfe\xb6\xb8\xb9\xba\xbc\xbe\xbf\xfa\xfb\xda\xdb', 'binary'),
+ }
+}, {
+ name: "cp737",
+ variations: ['cp-737', 737],
+ encodedStrings: {
+ empty: new Buffer(''),
+ hi: new Buffer('\x82\x9c\xa0\xe1!', 'binary'),
+ ascii: new Buffer(baseStrings.ascii, 'binary'),
+ greek: new Buffer('\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xab\xac\xad\xae\xaf\xe0\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\xe1\xe2\xe3\xe5\xe6\xe7\xe9\xea\xeb\xec\xed\xee\xef\xf0\xe4\xe8\xf4\xf5', 'binary'),
+ }
+}];
+
+var testsBatch = {};
+encodings.forEach(function(encoding) {
+ var enc = encoding.variations[0];
+ var key = "hi";
+ var tests = {
+ "Convert to empty buffer": function() {
+ assert.strictEqual(iconv.toEncoding("", enc).toString('binary'), new Buffer('').toString('binary'));
+ },
+ "Convert from empty buffer": function() {
+ assert.strictEqual(iconv.fromEncoding(new Buffer(''), enc), "");
+ },
+ "Convert from buffer": function() {
+ for (var key in encoding.encodedStrings)
+ assert.strictEqual(iconv.fromEncoding(encoding.encodedStrings[key], enc),
+ baseStrings[key]);
+ },
+ "Convert to buffer": function() {
+ for (var key in encoding.encodedStrings)
+ assert.strictEqual(iconv.toEncoding(baseStrings[key], enc).toString('binary'),
+ encoding.encodedStrings[key].toString('binary'));
+ },
+ "Try different variations of encoding": function() {
+ encoding.variations.forEach(function(enc) {
+ assert.strictEqual(iconv.fromEncoding(encoding.encodedStrings[key], enc), baseStrings[key]);
+ assert.strictEqual(iconv.toEncoding(baseStrings[key], enc).toString('binary'), encoding.encodedStrings[key].toString('binary'));
+ });
+ },
+ "Untranslatable chars are converted to defaultCharSingleByte": function() {
+ var expected = baseStrings.untranslatable.split('').map(function(c) {return iconv.defaultCharSingleByte; }).join('');
+ assert.strictEqual(iconv.toEncoding(baseStrings.untranslatable, enc).toString('binary'), expected); // Only '?' characters.
+ }
+ };
+
+ testsBatch[encoding.name+":"] = tests;
+});
+
+vows.describe("Test Greek encodings").addBatch(testsBatch).export(module);
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/iconv-lite/test/main-test.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/iconv-lite/test/main-test.js
new file mode 100644
index 0000000..50177f2
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/iconv-lite/test/main-test.js
@@ -0,0 +1,55 @@
+var vows = require('vows'),
+ assert = require('assert'),
+ iconv = require(__dirname+'/../');
+
+var testString = "Hello123!";
+var testStringLatin1 = "Hello123!£Å÷×çþÿ¿®";
+var testStringBase64 = "SGVsbG8xMjMh";
+
+vows.describe("Generic UTF8-UCS2 tests").addBatch({
+ "Vows is working": function() {},
+ "Return values are of correct types": function() {
+ assert.ok(iconv.toEncoding(testString, "utf8") instanceof Buffer);
+
+ var s = iconv.fromEncoding(new Buffer(testString), "utf8");
+ assert.strictEqual(Object.prototype.toString.call(s), "[object String]");
+ },
+ "Internal encodings all correctly encoded/decoded": function() {
+ ['utf8', "UTF-8", "UCS2", "binary", ""].forEach(function(enc) {
+ assert.strictEqual(iconv.toEncoding(testStringLatin1, enc).toString(enc), testStringLatin1);
+ assert.strictEqual(iconv.fromEncoding(new Buffer(testStringLatin1, enc), enc), testStringLatin1);
+ });
+ },
+ "Base64 correctly encoded/decoded": function() {
+ assert.strictEqual(iconv.toEncoding(testStringBase64, "base64").toString("binary"), testString);
+ assert.strictEqual(iconv.fromEncoding(new Buffer(testString, "binary"), "base64"), testStringBase64);
+ },
+ "Latin1 correctly encoded/decoded": function() {
+ assert.strictEqual(iconv.toEncoding(testStringLatin1, "latin1").toString("binary"), testStringLatin1);
+ assert.strictEqual(iconv.fromEncoding(new Buffer(testStringLatin1, "binary"), "latin1"), testStringLatin1);
+ },
+ "Convert from string, not buffer (binary encoding used)": function() {
+ assert.strictEqual(iconv.fromEncoding(testStringLatin1, "binary"), testStringLatin1);
+ },
+ "Convert to string, not buffer (utf8 used)": function() {
+ var res = iconv.toEncoding(new Buffer(testStringLatin1, "utf8"));
+ assert.ok(res instanceof Buffer);
+ assert.strictEqual(res.toString("utf8"), testStringLatin1);
+ },
+ "Throws on unknown encodings": function() {
+ assert.throws(function() { iconv.toEncoding("a", "xxx"); });
+ assert.throws(function() { iconv.fromEncoding("a", "xxx"); });
+ },
+ "Convert non-strings and non-buffers": function() {
+ assert.strictEqual(iconv.toEncoding({}, "utf8").toString(), "[object Object]");
+ assert.strictEqual(iconv.toEncoding(10, "utf8").toString(), "10");
+ assert.strictEqual(iconv.toEncoding(undefined, "utf8").toString(), "");
+ assert.strictEqual(iconv.fromEncoding({}, "utf8"), "[object Object]");
+ assert.strictEqual(iconv.fromEncoding(10, "utf8"), "10");
+ assert.strictEqual(iconv.fromEncoding(undefined, "utf8"), "");
+ },
+ "Aliases encode and decode work the same as toEncoding and fromEncoding": function() {
+ assert.strictEqual(iconv.toEncoding(testString, "latin1").toString("binary"), iconv.encode(testString, "latin1").toString("binary"));
+ assert.strictEqual(iconv.fromEncoding(testStringLatin1, "latin1"), iconv.decode(testStringLatin1, "latin1"));
+ },
+}).export(module)
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/iconv-lite/test/performance.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/iconv-lite/test/performance.js
new file mode 100644
index 0000000..835deac
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/iconv-lite/test/performance.js
@@ -0,0 +1,67 @@
+
+var iconv = require('iconv');
+var iconv_lite = require("../index");
+
+var encoding = process.argv[2] || "windows-1251";
+var convertTimes = 10000;
+
+var encodingStrings = {
+ 'windows-1251': 'This is a test string 32 chars..',
+ 'gbk': '这是中文字符测试。。！@￥%12',
+ 'utf8': '这是中文字符测试。。！@￥%12This is a test string 48 chars..',
+};
+// Test encoding.
+var str = encodingStrings[encoding];
+if (!str) {
+ throw new Error('Don\'t support ' + encoding + ' performance test.');
+}
+for (var i = 0; i < 13; i++) {
+ str = str + str;
+}
+
+console.log('\n' + encoding + ' charset performance test:');
+console.log("\nEncoding "+str.length+" chars "+convertTimes+" times:");
+
+var start = Date.now();
+var converter = new iconv.Iconv("utf8", encoding);
+for (var i = 0; i < convertTimes; i++) {
+ var b = converter.convert(str);
+}
+var duration = Date.now() - start;
+var mbs = convertTimes*b.length/duration/1024;
+
+console.log("iconv: "+duration+"ms, "+mbs.toFixed(2)+" Mb/s.");
+
+var start = Date.now();
+for (var i = 0; i < convertTimes; i++) {
+ var b = iconv_lite.encode(str, encoding);
+}
+var duration = Date.now() - start;
+var mbs = convertTimes*b.length/duration/1024;
+
+console.log("iconv-lite: "+duration+"ms, "+mbs.toFixed(2)+" Mb/s.");
+
+
+// Test decoding.
+var buf = iconv_lite.encode(str, encoding);
+console.log("\nDecoding "+buf.length+" bytes "+convertTimes+" times:");
+
+var start = Date.now();
+var converter = new iconv.Iconv(encoding, "utf8");
+for (var i = 0; i < convertTimes; i++) {
+ var s = converter.convert(buf).toString();
+}
+var duration = Date.now() - start;
+var mbs = convertTimes*buf.length/duration/1024;
+
+console.log("iconv: "+duration+"ms, "+mbs.toFixed(2)+" Mb/s.");
+
+var start = Date.now();
+for (var i = 0; i < convertTimes; i++) {
+ var s = iconv_lite.decode(buf, encoding);
+}
+var duration = Date.now() - start;
+var mbs = convertTimes*buf.length/duration/1024;
+
+console.log("iconv-lite: "+duration+"ms, "+mbs.toFixed(2)+" Mb/s.");
+
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/iconv-lite/test/turkish-test.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/iconv-lite/test/turkish-test.js
new file mode 100644
index 0000000..b2eb68e
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/iconv-lite/test/turkish-test.js
@@ -0,0 +1,90 @@
+var vows = require('vows'),
+ assert = require('assert'),
+ iconv = require(__dirname+'/../');
+
+var ascii = '\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f'+
+ ' !"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\x7f';
+
+var encodings = [{
+ name: "windows1254",
+ variations: ['windows-1254', 'win-1254', 'win1254', 'cp1254', 'cp-1254', 1254],
+ strings: {
+ empty: "",
+ ascii: ascii,
+ turkish: "€‚ƒ„…†‡ˆ‰Š‹Œ‘’“”•–—˜™š›œŸ¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏĞÑÒÓÔÕÖ×ØÙÚÛÜİŞßàáâãäåæçèéêëìíîïğñòóôõö÷øùúûüışÿ",
+ untranslatable: "\x81\x8d\x8e\x8f\x90\x9d\x9e"
+ },
+ encodedStrings: {
+ empty: new Buffer(''),
+ ascii: new Buffer(ascii, 'binary'),
+ turkish: new Buffer(
+ '\x80\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c' +
+ '\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9f' +
+ '\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xae\xaf' +
+ '\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf' +
+ '\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf' +
+ '\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf' +
+ '\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef' +
+ '\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff',
+ 'binary'),
+ }
+}, {
+ name: "iso88599",
+ variations: ['iso-8859-9', 'turkish', 'turkish8', 'cp28599', 'cp-28599', 28599],
+ strings: {
+ empty: "",
+ ascii: ascii,
+ turkish: "\xa0¡¢£¤¥¦§¨©ª«¬\xad®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏĞÑÒÓÔÕÖ×ØÙÚÛÜİŞßàáâãäåæçèéêëìíîïğñòóôõö÷øùúûüışÿ",
+ untranslatable: ''
+ },
+ encodedStrings: {
+ empty: new Buffer(''),
+ ascii: new Buffer(ascii, 'binary'),
+ turkish: new Buffer(
+ '\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf' +
+ '\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf' +
+ '\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf' +
+ '\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf' +
+ '\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef' +
+ '\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff',
+ 'binary')
+ }
+}];
+
+var testsBatch = {};
+encodings.forEach(function(encoding) {
+ var enc = encoding.variations[0];
+ var key = "turkish";
+ var tests = {
+ "Convert to empty buffer": function() {
+ assert.strictEqual(iconv.toEncoding("", enc).toString('binary'), new Buffer('').toString('binary'));
+ },
+ "Convert from empty buffer": function() {
+ assert.strictEqual(iconv.fromEncoding(new Buffer(''), enc), "");
+ },
+ "Convert from buffer": function() {
+ for (var key in encoding.encodedStrings)
+ assert.strictEqual(iconv.fromEncoding(encoding.encodedStrings[key], enc),
+ encoding.strings[key]);
+ },
+ "Convert to buffer": function() {
+ for (var key in encoding.encodedStrings)
+ assert.strictEqual(iconv.toEncoding(encoding.strings[key], enc).toString('binary'),
+ encoding.encodedStrings[key].toString('binary'));
+ },
+ "Try different variations of encoding": function() {
+ encoding.variations.forEach(function(enc) {
+ assert.strictEqual(iconv.fromEncoding(encoding.encodedStrings[key], enc), encoding.strings[key]);
+ assert.strictEqual(iconv.toEncoding(encoding.strings[key], enc).toString('binary'), encoding.encodedStrings[key].toString('binary'));
+ });
+ },
+ "Untranslatable chars are converted to defaultCharSingleByte": function() {
+ var expected = encoding.strings.untranslatable.split('').map(function(c) {return iconv.defaultCharSingleByte; }).join('');
+ assert.strictEqual(iconv.toEncoding(encoding.strings.untranslatable, enc).toString('binary'), expected); // Only '?' characters.
+ }
+ };
+
+ testsBatch[encoding.name+":"] = tests;
+});
+
+vows.describe("Test Turkish encodings").addBatch(testsBatch).export(module);
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/HISTORY.md b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/HISTORY.md
new file mode 100644
index 0000000..dfc48c2
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/HISTORY.md
@@ -0,0 +1,155 @@
+2.0.5 / 2013-04-26
+------------------
+
+* Close security issue in !!js/function constructor.
+ Big thanks to @nealpoole for security audit.
+
+
+2.0.4 / 2013-04-08
+------------------
+
+* Updated .npmignore to reduce package size
+
+
+2.0.3 / 2013-02-26
+------------------
+
+* Fixed dumping of empty arrays ans objects. ([] and {} instead of null)
+
+
+2.0.2 / 2013-02-15
+------------------
+
+* Fixed input validation: tabs are printable characters.
+
+
+2.0.1 / 2013-02-09
+------------------
+
+* Fixed error, when options not passed to function cass
+
+
+2.0.0 / 2013-02-09
+------------------
+
+* Full rewrite. New architecture. Fast one-stage parsing.
+* Changed custom types API.
+* Added YAML dumper.
+
+
+1.0.3 / 2012-11-05
+------------------
+
+* Fixed utf-8 files loading.
+
+
+1.0.2 / 2012-08-02
+------------------
+
+* Pull out hand-written shims. Use ES5-Shims for old browsers support. See #44.
+* Fix timstamps incorectly parsed in local time when no time part specified.
+
+
+1.0.1 / 2012-07-07
+------------------
+
+* Fixes `TypeError: 'undefined' is not an object` under Safari. Thanks Phuong.
+* Fix timestamps incorrectly parsed in local time. Thanks @caolan. Closes #46.
+
+
+1.0.0 / 2012-07-01
+------------------
+
+* `y`, `yes`, `n`, `no`, `on`, `off` are not converted to Booleans anymore.
+ Fixes #42.
+* `require(filename)` now returns a single document and throws an Error if
+ file contains more than one document.
+* CLI was merged back from js-yaml.bin
+
+
+0.3.7 / 2012-02-28
+------------------
+
+* Fix export of `addConstructor()`. Closes #39.
+
+
+0.3.6 / 2012-02-22
+------------------
+
+* Removed AMD parts - too buggy to use. Need help to rewrite from scratch
+* Removed YUI compressor warning (renamed `double` variable). Closes #40.
+
+
+0.3.5 / 2012-01-10
+------------------
+
+* Workagound for .npmignore fuckup under windows. Thanks to airportyh.
+
+
+0.3.4 / 2011-12-24
+------------------
+
+* Fixes str[] for oldIEs support.
+* Adds better has change support for browserified demo.
+* improves compact output of Error. Closes #33.
+
+
+0.3.3 / 2011-12-20
+------------------
+
+* jsyaml executable moved to separate module.
+* adds `compact` stringification of Errors.
+
+
+0.3.2 / 2011-12-16
+------------------
+
+* Fixes ug with block style scalars. Closes #26.
+* All sources are passing JSLint now.
+* Fixes bug in Safari. Closes #28.
+* Fixes bug in Opers. Closes #29.
+* Improves browser support. Closes #20.
+* Added jsyaml executable.
+* Added !!js/function support. Closes #12.
+
+
+0.3.1 / 2011-11-18
+------------------
+
+* Added AMD support for browserified version.
+* Wrapped browserified js-yaml into closure.
+* Fixed the resolvement of non-specific tags. Closes #17.
+* Added permalinks for online demo YAML snippets. Now we have YPaste service, lol.
+* Added !!js/regexp and !!js/undefined types. Partially solves #12.
+* Fixed !!set mapping.
+* Fixed month parse in dates. Closes #19.
+
+
+0.3.0 / 2011-11-09
+------------------
+
+* Removed JS.Class dependency. Closes #3.
+* Added browserified version. Closes #13.
+* Added live demo of browserified version.
+* Ported some of the PyYAML tests. See #14.
+* Fixed timestamp bug when fraction was given.
+
+
+0.2.2 / 2011-11-06
+------------------
+
+* Fixed crash on docs without ---. Closes #8.
+* Fixed miltiline string parse
+* Fixed tests/comments for using array as key
+
+
+0.2.1 / 2011-11-02
+------------------
+
+* Fixed short file read (<4k). Closes #9.
+
+
+0.2.0 / 2011-11-02
+------------------
+
+* First public release
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/LICENSE b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/LICENSE
new file mode 100644
index 0000000..0f16ee9
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/LICENSE
@@ -0,0 +1,21 @@
+(The MIT License)
+
+Copyright (C) 2011, 2013 by Vitaly Puzrin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/README.md b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/README.md
new file mode 100644
index 0000000..e326d60
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/README.md
@@ -0,0 +1,249 @@
+JS-YAML - YAML 1.2 parser and serializer for JavaScript
+=======================================================
+
+[](http://travis-ci.org/nodeca/js-yaml)
+
+[Online Demo](http://nodeca.github.com/js-yaml/)
+
+
+This is an implementation of [YAML](http://yaml.org/), a human friendly data
+serialization language. Started as [PyYAML](http://pyyaml.org/) port, it was
+completely rewritten from scratch. Now it's very fast, and supports 1.2 spec.
+
+
+Breaking changes in 1.x.x -> 2.0.x
+----------------------------------
+
+If your have not used __custom__ tags or loader classes - no changes needed. Just
+upgrade library and enjoy high parse speed.
+
+In other case, you should rewrite your tag constructors and custom loader
+classes, to conform new schema-based API. See
+[examples](https://github.com/nodeca/js-yaml/tree/master/examples) and
+[wiki](https://github.com/nodeca/js-yaml/wiki) for details.
+Note, that parser internals were completely rewritten.
+
+
+Installation
+------------
+
+### YAML module for node.js
+
+```
+npm install js-yaml
+```
+
+
+### CLI executable
+
+If you want to inspect your YAML files from CLI, install js-yaml globally:
+
+```
+npm install js-yaml -g
+```
+
+#### Usage
+
+```
+usage: js-yaml [-h] [-v] [-c] [-j] [-t] file
+
+Positional arguments:
+ file File with YAML document(s)
+
+Optional arguments:
+ -h, --help Show this help message and exit.
+ -v, --version Show program's version number and exit.
+ -c, --compact Display errors in compact mode
+ -j, --to-json Output a non-funky boring JSON
+ -t, --trace Show stack trace on error
+```
+
+
+### Bundled YAML library for browsers
+
+``` html
+
+
+```
+
+Browser support was done mostly for online demo. If you find any errors - feel
+free to send pull requests with fixes. Also note, that IE and other old browsers
+needs [es5-shims](https://github.com/kriskowal/es5-shim) to operate.
+
+
+API
+---
+
+Here we cover the most 'useful' methods. If you need advanced details (creating
+your own tags), see [wiki](https://github.com/nodeca/js-yaml/wiki) and
+[examples](https://github.com/nodeca/js-yaml/tree/master/examples) for more
+info.
+
+In node.js JS-YAML automatically registers handlers for `.yml` and `.yaml`
+files. You can load them just with `require`. That's mostly equivalent to
+calling `load()` on fetched content of a file. Just with one string!
+
+``` javascript
+require('js-yaml');
+
+// Get document, or throw exception on error
+try {
+ var doc = require('/home/ixti/example.yml');
+ console.log(doc);
+} catch (e) {
+ console.log(e);
+}
+```
+
+
+### load (string [ , options ])
+
+Parses `string` as single YAML document. Returns a JavaScript object or throws
+`YAMLException` on error.
+
+NOTE: This function **does not** understands multi-document sources, it throws
+exception on those.
+
+options:
+
+- `filename` _(default: null)_ - string to be used as a file path in
+ error/warning messages.
+- `strict` _(default - false)_ makes the loader to throw errors instead of
+ warnings.
+- `schema` _(default: `DEFAULT_SCHEMA`)_ - specifies a schema to use.
+
+
+### loadAll (string, iterator [ , options ])
+
+Same as `load()`, but understands multi-document sources and apply `iterator` to
+each document.
+
+``` javascript
+var yaml = require('js-yaml');
+
+yaml.loadAll(data, function (doc) {
+ console.log(doc);
+});
+```
+
+
+### safeLoad (string [ , options ])
+
+Same as `load()` but uses `SAFE_SCHEMA` by default - only recommended tags of
+YAML specification (no JavaScript-specific tags, e.g. `!!js/regexp`).
+
+
+### safeLoadAll (string, iterator [ , options ])
+
+Same as `loadAll()` but uses `SAFE_SCHEMA` by default - only recommended tags of
+YAML specification (no JavaScript-specific tags, e.g. `!!js/regexp`).
+
+
+### dump (object [ , options ])
+
+Serializes `object` as YAML document.
+
+options:
+
+- `indent` _(default: 2)_ - indentation width to use (in spaces).
+- `flowLevel` (default: -1) - specifies level of nesting, when to switch from
+ block to flow style for collections. -1 means block style everwhere
+- `styles` - "tag" => "style" map. Each tag may have own set of styles.
+- `schema` _(default: `DEFAULT_SCHEMA`)_ specifies a schema to use.
+
+styles:
+
+``` none
+!!null
+ "canonical" => "~"
+
+!!int
+ "binary" => "0b1", "0b101010", "0b1110001111010"
+ "octal" => "01", "052", "016172"
+ "decimal" => "1", "42", "7290"
+ "hexadecimal" => "0x1", "0x2A", "0x1C7A"
+
+!!null, !!bool, !!float
+ "lowercase" => "null", "true", "false", ".nan", '.inf'
+ "uppercase" => "NULL", "TRUE", "FALSE", ".NAN", '.INF'
+ "camelcase" => "Null", "True", "False", ".NaN", '.Inf'
+```
+
+By default, !!int uses `decimal`, and !!null, !!bool, !!float use `lowercase`.
+
+
+### safeDump (object [ , options ])
+
+Same as `dump()` but uses `SAFE_SCHEMA` by default - only recommended tags of
+YAML specification (no JavaScript-specific tags, e.g. `!!js/regexp`).
+
+
+Supported YAML types
+--------------------
+
+The list of standard YAML tags and corresponding JavaScipt types. See also
+[YAML tag discussion](http://pyyaml.org/wiki/YAMLTagDiscussion) and
+[YAML types repository](http://yaml.org/type/).
+
+```
+!!null '' # null
+!!bool 'yes' # bool
+!!int '3...' # number
+!!float '3.14...' # number
+!!binary '...base64...' # buffer
+!!timestamp 'YYYY-...' # date
+!!omap [ ... ] # array of key-value pairs
+!!pairs [ ... ] # array or array pairs
+!!set { ... } # array of objects with given keys and null values
+!!str '...' # string
+!!seq [ ... ] # array
+!!map { ... } # object
+```
+
+**JavaScript-specific tags**
+
+```
+!!js/regexp /pattern/gim # RegExp
+!!js/undefined '' # Undefined
+!!js/function 'function () {...}' # Function
+```
+
+
+
+
+## Caveats
+
+Note, that you use arrays or objects as key in JS-YAML. JS do not allows objects
+or array as keys, and stringifies (by calling .toString method) them at the
+moment of adding them.
+
+``` yaml
+---
+? [ foo, bar ]
+: - baz
+? { foo: bar }
+: - baz
+ - baz
+```
+
+``` javascript
+{ "foo,bar": ["baz"], "[object Object]": ["baz", "baz"] }
+```
+
+Also, reading of properties on implicit block mapping keys is not supported yet.
+So, the following YAML document cannot be loaded.
+
+``` yaml
+&anchor foo:
+ foo: bar
+ *anchor: duplicate key
+ baz: bat
+ *anchor: duplicate key
+```
+
+## License
+
+View the [LICENSE](https://github.com/nodeca/js-yaml/blob/master/LICENSE) file
+(MIT).
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/bin/js-yaml.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/bin/js-yaml.js
new file mode 100755
index 0000000..5110a4c
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/bin/js-yaml.js
@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+
+
+'use strict';
+
+
+// stdlib
+var fs = require('fs');
+var util = require('util');
+
+
+// 3rd-party
+var ArgumentParser = require('argparse').ArgumentParser;
+
+
+// internal
+var yaml = require('..');
+
+
+////////////////////////////////////////////////////////////////////////////////
+
+
+var cli = new ArgumentParser({
+ prog: 'js-yaml',
+ version: require('../package.json').version,
+ addHelp: true
+});
+
+
+cli.addArgument(['-c', '--compact'], {
+ help: 'Display errors in compact mode',
+ action: 'storeTrue'
+});
+
+
+cli.addArgument(['-j', '--to-json'], {
+ help: 'Output a non-funky boring JSON',
+ dest: 'json',
+ action: 'storeTrue'
+});
+
+
+cli.addArgument(['-t', '--trace'], {
+ help: 'Show stack trace on error',
+ action: 'storeTrue'
+});
+
+
+cli.addArgument(['file'], {
+ help: 'File to read'
+});
+
+
+////////////////////////////////////////////////////////////////////////////////
+
+
+var options = cli.parseArgs();
+
+
+////////////////////////////////////////////////////////////////////////////////
+
+
+fs.readFile(options.file, 'utf8', function (error, input) {
+ var output, isYaml;
+
+ if (error) {
+ if ('ENOENT' === error.code) {
+ console.error('File not found: ' + options.file);
+ process.exit(2);
+ }
+
+ console.error(
+ options.trace && error.stack ||
+ error.message ||
+ String(error));
+
+ process.exit(1);
+ }
+
+ try {
+ output = JSON.parse(input);
+ isYaml = false;
+ } catch (error) {
+ if (error instanceof SyntaxError) {
+ try {
+ output = [];
+ yaml.loadAll(input, function (doc) { output.push(doc); }, {});
+ isYaml = true;
+
+ if (0 === output.length) {
+ output = null;
+ } else if (1 === output.length) {
+ output = output[0];
+ }
+ } catch (error) {
+ if (options.trace && error.stack) {
+ console.error(error.stack);
+ } else {
+ console.error(error.toString(options.compact));
+ }
+
+ process.exit(1);
+ }
+ } else {
+ console.error(
+ options.trace && error.stack ||
+ error.message ||
+ String(error));
+
+ process.exit(1);
+ }
+ }
+
+ if (isYaml) {
+ if (options.json) {
+ console.log(JSON.stringify(output, null, ' '));
+ } else {
+ console.log("\n" + util.inspect(output, false, 10, true) + "\n");
+ }
+ } else {
+ console.log(yaml.dump(output));
+ }
+
+ process.exit(0);
+});
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/examples/custom_types.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/examples/custom_types.js
new file mode 100644
index 0000000..1cb987c
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/examples/custom_types.js
@@ -0,0 +1,104 @@
+'use strict';
+
+
+var fs = require('fs');
+var path = require('path');
+var util = require('util');
+var yaml = require('../lib/js-yaml');
+
+
+// Let define a couple of classes...
+
+function Point(x, y, z) {
+ this.klass = 'Point';
+ this.x = x;
+ this.y = y;
+ this.z = z;
+}
+
+
+function Space(height, width, points) {
+ if (points) {
+ if (!points.every(function (point) { return point instanceof Point; })) {
+ throw new Error('A non-Point inside a points array!');
+ }
+ }
+
+ this.klass = 'Space';
+ this.height = height;
+ this.width = width;
+ this.points = points;
+}
+
+
+// Let define YAML types to load and dump our Point/Space objects.
+
+var pointYamlType = new yaml.Type('!point', {
+ // The information used to load a Point.
+ loader: {
+ kind: 'array', // It must be an array. (sequence in YAML)
+ resolver: function (object) {
+ // It must contain exactly tree elements.
+ if (3 === object.length) {
+ return new Point(object[0], object[1], object[2]);
+
+ // Otherwise, it is NOT a Point.
+ } else {
+ return yaml.NIL;
+ }
+ }
+ },
+ // The information used to dump a Point.
+ dumper: {
+ kind: 'object', // It must be an object but not an array.
+ instanceOf: Point, // Also, it must be an instance of Point class.
+ representer: function (point) {
+ // And it should be represented in YAML as three-element sequence.
+ return [ point.x, point.y, point.z ];
+ }
+ }
+});
+
+
+var spaceYamlType = new yaml.Type('!space', {
+ loader: {
+ kind: 'object', // 'object' here means 'mapping' in YAML.
+ resolver: function (object) {
+ return new Space(object.height, object.width, object.points);
+ }
+ },
+ dumper: {
+ kind: 'object',
+ instanceOf: Space
+ // The representer is omitted here. So, Space objects will be dumped as is.
+ // That is regular mapping with three key-value pairs but with !space tag.
+ }
+});
+
+
+// After our types are defined, it's time to join them into a schema.
+
+var SPACE_SCHEMA = yaml.Schema.create([ spaceYamlType, pointYamlType ]);
+
+
+// And read a document using that schema.
+
+fs.readFile(path.join(__dirname, 'custom_types.yaml'), 'utf8', function (error, data) {
+ var loaded;
+
+ if (!error) {
+ loaded = yaml.load(data, { schema: SPACE_SCHEMA });
+ console.log(util.inspect(loaded, false, 20, true));
+ } else {
+ console.error(error.stack || error.message || String(error));
+ }
+});
+
+
+// There are some exports to play with this example interactively.
+
+module.exports.Point = Point;
+module.exports.Space = Space;
+module.exports.pointYamlType = pointYamlType;
+module.exports.spaceYamlType = spaceYamlType;
+module.exports.SPACE_SCHEMA = SPACE_SCHEMA;
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/examples/custom_types.yaml b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/examples/custom_types.yaml
new file mode 100644
index 0000000..033134f
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/examples/custom_types.yaml
@@ -0,0 +1,18 @@
+subject: Custom types in JS-YAML
+spaces:
+- !space
+ height: 1000
+ width: 1000
+ points:
+ - !point [ 10, 43, 23 ]
+ - !point [ 165, 0, 50 ]
+ - !point [ 100, 100, 100 ]
+
+- !space
+ height: 64
+ width: 128
+ points:
+ - !point [ 12, 43, 0 ]
+ - !point [ 1, 4, 90 ]
+
+- !space {} # An empty space
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/examples/dumper.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/examples/dumper.js
new file mode 100644
index 0000000..7952b18
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/examples/dumper.js
@@ -0,0 +1,31 @@
+'use strict';
+
+
+var yaml = require('../lib/js-yaml');
+var object = require('./dumper.json');
+
+
+console.log(yaml.dump(object, {
+ flowLevel: 3,
+ styles: {
+ '!!int' : 'hexadecimal',
+ '!!null' : 'camelcase'
+ }
+}));
+
+
+// Output:
+//==============================================================================
+// name: Wizzard
+// level: 0x11
+// sanity: Null
+// inventory:
+// - name: Hat
+// features: [magic, pointed]
+// traits: {}
+// - name: Staff
+// features: []
+// traits: {damage: 0xA}
+// - name: Cloak
+// features: [old]
+// traits: {defence: 0x0, comfort: 0x3}
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/examples/dumper.json b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/examples/dumper.json
new file mode 100644
index 0000000..9f54c05
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/examples/dumper.json
@@ -0,0 +1,22 @@
+{
+ "name" : "Wizzard",
+ "level" : 17,
+ "sanity" : null,
+ "inventory" : [
+ {
+ "name" : "Hat",
+ "features" : [ "magic", "pointed" ],
+ "traits" : {}
+ },
+ {
+ "name" : "Staff",
+ "features" : [],
+ "traits" : { "damage" : 10 }
+ },
+ {
+ "name" : "Cloak",
+ "features" : [ "old" ],
+ "traits" : { "defence" : 0, "comfort" : 3 }
+ }
+ ]
+}
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/examples/sample_document.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/examples/sample_document.js
new file mode 100644
index 0000000..1ce370d
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/examples/sample_document.js
@@ -0,0 +1,15 @@
+'use strict';
+
+
+var inspect = require('util').inspect;
+
+// just require jsyaml
+require('../lib/js-yaml');
+
+
+try {
+ var doc = require(__dirname + '/sample_document.yaml');
+ console.log(inspect(doc, false, 10, true));
+} catch (e) {
+ console.log(e.stack || e.toString());
+}
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/examples/sample_document.yaml b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/examples/sample_document.yaml
new file mode 100644
index 0000000..4479ee9
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/examples/sample_document.yaml
@@ -0,0 +1,197 @@
+---
+# Collection Types #############################################################
+################################################################################
+
+# http://yaml.org/type/map.html -----------------------------------------------#
+
+map:
+ # Unordered set of key: value pairs.
+ Block style: !!map
+ Clark : Evans
+ Ingy : döt Net
+ Oren : Ben-Kiki
+ Flow style: !!map { Clark: Evans, Ingy: döt Net, Oren: Ben-Kiki }
+
+# http://yaml.org/type/omap.html ----------------------------------------------#
+
+omap:
+ # Explicitly typed ordered map (dictionary).
+ Bestiary: !!omap
+ - aardvark: African pig-like ant eater. Ugly.
+ - anteater: South-American ant eater. Two species.
+ - anaconda: South-American constrictor snake. Scaly.
+ # Etc.
+ # Flow style
+ Numbers: !!omap [ one: 1, two: 2, three : 3 ]
+
+# http://yaml.org/type/pairs.html ---------------------------------------------#
+
+pairs:
+ # Explicitly typed pairs.
+ Block tasks: !!pairs
+ - meeting: with team.
+ - meeting: with boss.
+ - break: lunch.
+ - meeting: with client.
+ Flow tasks: !!pairs [ meeting: with team, meeting: with boss ]
+
+# http://yaml.org/type/set.html -----------------------------------------------#
+
+set:
+ # Explicitly typed set.
+ baseball players: !!set
+ ? Mark McGwire
+ ? Sammy Sosa
+ ? Ken Griffey
+ # Flow style
+ baseball teams: !!set { Boston Red Sox, Detroit Tigers, New York Yankees }
+
+# http://yaml.org/type/seq.html -----------------------------------------------#
+
+seq:
+ # Ordered sequence of nodes
+ Block style: !!seq
+ - Mercury # Rotates - no light/dark sides.
+ - Venus # Deadliest. Aptly named.
+ - Earth # Mostly dirt.
+ - Mars # Seems empty.
+ - Jupiter # The king.
+ - Saturn # Pretty.
+ - Uranus # Where the sun hardly shines.
+ - Neptune # Boring. No rings.
+ - Pluto # You call this a planet?
+ Flow style: !!seq [ Mercury, Venus, Earth, Mars, # Rocks
+ Jupiter, Saturn, Uranus, Neptune, # Gas
+ Pluto ] # Overrated
+
+
+# Scalar Types #################################################################
+################################################################################
+
+# http://yaml.org/type/binary.html --------------------------------------------#
+
+binary:
+ canonical: !!binary "\
+ R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOfn515eXvPz7Y6OjuDg4J+fn5\
+ OTk6enp56enmlpaWNjY6Ojo4SEhP/++f/++f/++f/++f/++f/++f/++f/++f/+\
+ +f/++f/++f/++f/++f/++SH+Dk1hZGUgd2l0aCBHSU1QACwAAAAADAAMAAAFLC\
+ AgjoEwnuNAFOhpEMTRiggcz4BNJHrv/zCFcLiwMWYNG84BwwEeECcgggoBADs="
+ generic: !!binary |
+ R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOfn515eXvPz7Y6OjuDg4J+fn5
+ OTk6enp56enmlpaWNjY6Ojo4SEhP/++f/++f/++f/++f/++f/++f/++f/++f/+
+ +f/++f/++f/++f/++f/++SH+Dk1hZGUgd2l0aCBHSU1QACwAAAAADAAMAAAFLC
+ AgjoEwnuNAFOhpEMTRiggcz4BNJHrv/zCFcLiwMWYNG84BwwEeECcgggoBADs=
+ description:
+ The binary value above is a tiny arrow encoded as a gif image.
+
+# http://yaml.org/type/bool.html ----------------------------------------------#
+
+bool:
+ - true
+ - True
+ - TRUE
+ - false
+ - False
+ - FALSE
+
+# http://yaml.org/type/float.html ---------------------------------------------#
+
+float:
+ canonical: 6.8523015e+5
+ exponentioal: 685.230_15e+03
+ fixed: 685_230.15
+ sexagesimal: 190:20:30.15
+ negative infinity: -.inf
+ not a number: .NaN
+
+# http://yaml.org/type/int.html -----------------------------------------------#
+
+int:
+ canonical: 685230
+ decimal: +685_230
+ octal: 02472256
+ hexadecimal: 0x_0A_74_AE
+ binary: 0b1010_0111_0100_1010_1110
+ sexagesimal: 190:20:30
+
+# http://yaml.org/type/merge.html ---------------------------------------------#
+
+merge:
+ - &CENTER { x: 1, y: 2 }
+ - &LEFT { x: 0, y: 2 }
+ - &BIG { r: 10 }
+ - &SMALL { r: 1 }
+
+ # All the following maps are equal:
+
+ - # Explicit keys
+ x: 1
+ y: 2
+ r: 10
+ label: nothing
+
+ - # Merge one map
+ << : *CENTER
+ r: 10
+ label: center
+
+ - # Merge multiple maps
+ << : [ *CENTER, *BIG ]
+ label: center/big
+
+ - # Override
+ << : [ *BIG, *LEFT, *SMALL ]
+ x: 1
+ label: big/left/small
+
+# http://yaml.org/type/null.html ----------------------------------------------#
+
+null:
+ # This mapping has four keys,
+ # one has a value.
+ empty:
+ canonical: ~
+ english: null
+ ~: null key
+ # This sequence has five
+ # entries, two have values.
+ sparse:
+ - ~
+ - 2nd entry
+ -
+ - 4th entry
+ - Null
+
+# http://yaml.org/type/str.html -----------------------------------------------#
+
+string: abcd
+
+# http://yaml.org/type/timestamp.html -----------------------------------------#
+
+timestamp:
+ canonical: 2001-12-15T02:59:43.1Z
+ valid iso8601: 2001-12-14t21:59:43.10-05:00
+ space separated: 2001-12-14 21:59:43.10 -5
+ no time zone (Z): 2001-12-15 2:59:43.10
+ date (00:00:00Z): 2002-12-14
+
+
+# JavaScript Specific Types ####################################################
+################################################################################
+
+# https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/RegExp
+
+regexp:
+ simple: !!js/regexp foobar
+ modifiers: !!js/regexp /foobar/mi
+
+# https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/undefined
+
+undefined: !!js/undefined ~
+
+# https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Function
+
+function: !!js/function >
+ function foobar() {
+ return 'Wow! JS-YAML Rocks!';
+ }
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/index.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/index.js
new file mode 100644
index 0000000..40606dd
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/index.js
@@ -0,0 +1 @@
+module.exports = require('./lib/js-yaml.js');
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml.js
new file mode 100644
index 0000000..a5146a3
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml.js
@@ -0,0 +1,33 @@
+'use strict';
+
+
+var loader = require('./js-yaml/loader');
+var dumper = require('./js-yaml/dumper');
+
+
+function deprecated(name) {
+ return function () {
+ throw new Error('Function ' + name + ' is deprecated and cannot be used.');
+ };
+}
+
+
+module.exports.Type = require('./js-yaml/type');
+module.exports.Schema = require('./js-yaml/schema');
+module.exports.MINIMAL_SCHEMA = require('./js-yaml/schema/minimal');
+module.exports.SAFE_SCHEMA = require('./js-yaml/schema/safe');
+module.exports.DEFAULT_SCHEMA = require('./js-yaml/schema/default');
+module.exports.load = loader.load;
+module.exports.loadAll = loader.loadAll;
+module.exports.safeLoad = loader.safeLoad;
+module.exports.safeLoadAll = loader.safeLoadAll;
+module.exports.dump = dumper.dump;
+module.exports.safeDump = dumper.safeDump;
+module.exports.YAMLException = require('./js-yaml/exception');
+module.exports.scan = deprecated('scan');
+module.exports.parse = deprecated('parse');
+module.exports.compose = deprecated('compose');
+module.exports.addConstructor = deprecated('addConstructor');
+
+
+require('./js-yaml/require');
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/common.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/common.js
new file mode 100644
index 0000000..cc7f824
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/common.js
@@ -0,0 +1,60 @@
+'use strict';
+
+
+var NIL = {};
+
+
+function isNothing(subject) {
+ return (undefined === subject) || (null === subject);
+}
+
+
+function isObject(subject) {
+ return ('object' === typeof subject) && (null !== subject);
+}
+
+
+function toArray(sequence) {
+ if (Array.isArray(sequence)) {
+ return sequence;
+ } else if (isNothing(sequence)) {
+ return [];
+ } else {
+ return [ sequence ];
+ }
+}
+
+
+function extend(target, source) {
+ var index, length, key, sourceKeys;
+
+ if (source) {
+ sourceKeys = Object.keys(source);
+
+ for (index = 0, length = sourceKeys.length; index < length; index += 1) {
+ key = sourceKeys[index];
+ target[key] = source[key];
+ }
+ }
+
+ return target;
+}
+
+
+function repeat(string, count) {
+ var result = '', cycle;
+
+ for (cycle = 0; cycle < count; cycle += 1) {
+ result += string;
+ }
+
+ return result;
+}
+
+
+module.exports.NIL = NIL;
+module.exports.isNothing = isNothing;
+module.exports.isObject = isObject;
+module.exports.toArray = toArray;
+module.exports.repeat = repeat;
+module.exports.extend = extend;
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/dumper.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/dumper.js
new file mode 100644
index 0000000..2385f56
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/dumper.js
@@ -0,0 +1,437 @@
+'use strict';
+
+
+var common = require('./common');
+var NIL = common.NIL;
+var YAMLException = require('./exception');
+var DEFAULT_SCHEMA = require('./schema/default');
+var SAFE_SCHEMA = require('./schema/safe');
+
+
+var _hasOwnProperty = Object.prototype.hasOwnProperty;
+
+
+var CHAR_TAB = 0x09; /* Tab */
+var CHAR_LINE_FEED = 0x0A; /* LF */
+var CHAR_CARRIAGE_RETURN = 0x0D; /* CR */
+var CHAR_SPACE = 0x20; /* Space */
+var CHAR_EXCLAMATION = 0x21; /* ! */
+var CHAR_DOUBLE_QUOTE = 0x22; /* " */
+var CHAR_SHARP = 0x23; /* # */
+var CHAR_PERCENT = 0x25; /* % */
+var CHAR_AMPERSAND = 0x26; /* & */
+var CHAR_SINGLE_QUOTE = 0x27; /* ' */
+var CHAR_ASTERISK = 0x2A; /* * */
+var CHAR_COMMA = 0x2C; /* , */
+var CHAR_MINUS = 0x2D; /* - */
+var CHAR_COLON = 0x3A; /* : */
+var CHAR_GREATER_THAN = 0x3E; /* > */
+var CHAR_QUESTION = 0x3F; /* ? */
+var CHAR_COMMERCIAL_AT = 0x40; /* @ */
+var CHAR_LEFT_SQUARE_BRACKET = 0x5B; /* [ */
+var CHAR_RIGHT_SQUARE_BRACKET = 0x5D; /* ] */
+var CHAR_GRAVE_ACCENT = 0x60; /* ` */
+var CHAR_LEFT_CURLY_BRACKET = 0x7B; /* { */
+var CHAR_VERTICAL_LINE = 0x7C; /* | */
+var CHAR_RIGHT_CURLY_BRACKET = 0x7D; /* } */
+
+
+var ESCAPE_SEQUENCES = {};
+
+ESCAPE_SEQUENCES[0x00] = '\\0';
+ESCAPE_SEQUENCES[0x07] = '\\a';
+ESCAPE_SEQUENCES[0x08] = '\\b';
+ESCAPE_SEQUENCES[0x09] = '\\t';
+ESCAPE_SEQUENCES[0x0A] = '\\n';
+ESCAPE_SEQUENCES[0x0B] = '\\v';
+ESCAPE_SEQUENCES[0x0C] = '\\f';
+ESCAPE_SEQUENCES[0x0D] = '\\r';
+ESCAPE_SEQUENCES[0x1B] = '\\e';
+ESCAPE_SEQUENCES[0x22] = '\\"';
+ESCAPE_SEQUENCES[0x5C] = '\\\\';
+ESCAPE_SEQUENCES[0x85] = '\\N';
+ESCAPE_SEQUENCES[0xA0] = '\\_';
+ESCAPE_SEQUENCES[0x2028] = '\\L';
+ESCAPE_SEQUENCES[0x2029] = '\\P';
+
+
+function kindOf(object) {
+ var kind = typeof object;
+
+ if (null === object) {
+ return 'null';
+ } else if ('number' === kind) {
+ return 0 === object % 1 ? 'integer' : 'float';
+ } else if ('object' === kind && Array.isArray(object)) {
+ return 'array';
+ } else {
+ return kind;
+ }
+}
+
+
+function compileStyleMap(schema, map) {
+ var result, keys, index, length, tag, style, type;
+
+ if (null === map) {
+ return {};
+ }
+
+ result = {};
+ keys = Object.keys(map);
+
+ for (index = 0, length = keys.length; index < length; index += 1) {
+ tag = keys[index];
+ style = String(map[tag]);
+
+ if ('!!' === tag.slice(0, 2)) {
+ tag = 'tag:yaml.org,2002:' + tag.slice(2);
+ }
+
+ type = schema.compiledTypeMap[tag];
+
+ if (type && type.dumper) {
+ if (_hasOwnProperty.call(type.dumper.styleAliases, style)) {
+ style = type.dumper.styleAliases[style];
+ }
+ }
+
+ result[tag] = style;
+ }
+
+ return result;
+}
+
+
+function encodeHex(character) {
+ var string, handle, length;
+
+ string = character.toString(16).toUpperCase();
+
+ if (character <= 0xFF) {
+ handle = 'x';
+ length = 2;
+ } else if (character <= 0xFFFF) {
+ handle = 'u';
+ length = 4;
+ } else if (character <= 0xFFFFFFFF) {
+ handle = 'U';
+ length = 8;
+ } else {
+ throw new YAMLException('code point within a string may not be greater than 0xFFFFFFFF');
+ }
+
+ return '\\' + handle + common.repeat('0', length - string.length) + string;
+}
+
+
+function dump(input, options) {
+ options = options || {};
+
+ var schema = options['schema'] || DEFAULT_SCHEMA,
+ indent = Math.max(1, (options['indent'] || 2)),
+ flowLevel = (common.isNothing(options['flowLevel']) ? -1 : options['flowLevel']),
+ styleMap = compileStyleMap(schema, options['styles'] || null),
+
+ implicitTypes = schema.compiledImplicit,
+ explicitTypes = schema.compiledExplicit,
+
+ kind,
+ tag,
+ result;
+
+ function generateNextLine(level) {
+ return '\n' + common.repeat(' ', indent * level);
+ }
+
+ function testImplicitResolving(object) {
+ var index, length, type;
+
+ for (index = 0, length = implicitTypes.length; index < length; index += 1) {
+ type = implicitTypes[index];
+
+ if (null !== type.loader &&
+ NIL !== type.loader.resolver(object, false)) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ function writeScalar(object) {
+ var isQuoted, checkpoint, position, length, character;
+
+ result = '';
+ isQuoted = false;
+ checkpoint = 0;
+
+ if (0 === object.length ||
+ CHAR_SPACE === object.charCodeAt(0) ||
+ CHAR_SPACE === object.charCodeAt(object.length - 1)) {
+ isQuoted = true;
+ }
+
+ for (position = 0, length = object.length; position < length; position += 1) {
+ character = object.charCodeAt(position);
+
+ if (!isQuoted) {
+ if (CHAR_TAB === character ||
+ CHAR_LINE_FEED === character ||
+ CHAR_CARRIAGE_RETURN === character ||
+ CHAR_COMMA === character ||
+ CHAR_LEFT_SQUARE_BRACKET === character ||
+ CHAR_RIGHT_SQUARE_BRACKET === character ||
+ CHAR_LEFT_CURLY_BRACKET === character ||
+ CHAR_RIGHT_CURLY_BRACKET === character ||
+ CHAR_SHARP === character ||
+ CHAR_AMPERSAND === character ||
+ CHAR_ASTERISK === character ||
+ CHAR_EXCLAMATION === character ||
+ CHAR_VERTICAL_LINE === character ||
+ CHAR_GREATER_THAN === character ||
+ CHAR_SINGLE_QUOTE === character ||
+ CHAR_DOUBLE_QUOTE === character ||
+ CHAR_PERCENT === character ||
+ CHAR_COMMERCIAL_AT === character ||
+ CHAR_GRAVE_ACCENT === character ||
+ CHAR_QUESTION === character ||
+ CHAR_COLON === character ||
+ CHAR_MINUS === character) {
+ isQuoted = true;
+ }
+ }
+
+ if (ESCAPE_SEQUENCES[character] ||
+ !((0x00020 <= character && character <= 0x00007E) ||
+ (0x00085 === character) ||
+ (0x000A0 <= character && character <= 0x00D7FF) ||
+ (0x0E000 <= character && character <= 0x00FFFD) ||
+ (0x10000 <= character && character <= 0x10FFFF))) {
+ result += object.slice(checkpoint, position);
+ result += ESCAPE_SEQUENCES[character] || encodeHex(character);
+ checkpoint = position + 1;
+ isQuoted = true;
+ }
+ }
+
+ if (checkpoint < position) {
+ result += object.slice(checkpoint, position);
+ }
+
+ if (!isQuoted && testImplicitResolving(result)) {
+ isQuoted = true;
+ }
+
+ if (isQuoted) {
+ result = '"' + result + '"';
+ }
+ }
+
+ function writeFlowSequence(level, object) {
+ var _result = '',
+ _tag = tag,
+ index,
+ length;
+
+ for (index = 0, length = object.length; index < length; index += 1) {
+ if (0 !== index) {
+ _result += ', ';
+ }
+
+ writeNode(level, object[index], false, false);
+ _result += result;
+ }
+
+ tag = _tag;
+ result = '[' + _result + ']';
+ }
+
+ function writeBlockSequence(level, object, compact) {
+ var _result = '',
+ _tag = tag,
+ index,
+ length;
+
+ for (index = 0, length = object.length; index < length; index += 1) {
+ if (!compact || 0 !== index) {
+ _result += generateNextLine(level);
+ }
+
+ writeNode(level + 1, object[index], true, true);
+ _result += '- ' + result;
+ }
+
+ tag = _tag;
+ result = _result;
+ }
+
+ function writeFlowMapping(level, object) {
+ var _result = '',
+ _tag = tag,
+ objectKeyList = Object.keys(object),
+ index,
+ length,
+ objectKey,
+ objectValue;
+
+ for (index = 0, length = objectKeyList.length; index < length; index += 1) {
+ if (0 !== index) {
+ _result += ', ';
+ }
+
+ objectKey = objectKeyList[index];
+ objectValue = object[objectKey];
+
+ writeNode(level, objectKey, false, false);
+
+ if (result.length > 1024) {
+ _result += '? ';
+ }
+
+ _result += result + ': ';
+ writeNode(level, objectValue, false, false);
+ _result += result;
+ }
+
+ tag = _tag;
+ result = '{' + _result + '}';
+ }
+
+ function writeBlockMapping(level, object, compact) {
+ var _result = '',
+ _tag = tag,
+ objectKeyList = Object.keys(object),
+ index,
+ length,
+ objectKey,
+ objectValue,
+ explicitPair;
+
+ for (index = 0, length = objectKeyList.length; index < length; index += 1) {
+ if (!compact || 0 !== index) {
+ _result += generateNextLine(level);
+ }
+
+ objectKey = objectKeyList[index];
+ objectValue = object[objectKey];
+
+ writeNode(level + 1, objectKey, true, true);
+ explicitPair = (null !== tag && '?' !== tag && result.length <= 1024);
+
+ if (explicitPair) {
+ _result += '? ';
+ }
+
+ _result += result;
+
+ if (explicitPair) {
+ _result += generateNextLine(level);
+ }
+
+ writeNode(level + 1, objectValue, true, explicitPair);
+ _result += ': ' + result;
+ }
+
+ tag = _tag;
+ result = _result;
+ }
+
+ function detectType(object, explicit) {
+ var _result, typeList, index, length, type, style;
+
+ typeList = explicit ? explicitTypes : implicitTypes;
+ kind = kindOf(object);
+
+ for (index = 0, length = typeList.length; index < length; index += 1) {
+ type = typeList[index];
+
+ if ((null !== type.dumper) &&
+ (null === type.dumper.kind || kind === type.dumper.kind) &&
+ (null === type.dumper.instanceOf || object instanceof type.dumper.instanceOf) &&
+ (null === type.dumper.predicate || type.dumper.predicate(object))) {
+ tag = explicit ? type.tag : '?';
+
+ if (null !== type.dumper.representer) {
+ style = styleMap[type.tag] || type.dumper.defaultStyle;
+
+ if ('function' === typeof type.dumper.representer) {
+ _result = type.dumper.representer(object, style);
+ } else if (_hasOwnProperty.call(type.dumper.representer, style)) {
+ _result = type.dumper.representer[style](object, style);
+ } else {
+ throw new YAMLException('!<' + type.tag + '> tag resolver accepts not "' + style + '" style');
+ }
+
+ if (NIL !== _result) {
+ kind = kindOf(_result);
+ result = _result;
+ } else {
+ if (explicit) {
+ throw new YAMLException('cannot represent an object of !<' + type.tag + '> type');
+ } else {
+ continue;
+ }
+ }
+ }
+
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ function writeNode(level, object, block, compact) {
+ tag = null;
+ result = object;
+
+ if (!detectType(object, false)) {
+ detectType(object, true);
+ }
+
+ if (block) {
+ block = (0 > flowLevel || flowLevel > level);
+ }
+
+ if ((null !== tag && '?' !== tag) || (2 !== indent && level > 0)) {
+ compact = false;
+ }
+
+ if ('object' === kind) {
+ if (block && (0 !== Object.keys(result).length)) {
+ writeBlockMapping(level, result, compact);
+ } else {
+ writeFlowMapping(level, result);
+ }
+ } else if ('array' === kind) {
+ if (block && (0 !== result.length)) {
+ writeBlockSequence(level, result, compact);
+ } else {
+ writeFlowSequence(level, result);
+ }
+ } else if ('string' === kind) {
+ if ('?' !== tag) {
+ writeScalar(result);
+ }
+ } else {
+ throw new YAMLException('unacceptabe kind of an object to dump (' + kind + ')');
+ }
+
+ if (null !== tag && '?' !== tag) {
+ result = '!<' + tag + '> ' + result;
+ }
+ }
+
+ writeNode(0, input, true, true);
+ return result + '\n';
+}
+
+
+function safeDump(input, options) {
+ return dump(input, common.extend({ schema: SAFE_SCHEMA }, options));
+}
+
+
+module.exports.dump = dump;
+module.exports.safeDump = safeDump;
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/exception.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/exception.js
new file mode 100644
index 0000000..479ba88
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/exception.js
@@ -0,0 +1,25 @@
+'use strict';
+
+
+function YAMLException(reason, mark) {
+ this.name = 'YAMLException';
+ this.reason = reason;
+ this.mark = mark;
+ this.message = this.toString(false);
+}
+
+
+YAMLException.prototype.toString = function toString(compact) {
+ var result;
+
+ result = 'JS-YAML: ' + (this.reason || '(unknown reason)');
+
+ if (!compact && this.mark) {
+ result += ' ' + this.mark.toString();
+ }
+
+ return result;
+};
+
+
+module.exports = YAMLException;
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/loader.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/loader.js
new file mode 100644
index 0000000..bdc71d1
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/loader.js
@@ -0,0 +1,1549 @@
+'use strict';
+
+
+var common = require('./common');
+var YAMLException = require('./exception');
+var Mark = require('./mark');
+var NIL = common.NIL;
+var SAFE_SCHEMA = require('./schema/safe');
+var DEFAULT_SCHEMA = require('./schema/default');
+
+
+var _hasOwnProperty = Object.prototype.hasOwnProperty;
+
+
+var KIND_STRING = 'string';
+var KIND_ARRAY = 'array';
+var KIND_OBJECT = 'object';
+
+
+var CONTEXT_FLOW_IN = 1;
+var CONTEXT_FLOW_OUT = 2;
+var CONTEXT_BLOCK_IN = 3;
+var CONTEXT_BLOCK_OUT = 4;
+
+
+var CHOMPING_CLIP = 1;
+var CHOMPING_STRIP = 2;
+var CHOMPING_KEEP = 3;
+
+
+var CHAR_TAB = 0x09; /* Tab */
+var CHAR_LINE_FEED = 0x0A; /* LF */
+var CHAR_CARRIAGE_RETURN = 0x0D; /* CR */
+var CHAR_SPACE = 0x20; /* Space */
+var CHAR_EXCLAMATION = 0x21; /* ! */
+var CHAR_DOUBLE_QUOTE = 0x22; /* " */
+var CHAR_SHARP = 0x23; /* # */
+var CHAR_PERCENT = 0x25; /* % */
+var CHAR_AMPERSAND = 0x26; /* & */
+var CHAR_SINGLE_QUOTE = 0x27; /* ' */
+var CHAR_ASTERISK = 0x2A; /* * */
+var CHAR_PLUS = 0x2B; /* + */
+var CHAR_COMMA = 0x2C; /* , */
+var CHAR_MINUS = 0x2D; /* - */
+var CHAR_DOT = 0x2E; /* . */
+var CHAR_SLASH = 0x2F; /* / */
+var CHAR_DIGIT_ZERO = 0x30; /* 0 */
+var CHAR_DIGIT_ONE = 0x31; /* 1 */
+var CHAR_DIGIT_NINE = 0x39; /* 9 */
+var CHAR_COLON = 0x3A; /* : */
+var CHAR_LESS_THAN = 0x3C; /* < */
+var CHAR_GREATER_THAN = 0x3E; /* > */
+var CHAR_QUESTION = 0x3F; /* ? */
+var CHAR_COMMERCIAL_AT = 0x40; /* @ */
+var CHAR_CAPITAL_A = 0x41; /* A */
+var CHAR_CAPITAL_F = 0x46; /* F */
+var CHAR_CAPITAL_L = 0x4C; /* L */
+var CHAR_CAPITAL_N = 0x4E; /* N */
+var CHAR_CAPITAL_P = 0x50; /* P */
+var CHAR_CAPITAL_U = 0x55; /* U */
+var CHAR_LEFT_SQUARE_BRACKET = 0x5B; /* [ */
+var CHAR_BACKSLASH = 0x5C; /* \ */
+var CHAR_RIGHT_SQUARE_BRACKET = 0x5D; /* ] */
+var CHAR_UNDERSCORE = 0x5F; /* _ */
+var CHAR_GRAVE_ACCENT = 0x60; /* ` */
+var CHAR_SMALL_A = 0x61; /* a */
+var CHAR_SMALL_B = 0x62; /* b */
+var CHAR_SMALL_E = 0x65; /* e */
+var CHAR_SMALL_F = 0x66; /* f */
+var CHAR_SMALL_N = 0x6E; /* n */
+var CHAR_SMALL_R = 0x72; /* r */
+var CHAR_SMALL_T = 0x74; /* t */
+var CHAR_SMALL_U = 0x75; /* u */
+var CHAR_SMALL_V = 0x76; /* v */
+var CHAR_SMALL_X = 0x78; /* x */
+var CHAR_LEFT_CURLY_BRACKET = 0x7B; /* { */
+var CHAR_VERTICAL_LINE = 0x7C; /* | */
+var CHAR_RIGHT_CURLY_BRACKET = 0x7D; /* } */
+
+
+var SIMPLE_ESCAPE_SEQUENCES = {};
+
+SIMPLE_ESCAPE_SEQUENCES[CHAR_DIGIT_ZERO] = '\x00';
+SIMPLE_ESCAPE_SEQUENCES[CHAR_SMALL_A] = '\x07';
+SIMPLE_ESCAPE_SEQUENCES[CHAR_SMALL_B] = '\x08';
+SIMPLE_ESCAPE_SEQUENCES[CHAR_SMALL_T] = '\x09';
+SIMPLE_ESCAPE_SEQUENCES[CHAR_TAB] = '\x09';
+SIMPLE_ESCAPE_SEQUENCES[CHAR_SMALL_N] = '\x0A';
+SIMPLE_ESCAPE_SEQUENCES[CHAR_SMALL_V] = '\x0B';
+SIMPLE_ESCAPE_SEQUENCES[CHAR_SMALL_F] = '\x0C';
+SIMPLE_ESCAPE_SEQUENCES[CHAR_SMALL_R] = '\x0D';
+SIMPLE_ESCAPE_SEQUENCES[CHAR_SMALL_E] = '\x1B';
+SIMPLE_ESCAPE_SEQUENCES[CHAR_SPACE] = ' ';
+SIMPLE_ESCAPE_SEQUENCES[CHAR_DOUBLE_QUOTE] = '\x22';
+SIMPLE_ESCAPE_SEQUENCES[CHAR_SLASH] = '/';
+SIMPLE_ESCAPE_SEQUENCES[CHAR_BACKSLASH] = '\x5C';
+SIMPLE_ESCAPE_SEQUENCES[CHAR_CAPITAL_N] = '\x85';
+SIMPLE_ESCAPE_SEQUENCES[CHAR_UNDERSCORE] = '\xA0';
+SIMPLE_ESCAPE_SEQUENCES[CHAR_CAPITAL_L] = '\u2028';
+SIMPLE_ESCAPE_SEQUENCES[CHAR_CAPITAL_P] = '\u2029';
+
+
+var HEXADECIMAL_ESCAPE_SEQUENCES = {};
+
+HEXADECIMAL_ESCAPE_SEQUENCES[CHAR_SMALL_X] = 2;
+HEXADECIMAL_ESCAPE_SEQUENCES[CHAR_SMALL_U] = 4;
+HEXADECIMAL_ESCAPE_SEQUENCES[CHAR_CAPITAL_U] = 8;
+
+
+var PATTERN_NON_PRINTABLE = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x84\x86-\x9F\uD800-\uDFFF\uFFFE\uFFFF]/;
+var PATTERN_NON_ASCII_LINE_BREAKS = /[\x85\u2028\u2029]/;
+var PATTERN_FLOW_INDICATORS = /[,\[\]\{\}]/;
+var PATTERN_TAG_HANDLE = /^(?:!|!!|![a-z\-]+!)$/i;
+var PATTERN_TAG_URI = /^(?:!|[^,\[\]\{\}])(?:%[0-9a-f]{2}|[0-9a-z\-#;\/\?:@&=\+\$,_\.!~\*'\(\)\[\]])*$/i;
+
+
+function loadAll(input, output, options) {
+ options = options || {};
+
+ var filename = options['filename'] || null,
+ schema = options['schema'] || DEFAULT_SCHEMA,
+ resolve = options['resolve'] || true,
+ validate = options['validate'] || true,
+ strict = options['strict'] || false,
+ legacy = options['legacy'] || false,
+
+ directiveHandlers = {},
+ implicitTypes = schema.compiledImplicit,
+ typeMap = schema.compiledTypeMap,
+
+ length = input.length,
+ position = 0,
+ line = 0,
+ lineStart = 0,
+ lineIndent = 0,
+ character = input.charCodeAt(position),
+
+ version,
+ checkLineBreaks,
+ tagMap,
+ anchorMap,
+ tag,
+ anchor,
+ kind,
+ result;
+
+ function generateError(message) {
+ return new YAMLException(
+ message,
+ new Mark(filename, input, position, line, (position - lineStart)));
+ }
+
+ function throwError(message) {
+ throw generateError(message);
+ }
+
+ function throwWarning(message) {
+ var error = generateError(message);
+
+ if (strict) {
+ throw error;
+ } else {
+ console.warn(error.toString());
+ }
+ }
+
+ directiveHandlers['YAML'] = function handleYamlDirective(name, args) {
+ var match, major, minor;
+
+ if (null !== version) {
+ throwError('duplication of %YAML directive');
+ }
+
+ if (1 !== args.length) {
+ throwError('YAML directive accepts exactly one argument');
+ }
+
+ match = /^([0-9]+)\.([0-9]+)$/.exec(args[0]);
+
+ if (null === match) {
+ throwError('ill-formed argument of the YAML directive');
+ }
+
+ major = parseInt(match[1], 10);
+ minor = parseInt(match[2], 10);
+
+ if (1 !== major) {
+ throwError('unacceptable YAML version of the document');
+ }
+
+ version = args[0];
+ checkLineBreaks = (minor < 2);
+
+ if (1 !== minor && 2 !== minor) {
+ throwWarning('unsupported YAML version of the document');
+ }
+ };
+
+ directiveHandlers['TAG'] = function handleTagDirective(name, args) {
+ var handle, prefix;
+
+ if (2 !== args.length) {
+ throwError('TAG directive accepts exactly two arguments');
+ }
+
+ handle = args[0];
+ prefix = args[1];
+
+ if (!PATTERN_TAG_HANDLE.test(handle)) {
+ throwError('ill-formed tag handle (first argument) of the TAG directive');
+ }
+
+ if (_hasOwnProperty.call(tagMap, handle)) {
+ throwError('there is a previously declared suffix for "' + handle + '" tag handle');
+ }
+
+ if (!PATTERN_TAG_URI.test(prefix)) {
+ throwError('ill-formed tag prefix (second argument) of the TAG directive');
+ }
+
+ tagMap[handle] = prefix;
+ };
+
+ function captureSegment(start, end, checkJson) {
+ var _position, _length, _character, _result;
+
+ if (start < end) {
+ _result = input.slice(start, end);
+
+ if (checkJson && validate) {
+ for (_position = 0, _length = _result.length;
+ _position < _length;
+ _position += 1) {
+ _character = _result.charCodeAt(_position);
+ if (!(0x09 === _character ||
+ 0x20 <= _character && _character <= 0x10FFFF)) {
+ throwError('expected valid JSON character');
+ }
+ }
+ }
+
+ result += _result;
+ }
+ }
+
+ function mergeMappings(destination, source) {
+ var sourceKeys, key, index, quantity;
+
+ if (!common.isObject(source)) {
+ throwError('cannot merge mappings; the provided source object is unacceptable');
+ }
+
+ sourceKeys = Object.keys(source);
+
+ for (index = 0, quantity = sourceKeys.length; index < quantity; index += 1) {
+ key = sourceKeys[index];
+
+ if (!_hasOwnProperty.call(destination, key)) {
+ destination[key] = source[key];
+ }
+ }
+ }
+
+ function storeMappingPair(_result, keyTag, keyNode, valueNode) {
+ var index, quantity;
+
+ keyNode = String(keyNode);
+
+ if (null === _result) {
+ _result = {};
+ }
+
+ if ('tag:yaml.org,2002:merge' === keyTag) {
+ if (Array.isArray(valueNode)) {
+ for (index = 0, quantity = valueNode.length; index < quantity; index += 1) {
+ mergeMappings(_result, valueNode[index]);
+ }
+ } else {
+ mergeMappings(_result, valueNode);
+ }
+ } else {
+ _result[keyNode] = valueNode;
+ }
+
+ return _result;
+ }
+
+ function readLineBreak() {
+ if (CHAR_LINE_FEED === character) {
+ position += 1;
+ } else if (CHAR_CARRIAGE_RETURN === character) {
+ if (CHAR_LINE_FEED === input.charCodeAt(position + 1)) {
+ position += 2;
+ } else {
+ position += 1;
+ }
+ } else {
+ throwError('a line break is expected');
+ }
+
+ line += 1;
+ lineStart = position;
+ character = input.charCodeAt(position);
+ }
+
+ function skipSeparationSpace(allowComments, checkIndent) {
+ var lineBreaks = 0;
+
+ while (position < length) {
+ while (CHAR_SPACE === character || CHAR_TAB === character) {
+ character = input.charCodeAt(++position);
+ }
+
+ if (allowComments && CHAR_SHARP === character) {
+ do { character = input.charCodeAt(++position); }
+ while (position < length &&
+ CHAR_LINE_FEED !== character &&
+ CHAR_CARRIAGE_RETURN !== character);
+ }
+
+ if (CHAR_LINE_FEED === character || CHAR_CARRIAGE_RETURN === character) {
+ readLineBreak();
+ lineBreaks += 1;
+ lineIndent = 0;
+
+ while (CHAR_SPACE === character) {
+ lineIndent += 1;
+ character = input.charCodeAt(++position);
+ }
+
+ if (lineIndent < checkIndent) {
+ throwWarning('deficient indentation');
+ }
+ } else {
+ break;
+ }
+ }
+
+ return lineBreaks;
+ }
+
+ function testDocumentSeparator() {
+ var _position, _character;
+
+ if (position === lineStart &&
+ (CHAR_MINUS === character || CHAR_DOT === character) &&
+ input.charCodeAt(position + 1) === character &&
+ input.charCodeAt(position + 2) === character) {
+
+ _position = position + 3;
+ _character = input.charCodeAt(_position);
+
+ if (_position >= length ||
+ CHAR_SPACE === _character ||
+ CHAR_TAB === _character ||
+ CHAR_LINE_FEED === _character ||
+ CHAR_CARRIAGE_RETURN === _character) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ function writeFoldedLines(count) {
+ if (1 === count) {
+ result += ' ';
+ } else if (count > 1) {
+ result += common.repeat('\n', count - 1);
+ }
+ }
+
+ function readPlainScalar(nodeIndent, withinFlowCollection) {
+ var preceding,
+ following,
+ captureStart,
+ captureEnd,
+ hasPendingContent,
+ _line,
+ _lineStart,
+ _lineIndent,
+ _kind = kind,
+ _result = result;
+
+ if (CHAR_SPACE === character ||
+ CHAR_TAB === character ||
+ CHAR_LINE_FEED === character ||
+ CHAR_CARRIAGE_RETURN === character ||
+ CHAR_COMMA === character ||
+ CHAR_LEFT_SQUARE_BRACKET === character ||
+ CHAR_RIGHT_SQUARE_BRACKET === character ||
+ CHAR_LEFT_CURLY_BRACKET === character ||
+ CHAR_RIGHT_CURLY_BRACKET === character ||
+ CHAR_SHARP === character ||
+ CHAR_AMPERSAND === character ||
+ CHAR_ASTERISK === character ||
+ CHAR_EXCLAMATION === character ||
+ CHAR_VERTICAL_LINE === character ||
+ CHAR_GREATER_THAN === character ||
+ CHAR_SINGLE_QUOTE === character ||
+ CHAR_DOUBLE_QUOTE === character ||
+ CHAR_PERCENT === character ||
+ CHAR_COMMERCIAL_AT === character ||
+ CHAR_GRAVE_ACCENT === character) {
+ return false;
+ }
+
+ if (CHAR_QUESTION === character ||
+ CHAR_MINUS === character) {
+ following = input.charCodeAt(position + 1);
+
+ if (CHAR_SPACE === following ||
+ CHAR_TAB === following ||
+ CHAR_LINE_FEED === following ||
+ CHAR_CARRIAGE_RETURN === following ||
+ withinFlowCollection &&
+ (CHAR_COMMA === following ||
+ CHAR_LEFT_SQUARE_BRACKET === following ||
+ CHAR_RIGHT_SQUARE_BRACKET === following ||
+ CHAR_LEFT_CURLY_BRACKET === following ||
+ CHAR_RIGHT_CURLY_BRACKET === following)) {
+ return false;
+ }
+ }
+
+ kind = KIND_STRING;
+ result = '';
+ captureStart = captureEnd = position;
+ hasPendingContent = false;
+
+ while (position < length) {
+ if (CHAR_COLON === character) {
+ following = input.charCodeAt(position + 1);
+
+ if (CHAR_SPACE === following ||
+ CHAR_TAB === following ||
+ CHAR_LINE_FEED === following ||
+ CHAR_CARRIAGE_RETURN === following ||
+ withinFlowCollection &&
+ (CHAR_COMMA === following ||
+ CHAR_LEFT_SQUARE_BRACKET === following ||
+ CHAR_RIGHT_SQUARE_BRACKET === following ||
+ CHAR_LEFT_CURLY_BRACKET === following ||
+ CHAR_RIGHT_CURLY_BRACKET === following)) {
+ break;
+ }
+
+ } else if (CHAR_SHARP === character) {
+ preceding = input.charCodeAt(position - 1);
+
+ if (CHAR_SPACE === preceding ||
+ CHAR_TAB === preceding ||
+ CHAR_LINE_FEED === preceding ||
+ CHAR_CARRIAGE_RETURN === preceding) {
+ break;
+ }
+
+ } else if ((position === lineStart && testDocumentSeparator()) ||
+ withinFlowCollection &&
+ (CHAR_COMMA === character ||
+ CHAR_LEFT_SQUARE_BRACKET === character ||
+ CHAR_RIGHT_SQUARE_BRACKET === character ||
+ CHAR_LEFT_CURLY_BRACKET === character ||
+ CHAR_RIGHT_CURLY_BRACKET === character)) {
+ break;
+
+ } else if (CHAR_LINE_FEED === character ||
+ CHAR_CARRIAGE_RETURN === character) {
+ _line = line;
+ _lineStart = lineStart;
+ _lineIndent = lineIndent;
+ skipSeparationSpace(false, -1);
+
+ if (lineIndent >= nodeIndent) {
+ hasPendingContent = true;
+ continue;
+ } else {
+ position = captureEnd;
+ line = _line;
+ lineStart = _lineStart;
+ lineIndent = _lineIndent;
+ character = input.charCodeAt(position);
+ break;
+ }
+ }
+
+ if (hasPendingContent) {
+ captureSegment(captureStart, captureEnd, false);
+ writeFoldedLines(line - _line);
+ captureStart = captureEnd = position;
+ hasPendingContent = false;
+ }
+
+ if (CHAR_SPACE !== character && CHAR_TAB !== character) {
+ captureEnd = position + 1;
+ }
+
+ character = input.charCodeAt(++position);
+ }
+
+ captureSegment(captureStart, captureEnd, false);
+
+ if (result) {
+ return true;
+ } else {
+ kind = _kind;
+ result = _result;
+ return false;
+ }
+ }
+
+ function readSingleQuotedScalar(nodeIndent) {
+ var captureStart, captureEnd;
+
+ if (CHAR_SINGLE_QUOTE !== character) {
+ return false;
+ }
+
+ kind = KIND_STRING;
+ result = '';
+ character = input.charCodeAt(++position);
+ captureStart = captureEnd = position;
+
+ while (position < length) {
+ if (CHAR_SINGLE_QUOTE === character) {
+ captureSegment(captureStart, position, true);
+ character = input.charCodeAt(++position);
+
+ if (CHAR_SINGLE_QUOTE === character) {
+ captureStart = captureEnd = position;
+ character = input.charCodeAt(++position);
+ } else {
+ return true;
+ }
+
+ } else if (CHAR_LINE_FEED === character ||
+ CHAR_CARRIAGE_RETURN === character) {
+ captureSegment(captureStart, captureEnd, true);
+ writeFoldedLines(skipSeparationSpace(false, nodeIndent));
+ captureStart = captureEnd = position;
+ character = input.charCodeAt(position);
+
+ } else if (position === lineStart && testDocumentSeparator()) {
+ throwError('unexpected end of the document within a single quoted scalar');
+
+ } else {
+ character = input.charCodeAt(++position);
+ captureEnd = position;
+ }
+ }
+
+ throwError('unexpected end of the stream within a single quoted scalar');
+ }
+
+ function readDoubleQuotedScalar(nodeIndent) {
+ var captureStart,
+ captureEnd,
+ hexLength,
+ hexIndex,
+ hexOffset,
+ hexResult;
+
+ if (CHAR_DOUBLE_QUOTE !== character) {
+ return false;
+ }
+
+ kind = KIND_STRING;
+ result = '';
+ character = input.charCodeAt(++position);
+ captureStart = captureEnd = position;
+
+ while (position < length) {
+ if (CHAR_DOUBLE_QUOTE === character) {
+ captureSegment(captureStart, position, true);
+ character = input.charCodeAt(++position);
+ return true;
+
+ } else if (CHAR_BACKSLASH === character) {
+ captureSegment(captureStart, position, true);
+ character = input.charCodeAt(++position);
+
+ if (CHAR_LINE_FEED === character ||
+ CHAR_CARRIAGE_RETURN === character) {
+ skipSeparationSpace(false, nodeIndent);
+
+ } else if (SIMPLE_ESCAPE_SEQUENCES[character]) {
+ result += SIMPLE_ESCAPE_SEQUENCES[character];
+ character = input.charCodeAt(++position);
+
+ } else if (HEXADECIMAL_ESCAPE_SEQUENCES[character]) {
+ hexLength = HEXADECIMAL_ESCAPE_SEQUENCES[character];
+ hexResult = 0;
+
+ for (hexIndex = 1; hexIndex <= hexLength; hexIndex += 1) {
+ hexOffset = (hexLength - hexIndex) * 4;
+ character = input.charCodeAt(++position);
+
+ if (CHAR_DIGIT_ZERO <= character && character <= CHAR_DIGIT_NINE) {
+ hexResult |= (character - CHAR_DIGIT_ZERO) << hexOffset;
+
+ } else if (CHAR_CAPITAL_A <= character && character <= CHAR_CAPITAL_F) {
+ hexResult |= (character - CHAR_CAPITAL_A + 10) << hexOffset;
+
+ } else if (CHAR_SMALL_A <= character && character <= CHAR_SMALL_F) {
+ hexResult |= (character - CHAR_SMALL_A + 10) << hexOffset;
+
+ } else {
+ throwError('expected hexadecimal character');
+ }
+ }
+
+ result += String.fromCharCode(hexResult);
+ character = input.charCodeAt(++position);
+
+ } else {
+ throwError('unknown escape sequence');
+ }
+
+ captureStart = captureEnd = position;
+
+ } else if (CHAR_LINE_FEED === character ||
+ CHAR_CARRIAGE_RETURN === character) {
+ captureSegment(captureStart, captureEnd, true);
+ writeFoldedLines(skipSeparationSpace(false, nodeIndent));
+ captureStart = captureEnd = position;
+ character = input.charCodeAt(position);
+
+ } else if (position === lineStart && testDocumentSeparator()) {
+ throwError('unexpected end of the document within a double quoted scalar');
+
+ } else {
+ character = input.charCodeAt(++position);
+ captureEnd = position;
+ }
+ }
+
+ throwError('unexpected end of the stream within a double quoted scalar');
+ }
+
+ function readFlowCollection(nodeIndent) {
+ var readNext = true,
+ _line,
+ _tag = tag,
+ _result,
+ following,
+ terminator,
+ isPair,
+ isExplicitPair,
+ isMapping,
+ keyNode,
+ keyTag,
+ valueNode;
+
+ switch (character) {
+ case CHAR_LEFT_SQUARE_BRACKET:
+ terminator = CHAR_RIGHT_SQUARE_BRACKET;
+ isMapping = false;
+ _result = [];
+ break;
+
+ case CHAR_LEFT_CURLY_BRACKET:
+ terminator = CHAR_RIGHT_CURLY_BRACKET;
+ isMapping = true;
+ _result = {};
+ break;
+
+ default:
+ return false;
+ }
+
+ if (null !== anchor) {
+ anchorMap[anchor] = _result;
+ }
+
+ character = input.charCodeAt(++position);
+
+ while (position < length) {
+ skipSeparationSpace(true, nodeIndent);
+
+ if (character === terminator) {
+ character = input.charCodeAt(++position);
+ tag = _tag;
+ kind = isMapping ? KIND_OBJECT : KIND_ARRAY;
+ result = _result;
+ return true;
+ } else if (!readNext) {
+ throwError('missed comma between flow collection entries');
+ }
+
+ keyTag = keyNode = valueNode = null;
+ isPair = isExplicitPair = false;
+
+ if (CHAR_QUESTION === character) {
+ following = input.charCodeAt(position + 1);
+
+ if (CHAR_SPACE === following ||
+ CHAR_TAB === following ||
+ CHAR_LINE_FEED === following ||
+ CHAR_CARRIAGE_RETURN === following) {
+ isPair = isExplicitPair = true;
+ position += 1;
+ character = following;
+ skipSeparationSpace(true, nodeIndent);
+ }
+ }
+
+ _line = line;
+ composeNode(nodeIndent, CONTEXT_FLOW_IN, false, true);
+ keyTag = tag;
+ keyNode = result;
+
+ if ((isExplicitPair || line === _line) && CHAR_COLON === character) {
+ isPair = true;
+ character = input.charCodeAt(++position);
+ skipSeparationSpace(true, nodeIndent);
+ composeNode(nodeIndent, CONTEXT_FLOW_IN, false, true);
+ valueNode = result;
+ }
+
+ if (isMapping) {
+ storeMappingPair(_result, keyTag, keyNode, valueNode);
+ } else if (isPair) {
+ _result.push(storeMappingPair(null, keyTag, keyNode, valueNode));
+ } else {
+ _result.push(keyNode);
+ }
+
+ skipSeparationSpace(true, nodeIndent);
+
+ if (CHAR_COMMA === character) {
+ readNext = true;
+ character = input.charCodeAt(++position);
+ } else {
+ readNext = false;
+ }
+ }
+
+ throwError('unexpected end of the stream within a flow collection');
+ }
+
+ function readBlockScalar(nodeIndent) {
+ var captureStart,
+ folding,
+ chomping = CHOMPING_CLIP,
+ detectedIndent = false,
+ textIndent = nodeIndent,
+ emptyLines = -1;
+
+ switch (character) {
+ case CHAR_VERTICAL_LINE:
+ folding = false;
+ break;
+
+ case CHAR_GREATER_THAN:
+ folding = true;
+ break;
+
+ default:
+ return false;
+ }
+
+ kind = KIND_STRING;
+ result = '';
+
+ while (position < length) {
+ character = input.charCodeAt(++position);
+
+ if (CHAR_PLUS === character || CHAR_MINUS === character) {
+ if (CHOMPING_CLIP === chomping) {
+ chomping = (CHAR_PLUS === character) ? CHOMPING_KEEP : CHOMPING_STRIP;
+ } else {
+ throwError('repeat of a chomping mode identifier');
+ }
+
+ } else if (CHAR_DIGIT_ZERO <= character && character <= CHAR_DIGIT_NINE) {
+ if (CHAR_DIGIT_ZERO === character) {
+ throwError('bad explicit indentation width of a block scalar; it cannot be less than one');
+ } else if (!detectedIndent) {
+ textIndent = nodeIndent + (character - CHAR_DIGIT_ONE);
+ detectedIndent = true;
+ } else {
+ throwError('repeat of an indentation width identifier');
+ }
+
+ } else {
+ break;
+ }
+ }
+
+ if (CHAR_SPACE === character || CHAR_TAB === character) {
+ do { character = input.charCodeAt(++position); }
+ while (CHAR_SPACE === character || CHAR_TAB === character);
+
+ if (CHAR_SHARP === character) {
+ do { character = input.charCodeAt(++position); }
+ while (position < length &&
+ CHAR_LINE_FEED !== character &&
+ CHAR_CARRIAGE_RETURN !== character);
+ }
+ }
+
+ while (position < length) {
+ readLineBreak();
+ lineIndent = 0;
+
+ while ((!detectedIndent || lineIndent < textIndent) &&
+ (CHAR_SPACE === character)) {
+ lineIndent += 1;
+ character = input.charCodeAt(++position);
+ }
+
+ if (!detectedIndent && lineIndent > textIndent) {
+ textIndent = lineIndent;
+ }
+
+ if (CHAR_LINE_FEED === character || CHAR_CARRIAGE_RETURN === character) {
+ emptyLines += 1;
+ continue;
+ }
+
+ // End of the scalar. Perform the chomping.
+ if (lineIndent < textIndent) {
+ if (CHOMPING_KEEP === chomping) {
+ result += common.repeat('\n', emptyLines + 1);
+ } else if (CHOMPING_CLIP === chomping) {
+ result += '\n';
+ }
+ break;
+ }
+
+ detectedIndent = true;
+
+ if (folding) {
+ if (CHAR_SPACE === character || CHAR_TAB === character) {
+ result += common.repeat('\n', emptyLines + 1);
+ emptyLines = 1;
+ } else if (0 === emptyLines) {
+ result += ' ';
+ emptyLines = 0;
+ } else {
+ result += common.repeat('\n', emptyLines);
+ emptyLines = 0;
+ }
+ } else {
+ result += common.repeat('\n', emptyLines + 1);
+ emptyLines = 0;
+ }
+
+ captureStart = position;
+
+ do { character = input.charCodeAt(++position); }
+ while (position < length &&
+ CHAR_LINE_FEED !== character &&
+ CHAR_CARRIAGE_RETURN !== character);
+
+ captureSegment(captureStart, position, false);
+ }
+
+ return true;
+ }
+
+ function readBlockSequence(nodeIndent) {
+ var _line,
+ _tag = tag,
+ _result = [],
+ following,
+ detected = false;
+
+ if (null !== anchor) {
+ anchorMap[anchor] = _result;
+ }
+
+ while (position < length) {
+ if (CHAR_MINUS !== character) {
+ break;
+ }
+
+ following = input.charCodeAt(position + 1);
+
+ if (CHAR_SPACE !== following &&
+ CHAR_TAB !== following &&
+ CHAR_LINE_FEED !== following &&
+ CHAR_CARRIAGE_RETURN !== following) {
+ break;
+ }
+
+ detected = true;
+ position += 1;
+ character = following;
+
+ if (skipSeparationSpace(true, -1)) {
+ if (lineIndent <= nodeIndent) {
+ _result.push(null);
+ continue;
+ }
+ }
+
+ _line = line;
+ composeNode(nodeIndent, CONTEXT_BLOCK_IN, false, true);
+ _result.push(result);
+ skipSeparationSpace(true, -1);
+
+ if ((line === _line || lineIndent > nodeIndent) && position < length) {
+ throwError('bad indentation of a sequence entry');
+ } else if (lineIndent < nodeIndent) {
+ break;
+ }
+ }
+
+ if (detected) {
+ tag = _tag;
+ kind = KIND_ARRAY;
+ result = _result;
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ function readBlockMapping(nodeIndent) {
+ var following,
+ allowCompact,
+ _line,
+ _tag = tag,
+ _result = {},
+ keyTag = null,
+ keyNode = null,
+ valueNode = null,
+ atExplicitKey = false,
+ detected = false;
+
+ if (null !== anchor) {
+ anchorMap[anchor] = _result;
+ }
+
+ while (position < length) {
+ following = input.charCodeAt(position + 1);
+ _line = line; // Save the current line.
+
+ if ((CHAR_QUESTION === character ||
+ CHAR_COLON === character) &&
+ (CHAR_SPACE === following ||
+ CHAR_TAB === following ||
+ CHAR_LINE_FEED === following ||
+ CHAR_CARRIAGE_RETURN === following)) {
+
+ if (CHAR_QUESTION === character) {
+ if (atExplicitKey) {
+ storeMappingPair(_result, keyTag, keyNode, null);
+ keyTag = keyNode = valueNode = null;
+ }
+
+ detected = true;
+ atExplicitKey = true;
+ allowCompact = true;
+
+ } else if (atExplicitKey) {
+ // i.e. CHAR_COLON === character after the explicit key.
+ atExplicitKey = false;
+ allowCompact = true;
+
+ } else {
+ throwError('incomplete explicit mapping pair; a key node is missed');
+ }
+
+ position += 1;
+ character = following;
+
+ } else if (composeNode(nodeIndent, CONTEXT_FLOW_OUT, false, true)) {
+ if (line === _line) {
+ // TODO: Remove this cycle when the flow readers will consume
+ // trailing whitespaces like the block readers.
+ while (CHAR_SPACE === character ||
+ CHAR_TAB === character) {
+ character = input.charCodeAt(++position);
+ }
+
+ if (CHAR_COLON === character) {
+ character = input.charCodeAt(++position);
+
+ if (CHAR_SPACE !== character &&
+ CHAR_TAB !== character &&
+ CHAR_LINE_FEED !== character &&
+ CHAR_CARRIAGE_RETURN !== character) {
+ throwError('a whitespace character is expected after the key-value separator within a block mapping');
+ }
+
+ if (atExplicitKey) {
+ storeMappingPair(_result, keyTag, keyNode, null);
+ keyTag = keyNode = valueNode = null;
+ }
+
+ detected = true;
+ atExplicitKey = false;
+ allowCompact = false;
+ keyTag = tag;
+ keyNode = result;
+
+ } else if (detected) {
+ throwError('can not read an implicit mapping pair; a colon is missed');
+
+ } else {
+ tag = _tag;
+ return true; // Keep the result of `composeNode`.
+ }
+
+ } else if (detected) {
+ throwError('can not read a block mapping entry; a multiline key may not be an implicit key');
+
+ } else {
+ tag = _tag;
+ return true; // Keep the result of `composeNode`.
+ }
+
+ } else {
+ break;
+ }
+
+ if (line === _line || lineIndent > nodeIndent) {
+ if (composeNode(nodeIndent, CONTEXT_BLOCK_OUT, true, allowCompact)) {
+ if (atExplicitKey) {
+ keyNode = result;
+ } else {
+ valueNode = result;
+ }
+ }
+
+ if (!atExplicitKey) {
+ storeMappingPair(_result, keyTag, keyNode, valueNode);
+ keyTag = keyNode = valueNode = null;
+ }
+
+ // TODO: It is needed only for flow node readers. It should be removed
+ // when the flow readers will consume trailing whitespaces as well as
+ // the block readers.
+ skipSeparationSpace(true, -1);
+ }
+
+ if (lineIndent > nodeIndent && position < length) {
+ throwError('bad indentation of a mapping entry');
+ } else if (lineIndent < nodeIndent) {
+ break;
+ }
+ }
+
+ if (atExplicitKey) {
+ storeMappingPair(_result, keyTag, keyNode, null);
+ }
+
+ if (detected) {
+ tag = _tag;
+ kind = KIND_OBJECT;
+ result = _result;
+ }
+
+ return detected;
+ }
+
+ function readTagProperty() {
+ var _position,
+ isVerbatim = false,
+ isNamed = false,
+ tagHandle,
+ tagName;
+
+ if (CHAR_EXCLAMATION !== character) {
+ return false;
+ }
+
+ if (null !== tag) {
+ throwError('duplication of a tag property');
+ }
+
+ character = input.charCodeAt(++position);
+
+ if (CHAR_LESS_THAN === character) {
+ isVerbatim = true;
+ character = input.charCodeAt(++position);
+
+ } else if (CHAR_EXCLAMATION === character) {
+ isNamed = true;
+ tagHandle = '!!';
+ character = input.charCodeAt(++position);
+
+ } else {
+ tagHandle = '!';
+ }
+
+ _position = position;
+
+ if (isVerbatim) {
+ do { character = input.charCodeAt(++position); }
+ while (position < length && CHAR_GREATER_THAN !== character);
+
+ if (position < length) {
+ tagName = input.slice(_position, position);
+ character = input.charCodeAt(++position);
+ } else {
+ throwError('unexpected end of the stream within a verbatim tag');
+ }
+ } else {
+ while (position < length &&
+ CHAR_SPACE !== character &&
+ CHAR_TAB !== character &&
+ CHAR_LINE_FEED !== character &&
+ CHAR_CARRIAGE_RETURN !== character) {
+
+ if (CHAR_EXCLAMATION === character) {
+ if (!isNamed) {
+ tagHandle = input.slice(_position - 1, position + 1);
+
+ if (validate && !PATTERN_TAG_HANDLE.test(tagHandle)) {
+ throwError('named tag handle cannot contain such characters');
+ }
+
+ isNamed = true;
+ _position = position + 1;
+ } else {
+ throwError('tag suffix cannot contain exclamation marks');
+ }
+ }
+
+ character = input.charCodeAt(++position);
+ }
+
+ tagName = input.slice(_position, position);
+
+ if (validate && PATTERN_FLOW_INDICATORS.test(tagName)) {
+ throwError('tag suffix cannot contain flow indicator characters');
+ }
+ }
+
+ if (validate && tagName && !PATTERN_TAG_URI.test(tagName)) {
+ throwError('tag name cannot contain such characters: ' + tagName);
+ }
+
+ if (isVerbatim) {
+ tag = tagName;
+
+ } else if (_hasOwnProperty.call(tagMap, tagHandle)) {
+ tag = tagMap[tagHandle] + tagName;
+
+ } else if ('!' === tagHandle) {
+ tag = '!' + tagName;
+
+ } else if ('!!' === tagHandle) {
+ tag = 'tag:yaml.org,2002:' + tagName;
+
+ } else {
+ throwError('undeclared tag handle "' + tagHandle + '"');
+ }
+
+ return true;
+ }
+
+ function readAnchorProperty() {
+ var _position;
+
+ if (CHAR_AMPERSAND !== character) {
+ return false;
+ }
+
+ if (null !== anchor) {
+ throwError('duplication of an anchor property');
+ }
+
+ character = input.charCodeAt(++position);
+ _position = position;
+
+ while (position < length &&
+ CHAR_SPACE !== character &&
+ CHAR_TAB !== character &&
+ CHAR_LINE_FEED !== character &&
+ CHAR_CARRIAGE_RETURN !== character &&
+ CHAR_COMMA !== character &&
+ CHAR_LEFT_SQUARE_BRACKET !== character &&
+ CHAR_RIGHT_SQUARE_BRACKET !== character &&
+ CHAR_LEFT_CURLY_BRACKET !== character &&
+ CHAR_RIGHT_CURLY_BRACKET !== character) {
+ character = input.charCodeAt(++position);
+ }
+
+ if (position === _position) {
+ throwError('name of an anchor node must contain at least one character');
+ }
+
+ anchor = input.slice(_position, position);
+ return true;
+ }
+
+ function readAlias() {
+ var _position, alias;
+
+ if (CHAR_ASTERISK !== character) {
+ return false;
+ }
+
+ character = input.charCodeAt(++position);
+ _position = position;
+
+ while (position < length &&
+ CHAR_SPACE !== character &&
+ CHAR_TAB !== character &&
+ CHAR_LINE_FEED !== character &&
+ CHAR_CARRIAGE_RETURN !== character &&
+ CHAR_COMMA !== character &&
+ CHAR_LEFT_SQUARE_BRACKET !== character &&
+ CHAR_RIGHT_SQUARE_BRACKET !== character &&
+ CHAR_LEFT_CURLY_BRACKET !== character &&
+ CHAR_RIGHT_CURLY_BRACKET !== character) {
+ character = input.charCodeAt(++position);
+ }
+
+ if (position === _position) {
+ throwError('name of an alias node must contain at least one character');
+ }
+
+ alias = input.slice(_position, position);
+
+ if (!anchorMap.hasOwnProperty(alias)) {
+ throwError('unidentified alias "' + alias + '"');
+ }
+
+ result = anchorMap[alias];
+ skipSeparationSpace(true, -1);
+ return true;
+ }
+
+ function composeNode(parentIndent, nodeContext, allowToSeek, allowCompact) {
+ var allowBlockStyles,
+ allowBlockScalars,
+ allowBlockCollections,
+ atNewLine = false,
+ isIndented = true,
+ hasContent = false,
+ typeIndex,
+ typeQuantity,
+ type,
+ typeLoader,
+ flowIndent,
+ blockIndent,
+ _result;
+
+ tag = null;
+ anchor = null;
+ kind = null;
+ result = null;
+
+ allowBlockStyles = allowBlockScalars = allowBlockCollections =
+ CONTEXT_BLOCK_OUT === nodeContext ||
+ CONTEXT_BLOCK_IN === nodeContext;
+
+ if (allowToSeek) {
+ if (skipSeparationSpace(true, -1)) {
+ atNewLine = true;
+
+ if (lineIndent === parentIndent) {
+ isIndented = false;
+
+ } else if (lineIndent > parentIndent) {
+ isIndented = true;
+
+ } else {
+ return false;
+ }
+ }
+ }
+
+ if (isIndented) {
+ while (readTagProperty() || readAnchorProperty()) {
+ if (skipSeparationSpace(true, -1)) {
+ atNewLine = true;
+
+ if (lineIndent > parentIndent) {
+ isIndented = true;
+ allowBlockCollections = allowBlockStyles;
+
+ } else if (lineIndent === parentIndent) {
+ isIndented = false;
+ allowBlockCollections = allowBlockStyles;
+
+ } else {
+ return true;
+ }
+ } else {
+ allowBlockCollections = false;
+ }
+ }
+ }
+
+ if (allowBlockCollections) {
+ allowBlockCollections = atNewLine || allowCompact;
+ }
+
+ if (isIndented || CONTEXT_BLOCK_OUT === nodeContext) {
+ if (CONTEXT_FLOW_IN === nodeContext || CONTEXT_FLOW_OUT === nodeContext) {
+ flowIndent = parentIndent;
+ } else {
+ flowIndent = parentIndent + 1;
+ }
+
+ blockIndent = position - lineStart;
+
+ if (isIndented) {
+ if (allowBlockCollections &&
+ (readBlockSequence(blockIndent) ||
+ readBlockMapping(blockIndent)) ||
+ readFlowCollection(flowIndent)) {
+ hasContent = true;
+ } else {
+ if ((allowBlockScalars && readBlockScalar(flowIndent)) ||
+ readSingleQuotedScalar(flowIndent) ||
+ readDoubleQuotedScalar(flowIndent)) {
+ hasContent = true;
+
+ } else if (readAlias()) {
+ hasContent = true;
+
+ if (null !== tag || null !== anchor) {
+ throwError('alias node should not have any properties');
+ }
+
+ } else if (readPlainScalar(flowIndent, CONTEXT_FLOW_IN === nodeContext)) {
+ hasContent = true;
+
+ if (null === tag) {
+ tag = '?';
+ }
+ }
+
+ if (null !== anchor) {
+ anchorMap[anchor] = result;
+ }
+ }
+ } else {
+ hasContent = allowBlockCollections && readBlockSequence(blockIndent);
+ }
+ }
+
+ if (null !== tag && '!' !== tag) {
+ if ('?' === tag) {
+ if (resolve) {
+ for (typeIndex = 0, typeQuantity = implicitTypes.length;
+ typeIndex < typeQuantity;
+ typeIndex += 1) {
+ type = implicitTypes[typeIndex];
+
+ // Implicit resolving is not allowed for non-scalar types, and '?'
+ // non-specific tag is only assigned to plain scalars. So, it isn't
+ // needed to check for 'kind' conformity.
+ _result = type.loader.resolver(result, false);
+
+ if (NIL !== _result) {
+ tag = type.tag;
+ result = _result;
+ break;
+ }
+ }
+ }
+ } else if (_hasOwnProperty.call(typeMap, tag)) {
+ typeLoader = typeMap[tag].loader;
+
+ if (null !== result && typeLoader.kind !== kind) {
+ throwError('unacceptable node kind for !<' + tag + '> tag; it should be "' + typeLoader.kind + '", not "' + kind + '"');
+ }
+
+ if (typeLoader.resolver) {
+ _result = typeLoader.resolver(result, true);
+
+ if (NIL !== _result) {
+ result = _result;
+ } else {
+ throwError('cannot resolve a node with !<' + tag + '> explicit tag');
+ }
+ }
+ } else {
+ throwWarning('unknown tag !<' + tag + '>');
+ }
+ }
+
+ return null !== tag || null !== anchor || hasContent;
+ }
+
+ function readDocument() {
+ var documentStart = position,
+ _position,
+ directiveName,
+ directiveArgs,
+ hasDirectives = false;
+
+ version = null;
+ checkLineBreaks = legacy;
+ tagMap = {};
+ anchorMap = {};
+
+ while (position < length) {
+ skipSeparationSpace(true, -1);
+
+ if (lineIndent > 0 || CHAR_PERCENT !== character) {
+ break;
+ }
+
+ hasDirectives = true;
+ character = input.charCodeAt(++position);
+ _position = position;
+
+ while (position < length &&
+ CHAR_SPACE !== character &&
+ CHAR_TAB !== character &&
+ CHAR_LINE_FEED !== character &&
+ CHAR_CARRIAGE_RETURN !== character) {
+ character = input.charCodeAt(++position);
+ }
+
+ directiveName = input.slice(_position, position);
+ directiveArgs = [];
+
+ if (directiveName.length < 1) {
+ throwError('directive name must not be less than one character in length');
+ }
+
+ while (position < length) {
+ while (CHAR_SPACE === character || CHAR_TAB === character) {
+ character = input.charCodeAt(++position);
+ }
+
+ if (CHAR_SHARP === character) {
+ do { character = input.charCodeAt(++position); }
+ while (position < length &&
+ CHAR_LINE_FEED !== character &&
+ CHAR_CARRIAGE_RETURN !== character);
+ break;
+ }
+
+ if (CHAR_LINE_FEED === character || CHAR_CARRIAGE_RETURN === character) {
+ break;
+ }
+
+ _position = position;
+
+ while (position < length &&
+ CHAR_SPACE !== character &&
+ CHAR_TAB !== character &&
+ CHAR_LINE_FEED !== character &&
+ CHAR_CARRIAGE_RETURN !== character) {
+ character = input.charCodeAt(++position);
+ }
+
+ directiveArgs.push(input.slice(_position, position));
+ }
+
+ if (position < length) {
+ readLineBreak();
+ }
+
+ if (_hasOwnProperty.call(directiveHandlers, directiveName)) {
+ directiveHandlers[directiveName](directiveName, directiveArgs);
+ } else {
+ throwWarning('unknown document directive "' + directiveName + '"');
+ }
+ }
+
+ skipSeparationSpace(true, -1);
+
+ if (0 === lineIndent &&
+ CHAR_MINUS === character &&
+ CHAR_MINUS === input.charCodeAt(position + 1) &&
+ CHAR_MINUS === input.charCodeAt(position + 2)) {
+ position += 3;
+ character = input.charCodeAt(position);
+ skipSeparationSpace(true, -1);
+
+ } else if (hasDirectives) {
+ throwError('directives end mark is expected');
+ }
+
+ composeNode(lineIndent - 1, CONTEXT_BLOCK_OUT, false, true);
+ skipSeparationSpace(true, -1);
+
+ if (validate && checkLineBreaks &&
+ PATTERN_NON_ASCII_LINE_BREAKS.test(input.slice(documentStart, position))) {
+ throwWarning('non-ASCII line breaks are interpreted as content');
+ }
+
+ output(result);
+
+ if (position === lineStart && testDocumentSeparator()) {
+ if (CHAR_DOT === character) {
+ position += 3;
+ character = input.charCodeAt(position);
+ skipSeparationSpace(true, -1);
+ }
+ return;
+ }
+
+ if (position < length) {
+ throwError('end of the stream or a document separator is expected');
+ } else {
+ return;
+ }
+ }
+
+ if (validate && PATTERN_NON_PRINTABLE.test(input)) {
+ throwError('the stream contains non-printable characters');
+ }
+
+ while (CHAR_SPACE === character) {
+ lineIndent += 1;
+ character = input.charCodeAt(++position);
+ }
+
+ while (position < length) {
+ readDocument();
+ }
+}
+
+
+function load(input, options) {
+ var result = null, received = false;
+
+ function callback(data) {
+ if (!received) {
+ result = data;
+ received = true;
+ } else {
+ throw new YAMLException('expected a single document in the stream, but found more');
+ }
+ }
+
+ loadAll(input, callback, options);
+
+ return result;
+}
+
+
+function safeLoadAll(input, output, options) {
+ loadAll(input, output, common.extend({ schema: SAFE_SCHEMA }, options));
+}
+
+
+function safeLoad(input, options) {
+ return load(input, common.extend({ schema: SAFE_SCHEMA }, options));
+}
+
+
+module.exports.loadAll = loadAll;
+module.exports.load = load;
+module.exports.safeLoadAll = safeLoadAll;
+module.exports.safeLoad = safeLoad;
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/mark.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/mark.js
new file mode 100644
index 0000000..bfe279b
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/mark.js
@@ -0,0 +1,78 @@
+'use strict';
+
+
+var common = require('./common');
+
+
+function Mark(name, buffer, position, line, column) {
+ this.name = name;
+ this.buffer = buffer;
+ this.position = position;
+ this.line = line;
+ this.column = column;
+}
+
+
+Mark.prototype.getSnippet = function getSnippet(indent, maxLength) {
+ var head, start, tail, end, snippet;
+
+ if (!this.buffer) {
+ return null;
+ }
+
+ indent = indent || 4;
+ maxLength = maxLength || 75;
+
+ head = '';
+ start = this.position;
+
+ while (start > 0 && -1 === '\x00\r\n\x85\u2028\u2029'.indexOf(this.buffer.charAt(start - 1))) {
+ start -= 1;
+ if (this.position - start > (maxLength / 2 - 1)) {
+ head = ' ... ';
+ start += 5;
+ break;
+ }
+ }
+
+ tail = '';
+ end = this.position;
+
+ while (end < this.buffer.length && -1 === '\x00\r\n\x85\u2028\u2029'.indexOf(this.buffer.charAt(end))) {
+ end += 1;
+ if (end - this.position > (maxLength / 2 - 1)) {
+ tail = ' ... ';
+ end -= 5;
+ break;
+ }
+ }
+
+ snippet = this.buffer.slice(start, end);
+
+ return common.repeat(' ', indent) + head + snippet + tail + '\n' +
+ common.repeat(' ', indent + this.position - start + head.length) + '^';
+};
+
+
+Mark.prototype.toString = function toString(compact) {
+ var snippet, where = '';
+
+ if (this.name) {
+ where += 'in "' + this.name + '" ';
+ }
+
+ where += 'at line ' + (this.line + 1) + ', column ' + (this.column + 1);
+
+ if (!compact) {
+ snippet = this.getSnippet();
+
+ if (snippet) {
+ where += ':\n' + snippet;
+ }
+ }
+
+ return where;
+};
+
+
+module.exports = Mark;
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/require.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/require.js
new file mode 100644
index 0000000..47b77e3
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/require.js
@@ -0,0 +1,23 @@
+'use strict';
+
+
+var fs = require('fs');
+var loader = require('./loader');
+
+
+function yamlRequireHandler(module, filename) {
+ var content = fs.readFileSync(filename, 'utf8');
+
+ // fill in documents
+ module.exports = loader.load(content, { filename: filename });
+}
+
+// register require extensions only if we're on node.js
+// hack for browserify
+if (undefined !== require.extensions) {
+ require.extensions['.yml'] = yamlRequireHandler;
+ require.extensions['.yaml'] = yamlRequireHandler;
+}
+
+
+module.exports = require;
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/schema.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/schema.js
new file mode 100644
index 0000000..ce21391
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/schema.js
@@ -0,0 +1,103 @@
+'use strict';
+
+
+var common = require('./common');
+var YAMLException = require('./exception');
+var Type = require('./type');
+
+
+function compileList(schema, name, result) {
+ var exclude = [];
+
+ schema.include.forEach(function (includedSchema) {
+ result = compileList(includedSchema, name, result);
+ });
+
+ schema[name].forEach(function (currentType) {
+ result.forEach(function (previousType, previousIndex) {
+ if (previousType.tag === currentType.tag) {
+ exclude.push(previousIndex);
+ }
+ });
+
+ result.push(currentType);
+ });
+
+ return result.filter(function (type, index) {
+ return -1 === exclude.indexOf(index);
+ });
+}
+
+
+function compileMap(/* lists... */) {
+ var result = {}, index, length;
+
+ function collectType(type) {
+ result[type.tag] = type;
+ }
+
+ for (index = 0, length = arguments.length; index < length; index += 1) {
+ arguments[index].forEach(collectType);
+ }
+
+ return result;
+}
+
+
+function Schema(definition) {
+ this.include = definition.include || [];
+ this.implicit = definition.implicit || [];
+ this.explicit = definition.explicit || [];
+
+ this.implicit.forEach(function (type) {
+ if (null !== type.loader && 'string' !== type.loader.kind) {
+ throw new YAMLException('There is a non-scalar type in the implicit list of a schema. Implicit resolving of such types is not supported.');
+ }
+ });
+
+ this.compiledImplicit = compileList(this, 'implicit', []);
+ this.compiledExplicit = compileList(this, 'explicit', []);
+ this.compiledTypeMap = compileMap(this.compiledImplicit, this.compiledExplicit);
+}
+
+
+Schema.DEFAULT = null;
+
+
+Schema.create = function createSchema() {
+ var schemas, types;
+
+ switch (arguments.length) {
+ case 1:
+ schemas = Schema.DEFAULT;
+ types = arguments[0];
+ break;
+
+ case 2:
+ schemas = arguments[0];
+ types = arguments[1];
+ break;
+
+ default:
+ throw new YAMLException('Wrong number of arguments for Schema.create function');
+ }
+
+ schemas = common.toArray(schemas);
+ types = common.toArray(types);
+
+ if (!schemas.every(function (schema) { return schema instanceof Schema; })) {
+ throw new YAMLException('Specified list of super schemas (or a single Schema object) contains a non-Schema object.');
+ }
+
+ if (!types.every(function (type) { return type instanceof Type; })) {
+ throw new YAMLException('Specified list of YAML types (or a single Type object) contains a non-Type object.');
+ }
+
+ return new Schema({
+ include: schemas,
+ explicit: types
+ });
+};
+
+
+module.exports = Schema;
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/schema/default.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/schema/default.js
new file mode 100644
index 0000000..71bb3fc
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/schema/default.js
@@ -0,0 +1,16 @@
+'use strict';
+
+
+var Schema = require('../schema');
+
+
+module.exports = Schema.DEFAULT = new Schema({
+ include: [
+ require('./safe')
+ ],
+ explicit: [
+ require('../type/js/undefined'),
+ require('../type/js/regexp'),
+ require('../type/js/function')
+ ]
+});
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/schema/minimal.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/schema/minimal.js
new file mode 100644
index 0000000..7a6ebbe
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/schema/minimal.js
@@ -0,0 +1,13 @@
+'use strict';
+
+
+var Schema = require('../schema');
+
+
+module.exports = new Schema({
+ explicit: [
+ require('../type/str'),
+ require('../type/seq'),
+ require('../type/map')
+ ]
+});
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/schema/safe.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/schema/safe.js
new file mode 100644
index 0000000..856b7c4
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/schema/safe.js
@@ -0,0 +1,25 @@
+'use strict';
+
+
+var Schema = require('../schema');
+
+
+module.exports = new Schema({
+ include: [
+ require('./minimal')
+ ],
+ implicit: [
+ require('../type/null'),
+ require('../type/bool'),
+ require('../type/int'),
+ require('../type/float'),
+ require('../type/timestamp'),
+ require('../type/merge')
+ ],
+ explicit: [
+ require('../type/binary'),
+ require('../type/omap'),
+ require('../type/pairs'),
+ require('../type/set')
+ ]
+});
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/type.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/type.js
new file mode 100644
index 0000000..e0124f2
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/type.js
@@ -0,0 +1,82 @@
+'use strict';
+
+
+var YAMLException = require('./exception');
+
+
+// TODO: Add tag format check.
+function Type(tag, options) {
+ options = options || {};
+
+ this.tag = tag;
+ this.loader = options['loader'] || null;
+ this.dumper = options['dumper'] || null;
+
+ if (null === this.loader && null === this.dumper) {
+ throw new YAMLException('Incomplete YAML type definition. "loader" or "dumper" setting must be specified.');
+ }
+
+ if (null !== this.loader) {
+ this.loader = new Type.Loader(this.loader);
+ }
+
+ if (null !== this.dumper) {
+ this.dumper = new Type.Dumper(this.dumper);
+ }
+}
+
+
+Type.Loader = function TypeLoader(options) {
+ options = options || {};
+
+ this.kind = options['kind'] || null;
+ this.resolver = options['resolver'] || null;
+
+ if ('string' !== this.kind &&
+ 'array' !== this.kind &&
+ 'object' !== this.kind) {
+ throw new YAMLException('Unacceptable "kind" setting of a type loader.');
+ }
+};
+
+
+function compileAliases(map) {
+ var result = {};
+
+ if (null !== map) {
+ Object.keys(map).forEach(function (style) {
+ map[style].forEach(function (alias) {
+ result[String(alias)] = style;
+ });
+ });
+ }
+
+ return result;
+}
+
+
+Type.Dumper = function TypeDumper(options) {
+ options = options || {};
+
+ this.kind = options['kind'] || null;
+ this.defaultStyle = options['defaultStyle'] || null;
+ this.instanceOf = options['instanceOf'] || null;
+ this.predicate = options['predicate'] || null;
+ this.representer = options['representer'] || null;
+ this.styleAliases = compileAliases(options['styleAliases'] || null);
+
+ if ('undefined' !== this.kind &&
+ 'null' !== this.kind &&
+ 'boolean' !== this.kind &&
+ 'integer' !== this.kind &&
+ 'float' !== this.kind &&
+ 'string' !== this.kind &&
+ 'array' !== this.kind &&
+ 'object' !== this.kind &&
+ 'function' !== this.kind) {
+ throw new YAMLException('Unacceptable "kind" setting of a type dumper.');
+ }
+};
+
+
+module.exports = Type;
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/type/binary.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/type/binary.js
new file mode 100644
index 0000000..37b4bc7
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/type/binary.js
@@ -0,0 +1,118 @@
+// Modified from:
+// https://raw.github.com/kanaka/noVNC/d890e8640f20fba3215ba7be8e0ff145aeb8c17c/include/base64.js
+
+'use strict';
+
+
+var NodeBuffer = require('buffer').Buffer; // A trick for browserified version.
+var common = require('../common');
+var NIL = common.NIL;
+var Type = require('../type');
+
+
+
+var BASE64_PADDING = '=';
+
+var BASE64_BINTABLE = [
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63,
+ 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, 0, -1, -1,
+ -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
+ 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1,
+ -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
+ 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1
+];
+
+var BASE64_CHARTABLE =
+ 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.split('');
+
+
+function resolveYamlBinary(object /*, explicit*/) {
+ var value, code, idx = 0, result = [], leftbits, leftdata;
+
+ leftbits = 0; // number of bits decoded, but yet to be appended
+ leftdata = 0; // bits decoded, but yet to be appended
+
+ // Convert one by one.
+ for (idx = 0; idx < object.length; idx += 1) {
+ code = object.charCodeAt(idx);
+ value = BASE64_BINTABLE[code & 0x7F];
+
+ // Skip LF(NL) || CR
+ if (0x0A !== code && 0x0D !== code) {
+ // Fail on illegal characters
+ if (-1 === value) {
+ return NIL;
+ }
+
+ // Collect data into leftdata, update bitcount
+ leftdata = (leftdata << 6) | value;
+ leftbits += 6;
+
+ // If we have 8 or more bits, append 8 bits to the result
+ if (leftbits >= 8) {
+ leftbits -= 8;
+
+ // Append if not padding.
+ if (BASE64_PADDING !== object.charAt(idx)) {
+ result.push((leftdata >> leftbits) & 0xFF);
+ }
+
+ leftdata &= (1 << leftbits) - 1;
+ }
+ }
+ }
+
+ // If there are any bits left, the base64 string was corrupted
+ if (leftbits) {
+ return NIL;
+ } else {
+ return new NodeBuffer(result);
+ }
+}
+
+
+function representYamlBinary(object /*, style*/) {
+ var result = '', index, length, rest;
+
+ // Convert every three bytes to 4 ASCII characters.
+ for (index = 0, length = object.length - 2; index < length; index += 3) {
+ result += BASE64_CHARTABLE[object[index + 0] >> 2];
+ result += BASE64_CHARTABLE[((object[index + 0] & 0x03) << 4) + (object[index + 1] >> 4)];
+ result += BASE64_CHARTABLE[((object[index + 1] & 0x0F) << 2) + (object[index + 2] >> 6)];
+ result += BASE64_CHARTABLE[object[index + 2] & 0x3F];
+ }
+
+ rest = object.length % 3;
+
+ // Convert the remaining 1 or 2 bytes, padding out to 4 characters.
+ if (0 !== rest) {
+ index = object.length - rest;
+ result += BASE64_CHARTABLE[object[index + 0] >> 2];
+
+ if (2 === rest) {
+ result += BASE64_CHARTABLE[((object[index + 0] & 0x03) << 4) + (object[index + 1] >> 4)];
+ result += BASE64_CHARTABLE[(object[index + 1] & 0x0F) << 2];
+ result += BASE64_PADDING;
+ } else {
+ result += BASE64_CHARTABLE[(object[index + 0] & 0x03) << 4];
+ result += BASE64_PADDING + BASE64_PADDING;
+ }
+ }
+
+ return result;
+}
+
+
+module.exports = new Type('tag:yaml.org,2002:binary', {
+ loader: {
+ kind: 'string',
+ resolver: resolveYamlBinary
+ },
+ dumper: {
+ kind: 'object',
+ instanceOf: NodeBuffer,
+ representer: representYamlBinary
+ }
+});
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/type/bool.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/type/bool.js
new file mode 100644
index 0000000..987a9e6
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/type/bool.js
@@ -0,0 +1,74 @@
+'use strict';
+
+
+var NIL = require('../common').NIL;
+var Type = require('../type');
+
+
+var YAML_IMPLICIT_BOOLEAN_MAP = {
+ 'true' : true,
+ 'True' : true,
+ 'TRUE' : true,
+ 'false' : false,
+ 'False' : false,
+ 'FALSE' : false
+};
+
+var YAML_EXPLICIT_BOOLEAN_MAP = {
+ 'true' : true,
+ 'True' : true,
+ 'TRUE' : true,
+ 'false' : false,
+ 'False' : false,
+ 'FALSE' : false,
+ 'y' : true,
+ 'Y' : true,
+ 'yes' : true,
+ 'Yes' : true,
+ 'YES' : true,
+ 'n' : false,
+ 'N' : false,
+ 'no' : false,
+ 'No' : false,
+ 'NO' : false,
+ 'on' : true,
+ 'On' : true,
+ 'ON' : true,
+ 'off' : false,
+ 'Off' : false,
+ 'OFF' : false
+};
+
+
+function resolveYamlBoolean(object, explicit) {
+ if (explicit) {
+ if (YAML_EXPLICIT_BOOLEAN_MAP.hasOwnProperty(object)) {
+ return YAML_EXPLICIT_BOOLEAN_MAP[object];
+ } else {
+ return NIL;
+ }
+ } else {
+ if (YAML_IMPLICIT_BOOLEAN_MAP.hasOwnProperty(object)) {
+ return YAML_IMPLICIT_BOOLEAN_MAP[object];
+ } else {
+ return NIL;
+ }
+ }
+}
+
+
+module.exports = new Type('tag:yaml.org,2002:bool', {
+ loader: {
+ kind: 'string',
+ resolver: resolveYamlBoolean
+ },
+ dumper: {
+ kind: 'boolean',
+ defaultStyle: 'lowercase',
+ representer: {
+ lowercase: function (object) { return object ? 'true' : 'false'; },
+ uppercase: function (object) { return object ? 'TRUE' : 'FALSE'; },
+ camelcase: function (object) { return object ? 'True' : 'False'; }
+ }
+ }
+});
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/type/float.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/type/float.js
new file mode 100644
index 0000000..edb5fcb
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/type/float.js
@@ -0,0 +1,102 @@
+'use strict';
+
+
+var NIL = require('../common').NIL;
+var Type = require('../type');
+
+
+var YAML_FLOAT_PATTERN = new RegExp(
+ '^(?:[-+]?(?:[0-9][0-9_]*)\\.[0-9_]*(?:[eE][-+][0-9]+)?' +
+ '|\\.[0-9_]+(?:[eE][-+][0-9]+)?' +
+ '|[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\\.[0-9_]*' +
+ '|[-+]?\\.(?:inf|Inf|INF)' +
+ '|\\.(?:nan|NaN|NAN))$');
+
+
+function resolveYamlFloat(object /*, explicit*/) {
+ var value, sign, base, digits;
+
+ if (!YAML_FLOAT_PATTERN.test(object)) {
+ return NIL;
+ }
+
+ value = object.replace(/_/g, '').toLowerCase();
+ sign = '-' === value[0] ? -1 : 1;
+ digits = [];
+
+ if (0 <= '+-'.indexOf(value[0])) {
+ value = value.slice(1);
+ }
+
+ if ('.inf' === value) {
+ return (1 === sign) ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY;
+
+ } else if ('.nan' === value) {
+ return NaN;
+
+ } else if (0 <= value.indexOf(':')) {
+ value.split(':').forEach(function (v) {
+ digits.unshift(parseFloat(v, 10));
+ });
+
+ value = 0.0;
+ base = 1;
+
+ digits.forEach(function (d) {
+ value += d * base;
+ base *= 60;
+ });
+
+ return sign * value;
+
+ } else {
+ return sign * parseFloat(value, 10);
+ }
+}
+
+
+function representYamlFloat(object, style) {
+ if (isNaN(object)) {
+ switch (style) {
+ case 'lowercase':
+ return '.nan';
+ case 'uppercase':
+ return '.NAN';
+ case 'camelcase':
+ return '.NaN';
+ }
+ } else if (Number.POSITIVE_INFINITY === object) {
+ switch (style) {
+ case 'lowercase':
+ return '.inf';
+ case 'uppercase':
+ return '.INF';
+ case 'camelcase':
+ return '.Inf';
+ }
+ } else if (Number.NEGATIVE_INFINITY === object) {
+ switch (style) {
+ case 'lowercase':
+ return '-.inf';
+ case 'uppercase':
+ return '-.INF';
+ case 'camelcase':
+ return '-.Inf';
+ }
+ } else {
+ return object.toString(10);
+ }
+}
+
+
+module.exports = new Type('tag:yaml.org,2002:float', {
+ loader: {
+ kind: 'string',
+ resolver: resolveYamlFloat
+ },
+ dumper: {
+ kind: 'float',
+ defaultStyle: 'lowercase',
+ representer: representYamlFloat
+ }
+});
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/type/int.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/type/int.js
new file mode 100644
index 0000000..f5e1e7e
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/type/int.js
@@ -0,0 +1,85 @@
+'use strict';
+
+
+var NIL = require('../common').NIL;
+var Type = require('../type');
+
+
+var YAML_INTEGER_PATTERN = new RegExp(
+ '^(?:[-+]?0b[0-1_]+' +
+ '|[-+]?0[0-7_]+' +
+ '|[-+]?(?:0|[1-9][0-9_]*)' +
+ '|[-+]?0x[0-9a-fA-F_]+' +
+ '|[-+]?[1-9][0-9_]*(?::[0-5]?[0-9])+)$');
+
+
+function resolveYamlInteger(object /*, explicit*/) {
+ var value, sign, base, digits;
+
+ if (!YAML_INTEGER_PATTERN.test(object)) {
+ return NIL;
+ }
+
+ value = object.replace(/_/g, '');
+ sign = '-' === value[0] ? -1 : 1;
+ digits = [];
+
+ if (0 <= '+-'.indexOf(value[0])) {
+ value = value.slice(1);
+ }
+
+ if ('0' === value) {
+ return 0;
+
+ } else if (/^0b/.test(value)) {
+ return sign * parseInt(value.slice(2), 2);
+
+ } else if (/^0x/.test(value)) {
+ return sign * parseInt(value, 16);
+
+ } else if ('0' === value[0]) {
+ return sign * parseInt(value, 8);
+
+ } else if (0 <= value.indexOf(':')) {
+ value.split(':').forEach(function (v) {
+ digits.unshift(parseInt(v, 10));
+ });
+
+ value = 0;
+ base = 1;
+
+ digits.forEach(function (d) {
+ value += (d * base);
+ base *= 60;
+ });
+
+ return sign * value;
+
+ } else {
+ return sign * parseInt(value, 10);
+ }
+}
+
+
+module.exports = new Type('tag:yaml.org,2002:int', {
+ loader: {
+ kind: 'string',
+ resolver: resolveYamlInteger
+ },
+ dumper: {
+ kind: 'integer',
+ defaultStyle: 'decimal',
+ representer: {
+ binary: function (object) { return '0b' + object.toString(2); },
+ octal: function (object) { return '0' + object.toString(8); },
+ decimal: function (object) { return object.toString(10); },
+ hexadecimal: function (object) { return '0x' + object.toString(16).toUpperCase(); }
+ },
+ styleAliases: {
+ binary: [ 2, 'bin' ],
+ octal: [ 8, 'oct' ],
+ decimal: [ 10, 'dec' ],
+ hexadecimal: [ 16, 'hex' ]
+ }
+ }
+});
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/type/js/function.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/type/js/function.js
new file mode 100644
index 0000000..4b3b3ca
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/type/js/function.js
@@ -0,0 +1,56 @@
+'use strict';
+
+
+var esprima = require('esprima');
+
+
+var NIL = require('../../common').NIL;
+var Type = require('../../type');
+
+
+function resolveJavascriptFunction(object /*, explicit*/) {
+ /*jslint evil:true*/
+
+ try {
+ var source = '(' + object + ')',
+ ast = esprima.parse(source, { range: true }),
+ params = [],
+ body;
+
+ if ('Program' !== ast.type ||
+ 1 !== ast.body.length ||
+ 'ExpressionStatement' !== ast.body[0].type ||
+ 'FunctionExpression' !== ast.body[0].expression.type) {
+ return NIL;
+ }
+
+ ast.body[0].expression.params.forEach(function (param) {
+ params.push(param.name);
+ });
+
+ body = ast.body[0].expression.body.range;
+
+ // Esprima's ranges include the first '{' and the last '}' characters on
+ // function expressions. So cut them out.
+ return new Function(params, source.slice(body[0]+1, body[1]-1));
+ } catch (err) {
+ return NIL;
+ }
+}
+
+
+function representJavascriptFunction(object /*, style*/) {
+ return object.toString();
+}
+
+
+module.exports = new Type('tag:yaml.org,2002:js/function', {
+ loader: {
+ kind: 'string',
+ resolver: resolveJavascriptFunction
+ },
+ dumper: {
+ kind: 'function',
+ representer: representJavascriptFunction,
+ }
+});
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/type/js/regexp.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/type/js/regexp.js
new file mode 100644
index 0000000..9f4f89e
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/type/js/regexp.js
@@ -0,0 +1,56 @@
+'use strict';
+
+
+var NIL = require('../../common').NIL;
+var Type = require('../../type');
+
+
+function resolveJavascriptRegExp(object /*, explicit*/) {
+ var regexp = object,
+ tail = /\/([gim]*)$/.exec(object),
+ modifiers;
+
+ // `/foo/gim` - tail can be maximum 4 chars
+ if ('/' === regexp[0] && tail && 4 >= tail[0].length) {
+ regexp = regexp.slice(1, regexp.length - tail[0].length);
+ modifiers = tail[1];
+ }
+
+ try {
+ return new RegExp(regexp, modifiers);
+ } catch (error) {
+ return NIL;
+ }
+}
+
+
+function representJavascriptRegExp(object /*, style*/) {
+ var result = '/' + object.source + '/';
+
+ if (object.global) {
+ result += 'g';
+ }
+
+ if (object.multiline) {
+ result += 'm';
+ }
+
+ if (object.ignoreCase) {
+ result += 'i';
+ }
+
+ return result;
+}
+
+
+module.exports = new Type('tag:yaml.org,2002:js/regexp', {
+ loader: {
+ kind: 'string',
+ resolver: resolveJavascriptRegExp
+ },
+ dumper: {
+ kind: 'object',
+ instanceOf: RegExp,
+ representer: representJavascriptRegExp
+ }
+});
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/type/js/undefined.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/type/js/undefined.js
new file mode 100644
index 0000000..8d2835e
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/type/js/undefined.js
@@ -0,0 +1,28 @@
+'use strict';
+
+
+var Type = require('../../type');
+
+
+function resolveJavascriptUndefined(/*object, explicit*/) {
+ var undef;
+
+ return undef;
+}
+
+
+function representJavascriptUndefined(/*object, explicit*/) {
+ return '';
+}
+
+
+module.exports = new Type('tag:yaml.org,2002:js/undefined', {
+ loader: {
+ kind: 'string',
+ resolver: resolveJavascriptUndefined
+ },
+ dumper: {
+ kind: 'undefined',
+ representer: representJavascriptUndefined
+ }
+});
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/type/map.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/type/map.js
new file mode 100644
index 0000000..5cda6de
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/type/map.js
@@ -0,0 +1,11 @@
+'use strict';
+
+
+var Type = require('../type');
+
+
+module.exports = new Type('tag:yaml.org,2002:map', {
+ loader: {
+ kind: 'object'
+ }
+});
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/type/merge.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/type/merge.js
new file mode 100644
index 0000000..8facc70
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/type/merge.js
@@ -0,0 +1,18 @@
+'use strict';
+
+
+var NIL = require('../common').NIL;
+var Type = require('../type');
+
+
+function resolveYamlMerge(object /*, explicit*/) {
+ return '<<' === object ? object : NIL;
+}
+
+
+module.exports = new Type('tag:yaml.org,2002:merge', {
+ loader: {
+ kind: 'string',
+ resolver: resolveYamlMerge
+ }
+});
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/type/null.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/type/null.js
new file mode 100644
index 0000000..796e1af
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/type/null.js
@@ -0,0 +1,36 @@
+'use strict';
+
+
+var NIL = require('../common').NIL;
+var Type = require('../type');
+
+
+var YAML_NULL_MAP = {
+ '~' : true,
+ 'null' : true,
+ 'Null' : true,
+ 'NULL' : true
+};
+
+
+function resolveYamlNull(object /*, explicit*/) {
+ return YAML_NULL_MAP[object] ? null : NIL;
+}
+
+
+module.exports = new Type('tag:yaml.org,2002:null', {
+ loader: {
+ kind: 'string',
+ resolver: resolveYamlNull
+ },
+ dumper: {
+ kind: 'null',
+ defaultStyle: 'lowercase',
+ representer: {
+ canonical: function () { return '~'; },
+ lowercase: function () { return 'null'; },
+ uppercase: function () { return 'NULL'; },
+ camelcase: function () { return 'Null'; },
+ }
+ }
+});
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/type/omap.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/type/omap.js
new file mode 100644
index 0000000..f7c248d
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/type/omap.js
@@ -0,0 +1,53 @@
+'use strict';
+
+
+var NIL = require('../common').NIL;
+var Type = require('../type');
+
+
+var _hasOwnProperty = Object.prototype.hasOwnProperty;
+var _toString = Object.prototype.toString;
+
+
+function resolveYamlOmap(object /*, explicit*/) {
+ var objectKeys = [], index, length, pair, pairKey, pairHasKey;
+
+ for (index = 0, length = object.length; index < length; index += 1) {
+ pair = object[index];
+ pairHasKey = false;
+
+ if ('[object Object]' !== _toString.call(pair)) {
+ return NIL;
+ }
+
+ for (pairKey in pair) {
+ if (_hasOwnProperty.call(pair, pairKey)) {
+ if (!pairHasKey) {
+ pairHasKey = true;
+ } else {
+ return NIL;
+ }
+ }
+ }
+
+ if (!pairHasKey) {
+ return NIL;
+ }
+
+ if (-1 === objectKeys.indexOf(pairKey)) {
+ objectKeys.push(pairKey);
+ } else {
+ return NIL;
+ }
+ }
+
+ return object;
+}
+
+
+module.exports = new Type('tag:yaml.org,2002:omap', {
+ loader: {
+ kind: 'array',
+ resolver: resolveYamlOmap
+ }
+});
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/type/pairs.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/type/pairs.js
new file mode 100644
index 0000000..828ff1b
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/type/pairs.js
@@ -0,0 +1,41 @@
+'use strict';
+
+
+var NIL = require('../common').NIL;
+var Type = require('../type');
+
+
+var _toString = Object.prototype.toString;
+
+
+function resolveYamlPairs(object /*, explicit*/) {
+ var index, length, pair, keys, result;
+
+ result = new Array(object.length);
+
+ for (index = 0, length = object.length; index < length; index += 1) {
+ pair = object[index];
+
+ if ('[object Object]' !== _toString.call(pair)) {
+ return NIL;
+ }
+
+ keys = Object.keys(pair);
+
+ if (1 !== keys.length) {
+ return NIL;
+ }
+
+ result[index] = [ keys[0], pair[keys[0]] ];
+ }
+
+ return result;
+}
+
+
+module.exports = new Type('tag:yaml.org,2002:pairs', {
+ loader: {
+ kind: 'array',
+ resolver: resolveYamlPairs
+ }
+});
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/type/seq.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/type/seq.js
new file mode 100644
index 0000000..80a7cf0
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/type/seq.js
@@ -0,0 +1,11 @@
+'use strict';
+
+
+var Type = require('../type');
+
+
+module.exports = new Type('tag:yaml.org,2002:seq', {
+ loader: {
+ kind: 'array'
+ }
+});
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/type/set.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/type/set.js
new file mode 100644
index 0000000..64bdc66
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/type/set.js
@@ -0,0 +1,31 @@
+'use strict';
+
+
+var NIL = require('../common').NIL;
+var Type = require('../type');
+
+
+var _hasOwnProperty = Object.prototype.hasOwnProperty;
+
+
+function resolveYamlSet(object /*, explicit*/) {
+ var key;
+
+ for (key in object) {
+ if (_hasOwnProperty.call(object, key)) {
+ if (null !== object[key]) {
+ return NIL;
+ }
+ }
+ }
+
+ return object;
+}
+
+
+module.exports = new Type('tag:yaml.org,2002:set', {
+ loader: {
+ kind: 'object',
+ resolver: resolveYamlSet
+ }
+});
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/type/str.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/type/str.js
new file mode 100644
index 0000000..384f14e
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/type/str.js
@@ -0,0 +1,11 @@
+'use strict';
+
+
+var Type = require('../type');
+
+
+module.exports = new Type('tag:yaml.org,2002:str', {
+ loader: {
+ kind: 'string'
+ }
+});
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/type/timestamp.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/type/timestamp.js
new file mode 100644
index 0000000..24da9e2
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/type/timestamp.js
@@ -0,0 +1,91 @@
+'use strict';
+
+
+var NIL = require('../common').NIL;
+var Type = require('../type');
+
+
+var YAML_TIMESTAMP_REGEXP = new RegExp(
+ '^([0-9][0-9][0-9][0-9])' + // [1] year
+ '-([0-9][0-9]?)' + // [2] month
+ '-([0-9][0-9]?)' + // [3] day
+ '(?:(?:[Tt]|[ \\t]+)' + // ...
+ '([0-9][0-9]?)' + // [4] hour
+ ':([0-9][0-9])' + // [5] minute
+ ':([0-9][0-9])' + // [6] second
+ '(?:\\.([0-9]*))?' + // [7] fraction
+ '(?:[ \\t]*(Z|([-+])([0-9][0-9]?)' + // [8] tz [9] tz_sign [10] tz_hour
+ '(?::([0-9][0-9]))?))?)?$'); // [11] tz_minute
+
+
+function resolveYamlTimestamp(object /*, explicit*/) {
+ var match, year, month, day, hour, minute, second, fraction = 0,
+ delta = null, tz_hour, tz_minute, data;
+
+ match = YAML_TIMESTAMP_REGEXP.exec(object);
+
+ if (null === match) {
+ return NIL;
+ }
+
+ // match: [1] year [2] month [3] day
+
+ year = +(match[1]);
+ month = +(match[2]) - 1; // JS month starts with 0
+ day = +(match[3]);
+
+ if (!match[4]) { // no hour
+ return new Date(Date.UTC(year, month, day));
+ }
+
+ // match: [4] hour [5] minute [6] second [7] fraction
+
+ hour = +(match[4]);
+ minute = +(match[5]);
+ second = +(match[6]);
+
+ if (match[7]) {
+ fraction = match[7].slice(0, 3);
+ while (fraction.length < 3) { // milli-seconds
+ fraction += '0';
+ }
+ fraction = +fraction;
+ }
+
+ // match: [8] tz [9] tz_sign [10] tz_hour [11] tz_minute
+
+ if (match[9]) {
+ tz_hour = +(match[10]);
+ tz_minute = +(match[11] || 0);
+ delta = (tz_hour * 60 + tz_minute) * 60000; // delta in mili-seconds
+ if ('-' === match[9]) {
+ delta = -delta;
+ }
+ }
+
+ data = new Date(Date.UTC(year, month, day, hour, minute, second, fraction));
+
+ if (delta) {
+ data.setTime(data.getTime() - delta);
+ }
+
+ return data;
+}
+
+
+function representYamlTimestamp(object /*, style*/) {
+ return object.toISOString();
+}
+
+
+module.exports = new Type('tag:yaml.org,2002:timestamp', {
+ loader: {
+ kind: 'string',
+ resolver: resolveYamlTimestamp
+ },
+ dumper: {
+ kind: 'object',
+ instanceOf: Date,
+ representer: representYamlTimestamp
+ }
+});
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/.bin/esparse b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/.bin/esparse
new file mode 120000
index 0000000..7423b18
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/.bin/esparse
@@ -0,0 +1 @@
+../esprima/bin/esparse.js
\ No newline at end of file
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/.bin/esvalidate b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/.bin/esvalidate
new file mode 120000
index 0000000..16069ef
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/.bin/esvalidate
@@ -0,0 +1 @@
+../esprima/bin/esvalidate.js
\ No newline at end of file
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/HISTORY.md b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/HISTORY.md
new file mode 100644
index 0000000..bb97617
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/HISTORY.md
@@ -0,0 +1,115 @@
+0.1.16 / 2013-12-01
+-------------------
+
+* Maintenance release. Updated dependencies and docs.
+
+
+0.1.15 / 2013-05-13
+-------------------
+
+* Fixed #55, @trebor89
+
+
+0.1.14 / 2013-05-12
+-------------------
+
+* Fixed #62, @maxtaco
+
+
+0.1.13 / 2013-04-08
+-------------------
+
+* Added `.npmignore` to reduce package size
+
+
+0.1.12 / 2013-02-10
+-------------------
+
+* Fixed conflictHandler (#46), @hpaulj
+
+
+0.1.11 / 2013-02-07
+-------------------
+
+* Multiple bugfixes, @hpaulj
+* Added 70+ tests (ported from python), @hpaulj
+* Added conflictHandler, @applepicke
+* Added fromfilePrefixChar, @hpaulj
+
+
+0.1.10 / 2012-12-30
+-------------------
+
+* Added [mutual exclusion](http://docs.python.org/dev/library/argparse.html#mutual-exclusion)
+ support, thanks to @hpaulj
+* Fixed options check for `storeConst` & `appendConst` actions, thanks to @hpaulj
+
+
+0.1.9 / 2012-12-27
+------------------
+
+* Fixed option dest interferens with other options (issue #23), thanks to @hpaulj
+* Fixed default value behavior with `*` positionals, thanks to @hpaulj
+* Improve `getDefault()` behavior, thanks to @hpaulj
+* Imrove negative argument parsing, thanks to @hpaulj
+
+
+0.1.8 / 2012-12-01
+------------------
+
+* Fixed parser parents (issue #19), thanks to @hpaulj
+* Fixed negative argument parse (issue #20), thanks to @hpaulj
+
+
+0.1.7 / 2012-10-14
+------------------
+
+* Fixed 'choices' argument parse (issue #16)
+* Fixed stderr output (issue #15)
+
+
+0.1.6 / 2012-09-09
+------------------
+
+* Fixed check for conflict of options (thanks to @tomxtobin)
+
+
+0.1.5 / 2012-09-03
+------------------
+
+* Fix parser #setDefaults method (thanks to @tomxtobin)
+
+
+0.1.4 / 2012-07-30
+------------------
+
+* Fixed pseudo-argument support (thanks to @CGamesPlay)
+* Fixed addHelp default (should be true), if not set (thanks to @benblank)
+
+
+0.1.3 / 2012-06-27
+------------------
+
+* Fixed formatter api name: Formatter -> HelpFormatter
+
+
+0.1.2 / 2012-05-29
+------------------
+
+* Added basic tests
+* Removed excess whitespace in help
+* Fixed error reporting, when parcer with subcommands
+ called with empty arguments
+
+
+0.1.1 / 2012-05-23
+------------------
+
+* Fixed line wrapping in help formatter
+* Added better error reporting on invalid arguments
+
+
+0.1.0 / 2012-05-16
+------------------
+
+* First release.
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/LICENSE b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/LICENSE
new file mode 100644
index 0000000..1afdae5
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/LICENSE
@@ -0,0 +1,21 @@
+(The MIT License)
+
+Copyright (C) 2012 by Vitaly Puzrin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/README.md b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/README.md
new file mode 100644
index 0000000..b7e8473
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/README.md
@@ -0,0 +1,239 @@
+argparse
+========
+
+[](http://travis-ci.org/nodeca/argparse)
+
+CLI arguments parser for node.js. Javascript port of python's
+[argparse](http://docs.python.org/dev/library/argparse.html) module
+(original version 3.2). That's a full port, except some very rare options,
+recorded in issue tracker.
+
+**NB.** Method names changed to camelCase. See [generated docs](http://nodeca.github.com/argparse/).
+
+
+Example
+=======
+
+test.js file:
+
+```javascript
+#!/usr/bin/env node
+'use strict';
+
+var ArgumentParser = require('../lib/argparse').ArgumentParser;
+var parser = new ArgumentParser({
+ version: '0.0.1',
+ addHelp:true,
+ description: 'Argparse example'
+});
+parser.addArgument(
+ [ '-f', '--foo' ],
+ {
+ help: 'foo bar'
+ }
+);
+parser.addArgument(
+ [ '-b', '--bar' ],
+ {
+ help: 'bar foo'
+ }
+);
+var args = parser.parseArgs();
+console.dir(args);
+```
+
+Display help:
+
+```
+$ ./test.js -h
+usage: example.js [-h] [-v] [-f FOO] [-b BAR]
+
+Argparse example
+
+Optional arguments:
+ -h, --help Show this help message and exit.
+ -v, --version Show program's version number and exit.
+ -f FOO, --foo FOO foo bar
+ -b BAR, --bar BAR bar foo
+```
+
+Parse arguments:
+
+```
+$ ./test.js -f=3 --bar=4
+{ foo: '3', bar: '4' }
+```
+
+More [examples](https://github.com/nodeca/argparse/tree/master/examples).
+
+
+ArgumentParser objects
+======================
+
+```
+new ArgumentParser({paramters hash});
+```
+
+Creates a new ArgumentParser object.
+
+**Supported params:**
+
+- ```description``` - Text to display before the argument help.
+- ```epilog``` - Text to display after the argument help.
+- ```addHelp``` - Add a -h/–help option to the parser. (default: true)
+- ```argumentDefault``` - Set the global default value for arguments. (default: null)
+- ```parents``` - A list of ArgumentParser objects whose arguments should also be included.
+- ```prefixChars``` - The set of characters that prefix optional arguments. (default: ‘-‘)
+- ```formatterClass``` - A class for customizing the help output.
+- ```prog``` - The name of the program (default: `path.basename(process.argv[1])`)
+- ```usage``` - The string describing the program usage (default: generated)
+- ```conflictHandler``` - Usually unnecessary, defines strategy for resolving conflicting optionals.
+
+**Not supportied yet**
+
+- ```fromfilePrefixChars``` - The set of characters that prefix files from which additional arguments should be read.
+
+
+Details in [original ArgumentParser guide](http://docs.python.org/dev/library/argparse.html#argumentparser-objects)
+
+
+addArgument() method
+====================
+
+```
+ArgumentParser.addArgument([names or flags], {options})
+```
+
+Defines how a single command-line argument should be parsed.
+
+- ```name or flags``` - Either a name or a list of option strings, e.g. foo or -f, --foo.
+
+Options:
+
+- ```action``` - The basic type of action to be taken when this argument is encountered at the command line.
+- ```nargs```- The number of command-line arguments that should be consumed.
+- ```constant``` - A constant value required by some action and nargs selections.
+- ```defaultValue``` - The value produced if the argument is absent from the command line.
+- ```type``` - The type to which the command-line argument should be converted.
+- ```choices``` - A container of the allowable values for the argument.
+- ```required``` - Whether or not the command-line option may be omitted (optionals only).
+- ```help``` - A brief description of what the argument does.
+- ```metavar``` - A name for the argument in usage messages.
+- ```dest``` - The name of the attribute to be added to the object returned by parseArgs().
+
+Details in [original add_argument guide](http://docs.python.org/dev/library/argparse.html#the-add-argument-method)
+
+
+Action (some details)
+================
+
+ArgumentParser objects associate command-line arguments with actions.
+These actions can do just about anything with the command-line arguments associated
+with them, though most actions simply add an attribute to the object returned by
+parseArgs(). The action keyword argument specifies how the command-line arguments
+should be handled. The supported actions are:
+
+- ```store``` - Just stores the argument’s value. This is the default action.
+- ```storeConst``` - Stores value, specified by the const keyword argument.
+ (Note that the const keyword argument defaults to the rather unhelpful None.)
+ The 'storeConst' action is most commonly used with optional arguments, that
+ specify some sort of flag.
+- ```storeTrue``` and ```storeFalse``` - Stores values True and False
+ respectively. These are special cases of 'storeConst'.
+- ```append``` - Stores a list, and appends each argument value to the list.
+ This is useful to allow an option to be specified multiple times.
+- ```appendConst``` - Stores a list, and appends value, specified by the
+ const keyword argument to the list. (Note, that the const keyword argument defaults
+ is None.) The 'appendConst' action is typically used when multiple arguments need
+ to store constants to the same list.
+- ```count``` - Counts the number of times a keyword argument occurs. For example,
+ used for increasing verbosity levels.
+- ```help``` - Prints a complete help message for all the options in the current
+ parser and then exits. By default a help action is automatically added to the parser.
+ See ArgumentParser for details of how the output is created.
+- ```version``` - Prints version information and exit. Expects a `version=`
+ keyword argument in the addArgument() call.
+
+Details in [original action guide](http://docs.python.org/dev/library/argparse.html#action)
+
+
+Sub-commands
+============
+
+ArgumentParser.addSubparsers()
+
+Many programs split their functionality into a number of sub-commands, for
+example, the svn program can invoke sub-commands like `svn checkout`, `svn update`,
+and `svn commit`. Splitting up functionality this way can be a particularly good
+idea when a program performs several different functions which require different
+kinds of command-line arguments. `ArgumentParser` supports creation of such
+sub-commands with `addSubparsers()` method. The `addSubparsers()` method is
+normally called with no arguments and returns an special action object.
+This object has a single method `addParser()`, which takes a command name and
+any `ArgumentParser` constructor arguments, and returns an `ArgumentParser` object
+that can be modified as usual.
+
+Example:
+
+sub_commands.js
+```javascript
+#!/usr/bin/env node
+'use strict';
+
+var ArgumentParser = require('../lib/argparse').ArgumentParser;
+var parser = new ArgumentParser({
+ version: '0.0.1',
+ addHelp:true,
+ description: 'Argparse examples: sub-commands',
+});
+
+var subparsers = parser.addSubparsers({
+ title:'subcommands',
+ dest:"subcommand_name"
+});
+
+var bar = subparsers.addParser('c1', {addHelp:true});
+bar.addArgument(
+ [ '-f', '--foo' ],
+ {
+ action: 'store',
+ help: 'foo3 bar3'
+ }
+);
+var bar = subparsers.addParser(
+ 'c2',
+ {aliases:['co'], addHelp:true}
+);
+bar.addArgument(
+ [ '-b', '--bar' ],
+ {
+ action: 'store',
+ type: 'int',
+ help: 'foo3 bar3'
+ }
+);
+
+var args = parser.parseArgs();
+console.dir(args);
+
+```
+
+Details in [original sub-commands guide](http://docs.python.org/dev/library/argparse.html#sub-commands)
+
+
+Contributors
+============
+
+- [Eugene Shkuropat](https://github.com/shkuropat)
+- [Paul Jacobson](https://github.com/hpaulj)
+
+[others](https://github.com/nodeca/argparse/graphs/contributors)
+
+License
+=======
+
+Copyright (c) 2012 [Vitaly Puzrin](https://github.com/puzrin).
+Released under the MIT license. See
+[LICENSE](https://github.com/nodeca/argparse/blob/master/LICENSE) for details.
+
+
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/examples/arguments.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/examples/arguments.js
new file mode 100755
index 0000000..5b090fa
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/examples/arguments.js
@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+'use strict';
+
+var ArgumentParser = require('../lib/argparse').ArgumentParser;
+var parser = new ArgumentParser({
+ version: '0.0.1',
+ addHelp: true,
+ description: 'Argparse examples: arguments'
+});
+parser.addArgument(
+ [ '-f', '--foo' ],
+ {
+ help: 'foo bar'
+ }
+);
+parser.addArgument(
+ [ '-b', '--bar' ],
+ {
+ help: 'bar foo'
+ }
+);
+
+
+parser.printHelp();
+console.log('-----------');
+
+var args;
+args = parser.parseArgs('-f 1 -b2'.split(' '));
+console.dir(args);
+console.log('-----------');
+args = parser.parseArgs('-f=3 --bar=4'.split(' '));
+console.dir(args);
+console.log('-----------');
+args = parser.parseArgs('--foo 5 --bar 6'.split(' '));
+console.dir(args);
+console.log('-----------');
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/examples/choice.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/examples/choice.js
new file mode 100755
index 0000000..2616fa4
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/examples/choice.js
@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+'use strict';
+
+var ArgumentParser = require('../lib/argparse').ArgumentParser;
+var parser = new ArgumentParser({
+ version: '0.0.1',
+ addHelp: true,
+ description: 'Argparse examples: choice'
+});
+
+parser.addArgument(['foo'], {choices: 'abc'});
+
+parser.printHelp();
+console.log('-----------');
+
+var args;
+args = parser.parseArgs(['c']);
+console.dir(args);
+console.log('-----------');
+parser.parseArgs(['X']);
+console.dir(args);
+
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/examples/constants.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/examples/constants.js
new file mode 100755
index 0000000..172a4f3
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/examples/constants.js
@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+'use strict';
+
+var ArgumentParser = require('../lib/argparse').ArgumentParser;
+var parser = new ArgumentParser({
+ version: '0.0.1',
+ addHelp: true,
+ description: 'Argparse examples: constant'
+});
+
+parser.addArgument(
+ [ '-a'],
+ {
+ action: 'storeConst',
+ dest: 'answer',
+ help: 'store constant',
+ constant: 42
+ }
+);
+parser.addArgument(
+ [ '--str' ],
+ {
+ action: 'appendConst',
+ dest: 'types',
+ help: 'append constant "str" to types',
+ constant: 'str'
+ }
+);
+parser.addArgument(
+ [ '--int' ],
+ {
+ action: 'appendConst',
+ dest: 'types',
+ help: 'append constant "int" to types',
+ constant: 'int'
+ }
+);
+
+parser.addArgument(
+ [ '--true' ],
+ {
+ action: 'storeTrue',
+ help: 'store true constant'
+ }
+);
+parser.addArgument(
+ [ '--false' ],
+ {
+ action: 'storeFalse',
+ help: 'store false constant'
+ }
+);
+
+parser.printHelp();
+console.log('-----------');
+
+var args;
+args = parser.parseArgs('-a --str --int --true'.split(' '));
+console.dir(args);
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/examples/help.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/examples/help.js
new file mode 100755
index 0000000..7eb9555
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/examples/help.js
@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+'use strict';
+
+var ArgumentParser = require('../lib/argparse').ArgumentParser;
+var parser = new ArgumentParser({
+ version: '0.0.1',
+ addHelp: true,
+ description: 'Argparse examples: help',
+ epilog: 'help epilog',
+ prog: 'help_example_prog',
+ usage: 'Usage %(prog)s '
+});
+parser.printHelp();
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/examples/nargs.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/examples/nargs.js
new file mode 100755
index 0000000..74f376b
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/examples/nargs.js
@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+'use strict';
+
+var ArgumentParser = require('../lib/argparse').ArgumentParser;
+var parser = new ArgumentParser({
+ version: '0.0.1',
+ addHelp: true,
+ description: 'Argparse examples: nargs'
+});
+parser.addArgument(
+ [ '-f', '--foo' ],
+ {
+ help: 'foo bar',
+ nargs: 1
+ }
+);
+parser.addArgument(
+ [ '-b', '--bar' ],
+ {
+ help: 'bar foo',
+ nargs: '*'
+ }
+);
+
+parser.printHelp();
+console.log('-----------');
+
+var args;
+args = parser.parseArgs('--foo a --bar c d'.split(' '));
+console.dir(args);
+console.log('-----------');
+args = parser.parseArgs('--bar b c f --foo a'.split(' '));
+console.dir(args);
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/examples/parents.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/examples/parents.js
new file mode 100755
index 0000000..dfe8968
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/examples/parents.js
@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+'use strict';
+
+var ArgumentParser = require('../lib/argparse').ArgumentParser;
+
+var args;
+var parent_parser = new ArgumentParser({ addHelp: false });
+// note addHelp:false to prevent duplication of the -h option
+parent_parser.addArgument(
+ ['--parent'],
+ { type: 'int', description: 'parent' }
+);
+
+var foo_parser = new ArgumentParser({
+ parents: [ parent_parser ],
+ description: 'child1'
+});
+foo_parser.addArgument(['foo']);
+args = foo_parser.parseArgs(['--parent', '2', 'XXX']);
+console.log(args);
+
+var bar_parser = new ArgumentParser({
+ parents: [ parent_parser ],
+ description: 'child2'
+});
+bar_parser.addArgument(['--bar']);
+args = bar_parser.parseArgs(['--bar', 'YYY']);
+console.log(args);
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/examples/prefix_chars.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/examples/prefix_chars.js
new file mode 100755
index 0000000..430d5e1
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/examples/prefix_chars.js
@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+'use strict';
+
+var ArgumentParser = require('../lib/argparse').ArgumentParser;
+var parser = new ArgumentParser({
+ version: '0.0.1',
+ addHelp: true,
+ description: 'Argparse examples: prefix_chars',
+ prefixChars: '-+'
+});
+parser.addArgument(['+f', '++foo']);
+parser.addArgument(['++bar'], {action: 'storeTrue'});
+
+parser.printHelp();
+console.log('-----------');
+
+var args;
+args = parser.parseArgs(['+f', '1']);
+console.dir(args);
+args = parser.parseArgs(['++bar']);
+console.dir(args);
+args = parser.parseArgs(['++foo', '2', '++bar']);
+console.dir(args);
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/examples/sub_commands.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/examples/sub_commands.js
new file mode 100755
index 0000000..df9c494
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/examples/sub_commands.js
@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+'use strict';
+
+var ArgumentParser = require('../lib/argparse').ArgumentParser;
+var parser = new ArgumentParser({
+ version: '0.0.1',
+ addHelp: true,
+ description: 'Argparse examples: sub-commands'
+});
+
+var subparsers = parser.addSubparsers({
+ title: 'subcommands',
+ dest: "subcommand_name"
+});
+
+var bar = subparsers.addParser('c1', {addHelp: true, help: 'c1 help'});
+bar.addArgument(
+ [ '-f', '--foo' ],
+ {
+ action: 'store',
+ help: 'foo3 bar3'
+ }
+);
+var bar = subparsers.addParser(
+ 'c2',
+ {aliases: ['co'], addHelp: true, help: 'c2 help'}
+);
+bar.addArgument(
+ [ '-b', '--bar' ],
+ {
+ action: 'store',
+ type: 'int',
+ help: 'foo3 bar3'
+ }
+);
+parser.printHelp();
+console.log('-----------');
+
+var args;
+args = parser.parseArgs('c1 -f 2'.split(' '));
+console.dir(args);
+console.log('-----------');
+args = parser.parseArgs('c2 -b 1'.split(' '));
+console.dir(args);
+console.log('-----------');
+args = parser.parseArgs('co -b 1'.split(' '));
+console.dir(args);
+console.log('-----------');
+parser.parseArgs(['c1', '-h']);
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/examples/sum.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/examples/sum.js
new file mode 100755
index 0000000..4532800
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/examples/sum.js
@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+
+'use strict';
+
+
+var ArgumentParser = require('../lib/argparse').ArgumentParser;
+var parser = new ArgumentParser({ description: 'Process some integers.' });
+
+
+function sum(arr) {
+ return arr.reduce(function (a, b) {
+ return a + b;
+ }, 0);
+}
+function max(arr) {
+ return Math.max.apply(Math, arr);
+}
+
+
+parser.addArgument(['integers'], {
+ metavar: 'N',
+ type: 'int',
+ nargs: '+',
+ help: 'an integer for the accumulator'
+});
+parser.addArgument(['--sum'], {
+ dest: 'accumulate',
+ action: 'storeConst',
+ constant: sum,
+ defaultValue: max,
+ help: 'sum the integers (default: find the max)'
+});
+
+var args = parser.parseArgs('--sum 1 2 -1'.split(' '));
+console.log(args.accumulate(args.integers));
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/examples/testformatters.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/examples/testformatters.js
new file mode 100644
index 0000000..afb4a2d
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/examples/testformatters.js
@@ -0,0 +1,270 @@
+'use strict';
+
+var a, group, parser, helptext;
+
+var assert = require('assert');
+var _ = require('underscore');
+_.str = require('underscore.string');
+var print = function () {
+ return console.log.apply(console, arguments);
+ };
+// print = function () {};
+
+var argparse = require('argparse');
+
+print("TEST argparse.ArgumentDefaultsHelpFormatter");
+
+parser = new argparse.ArgumentParser({
+ debug: true,
+ formatterClass: argparse.ArgumentDefaultsHelpFormatter,
+ description: 'description'
+});
+
+parser.addArgument(['--foo'], {
+ help: 'foo help - oh and by the way, %(defaultValue)s'
+});
+
+parser.addArgument(['--bar'], {
+ action: 'storeTrue',
+ help: 'bar help'
+});
+
+parser.addArgument(['spam'], {
+ help: 'spam help'
+});
+
+parser.addArgument(['badger'], {
+ nargs: '?',
+ defaultValue: 'wooden',
+ help: 'badger help'
+});
+
+group = parser.addArgumentGroup({
+ title: 'title',
+ description: 'group description'
+});
+
+group.addArgument(['--baz'], {
+ type: 'int',
+ defaultValue: 42,
+ help: 'baz help'
+});
+
+helptext = parser.formatHelp();
+print(helptext);
+// test selected clips
+assert(helptext.match(/badger help \(default: wooden\)/));
+assert(helptext.match(/foo help - oh and by the way, null/));
+assert(helptext.match(/bar help \(default: false\)/));
+assert(helptext.match(/title:\n {2}group description/)); // test indent
+assert(helptext.match(/baz help \(default: 42\)/im));
+
+/*
+usage: PROG [-h] [--foo FOO] [--bar] [--baz BAZ] spam [badger]
+
+description
+
+positional arguments:
+ spam spam help
+ badger badger help (default: wooden)
+
+optional arguments:
+ -h, --help show this help message and exit
+ --foo FOO foo help - oh and by the way, null
+ --bar bar help (default: false)
+
+title:
+ group description
+
+ --baz BAZ baz help (default: 42)
+*/
+
+print("TEST argparse.RawDescriptionHelpFormatter");
+
+parser = new argparse.ArgumentParser({
+ debug: true,
+ prog: 'PROG',
+ formatterClass: argparse.RawDescriptionHelpFormatter,
+ description: 'Keep the formatting\n' +
+ ' exactly as it is written\n' +
+ '\n' +
+ 'here\n'
+});
+
+a = parser.addArgument(['--foo'], {
+ help: ' foo help should not\n' +
+ ' retain this odd formatting'
+});
+
+parser.addArgument(['spam'], {
+ 'help': 'spam help'
+});
+
+group = parser.addArgumentGroup({
+ title: 'title',
+ description: ' This text\n' +
+ ' should be indented\n' +
+ ' exactly like it is here\n'
+});
+
+group.addArgument(['--bar'], {
+ help: 'bar help'
+});
+
+helptext = parser.formatHelp();
+print(helptext);
+// test selected clips
+assert(helptext.match(parser.description));
+assert.equal(helptext.match(a.help), null);
+assert(helptext.match(/foo help should not retain this odd formatting/));
+
+/*
+class TestHelpRawDescription(HelpTestCase):
+ """Test the RawTextHelpFormatter"""
+....
+
+usage: PROG [-h] [--foo FOO] [--bar BAR] spam
+
+Keep the formatting
+ exactly as it is written
+
+here
+
+positional arguments:
+ spam spam help
+
+optional arguments:
+ -h, --help show this help message and exit
+ --foo FOO foo help should not retain this odd formatting
+
+title:
+ This text
+ should be indented
+ exactly like it is here
+
+ --bar BAR bar help
+*/
+
+
+print("TEST argparse.RawTextHelpFormatter");
+
+parser = new argparse.ArgumentParser({
+ debug: true,
+ prog: 'PROG',
+ formatterClass: argparse.RawTextHelpFormatter,
+ description: 'Keep the formatting\n' +
+ ' exactly as it is written\n' +
+ '\n' +
+ 'here\n'
+});
+
+parser.addArgument(['--baz'], {
+ help: ' baz help should also\n' +
+ 'appear as given here'
+});
+
+a = parser.addArgument(['--foo'], {
+ help: ' foo help should also\n' +
+ 'appear as given here'
+});
+
+parser.addArgument(['spam'], {
+ 'help': 'spam help'
+});
+
+group = parser.addArgumentGroup({
+ title: 'title',
+ description: ' This text\n' +
+ ' should be indented\n' +
+ ' exactly like it is here\n'
+});
+
+group.addArgument(['--bar'], {
+ help: 'bar help'
+});
+
+helptext = parser.formatHelp();
+print(helptext);
+// test selected clips
+assert(helptext.match(parser.description));
+assert(helptext.match(/( {14})appear as given here/gm));
+
+/*
+class TestHelpRawText(HelpTestCase):
+ """Test the RawTextHelpFormatter"""
+
+usage: PROG [-h] [--foo FOO] [--bar BAR] spam
+
+Keep the formatting
+ exactly as it is written
+
+here
+
+positional arguments:
+ spam spam help
+
+optional arguments:
+ -h, --help show this help message and exit
+ --foo FOO foo help should also
+ appear as given here
+
+title:
+ This text
+ should be indented
+ exactly like it is here
+
+ --bar BAR bar help
+*/
+
+
+print("TEST metavar as a tuple");
+
+parser = new argparse.ArgumentParser({
+ prog: 'PROG'
+});
+
+parser.addArgument(['-w'], {
+ help: 'w',
+ nargs: '+',
+ metavar: ['W1', 'W2']
+});
+
+parser.addArgument(['-x'], {
+ help: 'x',
+ nargs: '*',
+ metavar: ['X1', 'X2']
+});
+
+parser.addArgument(['-y'], {
+ help: 'y',
+ nargs: 3,
+ metavar: ['Y1', 'Y2', 'Y3']
+});
+
+parser.addArgument(['-z'], {
+ help: 'z',
+ nargs: '?',
+ metavar: ['Z1']
+});
+
+helptext = parser.formatHelp();
+print(helptext);
+var ustring = 'PROG [-h] [-w W1 [W2 ...]] [-x [X1 [X2 ...]]] [-y Y1 Y2 Y3] [-z [Z1]]';
+ustring = ustring.replace(/\[/g, '\\[').replace(/\]/g, '\\]');
+// print(ustring)
+assert(helptext.match(new RegExp(ustring)));
+
+/*
+class TestHelpTupleMetavar(HelpTestCase):
+ """Test specifying metavar as a tuple"""
+
+usage: PROG [-h] [-w W1 [W2 ...]] [-x [X1 [X2 ...]]] [-y Y1 Y2 Y3] [-z [Z1]]
+
+optional arguments:
+ -h, --help show this help message and exit
+ -w W1 [W2 ...] w
+ -x [X1 [X2 ...]] x
+ -y Y1 Y2 Y3 y
+ -z [Z1] z
+*/
+
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/index.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/index.js
new file mode 100644
index 0000000..3b6eea0
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/index.js
@@ -0,0 +1 @@
+module.exports = require('./lib/argparse');
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/action.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/action.js
new file mode 100644
index 0000000..6f7e9a5
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/action.js
@@ -0,0 +1,146 @@
+/**
+ * class Action
+ *
+ * Base class for all actions
+ * Do not call in your code, use this class only for inherits your own action
+ *
+ * Information about how to convert command line strings to Javascript objects.
+ * Action objects are used by an ArgumentParser to represent the information
+ * needed to parse a single argument from one or more strings from the command
+ * line. The keyword arguments to the Action constructor are also all attributes
+ * of Action instances.
+ *
+ * #####Alowed keywords:
+ *
+ * - `store`
+ * - `storeConstant`
+ * - `storeTrue`
+ * - `storeFalse`
+ * - `append`
+ * - `appendConstant`
+ * - `count`
+ * - `help`
+ * - `version`
+ *
+ * Information about action options see [[Action.new]]
+ *
+ * See also [original guide](http://docs.python.org/dev/library/argparse.html#action)
+ *
+ **/
+
+'use strict';
+
+
+// Constants
+var $$ = require('./const');
+
+
+/**
+ * new Action(options)
+ *
+ * Base class for all actions. Used only for inherits
+ *
+ *
+ * ##### Options:
+ *
+ * - `optionStrings` A list of command-line option strings for the action.
+ * - `dest` Attribute to hold the created object(s)
+ * - `nargs` The number of command-line arguments that should be consumed.
+ * By default, one argument will be consumed and a single value will be
+ * produced.
+ * - `constant` Default value for an action with no value.
+ * - `defaultValue` The value to be produced if the option is not specified.
+ * - `type` Cast to 'string'|'int'|'float'|'complex'|function (string). If
+ * None, 'string'.
+ * - `choices` The choices available.
+ * - `required` True if the action must always be specified at the command
+ * line.
+ * - `help` The help describing the argument.
+ * - `metavar` The name to be used for the option's argument with the help
+ * string. If None, the 'dest' value will be used as the name.
+ *
+ * ##### nargs supported values:
+ *
+ * - `N` (an integer) consumes N arguments (and produces a list)
+ * - `?` consumes zero or one arguments
+ * - `*` consumes zero or more arguments (and produces a list)
+ * - `+` consumes one or more arguments (and produces a list)
+ *
+ * Note: that the difference between the default and nargs=1 is that with the
+ * default, a single value will be produced, while with nargs=1, a list
+ * containing a single value will be produced.
+ **/
+var Action = module.exports = function Action(options) {
+ options = options || {};
+ this.optionStrings = options.optionStrings || [];
+ this.dest = options.dest;
+ this.nargs = options.nargs !== undefined ? options.nargs : null;
+ this.constant = options.constant !== undefined ? options.constant : null;
+ this.defaultValue = options.defaultValue;
+ this.type = options.type !== undefined ? options.type : null;
+ this.choices = options.choices !== undefined ? options.choices : null;
+ this.required = options.required !== undefined ? options.required: false;
+ this.help = options.help !== undefined ? options.help : null;
+ this.metavar = options.metavar !== undefined ? options.metavar : null;
+
+ if (!(this.optionStrings instanceof Array)) {
+ throw new Error('optionStrings should be an array');
+ }
+ if (this.required !== undefined && typeof(this.required) !== 'boolean') {
+ throw new Error('required should be a boolean');
+ }
+};
+
+/**
+ * Action#getName -> String
+ *
+ * Tells action name
+ **/
+Action.prototype.getName = function () {
+ if (this.optionStrings.length > 0) {
+ return this.optionStrings.join('/');
+ } else if (this.metavar !== null && this.metavar !== $$.SUPPRESS) {
+ return this.metavar;
+ } else if (this.dest !== undefined && this.dest !== $$.SUPPRESS) {
+ return this.dest;
+ }
+ return null;
+};
+
+/**
+ * Action#isOptional -> Boolean
+ *
+ * Return true if optional
+ **/
+Action.prototype.isOptional = function () {
+ return !this.isPositional();
+};
+
+/**
+ * Action#isPositional -> Boolean
+ *
+ * Return true if positional
+ **/
+Action.prototype.isPositional = function () {
+ return (this.optionStrings.length === 0);
+};
+
+/**
+ * Action#call(parser, namespace, values, optionString) -> Void
+ * - parser (ArgumentParser): current parser
+ * - namespace (Namespace): namespace for output data
+ * - values (Array): parsed values
+ * - optionString (Array): input option string(not parsed)
+ *
+ * Call the action. Should be implemented in inherited classes
+ *
+ * ##### Example
+ *
+ * ActionCount.prototype.call = function (parser, namespace, values, optionString) {
+ * namespace.set(this.dest, (namespace[this.dest] || 0) + 1);
+ * };
+ *
+ **/
+Action.prototype.call = function () {
+ throw new Error('.call() not defined');// Not Implemented error
+};
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/action/append.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/action/append.js
new file mode 100644
index 0000000..48c6dbe
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/action/append.js
@@ -0,0 +1,55 @@
+/*:nodoc:*
+ * class ActionAppend
+ *
+ * This action stores a list, and appends each argument value to the list.
+ * This is useful to allow an option to be specified multiple times.
+ * This class inherided from [[Action]]
+ *
+ **/
+
+'use strict';
+
+var util = require('util');
+
+var Action = require('../action');
+
+// Constants
+var $$ = require('../const');
+
+/*:nodoc:*
+ * new ActionAppend(options)
+ * - options (object): options hash see [[Action.new]]
+ *
+ * Note: options.nargs should be optional for constants
+ * and more then zero for other
+ **/
+var ActionAppend = module.exports = function ActionAppend(options) {
+ options = options || {};
+ if (this.nargs <= 0) {
+ throw new Error('nargs for append actions must be > 0; if arg ' +
+ 'strings are not supplying the value to append, ' +
+ 'the append const action may be more appropriate');
+ }
+ if (!!this.constant && this.nargs !== $$.OPTIONAL) {
+ throw new Error('nargs must be OPTIONAL to supply const');
+ }
+ Action.call(this, options);
+};
+util.inherits(ActionAppend, Action);
+
+/*:nodoc:*
+ * ActionAppend#call(parser, namespace, values, optionString) -> Void
+ * - parser (ArgumentParser): current parser
+ * - namespace (Namespace): namespace for output data
+ * - values (Array): parsed values
+ * - optionString (Array): input option string(not parsed)
+ *
+ * Call the action. Save result in namespace object
+ **/
+ActionAppend.prototype.call = function (parser, namespace, values) {
+ var items = [].concat(namespace[this.dest] || []); // or _.clone
+ items.push(values);
+ namespace.set(this.dest, items);
+};
+
+
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/action/append/constant.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/action/append/constant.js
new file mode 100644
index 0000000..90747ab
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/action/append/constant.js
@@ -0,0 +1,47 @@
+/*:nodoc:*
+ * class ActionAppendConstant
+ *
+ * This stores a list, and appends the value specified by
+ * the const keyword argument to the list.
+ * (Note that the const keyword argument defaults to null.)
+ * The 'appendConst' action is typically useful when multiple
+ * arguments need to store constants to the same list.
+ *
+ * This class inherited from [[Action]]
+ **/
+
+'use strict';
+
+var util = require('util');
+
+var Action = require('../../action');
+
+/*:nodoc:*
+ * new ActionAppendConstant(options)
+ * - options (object): options hash see [[Action.new]]
+ *
+ **/
+var ActionAppendConstant = module.exports = function ActionAppendConstant(options) {
+ options = options || {};
+ options.nargs = 0;
+ if (options.constant === undefined) {
+ throw new Error('constant option is required for appendAction');
+ }
+ Action.call(this, options);
+};
+util.inherits(ActionAppendConstant, Action);
+
+/*:nodoc:*
+ * ActionAppendConstant#call(parser, namespace, values, optionString) -> Void
+ * - parser (ArgumentParser): current parser
+ * - namespace (Namespace): namespace for output data
+ * - values (Array): parsed values
+ * - optionString (Array): input option string(not parsed)
+ *
+ * Call the action. Save result in namespace object
+ **/
+ActionAppendConstant.prototype.call = function (parser, namespace) {
+ var items = [].concat(namespace[this.dest] || []);
+ items.push(this.constant);
+ namespace.set(this.dest, items);
+};
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/action/count.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/action/count.js
new file mode 100644
index 0000000..d6a5899
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/action/count.js
@@ -0,0 +1,40 @@
+/*:nodoc:*
+ * class ActionCount
+ *
+ * This counts the number of times a keyword argument occurs.
+ * For example, this is useful for increasing verbosity levels
+ *
+ * This class inherided from [[Action]]
+ *
+ **/
+'use strict';
+
+var util = require('util');
+
+var Action = require('../action');
+
+/*:nodoc:*
+ * new ActionCount(options)
+ * - options (object): options hash see [[Action.new]]
+ *
+ **/
+var ActionCount = module.exports = function ActionCount(options) {
+ options = options || {};
+ options.nargs = 0;
+
+ Action.call(this, options);
+};
+util.inherits(ActionCount, Action);
+
+/*:nodoc:*
+ * ActionCount#call(parser, namespace, values, optionString) -> Void
+ * - parser (ArgumentParser): current parser
+ * - namespace (Namespace): namespace for output data
+ * - values (Array): parsed values
+ * - optionString (Array): input option string(not parsed)
+ *
+ * Call the action. Save result in namespace object
+ **/
+ActionCount.prototype.call = function (parser, namespace) {
+ namespace.set(this.dest, (namespace[this.dest] || 0) + 1);
+};
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/action/help.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/action/help.js
new file mode 100644
index 0000000..7f7b4e2
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/action/help.js
@@ -0,0 +1,48 @@
+/*:nodoc:*
+ * class ActionHelp
+ *
+ * Support action for printing help
+ * This class inherided from [[Action]]
+ **/
+'use strict';
+
+var util = require('util');
+
+var Action = require('../action');
+
+// Constants
+var $$ = require('../const');
+
+/*:nodoc:*
+ * new ActionHelp(options)
+ * - options (object): options hash see [[Action.new]]
+ *
+ **/
+var ActionHelp = module.exports = function ActionHelp(options) {
+ options = options || {};
+ if (options.defaultValue !== null) {
+ options.defaultValue = options.defaultValue;
+ }
+ else {
+ options.defaultValue = $$.SUPPRESS;
+ }
+ options.dest = (options.dest !== null ? options.dest: $$.SUPPRESS);
+ options.nargs = 0;
+ Action.call(this, options);
+
+};
+util.inherits(ActionHelp, Action);
+
+/*:nodoc:*
+ * ActionHelp#call(parser, namespace, values, optionString)
+ * - parser (ArgumentParser): current parser
+ * - namespace (Namespace): namespace for output data
+ * - values (Array): parsed values
+ * - optionString (Array): input option string(not parsed)
+ *
+ * Print help and exit
+ **/
+ActionHelp.prototype.call = function (parser) {
+ parser.printHelp();
+ parser.exit();
+};
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/action/store.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/action/store.js
new file mode 100644
index 0000000..8ebc974
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/action/store.js
@@ -0,0 +1,50 @@
+/*:nodoc:*
+ * class ActionStore
+ *
+ * This action just stores the argument’s value. This is the default action.
+ *
+ * This class inherited from [[Action]]
+ *
+ **/
+'use strict';
+
+var util = require('util');
+
+var Action = require('../action');
+
+// Constants
+var $$ = require('../const');
+
+
+/*:nodoc:*
+ * new ActionStore(options)
+ * - options (object): options hash see [[Action.new]]
+ *
+ **/
+var ActionStore = module.exports = function ActionStore(options) {
+ options = options || {};
+ if (this.nargs <= 0) {
+ throw new Error('nargs for store actions must be > 0; if you ' +
+ 'have nothing to store, actions such as store ' +
+ 'true or store const may be more appropriate');
+
+ }
+ if (this.constant !== undefined && this.nargs !== $$.OPTIONAL) {
+ throw new Error('nargs must be OPTIONAL to supply const');
+ }
+ Action.call(this, options);
+};
+util.inherits(ActionStore, Action);
+
+/*:nodoc:*
+ * ActionStore#call(parser, namespace, values, optionString) -> Void
+ * - parser (ArgumentParser): current parser
+ * - namespace (Namespace): namespace for output data
+ * - values (Array): parsed values
+ * - optionString (Array): input option string(not parsed)
+ *
+ * Call the action. Save result in namespace object
+ **/
+ActionStore.prototype.call = function (parser, namespace, values) {
+ namespace.set(this.dest, values);
+};
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/action/store/constant.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/action/store/constant.js
new file mode 100644
index 0000000..8410fcf
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/action/store/constant.js
@@ -0,0 +1,43 @@
+/*:nodoc:*
+ * class ActionStoreConstant
+ *
+ * This action stores the value specified by the const keyword argument.
+ * (Note that the const keyword argument defaults to the rather unhelpful null.)
+ * The 'store_const' action is most commonly used with optional
+ * arguments that specify some sort of flag.
+ *
+ * This class inherited from [[Action]]
+ **/
+'use strict';
+
+var util = require('util');
+
+var Action = require('../../action');
+
+/*:nodoc:*
+ * new ActionStoreConstant(options)
+ * - options (object): options hash see [[Action.new]]
+ *
+ **/
+var ActionStoreConstant = module.exports = function ActionStoreConstant(options) {
+ options = options || {};
+ options.nargs = 0;
+ if (options.constant === undefined) {
+ throw new Error('constant option is required for storeAction');
+ }
+ Action.call(this, options);
+};
+util.inherits(ActionStoreConstant, Action);
+
+/*:nodoc:*
+ * ActionStoreConstant#call(parser, namespace, values, optionString) -> Void
+ * - parser (ArgumentParser): current parser
+ * - namespace (Namespace): namespace for output data
+ * - values (Array): parsed values
+ * - optionString (Array): input option string(not parsed)
+ *
+ * Call the action. Save result in namespace object
+ **/
+ActionStoreConstant.prototype.call = function (parser, namespace) {
+ namespace.set(this.dest, this.constant);
+};
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/action/store/false.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/action/store/false.js
new file mode 100644
index 0000000..66417bf
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/action/store/false.js
@@ -0,0 +1,27 @@
+/*:nodoc:*
+ * class ActionStoreFalse
+ *
+ * This action store the values False respectively.
+ * This is special cases of 'storeConst'
+ *
+ * This class inherited from [[Action]]
+ **/
+
+'use strict';
+
+var util = require('util');
+
+var ActionStoreConstant = require('./constant');
+
+/*:nodoc:*
+ * new ActionStoreFalse(options)
+ * - options (object): hash of options see [[Action.new]]
+ *
+ **/
+var ActionStoreFalse = module.exports = function ActionStoreFalse(options) {
+ options = options || {};
+ options.constant = false;
+ options.defaultValue = options.defaultValue !== null ? options.defaultValue: true;
+ ActionStoreConstant.call(this, options);
+};
+util.inherits(ActionStoreFalse, ActionStoreConstant);
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/action/store/true.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/action/store/true.js
new file mode 100644
index 0000000..43ec708
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/action/store/true.js
@@ -0,0 +1,26 @@
+/*:nodoc:*
+ * class ActionStoreTrue
+ *
+ * This action store the values True respectively.
+ * This isspecial cases of 'storeConst'
+ *
+ * This class inherited from [[Action]]
+ **/
+'use strict';
+
+var util = require('util');
+
+var ActionStoreConstant = require('./constant');
+
+/*:nodoc:*
+ * new ActionStoreTrue(options)
+ * - options (object): options hash see [[Action.new]]
+ *
+ **/
+var ActionStoreTrue = module.exports = function ActionStoreTrue(options) {
+ options = options || {};
+ options.constant = true;
+ options.defaultValue = options.defaultValue !== null ? options.defaultValue: false;
+ ActionStoreConstant.call(this, options);
+};
+util.inherits(ActionStoreTrue, ActionStoreConstant);
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/action/subparsers.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/action/subparsers.js
new file mode 100644
index 0000000..adecf65
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/action/subparsers.js
@@ -0,0 +1,148 @@
+/** internal
+ * class ActionSubparsers
+ *
+ * Support the creation of such sub-commands with the addSubparsers()
+ *
+ * This class inherited from [[Action]]
+ **/
+'use strict';
+
+var util = require('util');
+var format = require('util').format;
+var _ = require('underscore');
+
+
+var Action = require('../action');
+
+// Constants
+var $$ = require('../const');
+
+// Errors
+var argumentErrorHelper = require('../argument/error');
+
+
+/*:nodoc:*
+ * new ChoicesPseudoAction(name, help)
+ *
+ * Create pseudo action for correct help text
+ *
+ **/
+var ChoicesPseudoAction = function (name, help) {
+ var options = {
+ optionStrings: [],
+ dest: name,
+ help: help
+ };
+
+ Action.call(this, options);
+};
+util.inherits(ChoicesPseudoAction, Action);
+
+/**
+ * new ActionSubparsers(options)
+ * - options (object): options hash see [[Action.new]]
+ *
+ **/
+var ActionSubparsers = module.exports = function ActionSubparsers(options) {
+ options = options || {};
+ options.dest = options.dest || $$.SUPPRESS;
+ options.nargs = $$.PARSER;
+
+ this.debug = (options.debug === true);
+
+ this._progPrefix = options.prog;
+ this._parserClass = options.parserClass;
+ this._nameParserMap = {};
+ this._choicesActions = [];
+
+ options.choices = this._nameParserMap;
+ Action.call(this, options);
+};
+util.inherits(ActionSubparsers, Action);
+
+/*:nodoc:*
+ * ActionSubparsers#addParser(name, options) -> ArgumentParser
+ * - name (string): sub-command name
+ * - options (object): see [[ArgumentParser.new]]
+ *
+ * Note:
+ * addParser supports an additional aliases option,
+ * which allows multiple strings to refer to the same subparser.
+ * This example, like svn, aliases co as a shorthand for checkout
+ *
+ **/
+ActionSubparsers.prototype.addParser = function (name, options) {
+ var parser;
+
+ var self = this;
+
+ options = options || {};
+
+ options.debug = (this.debug === true);
+
+ // set program from the existing prefix
+ if (!options.prog) {
+ options.prog = this._progPrefix + ' ' + name;
+ }
+
+ var aliases = options.aliases || [];
+
+ // create a pseudo-action to hold the choice help
+ if (!!options.help || _.isString(options.help)) {
+ var help = options.help;
+ delete options.help;
+
+ var choiceAction = new ChoicesPseudoAction(name, help);
+ this._choicesActions.push(choiceAction);
+ }
+
+ // create the parser and add it to the map
+ parser = new this._parserClass(options);
+ this._nameParserMap[name] = parser;
+
+ // make parser available under aliases also
+ aliases.forEach(function (alias) {
+ self._nameParserMap[alias] = parser;
+ });
+
+ return parser;
+};
+
+ActionSubparsers.prototype._getSubactions = function () {
+ return this._choicesActions;
+};
+
+/*:nodoc:*
+ * ActionSubparsers#call(parser, namespace, values, optionString) -> Void
+ * - parser (ArgumentParser): current parser
+ * - namespace (Namespace): namespace for output data
+ * - values (Array): parsed values
+ * - optionString (Array): input option string(not parsed)
+ *
+ * Call the action. Parse input aguments
+ **/
+ActionSubparsers.prototype.call = function (parser, namespace, values) {
+ var parserName = values[0];
+ var argStrings = values.slice(1);
+
+ // set the parser name if requested
+ if (this.dest !== $$.SUPPRESS) {
+ namespace[this.dest] = parserName;
+ }
+
+ // select the parser
+ if (!!this._nameParserMap[parserName]) {
+ parser = this._nameParserMap[parserName];
+ } else {
+ throw argumentErrorHelper(format(
+ 'Unknown parser "%s" (choices: [%s]).',
+ parserName,
+ _.keys(this._nameParserMap).join(', ')
+ ));
+ }
+
+ // parse all the remaining options into the namespace
+ parser.parseArgs(argStrings, namespace);
+};
+
+
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/action/version.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/action/version.js
new file mode 100644
index 0000000..a17877c
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/action/version.js
@@ -0,0 +1,50 @@
+/*:nodoc:*
+ * class ActionVersion
+ *
+ * Support action for printing program version
+ * This class inherited from [[Action]]
+ **/
+'use strict';
+
+var util = require('util');
+
+var Action = require('../action');
+
+//
+// Constants
+//
+var $$ = require('../const');
+
+/*:nodoc:*
+ * new ActionVersion(options)
+ * - options (object): options hash see [[Action.new]]
+ *
+ **/
+var ActionVersion = module.exports = function ActionVersion(options) {
+ options = options || {};
+ options.defaultValue = (!!options.defaultValue ? options.defaultValue: $$.SUPPRESS);
+ options.dest = (options.dest || $$.SUPPRESS);
+ options.nargs = 0;
+ this.version = options.version;
+ Action.call(this, options);
+};
+util.inherits(ActionVersion, Action);
+
+/*:nodoc:*
+ * ActionVersion#call(parser, namespace, values, optionString) -> Void
+ * - parser (ArgumentParser): current parser
+ * - namespace (Namespace): namespace for output data
+ * - values (Array): parsed values
+ * - optionString (Array): input option string(not parsed)
+ *
+ * Print version and exit
+ **/
+ActionVersion.prototype.call = function (parser) {
+ var version = this.version || parser.version;
+ var formatter = parser._getFormatter();
+ formatter.addText(version);
+ parser.exit(0, formatter.formatHelp());
+};
+
+
+
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/action_container.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/action_container.js
new file mode 100644
index 0000000..dbe3e3c
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/action_container.js
@@ -0,0 +1,481 @@
+/** internal
+ * class ActionContainer
+ *
+ * Action container. Parent for [[ArgumentParser]] and [[ArgumentGroup]]
+ **/
+
+'use strict';
+
+var format = require('util').format;
+var _ = require('underscore');
+
+_.str = require('underscore.string');
+
+// Constants
+var $$ = require('./const');
+
+//Actions
+var ActionHelp = require('./action/help');
+var ActionAppend = require('./action/append');
+var ActionAppendConstant = require('./action/append/constant');
+var ActionCount = require('./action/count');
+var ActionStore = require('./action/store');
+var ActionStoreConstant = require('./action/store/constant');
+var ActionStoreTrue = require('./action/store/true');
+var ActionStoreFalse = require('./action/store/false');
+var ActionVersion = require('./action/version');
+var ActionSubparsers = require('./action/subparsers');
+
+// Errors
+var argumentErrorHelper = require('./argument/error');
+
+
+
+/**
+ * new ActionContainer(options)
+ *
+ * Action container. Parent for [[ArgumentParser]] and [[ArgumentGroup]]
+ *
+ * ##### Options:
+ *
+ * - `description` -- A description of what the program does
+ * - `prefixChars` -- Characters that prefix optional arguments
+ * - `argumentDefault` -- The default value for all arguments
+ * - `conflictHandler` -- The conflict handler to use for duplicate arguments
+ **/
+var ActionContainer = module.exports = function ActionContainer(options) {
+ options = options || {};
+
+ this.description = options.description;
+ this.argumentDefault = options.argumentDefault;
+ this.prefixChars = options.prefixChars || '';
+ this.conflictHandler = options.conflictHandler;
+
+ // set up registries
+ this._registries = {};
+
+ // register actions
+ this.register('action', null, ActionStore);
+ this.register('action', 'store', ActionStore);
+ this.register('action', 'storeConst', ActionStoreConstant);
+ this.register('action', 'storeTrue', ActionStoreTrue);
+ this.register('action', 'storeFalse', ActionStoreFalse);
+ this.register('action', 'append', ActionAppend);
+ this.register('action', 'appendConst', ActionAppendConstant);
+ this.register('action', 'count', ActionCount);
+ this.register('action', 'help', ActionHelp);
+ this.register('action', 'version', ActionVersion);
+ this.register('action', 'parsers', ActionSubparsers);
+
+ // raise an exception if the conflict handler is invalid
+ this._getHandler();
+
+ // action storage
+ this._actions = [];
+ this._optionStringActions = {};
+
+ // groups
+ this._actionGroups = [];
+ this._mutuallyExclusiveGroups = [];
+
+ // defaults storage
+ this._defaults = {};
+
+ // determines whether an "option" looks like a negative number
+ // -1, -1.5 -5e+4
+ this._regexpNegativeNumber = new RegExp('^[-]?[0-9]*\\.?[0-9]+([eE][-+]?[0-9]+)?$');
+
+ // whether or not there are any optionals that look like negative
+ // numbers -- uses a list so it can be shared and edited
+ this._hasNegativeNumberOptionals = [];
+};
+
+// Groups must be required, then ActionContainer already defined
+var ArgumentGroup = require('./argument/group');
+var MutuallyExclusiveGroup = require('./argument/exclusive');
+
+//
+// Registration methods
+//
+
+/**
+ * ActionContainer#register(registryName, value, object) -> Void
+ * - registryName (String) : object type action|type
+ * - value (string) : keyword
+ * - object (Object|Function) : handler
+ *
+ * Register handlers
+ **/
+ActionContainer.prototype.register = function (registryName, value, object) {
+ this._registries[registryName] = this._registries[registryName] || {};
+ this._registries[registryName][value] = object;
+};
+
+ActionContainer.prototype._registryGet = function (registryName, value, defaultValue) {
+ if (3 > arguments.length) {
+ defaultValue = null;
+ }
+ return this._registries[registryName][value] || defaultValue;
+};
+
+//
+// Namespace default accessor methods
+//
+
+/**
+ * ActionContainer#setDefaults(options) -> Void
+ * - options (object):hash of options see [[Action.new]]
+ *
+ * Set defaults
+ **/
+ActionContainer.prototype.setDefaults = function (options) {
+ options = options || {};
+ for (var property in options) {
+ this._defaults[property] = options[property];
+ }
+
+ // if these defaults match any existing arguments, replace the previous
+ // default on the object with the new one
+ this._actions.forEach(function (action) {
+ if (action.dest in options) {
+ action.defaultValue = options[action.dest];
+ }
+ });
+};
+
+/**
+ * ActionContainer#getDefault(dest) -> Mixed
+ * - dest (string): action destination
+ *
+ * Return action default value
+ **/
+ActionContainer.prototype.getDefault = function (dest) {
+ var result = (_.has(this._defaults, dest)) ? this._defaults[dest] : null;
+
+ this._actions.forEach(function (action) {
+ if (action.dest === dest && _.has(action, 'defaultValue')) {
+ result = action.defaultValue;
+ }
+ });
+
+ return result;
+};
+//
+// Adding argument actions
+//
+
+/**
+ * ActionContainer#addArgument(args, options) -> Object
+ * - args (Array): array of argument keys
+ * - options (Object): action objects see [[Action.new]]
+ *
+ * #### Examples
+ * - addArgument([-f, --foo], {action:'store', defaultValue=1, ...})
+ * - addArgument(['bar'], action: 'store', nargs:1, ...})
+ **/
+ActionContainer.prototype.addArgument = function (args, options) {
+ args = args;
+ options = options || {};
+
+ if (!_.isArray(args)) {
+ throw new TypeError('addArgument first argument should be an array');
+ }
+ if (!_.isObject(options) || _.isArray(options)) {
+ throw new TypeError('addArgument second argument should be a hash');
+ }
+
+ // if no positional args are supplied or only one is supplied and
+ // it doesn't look like an option string, parse a positional argument
+ if (!args || args.length === 1 && this.prefixChars.indexOf(args[0][0]) < 0) {
+ if (args && !!options.dest) {
+ throw new Error('dest supplied twice for positional argument');
+ }
+ options = this._getPositional(args, options);
+
+ // otherwise, we're adding an optional argument
+ } else {
+ options = this._getOptional(args, options);
+ }
+
+ // if no default was supplied, use the parser-level default
+ if (_.isUndefined(options.defaultValue)) {
+ var dest = options.dest;
+ if (_.has(this._defaults, dest)) {
+ options.defaultValue = this._defaults[dest];
+ } else if (!_.isUndefined(this.argumentDefault)) {
+ options.defaultValue = this.argumentDefault;
+ }
+ }
+
+ // create the action object, and add it to the parser
+ var ActionClass = this._popActionClass(options);
+ if (! _.isFunction(ActionClass)) {
+ throw new Error(format('Unknown action "%s".', ActionClass));
+ }
+ var action = new ActionClass(options);
+
+ // throw an error if the action type is not callable
+ var typeFunction = this._registryGet('type', action.type, action.type);
+ if (!_.isFunction(typeFunction)) {
+ throw new Error(format('"%s" is not callable', typeFunction));
+ }
+
+ return this._addAction(action);
+};
+
+/**
+ * ActionContainer#addArgumentGroup(options) -> ArgumentGroup
+ * - options (Object): hash of options see [[ArgumentGroup.new]]
+ *
+ * Create new arguments groups
+ **/
+ActionContainer.prototype.addArgumentGroup = function (options) {
+ var group = new ArgumentGroup(this, options);
+ this._actionGroups.push(group);
+ return group;
+};
+
+/**
+ * ActionContainer#addMutuallyExclusiveGroup(options) -> ArgumentGroup
+ * - options (Object): {required: false}
+ *
+ * Create new mutual exclusive groups
+ **/
+ActionContainer.prototype.addMutuallyExclusiveGroup = function (options) {
+ var group = new MutuallyExclusiveGroup(this, options);
+ this._mutuallyExclusiveGroups.push(group);
+ return group;
+};
+
+ActionContainer.prototype._addAction = function (action) {
+ var self = this;
+
+ // resolve any conflicts
+ this._checkConflict(action);
+
+ // add to actions list
+ this._actions.push(action);
+ action.container = this;
+
+ // index the action by any option strings it has
+ action.optionStrings.forEach(function (optionString) {
+ self._optionStringActions[optionString] = action;
+ });
+
+ // set the flag if any option strings look like negative numbers
+ action.optionStrings.forEach(function (optionString) {
+ if (optionString.match(self._regexpNegativeNumber)) {
+ if (!_.any(self._hasNegativeNumberOptionals)) {
+ self._hasNegativeNumberOptionals.push(true);
+ }
+ }
+ });
+
+ // return the created action
+ return action;
+};
+
+ActionContainer.prototype._removeAction = function (action) {
+ var actionIndex = this._actions.indexOf(action);
+ if (actionIndex >= 0) {
+ this._actions.splice(actionIndex, 1);
+ }
+};
+
+ActionContainer.prototype._addContainerActions = function (container) {
+ // collect groups by titles
+ var titleGroupMap = {};
+ this._actionGroups.forEach(function (group) {
+ if (titleGroupMap[group.title]) {
+ throw new Error(format('Cannot merge actions - two groups are named "%s".', group.title));
+ }
+ titleGroupMap[group.title] = group;
+ });
+
+ // map each action to its group
+ var groupMap = {};
+ function actionHash(action) {
+ // unique (hopefully?) string suitable as dictionary key
+ return action.getName();
+ }
+ container._actionGroups.forEach(function (group) {
+ // if a group with the title exists, use that, otherwise
+ // create a new group matching the container's group
+ if (!titleGroupMap[group.title]) {
+ titleGroupMap[group.title] = this.addArgumentGroup({
+ title: group.title,
+ description: group.description
+ });
+ }
+
+ // map the actions to their new group
+ group._groupActions.forEach(function (action) {
+ groupMap[actionHash(action)] = titleGroupMap[group.title];
+ });
+ }, this);
+
+ // add container's mutually exclusive groups
+ // NOTE: if add_mutually_exclusive_group ever gains title= and
+ // description= then this code will need to be expanded as above
+ var mutexGroup;
+ container._mutuallyExclusiveGroups.forEach(function (group) {
+ mutexGroup = this.addMutuallyExclusiveGroup({
+ required: group.required
+ });
+ // map the actions to their new mutex group
+ group._groupActions.forEach(function (action) {
+ groupMap[actionHash(action)] = mutexGroup;
+ });
+ }, this); // forEach takes a 'this' argument
+
+ // add all actions to this container or their group
+ container._actions.forEach(function (action) {
+ var key = actionHash(action);
+ if (!!groupMap[key]) {
+ groupMap[key]._addAction(action);
+ }
+ else
+ {
+ this._addAction(action);
+ }
+ });
+};
+
+ActionContainer.prototype._getPositional = function (dest, options) {
+ if (_.isArray(dest)) {
+ dest = _.first(dest);
+ }
+ // make sure required is not specified
+ if (options.required) {
+ throw new Error('"required" is an invalid argument for positionals.');
+ }
+
+ // mark positional arguments as required if at least one is
+ // always required
+ if (options.nargs !== $$.OPTIONAL && options.nargs !== $$.ZERO_OR_MORE) {
+ options.required = true;
+ }
+ if (options.nargs === $$.ZERO_OR_MORE && options.defaultValue === undefined) {
+ options.required = true;
+ }
+
+ // return the keyword arguments with no option strings
+ options.dest = dest;
+ options.optionStrings = [];
+ return options;
+};
+
+ActionContainer.prototype._getOptional = function (args, options) {
+ var prefixChars = this.prefixChars;
+ var optionStrings = [];
+ var optionStringsLong = [];
+
+ // determine short and long option strings
+ args.forEach(function (optionString) {
+ // error on strings that don't start with an appropriate prefix
+ if (prefixChars.indexOf(optionString[0]) < 0) {
+ throw new Error(format('Invalid option string "%s": must start with a "%s".',
+ optionString,
+ prefixChars
+ ));
+ }
+
+ // strings starting with two prefix characters are long options
+ optionStrings.push(optionString);
+ if (optionString.length > 1 && prefixChars.indexOf(optionString[1]) >= 0) {
+ optionStringsLong.push(optionString);
+ }
+ });
+
+ // infer dest, '--foo-bar' -> 'foo_bar' and '-x' -> 'x'
+ var dest = options.dest || null;
+ delete options.dest;
+
+ if (!dest) {
+ var optionStringDest = optionStringsLong.length ? optionStringsLong[0] :optionStrings[0];
+ dest = _.str.strip(optionStringDest, this.prefixChars);
+
+ if (dest.length === 0) {
+ throw new Error(
+ format('dest= is required for options like "%s"', optionStrings.join(', '))
+ );
+ }
+ dest = dest.replace(/-/g, '_');
+ }
+
+ // return the updated keyword arguments
+ options.dest = dest;
+ options.optionStrings = optionStrings;
+
+ return options;
+};
+
+ActionContainer.prototype._popActionClass = function (options, defaultValue) {
+ defaultValue = defaultValue || null;
+
+ var action = (options.action || defaultValue);
+ delete options.action;
+
+ var actionClass = this._registryGet('action', action, action);
+ return actionClass;
+};
+
+ActionContainer.prototype._getHandler = function () {
+ var handlerString = this.conflictHandler;
+ var handlerFuncName = "_handleConflict" + _.str.capitalize(handlerString);
+ var func = this[handlerFuncName];
+ if (typeof func === 'undefined') {
+ var msg = "invalid conflict resolution value: " + handlerString;
+ throw new Error(msg);
+ } else {
+ return func;
+ }
+};
+
+ActionContainer.prototype._checkConflict = function (action) {
+ var optionStringActions = this._optionStringActions;
+ var conflictOptionals = [];
+
+ // find all options that conflict with this option
+ // collect pairs, the string, and an existing action that it conflicts with
+ action.optionStrings.forEach(function (optionString) {
+ var conflOptional = optionStringActions[optionString];
+ if (typeof conflOptional !== 'undefined') {
+ conflictOptionals.push([optionString, conflOptional]);
+ }
+ });
+
+ if (conflictOptionals.length > 0) {
+ var conflictHandler = this._getHandler();
+ conflictHandler.call(this, action, conflictOptionals);
+ }
+};
+
+ActionContainer.prototype._handleConflictError = function (action, conflOptionals) {
+ var conflicts = _.map(conflOptionals, function (pair) {return pair[0]; });
+ conflicts = conflicts.join(', ');
+ throw argumentErrorHelper(
+ action,
+ format('Conflicting option string(s): %s', conflicts)
+ );
+};
+
+ActionContainer.prototype._handleConflictResolve = function (action, conflOptionals) {
+ // remove all conflicting options
+ var self = this;
+ conflOptionals.forEach(function (pair) {
+ var optionString = pair[0];
+ var conflictingAction = pair[1];
+ // remove the conflicting option string
+ var i = conflictingAction.optionStrings.indexOf(optionString);
+ if (i >= 0) {
+ conflictingAction.optionStrings.splice(i, 1);
+ }
+ delete self._optionStringActions[optionString];
+ // if the option now has no option string, remove it from the
+ // container holding it
+ if (conflictingAction.optionStrings.length === 0) {
+ conflictingAction.container._removeAction(conflictingAction);
+ }
+ });
+};
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/argparse.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/argparse.js
new file mode 100644
index 0000000..f2a2c51
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/argparse.js
@@ -0,0 +1,14 @@
+'use strict';
+
+module.exports.ArgumentParser = require('./argument_parser.js');
+module.exports.Namespace = require('./namespace');
+module.exports.Action = require('./action');
+module.exports.HelpFormatter = require('./help/formatter.js');
+module.exports.Const = require('./const.js');
+
+module.exports.ArgumentDefaultsHelpFormatter =
+ require('./help/added_formatters.js').ArgumentDefaultsHelpFormatter;
+module.exports.RawDescriptionHelpFormatter =
+ require('./help/added_formatters.js').RawDescriptionHelpFormatter;
+module.exports.RawTextHelpFormatter =
+ require('./help/added_formatters.js').RawTextHelpFormatter;
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/argument/error.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/argument/error.js
new file mode 100644
index 0000000..c8a02a0
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/argument/error.js
@@ -0,0 +1,50 @@
+'use strict';
+
+
+var format = require('util').format;
+
+
+var ERR_CODE = 'ARGError';
+
+/*:nodoc:*
+ * argumentError(argument, message) -> TypeError
+ * - argument (Object): action with broken argument
+ * - message (String): error message
+ *
+ * Error format helper. An error from creating or using an argument
+ * (optional or positional). The string value of this exception
+ * is the message, augmented with information
+ * about the argument that caused it.
+ *
+ * #####Example
+ *
+ * var argumentErrorHelper = require('./argument/error');
+ * if (conflictOptionals.length > 0) {
+ * throw argumentErrorHelper(
+ * action,
+ * format('Conflicting option string(s): %s', conflictOptionals.join(', '))
+ * );
+ * }
+ *
+ **/
+module.exports = function (argument, message) {
+ var argumentName = null;
+ var errMessage;
+ var err;
+
+ if (argument.getName) {
+ argumentName = argument.getName();
+ } else {
+ argumentName = '' + argument;
+ }
+
+ if (!argumentName) {
+ errMessage = message;
+ } else {
+ errMessage = format('argument "%s": %s', argumentName, message);
+ }
+
+ err = new TypeError(errMessage);
+ err.code = ERR_CODE;
+ return err;
+};
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/argument/exclusive.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/argument/exclusive.js
new file mode 100644
index 0000000..8287e00
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/argument/exclusive.js
@@ -0,0 +1,54 @@
+/** internal
+ * class MutuallyExclusiveGroup
+ *
+ * Group arguments.
+ * By default, ArgumentParser groups command-line arguments
+ * into “positional arguments” and “optional arguments”
+ * when displaying help messages. When there is a better
+ * conceptual grouping of arguments than this default one,
+ * appropriate groups can be created using the addArgumentGroup() method
+ *
+ * This class inherited from [[ArgumentContainer]]
+ **/
+'use strict';
+
+var util = require('util');
+
+var ArgumentGroup = require('./group');
+
+/**
+ * new MutuallyExclusiveGroup(container, options)
+ * - container (object): main container
+ * - options (object): options.required -> true/false
+ *
+ * `required` could be an argument itself, but making it a property of
+ * the options argument is more consistent with the JS adaptation of the Python)
+ **/
+var MutuallyExclusiveGroup = module.exports = function MutuallyExclusiveGroup(container, options) {
+ var required;
+ options = options || {};
+ required = options.required || false;
+ ArgumentGroup.call(this, container);
+ this.required = required;
+
+};
+util.inherits(MutuallyExclusiveGroup, ArgumentGroup);
+
+
+MutuallyExclusiveGroup.prototype._addAction = function (action) {
+ var msg;
+ if (action.required) {
+ msg = 'mutually exclusive arguments must be optional';
+ throw new Error(msg);
+ }
+ action = this._container._addAction(action);
+ this._groupActions.push(action);
+ return action;
+};
+
+
+MutuallyExclusiveGroup.prototype._removeAction = function (action) {
+ this._container._removeAction(action);
+ this._groupActions.remove(action);
+};
+
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/argument/group.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/argument/group.js
new file mode 100644
index 0000000..58b271f
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/argument/group.js
@@ -0,0 +1,75 @@
+/** internal
+ * class ArgumentGroup
+ *
+ * Group arguments.
+ * By default, ArgumentParser groups command-line arguments
+ * into “positional arguments” and “optional arguments”
+ * when displaying help messages. When there is a better
+ * conceptual grouping of arguments than this default one,
+ * appropriate groups can be created using the addArgumentGroup() method
+ *
+ * This class inherited from [[ArgumentContainer]]
+ **/
+'use strict';
+
+var util = require('util');
+
+var ActionContainer = require('../action_container');
+
+
+/**
+ * new ArgumentGroup(container, options)
+ * - container (object): main container
+ * - options (object): hash of group options
+ *
+ * #### options
+ * - **prefixChars** group name prefix
+ * - **argumentDefault** default argument value
+ * - **title** group title
+ * - **description** group description
+ *
+ **/
+var ArgumentGroup = module.exports = function ArgumentGroup(container, options) {
+
+ options = options || {};
+
+ // add any missing keyword arguments by checking the container
+ options.conflictHandler = (options.conflictHandler || container.conflictHandler);
+ options.prefixChars = (options.prefixChars || container.prefixChars);
+ options.argumentDefault = (options.argumentDefault || container.argumentDefault);
+
+ ActionContainer.call(this, options);
+
+ // group attributes
+ this.title = options.title;
+ this._groupActions = [];
+
+ // share most attributes with the container
+ this._container = container;
+ this._registries = container._registries;
+ this._actions = container._actions;
+ this._optionStringActions = container._optionStringActions;
+ this._defaults = container._defaults;
+ this._hasNegativeNumberOptionals = container._hasNegativeNumberOptionals;
+ this._mutuallyExclusiveGroups = container._mutuallyExclusiveGroups;
+};
+util.inherits(ArgumentGroup, ActionContainer);
+
+
+ArgumentGroup.prototype._addAction = function (action) {
+ // Parent add action
+ action = ActionContainer.prototype._addAction.call(this, action);
+ this._groupActions.push(action);
+ return action;
+};
+
+
+ArgumentGroup.prototype._removeAction = function (action) {
+ // Parent remove action
+ ActionContainer.prototype._removeAction.call(this, action);
+ var actionIndex = this._groupActions.indexOf(action);
+ if (actionIndex >= 0) {
+ this._groupActions.splice(actionIndex, 1);
+ }
+};
+
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/argument_parser.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/argument_parser.js
new file mode 100644
index 0000000..103c337
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/argument_parser.js
@@ -0,0 +1,1168 @@
+/**
+ * class ArgumentParser
+ *
+ * Object for parsing command line strings into js objects.
+ *
+ * Inherited from [[ActionContainer]]
+ **/
+'use strict';
+
+var util = require('util');
+var format = require('util').format;
+var Path = require('path');
+
+var _ = require('underscore');
+_.str = require('underscore.string');
+
+// Constants
+var $$ = require('./const');
+
+var ActionContainer = require('./action_container');
+
+// Errors
+var argumentErrorHelper = require('./argument/error');
+
+var HelpFormatter = require('./help/formatter');
+
+var Namespace = require('./namespace');
+
+
+/**
+ * new ArgumentParser(options)
+ *
+ * Create a new ArgumentParser object.
+ *
+ * ##### Options:
+ * - `prog` The name of the program (default: Path.basename(process.argv[1]))
+ * - `usage` A usage message (default: auto-generated from arguments)
+ * - `description` A description of what the program does
+ * - `epilog` Text following the argument descriptions
+ * - `parents` Parsers whose arguments should be copied into this one
+ * - `formatterClass` HelpFormatter class for printing help messages
+ * - `prefixChars` Characters that prefix optional arguments
+ * - `fromfilePrefixChars` Characters that prefix files containing additional arguments
+ * - `argumentDefault` The default value for all arguments
+ * - `addHelp` Add a -h/-help option
+ * - `conflictHandler` Specifies how to handle conflicting argument names
+ * - `debug` Enable debug mode. Argument errors throw exception in
+ * debug mode and process.exit in normal. Used for development and
+ * testing (default: false)
+ *
+ * See also [original guide][1]
+ *
+ * [1]:http://docs.python.org/dev/library/argparse.html#argumentparser-objects
+ **/
+var ArgumentParser = module.exports = function ArgumentParser(options) {
+ var self = this;
+ options = options || {};
+
+ options.description = (options.description || null);
+ options.argumentDefault = (options.argumentDefault || null);
+ options.prefixChars = (options.prefixChars || '-');
+ options.conflictHandler = (options.conflictHandler || 'error');
+ ActionContainer.call(this, options);
+
+ options.addHelp = (options.addHelp === undefined || !!options.addHelp);
+ options.parents = (options.parents || []);
+ // default program name
+ options.prog = (options.prog || Path.basename(process.argv[1]));
+ this.prog = options.prog;
+ this.usage = options.usage;
+ this.epilog = options.epilog;
+ this.version = options.version;
+
+ this.debug = (options.debug === true);
+
+ this.formatterClass = (options.formatterClass || HelpFormatter);
+ this.fromfilePrefixChars = options.fromfilePrefixChars || null;
+ this._positionals = this.addArgumentGroup({title: 'Positional arguments'});
+ this._optionals = this.addArgumentGroup({title: 'Optional arguments'});
+ this._subparsers = null;
+
+ // register types
+ var FUNCTION_IDENTITY = function (o) {
+ return o;
+ };
+ this.register('type', 'auto', FUNCTION_IDENTITY);
+ this.register('type', null, FUNCTION_IDENTITY);
+ this.register('type', 'int', function (x) {
+ var result = parseInt(x, 10);
+ if (isNaN(result)) {
+ throw new Error(x + ' is not a valid integer.');
+ }
+ return result;
+ });
+ this.register('type', 'float', function (x) {
+ var result = parseFloat(x);
+ if (isNaN(result)) {
+ throw new Error(x + ' is not a valid float.');
+ }
+ return result;
+ });
+ this.register('type', 'string', function (x) {
+ return '' + x;
+ });
+
+ // add help and version arguments if necessary
+ var defaultPrefix = (this.prefixChars.indexOf('-') > -1) ? '-' : this.prefixChars[0];
+ if (options.addHelp) {
+ this.addArgument(
+ [defaultPrefix + 'h', defaultPrefix + defaultPrefix + 'help'],
+ {
+ action: 'help',
+ defaultValue: $$.SUPPRESS,
+ help: 'Show this help message and exit.'
+ }
+ );
+ }
+ if (this.version !== undefined) {
+ this.addArgument(
+ [defaultPrefix + 'v', defaultPrefix + defaultPrefix + 'version'],
+ {
+ action: 'version',
+ version: this.version,
+ defaultValue: $$.SUPPRESS,
+ help: "Show program's version number and exit."
+ }
+ );
+ }
+
+ // add parent arguments and defaults
+ options.parents.forEach(function (parent) {
+ self._addContainerActions(parent);
+ if (parent._defaults !== undefined) {
+ for (var defaultKey in parent._defaults) {
+ if (parent._defaults.hasOwnProperty(defaultKey)) {
+ self._defaults[defaultKey] = parent._defaults[defaultKey];
+ }
+ }
+ }
+ });
+
+};
+util.inherits(ArgumentParser, ActionContainer);
+
+/**
+ * ArgumentParser#addSubparsers(options) -> [[ActionSubparsers]]
+ * - options (object): hash of options see [[ActionSubparsers.new]]
+ *
+ * See also [subcommands][1]
+ *
+ * [1]:http://docs.python.org/dev/library/argparse.html#sub-commands
+ **/
+ArgumentParser.prototype.addSubparsers = function (options) {
+ if (!!this._subparsers) {
+ this.error('Cannot have multiple subparser arguments.');
+ }
+
+ options = options || {};
+ options.debug = (this.debug === true);
+ options.optionStrings = [];
+ options.parserClass = (options.parserClass || ArgumentParser);
+
+
+ if (!!options.title || !!options.description) {
+
+ this._subparsers = this.addArgumentGroup({
+ title: (options.title || 'subcommands'),
+ description: options.description
+ });
+ delete options.title;
+ delete options.description;
+
+ } else {
+ this._subparsers = this._positionals;
+ }
+
+ // prog defaults to the usage message of this parser, skipping
+ // optional arguments and with no "usage:" prefix
+ if (!options.prog) {
+ var formatter = this._getFormatter();
+ var positionals = this._getPositionalActions();
+ var groups = this._mutuallyExclusiveGroups;
+ formatter.addUsage(this.usage, positionals, groups, '');
+ options.prog = _.str.strip(formatter.formatHelp());
+ }
+
+ // create the parsers action and add it to the positionals list
+ var ParsersClass = this._popActionClass(options, 'parsers');
+ var action = new ParsersClass(options);
+ this._subparsers._addAction(action);
+
+ // return the created parsers action
+ return action;
+};
+
+ArgumentParser.prototype._addAction = function (action) {
+ if (action.isOptional()) {
+ this._optionals._addAction(action);
+ } else {
+ this._positionals._addAction(action);
+ }
+ return action;
+};
+
+ArgumentParser.prototype._getOptionalActions = function () {
+ return this._actions.filter(function (action) {
+ return action.isOptional();
+ });
+};
+
+ArgumentParser.prototype._getPositionalActions = function () {
+ return this._actions.filter(function (action) {
+ return action.isPositional();
+ });
+};
+
+
+/**
+ * ArgumentParser#parseArgs(args, namespace) -> Namespace|Object
+ * - args (array): input elements
+ * - namespace (Namespace|Object): result object
+ *
+ * Parsed args and throws error if some arguments are not recognized
+ *
+ * See also [original guide][1]
+ *
+ * [1]:http://docs.python.org/dev/library/argparse.html#the-parse-args-method
+ **/
+ArgumentParser.prototype.parseArgs = function (args, namespace) {
+ var argv;
+ var result = this.parseKnownArgs(args, namespace);
+
+ args = result[0];
+ argv = result[1];
+ if (argv && argv.length > 0) {
+ this.error(
+ format('Unrecognized arguments: %s.', argv.join(' '))
+ );
+ }
+ return args;
+};
+
+/**
+ * ArgumentParser#parseKnownArgs(args, namespace) -> array
+ * - args (array): input options
+ * - namespace (Namespace|Object): result object
+ *
+ * Parse known arguments and return tuple of result object
+ * and unknown args
+ *
+ * See also [original guide][1]
+ *
+ * [1]:http://docs.python.org/dev/library/argparse.html#partial-parsing
+ **/
+ArgumentParser.prototype.parseKnownArgs = function (args, namespace) {
+ var self = this;
+
+ // args default to the system args
+ args = args || process.argv.slice(2);
+
+ // default Namespace built from parser defaults
+ namespace = namespace || new Namespace();
+
+ self._actions.forEach(function (action) {
+ if (action.dest !== $$.SUPPRESS) {
+ if (!_.has(namespace, action.dest)) {
+ if (action.defaultValue !== $$.SUPPRESS) {
+ var defaultValue = action.defaultValue;
+ if (_.isString(action.defaultValue)) {
+ defaultValue = self._getValue(action, defaultValue);
+ }
+ namespace[action.dest] = defaultValue;
+ }
+ }
+ }
+ });
+
+ _.keys(self._defaults).forEach(function (dest) {
+ namespace[dest] = self._defaults[dest];
+ });
+
+ // parse the arguments and exit if there are any errors
+ try {
+ var res = this._parseKnownArgs(args, namespace);
+
+ namespace = res[0];
+ args = res[1];
+ if (_.has(namespace, $$._UNRECOGNIZED_ARGS_ATTR)) {
+ args = _.union(args, namespace[$$._UNRECOGNIZED_ARGS_ATTR]);
+ delete namespace[$$._UNRECOGNIZED_ARGS_ATTR];
+ }
+ return [namespace, args];
+ } catch (e) {
+ this.error(e);
+ }
+};
+
+ArgumentParser.prototype._parseKnownArgs = function (argStrings, namespace) {
+ var self = this;
+
+ var extras = [];
+
+ // replace arg strings that are file references
+ if (this.fromfilePrefixChars !== null) {
+ argStrings = this._readArgsFromFiles(argStrings);
+ }
+ // map all mutually exclusive arguments to the other arguments
+ // they can't occur with
+ // Python has 'conflicts = action_conflicts.setdefault(mutex_action, [])'
+ // though I can't conceive of a way in which an action could be a member
+ // of two different mutually exclusive groups.
+
+ function actionHash(action) {
+ // some sort of hashable key for this action
+ // action itself cannot be a key in actionConflicts
+ // I think getName() (join of optionStrings) is unique enough
+ return action.getName();
+ }
+
+ var conflicts, key;
+ var actionConflicts = {};
+
+ this._mutuallyExclusiveGroups.forEach(function (mutexGroup) {
+ mutexGroup._groupActions.forEach(function (mutexAction, i, groupActions) {
+ key = actionHash(mutexAction);
+ if (!_.has(actionConflicts, key)) {
+ actionConflicts[key] = [];
+ }
+ conflicts = actionConflicts[key];
+ conflicts.push.apply(conflicts, groupActions.slice(0, i));
+ conflicts.push.apply(conflicts, groupActions.slice(i + 1));
+ });
+ });
+
+ // find all option indices, and determine the arg_string_pattern
+ // which has an 'O' if there is an option at an index,
+ // an 'A' if there is an argument, or a '-' if there is a '--'
+ var optionStringIndices = {};
+
+ var argStringPatternParts = [];
+
+ argStrings.forEach(function (argString, argStringIndex) {
+ if (argString === '--') {
+ argStringPatternParts.push('-');
+ while (argStringIndex < argStrings.length) {
+ argStringPatternParts.push('A');
+ argStringIndex++;
+ }
+ }
+ // otherwise, add the arg to the arg strings
+ // and note the index if it was an option
+ else {
+ var pattern;
+ var optionTuple = self._parseOptional(argString);
+ if (!optionTuple) {
+ pattern = 'A';
+ }
+ else {
+ optionStringIndices[argStringIndex] = optionTuple;
+ pattern = 'O';
+ }
+ argStringPatternParts.push(pattern);
+ }
+ });
+ var argStringsPattern = argStringPatternParts.join('');
+
+ var seenActions = [];
+ var seenNonDefaultActions = [];
+
+
+ function takeAction(action, argumentStrings, optionString) {
+ seenActions.push(action);
+ var argumentValues = self._getValues(action, argumentStrings);
+
+ // error if this argument is not allowed with other previously
+ // seen arguments, assuming that actions that use the default
+ // value don't really count as "present"
+ if (argumentValues !== action.defaultValue) {
+ seenNonDefaultActions.push(action);
+ if (!!actionConflicts[actionHash(action)]) {
+ actionConflicts[actionHash(action)].forEach(function (actionConflict) {
+ if (seenNonDefaultActions.indexOf(actionConflict) >= 0) {
+ throw argumentErrorHelper(
+ action,
+ format('Not allowed with argument "%s".', actionConflict.getName())
+ );
+ }
+ });
+ }
+ }
+
+ if (argumentValues !== $$.SUPPRESS) {
+ action.call(self, namespace, argumentValues, optionString);
+ }
+ }
+
+ function consumeOptional(startIndex) {
+ // get the optional identified at this index
+ var optionTuple = optionStringIndices[startIndex];
+ var action = optionTuple[0];
+ var optionString = optionTuple[1];
+ var explicitArg = optionTuple[2];
+
+ // identify additional optionals in the same arg string
+ // (e.g. -xyz is the same as -x -y -z if no args are required)
+ var actionTuples = [];
+
+ var args, argCount, start, stop;
+
+ while (true) {
+ if (!action) {
+ extras.push(argStrings[startIndex]);
+ return startIndex + 1;
+ }
+ if (!!explicitArg) {
+ argCount = self._matchArgument(action, 'A');
+
+ // if the action is a single-dash option and takes no
+ // arguments, try to parse more single-dash options out
+ // of the tail of the option string
+ var chars = self.prefixChars;
+ if (argCount === 0 && chars.indexOf(optionString[1]) < 0) {
+ actionTuples.push([action, [], optionString]);
+ optionString = optionString[0] + explicitArg[0];
+ var newExplicitArg = explicitArg.slice(1) || null;
+ var optionalsMap = self._optionStringActions;
+
+ if (_.keys(optionalsMap).indexOf(optionString) >= 0) {
+ action = optionalsMap[optionString];
+ explicitArg = newExplicitArg;
+ }
+ else {
+ var msg = 'ignored explicit argument %r';
+ throw argumentErrorHelper(action, msg);
+ }
+ }
+ // if the action expect exactly one argument, we've
+ // successfully matched the option; exit the loop
+ else if (argCount === 1) {
+ stop = startIndex + 1;
+ args = [explicitArg];
+ actionTuples.push([action, args, optionString]);
+ break;
+ }
+ // error if a double-dash option did not use the
+ // explicit argument
+ else {
+ var message = 'ignored explicit argument %r';
+ throw argumentErrorHelper(action, _.str.sprintf(message, explicitArg));
+ }
+ }
+ // if there is no explicit argument, try to match the
+ // optional's string arguments with the following strings
+ // if successful, exit the loop
+ else {
+
+ start = startIndex + 1;
+ var selectedPatterns = argStringsPattern.substr(start);
+
+ argCount = self._matchArgument(action, selectedPatterns);
+ stop = start + argCount;
+
+
+ args = argStrings.slice(start, stop);
+
+ actionTuples.push([action, args, optionString]);
+ break;
+ }
+
+ }
+
+ // add the Optional to the list and return the index at which
+ // the Optional's string args stopped
+ if (actionTuples.length < 1) {
+ throw new Error('length should be > 0');
+ }
+ for (var i = 0; i < actionTuples.length; i++) {
+ takeAction.apply(self, actionTuples[i]);
+ }
+ return stop;
+ }
+
+ // the list of Positionals left to be parsed; this is modified
+ // by consume_positionals()
+ var positionals = self._getPositionalActions();
+
+ function consumePositionals(startIndex) {
+ // match as many Positionals as possible
+ var selectedPattern = argStringsPattern.substr(startIndex);
+ var argCounts = self._matchArgumentsPartial(positionals, selectedPattern);
+
+ // slice off the appropriate arg strings for each Positional
+ // and add the Positional and its args to the list
+ _.zip(positionals, argCounts).forEach(function (item) {
+ var action = item[0];
+ var argCount = item[1];
+ if (argCount === undefined) {
+ return;
+ }
+ var args = argStrings.slice(startIndex, startIndex + argCount);
+
+ startIndex += argCount;
+ takeAction(action, args);
+ });
+
+ // slice off the Positionals that we just parsed and return the
+ // index at which the Positionals' string args stopped
+ positionals = positionals.slice(argCounts.length);
+ return startIndex;
+ }
+
+ // consume Positionals and Optionals alternately, until we have
+ // passed the last option string
+ var startIndex = 0;
+ var position;
+
+ var maxOptionStringIndex = -1;
+
+ Object.keys(optionStringIndices).forEach(function (position) {
+ maxOptionStringIndex = Math.max(maxOptionStringIndex, parseInt(position, 10));
+ });
+
+ var positionalsEndIndex, nextOptionStringIndex;
+
+ while (startIndex <= maxOptionStringIndex) {
+ // consume any Positionals preceding the next option
+ nextOptionStringIndex = null;
+ for (position in optionStringIndices) {
+ if (!optionStringIndices.hasOwnProperty(position)) { continue; }
+
+ position = parseInt(position, 10);
+ if (position >= startIndex) {
+ if (nextOptionStringIndex !== null) {
+ nextOptionStringIndex = Math.min(nextOptionStringIndex, position);
+ }
+ else {
+ nextOptionStringIndex = position;
+ }
+ }
+ }
+
+ if (startIndex !== nextOptionStringIndex) {
+ positionalsEndIndex = consumePositionals(startIndex);
+ // only try to parse the next optional if we didn't consume
+ // the option string during the positionals parsing
+ if (positionalsEndIndex > startIndex) {
+ startIndex = positionalsEndIndex;
+ continue;
+ }
+ else {
+ startIndex = positionalsEndIndex;
+ }
+ }
+
+ // if we consumed all the positionals we could and we're not
+ // at the index of an option string, there were extra arguments
+ if (!optionStringIndices[startIndex]) {
+ var strings = argStrings.slice(startIndex, nextOptionStringIndex);
+ extras = extras.concat(strings);
+ startIndex = nextOptionStringIndex;
+ }
+ // consume the next optional and any arguments for it
+ startIndex = consumeOptional(startIndex);
+ }
+
+ // consume any positionals following the last Optional
+ var stopIndex = consumePositionals(startIndex);
+
+ // if we didn't consume all the argument strings, there were extras
+ extras = extras.concat(_.rest(argStrings, stopIndex));
+
+ // if we didn't use all the Positional objects, there were too few
+ // arg strings supplied.
+ if (positionals.length > 0) {
+ self.error('too few arguments');
+ }
+
+ // make sure all required actions were present
+ self._actions.forEach(function (action) {
+ if (action.required) {
+ if (_.indexOf(seenActions, action) < 0) {
+ self.error(format('Argument "%s" is required', action.getName()));
+ }
+ }
+ });
+
+ // make sure all required groups have one option present
+ var actionUsed = false;
+ self._mutuallyExclusiveGroups.forEach(function (group) {
+ if (group.required) {
+ actionUsed = _.any(group._groupActions, function (action) {
+ return _.contains(seenNonDefaultActions, action);
+ });
+
+ // if no actions were used, report the error
+ if (!actionUsed) {
+ var names = [];
+ group._groupActions.forEach(function (action) {
+ if (action.help !== $$.SUPPRESS) {
+ names.push(action.getName());
+ }
+ });
+ names = names.join(' ');
+ var msg = 'one of the arguments ' + names + ' is required';
+ self.error(msg);
+ }
+ }
+ });
+
+ // return the updated namespace and the extra arguments
+ return [namespace, extras];
+};
+
+ArgumentParser.prototype._readArgsFromFiles = function (argStrings) {
+ // expand arguments referencing files
+ var _this = this;
+ var fs = require('fs');
+ var newArgStrings = [];
+ argStrings.forEach(function (argString) {
+ if (_this.fromfilePrefixChars.indexOf(argString[0]) < 0) {
+ // for regular arguments, just add them back into the list
+ newArgStrings.push(argString);
+ } else {
+ // replace arguments referencing files with the file content
+ try {
+ var argstrs = [];
+ var filename = argString.slice(1);
+ var content = fs.readFileSync(filename, 'utf8');
+ content = content.trim().split('\n');
+ content.forEach(function (argLine) {
+ _this.convertArgLineToArgs(argLine).forEach(function (arg) {
+ argstrs.push(arg);
+ });
+ argstrs = _this._readArgsFromFiles(argstrs);
+ });
+ newArgStrings.push.apply(newArgStrings, argstrs);
+ } catch (error) {
+ return _this.error(error.message);
+ }
+ }
+ });
+ return newArgStrings;
+};
+
+ArgumentParser.prototype.convertArgLineToArgs = function (argLine) {
+ return [argLine];
+};
+
+ArgumentParser.prototype._matchArgument = function (action, regexpArgStrings) {
+
+ // match the pattern for this action to the arg strings
+ var regexpNargs = new RegExp('^' + this._getNargsPattern(action));
+ var matches = regexpArgStrings.match(regexpNargs);
+ var message;
+
+ // throw an exception if we weren't able to find a match
+ if (!matches) {
+ switch (action.nargs) {
+ case undefined:
+ case null:
+ message = 'Expected one argument.';
+ break;
+ case $$.OPTIONAL:
+ message = 'Expected at most one argument.';
+ break;
+ case $$.ONE_OR_MORE:
+ message = 'Expected at least one argument.';
+ break;
+ default:
+ message = 'Expected %s argument(s)';
+ }
+
+ throw argumentErrorHelper(
+ action,
+ format(message, action.nargs)
+ );
+ }
+ // return the number of arguments matched
+ return matches[1].length;
+};
+
+ArgumentParser.prototype._matchArgumentsPartial = function (actions, regexpArgStrings) {
+ // progressively shorten the actions list by slicing off the
+ // final actions until we find a match
+ var self = this;
+ var result = [];
+ var actionSlice, pattern, matches;
+ var i, j;
+
+ var getLength = function (string) {
+ return string.length;
+ };
+
+ for (i = actions.length; i > 0; i--) {
+ pattern = '';
+ actionSlice = actions.slice(0, i);
+ for (j = 0; j < actionSlice.length; j++) {
+ pattern += self._getNargsPattern(actionSlice[j]);
+ }
+
+ pattern = new RegExp('^' + pattern);
+ matches = regexpArgStrings.match(pattern);
+
+ if (matches && matches.length > 0) {
+ // need only groups
+ matches = matches.splice(1);
+ result = result.concat(matches.map(getLength));
+ break;
+ }
+ }
+
+ // return the list of arg string counts
+ return result;
+};
+
+ArgumentParser.prototype._parseOptional = function (argString) {
+ var action, optionString, argExplicit, optionTuples;
+
+ // if it's an empty string, it was meant to be a positional
+ if (!argString) {
+ return null;
+ }
+
+ // if it doesn't start with a prefix, it was meant to be positional
+ if (this.prefixChars.indexOf(argString[0]) < 0) {
+ return null;
+ }
+
+ // if the option string is present in the parser, return the action
+ if (!!this._optionStringActions[argString]) {
+ return [this._optionStringActions[argString], argString, null];
+ }
+
+ // if it's just a single character, it was meant to be positional
+ if (argString.length === 1) {
+ return null;
+ }
+
+ // if the option string before the "=" is present, return the action
+ if (argString.indexOf('=') >= 0) {
+ var argStringSplit = argString.split('=');
+ optionString = argStringSplit[0];
+ argExplicit = argStringSplit[1];
+
+ if (!!this._optionStringActions[optionString]) {
+ action = this._optionStringActions[optionString];
+ return [action, optionString, argExplicit];
+ }
+ }
+
+ // search through all possible prefixes of the option string
+ // and all actions in the parser for possible interpretations
+ optionTuples = this._getOptionTuples(argString);
+
+ // if multiple actions match, the option string was ambiguous
+ if (optionTuples.length > 1) {
+ var optionStrings = optionTuples.map(function (optionTuple) {
+ return optionTuple[1];
+ });
+ this.error(format(
+ 'Ambiguous option: "%s" could match %s.',
+ argString, optionStrings.join(', ')
+ ));
+ // if exactly one action matched, this segmentation is good,
+ // so return the parsed action
+ } else if (optionTuples.length === 1) {
+ return optionTuples[0];
+ }
+
+ // if it was not found as an option, but it looks like a negative
+ // number, it was meant to be positional
+ // unless there are negative-number-like options
+ if (argString.match(this._regexpNegativeNumber)) {
+ if (!_.any(this._hasNegativeNumberOptionals)) {
+ return null;
+ }
+ }
+ // if it contains a space, it was meant to be a positional
+ if (argString.search(' ') >= 0) {
+ return null;
+ }
+
+ // it was meant to be an optional but there is no such option
+ // in this parser (though it might be a valid option in a subparser)
+ return [null, argString, null];
+};
+
+ArgumentParser.prototype._getOptionTuples = function (optionString) {
+ var result = [];
+ var chars = this.prefixChars;
+ var optionPrefix;
+ var argExplicit;
+ var action;
+ var actionOptionString;
+
+ // option strings starting with two prefix characters are only split at
+ // the '='
+ if (chars.indexOf(optionString[0]) >= 0 && chars.indexOf(optionString[1]) >= 0) {
+ if (optionString.indexOf('=') >= 0) {
+ var optionStringSplit = optionString.split('=', 1);
+
+ optionPrefix = optionStringSplit[0];
+ argExplicit = optionStringSplit[1];
+ } else {
+ optionPrefix = optionString;
+ argExplicit = null;
+ }
+
+ for (actionOptionString in this._optionStringActions) {
+ if (actionOptionString.substr(0, optionPrefix.length) === optionPrefix) {
+ action = this._optionStringActions[actionOptionString];
+ result.push([action, actionOptionString, argExplicit]);
+ }
+ }
+
+ // single character options can be concatenated with their arguments
+ // but multiple character options always have to have their argument
+ // separate
+ } else if (chars.indexOf(optionString[0]) >= 0 && chars.indexOf(optionString[1]) < 0) {
+ optionPrefix = optionString;
+ argExplicit = null;
+ var optionPrefixShort = optionString.substr(0, 2);
+ var argExplicitShort = optionString.substr(2);
+
+ for (actionOptionString in this._optionStringActions) {
+ action = this._optionStringActions[actionOptionString];
+ if (actionOptionString === optionPrefixShort) {
+ result.push([action, actionOptionString, argExplicitShort]);
+ } else if (actionOptionString.substr(0, optionPrefix.length) === optionPrefix) {
+ result.push([action, actionOptionString, argExplicit]);
+ }
+ }
+
+ // shouldn't ever get here
+ } else {
+ throw new Error(format('Unexpected option string: %s.', optionString));
+ }
+ // return the collected option tuples
+ return result;
+};
+
+ArgumentParser.prototype._getNargsPattern = function (action) {
+ // in all examples below, we have to allow for '--' args
+ // which are represented as '-' in the pattern
+ var regexpNargs;
+
+ switch (action.nargs) {
+ // the default (null) is assumed to be a single argument
+ case undefined:
+ case null:
+ regexpNargs = '(-*A-*)';
+ break;
+ // allow zero or more arguments
+ case $$.OPTIONAL:
+ regexpNargs = '(-*A?-*)';
+ break;
+ // allow zero or more arguments
+ case $$.ZERO_OR_MORE:
+ regexpNargs = '(-*[A-]*)';
+ break;
+ // allow one or more arguments
+ case $$.ONE_OR_MORE:
+ regexpNargs = '(-*A[A-]*)';
+ break;
+ // allow any number of options or arguments
+ case $$.REMAINDER:
+ regexpNargs = '([-AO]*)';
+ break;
+ // allow one argument followed by any number of options or arguments
+ case $$.PARSER:
+ regexpNargs = '(-*A[-AO]*)';
+ break;
+ // all others should be integers
+ default:
+ regexpNargs = '(-*' + _.str.repeat('-*A', action.nargs) + '-*)';
+ }
+
+ // if this is an optional action, -- is not allowed
+ if (action.isOptional()) {
+ regexpNargs = regexpNargs.replace(/-\*/g, '');
+ regexpNargs = regexpNargs.replace(/-/g, '');
+ }
+
+ // return the pattern
+ return regexpNargs;
+};
+
+//
+// Value conversion methods
+//
+
+ArgumentParser.prototype._getValues = function (action, argStrings) {
+ var self = this;
+
+ // for everything but PARSER args, strip out '--'
+ if (action.nargs !== $$.PARSER && action.nargs !== $$.REMAINDER) {
+ argStrings = argStrings.filter(function (arrayElement) {
+ return arrayElement !== '--';
+ });
+ }
+
+ var value, argString;
+
+ // optional argument produces a default when not present
+ if (argStrings.length === 0 && action.nargs === $$.OPTIONAL) {
+
+ value = (action.isOptional()) ? action.constant: action.defaultValue;
+
+ if (typeof(value) === 'string') {
+ value = this._getValue(action, value);
+ this._checkValue(action, value);
+ }
+
+ // when nargs='*' on a positional, if there were no command-line
+ // args, use the default if it is anything other than None
+ } else if (argStrings.length === 0 && action.nargs === $$.ZERO_OR_MORE &&
+ action.optionStrings.length === 0) {
+
+ value = (action.defaultValue || argStrings);
+ this._checkValue(action, value);
+
+ // single argument or optional argument produces a single value
+ } else if (argStrings.length === 1 &&
+ (!action.nargs || action.nargs === $$.OPTIONAL)) {
+
+ argString = argStrings[0];
+ value = this._getValue(action, argString);
+ this._checkValue(action, value);
+
+ // REMAINDER arguments convert all values, checking none
+ } else if (action.nargs === $$.REMAINDER) {
+ value = argStrings.map(function (v) {
+ return self._getValue(action, v);
+ });
+
+ // PARSER arguments convert all values, but check only the first
+ } else if (action.nargs === $$.PARSER) {
+ value = argStrings.map(function (v) {
+ return self._getValue(action, v);
+ });
+ this._checkValue(action, value[0]);
+
+ // all other types of nargs produce a list
+ } else {
+ value = argStrings.map(function (v) {
+ return self._getValue(action, v);
+ });
+ value.forEach(function (v) {
+ self._checkValue(action, v);
+ });
+ }
+
+ // return the converted value
+ return value;
+};
+
+ArgumentParser.prototype._getValue = function (action, argString) {
+ var result;
+
+ var typeFunction = this._registryGet('type', action.type, action.type);
+ if (!_.isFunction(typeFunction)) {
+ var message = format('%s is not callable', typeFunction);
+ throw argumentErrorHelper(action, message);
+ }
+
+ // convert the value to the appropriate type
+ try {
+ result = typeFunction(argString);
+
+ // ArgumentTypeErrors indicate errors
+ // If action.type is not a registered string, it is a function
+ // Try to deduce its name for inclusion in the error message
+ // Failing that, include the error message it raised.
+ } catch (e) {
+ var name = null;
+ if (_.isString(action.type)) {
+ name = action.type;
+ } else {
+ name = action.type.name || action.type.displayName || '';
+ }
+ var msg = format('Invalid %s value: %s', name, argString);
+ if (name === '') {msg += '\n' + e.message; }
+ throw argumentErrorHelper(action, msg);
+ }
+ // return the converted value
+ return result;
+};
+
+ArgumentParser.prototype._checkValue = function (action, value) {
+ // converted value must be one of the choices (if specified)
+ var choices = action.choices;
+ if (!!choices) {
+ // choise for argument can by array or string
+ if ((_.isString(choices) || _.isArray(choices)) &&
+ choices.indexOf(value) !== -1) {
+ return;
+ }
+ // choise for subparsers can by only hash
+ if (_.isObject(choices) && !_.isArray(choices) && choices[value]) {
+ return;
+ }
+
+ if (_.isString(choices)) {
+ choices = choices.split('').join(', ');
+ }
+ else if (_.isArray(choices)) {
+ choices = choices.join(', ');
+ }
+ else {
+ choices = _.keys(choices).join(', ');
+ }
+ var message = format('Invalid choice: %s (choose from [%s])', value, choices);
+ throw argumentErrorHelper(action, message);
+ }
+};
+
+//
+// Help formatting methods
+//
+
+/**
+ * ArgumentParser#formatUsage -> string
+ *
+ * Return usage string
+ *
+ * See also [original guide][1]
+ *
+ * [1]:http://docs.python.org/dev/library/argparse.html#printing-help
+ **/
+ArgumentParser.prototype.formatUsage = function () {
+ var formatter = this._getFormatter();
+ formatter.addUsage(this.usage, this._actions, this._mutuallyExclusiveGroups);
+ return formatter.formatHelp();
+};
+
+/**
+ * ArgumentParser#formatHelp -> string
+ *
+ * Return help
+ *
+ * See also [original guide][1]
+ *
+ * [1]:http://docs.python.org/dev/library/argparse.html#printing-help
+ **/
+ArgumentParser.prototype.formatHelp = function () {
+ var formatter = this._getFormatter();
+
+ // usage
+ formatter.addUsage(this.usage, this._actions, this._mutuallyExclusiveGroups);
+
+ // description
+ formatter.addText(this.description);
+
+ // positionals, optionals and user-defined groups
+ this._actionGroups.forEach(function (actionGroup) {
+ formatter.startSection(actionGroup.title);
+ formatter.addText(actionGroup.description);
+ formatter.addArguments(actionGroup._groupActions);
+ formatter.endSection();
+ });
+
+ // epilog
+ formatter.addText(this.epilog);
+
+ // determine help from format above
+ return formatter.formatHelp();
+};
+
+ArgumentParser.prototype._getFormatter = function () {
+ var FormatterClass = this.formatterClass;
+ var formatter = new FormatterClass({prog: this.prog});
+ return formatter;
+};
+
+//
+// Print functions
+//
+
+/**
+ * ArgumentParser#printUsage() -> Void
+ *
+ * Print usage
+ *
+ * See also [original guide][1]
+ *
+ * [1]:http://docs.python.org/dev/library/argparse.html#printing-help
+ **/
+ArgumentParser.prototype.printUsage = function () {
+ this._printMessage(this.formatUsage());
+};
+
+/**
+ * ArgumentParser#printHelp() -> Void
+ *
+ * Print help
+ *
+ * See also [original guide][1]
+ *
+ * [1]:http://docs.python.org/dev/library/argparse.html#printing-help
+ **/
+ArgumentParser.prototype.printHelp = function () {
+ this._printMessage(this.formatHelp());
+};
+
+ArgumentParser.prototype._printMessage = function (message, stream) {
+ if (!stream) {
+ stream = process.stdout;
+ }
+ if (message) {
+ stream.write('' + message);
+ }
+};
+
+//
+// Exit functions
+//
+
+/**
+ * ArgumentParser#exit(status=0, message) -> Void
+ * - status (int): exit status
+ * - message (string): message
+ *
+ * Print message in stderr/stdout and exit program
+ **/
+ArgumentParser.prototype.exit = function (status, message) {
+ if (!!message) {
+ if (status === 0) {
+ this._printMessage(message);
+ }
+ else {
+ this._printMessage(message, process.stderr);
+ }
+ }
+
+ process.exit(status);
+};
+
+/**
+ * ArgumentParser#error(message) -> Void
+ * - err (Error|string): message
+ *
+ * Error method Prints a usage message incorporating the message to stderr and
+ * exits. If you override this in a subclass,
+ * it should not return -- it should
+ * either exit or throw an exception.
+ *
+ **/
+ArgumentParser.prototype.error = function (err) {
+ var message;
+ if (err instanceof Error) {
+ if (this.debug === true) {
+ throw err;
+ }
+ message = err.message;
+ }
+ else {
+ message = err;
+ }
+ var msg = format('%s: error: %s', this.prog, message) + $$.EOL;
+
+ if (this.debug === true) {
+ throw new Error(msg);
+ }
+
+ this.printUsage(process.stderr);
+
+ return this.exit(2, msg);
+};
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/const.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/const.js
new file mode 100644
index 0000000..de831ba
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/const.js
@@ -0,0 +1,18 @@
+//
+// Constants
+//
+module.exports.EOL = '\n';
+
+module.exports.SUPPRESS = '==SUPPRESS==';
+
+module.exports.OPTIONAL = '?';
+
+module.exports.ZERO_OR_MORE = '*';
+
+module.exports.ONE_OR_MORE = '+';
+
+module.exports.PARSER = 'A...';
+
+module.exports.REMAINDER = '...';
+
+module.exports._UNRECOGNIZED_ARGS_ATTR = '_unrecognized_args';
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/help/added_formatters.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/help/added_formatters.js
new file mode 100644
index 0000000..cd2f369
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/help/added_formatters.js
@@ -0,0 +1,88 @@
+'use strict';
+
+var util = require('util');
+var _ = require('underscore');
+_.str = require('underscore.string');
+
+// Constants
+var $$ = require('../const');
+
+var HelpFormatter = require('./formatter.js');
+
+/**
+ * new RawDescriptionHelpFormatter(options)
+ * new ArgumentParser({formatterClass: argparse.RawDescriptionHelpFormatter, ...})
+ *
+ * Help message formatter which adds default values to argument help.
+ *
+ * Only the name of this class is considered a public API. All the methods
+ * provided by the class are considered an implementation detail.
+ **/
+
+var ArgumentDefaultsHelpFormatter = function ArgumentDefaultsHelpFormatter(options) {
+ HelpFormatter.call(this, options);
+};
+
+util.inherits(ArgumentDefaultsHelpFormatter, HelpFormatter);
+
+ArgumentDefaultsHelpFormatter.prototype._getHelpString = function (action) {
+ var help = action.help;
+ if (action.help.indexOf('%(defaultValue)s') === -1) {
+ if (action.defaultValue !== $$.SUPPRESS) {
+ var defaulting_nargs = [$$.OPTIONAL, $$.ZERO_OR_MORE];
+ if (action.isOptional() || (defaulting_nargs.indexOf(action.nargs) >= 0)) {
+ help += ' (default: %(defaultValue)s)';
+ }
+ }
+ }
+ return help;
+};
+
+module.exports.ArgumentDefaultsHelpFormatter = ArgumentDefaultsHelpFormatter;
+
+/**
+ * new RawDescriptionHelpFormatter(options)
+ * new ArgumentParser({formatterClass: argparse.RawDescriptionHelpFormatter, ...})
+ *
+ * Help message formatter which retains any formatting in descriptions.
+ *
+ * Only the name of this class is considered a public API. All the methods
+ * provided by the class are considered an implementation detail.
+ **/
+
+var RawDescriptionHelpFormatter = function RawDescriptionHelpFormatter(options) {
+ HelpFormatter.call(this, options);
+};
+
+util.inherits(RawDescriptionHelpFormatter, HelpFormatter);
+
+RawDescriptionHelpFormatter.prototype._fillText = function (text, width, indent) {
+ var lines = text.split('\n');
+ lines = lines.map(function (line) {
+ return _.str.rtrim(indent + line);
+ });
+ return lines.join('\n');
+};
+module.exports.RawDescriptionHelpFormatter = RawDescriptionHelpFormatter;
+
+/**
+ * new RawTextHelpFormatter(options)
+ * new ArgumentParser({formatterClass: argparse.RawTextHelpFormatter, ...})
+ *
+ * Help message formatter which retains formatting of all help text.
+ *
+ * Only the name of this class is considered a public API. All the methods
+ * provided by the class are considered an implementation detail.
+ **/
+
+var RawTextHelpFormatter = function RawTextHelpFormatter(options) {
+ RawDescriptionHelpFormatter.call(this, options);
+};
+
+util.inherits(RawTextHelpFormatter, RawDescriptionHelpFormatter);
+
+RawTextHelpFormatter.prototype._splitLines = function (text) {
+ return text.split('\n');
+};
+
+module.exports.RawTextHelpFormatter = RawTextHelpFormatter;
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/help/formatter.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/help/formatter.js
new file mode 100644
index 0000000..89319b9
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/help/formatter.js
@@ -0,0 +1,798 @@
+/**
+ * class HelpFormatter
+ *
+ * Formatter for generating usage messages and argument help strings. Only the
+ * name of this class is considered a public API. All the methods provided by
+ * the class are considered an implementation detail.
+ *
+ * Do not call in your code, use this class only for inherits your own forvatter
+ *
+ * ToDo add [additonal formatters][1]
+ *
+ * [1]:http://docs.python.org/dev/library/argparse.html#formatter-class
+ **/
+'use strict';
+
+var _ = require('underscore');
+_.str = require('underscore.string');
+
+// Constants
+var $$ = require('../const');
+
+
+/*:nodoc:* internal
+ * new Support(parent, heding)
+ * - parent (object): parent section
+ * - heading (string): header string
+ *
+ **/
+function Section(parent, heading) {
+ this._parent = parent;
+ this._heading = heading;
+ this._items = [];
+}
+
+/*:nodoc:* internal
+ * Section#addItem(callback) -> Void
+ * - callback (array): tuple with function and args
+ *
+ * Add function for single element
+ **/
+Section.prototype.addItem = function (callback) {
+ this._items.push(callback);
+};
+
+/*:nodoc:* internal
+ * Section#formatHelp(formatter) -> string
+ * - formatter (HelpFormatter): current formatter
+ *
+ * Form help section string
+ *
+ **/
+Section.prototype.formatHelp = function (formatter) {
+ var itemHelp, heading;
+
+ // format the indented section
+ if (!!this._parent) {
+ formatter._indent();
+ }
+
+ itemHelp = this._items.map(function (item) {
+ var obj, func, args;
+
+ obj = formatter;
+ func = item[0];
+ args = item[1];
+ return func.apply(obj, args);
+ });
+ itemHelp = formatter._joinParts(itemHelp);
+
+ if (!!this._parent) {
+ formatter._dedent();
+ }
+
+ // return nothing if the section was empty
+ if (!itemHelp) {
+ return '';
+ }
+
+ // add the heading if the section was non-empty
+ heading = '';
+ if (!!this._heading && this._heading !== $$.SUPPRESS) {
+ var currentIndent = formatter.currentIndent;
+ heading = _.str.repeat(' ', currentIndent) + this._heading + ':' + $$.EOL;
+ }
+
+ // join the section-initialize newline, the heading and the help
+ return formatter._joinParts([$$.EOL, heading, itemHelp, $$.EOL]);
+};
+
+/**
+ * new HelpFormatter(options)
+ *
+ * #### Options:
+ * - `prog`: program name
+ * - `indentIncriment`: indent step, default value 2
+ * - `maxHelpPosition`: max help position, default value = 24
+ * - `width`: line width
+ *
+ **/
+var HelpFormatter = module.exports = function HelpFormatter(options) {
+ options = options || {};
+
+ this._prog = options.prog;
+
+ this._maxHelpPosition = options.maxHelpPosition || 24;
+ this._width = (options.width || ((process.env.COLUMNS || 80) - 2));
+
+ this._currentIndent = 0;
+ this._indentIncriment = options.indentIncriment || 2;
+ this._level = 0;
+ this._actionMaxLength = 0;
+
+ this._rootSection = new Section(null);
+ this._currentSection = this._rootSection;
+
+ this._whitespaceMatcher = new RegExp('\\s+', 'g');
+ this._longBreakMatcher = new RegExp($$.EOL + $$.EOL + $$.EOL + '+', 'g');
+};
+
+HelpFormatter.prototype._indent = function () {
+ this._currentIndent += this._indentIncriment;
+ this._level += 1;
+};
+
+HelpFormatter.prototype._dedent = function () {
+ this._currentIndent -= this._indentIncriment;
+ this._level -= 1;
+ if (this._currentIndent < 0) {
+ throw new Error('Indent decreased below 0.');
+ }
+};
+
+HelpFormatter.prototype._addItem = function (func, args) {
+ this._currentSection.addItem([func, args]);
+};
+
+//
+// Message building methods
+//
+
+/**
+ * HelpFormatter#startSection(heading) -> Void
+ * - heading (string): header string
+ *
+ * Start new help section
+ *
+ * See alse [code example][1]
+ *
+ * ##### Example
+ *
+ * formatter.startSection(actionGroup.title);
+ * formatter.addText(actionGroup.description);
+ * formatter.addArguments(actionGroup._groupActions);
+ * formatter.endSection();
+ *
+ **/
+HelpFormatter.prototype.startSection = function (heading) {
+ this._indent();
+ var section = new Section(this._currentSection, heading);
+ var func = section.formatHelp.bind(section);
+ this._addItem(func, [this]);
+ this._currentSection = section;
+};
+
+/**
+ * HelpFormatter#endSection -> Void
+ *
+ * End help section
+ *
+ * ##### Example
+ *
+ * formatter.startSection(actionGroup.title);
+ * formatter.addText(actionGroup.description);
+ * formatter.addArguments(actionGroup._groupActions);
+ * formatter.endSection();
+ **/
+HelpFormatter.prototype.endSection = function () {
+ this._currentSection = this._currentSection._parent;
+ this._dedent();
+};
+
+/**
+ * HelpFormatter#addText(text) -> Void
+ * - text (string): plain text
+ *
+ * Add plain text into current section
+ *
+ * ##### Example
+ *
+ * formatter.startSection(actionGroup.title);
+ * formatter.addText(actionGroup.description);
+ * formatter.addArguments(actionGroup._groupActions);
+ * formatter.endSection();
+ *
+ **/
+HelpFormatter.prototype.addText = function (text) {
+ if (!!text && text !== $$.SUPPRESS) {
+ this._addItem(this._formatText, [text]);
+ }
+};
+
+/**
+ * HelpFormatter#addUsage(usage, actions, groups, prefix) -> Void
+ * - usage (string): usage text
+ * - actions (array): actions list
+ * - groups (array): groups list
+ * - prefix (string): usage prefix
+ *
+ * Add usage data into current section
+ *
+ * ##### Example
+ *
+ * formatter.addUsage(this.usage, this._actions, []);
+ * return formatter.formatHelp();
+ *
+ **/
+HelpFormatter.prototype.addUsage = function (usage, actions, groups, prefix) {
+ if (usage !== $$.SUPPRESS) {
+ this._addItem(this._formatUsage, [usage, actions, groups, prefix]);
+ }
+};
+
+/**
+ * HelpFormatter#addArgument(action) -> Void
+ * - action (object): action
+ *
+ * Add argument into current section
+ *
+ * Single variant of [[HelpFormatter#addArguments]]
+ **/
+HelpFormatter.prototype.addArgument = function (action) {
+ if (action.help !== $$.SUPPRESS) {
+ var self = this;
+
+ // find all invocations
+ var invocations = [this._formatActionInvocation(action)];
+ var invocationLength = invocations[0].length;
+
+ var actionLength;
+
+ if (!!action._getSubactions) {
+ this._indent();
+ action._getSubactions().forEach(function (subaction) {
+
+ var invocationNew = self._formatActionInvocation(subaction);
+ invocations.push(invocationNew);
+ invocationLength = Math.max(invocationLength, invocationNew.length);
+
+ });
+ this._dedent();
+ }
+
+ // update the maximum item length
+ actionLength = invocationLength + this._currentIndent;
+ this._actionMaxLength = Math.max(this._actionMaxLength, actionLength);
+
+ // add the item to the list
+ this._addItem(this._formatAction, [action]);
+ }
+};
+
+/**
+ * HelpFormatter#addArguments(actions) -> Void
+ * - actions (array): actions list
+ *
+ * Mass add arguments into current section
+ *
+ * ##### Example
+ *
+ * formatter.startSection(actionGroup.title);
+ * formatter.addText(actionGroup.description);
+ * formatter.addArguments(actionGroup._groupActions);
+ * formatter.endSection();
+ *
+ **/
+HelpFormatter.prototype.addArguments = function (actions) {
+ var self = this;
+ actions.forEach(function (action) {
+ self.addArgument(action);
+ });
+};
+
+//
+// Help-formatting methods
+//
+
+/**
+ * HelpFormatter#formatHelp -> string
+ *
+ * Format help
+ *
+ * ##### Example
+ *
+ * formatter.addText(this.epilog);
+ * return formatter.formatHelp();
+ *
+ **/
+HelpFormatter.prototype.formatHelp = function () {
+ var help = this._rootSection.formatHelp(this);
+ if (help) {
+ help = help.replace(this._longBreakMatcher, $$.EOL + $$.EOL);
+ help = _.str.strip(help, $$.EOL) + $$.EOL;
+ }
+ return help;
+};
+
+HelpFormatter.prototype._joinParts = function (partStrings) {
+ return partStrings.filter(function (part) {
+ return (!!part && part !== $$.SUPPRESS);
+ }).join('');
+};
+
+HelpFormatter.prototype._formatUsage = function (usage, actions, groups, prefix) {
+ if (!prefix && !_.isString(prefix)) {
+ prefix = 'usage: ';
+ }
+
+ actions = actions || [];
+ groups = groups || [];
+
+
+ // if usage is specified, use that
+ if (usage) {
+ usage = _.str.sprintf(usage, {prog: this._prog});
+
+ // if no optionals or positionals are available, usage is just prog
+ } else if (!usage && actions.length === 0) {
+ usage = this._prog;
+
+ // if optionals and positionals are available, calculate usage
+ } else if (!usage) {
+ var prog = this._prog;
+ var optionals = [];
+ var positionals = [];
+ var actionUsage;
+ var textWidth;
+
+ // split optionals from positionals
+ actions.forEach(function (action) {
+ if (action.isOptional()) {
+ optionals.push(action);
+ } else {
+ positionals.push(action);
+ }
+ });
+
+ // build full usage string
+ actionUsage = this._formatActionsUsage([].concat(optionals, positionals), groups);
+ usage = [prog, actionUsage].join(' ');
+
+ // wrap the usage parts if it's too long
+ textWidth = this._width - this._currentIndent;
+ if ((prefix.length + usage.length) > textWidth) {
+
+ // break usage into wrappable parts
+ var regexpPart = new RegExp('\\(.*?\\)+|\\[.*?\\]+|\\S+', 'g');
+ var optionalUsage = this._formatActionsUsage(optionals, groups);
+ var positionalUsage = this._formatActionsUsage(positionals, groups);
+
+
+ var optionalParts = optionalUsage.match(regexpPart);
+ var positionalParts = positionalUsage.match(regexpPart) || [];
+
+ if (optionalParts.join(' ') !== optionalUsage) {
+ throw new Error('assert "optionalParts.join(\' \') === optionalUsage"');
+ }
+ if (positionalParts.join(' ') !== positionalUsage) {
+ throw new Error('assert "positionalParts.join(\' \') === positionalUsage"');
+ }
+
+ // helper for wrapping lines
+ var _getLines = function (parts, indent, prefix) {
+ var lines = [];
+ var line = [];
+
+ var lineLength = !!prefix ? prefix.length - 1: indent.length - 1;
+
+ parts.forEach(function (part) {
+ if (lineLength + 1 + part.length > textWidth) {
+ lines.push(indent + line.join(' '));
+ line = [];
+ lineLength = indent.length - 1;
+ }
+ line.push(part);
+ lineLength += part.length + 1;
+ });
+
+ if (line) {
+ lines.push(indent + line.join(' '));
+ }
+ if (prefix) {
+ lines[0] = lines[0].substr(indent.length);
+ }
+ return lines;
+ };
+
+ var lines, indent, parts;
+ // if prog is short, follow it with optionals or positionals
+ if (prefix.length + prog.length <= 0.75 * textWidth) {
+ indent = _.str.repeat(' ', (prefix.length + prog.length + 1));
+ if (optionalParts) {
+ lines = [].concat(
+ _getLines([prog].concat(optionalParts), indent, prefix),
+ _getLines(positionalParts, indent)
+ );
+ } else if (positionalParts) {
+ lines = _getLines([prog].concat(positionalParts), indent, prefix);
+ } else {
+ lines = [prog];
+ }
+
+ // if prog is long, put it on its own line
+ } else {
+ indent = _.str.repeat(' ', prefix.length);
+ parts = optionalParts + positionalParts;
+ lines = _getLines(parts, indent);
+ if (lines.length > 1) {
+ lines = [].concat(
+ _getLines(optionalParts, indent),
+ _getLines(positionalParts, indent)
+ );
+ }
+ lines = [prog] + lines;
+ }
+ // join lines into usage
+ usage = lines.join($$.EOL);
+ }
+ }
+
+ // prefix with 'usage:'
+ return prefix + usage + $$.EOL + $$.EOL;
+};
+
+HelpFormatter.prototype._formatActionsUsage = function (actions, groups) {
+ // find group indices and identify actions in groups
+ var groupActions = [];
+ var inserts = [];
+ var self = this;
+
+ groups.forEach(function (group) {
+ var end;
+ var i;
+
+ var start = actions.indexOf(group._groupActions[0]);
+ if (start >= 0) {
+ end = start + group._groupActions.length;
+
+ //if (actions.slice(start, end) === group._groupActions) {
+ if (_.isEqual(actions.slice(start, end), group._groupActions)) {
+ group._groupActions.forEach(function (action) {
+ groupActions.push(action);
+ });
+
+ if (!group.required) {
+ if (!!inserts[start]) {
+ inserts[start] += ' [';
+ }
+ else {
+ inserts[start] = '[';
+ }
+ inserts[end] = ']';
+ } else {
+ if (!!inserts[start]) {
+ inserts[start] += ' (';
+ }
+ else {
+ inserts[start] = '(';
+ }
+ inserts[end] = ')';
+ }
+ for (i = start + 1; i < end; i += 1) {
+ inserts[i] = '|';
+ }
+ }
+ }
+ });
+
+ // collect all actions format strings
+ var parts = [];
+
+ actions.forEach(function (action, actionIndex) {
+ var part;
+ var optionString;
+ var argsDefault;
+ var argsString;
+
+ // suppressed arguments are marked with None
+ // remove | separators for suppressed arguments
+ if (action.help === $$.SUPPRESS) {
+ parts.push(null);
+ if (inserts[actionIndex] === '|') {
+ inserts.splice(actionIndex, actionIndex);
+ } else if (inserts[actionIndex + 1] === '|') {
+ inserts.splice(actionIndex + 1, actionIndex + 1);
+ }
+
+ // produce all arg strings
+ } else if (!action.isOptional()) {
+ part = self._formatArgs(action, action.dest);
+
+ // if it's in a group, strip the outer []
+ if (groupActions.indexOf(action) >= 0) {
+ if (part[0] === '[' && part[part.length - 1] === ']') {
+ part = part.slice(1, -1);
+ }
+ }
+ // add the action string to the list
+ parts.push(part);
+
+ // produce the first way to invoke the option in brackets
+ } else {
+ optionString = action.optionStrings[0];
+
+ // if the Optional doesn't take a value, format is: -s or --long
+ if (action.nargs === 0) {
+ part = '' + optionString;
+
+ // if the Optional takes a value, format is: -s ARGS or --long ARGS
+ } else {
+ argsDefault = action.dest.toUpperCase();
+ argsString = self._formatArgs(action, argsDefault);
+ part = optionString + ' ' + argsString;
+ }
+ // make it look optional if it's not required or in a group
+ if (!action.required && groupActions.indexOf(action) < 0) {
+ part = '[' + part + ']';
+ }
+ // add the action string to the list
+ parts.push(part);
+ }
+ });
+
+ // insert things at the necessary indices
+ for (var i = inserts.length - 1; i >= 0; --i) {
+ if (inserts[i] !== null) {
+ parts.splice(i, 0, inserts[i]);
+ }
+ }
+
+ // join all the action items with spaces
+ var text = parts.filter(function (part) {
+ return !!part;
+ }).join(' ');
+
+ // clean up separators for mutually exclusive groups
+ text = text.replace(/([\[(]) /g, '$1'); // remove spaces
+ text = text.replace(/ ([\])])/g, '$1');
+ text = text.replace(/\[ *\]/g, ''); // remove empty groups
+ text = text.replace(/\( *\)/g, '');
+ text = text.replace(/\(([^|]*)\)/g, '$1'); // remove () from single action groups
+
+ text = _.str.strip(text);
+
+ // return the text
+ return text;
+};
+
+HelpFormatter.prototype._formatText = function (text) {
+ text = _.str.sprintf(text, {prog: this._prog});
+ var textWidth = this._width - this._currentIndent;
+ var indentIncriment = _.str.repeat(' ', this._currentIndent);
+ return this._fillText(text, textWidth, indentIncriment) + $$.EOL + $$.EOL;
+};
+
+HelpFormatter.prototype._formatAction = function (action) {
+ var self = this;
+
+ var helpText;
+ var helpLines;
+ var parts;
+ var indentFirst;
+
+ // determine the required width and the entry label
+ var helpPosition = Math.min(this._actionMaxLength + 2, this._maxHelpPosition);
+ var helpWidth = this._width - helpPosition;
+ var actionWidth = helpPosition - this._currentIndent - 2;
+ var actionHeader = this._formatActionInvocation(action);
+
+ // no help; start on same line and add a final newline
+ if (!action.help) {
+ actionHeader = _.str.repeat(' ', this._currentIndent) + actionHeader + $$.EOL;
+
+ // short action name; start on the same line and pad two spaces
+ } else if (actionHeader.length <= actionWidth) {
+ actionHeader = _.str.repeat(' ', this._currentIndent) +
+ actionHeader +
+ ' ' +
+ _.str.repeat(' ', actionWidth - actionHeader.length);
+ indentFirst = 0;
+
+ // long action name; start on the next line
+ } else {
+ actionHeader = _.str.repeat(' ', this._currentIndent) + actionHeader + $$.EOL;
+ indentFirst = helpPosition;
+ }
+
+ // collect the pieces of the action help
+ parts = [actionHeader];
+
+ // if there was help for the action, add lines of help text
+ if (!!action.help) {
+ helpText = this._expandHelp(action);
+ helpLines = this._splitLines(helpText, helpWidth);
+ parts.push(_.str.repeat(' ', indentFirst) + helpLines[0] + $$.EOL);
+ helpLines.slice(1).forEach(function (line) {
+ parts.push(_.str.repeat(' ', helpPosition) + line + $$.EOL);
+ });
+
+ // or add a newline if the description doesn't end with one
+ } else if (actionHeader.charAt(actionHeader.length - 1) !== $$.EOL) {
+ parts.push($$.EOL);
+ }
+ // if there are any sub-actions, add their help as well
+ if (!!action._getSubactions) {
+ this._indent();
+ action._getSubactions().forEach(function (subaction) {
+ parts.push(self._formatAction(subaction));
+ });
+ this._dedent();
+ }
+ // return a single string
+ return this._joinParts(parts);
+};
+
+HelpFormatter.prototype._formatActionInvocation = function (action) {
+ if (!action.isOptional()) {
+ var format_func = this._metavarFormatter(action, action.dest);
+ var metavars = format_func(1);
+ return metavars[0];
+ } else {
+ var parts = [];
+ var argsDefault;
+ var argsString;
+
+ // if the Optional doesn't take a value, format is: -s, --long
+ if (action.nargs === 0) {
+ parts = parts.concat(action.optionStrings);
+
+ // if the Optional takes a value, format is: -s ARGS, --long ARGS
+ } else {
+ argsDefault = action.dest.toUpperCase();
+ argsString = this._formatArgs(action, argsDefault);
+ action.optionStrings.forEach(function (optionString) {
+ parts.push(optionString + ' ' + argsString);
+ });
+ }
+ return parts.join(', ');
+ }
+};
+
+HelpFormatter.prototype._metavarFormatter = function (action, metavarDefault) {
+ var result;
+
+ if (!!action.metavar || action.metavar === '') {
+ result = action.metavar;
+ } else if (!!action.choices) {
+ var choices = action.choices;
+
+ if (_.isString(choices)) {
+ choices = choices.split('').join(', ');
+ } else if (_.isArray(choices)) {
+ choices = choices.join(',');
+ }
+ else
+ {
+ choices = _.keys(choices).join(',');
+ }
+ result = '{' + choices + '}';
+ } else {
+ result = metavarDefault;
+ }
+
+ return function (size) {
+ if (Array.isArray(result)) {
+ return result;
+ } else {
+ var metavars = [];
+ for (var i = 0; i < size; i += 1) {
+ metavars.push(result);
+ }
+ return metavars;
+ }
+ };
+};
+
+HelpFormatter.prototype._formatArgs = function (action, metavarDefault) {
+ var result;
+ var metavars;
+
+ var buildMetavar = this._metavarFormatter(action, metavarDefault);
+
+ switch (action.nargs) {
+ case undefined:
+ case null:
+ metavars = buildMetavar(1);
+ result = '' + metavars[0];
+ break;
+ case $$.OPTIONAL:
+ metavars = buildMetavar(1);
+ result = '[' + metavars[0] + ']';
+ break;
+ case $$.ZERO_OR_MORE:
+ metavars = buildMetavar(2);
+ result = '[' + metavars[0] + ' [' + metavars[1] + ' ...]]';
+ break;
+ case $$.ONE_OR_MORE:
+ metavars = buildMetavar(2);
+ result = '' + metavars[0] + ' [' + metavars[1] + ' ...]';
+ break;
+ case $$.REMAINDER:
+ result = '...';
+ break;
+ case $$.PARSER:
+ metavars = buildMetavar(1);
+ result = metavars[0] + ' ...';
+ break;
+ default:
+ metavars = buildMetavar(action.nargs);
+ result = metavars.join(' ');
+ }
+ return result;
+};
+
+HelpFormatter.prototype._expandHelp = function (action) {
+ var params = { prog: this._prog };
+
+ Object.keys(action).forEach(function (actionProperty) {
+ var actionValue = action[actionProperty];
+
+ if (actionValue !== $$.SUPPRESS) {
+ params[actionProperty] = actionValue;
+ }
+ });
+
+ if (!!params.choices) {
+ if (_.isString(params.choices)) {
+ params.choices = params.choices.split('').join(', ');
+ }
+ else if (_.isArray(params.choices)) {
+ params.choices = params.choices.join(', ');
+ }
+ else {
+ params.choices = _.keys(params.choices).join(', ');
+ }
+ }
+
+ return _.str.sprintf(this._getHelpString(action), params);
+};
+
+HelpFormatter.prototype._splitLines = function (text, width) {
+ var lines = [];
+ var delimiters = [" ", ".", ",", "!", "?"];
+ var re = new RegExp('[' + delimiters.join('') + '][^' + delimiters.join('') + ']*$');
+
+ text = text.replace(/[\n\|\t]/g, ' ');
+
+ text = _.str.strip(text);
+ text = text.replace(this._whitespaceMatcher, ' ');
+
+ // Wraps the single paragraph in text (a string) so every line
+ // is at most width characters long.
+ text.split($$.EOL).forEach(function (line) {
+ if (width >= line.length) {
+ lines.push(line);
+ return;
+ }
+
+ var wrapStart = 0;
+ var wrapEnd = width;
+ var delimiterIndex = 0;
+ while (wrapEnd <= line.length) {
+ if (wrapEnd !== line.length && delimiters.indexOf(line[wrapEnd] < -1)) {
+ delimiterIndex = (re.exec(line.substring(wrapStart, wrapEnd)) || {}).index;
+ wrapEnd = wrapStart + delimiterIndex + 1;
+ }
+ lines.push(line.substring(wrapStart, wrapEnd));
+ wrapStart = wrapEnd;
+ wrapEnd += width;
+ }
+ if (wrapStart < line.length) {
+ lines.push(line.substring(wrapStart, wrapEnd));
+ }
+ });
+
+ return lines;
+};
+
+HelpFormatter.prototype._fillText = function (text, width, indent) {
+ var lines = this._splitLines(text, width);
+ lines = lines.map(function (line) {
+ return indent + line;
+ });
+ return lines.join($$.EOL);
+};
+
+HelpFormatter.prototype._getHelpString = function (action) {
+ return action.help;
+};
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/namespace.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/namespace.js
new file mode 100644
index 0000000..3546f2d
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/lib/namespace.js
@@ -0,0 +1,77 @@
+/**
+ * class Namespace
+ *
+ * Simple object for storing attributes. Implements equality by attribute names
+ * and values, and provides a simple string representation.
+ *
+ * See also [original guide][1]
+ *
+ * [1]:http://docs.python.org/dev/library/argparse.html#the-namespace-object
+ **/
+'use strict';
+
+var _ = require('underscore');
+
+/**
+ * new Namespace(options)
+ * - options(object): predefined propertis for result object
+ *
+ **/
+var Namespace = module.exports = function Namespace(options) {
+ _.extend(this, options);
+};
+
+/**
+ * Namespace#isset(key) -> Boolean
+ * - key (string|number): property name
+ *
+ * Tells whenever `namespace` contains given `key` or not.
+ **/
+Namespace.prototype.isset = function (key) {
+ return _.has(this, key);
+};
+
+/**
+ * Namespace#set(key, value) -> self
+ * -key (string|number|object): propery name
+ * -value (mixed): new property value
+ *
+ * Set the property named key with value.
+ * If key object then set all key properties to namespace object
+ **/
+Namespace.prototype.set = function (key, value) {
+ if (typeof (key) === 'object') {
+ _.extend(this, key);
+ } else {
+ this[key] = value;
+ }
+ return this;
+};
+
+/**
+ * Namespace#get(key, defaultValue) -> mixed
+ * - key (string|number): property name
+ * - defaultValue (mixed): default value
+ *
+ * Return the property key or defaulValue if not set
+ **/
+Namespace.prototype.get = function (key, defaultValue) {
+ return !this[key] ? defaultValue: this[key];
+};
+
+/**
+ * Namespace#unset(key, defaultValue) -> mixed
+ * - key (string|number): property name
+ * - defaultValue (mixed): default value
+ *
+ * Return data[key](and delete it) or defaultValue
+ **/
+Namespace.prototype.unset = function (key, defaultValue) {
+ var value = this[key];
+ if (value !== null) {
+ delete this[key];
+ return value;
+ } else {
+ return defaultValue;
+ }
+};
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore.string/.npmignore b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore.string/.npmignore
new file mode 100644
index 0000000..0fc18a4
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore.string/.npmignore
@@ -0,0 +1,2 @@
+test
+dist
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore.string/.travis.yml b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore.string/.travis.yml
new file mode 100644
index 0000000..b4ae6a7
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore.string/.travis.yml
@@ -0,0 +1,8 @@
+language: node_js
+node_js:
+ - "0.11"
+
+before_script:
+ - "export DISPLAY=:99.0"
+ - "sh -e /etc/init.d/xvfb start"
+ - sleep 2
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore.string/README.markdown b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore.string/README.markdown
new file mode 100644
index 0000000..4e58be4
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore.string/README.markdown
@@ -0,0 +1,825 @@
+# Underscore.string [](http://travis-ci.org/epeli/underscore.string) #
+
+
+
+Javascript lacks complete string manipulation operations.
+This an attempt to fill that gap. List of build-in methods can be found
+for example from [Dive Into JavaScript][d].
+
+[d]: http://www.diveintojavascript.com/core-javascript-reference/the-string-object
+
+
+As name states this an extension for [Underscore.js][u] (and [Lo-Dash](http://lodash.com/)), but it can be used
+independently from **_s**-global variable. But with Underscore.js you can
+use Object-Oriented style and chaining:
+
+[u]: http://underscorejs.org/
+
+```javascript
+_(" epeli ").chain().trim().capitalize().value()
+=> "Epeli"
+```
+
+## Download ##
+
+ * [Development version](https://raw.github.com/epeli/underscore.string/master/lib/underscore.string.js) *Uncompressed with Comments 18kb*
+ * [Production version](https://github.com/epeli/underscore.string/raw/master/dist/underscore.string.min.js) *Minified 7kb*
+
+
+## Node.js installation ##
+
+**npm package**
+
+ npm install underscore.string
+
+**Standalone usage**:
+
+```javascript
+var _s = require('underscore.string');
+```
+
+**Integrate with Underscore.js**:
+
+```javascript
+var _ = require('underscore');
+
+// Import Underscore.string to separate object, because there are conflict functions (include, reverse, contains)
+_.str = require('underscore.string');
+
+// Mix in non-conflict functions to Underscore namespace if you want
+_.mixin(_.str.exports());
+
+// All functions, include conflict, will be available through _.str object
+_.str.include('Underscore.string', 'string'); // => true
+```
+
+**Or Integrate with Underscore.js without module loading**
+
+Run the following expression after Underscore.js and Underscore.string are loaded
+```javascript
+// _.str becomes a global variable if no module loading is detected
+// Mix in non-conflict functions to Underscore namespace
+_.mixin(_.str.exports());
+```
+
+## String Functions ##
+
+For availability of functions in this way you need to mix in Underscore.string functions:
+
+```javascript
+_.mixin(_.string.exports());
+```
+
+otherwise functions from examples will be available through _.string or _.str objects:
+
+```javascript
+_.str.capitalize('epeli')
+=> "Epeli"
+```
+
+**numberFormat** _.numberFormat(number, [ decimals=0, decimalSeparator='.', orderSeparator=','])
+
+Formats the numbers.
+
+```javascript
+_.numberFormat(1000, 2)
+=> "1,000.00"
+
+_.numberFormat(123456789.123, 5, '.', ',')
+=> "123,456,789.12300"
+```
+
+
+**levenshtein** _.levenshtein(string1, string2)
+
+Calculates [Levenshtein distance][ld] between two strings.
+[ld]: http://en.wikipedia.org/wiki/Levenshtein_distance
+
+```javascript
+_.levenshtein('kitten', 'kittah')
+=> 2
+```
+
+**capitalize** _.capitalize(string)
+
+Converts first letter of the string to uppercase.
+
+```javascript
+_.capitalize("foo Bar")
+=> "Foo Bar"
+```
+
+**chop** _.chop(string, step)
+
+```javascript
+_.chop('whitespace', 3)
+=> ['whi','tes','pac','e']
+```
+
+**clean** _.clean(str)
+
+Compress some whitespaces to one.
+
+```javascript
+_.clean(" foo bar ")
+=> 'foo bar'
+```
+
+**chars** _.chars(str)
+
+```javascript
+_.chars('Hello')
+=> ['H','e','l','l','o']
+```
+
+**swapCase** _.swapCase(str)
+
+Returns a copy of the string in which all the case-based characters have had their case swapped.
+
+```javascript
+_.swapCase('hELLO')
+=> 'Hello'
+```
+
+**include** available only through _.str object, because Underscore has function with the same name.
+
+```javascript
+_.str.include("foobar", "ob")
+=> true
+```
+
+(removed) **includes** _.includes(string, substring)
+
+Tests if string contains a substring.
+
+```javascript
+_.includes("foobar", "ob")
+=> true
+```
+
+**includes** function was removed
+
+But you can create it in this way, for compatibility with previous versions:
+
+```javascript
+_.includes = _.str.include
+```
+
+**count** _.count(string, substring)
+
+```javascript
+_('Hello world').count('l')
+=> 3
+```
+
+**escapeHTML** _.escapeHTML(string)
+
+Converts HTML special characters to their entity equivalents.
+
+```javascript
+_('Blah blah blah
').escapeHTML();
+=> '<div>Blah blah blah</div>'
+```
+
+**unescapeHTML** _.unescapeHTML(string)
+
+Converts entity characters to HTML equivalents.
+
+```javascript
+_('<div>Blah blah blah</div>').unescapeHTML();
+=> 'Blah blah blah
'
+```
+
+**insert** _.insert(string, index, substing)
+
+```javascript
+_('Hello ').insert(6, 'world')
+=> 'Hello world'
+```
+
+**isBlank** _.isBlank(string)
+
+```javascript
+_('').isBlank(); // => true
+_('\n').isBlank(); // => true
+_(' ').isBlank(); // => true
+_('a').isBlank(); // => false
+```
+
+**join** _.join(separator, *strings)
+
+Joins strings together with given separator
+
+```javascript
+_.join(" ", "foo", "bar")
+=> "foo bar"
+```
+
+**lines** _.lines(str)
+
+```javascript
+_.lines("Hello\nWorld")
+=> ["Hello", "World"]
+```
+
+**reverse** available only through _.str object, because Underscore has function with the same name.
+
+Return reversed string:
+
+```javascript
+_.str.reverse("foobar")
+=> 'raboof'
+```
+
+**splice** _.splice(string, index, howmany, substring)
+
+Like a array splice.
+
+```javascript
+_('https://edtsech@bitbucket.org/edtsech/underscore.strings').splice(30, 7, 'epeli')
+=> 'https://edtsech@bitbucket.org/epeli/underscore.strings'
+```
+
+**startsWith** _.startsWith(string, starts)
+
+This method checks whether string starts with starts.
+
+```javascript
+_("image.gif").startsWith("image")
+=> true
+```
+
+**endsWith** _.endsWith(string, ends)
+
+This method checks whether string ends with ends.
+
+```javascript
+_("image.gif").endsWith("gif")
+=> true
+```
+
+**succ** _.succ(str)
+
+Returns the successor to str.
+
+```javascript
+_('a').succ()
+=> 'b'
+
+_('A').succ()
+=> 'B'
+```
+
+**supplant**
+
+Supplant function was removed, use Underscore.js [template function][p].
+
+[p]: http://documentcloud.github.com/underscore/#template
+
+**strip** alias for *trim*
+
+**lstrip** alias for *ltrim*
+
+**rstrip** alias for *rtrim*
+
+**titleize** _.titleize(string)
+
+```javascript
+_('my name is epeli').titleize()
+=> 'My Name Is Epeli'
+```
+
+**camelize** _.camelize(string)
+
+Converts underscored or dasherized string to a camelized one. Begins with
+a lower case letter unless it starts with an underscore or string
+
+```javascript
+_('moz-transform').camelize()
+=> 'mozTransform'
+_('-moz-transform').camelize()
+=> 'MozTransform'
+```
+
+**classify** _.classify(string)
+
+Converts string to camelized class name. First letter is always upper case
+
+```javascript
+_('some_class_name').classify()
+=> 'SomeClassName'
+```
+
+**underscored** _.underscored(string)
+
+Converts a camelized or dasherized string into an underscored one
+
+```javascript
+_('MozTransform').underscored()
+=> 'moz_transform'
+```
+
+**dasherize** _.dasherize(string)
+
+Converts a underscored or camelized string into an dasherized one
+
+```javascript
+_('MozTransform').dasherize()
+=> '-moz-transform'
+```
+
+**humanize** _.humanize(string)
+
+Converts an underscored, camelized, or dasherized string into a humanized one.
+Also removes beginning and ending whitespace, and removes the postfix '_id'.
+
+```javascript
+_(' capitalize dash-CamelCase_underscore trim ').humanize()
+=> 'Capitalize dash camel case underscore trim'
+```
+
+**trim** _.trim(string, [characters])
+
+trims defined characters from begining and ending of the string.
+Defaults to whitespace characters.
+
+```javascript
+_.trim(" foobar ")
+=> "foobar"
+
+_.trim("_-foobar-_", "_-")
+=> "foobar"
+```
+
+
+**ltrim** _.ltrim(string, [characters])
+
+Left trim. Similar to trim, but only for left side.
+
+
+**rtrim** _.rtrim(string, [characters])
+
+Right trim. Similar to trim, but only for right side.
+
+**truncate** _.truncate(string, length, truncateString)
+
+```javascript
+_('Hello world').truncate(5)
+=> 'Hello...'
+
+_('Hello').truncate(10)
+=> 'Hello'
+```
+
+**prune** _.prune(string, length, pruneString)
+
+Elegant version of truncate.
+Makes sure the pruned string does not exceed the original length.
+Avoid half-chopped words when truncating.
+
+```javascript
+_('Hello, world').prune(5)
+=> 'Hello...'
+
+_('Hello, world').prune(8)
+=> 'Hello...'
+
+_('Hello, world').prune(5, ' (read a lot more)')
+=> 'Hello, world' (as adding "(read a lot more)" would be longer than the original string)
+
+_('Hello, cruel world').prune(15)
+=> 'Hello, cruel...'
+
+_('Hello').prune(10)
+=> 'Hello'
+```
+
+**words** _.words(str, delimiter=/\s+/)
+
+Split string by delimiter (String or RegExp), /\s+/ by default.
+
+```javascript
+_.words(" I love you ")
+=> ["I","love","you"]
+
+_.words("I_love_you", "_")
+=> ["I","love","you"]
+
+_.words("I-love-you", /-/)
+=> ["I","love","you"]
+
+_.words(" ")
+=> []
+```
+
+**sprintf** _.sprintf(string format, *arguments)
+
+C like string formatting.
+Credits goes to [Alexandru Marasteanu][o].
+For more detailed documentation, see the [original page][o].
+
+[o]: http://www.diveintojavascript.com/projects/javascript-sprintf
+
+```javascript
+_.sprintf("%.1f", 1.17)
+"1.2"
+```
+
+**pad** _.pad(str, length, [padStr, type])
+
+pads the `str` with characters until the total string length is equal to the passed `length` parameter. By default, pads on the **left** with the space char (`" "`). `padStr` is truncated to a single character if necessary.
+
+```javascript
+_.pad("1", 8)
+-> " 1";
+
+_.pad("1", 8, '0')
+-> "00000001";
+
+_.pad("1", 8, '0', 'right')
+-> "10000000";
+
+_.pad("1", 8, '0', 'both')
+-> "00001000";
+
+_.pad("1", 8, 'bleepblorp', 'both')
+-> "bbbb1bbb";
+```
+
+**lpad** _.lpad(str, length, [padStr])
+
+left-pad a string. Alias for `pad(str, length, padStr, 'left')`
+
+```javascript
+_.lpad("1", 8, '0')
+-> "00000001";
+```
+
+**rpad** _.rpad(str, length, [padStr])
+
+right-pad a string. Alias for `pad(str, length, padStr, 'right')`
+
+```javascript
+_.rpad("1", 8, '0')
+-> "10000000";
+```
+
+**lrpad** _.lrpad(str, length, [padStr])
+
+left/right-pad a string. Alias for `pad(str, length, padStr, 'both')`
+
+```javascript
+_.lrpad("1", 8, '0')
+-> "00001000";
+```
+
+**center** alias for **lrpad**
+
+**ljust** alias for *rpad*
+
+**rjust** alias for *lpad*
+
+**toNumber** _.toNumber(string, [decimals])
+
+Parse string to number. Returns NaN if string can't be parsed to number.
+
+```javascript
+_('2.556').toNumber()
+=> 3
+
+_('2.556').toNumber(1)
+=> 2.6
+```
+
+**strRight** _.strRight(string, pattern)
+
+Searches a string from left to right for a pattern and returns a substring consisting of the characters in the string that are to the right of the pattern or all string if no match found.
+
+```javascript
+_('This_is_a_test_string').strRight('_')
+=> "is_a_test_string";
+```
+
+**strRightBack** _.strRightBack(string, pattern)
+
+Searches a string from right to left for a pattern and returns a substring consisting of the characters in the string that are to the right of the pattern or all string if no match found.
+
+```javascript
+_('This_is_a_test_string').strRightBack('_')
+=> "string";
+```
+
+**strLeft** _.strLeft(string, pattern)
+
+Searches a string from left to right for a pattern and returns a substring consisting of the characters in the string that are to the left of the pattern or all string if no match found.
+
+```javascript
+_('This_is_a_test_string').strLeft('_')
+=> "This";
+```
+
+**strLeftBack** _.strLeftBack(string, pattern)
+
+Searches a string from right to left for a pattern and returns a substring consisting of the characters in the string that are to the left of the pattern or all string if no match found.
+
+```javascript
+_('This_is_a_test_string').strLeftBack('_')
+=> "This_is_a_test";
+```
+
+**stripTags**
+
+Removes all html tags from string.
+
+```javascript
+_('a link').stripTags()
+=> 'a link'
+
+_('a link').stripTags()
+=> 'a linkalert("hello world!")'
+```
+
+**toSentence** _.toSentence(array, [delimiter, lastDelimiter])
+
+Join an array into a human readable sentence.
+
+```javascript
+_.toSentence(['jQuery', 'Mootools', 'Prototype'])
+=> 'jQuery, Mootools and Prototype';
+
+_.toSentence(['jQuery', 'Mootools', 'Prototype'], ', ', ' unt ')
+=> 'jQuery, Mootools unt Prototype';
+```
+
+**toSentenceSerial** _.toSentenceSerial(array, [delimiter, lastDelimiter])
+
+The same as `toSentence`, but adjusts delimeters to use [Serial comma](http://en.wikipedia.org/wiki/Serial_comma).
+
+```javascript
+_.toSentenceSerial(['jQuery', 'Mootools'])
+=> 'jQuery and Mootools';
+
+_.toSentenceSerial(['jQuery', 'Mootools', 'Prototype'])
+=> 'jQuery, Mootools, and Prototype'
+
+_.toSentenceSerial(['jQuery', 'Mootools', 'Prototype'], ', ', ' unt ');
+=> 'jQuery, Mootools, unt Prototype';
+```
+
+**repeat** _.repeat(string, count, [separator])
+
+Repeats a string count times.
+
+```javascript
+_.repeat("foo", 3)
+=> 'foofoofoo';
+
+_.repeat("foo", 3, "bar")
+=> 'foobarfoobarfoo'
+```
+
+**surround** _.surround(string, wrap)
+
+Surround a string with another string.
+
+```javascript
+_.surround("foo", "ab")
+=> 'abfooab';
+```
+
+**quote** _.quote(string, quoteChar) or _.q(string, quoteChar)
+
+Quotes a string. `quoteChar` defaults to `"`.
+
+```javascript
+_.quote('foo', quoteChar)
+=> '"foo"';
+```
+**unquote** _.unquote(string, quoteChar)
+
+Unquotes a string. `quoteChar` defaults to `"`.
+
+```javascript
+_.unquote('"foo"')
+=> 'foo';
+_.unquote("'foo'", "'")
+=> 'foo';
+```
+
+
+**slugify** _.slugify(string)
+
+Transform text into a URL slug. Replaces whitespaces, accentuated, and special characters with a dash.
+
+```javascript
+_.slugify("Un éléphant à l'orée du bois")
+=> 'un-elephant-a-loree-du-bois';
+```
+
+***Caution: this function is charset dependent***
+
+**naturalCmp** array.sort(_.naturalCmp)
+
+Naturally sort strings like humans would do.
+
+```javascript
+['foo20', 'foo5'].sort(_.naturalCmp)
+=> [ 'foo5', 'foo20' ]
+```
+
+**toBoolean** _.toBoolean(string) or _.toBool(string)
+
+Turn strings that can be commonly considered as booleas to real booleans. Such as "true", "false", "1" and "0". This function is case insensitive.
+
+```javascript
+_.toBoolean("true")
+=> true
+_.toBoolean("FALSE")
+=> false
+_.toBoolean("random")
+=> undefined
+```
+
+It can be customized by giving arrays of truth and falsy value matcher as parameters. Matchers can be also RegExp objects.
+
+```javascript
+_.toBoolean("truthy", ["truthy"], ["falsy"])
+=> true
+_.toBoolean("true only at start", [/^true/])
+=> true
+```
+
+## Roadmap ##
+
+Any suggestions or bug reports are welcome. Just email me or more preferably open an issue.
+
+#### Problems
+
+We lose two things for `include` and `reverse` methods from `_.string`:
+
+* Calls like `_('foobar').include('bar')` aren't available;
+* Chaining isn't available too.
+
+But if you need this functionality you can create aliases for conflict functions which will be convenient for you:
+
+```javascript
+_.mixin({
+ includeString: _.str.include,
+ reverseString: _.str.reverse
+})
+
+// Now wrapper calls and chaining are available.
+_('foobar').chain().reverseString().includeString('rab').value()
+```
+
+#### Standalone Usage
+
+If you are using Underscore.string without Underscore. You also have `_.string` namespace for it and `_.str` alias
+But of course you can just reassign `_` variable with `_.string`
+
+```javascript
+_ = _.string
+```
+
+## Changelog ##
+
+### 2.4.0 ###
+
+* Move from rake to gulp
+* Add support form classify camelcase strings
+* Fix bower.json
+* [Full changelog](https://github.com/epeli/underscore.string/compare/v2.3.3...2.4.0)
+
+### 2.3.3 ###
+
+* Add `toBoolean`
+* Add `unquote`
+* Add quote char option to `quote`
+* Support dash-separated words in `titleize`
+* [Full changelog](https://github.com/epeli/underscore.string/compare/v2.3.2...2.3.3)
+
+### 2.3.2 ###
+
+* Add `naturalCmp`
+* Bug fix to `camelize`
+* Add ă, ș, ț and ś to `slugify`
+* Doc updates
+* Add support for [component](http://component.io/)
+* [Full changelog](https://github.com/epeli/underscore.string/compare/v2.3.1...v2.3.2)
+
+### 2.3.1 ###
+
+* Bug fixes to `escapeHTML`, `classify`, `substr`
+* Faster `count`
+* Documentation fixes
+* [Full changelog](https://github.com/epeli/underscore.string/compare/v2.3.0...v2.3.1)
+
+### 2.3.0 ###
+
+* Added `numberformat` method
+* Added `levenshtein` method (Levenshtein distance calculation)
+* Added `swapCase` method
+* Changed default behavior of `words` method
+* Added `toSentenceSerial` method
+* Added `surround` and `quote` methods
+
+### 2.2.1 ###
+
+* Same as 2.2.0 (2.2.0rc on npm) to fix some npm drama
+
+### 2.2.0 ###
+
+* Capitalize method behavior changed
+* Various perfomance tweaks
+
+### 2.1.1###
+
+* Fixed words method bug
+* Added classify method
+
+### 2.1.0 ###
+
+* AMD support
+* Added toSentence method
+* Added slugify method
+* Lots of speed optimizations
+
+### 2.0.0 ###
+
+* Added prune, humanize functions
+* Added _.string (_.str) namespace for Underscore.string library
+* Removed includes function
+
+For upgrading to this version you need to mix in Underscore.string library to Underscore object:
+
+```javascript
+_.mixin(_.string.exports());
+```
+
+and all non-conflict Underscore.string functions will be available through Underscore object.
+Also function `includes` has been removed, you should replace this function by `_.str.include`
+or create alias `_.includes = _.str.include` and all your code will work fine.
+
+### 1.1.6 ###
+
+* Fixed reverse and truncate
+* Added isBlank, stripTags, inlude(alias for includes)
+* Added uglifier compression
+
+### 1.1.5 ###
+
+* Added strRight, strRightBack, strLeft, strLeftBack
+
+### 1.1.4 ###
+
+* Added pad, lpad, rpad, lrpad methods and aliases center, ljust, rjust
+* Integration with Underscore 1.1.6
+
+### 1.1.3 ###
+
+* Added methods: underscored, camelize, dasherize
+* Support newer version of npm
+
+### 1.1.2 ###
+
+* Created functions: lines, chars, words functions
+
+### 1.0.2 ###
+
+* Created integration test suite with underscore.js 1.1.4 (now it's absolutely compatible)
+* Removed 'reverse' function, because this function override underscore.js 'reverse'
+
+## Contribute ##
+
+* Fork & pull request. Don't forget about tests.
+* If you planning add some feature please create issue before.
+
+Otherwise changes will be rejected.
+
+## Contributors list ##
+[Can be found here](https://github.com/epeli/underscore.string/graphs/contributors).
+
+
+## Licence ##
+
+The MIT License
+
+Copyright (c) 2011 Esa-Matti Suuronen esa-matti@suuronen.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore.string/bower.json b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore.string/bower.json
new file mode 100644
index 0000000..6aef0bd
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore.string/bower.json
@@ -0,0 +1,33 @@
+{
+ "name": "underscore.string",
+ "version": "2.4.0",
+ "description": "String manipulation extensions for Underscore.js javascript library.",
+ "homepage": "http://epeli.github.com/underscore.string/",
+ "contributors": [
+ "Esa-Matti Suuronen (http://esa-matti.suuronen.org/)",
+ "Edward Tsech ",
+ "Pavel Pravosud ()",
+ "Sasha Koss (http://koss.nocorp.me/)",
+ "Vladimir Dronnikov ",
+ "Pete Kruckenberg ()",
+ "Paul Chavard ()",
+ "Ed Finkler ()"
+ ],
+ "keywords": [
+ "underscore",
+ "string"
+ ],
+ "main": "./lib/underscore.string.js",
+ "repository": {
+ "type": "git",
+ "url": "https://github.com/epeli/underscore.string.git"
+ },
+ "bugs": {
+ "url": "https://github.com/epeli/underscore.string/issues"
+ },
+ "licenses": [
+ {
+ "type": "MIT"
+ }
+ ]
+}
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore.string/component.json b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore.string/component.json
new file mode 100644
index 0000000..96e23d3
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore.string/component.json
@@ -0,0 +1,11 @@
+{
+ "name": "underscore.string",
+ "repo": "epeli/underscore.string",
+ "description": "String manipulation extensions for Underscore.js javascript library",
+ "version": "2.4.0",
+ "keywords": ["underscore", "string"],
+ "dependencies": {},
+ "development": {},
+ "main": "lib/underscore.string.js",
+ "scripts": ["lib/underscore.string.js"]
+}
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore.string/foo.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore.string/foo.js
new file mode 100644
index 0000000..cdc1d08
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore.string/foo.js
@@ -0,0 +1,10 @@
+
+ function boolMatch(s, matchers) {
+ var i, matcher, down = s.toLowerCase();
+ matchers = [].concat(matchers);
+ for (i = 0; i < matchers.length; i += 1) {
+ matcher = matchers[i];
+ if (matcher.test && matcher.test(s)) return true;
+ if (matcher && matcher.toLowerCase() === down) return true;
+ }
+ }
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore.string/gulpfile.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore.string/gulpfile.js
new file mode 100644
index 0000000..6eaead8
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore.string/gulpfile.js
@@ -0,0 +1,26 @@
+var gulp = require('gulp'),
+ qunit = require("gulp-qunit"),
+ uglify = require('gulp-uglify'),
+ clean = require('gulp-clean'),
+ rename = require('gulp-rename'),
+ SRC = 'lib/underscore.string.js',
+ DEST = 'dist',
+ MIN_FILE = 'underscore.string.min.js',
+ TEST_SUITES = ['test/test.html', 'test/test_underscore/index.html'];
+
+gulp.task('test', function() {
+ return gulp.src(TEST_SUITES)
+ .pipe(qunit());
+});
+
+gulp.task('clean', function() {
+ return gulp.src(DEST)
+ .pipe(clean());
+});
+
+gulp.task('build', ['test', 'clean'], function() {
+ return gulp.src(SRC)
+ .pipe(uglify())
+ .pipe(rename(MIN_FILE))
+ .pipe(gulp.dest(DEST));
+});
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore.string/lib/underscore.string.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore.string/lib/underscore.string.js
new file mode 100644
index 0000000..c9c8d47
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore.string/lib/underscore.string.js
@@ -0,0 +1,673 @@
+// Underscore.string
+// (c) 2010 Esa-Matti Suuronen
+// Underscore.string is freely distributable under the terms of the MIT license.
+// Documentation: https://github.com/epeli/underscore.string
+// Some code is borrowed from MooTools and Alexandru Marasteanu.
+// Version '2.4.0'
+
+!function(root, String){
+ 'use strict';
+
+ // Defining helper functions.
+
+ var nativeTrim = String.prototype.trim;
+ var nativeTrimRight = String.prototype.trimRight;
+ var nativeTrimLeft = String.prototype.trimLeft;
+
+ var parseNumber = function(source) { return source * 1 || 0; };
+
+ var strRepeat = function(str, qty){
+ if (qty < 1) return '';
+ var result = '';
+ while (qty > 0) {
+ if (qty & 1) result += str;
+ qty >>= 1, str += str;
+ }
+ return result;
+ };
+
+ var slice = [].slice;
+
+ var defaultToWhiteSpace = function(characters) {
+ if (characters == null)
+ return '\\s';
+ else if (characters.source)
+ return characters.source;
+ else
+ return '[' + _s.escapeRegExp(characters) + ']';
+ };
+
+ // Helper for toBoolean
+ function boolMatch(s, matchers) {
+ var i, matcher, down = s.toLowerCase();
+ matchers = [].concat(matchers);
+ for (i = 0; i < matchers.length; i += 1) {
+ matcher = matchers[i];
+ if (!matcher) continue;
+ if (matcher.test && matcher.test(s)) return true;
+ if (matcher.toLowerCase() === down) return true;
+ }
+ }
+
+ var escapeChars = {
+ lt: '<',
+ gt: '>',
+ quot: '"',
+ amp: '&',
+ apos: "'"
+ };
+
+ var reversedEscapeChars = {};
+ for(var key in escapeChars) reversedEscapeChars[escapeChars[key]] = key;
+ reversedEscapeChars["'"] = '#39';
+
+ // sprintf() for JavaScript 0.7-beta1
+ // http://www.diveintojavascript.com/projects/javascript-sprintf
+ //
+ // Copyright (c) Alexandru Marasteanu
+ // All rights reserved.
+
+ var sprintf = (function() {
+ function get_type(variable) {
+ return Object.prototype.toString.call(variable).slice(8, -1).toLowerCase();
+ }
+
+ var str_repeat = strRepeat;
+
+ var str_format = function() {
+ if (!str_format.cache.hasOwnProperty(arguments[0])) {
+ str_format.cache[arguments[0]] = str_format.parse(arguments[0]);
+ }
+ return str_format.format.call(null, str_format.cache[arguments[0]], arguments);
+ };
+
+ str_format.format = function(parse_tree, argv) {
+ var cursor = 1, tree_length = parse_tree.length, node_type = '', arg, output = [], i, k, match, pad, pad_character, pad_length;
+ for (i = 0; i < tree_length; i++) {
+ node_type = get_type(parse_tree[i]);
+ if (node_type === 'string') {
+ output.push(parse_tree[i]);
+ }
+ else if (node_type === 'array') {
+ match = parse_tree[i]; // convenience purposes only
+ if (match[2]) { // keyword argument
+ arg = argv[cursor];
+ for (k = 0; k < match[2].length; k++) {
+ if (!arg.hasOwnProperty(match[2][k])) {
+ throw new Error(sprintf('[_.sprintf] property "%s" does not exist', match[2][k]));
+ }
+ arg = arg[match[2][k]];
+ }
+ } else if (match[1]) { // positional argument (explicit)
+ arg = argv[match[1]];
+ }
+ else { // positional argument (implicit)
+ arg = argv[cursor++];
+ }
+
+ if (/[^s]/.test(match[8]) && (get_type(arg) != 'number')) {
+ throw new Error(sprintf('[_.sprintf] expecting number but found %s', get_type(arg)));
+ }
+ switch (match[8]) {
+ case 'b': arg = arg.toString(2); break;
+ case 'c': arg = String.fromCharCode(arg); break;
+ case 'd': arg = parseInt(arg, 10); break;
+ case 'e': arg = match[7] ? arg.toExponential(match[7]) : arg.toExponential(); break;
+ case 'f': arg = match[7] ? parseFloat(arg).toFixed(match[7]) : parseFloat(arg); break;
+ case 'o': arg = arg.toString(8); break;
+ case 's': arg = ((arg = String(arg)) && match[7] ? arg.substring(0, match[7]) : arg); break;
+ case 'u': arg = Math.abs(arg); break;
+ case 'x': arg = arg.toString(16); break;
+ case 'X': arg = arg.toString(16).toUpperCase(); break;
+ }
+ arg = (/[def]/.test(match[8]) && match[3] && arg >= 0 ? '+'+ arg : arg);
+ pad_character = match[4] ? match[4] == '0' ? '0' : match[4].charAt(1) : ' ';
+ pad_length = match[6] - String(arg).length;
+ pad = match[6] ? str_repeat(pad_character, pad_length) : '';
+ output.push(match[5] ? arg + pad : pad + arg);
+ }
+ }
+ return output.join('');
+ };
+
+ str_format.cache = {};
+
+ str_format.parse = function(fmt) {
+ var _fmt = fmt, match = [], parse_tree = [], arg_names = 0;
+ while (_fmt) {
+ if ((match = /^[^\x25]+/.exec(_fmt)) !== null) {
+ parse_tree.push(match[0]);
+ }
+ else if ((match = /^\x25{2}/.exec(_fmt)) !== null) {
+ parse_tree.push('%');
+ }
+ else if ((match = /^\x25(?:([1-9]\d*)\$|\(([^\)]+)\))?(\+)?(0|'[^$])?(-)?(\d+)?(?:\.(\d+))?([b-fosuxX])/.exec(_fmt)) !== null) {
+ if (match[2]) {
+ arg_names |= 1;
+ var field_list = [], replacement_field = match[2], field_match = [];
+ if ((field_match = /^([a-z_][a-z_\d]*)/i.exec(replacement_field)) !== null) {
+ field_list.push(field_match[1]);
+ while ((replacement_field = replacement_field.substring(field_match[0].length)) !== '') {
+ if ((field_match = /^\.([a-z_][a-z_\d]*)/i.exec(replacement_field)) !== null) {
+ field_list.push(field_match[1]);
+ }
+ else if ((field_match = /^\[(\d+)\]/.exec(replacement_field)) !== null) {
+ field_list.push(field_match[1]);
+ }
+ else {
+ throw new Error('[_.sprintf] huh?');
+ }
+ }
+ }
+ else {
+ throw new Error('[_.sprintf] huh?');
+ }
+ match[2] = field_list;
+ }
+ else {
+ arg_names |= 2;
+ }
+ if (arg_names === 3) {
+ throw new Error('[_.sprintf] mixing positional and named placeholders is not (yet) supported');
+ }
+ parse_tree.push(match);
+ }
+ else {
+ throw new Error('[_.sprintf] huh?');
+ }
+ _fmt = _fmt.substring(match[0].length);
+ }
+ return parse_tree;
+ };
+
+ return str_format;
+ })();
+
+
+
+ // Defining underscore.string
+
+ var _s = {
+
+ VERSION: '2.4.0',
+
+ isBlank: function(str){
+ if (str == null) str = '';
+ return (/^\s*$/).test(str);
+ },
+
+ stripTags: function(str){
+ if (str == null) return '';
+ return String(str).replace(/<\/?[^>]+>/g, '');
+ },
+
+ capitalize : function(str){
+ str = str == null ? '' : String(str);
+ return str.charAt(0).toUpperCase() + str.slice(1);
+ },
+
+ chop: function(str, step){
+ if (str == null) return [];
+ str = String(str);
+ step = ~~step;
+ return step > 0 ? str.match(new RegExp('.{1,' + step + '}', 'g')) : [str];
+ },
+
+ clean: function(str){
+ return _s.strip(str).replace(/\s+/g, ' ');
+ },
+
+ count: function(str, substr){
+ if (str == null || substr == null) return 0;
+
+ str = String(str);
+ substr = String(substr);
+
+ var count = 0,
+ pos = 0,
+ length = substr.length;
+
+ while (true) {
+ pos = str.indexOf(substr, pos);
+ if (pos === -1) break;
+ count++;
+ pos += length;
+ }
+
+ return count;
+ },
+
+ chars: function(str) {
+ if (str == null) return [];
+ return String(str).split('');
+ },
+
+ swapCase: function(str) {
+ if (str == null) return '';
+ return String(str).replace(/\S/g, function(c){
+ return c === c.toUpperCase() ? c.toLowerCase() : c.toUpperCase();
+ });
+ },
+
+ escapeHTML: function(str) {
+ if (str == null) return '';
+ return String(str).replace(/[&<>"']/g, function(m){ return '&' + reversedEscapeChars[m] + ';'; });
+ },
+
+ unescapeHTML: function(str) {
+ if (str == null) return '';
+ return String(str).replace(/\&([^;]+);/g, function(entity, entityCode){
+ var match;
+
+ if (entityCode in escapeChars) {
+ return escapeChars[entityCode];
+ } else if (match = entityCode.match(/^#x([\da-fA-F]+)$/)) {
+ return String.fromCharCode(parseInt(match[1], 16));
+ } else if (match = entityCode.match(/^#(\d+)$/)) {
+ return String.fromCharCode(~~match[1]);
+ } else {
+ return entity;
+ }
+ });
+ },
+
+ escapeRegExp: function(str){
+ if (str == null) return '';
+ return String(str).replace(/([.*+?^=!:${}()|[\]\/\\])/g, '\\$1');
+ },
+
+ splice: function(str, i, howmany, substr){
+ var arr = _s.chars(str);
+ arr.splice(~~i, ~~howmany, substr);
+ return arr.join('');
+ },
+
+ insert: function(str, i, substr){
+ return _s.splice(str, i, 0, substr);
+ },
+
+ include: function(str, needle){
+ if (needle === '') return true;
+ if (str == null) return false;
+ return String(str).indexOf(needle) !== -1;
+ },
+
+ join: function() {
+ var args = slice.call(arguments),
+ separator = args.shift();
+
+ if (separator == null) separator = '';
+
+ return args.join(separator);
+ },
+
+ lines: function(str) {
+ if (str == null) return [];
+ return String(str).split("\n");
+ },
+
+ reverse: function(str){
+ return _s.chars(str).reverse().join('');
+ },
+
+ startsWith: function(str, starts){
+ if (starts === '') return true;
+ if (str == null || starts == null) return false;
+ str = String(str); starts = String(starts);
+ return str.length >= starts.length && str.slice(0, starts.length) === starts;
+ },
+
+ endsWith: function(str, ends){
+ if (ends === '') return true;
+ if (str == null || ends == null) return false;
+ str = String(str); ends = String(ends);
+ return str.length >= ends.length && str.slice(str.length - ends.length) === ends;
+ },
+
+ succ: function(str){
+ if (str == null) return '';
+ str = String(str);
+ return str.slice(0, -1) + String.fromCharCode(str.charCodeAt(str.length-1) + 1);
+ },
+
+ titleize: function(str){
+ if (str == null) return '';
+ str = String(str).toLowerCase();
+ return str.replace(/(?:^|\s|-)\S/g, function(c){ return c.toUpperCase(); });
+ },
+
+ camelize: function(str){
+ return _s.trim(str).replace(/[-_\s]+(.)?/g, function(match, c){ return c ? c.toUpperCase() : ""; });
+ },
+
+ underscored: function(str){
+ return _s.trim(str).replace(/([a-z\d])([A-Z]+)/g, '$1_$2').replace(/[-\s]+/g, '_').toLowerCase();
+ },
+
+ dasherize: function(str){
+ return _s.trim(str).replace(/([A-Z])/g, '-$1').replace(/[-_\s]+/g, '-').toLowerCase();
+ },
+
+ classify: function(str){
+ return _s.capitalize(_s.camelize(String(str).replace(/[\W_]/g, ' ')).replace(/\s/g, ''));
+ },
+
+ humanize: function(str){
+ return _s.capitalize(_s.underscored(str).replace(/_id$/,'').replace(/_/g, ' '));
+ },
+
+ trim: function(str, characters){
+ if (str == null) return '';
+ if (!characters && nativeTrim) return nativeTrim.call(str);
+ characters = defaultToWhiteSpace(characters);
+ return String(str).replace(new RegExp('^' + characters + '+|' + characters + '+$', 'g'), '');
+ },
+
+ ltrim: function(str, characters){
+ if (str == null) return '';
+ if (!characters && nativeTrimLeft) return nativeTrimLeft.call(str);
+ characters = defaultToWhiteSpace(characters);
+ return String(str).replace(new RegExp('^' + characters + '+'), '');
+ },
+
+ rtrim: function(str, characters){
+ if (str == null) return '';
+ if (!characters && nativeTrimRight) return nativeTrimRight.call(str);
+ characters = defaultToWhiteSpace(characters);
+ return String(str).replace(new RegExp(characters + '+$'), '');
+ },
+
+ truncate: function(str, length, truncateStr){
+ if (str == null) return '';
+ str = String(str); truncateStr = truncateStr || '...';
+ length = ~~length;
+ return str.length > length ? str.slice(0, length) + truncateStr : str;
+ },
+
+ /**
+ * _s.prune: a more elegant version of truncate
+ * prune extra chars, never leaving a half-chopped word.
+ * @author github.com/rwz
+ */
+ prune: function(str, length, pruneStr){
+ if (str == null) return '';
+
+ str = String(str); length = ~~length;
+ pruneStr = pruneStr != null ? String(pruneStr) : '...';
+
+ if (str.length <= length) return str;
+
+ var tmpl = function(c){ return c.toUpperCase() !== c.toLowerCase() ? 'A' : ' '; },
+ template = str.slice(0, length+1).replace(/.(?=\W*\w*$)/g, tmpl); // 'Hello, world' -> 'HellAA AAAAA'
+
+ if (template.slice(template.length-2).match(/\w\w/))
+ template = template.replace(/\s*\S+$/, '');
+ else
+ template = _s.rtrim(template.slice(0, template.length-1));
+
+ return (template+pruneStr).length > str.length ? str : str.slice(0, template.length)+pruneStr;
+ },
+
+ words: function(str, delimiter) {
+ if (_s.isBlank(str)) return [];
+ return _s.trim(str, delimiter).split(delimiter || /\s+/);
+ },
+
+ pad: function(str, length, padStr, type) {
+ str = str == null ? '' : String(str);
+ length = ~~length;
+
+ var padlen = 0;
+
+ if (!padStr)
+ padStr = ' ';
+ else if (padStr.length > 1)
+ padStr = padStr.charAt(0);
+
+ switch(type) {
+ case 'right':
+ padlen = length - str.length;
+ return str + strRepeat(padStr, padlen);
+ case 'both':
+ padlen = length - str.length;
+ return strRepeat(padStr, Math.ceil(padlen/2)) + str
+ + strRepeat(padStr, Math.floor(padlen/2));
+ default: // 'left'
+ padlen = length - str.length;
+ return strRepeat(padStr, padlen) + str;
+ }
+ },
+
+ lpad: function(str, length, padStr) {
+ return _s.pad(str, length, padStr);
+ },
+
+ rpad: function(str, length, padStr) {
+ return _s.pad(str, length, padStr, 'right');
+ },
+
+ lrpad: function(str, length, padStr) {
+ return _s.pad(str, length, padStr, 'both');
+ },
+
+ sprintf: sprintf,
+
+ vsprintf: function(fmt, argv){
+ argv.unshift(fmt);
+ return sprintf.apply(null, argv);
+ },
+
+ toNumber: function(str, decimals) {
+ if (!str) return 0;
+ str = _s.trim(str);
+ if (!str.match(/^-?\d+(?:\.\d+)?$/)) return NaN;
+ return parseNumber(parseNumber(str).toFixed(~~decimals));
+ },
+
+ numberFormat : function(number, dec, dsep, tsep) {
+ if (isNaN(number) || number == null) return '';
+
+ number = number.toFixed(~~dec);
+ tsep = typeof tsep == 'string' ? tsep : ',';
+
+ var parts = number.split('.'), fnums = parts[0],
+ decimals = parts[1] ? (dsep || '.') + parts[1] : '';
+
+ return fnums.replace(/(\d)(?=(?:\d{3})+$)/g, '$1' + tsep) + decimals;
+ },
+
+ strRight: function(str, sep){
+ if (str == null) return '';
+ str = String(str); sep = sep != null ? String(sep) : sep;
+ var pos = !sep ? -1 : str.indexOf(sep);
+ return ~pos ? str.slice(pos+sep.length, str.length) : str;
+ },
+
+ strRightBack: function(str, sep){
+ if (str == null) return '';
+ str = String(str); sep = sep != null ? String(sep) : sep;
+ var pos = !sep ? -1 : str.lastIndexOf(sep);
+ return ~pos ? str.slice(pos+sep.length, str.length) : str;
+ },
+
+ strLeft: function(str, sep){
+ if (str == null) return '';
+ str = String(str); sep = sep != null ? String(sep) : sep;
+ var pos = !sep ? -1 : str.indexOf(sep);
+ return ~pos ? str.slice(0, pos) : str;
+ },
+
+ strLeftBack: function(str, sep){
+ if (str == null) return '';
+ str += ''; sep = sep != null ? ''+sep : sep;
+ var pos = str.lastIndexOf(sep);
+ return ~pos ? str.slice(0, pos) : str;
+ },
+
+ toSentence: function(array, separator, lastSeparator, serial) {
+ separator = separator || ', ';
+ lastSeparator = lastSeparator || ' and ';
+ var a = array.slice(), lastMember = a.pop();
+
+ if (array.length > 2 && serial) lastSeparator = _s.rtrim(separator) + lastSeparator;
+
+ return a.length ? a.join(separator) + lastSeparator + lastMember : lastMember;
+ },
+
+ toSentenceSerial: function() {
+ var args = slice.call(arguments);
+ args[3] = true;
+ return _s.toSentence.apply(_s, args);
+ },
+
+ slugify: function(str) {
+ if (str == null) return '';
+
+ var from = "ąàáäâãåæăćęèéëêìíïîłńòóöôõøśșțùúüûñçżź",
+ to = "aaaaaaaaaceeeeeiiiilnoooooosstuuuunczz",
+ regex = new RegExp(defaultToWhiteSpace(from), 'g');
+
+ str = String(str).toLowerCase().replace(regex, function(c){
+ var index = from.indexOf(c);
+ return to.charAt(index) || '-';
+ });
+
+ return _s.dasherize(str.replace(/[^\w\s-]/g, ''));
+ },
+
+ surround: function(str, wrapper) {
+ return [wrapper, str, wrapper].join('');
+ },
+
+ quote: function(str, quoteChar) {
+ return _s.surround(str, quoteChar || '"');
+ },
+
+ unquote: function(str, quoteChar) {
+ quoteChar = quoteChar || '"';
+ if (str[0] === quoteChar && str[str.length-1] === quoteChar)
+ return str.slice(1,str.length-1);
+ else return str;
+ },
+
+ exports: function() {
+ var result = {};
+
+ for (var prop in this) {
+ if (!this.hasOwnProperty(prop) || prop.match(/^(?:include|contains|reverse)$/)) continue;
+ result[prop] = this[prop];
+ }
+
+ return result;
+ },
+
+ repeat: function(str, qty, separator){
+ if (str == null) return '';
+
+ qty = ~~qty;
+
+ // using faster implementation if separator is not needed;
+ if (separator == null) return strRepeat(String(str), qty);
+
+ // this one is about 300x slower in Google Chrome
+ for (var repeat = []; qty > 0; repeat[--qty] = str) {}
+ return repeat.join(separator);
+ },
+
+ naturalCmp: function(str1, str2){
+ if (str1 == str2) return 0;
+ if (!str1) return -1;
+ if (!str2) return 1;
+
+ var cmpRegex = /(\.\d+)|(\d+)|(\D+)/g,
+ tokens1 = String(str1).toLowerCase().match(cmpRegex),
+ tokens2 = String(str2).toLowerCase().match(cmpRegex),
+ count = Math.min(tokens1.length, tokens2.length);
+
+ for(var i = 0; i < count; i++) {
+ var a = tokens1[i], b = tokens2[i];
+
+ if (a !== b){
+ var num1 = parseInt(a, 10);
+ if (!isNaN(num1)){
+ var num2 = parseInt(b, 10);
+ if (!isNaN(num2) && num1 - num2)
+ return num1 - num2;
+ }
+ return a < b ? -1 : 1;
+ }
+ }
+
+ if (tokens1.length === tokens2.length)
+ return tokens1.length - tokens2.length;
+
+ return str1 < str2 ? -1 : 1;
+ },
+
+ levenshtein: function(str1, str2) {
+ if (str1 == null && str2 == null) return 0;
+ if (str1 == null) return String(str2).length;
+ if (str2 == null) return String(str1).length;
+
+ str1 = String(str1); str2 = String(str2);
+
+ var current = [], prev, value;
+
+ for (var i = 0; i <= str2.length; i++)
+ for (var j = 0; j <= str1.length; j++) {
+ if (i && j)
+ if (str1.charAt(j - 1) === str2.charAt(i - 1))
+ value = prev;
+ else
+ value = Math.min(current[j], current[j - 1], prev) + 1;
+ else
+ value = i + j;
+
+ prev = current[j];
+ current[j] = value;
+ }
+
+ return current.pop();
+ },
+
+ toBoolean: function(str, trueValues, falseValues) {
+ if (typeof str === "number") str = "" + str;
+ if (typeof str !== "string") return !!str;
+ str = _s.trim(str);
+ if (boolMatch(str, trueValues || ["true", "1"])) return true;
+ if (boolMatch(str, falseValues || ["false", "0"])) return false;
+ }
+ };
+
+ // Aliases
+
+ _s.strip = _s.trim;
+ _s.lstrip = _s.ltrim;
+ _s.rstrip = _s.rtrim;
+ _s.center = _s.lrpad;
+ _s.rjust = _s.lpad;
+ _s.ljust = _s.rpad;
+ _s.contains = _s.include;
+ _s.q = _s.quote;
+ _s.toBool = _s.toBoolean;
+
+ // Exporting
+
+ // CommonJS module is defined
+ if (typeof exports !== 'undefined') {
+ if (typeof module !== 'undefined' && module.exports)
+ module.exports = _s;
+
+ exports._s = _s;
+ }
+
+ // Register as a named module with AMD.
+ if (typeof define === 'function' && define.amd)
+ define('underscore.string', [], function(){ return _s; });
+
+
+ // Integrate with Underscore.js if defined
+ // or create our own underscore object.
+ root._ = root._ || {};
+ root._.string = root._.str = _s;
+}(this, String);
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore.string/package.json b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore.string/package.json
new file mode 100644
index 0000000..db5d14e
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore.string/package.json
@@ -0,0 +1,107 @@
+{
+ "name": "underscore.string",
+ "version": "2.4.0",
+ "description": "String manipulation extensions for Underscore.js javascript library.",
+ "homepage": "http://epeli.github.com/underscore.string/",
+ "contributors": [
+ {
+ "name": "Esa-Matti Suuronen",
+ "email": "esa-matti@suuronen.org",
+ "url": "http://esa-matti.suuronen.org/"
+ },
+ {
+ "name": "Edward Tsech",
+ "email": "edtsech@gmail.com"
+ },
+ {
+ "name": "Pavel Pravosud",
+ "email": "pavel@pravosud.com",
+ "url": ""
+ },
+ {
+ "name": "Sasha Koss",
+ "email": "kossnocorp@gmail.com",
+ "url": "http://koss.nocorp.me/"
+ },
+ {
+ "name": "Vladimir Dronnikov",
+ "email": "dronnikov@gmail.com"
+ },
+ {
+ "name": "Pete Kruckenberg",
+ "email": "https://github.com/kruckenb",
+ "url": ""
+ },
+ {
+ "name": "Paul Chavard",
+ "email": "paul@chavard.net",
+ "url": ""
+ },
+ {
+ "name": "Ed Finkler",
+ "email": "coj@funkatron.com",
+ "url": ""
+ }
+ ],
+ "keywords": [
+ "underscore",
+ "string"
+ ],
+ "main": "./lib/underscore.string.js",
+ "directories": {
+ "lib": "./lib"
+ },
+ "engines": {
+ "node": "*"
+ },
+ "repository": {
+ "type": "git",
+ "url": "https://github.com/epeli/underscore.string.git"
+ },
+ "bugs": {
+ "url": "https://github.com/epeli/underscore.string/issues"
+ },
+ "licenses": [
+ {
+ "type": "MIT"
+ }
+ ],
+ "scripts": {
+ "test": "gulp test"
+ },
+ "devDependencies": {
+ "gulp": "~3.8.10",
+ "gulp-uglify": "~1.0.1",
+ "gulp-qunit": "~1.0.0",
+ "gulp-clean": "~0.3.1",
+ "gulp-rename": "~1.2.0"
+ },
+ "_id": "underscore.string@2.4.0",
+ "dist": {
+ "shasum": "8cdd8fbac4e2d2ea1e7e2e8097c42f442280f85b",
+ "tarball": "http://registry.npmjs.org/underscore.string/-/underscore.string-2.4.0.tgz"
+ },
+ "_from": "underscore.string@~2.4.0",
+ "_npmVersion": "1.3.24",
+ "_npmUser": {
+ "name": "epeli",
+ "email": "esa-matti@suuronen.org"
+ },
+ "maintainers": [
+ {
+ "name": "edtsech",
+ "email": "edtsech@gmail.com"
+ },
+ {
+ "name": "rwz",
+ "email": "rwz@duckroll.ru"
+ },
+ {
+ "name": "epeli",
+ "email": "esa-matti@suuronen.org"
+ }
+ ],
+ "_shasum": "8cdd8fbac4e2d2ea1e7e2e8097c42f442280f85b",
+ "_resolved": "https://registry.npmjs.org/underscore.string/-/underscore.string-2.4.0.tgz",
+ "readme": "ERROR: No README data found!"
+}
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore/LICENSE b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore/LICENSE
new file mode 100644
index 0000000..0d6b873
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore/LICENSE
@@ -0,0 +1,23 @@
+Copyright (c) 2009-2014 Jeremy Ashkenas, DocumentCloud and Investigative
+Reporters & Editors
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore/README.md b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore/README.md
new file mode 100644
index 0000000..c2ba259
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore/README.md
@@ -0,0 +1,22 @@
+ __
+ /\ \ __
+ __ __ ___ \_\ \ __ _ __ ____ ___ ___ _ __ __ /\_\ ____
+ /\ \/\ \ /' _ `\ /'_ \ /'__`\/\ __\/ ,__\ / ___\ / __`\/\ __\/'__`\ \/\ \ /',__\
+ \ \ \_\ \/\ \/\ \/\ \ \ \/\ __/\ \ \//\__, `\/\ \__//\ \ \ \ \ \//\ __/ __ \ \ \/\__, `\
+ \ \____/\ \_\ \_\ \___,_\ \____\\ \_\\/\____/\ \____\ \____/\ \_\\ \____\/\_\ _\ \ \/\____/
+ \/___/ \/_/\/_/\/__,_ /\/____/ \/_/ \/___/ \/____/\/___/ \/_/ \/____/\/_//\ \_\ \/___/
+ \ \____/
+ \/___/
+
+Underscore.js is a utility-belt library for JavaScript that provides
+support for the usual functional suspects (each, map, reduce, filter...)
+without extending any core JavaScript objects.
+
+For Docs, License, Tests, and pre-packed downloads, see:
+http://underscorejs.org
+
+Underscore is an open-sourced component of DocumentCloud:
+https://github.com/documentcloud
+
+Many thanks to our contributors:
+https://github.com/jashkenas/underscore/contributors
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore/package.json b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore/package.json
new file mode 100644
index 0000000..5a82a14
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore/package.json
@@ -0,0 +1,69 @@
+{
+ "name": "underscore",
+ "description": "JavaScript's functional programming helper library.",
+ "homepage": "http://underscorejs.org",
+ "keywords": [
+ "util",
+ "functional",
+ "server",
+ "client",
+ "browser"
+ ],
+ "author": {
+ "name": "Jeremy Ashkenas",
+ "email": "jeremy@documentcloud.org"
+ },
+ "repository": {
+ "type": "git",
+ "url": "git://github.com/jashkenas/underscore.git"
+ },
+ "main": "underscore.js",
+ "version": "1.7.0",
+ "devDependencies": {
+ "docco": "0.6.x",
+ "phantomjs": "1.9.7-1",
+ "uglify-js": "2.4.x",
+ "eslint": "0.6.x"
+ },
+ "scripts": {
+ "test": "phantomjs test/vendor/runner.js test/index.html?noglobals=true && eslint underscore.js test/*.js test/vendor/runner.js",
+ "build": "uglifyjs underscore.js -c \"evaluate=false\" --comments \"/ .*/\" -m --source-map underscore-min.map -o underscore-min.js",
+ "doc": "docco underscore.js"
+ },
+ "licenses": [
+ {
+ "type": "MIT",
+ "url": "https://raw.github.com/jashkenas/underscore/master/LICENSE"
+ }
+ ],
+ "files": [
+ "underscore.js",
+ "underscore-min.js",
+ "LICENSE"
+ ],
+ "gitHead": "da996e665deb0b69b257e80e3e257c04fde4191c",
+ "bugs": {
+ "url": "https://github.com/jashkenas/underscore/issues"
+ },
+ "_id": "underscore@1.7.0",
+ "_shasum": "6bbaf0877500d36be34ecaa584e0db9fef035209",
+ "_from": "underscore@~1.7.0",
+ "_npmVersion": "1.4.24",
+ "_npmUser": {
+ "name": "jashkenas",
+ "email": "jashkenas@gmail.com"
+ },
+ "maintainers": [
+ {
+ "name": "jashkenas",
+ "email": "jashkenas@gmail.com"
+ }
+ ],
+ "dist": {
+ "shasum": "6bbaf0877500d36be34ecaa584e0db9fef035209",
+ "tarball": "http://registry.npmjs.org/underscore/-/underscore-1.7.0.tgz"
+ },
+ "directories": {},
+ "_resolved": "https://registry.npmjs.org/underscore/-/underscore-1.7.0.tgz",
+ "readme": "ERROR: No README data found!"
+}
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore/underscore-min.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore/underscore-min.js
new file mode 100644
index 0000000..11f1d96
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore/underscore-min.js
@@ -0,0 +1,6 @@
+// Underscore.js 1.7.0
+// http://underscorejs.org
+// (c) 2009-2014 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+// Underscore may be freely distributed under the MIT license.
+(function(){var n=this,t=n._,r=Array.prototype,e=Object.prototype,u=Function.prototype,i=r.push,a=r.slice,o=r.concat,l=e.toString,c=e.hasOwnProperty,f=Array.isArray,s=Object.keys,p=u.bind,h=function(n){return n instanceof h?n:this instanceof h?void(this._wrapped=n):new h(n)};"undefined"!=typeof exports?("undefined"!=typeof module&&module.exports&&(exports=module.exports=h),exports._=h):n._=h,h.VERSION="1.7.0";var g=function(n,t,r){if(t===void 0)return n;switch(null==r?3:r){case 1:return function(r){return n.call(t,r)};case 2:return function(r,e){return n.call(t,r,e)};case 3:return function(r,e,u){return n.call(t,r,e,u)};case 4:return function(r,e,u,i){return n.call(t,r,e,u,i)}}return function(){return n.apply(t,arguments)}};h.iteratee=function(n,t,r){return null==n?h.identity:h.isFunction(n)?g(n,t,r):h.isObject(n)?h.matches(n):h.property(n)},h.each=h.forEach=function(n,t,r){if(null==n)return n;t=g(t,r);var e,u=n.length;if(u===+u)for(e=0;u>e;e++)t(n[e],e,n);else{var i=h.keys(n);for(e=0,u=i.length;u>e;e++)t(n[i[e]],i[e],n)}return n},h.map=h.collect=function(n,t,r){if(null==n)return[];t=h.iteratee(t,r);for(var e,u=n.length!==+n.length&&h.keys(n),i=(u||n).length,a=Array(i),o=0;i>o;o++)e=u?u[o]:o,a[o]=t(n[e],e,n);return a};var v="Reduce of empty array with no initial value";h.reduce=h.foldl=h.inject=function(n,t,r,e){null==n&&(n=[]),t=g(t,e,4);var u,i=n.length!==+n.length&&h.keys(n),a=(i||n).length,o=0;if(arguments.length<3){if(!a)throw new TypeError(v);r=n[i?i[o++]:o++]}for(;a>o;o++)u=i?i[o]:o,r=t(r,n[u],u,n);return r},h.reduceRight=h.foldr=function(n,t,r,e){null==n&&(n=[]),t=g(t,e,4);var u,i=n.length!==+n.length&&h.keys(n),a=(i||n).length;if(arguments.length<3){if(!a)throw new TypeError(v);r=n[i?i[--a]:--a]}for(;a--;)u=i?i[a]:a,r=t(r,n[u],u,n);return r},h.find=h.detect=function(n,t,r){var e;return t=h.iteratee(t,r),h.some(n,function(n,r,u){return t(n,r,u)?(e=n,!0):void 0}),e},h.filter=h.select=function(n,t,r){var e=[];return null==n?e:(t=h.iteratee(t,r),h.each(n,function(n,r,u){t(n,r,u)&&e.push(n)}),e)},h.reject=function(n,t,r){return h.filter(n,h.negate(h.iteratee(t)),r)},h.every=h.all=function(n,t,r){if(null==n)return!0;t=h.iteratee(t,r);var e,u,i=n.length!==+n.length&&h.keys(n),a=(i||n).length;for(e=0;a>e;e++)if(u=i?i[e]:e,!t(n[u],u,n))return!1;return!0},h.some=h.any=function(n,t,r){if(null==n)return!1;t=h.iteratee(t,r);var e,u,i=n.length!==+n.length&&h.keys(n),a=(i||n).length;for(e=0;a>e;e++)if(u=i?i[e]:e,t(n[u],u,n))return!0;return!1},h.contains=h.include=function(n,t){return null==n?!1:(n.length!==+n.length&&(n=h.values(n)),h.indexOf(n,t)>=0)},h.invoke=function(n,t){var r=a.call(arguments,2),e=h.isFunction(t);return h.map(n,function(n){return(e?t:n[t]).apply(n,r)})},h.pluck=function(n,t){return h.map(n,h.property(t))},h.where=function(n,t){return h.filter(n,h.matches(t))},h.findWhere=function(n,t){return h.find(n,h.matches(t))},h.max=function(n,t,r){var e,u,i=-1/0,a=-1/0;if(null==t&&null!=n){n=n.length===+n.length?n:h.values(n);for(var o=0,l=n.length;l>o;o++)e=n[o],e>i&&(i=e)}else t=h.iteratee(t,r),h.each(n,function(n,r,e){u=t(n,r,e),(u>a||u===-1/0&&i===-1/0)&&(i=n,a=u)});return i},h.min=function(n,t,r){var e,u,i=1/0,a=1/0;if(null==t&&null!=n){n=n.length===+n.length?n:h.values(n);for(var o=0,l=n.length;l>o;o++)e=n[o],i>e&&(i=e)}else t=h.iteratee(t,r),h.each(n,function(n,r,e){u=t(n,r,e),(a>u||1/0===u&&1/0===i)&&(i=n,a=u)});return i},h.shuffle=function(n){for(var t,r=n&&n.length===+n.length?n:h.values(n),e=r.length,u=Array(e),i=0;e>i;i++)t=h.random(0,i),t!==i&&(u[i]=u[t]),u[t]=r[i];return u},h.sample=function(n,t,r){return null==t||r?(n.length!==+n.length&&(n=h.values(n)),n[h.random(n.length-1)]):h.shuffle(n).slice(0,Math.max(0,t))},h.sortBy=function(n,t,r){return t=h.iteratee(t,r),h.pluck(h.map(n,function(n,r,e){return{value:n,index:r,criteria:t(n,r,e)}}).sort(function(n,t){var r=n.criteria,e=t.criteria;if(r!==e){if(r>e||r===void 0)return 1;if(e>r||e===void 0)return-1}return n.index-t.index}),"value")};var m=function(n){return function(t,r,e){var u={};return r=h.iteratee(r,e),h.each(t,function(e,i){var a=r(e,i,t);n(u,e,a)}),u}};h.groupBy=m(function(n,t,r){h.has(n,r)?n[r].push(t):n[r]=[t]}),h.indexBy=m(function(n,t,r){n[r]=t}),h.countBy=m(function(n,t,r){h.has(n,r)?n[r]++:n[r]=1}),h.sortedIndex=function(n,t,r,e){r=h.iteratee(r,e,1);for(var u=r(t),i=0,a=n.length;a>i;){var o=i+a>>>1;r(n[o])t?[]:a.call(n,0,t)},h.initial=function(n,t,r){return a.call(n,0,Math.max(0,n.length-(null==t||r?1:t)))},h.last=function(n,t,r){return null==n?void 0:null==t||r?n[n.length-1]:a.call(n,Math.max(n.length-t,0))},h.rest=h.tail=h.drop=function(n,t,r){return a.call(n,null==t||r?1:t)},h.compact=function(n){return h.filter(n,h.identity)};var y=function(n,t,r,e){if(t&&h.every(n,h.isArray))return o.apply(e,n);for(var u=0,a=n.length;a>u;u++){var l=n[u];h.isArray(l)||h.isArguments(l)?t?i.apply(e,l):y(l,t,r,e):r||e.push(l)}return e};h.flatten=function(n,t){return y(n,t,!1,[])},h.without=function(n){return h.difference(n,a.call(arguments,1))},h.uniq=h.unique=function(n,t,r,e){if(null==n)return[];h.isBoolean(t)||(e=r,r=t,t=!1),null!=r&&(r=h.iteratee(r,e));for(var u=[],i=[],a=0,o=n.length;o>a;a++){var l=n[a];if(t)a&&i===l||u.push(l),i=l;else if(r){var c=r(l,a,n);h.indexOf(i,c)<0&&(i.push(c),u.push(l))}else h.indexOf(u,l)<0&&u.push(l)}return u},h.union=function(){return h.uniq(y(arguments,!0,!0,[]))},h.intersection=function(n){if(null==n)return[];for(var t=[],r=arguments.length,e=0,u=n.length;u>e;e++){var i=n[e];if(!h.contains(t,i)){for(var a=1;r>a&&h.contains(arguments[a],i);a++);a===r&&t.push(i)}}return t},h.difference=function(n){var t=y(a.call(arguments,1),!0,!0,[]);return h.filter(n,function(n){return!h.contains(t,n)})},h.zip=function(n){if(null==n)return[];for(var t=h.max(arguments,"length").length,r=Array(t),e=0;t>e;e++)r[e]=h.pluck(arguments,e);return r},h.object=function(n,t){if(null==n)return{};for(var r={},e=0,u=n.length;u>e;e++)t?r[n[e]]=t[e]:r[n[e][0]]=n[e][1];return r},h.indexOf=function(n,t,r){if(null==n)return-1;var e=0,u=n.length;if(r){if("number"!=typeof r)return e=h.sortedIndex(n,t),n[e]===t?e:-1;e=0>r?Math.max(0,u+r):r}for(;u>e;e++)if(n[e]===t)return e;return-1},h.lastIndexOf=function(n,t,r){if(null==n)return-1;var e=n.length;for("number"==typeof r&&(e=0>r?e+r+1:Math.min(e,r+1));--e>=0;)if(n[e]===t)return e;return-1},h.range=function(n,t,r){arguments.length<=1&&(t=n||0,n=0),r=r||1;for(var e=Math.max(Math.ceil((t-n)/r),0),u=Array(e),i=0;e>i;i++,n+=r)u[i]=n;return u};var d=function(){};h.bind=function(n,t){var r,e;if(p&&n.bind===p)return p.apply(n,a.call(arguments,1));if(!h.isFunction(n))throw new TypeError("Bind must be called on a function");return r=a.call(arguments,2),e=function(){if(!(this instanceof e))return n.apply(t,r.concat(a.call(arguments)));d.prototype=n.prototype;var u=new d;d.prototype=null;var i=n.apply(u,r.concat(a.call(arguments)));return h.isObject(i)?i:u}},h.partial=function(n){var t=a.call(arguments,1);return function(){for(var r=0,e=t.slice(),u=0,i=e.length;i>u;u++)e[u]===h&&(e[u]=arguments[r++]);for(;r=e)throw new Error("bindAll must be passed function names");for(t=1;e>t;t++)r=arguments[t],n[r]=h.bind(n[r],n);return n},h.memoize=function(n,t){var r=function(e){var u=r.cache,i=t?t.apply(this,arguments):e;return h.has(u,i)||(u[i]=n.apply(this,arguments)),u[i]};return r.cache={},r},h.delay=function(n,t){var r=a.call(arguments,2);return setTimeout(function(){return n.apply(null,r)},t)},h.defer=function(n){return h.delay.apply(h,[n,1].concat(a.call(arguments,1)))},h.throttle=function(n,t,r){var e,u,i,a=null,o=0;r||(r={});var l=function(){o=r.leading===!1?0:h.now(),a=null,i=n.apply(e,u),a||(e=u=null)};return function(){var c=h.now();o||r.leading!==!1||(o=c);var f=t-(c-o);return e=this,u=arguments,0>=f||f>t?(clearTimeout(a),a=null,o=c,i=n.apply(e,u),a||(e=u=null)):a||r.trailing===!1||(a=setTimeout(l,f)),i}},h.debounce=function(n,t,r){var e,u,i,a,o,l=function(){var c=h.now()-a;t>c&&c>0?e=setTimeout(l,t-c):(e=null,r||(o=n.apply(i,u),e||(i=u=null)))};return function(){i=this,u=arguments,a=h.now();var c=r&&!e;return e||(e=setTimeout(l,t)),c&&(o=n.apply(i,u),i=u=null),o}},h.wrap=function(n,t){return h.partial(t,n)},h.negate=function(n){return function(){return!n.apply(this,arguments)}},h.compose=function(){var n=arguments,t=n.length-1;return function(){for(var r=t,e=n[t].apply(this,arguments);r--;)e=n[r].call(this,e);return e}},h.after=function(n,t){return function(){return--n<1?t.apply(this,arguments):void 0}},h.before=function(n,t){var r;return function(){return--n>0?r=t.apply(this,arguments):t=null,r}},h.once=h.partial(h.before,2),h.keys=function(n){if(!h.isObject(n))return[];if(s)return s(n);var t=[];for(var r in n)h.has(n,r)&&t.push(r);return t},h.values=function(n){for(var t=h.keys(n),r=t.length,e=Array(r),u=0;r>u;u++)e[u]=n[t[u]];return e},h.pairs=function(n){for(var t=h.keys(n),r=t.length,e=Array(r),u=0;r>u;u++)e[u]=[t[u],n[t[u]]];return e},h.invert=function(n){for(var t={},r=h.keys(n),e=0,u=r.length;u>e;e++)t[n[r[e]]]=r[e];return t},h.functions=h.methods=function(n){var t=[];for(var r in n)h.isFunction(n[r])&&t.push(r);return t.sort()},h.extend=function(n){if(!h.isObject(n))return n;for(var t,r,e=1,u=arguments.length;u>e;e++){t=arguments[e];for(r in t)c.call(t,r)&&(n[r]=t[r])}return n},h.pick=function(n,t,r){var e,u={};if(null==n)return u;if(h.isFunction(t)){t=g(t,r);for(e in n){var i=n[e];t(i,e,n)&&(u[e]=i)}}else{var l=o.apply([],a.call(arguments,1));n=new Object(n);for(var c=0,f=l.length;f>c;c++)e=l[c],e in n&&(u[e]=n[e])}return u},h.omit=function(n,t,r){if(h.isFunction(t))t=h.negate(t);else{var e=h.map(o.apply([],a.call(arguments,1)),String);t=function(n,t){return!h.contains(e,t)}}return h.pick(n,t,r)},h.defaults=function(n){if(!h.isObject(n))return n;for(var t=1,r=arguments.length;r>t;t++){var e=arguments[t];for(var u in e)n[u]===void 0&&(n[u]=e[u])}return n},h.clone=function(n){return h.isObject(n)?h.isArray(n)?n.slice():h.extend({},n):n},h.tap=function(n,t){return t(n),n};var b=function(n,t,r,e){if(n===t)return 0!==n||1/n===1/t;if(null==n||null==t)return n===t;n instanceof h&&(n=n._wrapped),t instanceof h&&(t=t._wrapped);var u=l.call(n);if(u!==l.call(t))return!1;switch(u){case"[object RegExp]":case"[object String]":return""+n==""+t;case"[object Number]":return+n!==+n?+t!==+t:0===+n?1/+n===1/t:+n===+t;case"[object Date]":case"[object Boolean]":return+n===+t}if("object"!=typeof n||"object"!=typeof t)return!1;for(var i=r.length;i--;)if(r[i]===n)return e[i]===t;var a=n.constructor,o=t.constructor;if(a!==o&&"constructor"in n&&"constructor"in t&&!(h.isFunction(a)&&a instanceof a&&h.isFunction(o)&&o instanceof o))return!1;r.push(n),e.push(t);var c,f;if("[object Array]"===u){if(c=n.length,f=c===t.length)for(;c--&&(f=b(n[c],t[c],r,e)););}else{var s,p=h.keys(n);if(c=p.length,f=h.keys(t).length===c)for(;c--&&(s=p[c],f=h.has(t,s)&&b(n[s],t[s],r,e)););}return r.pop(),e.pop(),f};h.isEqual=function(n,t){return b(n,t,[],[])},h.isEmpty=function(n){if(null==n)return!0;if(h.isArray(n)||h.isString(n)||h.isArguments(n))return 0===n.length;for(var t in n)if(h.has(n,t))return!1;return!0},h.isElement=function(n){return!(!n||1!==n.nodeType)},h.isArray=f||function(n){return"[object Array]"===l.call(n)},h.isObject=function(n){var t=typeof n;return"function"===t||"object"===t&&!!n},h.each(["Arguments","Function","String","Number","Date","RegExp"],function(n){h["is"+n]=function(t){return l.call(t)==="[object "+n+"]"}}),h.isArguments(arguments)||(h.isArguments=function(n){return h.has(n,"callee")}),"function"!=typeof/./&&(h.isFunction=function(n){return"function"==typeof n||!1}),h.isFinite=function(n){return isFinite(n)&&!isNaN(parseFloat(n))},h.isNaN=function(n){return h.isNumber(n)&&n!==+n},h.isBoolean=function(n){return n===!0||n===!1||"[object Boolean]"===l.call(n)},h.isNull=function(n){return null===n},h.isUndefined=function(n){return n===void 0},h.has=function(n,t){return null!=n&&c.call(n,t)},h.noConflict=function(){return n._=t,this},h.identity=function(n){return n},h.constant=function(n){return function(){return n}},h.noop=function(){},h.property=function(n){return function(t){return t[n]}},h.matches=function(n){var t=h.pairs(n),r=t.length;return function(n){if(null==n)return!r;n=new Object(n);for(var e=0;r>e;e++){var u=t[e],i=u[0];if(u[1]!==n[i]||!(i in n))return!1}return!0}},h.times=function(n,t,r){var e=Array(Math.max(0,n));t=g(t,r,1);for(var u=0;n>u;u++)e[u]=t(u);return e},h.random=function(n,t){return null==t&&(t=n,n=0),n+Math.floor(Math.random()*(t-n+1))},h.now=Date.now||function(){return(new Date).getTime()};var _={"&":"&","<":"<",">":">",'"':""","'":"'","`":"`"},w=h.invert(_),j=function(n){var t=function(t){return n[t]},r="(?:"+h.keys(n).join("|")+")",e=RegExp(r),u=RegExp(r,"g");return function(n){return n=null==n?"":""+n,e.test(n)?n.replace(u,t):n}};h.escape=j(_),h.unescape=j(w),h.result=function(n,t){if(null==n)return void 0;var r=n[t];return h.isFunction(r)?n[t]():r};var x=0;h.uniqueId=function(n){var t=++x+"";return n?n+t:t},h.templateSettings={evaluate:/<%([\s\S]+?)%>/g,interpolate:/<%=([\s\S]+?)%>/g,escape:/<%-([\s\S]+?)%>/g};var A=/(.)^/,k={"'":"'","\\":"\\","\r":"r","\n":"n","\u2028":"u2028","\u2029":"u2029"},O=/\\|'|\r|\n|\u2028|\u2029/g,F=function(n){return"\\"+k[n]};h.template=function(n,t,r){!t&&r&&(t=r),t=h.defaults({},t,h.templateSettings);var e=RegExp([(t.escape||A).source,(t.interpolate||A).source,(t.evaluate||A).source].join("|")+"|$","g"),u=0,i="__p+='";n.replace(e,function(t,r,e,a,o){return i+=n.slice(u,o).replace(O,F),u=o+t.length,r?i+="'+\n((__t=("+r+"))==null?'':_.escape(__t))+\n'":e?i+="'+\n((__t=("+e+"))==null?'':__t)+\n'":a&&(i+="';\n"+a+"\n__p+='"),t}),i+="';\n",t.variable||(i="with(obj||{}){\n"+i+"}\n"),i="var __t,__p='',__j=Array.prototype.join,"+"print=function(){__p+=__j.call(arguments,'');};\n"+i+"return __p;\n";try{var a=new Function(t.variable||"obj","_",i)}catch(o){throw o.source=i,o}var l=function(n){return a.call(this,n,h)},c=t.variable||"obj";return l.source="function("+c+"){\n"+i+"}",l},h.chain=function(n){var t=h(n);return t._chain=!0,t};var E=function(n){return this._chain?h(n).chain():n};h.mixin=function(n){h.each(h.functions(n),function(t){var r=h[t]=n[t];h.prototype[t]=function(){var n=[this._wrapped];return i.apply(n,arguments),E.call(this,r.apply(h,n))}})},h.mixin(h),h.each(["pop","push","reverse","shift","sort","splice","unshift"],function(n){var t=r[n];h.prototype[n]=function(){var r=this._wrapped;return t.apply(r,arguments),"shift"!==n&&"splice"!==n||0!==r.length||delete r[0],E.call(this,r)}}),h.each(["concat","join","slice"],function(n){var t=r[n];h.prototype[n]=function(){return E.call(this,t.apply(this._wrapped,arguments))}}),h.prototype.value=function(){return this._wrapped},"function"==typeof define&&define.amd&&define("underscore",[],function(){return h})}).call(this);
+//# sourceMappingURL=underscore-min.map
\ No newline at end of file
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore/underscore.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore/underscore.js
new file mode 100644
index 0000000..b4f49a0
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore/underscore.js
@@ -0,0 +1,1415 @@
+// Underscore.js 1.7.0
+// http://underscorejs.org
+// (c) 2009-2014 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+// Underscore may be freely distributed under the MIT license.
+
+(function() {
+
+ // Baseline setup
+ // --------------
+
+ // Establish the root object, `window` in the browser, or `exports` on the server.
+ var root = this;
+
+ // Save the previous value of the `_` variable.
+ var previousUnderscore = root._;
+
+ // Save bytes in the minified (but not gzipped) version:
+ var ArrayProto = Array.prototype, ObjProto = Object.prototype, FuncProto = Function.prototype;
+
+ // Create quick reference variables for speed access to core prototypes.
+ var
+ push = ArrayProto.push,
+ slice = ArrayProto.slice,
+ concat = ArrayProto.concat,
+ toString = ObjProto.toString,
+ hasOwnProperty = ObjProto.hasOwnProperty;
+
+ // All **ECMAScript 5** native function implementations that we hope to use
+ // are declared here.
+ var
+ nativeIsArray = Array.isArray,
+ nativeKeys = Object.keys,
+ nativeBind = FuncProto.bind;
+
+ // Create a safe reference to the Underscore object for use below.
+ var _ = function(obj) {
+ if (obj instanceof _) return obj;
+ if (!(this instanceof _)) return new _(obj);
+ this._wrapped = obj;
+ };
+
+ // Export the Underscore object for **Node.js**, with
+ // backwards-compatibility for the old `require()` API. If we're in
+ // the browser, add `_` as a global object.
+ if (typeof exports !== 'undefined') {
+ if (typeof module !== 'undefined' && module.exports) {
+ exports = module.exports = _;
+ }
+ exports._ = _;
+ } else {
+ root._ = _;
+ }
+
+ // Current version.
+ _.VERSION = '1.7.0';
+
+ // Internal function that returns an efficient (for current engines) version
+ // of the passed-in callback, to be repeatedly applied in other Underscore
+ // functions.
+ var createCallback = function(func, context, argCount) {
+ if (context === void 0) return func;
+ switch (argCount == null ? 3 : argCount) {
+ case 1: return function(value) {
+ return func.call(context, value);
+ };
+ case 2: return function(value, other) {
+ return func.call(context, value, other);
+ };
+ case 3: return function(value, index, collection) {
+ return func.call(context, value, index, collection);
+ };
+ case 4: return function(accumulator, value, index, collection) {
+ return func.call(context, accumulator, value, index, collection);
+ };
+ }
+ return function() {
+ return func.apply(context, arguments);
+ };
+ };
+
+ // A mostly-internal function to generate callbacks that can be applied
+ // to each element in a collection, returning the desired result — either
+ // identity, an arbitrary callback, a property matcher, or a property accessor.
+ _.iteratee = function(value, context, argCount) {
+ if (value == null) return _.identity;
+ if (_.isFunction(value)) return createCallback(value, context, argCount);
+ if (_.isObject(value)) return _.matches(value);
+ return _.property(value);
+ };
+
+ // Collection Functions
+ // --------------------
+
+ // The cornerstone, an `each` implementation, aka `forEach`.
+ // Handles raw objects in addition to array-likes. Treats all
+ // sparse array-likes as if they were dense.
+ _.each = _.forEach = function(obj, iteratee, context) {
+ if (obj == null) return obj;
+ iteratee = createCallback(iteratee, context);
+ var i, length = obj.length;
+ if (length === +length) {
+ for (i = 0; i < length; i++) {
+ iteratee(obj[i], i, obj);
+ }
+ } else {
+ var keys = _.keys(obj);
+ for (i = 0, length = keys.length; i < length; i++) {
+ iteratee(obj[keys[i]], keys[i], obj);
+ }
+ }
+ return obj;
+ };
+
+ // Return the results of applying the iteratee to each element.
+ _.map = _.collect = function(obj, iteratee, context) {
+ if (obj == null) return [];
+ iteratee = _.iteratee(iteratee, context);
+ var keys = obj.length !== +obj.length && _.keys(obj),
+ length = (keys || obj).length,
+ results = Array(length),
+ currentKey;
+ for (var index = 0; index < length; index++) {
+ currentKey = keys ? keys[index] : index;
+ results[index] = iteratee(obj[currentKey], currentKey, obj);
+ }
+ return results;
+ };
+
+ var reduceError = 'Reduce of empty array with no initial value';
+
+ // **Reduce** builds up a single result from a list of values, aka `inject`,
+ // or `foldl`.
+ _.reduce = _.foldl = _.inject = function(obj, iteratee, memo, context) {
+ if (obj == null) obj = [];
+ iteratee = createCallback(iteratee, context, 4);
+ var keys = obj.length !== +obj.length && _.keys(obj),
+ length = (keys || obj).length,
+ index = 0, currentKey;
+ if (arguments.length < 3) {
+ if (!length) throw new TypeError(reduceError);
+ memo = obj[keys ? keys[index++] : index++];
+ }
+ for (; index < length; index++) {
+ currentKey = keys ? keys[index] : index;
+ memo = iteratee(memo, obj[currentKey], currentKey, obj);
+ }
+ return memo;
+ };
+
+ // The right-associative version of reduce, also known as `foldr`.
+ _.reduceRight = _.foldr = function(obj, iteratee, memo, context) {
+ if (obj == null) obj = [];
+ iteratee = createCallback(iteratee, context, 4);
+ var keys = obj.length !== + obj.length && _.keys(obj),
+ index = (keys || obj).length,
+ currentKey;
+ if (arguments.length < 3) {
+ if (!index) throw new TypeError(reduceError);
+ memo = obj[keys ? keys[--index] : --index];
+ }
+ while (index--) {
+ currentKey = keys ? keys[index] : index;
+ memo = iteratee(memo, obj[currentKey], currentKey, obj);
+ }
+ return memo;
+ };
+
+ // Return the first value which passes a truth test. Aliased as `detect`.
+ _.find = _.detect = function(obj, predicate, context) {
+ var result;
+ predicate = _.iteratee(predicate, context);
+ _.some(obj, function(value, index, list) {
+ if (predicate(value, index, list)) {
+ result = value;
+ return true;
+ }
+ });
+ return result;
+ };
+
+ // Return all the elements that pass a truth test.
+ // Aliased as `select`.
+ _.filter = _.select = function(obj, predicate, context) {
+ var results = [];
+ if (obj == null) return results;
+ predicate = _.iteratee(predicate, context);
+ _.each(obj, function(value, index, list) {
+ if (predicate(value, index, list)) results.push(value);
+ });
+ return results;
+ };
+
+ // Return all the elements for which a truth test fails.
+ _.reject = function(obj, predicate, context) {
+ return _.filter(obj, _.negate(_.iteratee(predicate)), context);
+ };
+
+ // Determine whether all of the elements match a truth test.
+ // Aliased as `all`.
+ _.every = _.all = function(obj, predicate, context) {
+ if (obj == null) return true;
+ predicate = _.iteratee(predicate, context);
+ var keys = obj.length !== +obj.length && _.keys(obj),
+ length = (keys || obj).length,
+ index, currentKey;
+ for (index = 0; index < length; index++) {
+ currentKey = keys ? keys[index] : index;
+ if (!predicate(obj[currentKey], currentKey, obj)) return false;
+ }
+ return true;
+ };
+
+ // Determine if at least one element in the object matches a truth test.
+ // Aliased as `any`.
+ _.some = _.any = function(obj, predicate, context) {
+ if (obj == null) return false;
+ predicate = _.iteratee(predicate, context);
+ var keys = obj.length !== +obj.length && _.keys(obj),
+ length = (keys || obj).length,
+ index, currentKey;
+ for (index = 0; index < length; index++) {
+ currentKey = keys ? keys[index] : index;
+ if (predicate(obj[currentKey], currentKey, obj)) return true;
+ }
+ return false;
+ };
+
+ // Determine if the array or object contains a given value (using `===`).
+ // Aliased as `include`.
+ _.contains = _.include = function(obj, target) {
+ if (obj == null) return false;
+ if (obj.length !== +obj.length) obj = _.values(obj);
+ return _.indexOf(obj, target) >= 0;
+ };
+
+ // Invoke a method (with arguments) on every item in a collection.
+ _.invoke = function(obj, method) {
+ var args = slice.call(arguments, 2);
+ var isFunc = _.isFunction(method);
+ return _.map(obj, function(value) {
+ return (isFunc ? method : value[method]).apply(value, args);
+ });
+ };
+
+ // Convenience version of a common use case of `map`: fetching a property.
+ _.pluck = function(obj, key) {
+ return _.map(obj, _.property(key));
+ };
+
+ // Convenience version of a common use case of `filter`: selecting only objects
+ // containing specific `key:value` pairs.
+ _.where = function(obj, attrs) {
+ return _.filter(obj, _.matches(attrs));
+ };
+
+ // Convenience version of a common use case of `find`: getting the first object
+ // containing specific `key:value` pairs.
+ _.findWhere = function(obj, attrs) {
+ return _.find(obj, _.matches(attrs));
+ };
+
+ // Return the maximum element (or element-based computation).
+ _.max = function(obj, iteratee, context) {
+ var result = -Infinity, lastComputed = -Infinity,
+ value, computed;
+ if (iteratee == null && obj != null) {
+ obj = obj.length === +obj.length ? obj : _.values(obj);
+ for (var i = 0, length = obj.length; i < length; i++) {
+ value = obj[i];
+ if (value > result) {
+ result = value;
+ }
+ }
+ } else {
+ iteratee = _.iteratee(iteratee, context);
+ _.each(obj, function(value, index, list) {
+ computed = iteratee(value, index, list);
+ if (computed > lastComputed || computed === -Infinity && result === -Infinity) {
+ result = value;
+ lastComputed = computed;
+ }
+ });
+ }
+ return result;
+ };
+
+ // Return the minimum element (or element-based computation).
+ _.min = function(obj, iteratee, context) {
+ var result = Infinity, lastComputed = Infinity,
+ value, computed;
+ if (iteratee == null && obj != null) {
+ obj = obj.length === +obj.length ? obj : _.values(obj);
+ for (var i = 0, length = obj.length; i < length; i++) {
+ value = obj[i];
+ if (value < result) {
+ result = value;
+ }
+ }
+ } else {
+ iteratee = _.iteratee(iteratee, context);
+ _.each(obj, function(value, index, list) {
+ computed = iteratee(value, index, list);
+ if (computed < lastComputed || computed === Infinity && result === Infinity) {
+ result = value;
+ lastComputed = computed;
+ }
+ });
+ }
+ return result;
+ };
+
+ // Shuffle a collection, using the modern version of the
+ // [Fisher-Yates shuffle](http://en.wikipedia.org/wiki/Fisher–Yates_shuffle).
+ _.shuffle = function(obj) {
+ var set = obj && obj.length === +obj.length ? obj : _.values(obj);
+ var length = set.length;
+ var shuffled = Array(length);
+ for (var index = 0, rand; index < length; index++) {
+ rand = _.random(0, index);
+ if (rand !== index) shuffled[index] = shuffled[rand];
+ shuffled[rand] = set[index];
+ }
+ return shuffled;
+ };
+
+ // Sample **n** random values from a collection.
+ // If **n** is not specified, returns a single random element.
+ // The internal `guard` argument allows it to work with `map`.
+ _.sample = function(obj, n, guard) {
+ if (n == null || guard) {
+ if (obj.length !== +obj.length) obj = _.values(obj);
+ return obj[_.random(obj.length - 1)];
+ }
+ return _.shuffle(obj).slice(0, Math.max(0, n));
+ };
+
+ // Sort the object's values by a criterion produced by an iteratee.
+ _.sortBy = function(obj, iteratee, context) {
+ iteratee = _.iteratee(iteratee, context);
+ return _.pluck(_.map(obj, function(value, index, list) {
+ return {
+ value: value,
+ index: index,
+ criteria: iteratee(value, index, list)
+ };
+ }).sort(function(left, right) {
+ var a = left.criteria;
+ var b = right.criteria;
+ if (a !== b) {
+ if (a > b || a === void 0) return 1;
+ if (a < b || b === void 0) return -1;
+ }
+ return left.index - right.index;
+ }), 'value');
+ };
+
+ // An internal function used for aggregate "group by" operations.
+ var group = function(behavior) {
+ return function(obj, iteratee, context) {
+ var result = {};
+ iteratee = _.iteratee(iteratee, context);
+ _.each(obj, function(value, index) {
+ var key = iteratee(value, index, obj);
+ behavior(result, value, key);
+ });
+ return result;
+ };
+ };
+
+ // Groups the object's values by a criterion. Pass either a string attribute
+ // to group by, or a function that returns the criterion.
+ _.groupBy = group(function(result, value, key) {
+ if (_.has(result, key)) result[key].push(value); else result[key] = [value];
+ });
+
+ // Indexes the object's values by a criterion, similar to `groupBy`, but for
+ // when you know that your index values will be unique.
+ _.indexBy = group(function(result, value, key) {
+ result[key] = value;
+ });
+
+ // Counts instances of an object that group by a certain criterion. Pass
+ // either a string attribute to count by, or a function that returns the
+ // criterion.
+ _.countBy = group(function(result, value, key) {
+ if (_.has(result, key)) result[key]++; else result[key] = 1;
+ });
+
+ // Use a comparator function to figure out the smallest index at which
+ // an object should be inserted so as to maintain order. Uses binary search.
+ _.sortedIndex = function(array, obj, iteratee, context) {
+ iteratee = _.iteratee(iteratee, context, 1);
+ var value = iteratee(obj);
+ var low = 0, high = array.length;
+ while (low < high) {
+ var mid = low + high >>> 1;
+ if (iteratee(array[mid]) < value) low = mid + 1; else high = mid;
+ }
+ return low;
+ };
+
+ // Safely create a real, live array from anything iterable.
+ _.toArray = function(obj) {
+ if (!obj) return [];
+ if (_.isArray(obj)) return slice.call(obj);
+ if (obj.length === +obj.length) return _.map(obj, _.identity);
+ return _.values(obj);
+ };
+
+ // Return the number of elements in an object.
+ _.size = function(obj) {
+ if (obj == null) return 0;
+ return obj.length === +obj.length ? obj.length : _.keys(obj).length;
+ };
+
+ // Split a collection into two arrays: one whose elements all satisfy the given
+ // predicate, and one whose elements all do not satisfy the predicate.
+ _.partition = function(obj, predicate, context) {
+ predicate = _.iteratee(predicate, context);
+ var pass = [], fail = [];
+ _.each(obj, function(value, key, obj) {
+ (predicate(value, key, obj) ? pass : fail).push(value);
+ });
+ return [pass, fail];
+ };
+
+ // Array Functions
+ // ---------------
+
+ // Get the first element of an array. Passing **n** will return the first N
+ // values in the array. Aliased as `head` and `take`. The **guard** check
+ // allows it to work with `_.map`.
+ _.first = _.head = _.take = function(array, n, guard) {
+ if (array == null) return void 0;
+ if (n == null || guard) return array[0];
+ if (n < 0) return [];
+ return slice.call(array, 0, n);
+ };
+
+ // Returns everything but the last entry of the array. Especially useful on
+ // the arguments object. Passing **n** will return all the values in
+ // the array, excluding the last N. The **guard** check allows it to work with
+ // `_.map`.
+ _.initial = function(array, n, guard) {
+ return slice.call(array, 0, Math.max(0, array.length - (n == null || guard ? 1 : n)));
+ };
+
+ // Get the last element of an array. Passing **n** will return the last N
+ // values in the array. The **guard** check allows it to work with `_.map`.
+ _.last = function(array, n, guard) {
+ if (array == null) return void 0;
+ if (n == null || guard) return array[array.length - 1];
+ return slice.call(array, Math.max(array.length - n, 0));
+ };
+
+ // Returns everything but the first entry of the array. Aliased as `tail` and `drop`.
+ // Especially useful on the arguments object. Passing an **n** will return
+ // the rest N values in the array. The **guard**
+ // check allows it to work with `_.map`.
+ _.rest = _.tail = _.drop = function(array, n, guard) {
+ return slice.call(array, n == null || guard ? 1 : n);
+ };
+
+ // Trim out all falsy values from an array.
+ _.compact = function(array) {
+ return _.filter(array, _.identity);
+ };
+
+ // Internal implementation of a recursive `flatten` function.
+ var flatten = function(input, shallow, strict, output) {
+ if (shallow && _.every(input, _.isArray)) {
+ return concat.apply(output, input);
+ }
+ for (var i = 0, length = input.length; i < length; i++) {
+ var value = input[i];
+ if (!_.isArray(value) && !_.isArguments(value)) {
+ if (!strict) output.push(value);
+ } else if (shallow) {
+ push.apply(output, value);
+ } else {
+ flatten(value, shallow, strict, output);
+ }
+ }
+ return output;
+ };
+
+ // Flatten out an array, either recursively (by default), or just one level.
+ _.flatten = function(array, shallow) {
+ return flatten(array, shallow, false, []);
+ };
+
+ // Return a version of the array that does not contain the specified value(s).
+ _.without = function(array) {
+ return _.difference(array, slice.call(arguments, 1));
+ };
+
+ // Produce a duplicate-free version of the array. If the array has already
+ // been sorted, you have the option of using a faster algorithm.
+ // Aliased as `unique`.
+ _.uniq = _.unique = function(array, isSorted, iteratee, context) {
+ if (array == null) return [];
+ if (!_.isBoolean(isSorted)) {
+ context = iteratee;
+ iteratee = isSorted;
+ isSorted = false;
+ }
+ if (iteratee != null) iteratee = _.iteratee(iteratee, context);
+ var result = [];
+ var seen = [];
+ for (var i = 0, length = array.length; i < length; i++) {
+ var value = array[i];
+ if (isSorted) {
+ if (!i || seen !== value) result.push(value);
+ seen = value;
+ } else if (iteratee) {
+ var computed = iteratee(value, i, array);
+ if (_.indexOf(seen, computed) < 0) {
+ seen.push(computed);
+ result.push(value);
+ }
+ } else if (_.indexOf(result, value) < 0) {
+ result.push(value);
+ }
+ }
+ return result;
+ };
+
+ // Produce an array that contains the union: each distinct element from all of
+ // the passed-in arrays.
+ _.union = function() {
+ return _.uniq(flatten(arguments, true, true, []));
+ };
+
+ // Produce an array that contains every item shared between all the
+ // passed-in arrays.
+ _.intersection = function(array) {
+ if (array == null) return [];
+ var result = [];
+ var argsLength = arguments.length;
+ for (var i = 0, length = array.length; i < length; i++) {
+ var item = array[i];
+ if (_.contains(result, item)) continue;
+ for (var j = 1; j < argsLength; j++) {
+ if (!_.contains(arguments[j], item)) break;
+ }
+ if (j === argsLength) result.push(item);
+ }
+ return result;
+ };
+
+ // Take the difference between one array and a number of other arrays.
+ // Only the elements present in just the first array will remain.
+ _.difference = function(array) {
+ var rest = flatten(slice.call(arguments, 1), true, true, []);
+ return _.filter(array, function(value){
+ return !_.contains(rest, value);
+ });
+ };
+
+ // Zip together multiple lists into a single array -- elements that share
+ // an index go together.
+ _.zip = function(array) {
+ if (array == null) return [];
+ var length = _.max(arguments, 'length').length;
+ var results = Array(length);
+ for (var i = 0; i < length; i++) {
+ results[i] = _.pluck(arguments, i);
+ }
+ return results;
+ };
+
+ // Converts lists into objects. Pass either a single array of `[key, value]`
+ // pairs, or two parallel arrays of the same length -- one of keys, and one of
+ // the corresponding values.
+ _.object = function(list, values) {
+ if (list == null) return {};
+ var result = {};
+ for (var i = 0, length = list.length; i < length; i++) {
+ if (values) {
+ result[list[i]] = values[i];
+ } else {
+ result[list[i][0]] = list[i][1];
+ }
+ }
+ return result;
+ };
+
+ // Return the position of the first occurrence of an item in an array,
+ // or -1 if the item is not included in the array.
+ // If the array is large and already in sort order, pass `true`
+ // for **isSorted** to use binary search.
+ _.indexOf = function(array, item, isSorted) {
+ if (array == null) return -1;
+ var i = 0, length = array.length;
+ if (isSorted) {
+ if (typeof isSorted == 'number') {
+ i = isSorted < 0 ? Math.max(0, length + isSorted) : isSorted;
+ } else {
+ i = _.sortedIndex(array, item);
+ return array[i] === item ? i : -1;
+ }
+ }
+ for (; i < length; i++) if (array[i] === item) return i;
+ return -1;
+ };
+
+ _.lastIndexOf = function(array, item, from) {
+ if (array == null) return -1;
+ var idx = array.length;
+ if (typeof from == 'number') {
+ idx = from < 0 ? idx + from + 1 : Math.min(idx, from + 1);
+ }
+ while (--idx >= 0) if (array[idx] === item) return idx;
+ return -1;
+ };
+
+ // Generate an integer Array containing an arithmetic progression. A port of
+ // the native Python `range()` function. See
+ // [the Python documentation](http://docs.python.org/library/functions.html#range).
+ _.range = function(start, stop, step) {
+ if (arguments.length <= 1) {
+ stop = start || 0;
+ start = 0;
+ }
+ step = step || 1;
+
+ var length = Math.max(Math.ceil((stop - start) / step), 0);
+ var range = Array(length);
+
+ for (var idx = 0; idx < length; idx++, start += step) {
+ range[idx] = start;
+ }
+
+ return range;
+ };
+
+ // Function (ahem) Functions
+ // ------------------
+
+ // Reusable constructor function for prototype setting.
+ var Ctor = function(){};
+
+ // Create a function bound to a given object (assigning `this`, and arguments,
+ // optionally). Delegates to **ECMAScript 5**'s native `Function.bind` if
+ // available.
+ _.bind = function(func, context) {
+ var args, bound;
+ if (nativeBind && func.bind === nativeBind) return nativeBind.apply(func, slice.call(arguments, 1));
+ if (!_.isFunction(func)) throw new TypeError('Bind must be called on a function');
+ args = slice.call(arguments, 2);
+ bound = function() {
+ if (!(this instanceof bound)) return func.apply(context, args.concat(slice.call(arguments)));
+ Ctor.prototype = func.prototype;
+ var self = new Ctor;
+ Ctor.prototype = null;
+ var result = func.apply(self, args.concat(slice.call(arguments)));
+ if (_.isObject(result)) return result;
+ return self;
+ };
+ return bound;
+ };
+
+ // Partially apply a function by creating a version that has had some of its
+ // arguments pre-filled, without changing its dynamic `this` context. _ acts
+ // as a placeholder, allowing any combination of arguments to be pre-filled.
+ _.partial = function(func) {
+ var boundArgs = slice.call(arguments, 1);
+ return function() {
+ var position = 0;
+ var args = boundArgs.slice();
+ for (var i = 0, length = args.length; i < length; i++) {
+ if (args[i] === _) args[i] = arguments[position++];
+ }
+ while (position < arguments.length) args.push(arguments[position++]);
+ return func.apply(this, args);
+ };
+ };
+
+ // Bind a number of an object's methods to that object. Remaining arguments
+ // are the method names to be bound. Useful for ensuring that all callbacks
+ // defined on an object belong to it.
+ _.bindAll = function(obj) {
+ var i, length = arguments.length, key;
+ if (length <= 1) throw new Error('bindAll must be passed function names');
+ for (i = 1; i < length; i++) {
+ key = arguments[i];
+ obj[key] = _.bind(obj[key], obj);
+ }
+ return obj;
+ };
+
+ // Memoize an expensive function by storing its results.
+ _.memoize = function(func, hasher) {
+ var memoize = function(key) {
+ var cache = memoize.cache;
+ var address = hasher ? hasher.apply(this, arguments) : key;
+ if (!_.has(cache, address)) cache[address] = func.apply(this, arguments);
+ return cache[address];
+ };
+ memoize.cache = {};
+ return memoize;
+ };
+
+ // Delays a function for the given number of milliseconds, and then calls
+ // it with the arguments supplied.
+ _.delay = function(func, wait) {
+ var args = slice.call(arguments, 2);
+ return setTimeout(function(){
+ return func.apply(null, args);
+ }, wait);
+ };
+
+ // Defers a function, scheduling it to run after the current call stack has
+ // cleared.
+ _.defer = function(func) {
+ return _.delay.apply(_, [func, 1].concat(slice.call(arguments, 1)));
+ };
+
+ // Returns a function, that, when invoked, will only be triggered at most once
+ // during a given window of time. Normally, the throttled function will run
+ // as much as it can, without ever going more than once per `wait` duration;
+ // but if you'd like to disable the execution on the leading edge, pass
+ // `{leading: false}`. To disable execution on the trailing edge, ditto.
+ _.throttle = function(func, wait, options) {
+ var context, args, result;
+ var timeout = null;
+ var previous = 0;
+ if (!options) options = {};
+ var later = function() {
+ previous = options.leading === false ? 0 : _.now();
+ timeout = null;
+ result = func.apply(context, args);
+ if (!timeout) context = args = null;
+ };
+ return function() {
+ var now = _.now();
+ if (!previous && options.leading === false) previous = now;
+ var remaining = wait - (now - previous);
+ context = this;
+ args = arguments;
+ if (remaining <= 0 || remaining > wait) {
+ clearTimeout(timeout);
+ timeout = null;
+ previous = now;
+ result = func.apply(context, args);
+ if (!timeout) context = args = null;
+ } else if (!timeout && options.trailing !== false) {
+ timeout = setTimeout(later, remaining);
+ }
+ return result;
+ };
+ };
+
+ // Returns a function, that, as long as it continues to be invoked, will not
+ // be triggered. The function will be called after it stops being called for
+ // N milliseconds. If `immediate` is passed, trigger the function on the
+ // leading edge, instead of the trailing.
+ _.debounce = function(func, wait, immediate) {
+ var timeout, args, context, timestamp, result;
+
+ var later = function() {
+ var last = _.now() - timestamp;
+
+ if (last < wait && last > 0) {
+ timeout = setTimeout(later, wait - last);
+ } else {
+ timeout = null;
+ if (!immediate) {
+ result = func.apply(context, args);
+ if (!timeout) context = args = null;
+ }
+ }
+ };
+
+ return function() {
+ context = this;
+ args = arguments;
+ timestamp = _.now();
+ var callNow = immediate && !timeout;
+ if (!timeout) timeout = setTimeout(later, wait);
+ if (callNow) {
+ result = func.apply(context, args);
+ context = args = null;
+ }
+
+ return result;
+ };
+ };
+
+ // Returns the first function passed as an argument to the second,
+ // allowing you to adjust arguments, run code before and after, and
+ // conditionally execute the original function.
+ _.wrap = function(func, wrapper) {
+ return _.partial(wrapper, func);
+ };
+
+ // Returns a negated version of the passed-in predicate.
+ _.negate = function(predicate) {
+ return function() {
+ return !predicate.apply(this, arguments);
+ };
+ };
+
+ // Returns a function that is the composition of a list of functions, each
+ // consuming the return value of the function that follows.
+ _.compose = function() {
+ var args = arguments;
+ var start = args.length - 1;
+ return function() {
+ var i = start;
+ var result = args[start].apply(this, arguments);
+ while (i--) result = args[i].call(this, result);
+ return result;
+ };
+ };
+
+ // Returns a function that will only be executed after being called N times.
+ _.after = function(times, func) {
+ return function() {
+ if (--times < 1) {
+ return func.apply(this, arguments);
+ }
+ };
+ };
+
+ // Returns a function that will only be executed before being called N times.
+ _.before = function(times, func) {
+ var memo;
+ return function() {
+ if (--times > 0) {
+ memo = func.apply(this, arguments);
+ } else {
+ func = null;
+ }
+ return memo;
+ };
+ };
+
+ // Returns a function that will be executed at most one time, no matter how
+ // often you call it. Useful for lazy initialization.
+ _.once = _.partial(_.before, 2);
+
+ // Object Functions
+ // ----------------
+
+ // Retrieve the names of an object's properties.
+ // Delegates to **ECMAScript 5**'s native `Object.keys`
+ _.keys = function(obj) {
+ if (!_.isObject(obj)) return [];
+ if (nativeKeys) return nativeKeys(obj);
+ var keys = [];
+ for (var key in obj) if (_.has(obj, key)) keys.push(key);
+ return keys;
+ };
+
+ // Retrieve the values of an object's properties.
+ _.values = function(obj) {
+ var keys = _.keys(obj);
+ var length = keys.length;
+ var values = Array(length);
+ for (var i = 0; i < length; i++) {
+ values[i] = obj[keys[i]];
+ }
+ return values;
+ };
+
+ // Convert an object into a list of `[key, value]` pairs.
+ _.pairs = function(obj) {
+ var keys = _.keys(obj);
+ var length = keys.length;
+ var pairs = Array(length);
+ for (var i = 0; i < length; i++) {
+ pairs[i] = [keys[i], obj[keys[i]]];
+ }
+ return pairs;
+ };
+
+ // Invert the keys and values of an object. The values must be serializable.
+ _.invert = function(obj) {
+ var result = {};
+ var keys = _.keys(obj);
+ for (var i = 0, length = keys.length; i < length; i++) {
+ result[obj[keys[i]]] = keys[i];
+ }
+ return result;
+ };
+
+ // Return a sorted list of the function names available on the object.
+ // Aliased as `methods`
+ _.functions = _.methods = function(obj) {
+ var names = [];
+ for (var key in obj) {
+ if (_.isFunction(obj[key])) names.push(key);
+ }
+ return names.sort();
+ };
+
+ // Extend a given object with all the properties in passed-in object(s).
+ _.extend = function(obj) {
+ if (!_.isObject(obj)) return obj;
+ var source, prop;
+ for (var i = 1, length = arguments.length; i < length; i++) {
+ source = arguments[i];
+ for (prop in source) {
+ if (hasOwnProperty.call(source, prop)) {
+ obj[prop] = source[prop];
+ }
+ }
+ }
+ return obj;
+ };
+
+ // Return a copy of the object only containing the whitelisted properties.
+ _.pick = function(obj, iteratee, context) {
+ var result = {}, key;
+ if (obj == null) return result;
+ if (_.isFunction(iteratee)) {
+ iteratee = createCallback(iteratee, context);
+ for (key in obj) {
+ var value = obj[key];
+ if (iteratee(value, key, obj)) result[key] = value;
+ }
+ } else {
+ var keys = concat.apply([], slice.call(arguments, 1));
+ obj = new Object(obj);
+ for (var i = 0, length = keys.length; i < length; i++) {
+ key = keys[i];
+ if (key in obj) result[key] = obj[key];
+ }
+ }
+ return result;
+ };
+
+ // Return a copy of the object without the blacklisted properties.
+ _.omit = function(obj, iteratee, context) {
+ if (_.isFunction(iteratee)) {
+ iteratee = _.negate(iteratee);
+ } else {
+ var keys = _.map(concat.apply([], slice.call(arguments, 1)), String);
+ iteratee = function(value, key) {
+ return !_.contains(keys, key);
+ };
+ }
+ return _.pick(obj, iteratee, context);
+ };
+
+ // Fill in a given object with default properties.
+ _.defaults = function(obj) {
+ if (!_.isObject(obj)) return obj;
+ for (var i = 1, length = arguments.length; i < length; i++) {
+ var source = arguments[i];
+ for (var prop in source) {
+ if (obj[prop] === void 0) obj[prop] = source[prop];
+ }
+ }
+ return obj;
+ };
+
+ // Create a (shallow-cloned) duplicate of an object.
+ _.clone = function(obj) {
+ if (!_.isObject(obj)) return obj;
+ return _.isArray(obj) ? obj.slice() : _.extend({}, obj);
+ };
+
+ // Invokes interceptor with the obj, and then returns obj.
+ // The primary purpose of this method is to "tap into" a method chain, in
+ // order to perform operations on intermediate results within the chain.
+ _.tap = function(obj, interceptor) {
+ interceptor(obj);
+ return obj;
+ };
+
+ // Internal recursive comparison function for `isEqual`.
+ var eq = function(a, b, aStack, bStack) {
+ // Identical objects are equal. `0 === -0`, but they aren't identical.
+ // See the [Harmony `egal` proposal](http://wiki.ecmascript.org/doku.php?id=harmony:egal).
+ if (a === b) return a !== 0 || 1 / a === 1 / b;
+ // A strict comparison is necessary because `null == undefined`.
+ if (a == null || b == null) return a === b;
+ // Unwrap any wrapped objects.
+ if (a instanceof _) a = a._wrapped;
+ if (b instanceof _) b = b._wrapped;
+ // Compare `[[Class]]` names.
+ var className = toString.call(a);
+ if (className !== toString.call(b)) return false;
+ switch (className) {
+ // Strings, numbers, regular expressions, dates, and booleans are compared by value.
+ case '[object RegExp]':
+ // RegExps are coerced to strings for comparison (Note: '' + /a/i === '/a/i')
+ case '[object String]':
+ // Primitives and their corresponding object wrappers are equivalent; thus, `"5"` is
+ // equivalent to `new String("5")`.
+ return '' + a === '' + b;
+ case '[object Number]':
+ // `NaN`s are equivalent, but non-reflexive.
+ // Object(NaN) is equivalent to NaN
+ if (+a !== +a) return +b !== +b;
+ // An `egal` comparison is performed for other numeric values.
+ return +a === 0 ? 1 / +a === 1 / b : +a === +b;
+ case '[object Date]':
+ case '[object Boolean]':
+ // Coerce dates and booleans to numeric primitive values. Dates are compared by their
+ // millisecond representations. Note that invalid dates with millisecond representations
+ // of `NaN` are not equivalent.
+ return +a === +b;
+ }
+ if (typeof a != 'object' || typeof b != 'object') return false;
+ // Assume equality for cyclic structures. The algorithm for detecting cyclic
+ // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.
+ var length = aStack.length;
+ while (length--) {
+ // Linear search. Performance is inversely proportional to the number of
+ // unique nested structures.
+ if (aStack[length] === a) return bStack[length] === b;
+ }
+ // Objects with different constructors are not equivalent, but `Object`s
+ // from different frames are.
+ var aCtor = a.constructor, bCtor = b.constructor;
+ if (
+ aCtor !== bCtor &&
+ // Handle Object.create(x) cases
+ 'constructor' in a && 'constructor' in b &&
+ !(_.isFunction(aCtor) && aCtor instanceof aCtor &&
+ _.isFunction(bCtor) && bCtor instanceof bCtor)
+ ) {
+ return false;
+ }
+ // Add the first object to the stack of traversed objects.
+ aStack.push(a);
+ bStack.push(b);
+ var size, result;
+ // Recursively compare objects and arrays.
+ if (className === '[object Array]') {
+ // Compare array lengths to determine if a deep comparison is necessary.
+ size = a.length;
+ result = size === b.length;
+ if (result) {
+ // Deep compare the contents, ignoring non-numeric properties.
+ while (size--) {
+ if (!(result = eq(a[size], b[size], aStack, bStack))) break;
+ }
+ }
+ } else {
+ // Deep compare objects.
+ var keys = _.keys(a), key;
+ size = keys.length;
+ // Ensure that both objects contain the same number of properties before comparing deep equality.
+ result = _.keys(b).length === size;
+ if (result) {
+ while (size--) {
+ // Deep compare each member
+ key = keys[size];
+ if (!(result = _.has(b, key) && eq(a[key], b[key], aStack, bStack))) break;
+ }
+ }
+ }
+ // Remove the first object from the stack of traversed objects.
+ aStack.pop();
+ bStack.pop();
+ return result;
+ };
+
+ // Perform a deep comparison to check if two objects are equal.
+ _.isEqual = function(a, b) {
+ return eq(a, b, [], []);
+ };
+
+ // Is a given array, string, or object empty?
+ // An "empty" object has no enumerable own-properties.
+ _.isEmpty = function(obj) {
+ if (obj == null) return true;
+ if (_.isArray(obj) || _.isString(obj) || _.isArguments(obj)) return obj.length === 0;
+ for (var key in obj) if (_.has(obj, key)) return false;
+ return true;
+ };
+
+ // Is a given value a DOM element?
+ _.isElement = function(obj) {
+ return !!(obj && obj.nodeType === 1);
+ };
+
+ // Is a given value an array?
+ // Delegates to ECMA5's native Array.isArray
+ _.isArray = nativeIsArray || function(obj) {
+ return toString.call(obj) === '[object Array]';
+ };
+
+ // Is a given variable an object?
+ _.isObject = function(obj) {
+ var type = typeof obj;
+ return type === 'function' || type === 'object' && !!obj;
+ };
+
+ // Add some isType methods: isArguments, isFunction, isString, isNumber, isDate, isRegExp.
+ _.each(['Arguments', 'Function', 'String', 'Number', 'Date', 'RegExp'], function(name) {
+ _['is' + name] = function(obj) {
+ return toString.call(obj) === '[object ' + name + ']';
+ };
+ });
+
+ // Define a fallback version of the method in browsers (ahem, IE), where
+ // there isn't any inspectable "Arguments" type.
+ if (!_.isArguments(arguments)) {
+ _.isArguments = function(obj) {
+ return _.has(obj, 'callee');
+ };
+ }
+
+ // Optimize `isFunction` if appropriate. Work around an IE 11 bug.
+ if (typeof /./ !== 'function') {
+ _.isFunction = function(obj) {
+ return typeof obj == 'function' || false;
+ };
+ }
+
+ // Is a given object a finite number?
+ _.isFinite = function(obj) {
+ return isFinite(obj) && !isNaN(parseFloat(obj));
+ };
+
+ // Is the given value `NaN`? (NaN is the only number which does not equal itself).
+ _.isNaN = function(obj) {
+ return _.isNumber(obj) && obj !== +obj;
+ };
+
+ // Is a given value a boolean?
+ _.isBoolean = function(obj) {
+ return obj === true || obj === false || toString.call(obj) === '[object Boolean]';
+ };
+
+ // Is a given value equal to null?
+ _.isNull = function(obj) {
+ return obj === null;
+ };
+
+ // Is a given variable undefined?
+ _.isUndefined = function(obj) {
+ return obj === void 0;
+ };
+
+ // Shortcut function for checking if an object has a given property directly
+ // on itself (in other words, not on a prototype).
+ _.has = function(obj, key) {
+ return obj != null && hasOwnProperty.call(obj, key);
+ };
+
+ // Utility Functions
+ // -----------------
+
+ // Run Underscore.js in *noConflict* mode, returning the `_` variable to its
+ // previous owner. Returns a reference to the Underscore object.
+ _.noConflict = function() {
+ root._ = previousUnderscore;
+ return this;
+ };
+
+ // Keep the identity function around for default iteratees.
+ _.identity = function(value) {
+ return value;
+ };
+
+ _.constant = function(value) {
+ return function() {
+ return value;
+ };
+ };
+
+ _.noop = function(){};
+
+ _.property = function(key) {
+ return function(obj) {
+ return obj[key];
+ };
+ };
+
+ // Returns a predicate for checking whether an object has a given set of `key:value` pairs.
+ _.matches = function(attrs) {
+ var pairs = _.pairs(attrs), length = pairs.length;
+ return function(obj) {
+ if (obj == null) return !length;
+ obj = new Object(obj);
+ for (var i = 0; i < length; i++) {
+ var pair = pairs[i], key = pair[0];
+ if (pair[1] !== obj[key] || !(key in obj)) return false;
+ }
+ return true;
+ };
+ };
+
+ // Run a function **n** times.
+ _.times = function(n, iteratee, context) {
+ var accum = Array(Math.max(0, n));
+ iteratee = createCallback(iteratee, context, 1);
+ for (var i = 0; i < n; i++) accum[i] = iteratee(i);
+ return accum;
+ };
+
+ // Return a random integer between min and max (inclusive).
+ _.random = function(min, max) {
+ if (max == null) {
+ max = min;
+ min = 0;
+ }
+ return min + Math.floor(Math.random() * (max - min + 1));
+ };
+
+ // A (possibly faster) way to get the current timestamp as an integer.
+ _.now = Date.now || function() {
+ return new Date().getTime();
+ };
+
+ // List of HTML entities for escaping.
+ var escapeMap = {
+ '&': '&',
+ '<': '<',
+ '>': '>',
+ '"': '"',
+ "'": ''',
+ '`': '`'
+ };
+ var unescapeMap = _.invert(escapeMap);
+
+ // Functions for escaping and unescaping strings to/from HTML interpolation.
+ var createEscaper = function(map) {
+ var escaper = function(match) {
+ return map[match];
+ };
+ // Regexes for identifying a key that needs to be escaped
+ var source = '(?:' + _.keys(map).join('|') + ')';
+ var testRegexp = RegExp(source);
+ var replaceRegexp = RegExp(source, 'g');
+ return function(string) {
+ string = string == null ? '' : '' + string;
+ return testRegexp.test(string) ? string.replace(replaceRegexp, escaper) : string;
+ };
+ };
+ _.escape = createEscaper(escapeMap);
+ _.unescape = createEscaper(unescapeMap);
+
+ // If the value of the named `property` is a function then invoke it with the
+ // `object` as context; otherwise, return it.
+ _.result = function(object, property) {
+ if (object == null) return void 0;
+ var value = object[property];
+ return _.isFunction(value) ? object[property]() : value;
+ };
+
+ // Generate a unique integer id (unique within the entire client session).
+ // Useful for temporary DOM ids.
+ var idCounter = 0;
+ _.uniqueId = function(prefix) {
+ var id = ++idCounter + '';
+ return prefix ? prefix + id : id;
+ };
+
+ // By default, Underscore uses ERB-style template delimiters, change the
+ // following template settings to use alternative delimiters.
+ _.templateSettings = {
+ evaluate : /<%([\s\S]+?)%>/g,
+ interpolate : /<%=([\s\S]+?)%>/g,
+ escape : /<%-([\s\S]+?)%>/g
+ };
+
+ // When customizing `templateSettings`, if you don't want to define an
+ // interpolation, evaluation or escaping regex, we need one that is
+ // guaranteed not to match.
+ var noMatch = /(.)^/;
+
+ // Certain characters need to be escaped so that they can be put into a
+ // string literal.
+ var escapes = {
+ "'": "'",
+ '\\': '\\',
+ '\r': 'r',
+ '\n': 'n',
+ '\u2028': 'u2028',
+ '\u2029': 'u2029'
+ };
+
+ var escaper = /\\|'|\r|\n|\u2028|\u2029/g;
+
+ var escapeChar = function(match) {
+ return '\\' + escapes[match];
+ };
+
+ // JavaScript micro-templating, similar to John Resig's implementation.
+ // Underscore templating handles arbitrary delimiters, preserves whitespace,
+ // and correctly escapes quotes within interpolated code.
+ // NB: `oldSettings` only exists for backwards compatibility.
+ _.template = function(text, settings, oldSettings) {
+ if (!settings && oldSettings) settings = oldSettings;
+ settings = _.defaults({}, settings, _.templateSettings);
+
+ // Combine delimiters into one regular expression via alternation.
+ var matcher = RegExp([
+ (settings.escape || noMatch).source,
+ (settings.interpolate || noMatch).source,
+ (settings.evaluate || noMatch).source
+ ].join('|') + '|$', 'g');
+
+ // Compile the template source, escaping string literals appropriately.
+ var index = 0;
+ var source = "__p+='";
+ text.replace(matcher, function(match, escape, interpolate, evaluate, offset) {
+ source += text.slice(index, offset).replace(escaper, escapeChar);
+ index = offset + match.length;
+
+ if (escape) {
+ source += "'+\n((__t=(" + escape + "))==null?'':_.escape(__t))+\n'";
+ } else if (interpolate) {
+ source += "'+\n((__t=(" + interpolate + "))==null?'':__t)+\n'";
+ } else if (evaluate) {
+ source += "';\n" + evaluate + "\n__p+='";
+ }
+
+ // Adobe VMs need the match returned to produce the correct offest.
+ return match;
+ });
+ source += "';\n";
+
+ // If a variable is not specified, place data values in local scope.
+ if (!settings.variable) source = 'with(obj||{}){\n' + source + '}\n';
+
+ source = "var __t,__p='',__j=Array.prototype.join," +
+ "print=function(){__p+=__j.call(arguments,'');};\n" +
+ source + 'return __p;\n';
+
+ try {
+ var render = new Function(settings.variable || 'obj', '_', source);
+ } catch (e) {
+ e.source = source;
+ throw e;
+ }
+
+ var template = function(data) {
+ return render.call(this, data, _);
+ };
+
+ // Provide the compiled source as a convenience for precompilation.
+ var argument = settings.variable || 'obj';
+ template.source = 'function(' + argument + '){\n' + source + '}';
+
+ return template;
+ };
+
+ // Add a "chain" function. Start chaining a wrapped Underscore object.
+ _.chain = function(obj) {
+ var instance = _(obj);
+ instance._chain = true;
+ return instance;
+ };
+
+ // OOP
+ // ---------------
+ // If Underscore is called as a function, it returns a wrapped object that
+ // can be used OO-style. This wrapper holds altered versions of all the
+ // underscore functions. Wrapped objects may be chained.
+
+ // Helper function to continue chaining intermediate results.
+ var result = function(obj) {
+ return this._chain ? _(obj).chain() : obj;
+ };
+
+ // Add your own custom functions to the Underscore object.
+ _.mixin = function(obj) {
+ _.each(_.functions(obj), function(name) {
+ var func = _[name] = obj[name];
+ _.prototype[name] = function() {
+ var args = [this._wrapped];
+ push.apply(args, arguments);
+ return result.call(this, func.apply(_, args));
+ };
+ });
+ };
+
+ // Add all of the Underscore functions to the wrapper object.
+ _.mixin(_);
+
+ // Add all mutator Array functions to the wrapper.
+ _.each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) {
+ var method = ArrayProto[name];
+ _.prototype[name] = function() {
+ var obj = this._wrapped;
+ method.apply(obj, arguments);
+ if ((name === 'shift' || name === 'splice') && obj.length === 0) delete obj[0];
+ return result.call(this, obj);
+ };
+ });
+
+ // Add all accessor Array functions to the wrapper.
+ _.each(['concat', 'join', 'slice'], function(name) {
+ var method = ArrayProto[name];
+ _.prototype[name] = function() {
+ return result.call(this, method.apply(this._wrapped, arguments));
+ };
+ });
+
+ // Extracts the result from a wrapped and chained object.
+ _.prototype.value = function() {
+ return this._wrapped;
+ };
+
+ // AMD registration happens at the end for compatibility with AMD loaders
+ // that may not enforce next-turn semantics on modules. Even though general
+ // practice for AMD registration is to be anonymous, underscore registers
+ // as a named module because, like jQuery, it is a base library that is
+ // popular enough to be bundled in a third party lib, but not be part of
+ // an AMD load request. Those cases could generate an error when an
+ // anonymous define() is called outside of a loader request.
+ if (typeof define === 'function' && define.amd) {
+ define('underscore', [], function() {
+ return _;
+ });
+ }
+}.call(this));
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/package.json b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/package.json
new file mode 100644
index 0000000..a9242a2
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/package.json
@@ -0,0 +1,62 @@
+{
+ "name": "argparse",
+ "description": "Very powerful CLI arguments parser. Native port of argparse - python's options parsing library",
+ "version": "0.1.16",
+ "keywords": [
+ "cli",
+ "parser",
+ "argparse",
+ "option",
+ "args"
+ ],
+ "homepage": "https://github.com/nodeca/argparse",
+ "contributors": [
+ {
+ "name": "Eugene Shkuropat"
+ },
+ {
+ "name": "Paul Jacobson"
+ }
+ ],
+ "bugs": {
+ "url": "https://github.com/nodeca/argparse/issues"
+ },
+ "license": "MIT",
+ "repository": {
+ "type": "git",
+ "url": "git://github.com/nodeca/argparse.git"
+ },
+ "main": "./index.js",
+ "scripts": {
+ "test": "make test"
+ },
+ "dependencies": {
+ "underscore": "~1.7.0",
+ "underscore.string": "~2.4.0"
+ },
+ "devDependencies": {
+ "mocha": "*"
+ },
+ "gitHead": "9c32eb1405d5d4b5686087d95bac010774979659",
+ "_id": "argparse@0.1.16",
+ "_shasum": "cfd01e0fbba3d6caed049fbd758d40f65196f57c",
+ "_from": "argparse@~ 0.1.11",
+ "_npmVersion": "1.4.28",
+ "_npmUser": {
+ "name": "vitaly",
+ "email": "vitaly@rcdesign.ru"
+ },
+ "maintainers": [
+ {
+ "name": "vitaly",
+ "email": "vitaly@rcdesign.ru"
+ }
+ ],
+ "dist": {
+ "shasum": "cfd01e0fbba3d6caed049fbd758d40f65196f57c",
+ "tarball": "http://registry.npmjs.org/argparse/-/argparse-0.1.16.tgz"
+ },
+ "directories": {},
+ "_resolved": "https://registry.npmjs.org/argparse/-/argparse-0.1.16.tgz",
+ "readme": "ERROR: No README data found!"
+}
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/esprima/README.md b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/esprima/README.md
new file mode 100644
index 0000000..a74bd12
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/esprima/README.md
@@ -0,0 +1,73 @@
+**Esprima** ([esprima.org](http://esprima.org)) is a high performance,
+standard-compliant [ECMAScript](http://www.ecma-international.org/publications/standards/Ecma-262.htm)
+parser written in ECMAScript (also popularly known as
+[JavaScript](http://en.wikipedia.org/wiki/JavaScript>JavaScript)).
+Esprima is created and maintained by [Ariya Hidayat](http://twitter.com/ariyahidayat),
+with the help of [many contributors](https://github.com/ariya/esprima/contributors).
+
+Esprima runs on web browsers (IE 6+, Firefox 1+, Safari 3+, Chrome 1+, Konqueror 4.6+, Opera 8+) as well as
+[Node.js](http://nodejs.org).
+
+### Features
+
+- Full support for [ECMAScript 5.1](http://www.ecma-international.org/publications/standards/Ecma-262.htm)(ECMA-262)
+- Sensible [syntax tree format](http://esprima.org/doc/index.html#ast) compatible with Mozilla
+[Parser AST](https://developer.mozilla.org/en/SpiderMonkey/Parser_API)
+- Heavily tested (> 550 [unit tests](http://esprima.org/test/) with solid 100% statement coverage)
+- Optional tracking of syntax node location (index-based and line-column)
+- Experimental support for ES6/Harmony (module, class, destructuring, ...)
+
+Esprima is blazing fast (see the [benchmark suite](http://esprima.org/test/benchmarks.html)).
+It is up to 3x faster than UglifyJS v1 and it is still [competitive](http://esprima.org/test/compare.html)
+with the new generation of fast parsers.
+
+### Applications
+
+Esprima serves as the basis for many popular JavaScript development tools:
+
+- Code coverage analysis: [node-cover](https://github.com/itay/node-cover), [Istanbul](https://github.com/yahoo/Istanbul)
+- Documentation tool: [JFDoc](https://github.com/thejohnfreeman/jfdoc), [JSDuck](https://github.com/senchalabs/jsduck)
+- Language extension: [LLJS](http://mbebenita.github.com/LLJS/) (low-level JS),
+[Sweet.js](http://sweetjs.org/) (macro)
+- ES6/Harmony transpiler: [Six](https://github.com/matthewrobb/six), [Harmonizr](https://github.com/jdiamond/harmonizr)
+- Eclipse Orion smart editing ([outline view](https://github.com/aclement/esprima-outline), [content assist](http://contraptionsforprogramming.blogspot.com/2012/02/better-javascript-content-assist-in.html))
+- Source code modification: [Esmorph](https://github.com/ariya/esmorph), [Code Painter](https://github.com/fawek/codepainter),
+- Source transformation: [node-falafel](https://github.com/substack/node-falafel), [Esmangle](https://github.com/Constellation/esmangle), [escodegen](https://github.com/Constellation/escodegen)
+
+### Questions?
+- [Documentation](http://esprima.org/doc)
+- [Issue tracker](http://issues.esprima.org): [known problems](http://code.google.com/p/esprima/issues/list?q=Defect)
+and [future plans](http://code.google.com/p/esprima/issues/list?q=Enhancement)
+- [Mailing list](http://groups.google.com/group/esprima)
+- [Contribution guide](http://esprima.org/doc/index.html#contribution)
+
+Follow [@Esprima](http://twitter.com/Esprima) on Twitter to get the
+development updates.
+Feedback and contribution are welcomed!
+
+### License
+
+Copyright (C) 2012, 2011 [Ariya Hidayat](http://ariya.ofilabs.com/about)
+ and other contributors.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/esprima/bin/esparse.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/esprima/bin/esparse.js
new file mode 100755
index 0000000..3e7bb81
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/esprima/bin/esparse.js
@@ -0,0 +1,117 @@
+#!/usr/bin/env node
+/*
+ Copyright (C) 2012 Ariya Hidayat
+ Copyright (C) 2011 Ariya Hidayat
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ ARE DISCLAIMED. IN NO EVENT SHALL BE LIABLE FOR ANY
+ DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+/*jslint sloppy:true node:true rhino:true */
+
+var fs, esprima, fname, content, options, syntax;
+
+if (typeof require === 'function') {
+ fs = require('fs');
+ esprima = require('esprima');
+} else if (typeof load === 'function') {
+ try {
+ load('esprima.js');
+ } catch (e) {
+ load('../esprima.js');
+ }
+}
+
+// Shims to Node.js objects when running under Rhino.
+if (typeof console === 'undefined' && typeof process === 'undefined') {
+ console = { log: print };
+ fs = { readFileSync: readFile };
+ process = { argv: arguments, exit: quit };
+ process.argv.unshift('esparse.js');
+ process.argv.unshift('rhino');
+}
+
+function showUsage() {
+ console.log('Usage:');
+ console.log(' esparse [options] file.js');
+ console.log();
+ console.log('Available options:');
+ console.log();
+ console.log(' --comment Gather all line and block comments in an array');
+ console.log(' --loc Include line-column location info for each syntax node');
+ console.log(' --range Include index-based range for each syntax node');
+ console.log(' --raw Display the raw value of literals');
+ console.log(' --tokens List all tokens in an array');
+ console.log(' --tolerant Tolerate errors on a best-effort basis (experimental)');
+ console.log(' -v, --version Shows program version');
+ console.log();
+ process.exit(1);
+}
+
+if (process.argv.length <= 2) {
+ showUsage();
+}
+
+options = {};
+
+process.argv.splice(2).forEach(function (entry) {
+
+ if (entry === '-h' || entry === '--help') {
+ showUsage();
+ } else if (entry === '-v' || entry === '--version') {
+ console.log('ECMAScript Parser (using Esprima version', esprima.version, ')');
+ console.log();
+ process.exit(0);
+ } else if (entry === '--comment') {
+ options.comment = true;
+ } else if (entry === '--loc') {
+ options.loc = true;
+ } else if (entry === '--range') {
+ options.range = true;
+ } else if (entry === '--raw') {
+ options.raw = true;
+ } else if (entry === '--tokens') {
+ options.tokens = true;
+ } else if (entry === '--tolerant') {
+ options.tolerant = true;
+ } else if (entry.slice(0, 2) === '--') {
+ console.log('Error: unknown option ' + entry + '.');
+ process.exit(1);
+ } else if (typeof fname === 'string') {
+ console.log('Error: more than one input file.');
+ process.exit(1);
+ } else {
+ fname = entry;
+ }
+});
+
+if (typeof fname !== 'string') {
+ console.log('Error: no input file.');
+ process.exit(1);
+}
+
+try {
+ content = fs.readFileSync(fname, 'utf-8');
+ syntax = esprima.parse(content, options);
+ console.log(JSON.stringify(syntax, null, 4));
+} catch (e) {
+ console.log('Error: ' + e.message);
+ process.exit(1);
+}
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/esprima/bin/esvalidate.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/esprima/bin/esvalidate.js
new file mode 100755
index 0000000..e0af3f7
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/esprima/bin/esvalidate.js
@@ -0,0 +1,177 @@
+#!/usr/bin/env node
+/*
+ Copyright (C) 2012 Ariya Hidayat
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ ARE DISCLAIMED. IN NO EVENT SHALL BE LIABLE FOR ANY
+ DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+/*jslint sloppy:true plusplus:true node:true rhino:true */
+
+var fs, esprima, options, fnames, count;
+
+if (typeof require === 'function') {
+ fs = require('fs');
+ esprima = require('esprima');
+} else if (typeof load === 'function') {
+ try {
+ load('esprima.js');
+ } catch (e) {
+ load('../esprima.js');
+ }
+}
+
+// Shims to Node.js objects when running under Rhino.
+if (typeof console === 'undefined' && typeof process === 'undefined') {
+ console = { log: print };
+ fs = { readFileSync: readFile };
+ process = { argv: arguments, exit: quit };
+ process.argv.unshift('esvalidate.js');
+ process.argv.unshift('rhino');
+}
+
+function showUsage() {
+ console.log('Usage:');
+ console.log(' esvalidate [options] file.js');
+ console.log();
+ console.log('Available options:');
+ console.log();
+ console.log(' --format=type Set the report format, plain (default) or junit');
+ console.log(' -v, --version Print program version');
+ console.log();
+ process.exit(1);
+}
+
+if (process.argv.length <= 2) {
+ showUsage();
+}
+
+options = {
+ format: 'plain'
+};
+
+fnames = [];
+
+process.argv.splice(2).forEach(function (entry) {
+
+ if (entry === '-h' || entry === '--help') {
+ showUsage();
+ } else if (entry === '-v' || entry === '--version') {
+ console.log('ECMAScript Validator (using Esprima version', esprima.version, ')');
+ console.log();
+ process.exit(0);
+ } else if (entry.slice(0, 9) === '--format=') {
+ options.format = entry.slice(9);
+ if (options.format !== 'plain' && options.format !== 'junit') {
+ console.log('Error: unknown report format ' + options.format + '.');
+ process.exit(1);
+ }
+ } else if (entry.slice(0, 2) === '--') {
+ console.log('Error: unknown option ' + entry + '.');
+ process.exit(1);
+ } else {
+ fnames.push(entry);
+ }
+});
+
+if (fnames.length === 0) {
+ console.log('Error: no input file.');
+ process.exit(1);
+}
+
+if (options.format === 'junit') {
+ console.log('');
+ console.log('');
+}
+
+count = 0;
+fnames.forEach(function (fname) {
+ var content, timestamp, syntax, name;
+ try {
+ content = fs.readFileSync(fname, 'utf-8');
+
+ if (content[0] === '#' && content[1] === '!') {
+ content = '//' + content.substr(2, content.length);
+ }
+
+ timestamp = Date.now();
+ syntax = esprima.parse(content, { tolerant: true });
+
+ if (options.format === 'junit') {
+
+ name = fname;
+ if (name.lastIndexOf('/') >= 0) {
+ name = name.slice(name.lastIndexOf('/') + 1);
+ }
+
+ console.log('');
+
+ syntax.errors.forEach(function (error) {
+ var msg = error.message;
+ msg = msg.replace(/^Line\ [0-9]*\:\ /, '');
+ console.log(' ');
+ console.log(' ' +
+ error.message + '(' + name + ':' + error.lineNumber + ')' +
+ '');
+ console.log(' ');
+ });
+
+ console.log('');
+
+ } else if (options.format === 'plain') {
+
+ syntax.errors.forEach(function (error) {
+ var msg = error.message;
+ msg = msg.replace(/^Line\ [0-9]*\:\ /, '');
+ msg = fname + ':' + error.lineNumber + ': ' + msg;
+ console.log(msg);
+ ++count;
+ });
+
+ }
+ } catch (e) {
+ ++count;
+ if (options.format === 'junit') {
+ console.log('');
+ console.log(' ');
+ console.log(' ' +
+ e.message + '(' + fname + ((e.lineNumber) ? ':' + e.lineNumber : '') +
+ ')');
+ console.log(' ');
+ console.log('');
+ } else {
+ console.log('Error: ' + e.message);
+ }
+ }
+});
+
+if (options.format === 'junit') {
+ console.log('');
+}
+
+if (count > 0) {
+ process.exit(1);
+}
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/esprima/esprima.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/esprima/esprima.js
new file mode 100644
index 0000000..f1320da
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/esprima/esprima.js
@@ -0,0 +1,3908 @@
+/*
+ Copyright (C) 2012 Ariya Hidayat
+ Copyright (C) 2012 Mathias Bynens
+ Copyright (C) 2012 Joost-Wim Boekesteijn
+ Copyright (C) 2012 Kris Kowal
+ Copyright (C) 2012 Yusuke Suzuki
+ Copyright (C) 2012 Arpad Borsos
+ Copyright (C) 2011 Ariya Hidayat
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ ARE DISCLAIMED. IN NO EVENT SHALL BE LIABLE FOR ANY
+ DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+/*jslint bitwise:true plusplus:true */
+/*global esprima:true, define:true, exports:true, window: true,
+throwError: true, createLiteral: true, generateStatement: true,
+parseAssignmentExpression: true, parseBlock: true, parseExpression: true,
+parseFunctionDeclaration: true, parseFunctionExpression: true,
+parseFunctionSourceElements: true, parseVariableIdentifier: true,
+parseLeftHandSideExpression: true,
+parseStatement: true, parseSourceElement: true */
+
+(function (root, factory) {
+ 'use strict';
+
+ // Universal Module Definition (UMD) to support AMD, CommonJS/Node.js,
+ // Rhino, and plain browser loading.
+ if (typeof define === 'function' && define.amd) {
+ define(['exports'], factory);
+ } else if (typeof exports !== 'undefined') {
+ factory(exports);
+ } else {
+ factory((root.esprima = {}));
+ }
+}(this, function (exports) {
+ 'use strict';
+
+ var Token,
+ TokenName,
+ Syntax,
+ PropertyKind,
+ Messages,
+ Regex,
+ source,
+ strict,
+ index,
+ lineNumber,
+ lineStart,
+ length,
+ buffer,
+ state,
+ extra;
+
+ Token = {
+ BooleanLiteral: 1,
+ EOF: 2,
+ Identifier: 3,
+ Keyword: 4,
+ NullLiteral: 5,
+ NumericLiteral: 6,
+ Punctuator: 7,
+ StringLiteral: 8
+ };
+
+ TokenName = {};
+ TokenName[Token.BooleanLiteral] = 'Boolean';
+ TokenName[Token.EOF] = '';
+ TokenName[Token.Identifier] = 'Identifier';
+ TokenName[Token.Keyword] = 'Keyword';
+ TokenName[Token.NullLiteral] = 'Null';
+ TokenName[Token.NumericLiteral] = 'Numeric';
+ TokenName[Token.Punctuator] = 'Punctuator';
+ TokenName[Token.StringLiteral] = 'String';
+
+ Syntax = {
+ AssignmentExpression: 'AssignmentExpression',
+ ArrayExpression: 'ArrayExpression',
+ BlockStatement: 'BlockStatement',
+ BinaryExpression: 'BinaryExpression',
+ BreakStatement: 'BreakStatement',
+ CallExpression: 'CallExpression',
+ CatchClause: 'CatchClause',
+ ConditionalExpression: 'ConditionalExpression',
+ ContinueStatement: 'ContinueStatement',
+ DoWhileStatement: 'DoWhileStatement',
+ DebuggerStatement: 'DebuggerStatement',
+ EmptyStatement: 'EmptyStatement',
+ ExpressionStatement: 'ExpressionStatement',
+ ForStatement: 'ForStatement',
+ ForInStatement: 'ForInStatement',
+ FunctionDeclaration: 'FunctionDeclaration',
+ FunctionExpression: 'FunctionExpression',
+ Identifier: 'Identifier',
+ IfStatement: 'IfStatement',
+ Literal: 'Literal',
+ LabeledStatement: 'LabeledStatement',
+ LogicalExpression: 'LogicalExpression',
+ MemberExpression: 'MemberExpression',
+ NewExpression: 'NewExpression',
+ ObjectExpression: 'ObjectExpression',
+ Program: 'Program',
+ Property: 'Property',
+ ReturnStatement: 'ReturnStatement',
+ SequenceExpression: 'SequenceExpression',
+ SwitchStatement: 'SwitchStatement',
+ SwitchCase: 'SwitchCase',
+ ThisExpression: 'ThisExpression',
+ ThrowStatement: 'ThrowStatement',
+ TryStatement: 'TryStatement',
+ UnaryExpression: 'UnaryExpression',
+ UpdateExpression: 'UpdateExpression',
+ VariableDeclaration: 'VariableDeclaration',
+ VariableDeclarator: 'VariableDeclarator',
+ WhileStatement: 'WhileStatement',
+ WithStatement: 'WithStatement'
+ };
+
+ PropertyKind = {
+ Data: 1,
+ Get: 2,
+ Set: 4
+ };
+
+ // Error messages should be identical to V8.
+ Messages = {
+ UnexpectedToken: 'Unexpected token %0',
+ UnexpectedNumber: 'Unexpected number',
+ UnexpectedString: 'Unexpected string',
+ UnexpectedIdentifier: 'Unexpected identifier',
+ UnexpectedReserved: 'Unexpected reserved word',
+ UnexpectedEOS: 'Unexpected end of input',
+ NewlineAfterThrow: 'Illegal newline after throw',
+ InvalidRegExp: 'Invalid regular expression',
+ UnterminatedRegExp: 'Invalid regular expression: missing /',
+ InvalidLHSInAssignment: 'Invalid left-hand side in assignment',
+ InvalidLHSInForIn: 'Invalid left-hand side in for-in',
+ MultipleDefaultsInSwitch: 'More than one default clause in switch statement',
+ NoCatchOrFinally: 'Missing catch or finally after try',
+ UnknownLabel: 'Undefined label \'%0\'',
+ Redeclaration: '%0 \'%1\' has already been declared',
+ IllegalContinue: 'Illegal continue statement',
+ IllegalBreak: 'Illegal break statement',
+ IllegalReturn: 'Illegal return statement',
+ StrictModeWith: 'Strict mode code may not include a with statement',
+ StrictCatchVariable: 'Catch variable may not be eval or arguments in strict mode',
+ StrictVarName: 'Variable name may not be eval or arguments in strict mode',
+ StrictParamName: 'Parameter name eval or arguments is not allowed in strict mode',
+ StrictParamDupe: 'Strict mode function may not have duplicate parameter names',
+ StrictFunctionName: 'Function name may not be eval or arguments in strict mode',
+ StrictOctalLiteral: 'Octal literals are not allowed in strict mode.',
+ StrictDelete: 'Delete of an unqualified identifier in strict mode.',
+ StrictDuplicateProperty: 'Duplicate data property in object literal not allowed in strict mode',
+ AccessorDataProperty: 'Object literal may not have data and accessor property with the same name',
+ AccessorGetSet: 'Object literal may not have multiple get/set accessors with the same name',
+ StrictLHSAssignment: 'Assignment to eval or arguments is not allowed in strict mode',
+ StrictLHSPostfix: 'Postfix increment/decrement may not have eval or arguments operand in strict mode',
+ StrictLHSPrefix: 'Prefix increment/decrement may not have eval or arguments operand in strict mode',
+ StrictReservedWord: 'Use of future reserved word in strict mode'
+ };
+
+ // See also tools/generate-unicode-regex.py.
+ Regex = {
+ NonAsciiIdentifierStart: new RegExp('[\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u0527\u0531-\u0556\u0559\u0561-\u0587\u05d0-\u05ea\u05f0-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u08a0\u08a2-\u08ac\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0977\u0979-\u097f\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c33\u0c35-\u0c39\u0c3d\u0c58\u0c59\u0c60\u0c61\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d60\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e87\u0e88\u0e8a\u0e8d\u0e94-\u0e97\u0e99-\u0e9f\u0ea1-\u0ea3\u0ea5\u0ea7\u0eaa\u0eab\u0ead-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f4\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f0\u1700-\u170c\u170e-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1877\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191c\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19c1-\u19c7\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4b\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1ce9-\u1cec\u1cee-\u1cf1\u1cf5\u1cf6\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2119-\u211d\u2124\u2126\u2128\u212a-\u212d\u212f-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2e2f\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309d-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312d\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4db5\u4e00-\u9fcc\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua697\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua78e\ua790-\ua793\ua7a0-\ua7aa\ua7f8-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa80-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uabc0-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc]'),
+ NonAsciiIdentifierPart: new RegExp('[\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0300-\u0374\u0376\u0377\u037a-\u037d\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u0483-\u0487\u048a-\u0527\u0531-\u0556\u0559\u0561-\u0587\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u05d0-\u05ea\u05f0-\u05f2\u0610-\u061a\u0620-\u0669\u066e-\u06d3\u06d5-\u06dc\u06df-\u06e8\u06ea-\u06fc\u06ff\u0710-\u074a\u074d-\u07b1\u07c0-\u07f5\u07fa\u0800-\u082d\u0840-\u085b\u08a0\u08a2-\u08ac\u08e4-\u08fe\u0900-\u0963\u0966-\u096f\u0971-\u0977\u0979-\u097f\u0981-\u0983\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bc-\u09c4\u09c7\u09c8\u09cb-\u09ce\u09d7\u09dc\u09dd\u09df-\u09e3\u09e6-\u09f1\u0a01-\u0a03\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a59-\u0a5c\u0a5e\u0a66-\u0a75\u0a81-\u0a83\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abc-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ad0\u0ae0-\u0ae3\u0ae6-\u0aef\u0b01-\u0b03\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3c-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b56\u0b57\u0b5c\u0b5d\u0b5f-\u0b63\u0b66-\u0b6f\u0b71\u0b82\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd0\u0bd7\u0be6-\u0bef\u0c01-\u0c03\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c33\u0c35-\u0c39\u0c3d-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c58\u0c59\u0c60-\u0c63\u0c66-\u0c6f\u0c82\u0c83\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbc-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0cde\u0ce0-\u0ce3\u0ce6-\u0cef\u0cf1\u0cf2\u0d02\u0d03\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d-\u0d44\u0d46-\u0d48\u0d4a-\u0d4e\u0d57\u0d60-\u0d63\u0d66-\u0d6f\u0d7a-\u0d7f\u0d82\u0d83\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0df2\u0df3\u0e01-\u0e3a\u0e40-\u0e4e\u0e50-\u0e59\u0e81\u0e82\u0e84\u0e87\u0e88\u0e8a\u0e8d\u0e94-\u0e97\u0e99-\u0e9f\u0ea1-\u0ea3\u0ea5\u0ea7\u0eaa\u0eab\u0ead-\u0eb9\u0ebb-\u0ebd\u0ec0-\u0ec4\u0ec6\u0ec8-\u0ecd\u0ed0-\u0ed9\u0edc-\u0edf\u0f00\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f3e-\u0f47\u0f49-\u0f6c\u0f71-\u0f84\u0f86-\u0f97\u0f99-\u0fbc\u0fc6\u1000-\u1049\u1050-\u109d\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u135d-\u135f\u1380-\u138f\u13a0-\u13f4\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f0\u1700-\u170c\u170e-\u1714\u1720-\u1734\u1740-\u1753\u1760-\u176c\u176e-\u1770\u1772\u1773\u1780-\u17d3\u17d7\u17dc\u17dd\u17e0-\u17e9\u180b-\u180d\u1810-\u1819\u1820-\u1877\u1880-\u18aa\u18b0-\u18f5\u1900-\u191c\u1920-\u192b\u1930-\u193b\u1946-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u19d0-\u19d9\u1a00-\u1a1b\u1a20-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1aa7\u1b00-\u1b4b\u1b50-\u1b59\u1b6b-\u1b73\u1b80-\u1bf3\u1c00-\u1c37\u1c40-\u1c49\u1c4d-\u1c7d\u1cd0-\u1cd2\u1cd4-\u1cf6\u1d00-\u1de6\u1dfc-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u200c\u200d\u203f\u2040\u2054\u2071\u207f\u2090-\u209c\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2102\u2107\u210a-\u2113\u2115\u2119-\u211d\u2124\u2126\u2128\u212a-\u212d\u212f-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d7f-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2de0-\u2dff\u2e2f\u3005-\u3007\u3021-\u302f\u3031-\u3035\u3038-\u303c\u3041-\u3096\u3099\u309a\u309d-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312d\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4db5\u4e00-\u9fcc\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua62b\ua640-\ua66f\ua674-\ua67d\ua67f-\ua697\ua69f-\ua6f1\ua717-\ua71f\ua722-\ua788\ua78b-\ua78e\ua790-\ua793\ua7a0-\ua7aa\ua7f8-\ua827\ua840-\ua873\ua880-\ua8c4\ua8d0-\ua8d9\ua8e0-\ua8f7\ua8fb\ua900-\ua92d\ua930-\ua953\ua960-\ua97c\ua980-\ua9c0\ua9cf-\ua9d9\uaa00-\uaa36\uaa40-\uaa4d\uaa50-\uaa59\uaa60-\uaa76\uaa7a\uaa7b\uaa80-\uaac2\uaadb-\uaadd\uaae0-\uaaef\uaaf2-\uaaf6\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uabc0-\uabea\uabec\uabed\uabf0-\uabf9\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe00-\ufe0f\ufe20-\ufe26\ufe33\ufe34\ufe4d-\ufe4f\ufe70-\ufe74\ufe76-\ufefc\uff10-\uff19\uff21-\uff3a\uff3f\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc]')
+ };
+
+ // Ensure the condition is true, otherwise throw an error.
+ // This is only to have a better contract semantic, i.e. another safety net
+ // to catch a logic error. The condition shall be fulfilled in normal case.
+ // Do NOT use this to enforce a certain condition on any user input.
+
+ function assert(condition, message) {
+ if (!condition) {
+ throw new Error('ASSERT: ' + message);
+ }
+ }
+
+ function sliceSource(from, to) {
+ return source.slice(from, to);
+ }
+
+ if (typeof 'esprima'[0] === 'undefined') {
+ sliceSource = function sliceArraySource(from, to) {
+ return source.slice(from, to).join('');
+ };
+ }
+
+ function isDecimalDigit(ch) {
+ return '0123456789'.indexOf(ch) >= 0;
+ }
+
+ function isHexDigit(ch) {
+ return '0123456789abcdefABCDEF'.indexOf(ch) >= 0;
+ }
+
+ function isOctalDigit(ch) {
+ return '01234567'.indexOf(ch) >= 0;
+ }
+
+
+ // 7.2 White Space
+
+ function isWhiteSpace(ch) {
+ return (ch === ' ') || (ch === '\u0009') || (ch === '\u000B') ||
+ (ch === '\u000C') || (ch === '\u00A0') ||
+ (ch.charCodeAt(0) >= 0x1680 &&
+ '\u1680\u180E\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\uFEFF'.indexOf(ch) >= 0);
+ }
+
+ // 7.3 Line Terminators
+
+ function isLineTerminator(ch) {
+ return (ch === '\n' || ch === '\r' || ch === '\u2028' || ch === '\u2029');
+ }
+
+ // 7.6 Identifier Names and Identifiers
+
+ function isIdentifierStart(ch) {
+ return (ch === '$') || (ch === '_') || (ch === '\\') ||
+ (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') ||
+ ((ch.charCodeAt(0) >= 0x80) && Regex.NonAsciiIdentifierStart.test(ch));
+ }
+
+ function isIdentifierPart(ch) {
+ return (ch === '$') || (ch === '_') || (ch === '\\') ||
+ (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') ||
+ ((ch >= '0') && (ch <= '9')) ||
+ ((ch.charCodeAt(0) >= 0x80) && Regex.NonAsciiIdentifierPart.test(ch));
+ }
+
+ // 7.6.1.2 Future Reserved Words
+
+ function isFutureReservedWord(id) {
+ switch (id) {
+
+ // Future reserved words.
+ case 'class':
+ case 'enum':
+ case 'export':
+ case 'extends':
+ case 'import':
+ case 'super':
+ return true;
+ }
+
+ return false;
+ }
+
+ function isStrictModeReservedWord(id) {
+ switch (id) {
+
+ // Strict Mode reserved words.
+ case 'implements':
+ case 'interface':
+ case 'package':
+ case 'private':
+ case 'protected':
+ case 'public':
+ case 'static':
+ case 'yield':
+ case 'let':
+ return true;
+ }
+
+ return false;
+ }
+
+ function isRestrictedWord(id) {
+ return id === 'eval' || id === 'arguments';
+ }
+
+ // 7.6.1.1 Keywords
+
+ function isKeyword(id) {
+ var keyword = false;
+ switch (id.length) {
+ case 2:
+ keyword = (id === 'if') || (id === 'in') || (id === 'do');
+ break;
+ case 3:
+ keyword = (id === 'var') || (id === 'for') || (id === 'new') || (id === 'try');
+ break;
+ case 4:
+ keyword = (id === 'this') || (id === 'else') || (id === 'case') || (id === 'void') || (id === 'with');
+ break;
+ case 5:
+ keyword = (id === 'while') || (id === 'break') || (id === 'catch') || (id === 'throw');
+ break;
+ case 6:
+ keyword = (id === 'return') || (id === 'typeof') || (id === 'delete') || (id === 'switch');
+ break;
+ case 7:
+ keyword = (id === 'default') || (id === 'finally');
+ break;
+ case 8:
+ keyword = (id === 'function') || (id === 'continue') || (id === 'debugger');
+ break;
+ case 10:
+ keyword = (id === 'instanceof');
+ break;
+ }
+
+ if (keyword) {
+ return true;
+ }
+
+ switch (id) {
+ // Future reserved words.
+ // 'const' is specialized as Keyword in V8.
+ case 'const':
+ return true;
+
+ // For compatiblity to SpiderMonkey and ES.next
+ case 'yield':
+ case 'let':
+ return true;
+ }
+
+ if (strict && isStrictModeReservedWord(id)) {
+ return true;
+ }
+
+ return isFutureReservedWord(id);
+ }
+
+ // 7.4 Comments
+
+ function skipComment() {
+ var ch, blockComment, lineComment;
+
+ blockComment = false;
+ lineComment = false;
+
+ while (index < length) {
+ ch = source[index];
+
+ if (lineComment) {
+ ch = source[index++];
+ if (isLineTerminator(ch)) {
+ lineComment = false;
+ if (ch === '\r' && source[index] === '\n') {
+ ++index;
+ }
+ ++lineNumber;
+ lineStart = index;
+ }
+ } else if (blockComment) {
+ if (isLineTerminator(ch)) {
+ if (ch === '\r' && source[index + 1] === '\n') {
+ ++index;
+ }
+ ++lineNumber;
+ ++index;
+ lineStart = index;
+ if (index >= length) {
+ throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+ }
+ } else {
+ ch = source[index++];
+ if (index >= length) {
+ throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+ }
+ if (ch === '*') {
+ ch = source[index];
+ if (ch === '/') {
+ ++index;
+ blockComment = false;
+ }
+ }
+ }
+ } else if (ch === '/') {
+ ch = source[index + 1];
+ if (ch === '/') {
+ index += 2;
+ lineComment = true;
+ } else if (ch === '*') {
+ index += 2;
+ blockComment = true;
+ if (index >= length) {
+ throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+ }
+ } else {
+ break;
+ }
+ } else if (isWhiteSpace(ch)) {
+ ++index;
+ } else if (isLineTerminator(ch)) {
+ ++index;
+ if (ch === '\r' && source[index] === '\n') {
+ ++index;
+ }
+ ++lineNumber;
+ lineStart = index;
+ } else {
+ break;
+ }
+ }
+ }
+
+ function scanHexEscape(prefix) {
+ var i, len, ch, code = 0;
+
+ len = (prefix === 'u') ? 4 : 2;
+ for (i = 0; i < len; ++i) {
+ if (index < length && isHexDigit(source[index])) {
+ ch = source[index++];
+ code = code * 16 + '0123456789abcdef'.indexOf(ch.toLowerCase());
+ } else {
+ return '';
+ }
+ }
+ return String.fromCharCode(code);
+ }
+
+ function scanIdentifier() {
+ var ch, start, id, restore;
+
+ ch = source[index];
+ if (!isIdentifierStart(ch)) {
+ return;
+ }
+
+ start = index;
+ if (ch === '\\') {
+ ++index;
+ if (source[index] !== 'u') {
+ return;
+ }
+ ++index;
+ restore = index;
+ ch = scanHexEscape('u');
+ if (ch) {
+ if (ch === '\\' || !isIdentifierStart(ch)) {
+ return;
+ }
+ id = ch;
+ } else {
+ index = restore;
+ id = 'u';
+ }
+ } else {
+ id = source[index++];
+ }
+
+ while (index < length) {
+ ch = source[index];
+ if (!isIdentifierPart(ch)) {
+ break;
+ }
+ if (ch === '\\') {
+ ++index;
+ if (source[index] !== 'u') {
+ return;
+ }
+ ++index;
+ restore = index;
+ ch = scanHexEscape('u');
+ if (ch) {
+ if (ch === '\\' || !isIdentifierPart(ch)) {
+ return;
+ }
+ id += ch;
+ } else {
+ index = restore;
+ id += 'u';
+ }
+ } else {
+ id += source[index++];
+ }
+ }
+
+ // There is no keyword or literal with only one character.
+ // Thus, it must be an identifier.
+ if (id.length === 1) {
+ return {
+ type: Token.Identifier,
+ value: id,
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ }
+
+ if (isKeyword(id)) {
+ return {
+ type: Token.Keyword,
+ value: id,
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ }
+
+ // 7.8.1 Null Literals
+
+ if (id === 'null') {
+ return {
+ type: Token.NullLiteral,
+ value: id,
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ }
+
+ // 7.8.2 Boolean Literals
+
+ if (id === 'true' || id === 'false') {
+ return {
+ type: Token.BooleanLiteral,
+ value: id,
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ }
+
+ return {
+ type: Token.Identifier,
+ value: id,
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ }
+
+ // 7.7 Punctuators
+
+ function scanPunctuator() {
+ var start = index,
+ ch1 = source[index],
+ ch2,
+ ch3,
+ ch4;
+
+ // Check for most common single-character punctuators.
+
+ if (ch1 === ';' || ch1 === '{' || ch1 === '}') {
+ ++index;
+ return {
+ type: Token.Punctuator,
+ value: ch1,
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ }
+
+ if (ch1 === ',' || ch1 === '(' || ch1 === ')') {
+ ++index;
+ return {
+ type: Token.Punctuator,
+ value: ch1,
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ }
+
+ // Dot (.) can also start a floating-point number, hence the need
+ // to check the next character.
+
+ ch2 = source[index + 1];
+ if (ch1 === '.' && !isDecimalDigit(ch2)) {
+ return {
+ type: Token.Punctuator,
+ value: source[index++],
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ }
+
+ // Peek more characters.
+
+ ch3 = source[index + 2];
+ ch4 = source[index + 3];
+
+ // 4-character punctuator: >>>=
+
+ if (ch1 === '>' && ch2 === '>' && ch3 === '>') {
+ if (ch4 === '=') {
+ index += 4;
+ return {
+ type: Token.Punctuator,
+ value: '>>>=',
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ }
+ }
+
+ // 3-character punctuators: === !== >>> <<= >>=
+
+ if (ch1 === '=' && ch2 === '=' && ch3 === '=') {
+ index += 3;
+ return {
+ type: Token.Punctuator,
+ value: '===',
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ }
+
+ if (ch1 === '!' && ch2 === '=' && ch3 === '=') {
+ index += 3;
+ return {
+ type: Token.Punctuator,
+ value: '!==',
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ }
+
+ if (ch1 === '>' && ch2 === '>' && ch3 === '>') {
+ index += 3;
+ return {
+ type: Token.Punctuator,
+ value: '>>>',
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ }
+
+ if (ch1 === '<' && ch2 === '<' && ch3 === '=') {
+ index += 3;
+ return {
+ type: Token.Punctuator,
+ value: '<<=',
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ }
+
+ if (ch1 === '>' && ch2 === '>' && ch3 === '=') {
+ index += 3;
+ return {
+ type: Token.Punctuator,
+ value: '>>=',
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ }
+
+ // 2-character punctuators: <= >= == != ++ -- << >> && ||
+ // += -= *= %= &= |= ^= /=
+
+ if (ch2 === '=') {
+ if ('<>=!+-*%&|^/'.indexOf(ch1) >= 0) {
+ index += 2;
+ return {
+ type: Token.Punctuator,
+ value: ch1 + ch2,
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ }
+ }
+
+ if (ch1 === ch2 && ('+-<>&|'.indexOf(ch1) >= 0)) {
+ if ('+-<>&|'.indexOf(ch2) >= 0) {
+ index += 2;
+ return {
+ type: Token.Punctuator,
+ value: ch1 + ch2,
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ }
+ }
+
+ // The remaining 1-character punctuators.
+
+ if ('[]<>+-*%&|^!~?:=/'.indexOf(ch1) >= 0) {
+ return {
+ type: Token.Punctuator,
+ value: source[index++],
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ }
+ }
+
+ // 7.8.3 Numeric Literals
+
+ function scanNumericLiteral() {
+ var number, start, ch;
+
+ ch = source[index];
+ assert(isDecimalDigit(ch) || (ch === '.'),
+ 'Numeric literal must start with a decimal digit or a decimal point');
+
+ start = index;
+ number = '';
+ if (ch !== '.') {
+ number = source[index++];
+ ch = source[index];
+
+ // Hex number starts with '0x'.
+ // Octal number starts with '0'.
+ if (number === '0') {
+ if (ch === 'x' || ch === 'X') {
+ number += source[index++];
+ while (index < length) {
+ ch = source[index];
+ if (!isHexDigit(ch)) {
+ break;
+ }
+ number += source[index++];
+ }
+
+ if (number.length <= 2) {
+ // only 0x
+ throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+ }
+
+ if (index < length) {
+ ch = source[index];
+ if (isIdentifierStart(ch)) {
+ throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+ }
+ }
+ return {
+ type: Token.NumericLiteral,
+ value: parseInt(number, 16),
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ } else if (isOctalDigit(ch)) {
+ number += source[index++];
+ while (index < length) {
+ ch = source[index];
+ if (!isOctalDigit(ch)) {
+ break;
+ }
+ number += source[index++];
+ }
+
+ if (index < length) {
+ ch = source[index];
+ if (isIdentifierStart(ch) || isDecimalDigit(ch)) {
+ throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+ }
+ }
+ return {
+ type: Token.NumericLiteral,
+ value: parseInt(number, 8),
+ octal: true,
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ }
+
+ // decimal number starts with '0' such as '09' is illegal.
+ if (isDecimalDigit(ch)) {
+ throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+ }
+ }
+
+ while (index < length) {
+ ch = source[index];
+ if (!isDecimalDigit(ch)) {
+ break;
+ }
+ number += source[index++];
+ }
+ }
+
+ if (ch === '.') {
+ number += source[index++];
+ while (index < length) {
+ ch = source[index];
+ if (!isDecimalDigit(ch)) {
+ break;
+ }
+ number += source[index++];
+ }
+ }
+
+ if (ch === 'e' || ch === 'E') {
+ number += source[index++];
+
+ ch = source[index];
+ if (ch === '+' || ch === '-') {
+ number += source[index++];
+ }
+
+ ch = source[index];
+ if (isDecimalDigit(ch)) {
+ number += source[index++];
+ while (index < length) {
+ ch = source[index];
+ if (!isDecimalDigit(ch)) {
+ break;
+ }
+ number += source[index++];
+ }
+ } else {
+ ch = 'character ' + ch;
+ if (index >= length) {
+ ch = '';
+ }
+ throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+ }
+ }
+
+ if (index < length) {
+ ch = source[index];
+ if (isIdentifierStart(ch)) {
+ throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+ }
+ }
+
+ return {
+ type: Token.NumericLiteral,
+ value: parseFloat(number),
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ }
+
+ // 7.8.4 String Literals
+
+ function scanStringLiteral() {
+ var str = '', quote, start, ch, code, unescaped, restore, octal = false;
+
+ quote = source[index];
+ assert((quote === '\'' || quote === '"'),
+ 'String literal must starts with a quote');
+
+ start = index;
+ ++index;
+
+ while (index < length) {
+ ch = source[index++];
+
+ if (ch === quote) {
+ quote = '';
+ break;
+ } else if (ch === '\\') {
+ ch = source[index++];
+ if (!isLineTerminator(ch)) {
+ switch (ch) {
+ case 'n':
+ str += '\n';
+ break;
+ case 'r':
+ str += '\r';
+ break;
+ case 't':
+ str += '\t';
+ break;
+ case 'u':
+ case 'x':
+ restore = index;
+ unescaped = scanHexEscape(ch);
+ if (unescaped) {
+ str += unescaped;
+ } else {
+ index = restore;
+ str += ch;
+ }
+ break;
+ case 'b':
+ str += '\b';
+ break;
+ case 'f':
+ str += '\f';
+ break;
+ case 'v':
+ str += '\x0B';
+ break;
+
+ default:
+ if (isOctalDigit(ch)) {
+ code = '01234567'.indexOf(ch);
+
+ // \0 is not octal escape sequence
+ if (code !== 0) {
+ octal = true;
+ }
+
+ if (index < length && isOctalDigit(source[index])) {
+ octal = true;
+ code = code * 8 + '01234567'.indexOf(source[index++]);
+
+ // 3 digits are only allowed when string starts
+ // with 0, 1, 2, 3
+ if ('0123'.indexOf(ch) >= 0 &&
+ index < length &&
+ isOctalDigit(source[index])) {
+ code = code * 8 + '01234567'.indexOf(source[index++]);
+ }
+ }
+ str += String.fromCharCode(code);
+ } else {
+ str += ch;
+ }
+ break;
+ }
+ } else {
+ ++lineNumber;
+ if (ch === '\r' && source[index] === '\n') {
+ ++index;
+ }
+ }
+ } else if (isLineTerminator(ch)) {
+ break;
+ } else {
+ str += ch;
+ }
+ }
+
+ if (quote !== '') {
+ throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+ }
+
+ return {
+ type: Token.StringLiteral,
+ value: str,
+ octal: octal,
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ }
+
+ function scanRegExp() {
+ var str, ch, start, pattern, flags, value, classMarker = false, restore, terminated = false;
+
+ buffer = null;
+ skipComment();
+
+ start = index;
+ ch = source[index];
+ assert(ch === '/', 'Regular expression literal must start with a slash');
+ str = source[index++];
+
+ while (index < length) {
+ ch = source[index++];
+ str += ch;
+ if (ch === '\\') {
+ ch = source[index++];
+ // ECMA-262 7.8.5
+ if (isLineTerminator(ch)) {
+ throwError({}, Messages.UnterminatedRegExp);
+ }
+ str += ch;
+ } else if (classMarker) {
+ if (ch === ']') {
+ classMarker = false;
+ }
+ } else {
+ if (ch === '/') {
+ terminated = true;
+ break;
+ } else if (ch === '[') {
+ classMarker = true;
+ } else if (isLineTerminator(ch)) {
+ throwError({}, Messages.UnterminatedRegExp);
+ }
+ }
+ }
+
+ if (!terminated) {
+ throwError({}, Messages.UnterminatedRegExp);
+ }
+
+ // Exclude leading and trailing slash.
+ pattern = str.substr(1, str.length - 2);
+
+ flags = '';
+ while (index < length) {
+ ch = source[index];
+ if (!isIdentifierPart(ch)) {
+ break;
+ }
+
+ ++index;
+ if (ch === '\\' && index < length) {
+ ch = source[index];
+ if (ch === 'u') {
+ ++index;
+ restore = index;
+ ch = scanHexEscape('u');
+ if (ch) {
+ flags += ch;
+ str += '\\u';
+ for (; restore < index; ++restore) {
+ str += source[restore];
+ }
+ } else {
+ index = restore;
+ flags += 'u';
+ str += '\\u';
+ }
+ } else {
+ str += '\\';
+ }
+ } else {
+ flags += ch;
+ str += ch;
+ }
+ }
+
+ try {
+ value = new RegExp(pattern, flags);
+ } catch (e) {
+ throwError({}, Messages.InvalidRegExp);
+ }
+
+ return {
+ literal: str,
+ value: value,
+ range: [start, index]
+ };
+ }
+
+ function isIdentifierName(token) {
+ return token.type === Token.Identifier ||
+ token.type === Token.Keyword ||
+ token.type === Token.BooleanLiteral ||
+ token.type === Token.NullLiteral;
+ }
+
+ function advance() {
+ var ch, token;
+
+ skipComment();
+
+ if (index >= length) {
+ return {
+ type: Token.EOF,
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [index, index]
+ };
+ }
+
+ token = scanPunctuator();
+ if (typeof token !== 'undefined') {
+ return token;
+ }
+
+ ch = source[index];
+
+ if (ch === '\'' || ch === '"') {
+ return scanStringLiteral();
+ }
+
+ if (ch === '.' || isDecimalDigit(ch)) {
+ return scanNumericLiteral();
+ }
+
+ token = scanIdentifier();
+ if (typeof token !== 'undefined') {
+ return token;
+ }
+
+ throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+ }
+
+ function lex() {
+ var token;
+
+ if (buffer) {
+ index = buffer.range[1];
+ lineNumber = buffer.lineNumber;
+ lineStart = buffer.lineStart;
+ token = buffer;
+ buffer = null;
+ return token;
+ }
+
+ buffer = null;
+ return advance();
+ }
+
+ function lookahead() {
+ var pos, line, start;
+
+ if (buffer !== null) {
+ return buffer;
+ }
+
+ pos = index;
+ line = lineNumber;
+ start = lineStart;
+ buffer = advance();
+ index = pos;
+ lineNumber = line;
+ lineStart = start;
+
+ return buffer;
+ }
+
+ // Return true if there is a line terminator before the next token.
+
+ function peekLineTerminator() {
+ var pos, line, start, found;
+
+ pos = index;
+ line = lineNumber;
+ start = lineStart;
+ skipComment();
+ found = lineNumber !== line;
+ index = pos;
+ lineNumber = line;
+ lineStart = start;
+
+ return found;
+ }
+
+ // Throw an exception
+
+ function throwError(token, messageFormat) {
+ var error,
+ args = Array.prototype.slice.call(arguments, 2),
+ msg = messageFormat.replace(
+ /%(\d)/g,
+ function (whole, index) {
+ return args[index] || '';
+ }
+ );
+
+ if (typeof token.lineNumber === 'number') {
+ error = new Error('Line ' + token.lineNumber + ': ' + msg);
+ error.index = token.range[0];
+ error.lineNumber = token.lineNumber;
+ error.column = token.range[0] - lineStart + 1;
+ } else {
+ error = new Error('Line ' + lineNumber + ': ' + msg);
+ error.index = index;
+ error.lineNumber = lineNumber;
+ error.column = index - lineStart + 1;
+ }
+
+ throw error;
+ }
+
+ function throwErrorTolerant() {
+ try {
+ throwError.apply(null, arguments);
+ } catch (e) {
+ if (extra.errors) {
+ extra.errors.push(e);
+ } else {
+ throw e;
+ }
+ }
+ }
+
+
+ // Throw an exception because of the token.
+
+ function throwUnexpected(token) {
+ if (token.type === Token.EOF) {
+ throwError(token, Messages.UnexpectedEOS);
+ }
+
+ if (token.type === Token.NumericLiteral) {
+ throwError(token, Messages.UnexpectedNumber);
+ }
+
+ if (token.type === Token.StringLiteral) {
+ throwError(token, Messages.UnexpectedString);
+ }
+
+ if (token.type === Token.Identifier) {
+ throwError(token, Messages.UnexpectedIdentifier);
+ }
+
+ if (token.type === Token.Keyword) {
+ if (isFutureReservedWord(token.value)) {
+ throwError(token, Messages.UnexpectedReserved);
+ } else if (strict && isStrictModeReservedWord(token.value)) {
+ throwErrorTolerant(token, Messages.StrictReservedWord);
+ return;
+ }
+ throwError(token, Messages.UnexpectedToken, token.value);
+ }
+
+ // BooleanLiteral, NullLiteral, or Punctuator.
+ throwError(token, Messages.UnexpectedToken, token.value);
+ }
+
+ // Expect the next token to match the specified punctuator.
+ // If not, an exception will be thrown.
+
+ function expect(value) {
+ var token = lex();
+ if (token.type !== Token.Punctuator || token.value !== value) {
+ throwUnexpected(token);
+ }
+ }
+
+ // Expect the next token to match the specified keyword.
+ // If not, an exception will be thrown.
+
+ function expectKeyword(keyword) {
+ var token = lex();
+ if (token.type !== Token.Keyword || token.value !== keyword) {
+ throwUnexpected(token);
+ }
+ }
+
+ // Return true if the next token matches the specified punctuator.
+
+ function match(value) {
+ var token = lookahead();
+ return token.type === Token.Punctuator && token.value === value;
+ }
+
+ // Return true if the next token matches the specified keyword
+
+ function matchKeyword(keyword) {
+ var token = lookahead();
+ return token.type === Token.Keyword && token.value === keyword;
+ }
+
+ // Return true if the next token is an assignment operator
+
+ function matchAssign() {
+ var token = lookahead(),
+ op = token.value;
+
+ if (token.type !== Token.Punctuator) {
+ return false;
+ }
+ return op === '=' ||
+ op === '*=' ||
+ op === '/=' ||
+ op === '%=' ||
+ op === '+=' ||
+ op === '-=' ||
+ op === '<<=' ||
+ op === '>>=' ||
+ op === '>>>=' ||
+ op === '&=' ||
+ op === '^=' ||
+ op === '|=';
+ }
+
+ function consumeSemicolon() {
+ var token, line;
+
+ // Catch the very common case first.
+ if (source[index] === ';') {
+ lex();
+ return;
+ }
+
+ line = lineNumber;
+ skipComment();
+ if (lineNumber !== line) {
+ return;
+ }
+
+ if (match(';')) {
+ lex();
+ return;
+ }
+
+ token = lookahead();
+ if (token.type !== Token.EOF && !match('}')) {
+ throwUnexpected(token);
+ }
+ }
+
+ // Return true if provided expression is LeftHandSideExpression
+
+ function isLeftHandSide(expr) {
+ return expr.type === Syntax.Identifier || expr.type === Syntax.MemberExpression;
+ }
+
+ // 11.1.4 Array Initialiser
+
+ function parseArrayInitialiser() {
+ var elements = [];
+
+ expect('[');
+
+ while (!match(']')) {
+ if (match(',')) {
+ lex();
+ elements.push(null);
+ } else {
+ elements.push(parseAssignmentExpression());
+
+ if (!match(']')) {
+ expect(',');
+ }
+ }
+ }
+
+ expect(']');
+
+ return {
+ type: Syntax.ArrayExpression,
+ elements: elements
+ };
+ }
+
+ // 11.1.5 Object Initialiser
+
+ function parsePropertyFunction(param, first) {
+ var previousStrict, body;
+
+ previousStrict = strict;
+ body = parseFunctionSourceElements();
+ if (first && strict && isRestrictedWord(param[0].name)) {
+ throwErrorTolerant(first, Messages.StrictParamName);
+ }
+ strict = previousStrict;
+
+ return {
+ type: Syntax.FunctionExpression,
+ id: null,
+ params: param,
+ defaults: [],
+ body: body,
+ rest: null,
+ generator: false,
+ expression: false
+ };
+ }
+
+ function parseObjectPropertyKey() {
+ var token = lex();
+
+ // Note: This function is called only from parseObjectProperty(), where
+ // EOF and Punctuator tokens are already filtered out.
+
+ if (token.type === Token.StringLiteral || token.type === Token.NumericLiteral) {
+ if (strict && token.octal) {
+ throwErrorTolerant(token, Messages.StrictOctalLiteral);
+ }
+ return createLiteral(token);
+ }
+
+ return {
+ type: Syntax.Identifier,
+ name: token.value
+ };
+ }
+
+ function parseObjectProperty() {
+ var token, key, id, param;
+
+ token = lookahead();
+
+ if (token.type === Token.Identifier) {
+
+ id = parseObjectPropertyKey();
+
+ // Property Assignment: Getter and Setter.
+
+ if (token.value === 'get' && !match(':')) {
+ key = parseObjectPropertyKey();
+ expect('(');
+ expect(')');
+ return {
+ type: Syntax.Property,
+ key: key,
+ value: parsePropertyFunction([]),
+ kind: 'get'
+ };
+ } else if (token.value === 'set' && !match(':')) {
+ key = parseObjectPropertyKey();
+ expect('(');
+ token = lookahead();
+ if (token.type !== Token.Identifier) {
+ expect(')');
+ throwErrorTolerant(token, Messages.UnexpectedToken, token.value);
+ return {
+ type: Syntax.Property,
+ key: key,
+ value: parsePropertyFunction([]),
+ kind: 'set'
+ };
+ } else {
+ param = [ parseVariableIdentifier() ];
+ expect(')');
+ return {
+ type: Syntax.Property,
+ key: key,
+ value: parsePropertyFunction(param, token),
+ kind: 'set'
+ };
+ }
+ } else {
+ expect(':');
+ return {
+ type: Syntax.Property,
+ key: id,
+ value: parseAssignmentExpression(),
+ kind: 'init'
+ };
+ }
+ } else if (token.type === Token.EOF || token.type === Token.Punctuator) {
+ throwUnexpected(token);
+ } else {
+ key = parseObjectPropertyKey();
+ expect(':');
+ return {
+ type: Syntax.Property,
+ key: key,
+ value: parseAssignmentExpression(),
+ kind: 'init'
+ };
+ }
+ }
+
+ function parseObjectInitialiser() {
+ var properties = [], property, name, kind, map = {}, toString = String;
+
+ expect('{');
+
+ while (!match('}')) {
+ property = parseObjectProperty();
+
+ if (property.key.type === Syntax.Identifier) {
+ name = property.key.name;
+ } else {
+ name = toString(property.key.value);
+ }
+ kind = (property.kind === 'init') ? PropertyKind.Data : (property.kind === 'get') ? PropertyKind.Get : PropertyKind.Set;
+ if (Object.prototype.hasOwnProperty.call(map, name)) {
+ if (map[name] === PropertyKind.Data) {
+ if (strict && kind === PropertyKind.Data) {
+ throwErrorTolerant({}, Messages.StrictDuplicateProperty);
+ } else if (kind !== PropertyKind.Data) {
+ throwErrorTolerant({}, Messages.AccessorDataProperty);
+ }
+ } else {
+ if (kind === PropertyKind.Data) {
+ throwErrorTolerant({}, Messages.AccessorDataProperty);
+ } else if (map[name] & kind) {
+ throwErrorTolerant({}, Messages.AccessorGetSet);
+ }
+ }
+ map[name] |= kind;
+ } else {
+ map[name] = kind;
+ }
+
+ properties.push(property);
+
+ if (!match('}')) {
+ expect(',');
+ }
+ }
+
+ expect('}');
+
+ return {
+ type: Syntax.ObjectExpression,
+ properties: properties
+ };
+ }
+
+ // 11.1.6 The Grouping Operator
+
+ function parseGroupExpression() {
+ var expr;
+
+ expect('(');
+
+ expr = parseExpression();
+
+ expect(')');
+
+ return expr;
+ }
+
+
+ // 11.1 Primary Expressions
+
+ function parsePrimaryExpression() {
+ var token = lookahead(),
+ type = token.type;
+
+ if (type === Token.Identifier) {
+ return {
+ type: Syntax.Identifier,
+ name: lex().value
+ };
+ }
+
+ if (type === Token.StringLiteral || type === Token.NumericLiteral) {
+ if (strict && token.octal) {
+ throwErrorTolerant(token, Messages.StrictOctalLiteral);
+ }
+ return createLiteral(lex());
+ }
+
+ if (type === Token.Keyword) {
+ if (matchKeyword('this')) {
+ lex();
+ return {
+ type: Syntax.ThisExpression
+ };
+ }
+
+ if (matchKeyword('function')) {
+ return parseFunctionExpression();
+ }
+ }
+
+ if (type === Token.BooleanLiteral) {
+ lex();
+ token.value = (token.value === 'true');
+ return createLiteral(token);
+ }
+
+ if (type === Token.NullLiteral) {
+ lex();
+ token.value = null;
+ return createLiteral(token);
+ }
+
+ if (match('[')) {
+ return parseArrayInitialiser();
+ }
+
+ if (match('{')) {
+ return parseObjectInitialiser();
+ }
+
+ if (match('(')) {
+ return parseGroupExpression();
+ }
+
+ if (match('/') || match('/=')) {
+ return createLiteral(scanRegExp());
+ }
+
+ return throwUnexpected(lex());
+ }
+
+ // 11.2 Left-Hand-Side Expressions
+
+ function parseArguments() {
+ var args = [];
+
+ expect('(');
+
+ if (!match(')')) {
+ while (index < length) {
+ args.push(parseAssignmentExpression());
+ if (match(')')) {
+ break;
+ }
+ expect(',');
+ }
+ }
+
+ expect(')');
+
+ return args;
+ }
+
+ function parseNonComputedProperty() {
+ var token = lex();
+
+ if (!isIdentifierName(token)) {
+ throwUnexpected(token);
+ }
+
+ return {
+ type: Syntax.Identifier,
+ name: token.value
+ };
+ }
+
+ function parseNonComputedMember() {
+ expect('.');
+
+ return parseNonComputedProperty();
+ }
+
+ function parseComputedMember() {
+ var expr;
+
+ expect('[');
+
+ expr = parseExpression();
+
+ expect(']');
+
+ return expr;
+ }
+
+ function parseNewExpression() {
+ var expr;
+
+ expectKeyword('new');
+
+ expr = {
+ type: Syntax.NewExpression,
+ callee: parseLeftHandSideExpression(),
+ 'arguments': []
+ };
+
+ if (match('(')) {
+ expr['arguments'] = parseArguments();
+ }
+
+ return expr;
+ }
+
+ function parseLeftHandSideExpressionAllowCall() {
+ var expr;
+
+ expr = matchKeyword('new') ? parseNewExpression() : parsePrimaryExpression();
+
+ while (match('.') || match('[') || match('(')) {
+ if (match('(')) {
+ expr = {
+ type: Syntax.CallExpression,
+ callee: expr,
+ 'arguments': parseArguments()
+ };
+ } else if (match('[')) {
+ expr = {
+ type: Syntax.MemberExpression,
+ computed: true,
+ object: expr,
+ property: parseComputedMember()
+ };
+ } else {
+ expr = {
+ type: Syntax.MemberExpression,
+ computed: false,
+ object: expr,
+ property: parseNonComputedMember()
+ };
+ }
+ }
+
+ return expr;
+ }
+
+
+ function parseLeftHandSideExpression() {
+ var expr;
+
+ expr = matchKeyword('new') ? parseNewExpression() : parsePrimaryExpression();
+
+ while (match('.') || match('[')) {
+ if (match('[')) {
+ expr = {
+ type: Syntax.MemberExpression,
+ computed: true,
+ object: expr,
+ property: parseComputedMember()
+ };
+ } else {
+ expr = {
+ type: Syntax.MemberExpression,
+ computed: false,
+ object: expr,
+ property: parseNonComputedMember()
+ };
+ }
+ }
+
+ return expr;
+ }
+
+ // 11.3 Postfix Expressions
+
+ function parsePostfixExpression() {
+ var expr = parseLeftHandSideExpressionAllowCall(), token;
+
+ token = lookahead();
+ if (token.type !== Token.Punctuator) {
+ return expr;
+ }
+
+ if ((match('++') || match('--')) && !peekLineTerminator()) {
+ // 11.3.1, 11.3.2
+ if (strict && expr.type === Syntax.Identifier && isRestrictedWord(expr.name)) {
+ throwErrorTolerant({}, Messages.StrictLHSPostfix);
+ }
+ if (!isLeftHandSide(expr)) {
+ throwErrorTolerant({}, Messages.InvalidLHSInAssignment);
+ }
+
+ expr = {
+ type: Syntax.UpdateExpression,
+ operator: lex().value,
+ argument: expr,
+ prefix: false
+ };
+ }
+
+ return expr;
+ }
+
+ // 11.4 Unary Operators
+
+ function parseUnaryExpression() {
+ var token, expr;
+
+ token = lookahead();
+ if (token.type !== Token.Punctuator && token.type !== Token.Keyword) {
+ return parsePostfixExpression();
+ }
+
+ if (match('++') || match('--')) {
+ token = lex();
+ expr = parseUnaryExpression();
+ // 11.4.4, 11.4.5
+ if (strict && expr.type === Syntax.Identifier && isRestrictedWord(expr.name)) {
+ throwErrorTolerant({}, Messages.StrictLHSPrefix);
+ }
+
+ if (!isLeftHandSide(expr)) {
+ throwErrorTolerant({}, Messages.InvalidLHSInAssignment);
+ }
+
+ expr = {
+ type: Syntax.UpdateExpression,
+ operator: token.value,
+ argument: expr,
+ prefix: true
+ };
+ return expr;
+ }
+
+ if (match('+') || match('-') || match('~') || match('!')) {
+ expr = {
+ type: Syntax.UnaryExpression,
+ operator: lex().value,
+ argument: parseUnaryExpression(),
+ prefix: true
+ };
+ return expr;
+ }
+
+ if (matchKeyword('delete') || matchKeyword('void') || matchKeyword('typeof')) {
+ expr = {
+ type: Syntax.UnaryExpression,
+ operator: lex().value,
+ argument: parseUnaryExpression(),
+ prefix: true
+ };
+ if (strict && expr.operator === 'delete' && expr.argument.type === Syntax.Identifier) {
+ throwErrorTolerant({}, Messages.StrictDelete);
+ }
+ return expr;
+ }
+
+ return parsePostfixExpression();
+ }
+
+ // 11.5 Multiplicative Operators
+
+ function parseMultiplicativeExpression() {
+ var expr = parseUnaryExpression();
+
+ while (match('*') || match('/') || match('%')) {
+ expr = {
+ type: Syntax.BinaryExpression,
+ operator: lex().value,
+ left: expr,
+ right: parseUnaryExpression()
+ };
+ }
+
+ return expr;
+ }
+
+ // 11.6 Additive Operators
+
+ function parseAdditiveExpression() {
+ var expr = parseMultiplicativeExpression();
+
+ while (match('+') || match('-')) {
+ expr = {
+ type: Syntax.BinaryExpression,
+ operator: lex().value,
+ left: expr,
+ right: parseMultiplicativeExpression()
+ };
+ }
+
+ return expr;
+ }
+
+ // 11.7 Bitwise Shift Operators
+
+ function parseShiftExpression() {
+ var expr = parseAdditiveExpression();
+
+ while (match('<<') || match('>>') || match('>>>')) {
+ expr = {
+ type: Syntax.BinaryExpression,
+ operator: lex().value,
+ left: expr,
+ right: parseAdditiveExpression()
+ };
+ }
+
+ return expr;
+ }
+ // 11.8 Relational Operators
+
+ function parseRelationalExpression() {
+ var expr, previousAllowIn;
+
+ previousAllowIn = state.allowIn;
+ state.allowIn = true;
+
+ expr = parseShiftExpression();
+
+ while (match('<') || match('>') || match('<=') || match('>=') || (previousAllowIn && matchKeyword('in')) || matchKeyword('instanceof')) {
+ expr = {
+ type: Syntax.BinaryExpression,
+ operator: lex().value,
+ left: expr,
+ right: parseShiftExpression()
+ };
+ }
+
+ state.allowIn = previousAllowIn;
+ return expr;
+ }
+
+ // 11.9 Equality Operators
+
+ function parseEqualityExpression() {
+ var expr = parseRelationalExpression();
+
+ while (match('==') || match('!=') || match('===') || match('!==')) {
+ expr = {
+ type: Syntax.BinaryExpression,
+ operator: lex().value,
+ left: expr,
+ right: parseRelationalExpression()
+ };
+ }
+
+ return expr;
+ }
+
+ // 11.10 Binary Bitwise Operators
+
+ function parseBitwiseANDExpression() {
+ var expr = parseEqualityExpression();
+
+ while (match('&')) {
+ lex();
+ expr = {
+ type: Syntax.BinaryExpression,
+ operator: '&',
+ left: expr,
+ right: parseEqualityExpression()
+ };
+ }
+
+ return expr;
+ }
+
+ function parseBitwiseXORExpression() {
+ var expr = parseBitwiseANDExpression();
+
+ while (match('^')) {
+ lex();
+ expr = {
+ type: Syntax.BinaryExpression,
+ operator: '^',
+ left: expr,
+ right: parseBitwiseANDExpression()
+ };
+ }
+
+ return expr;
+ }
+
+ function parseBitwiseORExpression() {
+ var expr = parseBitwiseXORExpression();
+
+ while (match('|')) {
+ lex();
+ expr = {
+ type: Syntax.BinaryExpression,
+ operator: '|',
+ left: expr,
+ right: parseBitwiseXORExpression()
+ };
+ }
+
+ return expr;
+ }
+
+ // 11.11 Binary Logical Operators
+
+ function parseLogicalANDExpression() {
+ var expr = parseBitwiseORExpression();
+
+ while (match('&&')) {
+ lex();
+ expr = {
+ type: Syntax.LogicalExpression,
+ operator: '&&',
+ left: expr,
+ right: parseBitwiseORExpression()
+ };
+ }
+
+ return expr;
+ }
+
+ function parseLogicalORExpression() {
+ var expr = parseLogicalANDExpression();
+
+ while (match('||')) {
+ lex();
+ expr = {
+ type: Syntax.LogicalExpression,
+ operator: '||',
+ left: expr,
+ right: parseLogicalANDExpression()
+ };
+ }
+
+ return expr;
+ }
+
+ // 11.12 Conditional Operator
+
+ function parseConditionalExpression() {
+ var expr, previousAllowIn, consequent;
+
+ expr = parseLogicalORExpression();
+
+ if (match('?')) {
+ lex();
+ previousAllowIn = state.allowIn;
+ state.allowIn = true;
+ consequent = parseAssignmentExpression();
+ state.allowIn = previousAllowIn;
+ expect(':');
+
+ expr = {
+ type: Syntax.ConditionalExpression,
+ test: expr,
+ consequent: consequent,
+ alternate: parseAssignmentExpression()
+ };
+ }
+
+ return expr;
+ }
+
+ // 11.13 Assignment Operators
+
+ function parseAssignmentExpression() {
+ var token, expr;
+
+ token = lookahead();
+ expr = parseConditionalExpression();
+
+ if (matchAssign()) {
+ // LeftHandSideExpression
+ if (!isLeftHandSide(expr)) {
+ throwErrorTolerant({}, Messages.InvalidLHSInAssignment);
+ }
+
+ // 11.13.1
+ if (strict && expr.type === Syntax.Identifier && isRestrictedWord(expr.name)) {
+ throwErrorTolerant(token, Messages.StrictLHSAssignment);
+ }
+
+ expr = {
+ type: Syntax.AssignmentExpression,
+ operator: lex().value,
+ left: expr,
+ right: parseAssignmentExpression()
+ };
+ }
+
+ return expr;
+ }
+
+ // 11.14 Comma Operator
+
+ function parseExpression() {
+ var expr = parseAssignmentExpression();
+
+ if (match(',')) {
+ expr = {
+ type: Syntax.SequenceExpression,
+ expressions: [ expr ]
+ };
+
+ while (index < length) {
+ if (!match(',')) {
+ break;
+ }
+ lex();
+ expr.expressions.push(parseAssignmentExpression());
+ }
+
+ }
+ return expr;
+ }
+
+ // 12.1 Block
+
+ function parseStatementList() {
+ var list = [],
+ statement;
+
+ while (index < length) {
+ if (match('}')) {
+ break;
+ }
+ statement = parseSourceElement();
+ if (typeof statement === 'undefined') {
+ break;
+ }
+ list.push(statement);
+ }
+
+ return list;
+ }
+
+ function parseBlock() {
+ var block;
+
+ expect('{');
+
+ block = parseStatementList();
+
+ expect('}');
+
+ return {
+ type: Syntax.BlockStatement,
+ body: block
+ };
+ }
+
+ // 12.2 Variable Statement
+
+ function parseVariableIdentifier() {
+ var token = lex();
+
+ if (token.type !== Token.Identifier) {
+ throwUnexpected(token);
+ }
+
+ return {
+ type: Syntax.Identifier,
+ name: token.value
+ };
+ }
+
+ function parseVariableDeclaration(kind) {
+ var id = parseVariableIdentifier(),
+ init = null;
+
+ // 12.2.1
+ if (strict && isRestrictedWord(id.name)) {
+ throwErrorTolerant({}, Messages.StrictVarName);
+ }
+
+ if (kind === 'const') {
+ expect('=');
+ init = parseAssignmentExpression();
+ } else if (match('=')) {
+ lex();
+ init = parseAssignmentExpression();
+ }
+
+ return {
+ type: Syntax.VariableDeclarator,
+ id: id,
+ init: init
+ };
+ }
+
+ function parseVariableDeclarationList(kind) {
+ var list = [];
+
+ do {
+ list.push(parseVariableDeclaration(kind));
+ if (!match(',')) {
+ break;
+ }
+ lex();
+ } while (index < length);
+
+ return list;
+ }
+
+ function parseVariableStatement() {
+ var declarations;
+
+ expectKeyword('var');
+
+ declarations = parseVariableDeclarationList();
+
+ consumeSemicolon();
+
+ return {
+ type: Syntax.VariableDeclaration,
+ declarations: declarations,
+ kind: 'var'
+ };
+ }
+
+ // kind may be `const` or `let`
+ // Both are experimental and not in the specification yet.
+ // see http://wiki.ecmascript.org/doku.php?id=harmony:const
+ // and http://wiki.ecmascript.org/doku.php?id=harmony:let
+ function parseConstLetDeclaration(kind) {
+ var declarations;
+
+ expectKeyword(kind);
+
+ declarations = parseVariableDeclarationList(kind);
+
+ consumeSemicolon();
+
+ return {
+ type: Syntax.VariableDeclaration,
+ declarations: declarations,
+ kind: kind
+ };
+ }
+
+ // 12.3 Empty Statement
+
+ function parseEmptyStatement() {
+ expect(';');
+
+ return {
+ type: Syntax.EmptyStatement
+ };
+ }
+
+ // 12.4 Expression Statement
+
+ function parseExpressionStatement() {
+ var expr = parseExpression();
+
+ consumeSemicolon();
+
+ return {
+ type: Syntax.ExpressionStatement,
+ expression: expr
+ };
+ }
+
+ // 12.5 If statement
+
+ function parseIfStatement() {
+ var test, consequent, alternate;
+
+ expectKeyword('if');
+
+ expect('(');
+
+ test = parseExpression();
+
+ expect(')');
+
+ consequent = parseStatement();
+
+ if (matchKeyword('else')) {
+ lex();
+ alternate = parseStatement();
+ } else {
+ alternate = null;
+ }
+
+ return {
+ type: Syntax.IfStatement,
+ test: test,
+ consequent: consequent,
+ alternate: alternate
+ };
+ }
+
+ // 12.6 Iteration Statements
+
+ function parseDoWhileStatement() {
+ var body, test, oldInIteration;
+
+ expectKeyword('do');
+
+ oldInIteration = state.inIteration;
+ state.inIteration = true;
+
+ body = parseStatement();
+
+ state.inIteration = oldInIteration;
+
+ expectKeyword('while');
+
+ expect('(');
+
+ test = parseExpression();
+
+ expect(')');
+
+ if (match(';')) {
+ lex();
+ }
+
+ return {
+ type: Syntax.DoWhileStatement,
+ body: body,
+ test: test
+ };
+ }
+
+ function parseWhileStatement() {
+ var test, body, oldInIteration;
+
+ expectKeyword('while');
+
+ expect('(');
+
+ test = parseExpression();
+
+ expect(')');
+
+ oldInIteration = state.inIteration;
+ state.inIteration = true;
+
+ body = parseStatement();
+
+ state.inIteration = oldInIteration;
+
+ return {
+ type: Syntax.WhileStatement,
+ test: test,
+ body: body
+ };
+ }
+
+ function parseForVariableDeclaration() {
+ var token = lex();
+
+ return {
+ type: Syntax.VariableDeclaration,
+ declarations: parseVariableDeclarationList(),
+ kind: token.value
+ };
+ }
+
+ function parseForStatement() {
+ var init, test, update, left, right, body, oldInIteration;
+
+ init = test = update = null;
+
+ expectKeyword('for');
+
+ expect('(');
+
+ if (match(';')) {
+ lex();
+ } else {
+ if (matchKeyword('var') || matchKeyword('let')) {
+ state.allowIn = false;
+ init = parseForVariableDeclaration();
+ state.allowIn = true;
+
+ if (init.declarations.length === 1 && matchKeyword('in')) {
+ lex();
+ left = init;
+ right = parseExpression();
+ init = null;
+ }
+ } else {
+ state.allowIn = false;
+ init = parseExpression();
+ state.allowIn = true;
+
+ if (matchKeyword('in')) {
+ // LeftHandSideExpression
+ if (!isLeftHandSide(init)) {
+ throwErrorTolerant({}, Messages.InvalidLHSInForIn);
+ }
+
+ lex();
+ left = init;
+ right = parseExpression();
+ init = null;
+ }
+ }
+
+ if (typeof left === 'undefined') {
+ expect(';');
+ }
+ }
+
+ if (typeof left === 'undefined') {
+
+ if (!match(';')) {
+ test = parseExpression();
+ }
+ expect(';');
+
+ if (!match(')')) {
+ update = parseExpression();
+ }
+ }
+
+ expect(')');
+
+ oldInIteration = state.inIteration;
+ state.inIteration = true;
+
+ body = parseStatement();
+
+ state.inIteration = oldInIteration;
+
+ if (typeof left === 'undefined') {
+ return {
+ type: Syntax.ForStatement,
+ init: init,
+ test: test,
+ update: update,
+ body: body
+ };
+ }
+
+ return {
+ type: Syntax.ForInStatement,
+ left: left,
+ right: right,
+ body: body,
+ each: false
+ };
+ }
+
+ // 12.7 The continue statement
+
+ function parseContinueStatement() {
+ var token, label = null;
+
+ expectKeyword('continue');
+
+ // Optimize the most common form: 'continue;'.
+ if (source[index] === ';') {
+ lex();
+
+ if (!state.inIteration) {
+ throwError({}, Messages.IllegalContinue);
+ }
+
+ return {
+ type: Syntax.ContinueStatement,
+ label: null
+ };
+ }
+
+ if (peekLineTerminator()) {
+ if (!state.inIteration) {
+ throwError({}, Messages.IllegalContinue);
+ }
+
+ return {
+ type: Syntax.ContinueStatement,
+ label: null
+ };
+ }
+
+ token = lookahead();
+ if (token.type === Token.Identifier) {
+ label = parseVariableIdentifier();
+
+ if (!Object.prototype.hasOwnProperty.call(state.labelSet, label.name)) {
+ throwError({}, Messages.UnknownLabel, label.name);
+ }
+ }
+
+ consumeSemicolon();
+
+ if (label === null && !state.inIteration) {
+ throwError({}, Messages.IllegalContinue);
+ }
+
+ return {
+ type: Syntax.ContinueStatement,
+ label: label
+ };
+ }
+
+ // 12.8 The break statement
+
+ function parseBreakStatement() {
+ var token, label = null;
+
+ expectKeyword('break');
+
+ // Optimize the most common form: 'break;'.
+ if (source[index] === ';') {
+ lex();
+
+ if (!(state.inIteration || state.inSwitch)) {
+ throwError({}, Messages.IllegalBreak);
+ }
+
+ return {
+ type: Syntax.BreakStatement,
+ label: null
+ };
+ }
+
+ if (peekLineTerminator()) {
+ if (!(state.inIteration || state.inSwitch)) {
+ throwError({}, Messages.IllegalBreak);
+ }
+
+ return {
+ type: Syntax.BreakStatement,
+ label: null
+ };
+ }
+
+ token = lookahead();
+ if (token.type === Token.Identifier) {
+ label = parseVariableIdentifier();
+
+ if (!Object.prototype.hasOwnProperty.call(state.labelSet, label.name)) {
+ throwError({}, Messages.UnknownLabel, label.name);
+ }
+ }
+
+ consumeSemicolon();
+
+ if (label === null && !(state.inIteration || state.inSwitch)) {
+ throwError({}, Messages.IllegalBreak);
+ }
+
+ return {
+ type: Syntax.BreakStatement,
+ label: label
+ };
+ }
+
+ // 12.9 The return statement
+
+ function parseReturnStatement() {
+ var token, argument = null;
+
+ expectKeyword('return');
+
+ if (!state.inFunctionBody) {
+ throwErrorTolerant({}, Messages.IllegalReturn);
+ }
+
+ // 'return' followed by a space and an identifier is very common.
+ if (source[index] === ' ') {
+ if (isIdentifierStart(source[index + 1])) {
+ argument = parseExpression();
+ consumeSemicolon();
+ return {
+ type: Syntax.ReturnStatement,
+ argument: argument
+ };
+ }
+ }
+
+ if (peekLineTerminator()) {
+ return {
+ type: Syntax.ReturnStatement,
+ argument: null
+ };
+ }
+
+ if (!match(';')) {
+ token = lookahead();
+ if (!match('}') && token.type !== Token.EOF) {
+ argument = parseExpression();
+ }
+ }
+
+ consumeSemicolon();
+
+ return {
+ type: Syntax.ReturnStatement,
+ argument: argument
+ };
+ }
+
+ // 12.10 The with statement
+
+ function parseWithStatement() {
+ var object, body;
+
+ if (strict) {
+ throwErrorTolerant({}, Messages.StrictModeWith);
+ }
+
+ expectKeyword('with');
+
+ expect('(');
+
+ object = parseExpression();
+
+ expect(')');
+
+ body = parseStatement();
+
+ return {
+ type: Syntax.WithStatement,
+ object: object,
+ body: body
+ };
+ }
+
+ // 12.10 The swith statement
+
+ function parseSwitchCase() {
+ var test,
+ consequent = [],
+ statement;
+
+ if (matchKeyword('default')) {
+ lex();
+ test = null;
+ } else {
+ expectKeyword('case');
+ test = parseExpression();
+ }
+ expect(':');
+
+ while (index < length) {
+ if (match('}') || matchKeyword('default') || matchKeyword('case')) {
+ break;
+ }
+ statement = parseStatement();
+ if (typeof statement === 'undefined') {
+ break;
+ }
+ consequent.push(statement);
+ }
+
+ return {
+ type: Syntax.SwitchCase,
+ test: test,
+ consequent: consequent
+ };
+ }
+
+ function parseSwitchStatement() {
+ var discriminant, cases, clause, oldInSwitch, defaultFound;
+
+ expectKeyword('switch');
+
+ expect('(');
+
+ discriminant = parseExpression();
+
+ expect(')');
+
+ expect('{');
+
+ cases = [];
+
+ if (match('}')) {
+ lex();
+ return {
+ type: Syntax.SwitchStatement,
+ discriminant: discriminant,
+ cases: cases
+ };
+ }
+
+ oldInSwitch = state.inSwitch;
+ state.inSwitch = true;
+ defaultFound = false;
+
+ while (index < length) {
+ if (match('}')) {
+ break;
+ }
+ clause = parseSwitchCase();
+ if (clause.test === null) {
+ if (defaultFound) {
+ throwError({}, Messages.MultipleDefaultsInSwitch);
+ }
+ defaultFound = true;
+ }
+ cases.push(clause);
+ }
+
+ state.inSwitch = oldInSwitch;
+
+ expect('}');
+
+ return {
+ type: Syntax.SwitchStatement,
+ discriminant: discriminant,
+ cases: cases
+ };
+ }
+
+ // 12.13 The throw statement
+
+ function parseThrowStatement() {
+ var argument;
+
+ expectKeyword('throw');
+
+ if (peekLineTerminator()) {
+ throwError({}, Messages.NewlineAfterThrow);
+ }
+
+ argument = parseExpression();
+
+ consumeSemicolon();
+
+ return {
+ type: Syntax.ThrowStatement,
+ argument: argument
+ };
+ }
+
+ // 12.14 The try statement
+
+ function parseCatchClause() {
+ var param;
+
+ expectKeyword('catch');
+
+ expect('(');
+ if (match(')')) {
+ throwUnexpected(lookahead());
+ }
+
+ param = parseVariableIdentifier();
+ // 12.14.1
+ if (strict && isRestrictedWord(param.name)) {
+ throwErrorTolerant({}, Messages.StrictCatchVariable);
+ }
+
+ expect(')');
+
+ return {
+ type: Syntax.CatchClause,
+ param: param,
+ body: parseBlock()
+ };
+ }
+
+ function parseTryStatement() {
+ var block, handlers = [], finalizer = null;
+
+ expectKeyword('try');
+
+ block = parseBlock();
+
+ if (matchKeyword('catch')) {
+ handlers.push(parseCatchClause());
+ }
+
+ if (matchKeyword('finally')) {
+ lex();
+ finalizer = parseBlock();
+ }
+
+ if (handlers.length === 0 && !finalizer) {
+ throwError({}, Messages.NoCatchOrFinally);
+ }
+
+ return {
+ type: Syntax.TryStatement,
+ block: block,
+ guardedHandlers: [],
+ handlers: handlers,
+ finalizer: finalizer
+ };
+ }
+
+ // 12.15 The debugger statement
+
+ function parseDebuggerStatement() {
+ expectKeyword('debugger');
+
+ consumeSemicolon();
+
+ return {
+ type: Syntax.DebuggerStatement
+ };
+ }
+
+ // 12 Statements
+
+ function parseStatement() {
+ var token = lookahead(),
+ expr,
+ labeledBody;
+
+ if (token.type === Token.EOF) {
+ throwUnexpected(token);
+ }
+
+ if (token.type === Token.Punctuator) {
+ switch (token.value) {
+ case ';':
+ return parseEmptyStatement();
+ case '{':
+ return parseBlock();
+ case '(':
+ return parseExpressionStatement();
+ default:
+ break;
+ }
+ }
+
+ if (token.type === Token.Keyword) {
+ switch (token.value) {
+ case 'break':
+ return parseBreakStatement();
+ case 'continue':
+ return parseContinueStatement();
+ case 'debugger':
+ return parseDebuggerStatement();
+ case 'do':
+ return parseDoWhileStatement();
+ case 'for':
+ return parseForStatement();
+ case 'function':
+ return parseFunctionDeclaration();
+ case 'if':
+ return parseIfStatement();
+ case 'return':
+ return parseReturnStatement();
+ case 'switch':
+ return parseSwitchStatement();
+ case 'throw':
+ return parseThrowStatement();
+ case 'try':
+ return parseTryStatement();
+ case 'var':
+ return parseVariableStatement();
+ case 'while':
+ return parseWhileStatement();
+ case 'with':
+ return parseWithStatement();
+ default:
+ break;
+ }
+ }
+
+ expr = parseExpression();
+
+ // 12.12 Labelled Statements
+ if ((expr.type === Syntax.Identifier) && match(':')) {
+ lex();
+
+ if (Object.prototype.hasOwnProperty.call(state.labelSet, expr.name)) {
+ throwError({}, Messages.Redeclaration, 'Label', expr.name);
+ }
+
+ state.labelSet[expr.name] = true;
+ labeledBody = parseStatement();
+ delete state.labelSet[expr.name];
+
+ return {
+ type: Syntax.LabeledStatement,
+ label: expr,
+ body: labeledBody
+ };
+ }
+
+ consumeSemicolon();
+
+ return {
+ type: Syntax.ExpressionStatement,
+ expression: expr
+ };
+ }
+
+ // 13 Function Definition
+
+ function parseFunctionSourceElements() {
+ var sourceElement, sourceElements = [], token, directive, firstRestricted,
+ oldLabelSet, oldInIteration, oldInSwitch, oldInFunctionBody;
+
+ expect('{');
+
+ while (index < length) {
+ token = lookahead();
+ if (token.type !== Token.StringLiteral) {
+ break;
+ }
+
+ sourceElement = parseSourceElement();
+ sourceElements.push(sourceElement);
+ if (sourceElement.expression.type !== Syntax.Literal) {
+ // this is not directive
+ break;
+ }
+ directive = sliceSource(token.range[0] + 1, token.range[1] - 1);
+ if (directive === 'use strict') {
+ strict = true;
+ if (firstRestricted) {
+ throwErrorTolerant(firstRestricted, Messages.StrictOctalLiteral);
+ }
+ } else {
+ if (!firstRestricted && token.octal) {
+ firstRestricted = token;
+ }
+ }
+ }
+
+ oldLabelSet = state.labelSet;
+ oldInIteration = state.inIteration;
+ oldInSwitch = state.inSwitch;
+ oldInFunctionBody = state.inFunctionBody;
+
+ state.labelSet = {};
+ state.inIteration = false;
+ state.inSwitch = false;
+ state.inFunctionBody = true;
+
+ while (index < length) {
+ if (match('}')) {
+ break;
+ }
+ sourceElement = parseSourceElement();
+ if (typeof sourceElement === 'undefined') {
+ break;
+ }
+ sourceElements.push(sourceElement);
+ }
+
+ expect('}');
+
+ state.labelSet = oldLabelSet;
+ state.inIteration = oldInIteration;
+ state.inSwitch = oldInSwitch;
+ state.inFunctionBody = oldInFunctionBody;
+
+ return {
+ type: Syntax.BlockStatement,
+ body: sourceElements
+ };
+ }
+
+ function parseFunctionDeclaration() {
+ var id, param, params = [], body, token, stricted, firstRestricted, message, previousStrict, paramSet;
+
+ expectKeyword('function');
+ token = lookahead();
+ id = parseVariableIdentifier();
+ if (strict) {
+ if (isRestrictedWord(token.value)) {
+ throwErrorTolerant(token, Messages.StrictFunctionName);
+ }
+ } else {
+ if (isRestrictedWord(token.value)) {
+ firstRestricted = token;
+ message = Messages.StrictFunctionName;
+ } else if (isStrictModeReservedWord(token.value)) {
+ firstRestricted = token;
+ message = Messages.StrictReservedWord;
+ }
+ }
+
+ expect('(');
+
+ if (!match(')')) {
+ paramSet = {};
+ while (index < length) {
+ token = lookahead();
+ param = parseVariableIdentifier();
+ if (strict) {
+ if (isRestrictedWord(token.value)) {
+ stricted = token;
+ message = Messages.StrictParamName;
+ }
+ if (Object.prototype.hasOwnProperty.call(paramSet, token.value)) {
+ stricted = token;
+ message = Messages.StrictParamDupe;
+ }
+ } else if (!firstRestricted) {
+ if (isRestrictedWord(token.value)) {
+ firstRestricted = token;
+ message = Messages.StrictParamName;
+ } else if (isStrictModeReservedWord(token.value)) {
+ firstRestricted = token;
+ message = Messages.StrictReservedWord;
+ } else if (Object.prototype.hasOwnProperty.call(paramSet, token.value)) {
+ firstRestricted = token;
+ message = Messages.StrictParamDupe;
+ }
+ }
+ params.push(param);
+ paramSet[param.name] = true;
+ if (match(')')) {
+ break;
+ }
+ expect(',');
+ }
+ }
+
+ expect(')');
+
+ previousStrict = strict;
+ body = parseFunctionSourceElements();
+ if (strict && firstRestricted) {
+ throwError(firstRestricted, message);
+ }
+ if (strict && stricted) {
+ throwErrorTolerant(stricted, message);
+ }
+ strict = previousStrict;
+
+ return {
+ type: Syntax.FunctionDeclaration,
+ id: id,
+ params: params,
+ defaults: [],
+ body: body,
+ rest: null,
+ generator: false,
+ expression: false
+ };
+ }
+
+ function parseFunctionExpression() {
+ var token, id = null, stricted, firstRestricted, message, param, params = [], body, previousStrict, paramSet;
+
+ expectKeyword('function');
+
+ if (!match('(')) {
+ token = lookahead();
+ id = parseVariableIdentifier();
+ if (strict) {
+ if (isRestrictedWord(token.value)) {
+ throwErrorTolerant(token, Messages.StrictFunctionName);
+ }
+ } else {
+ if (isRestrictedWord(token.value)) {
+ firstRestricted = token;
+ message = Messages.StrictFunctionName;
+ } else if (isStrictModeReservedWord(token.value)) {
+ firstRestricted = token;
+ message = Messages.StrictReservedWord;
+ }
+ }
+ }
+
+ expect('(');
+
+ if (!match(')')) {
+ paramSet = {};
+ while (index < length) {
+ token = lookahead();
+ param = parseVariableIdentifier();
+ if (strict) {
+ if (isRestrictedWord(token.value)) {
+ stricted = token;
+ message = Messages.StrictParamName;
+ }
+ if (Object.prototype.hasOwnProperty.call(paramSet, token.value)) {
+ stricted = token;
+ message = Messages.StrictParamDupe;
+ }
+ } else if (!firstRestricted) {
+ if (isRestrictedWord(token.value)) {
+ firstRestricted = token;
+ message = Messages.StrictParamName;
+ } else if (isStrictModeReservedWord(token.value)) {
+ firstRestricted = token;
+ message = Messages.StrictReservedWord;
+ } else if (Object.prototype.hasOwnProperty.call(paramSet, token.value)) {
+ firstRestricted = token;
+ message = Messages.StrictParamDupe;
+ }
+ }
+ params.push(param);
+ paramSet[param.name] = true;
+ if (match(')')) {
+ break;
+ }
+ expect(',');
+ }
+ }
+
+ expect(')');
+
+ previousStrict = strict;
+ body = parseFunctionSourceElements();
+ if (strict && firstRestricted) {
+ throwError(firstRestricted, message);
+ }
+ if (strict && stricted) {
+ throwErrorTolerant(stricted, message);
+ }
+ strict = previousStrict;
+
+ return {
+ type: Syntax.FunctionExpression,
+ id: id,
+ params: params,
+ defaults: [],
+ body: body,
+ rest: null,
+ generator: false,
+ expression: false
+ };
+ }
+
+ // 14 Program
+
+ function parseSourceElement() {
+ var token = lookahead();
+
+ if (token.type === Token.Keyword) {
+ switch (token.value) {
+ case 'const':
+ case 'let':
+ return parseConstLetDeclaration(token.value);
+ case 'function':
+ return parseFunctionDeclaration();
+ default:
+ return parseStatement();
+ }
+ }
+
+ if (token.type !== Token.EOF) {
+ return parseStatement();
+ }
+ }
+
+ function parseSourceElements() {
+ var sourceElement, sourceElements = [], token, directive, firstRestricted;
+
+ while (index < length) {
+ token = lookahead();
+ if (token.type !== Token.StringLiteral) {
+ break;
+ }
+
+ sourceElement = parseSourceElement();
+ sourceElements.push(sourceElement);
+ if (sourceElement.expression.type !== Syntax.Literal) {
+ // this is not directive
+ break;
+ }
+ directive = sliceSource(token.range[0] + 1, token.range[1] - 1);
+ if (directive === 'use strict') {
+ strict = true;
+ if (firstRestricted) {
+ throwErrorTolerant(firstRestricted, Messages.StrictOctalLiteral);
+ }
+ } else {
+ if (!firstRestricted && token.octal) {
+ firstRestricted = token;
+ }
+ }
+ }
+
+ while (index < length) {
+ sourceElement = parseSourceElement();
+ if (typeof sourceElement === 'undefined') {
+ break;
+ }
+ sourceElements.push(sourceElement);
+ }
+ return sourceElements;
+ }
+
+ function parseProgram() {
+ var program;
+ strict = false;
+ program = {
+ type: Syntax.Program,
+ body: parseSourceElements()
+ };
+ return program;
+ }
+
+ // The following functions are needed only when the option to preserve
+ // the comments is active.
+
+ function addComment(type, value, start, end, loc) {
+ assert(typeof start === 'number', 'Comment must have valid position');
+
+ // Because the way the actual token is scanned, often the comments
+ // (if any) are skipped twice during the lexical analysis.
+ // Thus, we need to skip adding a comment if the comment array already
+ // handled it.
+ if (extra.comments.length > 0) {
+ if (extra.comments[extra.comments.length - 1].range[1] > start) {
+ return;
+ }
+ }
+
+ extra.comments.push({
+ type: type,
+ value: value,
+ range: [start, end],
+ loc: loc
+ });
+ }
+
+ function scanComment() {
+ var comment, ch, loc, start, blockComment, lineComment;
+
+ comment = '';
+ blockComment = false;
+ lineComment = false;
+
+ while (index < length) {
+ ch = source[index];
+
+ if (lineComment) {
+ ch = source[index++];
+ if (isLineTerminator(ch)) {
+ loc.end = {
+ line: lineNumber,
+ column: index - lineStart - 1
+ };
+ lineComment = false;
+ addComment('Line', comment, start, index - 1, loc);
+ if (ch === '\r' && source[index] === '\n') {
+ ++index;
+ }
+ ++lineNumber;
+ lineStart = index;
+ comment = '';
+ } else if (index >= length) {
+ lineComment = false;
+ comment += ch;
+ loc.end = {
+ line: lineNumber,
+ column: length - lineStart
+ };
+ addComment('Line', comment, start, length, loc);
+ } else {
+ comment += ch;
+ }
+ } else if (blockComment) {
+ if (isLineTerminator(ch)) {
+ if (ch === '\r' && source[index + 1] === '\n') {
+ ++index;
+ comment += '\r\n';
+ } else {
+ comment += ch;
+ }
+ ++lineNumber;
+ ++index;
+ lineStart = index;
+ if (index >= length) {
+ throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+ }
+ } else {
+ ch = source[index++];
+ if (index >= length) {
+ throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+ }
+ comment += ch;
+ if (ch === '*') {
+ ch = source[index];
+ if (ch === '/') {
+ comment = comment.substr(0, comment.length - 1);
+ blockComment = false;
+ ++index;
+ loc.end = {
+ line: lineNumber,
+ column: index - lineStart
+ };
+ addComment('Block', comment, start, index, loc);
+ comment = '';
+ }
+ }
+ }
+ } else if (ch === '/') {
+ ch = source[index + 1];
+ if (ch === '/') {
+ loc = {
+ start: {
+ line: lineNumber,
+ column: index - lineStart
+ }
+ };
+ start = index;
+ index += 2;
+ lineComment = true;
+ if (index >= length) {
+ loc.end = {
+ line: lineNumber,
+ column: index - lineStart
+ };
+ lineComment = false;
+ addComment('Line', comment, start, index, loc);
+ }
+ } else if (ch === '*') {
+ start = index;
+ index += 2;
+ blockComment = true;
+ loc = {
+ start: {
+ line: lineNumber,
+ column: index - lineStart - 2
+ }
+ };
+ if (index >= length) {
+ throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+ }
+ } else {
+ break;
+ }
+ } else if (isWhiteSpace(ch)) {
+ ++index;
+ } else if (isLineTerminator(ch)) {
+ ++index;
+ if (ch === '\r' && source[index] === '\n') {
+ ++index;
+ }
+ ++lineNumber;
+ lineStart = index;
+ } else {
+ break;
+ }
+ }
+ }
+
+ function filterCommentLocation() {
+ var i, entry, comment, comments = [];
+
+ for (i = 0; i < extra.comments.length; ++i) {
+ entry = extra.comments[i];
+ comment = {
+ type: entry.type,
+ value: entry.value
+ };
+ if (extra.range) {
+ comment.range = entry.range;
+ }
+ if (extra.loc) {
+ comment.loc = entry.loc;
+ }
+ comments.push(comment);
+ }
+
+ extra.comments = comments;
+ }
+
+ function collectToken() {
+ var start, loc, token, range, value;
+
+ skipComment();
+ start = index;
+ loc = {
+ start: {
+ line: lineNumber,
+ column: index - lineStart
+ }
+ };
+
+ token = extra.advance();
+ loc.end = {
+ line: lineNumber,
+ column: index - lineStart
+ };
+
+ if (token.type !== Token.EOF) {
+ range = [token.range[0], token.range[1]];
+ value = sliceSource(token.range[0], token.range[1]);
+ extra.tokens.push({
+ type: TokenName[token.type],
+ value: value,
+ range: range,
+ loc: loc
+ });
+ }
+
+ return token;
+ }
+
+ function collectRegex() {
+ var pos, loc, regex, token;
+
+ skipComment();
+
+ pos = index;
+ loc = {
+ start: {
+ line: lineNumber,
+ column: index - lineStart
+ }
+ };
+
+ regex = extra.scanRegExp();
+ loc.end = {
+ line: lineNumber,
+ column: index - lineStart
+ };
+
+ // Pop the previous token, which is likely '/' or '/='
+ if (extra.tokens.length > 0) {
+ token = extra.tokens[extra.tokens.length - 1];
+ if (token.range[0] === pos && token.type === 'Punctuator') {
+ if (token.value === '/' || token.value === '/=') {
+ extra.tokens.pop();
+ }
+ }
+ }
+
+ extra.tokens.push({
+ type: 'RegularExpression',
+ value: regex.literal,
+ range: [pos, index],
+ loc: loc
+ });
+
+ return regex;
+ }
+
+ function filterTokenLocation() {
+ var i, entry, token, tokens = [];
+
+ for (i = 0; i < extra.tokens.length; ++i) {
+ entry = extra.tokens[i];
+ token = {
+ type: entry.type,
+ value: entry.value
+ };
+ if (extra.range) {
+ token.range = entry.range;
+ }
+ if (extra.loc) {
+ token.loc = entry.loc;
+ }
+ tokens.push(token);
+ }
+
+ extra.tokens = tokens;
+ }
+
+ function createLiteral(token) {
+ return {
+ type: Syntax.Literal,
+ value: token.value
+ };
+ }
+
+ function createRawLiteral(token) {
+ return {
+ type: Syntax.Literal,
+ value: token.value,
+ raw: sliceSource(token.range[0], token.range[1])
+ };
+ }
+
+ function createLocationMarker() {
+ var marker = {};
+
+ marker.range = [index, index];
+ marker.loc = {
+ start: {
+ line: lineNumber,
+ column: index - lineStart
+ },
+ end: {
+ line: lineNumber,
+ column: index - lineStart
+ }
+ };
+
+ marker.end = function () {
+ this.range[1] = index;
+ this.loc.end.line = lineNumber;
+ this.loc.end.column = index - lineStart;
+ };
+
+ marker.applyGroup = function (node) {
+ if (extra.range) {
+ node.groupRange = [this.range[0], this.range[1]];
+ }
+ if (extra.loc) {
+ node.groupLoc = {
+ start: {
+ line: this.loc.start.line,
+ column: this.loc.start.column
+ },
+ end: {
+ line: this.loc.end.line,
+ column: this.loc.end.column
+ }
+ };
+ }
+ };
+
+ marker.apply = function (node) {
+ if (extra.range) {
+ node.range = [this.range[0], this.range[1]];
+ }
+ if (extra.loc) {
+ node.loc = {
+ start: {
+ line: this.loc.start.line,
+ column: this.loc.start.column
+ },
+ end: {
+ line: this.loc.end.line,
+ column: this.loc.end.column
+ }
+ };
+ }
+ };
+
+ return marker;
+ }
+
+ function trackGroupExpression() {
+ var marker, expr;
+
+ skipComment();
+ marker = createLocationMarker();
+ expect('(');
+
+ expr = parseExpression();
+
+ expect(')');
+
+ marker.end();
+ marker.applyGroup(expr);
+
+ return expr;
+ }
+
+ function trackLeftHandSideExpression() {
+ var marker, expr;
+
+ skipComment();
+ marker = createLocationMarker();
+
+ expr = matchKeyword('new') ? parseNewExpression() : parsePrimaryExpression();
+
+ while (match('.') || match('[')) {
+ if (match('[')) {
+ expr = {
+ type: Syntax.MemberExpression,
+ computed: true,
+ object: expr,
+ property: parseComputedMember()
+ };
+ marker.end();
+ marker.apply(expr);
+ } else {
+ expr = {
+ type: Syntax.MemberExpression,
+ computed: false,
+ object: expr,
+ property: parseNonComputedMember()
+ };
+ marker.end();
+ marker.apply(expr);
+ }
+ }
+
+ return expr;
+ }
+
+ function trackLeftHandSideExpressionAllowCall() {
+ var marker, expr;
+
+ skipComment();
+ marker = createLocationMarker();
+
+ expr = matchKeyword('new') ? parseNewExpression() : parsePrimaryExpression();
+
+ while (match('.') || match('[') || match('(')) {
+ if (match('(')) {
+ expr = {
+ type: Syntax.CallExpression,
+ callee: expr,
+ 'arguments': parseArguments()
+ };
+ marker.end();
+ marker.apply(expr);
+ } else if (match('[')) {
+ expr = {
+ type: Syntax.MemberExpression,
+ computed: true,
+ object: expr,
+ property: parseComputedMember()
+ };
+ marker.end();
+ marker.apply(expr);
+ } else {
+ expr = {
+ type: Syntax.MemberExpression,
+ computed: false,
+ object: expr,
+ property: parseNonComputedMember()
+ };
+ marker.end();
+ marker.apply(expr);
+ }
+ }
+
+ return expr;
+ }
+
+ function filterGroup(node) {
+ var n, i, entry;
+
+ n = (Object.prototype.toString.apply(node) === '[object Array]') ? [] : {};
+ for (i in node) {
+ if (node.hasOwnProperty(i) && i !== 'groupRange' && i !== 'groupLoc') {
+ entry = node[i];
+ if (entry === null || typeof entry !== 'object' || entry instanceof RegExp) {
+ n[i] = entry;
+ } else {
+ n[i] = filterGroup(entry);
+ }
+ }
+ }
+ return n;
+ }
+
+ function wrapTrackingFunction(range, loc) {
+
+ return function (parseFunction) {
+
+ function isBinary(node) {
+ return node.type === Syntax.LogicalExpression ||
+ node.type === Syntax.BinaryExpression;
+ }
+
+ function visit(node) {
+ var start, end;
+
+ if (isBinary(node.left)) {
+ visit(node.left);
+ }
+ if (isBinary(node.right)) {
+ visit(node.right);
+ }
+
+ if (range) {
+ if (node.left.groupRange || node.right.groupRange) {
+ start = node.left.groupRange ? node.left.groupRange[0] : node.left.range[0];
+ end = node.right.groupRange ? node.right.groupRange[1] : node.right.range[1];
+ node.range = [start, end];
+ } else if (typeof node.range === 'undefined') {
+ start = node.left.range[0];
+ end = node.right.range[1];
+ node.range = [start, end];
+ }
+ }
+ if (loc) {
+ if (node.left.groupLoc || node.right.groupLoc) {
+ start = node.left.groupLoc ? node.left.groupLoc.start : node.left.loc.start;
+ end = node.right.groupLoc ? node.right.groupLoc.end : node.right.loc.end;
+ node.loc = {
+ start: start,
+ end: end
+ };
+ } else if (typeof node.loc === 'undefined') {
+ node.loc = {
+ start: node.left.loc.start,
+ end: node.right.loc.end
+ };
+ }
+ }
+ }
+
+ return function () {
+ var marker, node;
+
+ skipComment();
+
+ marker = createLocationMarker();
+ node = parseFunction.apply(null, arguments);
+ marker.end();
+
+ if (range && typeof node.range === 'undefined') {
+ marker.apply(node);
+ }
+
+ if (loc && typeof node.loc === 'undefined') {
+ marker.apply(node);
+ }
+
+ if (isBinary(node)) {
+ visit(node);
+ }
+
+ return node;
+ };
+ };
+ }
+
+ function patch() {
+
+ var wrapTracking;
+
+ if (extra.comments) {
+ extra.skipComment = skipComment;
+ skipComment = scanComment;
+ }
+
+ if (extra.raw) {
+ extra.createLiteral = createLiteral;
+ createLiteral = createRawLiteral;
+ }
+
+ if (extra.range || extra.loc) {
+
+ extra.parseGroupExpression = parseGroupExpression;
+ extra.parseLeftHandSideExpression = parseLeftHandSideExpression;
+ extra.parseLeftHandSideExpressionAllowCall = parseLeftHandSideExpressionAllowCall;
+ parseGroupExpression = trackGroupExpression;
+ parseLeftHandSideExpression = trackLeftHandSideExpression;
+ parseLeftHandSideExpressionAllowCall = trackLeftHandSideExpressionAllowCall;
+
+ wrapTracking = wrapTrackingFunction(extra.range, extra.loc);
+
+ extra.parseAdditiveExpression = parseAdditiveExpression;
+ extra.parseAssignmentExpression = parseAssignmentExpression;
+ extra.parseBitwiseANDExpression = parseBitwiseANDExpression;
+ extra.parseBitwiseORExpression = parseBitwiseORExpression;
+ extra.parseBitwiseXORExpression = parseBitwiseXORExpression;
+ extra.parseBlock = parseBlock;
+ extra.parseFunctionSourceElements = parseFunctionSourceElements;
+ extra.parseCatchClause = parseCatchClause;
+ extra.parseComputedMember = parseComputedMember;
+ extra.parseConditionalExpression = parseConditionalExpression;
+ extra.parseConstLetDeclaration = parseConstLetDeclaration;
+ extra.parseEqualityExpression = parseEqualityExpression;
+ extra.parseExpression = parseExpression;
+ extra.parseForVariableDeclaration = parseForVariableDeclaration;
+ extra.parseFunctionDeclaration = parseFunctionDeclaration;
+ extra.parseFunctionExpression = parseFunctionExpression;
+ extra.parseLogicalANDExpression = parseLogicalANDExpression;
+ extra.parseLogicalORExpression = parseLogicalORExpression;
+ extra.parseMultiplicativeExpression = parseMultiplicativeExpression;
+ extra.parseNewExpression = parseNewExpression;
+ extra.parseNonComputedProperty = parseNonComputedProperty;
+ extra.parseObjectProperty = parseObjectProperty;
+ extra.parseObjectPropertyKey = parseObjectPropertyKey;
+ extra.parsePostfixExpression = parsePostfixExpression;
+ extra.parsePrimaryExpression = parsePrimaryExpression;
+ extra.parseProgram = parseProgram;
+ extra.parsePropertyFunction = parsePropertyFunction;
+ extra.parseRelationalExpression = parseRelationalExpression;
+ extra.parseStatement = parseStatement;
+ extra.parseShiftExpression = parseShiftExpression;
+ extra.parseSwitchCase = parseSwitchCase;
+ extra.parseUnaryExpression = parseUnaryExpression;
+ extra.parseVariableDeclaration = parseVariableDeclaration;
+ extra.parseVariableIdentifier = parseVariableIdentifier;
+
+ parseAdditiveExpression = wrapTracking(extra.parseAdditiveExpression);
+ parseAssignmentExpression = wrapTracking(extra.parseAssignmentExpression);
+ parseBitwiseANDExpression = wrapTracking(extra.parseBitwiseANDExpression);
+ parseBitwiseORExpression = wrapTracking(extra.parseBitwiseORExpression);
+ parseBitwiseXORExpression = wrapTracking(extra.parseBitwiseXORExpression);
+ parseBlock = wrapTracking(extra.parseBlock);
+ parseFunctionSourceElements = wrapTracking(extra.parseFunctionSourceElements);
+ parseCatchClause = wrapTracking(extra.parseCatchClause);
+ parseComputedMember = wrapTracking(extra.parseComputedMember);
+ parseConditionalExpression = wrapTracking(extra.parseConditionalExpression);
+ parseConstLetDeclaration = wrapTracking(extra.parseConstLetDeclaration);
+ parseEqualityExpression = wrapTracking(extra.parseEqualityExpression);
+ parseExpression = wrapTracking(extra.parseExpression);
+ parseForVariableDeclaration = wrapTracking(extra.parseForVariableDeclaration);
+ parseFunctionDeclaration = wrapTracking(extra.parseFunctionDeclaration);
+ parseFunctionExpression = wrapTracking(extra.parseFunctionExpression);
+ parseLeftHandSideExpression = wrapTracking(parseLeftHandSideExpression);
+ parseLogicalANDExpression = wrapTracking(extra.parseLogicalANDExpression);
+ parseLogicalORExpression = wrapTracking(extra.parseLogicalORExpression);
+ parseMultiplicativeExpression = wrapTracking(extra.parseMultiplicativeExpression);
+ parseNewExpression = wrapTracking(extra.parseNewExpression);
+ parseNonComputedProperty = wrapTracking(extra.parseNonComputedProperty);
+ parseObjectProperty = wrapTracking(extra.parseObjectProperty);
+ parseObjectPropertyKey = wrapTracking(extra.parseObjectPropertyKey);
+ parsePostfixExpression = wrapTracking(extra.parsePostfixExpression);
+ parsePrimaryExpression = wrapTracking(extra.parsePrimaryExpression);
+ parseProgram = wrapTracking(extra.parseProgram);
+ parsePropertyFunction = wrapTracking(extra.parsePropertyFunction);
+ parseRelationalExpression = wrapTracking(extra.parseRelationalExpression);
+ parseStatement = wrapTracking(extra.parseStatement);
+ parseShiftExpression = wrapTracking(extra.parseShiftExpression);
+ parseSwitchCase = wrapTracking(extra.parseSwitchCase);
+ parseUnaryExpression = wrapTracking(extra.parseUnaryExpression);
+ parseVariableDeclaration = wrapTracking(extra.parseVariableDeclaration);
+ parseVariableIdentifier = wrapTracking(extra.parseVariableIdentifier);
+ }
+
+ if (typeof extra.tokens !== 'undefined') {
+ extra.advance = advance;
+ extra.scanRegExp = scanRegExp;
+
+ advance = collectToken;
+ scanRegExp = collectRegex;
+ }
+ }
+
+ function unpatch() {
+ if (typeof extra.skipComment === 'function') {
+ skipComment = extra.skipComment;
+ }
+
+ if (extra.raw) {
+ createLiteral = extra.createLiteral;
+ }
+
+ if (extra.range || extra.loc) {
+ parseAdditiveExpression = extra.parseAdditiveExpression;
+ parseAssignmentExpression = extra.parseAssignmentExpression;
+ parseBitwiseANDExpression = extra.parseBitwiseANDExpression;
+ parseBitwiseORExpression = extra.parseBitwiseORExpression;
+ parseBitwiseXORExpression = extra.parseBitwiseXORExpression;
+ parseBlock = extra.parseBlock;
+ parseFunctionSourceElements = extra.parseFunctionSourceElements;
+ parseCatchClause = extra.parseCatchClause;
+ parseComputedMember = extra.parseComputedMember;
+ parseConditionalExpression = extra.parseConditionalExpression;
+ parseConstLetDeclaration = extra.parseConstLetDeclaration;
+ parseEqualityExpression = extra.parseEqualityExpression;
+ parseExpression = extra.parseExpression;
+ parseForVariableDeclaration = extra.parseForVariableDeclaration;
+ parseFunctionDeclaration = extra.parseFunctionDeclaration;
+ parseFunctionExpression = extra.parseFunctionExpression;
+ parseGroupExpression = extra.parseGroupExpression;
+ parseLeftHandSideExpression = extra.parseLeftHandSideExpression;
+ parseLeftHandSideExpressionAllowCall = extra.parseLeftHandSideExpressionAllowCall;
+ parseLogicalANDExpression = extra.parseLogicalANDExpression;
+ parseLogicalORExpression = extra.parseLogicalORExpression;
+ parseMultiplicativeExpression = extra.parseMultiplicativeExpression;
+ parseNewExpression = extra.parseNewExpression;
+ parseNonComputedProperty = extra.parseNonComputedProperty;
+ parseObjectProperty = extra.parseObjectProperty;
+ parseObjectPropertyKey = extra.parseObjectPropertyKey;
+ parsePrimaryExpression = extra.parsePrimaryExpression;
+ parsePostfixExpression = extra.parsePostfixExpression;
+ parseProgram = extra.parseProgram;
+ parsePropertyFunction = extra.parsePropertyFunction;
+ parseRelationalExpression = extra.parseRelationalExpression;
+ parseStatement = extra.parseStatement;
+ parseShiftExpression = extra.parseShiftExpression;
+ parseSwitchCase = extra.parseSwitchCase;
+ parseUnaryExpression = extra.parseUnaryExpression;
+ parseVariableDeclaration = extra.parseVariableDeclaration;
+ parseVariableIdentifier = extra.parseVariableIdentifier;
+ }
+
+ if (typeof extra.scanRegExp === 'function') {
+ advance = extra.advance;
+ scanRegExp = extra.scanRegExp;
+ }
+ }
+
+ function stringToArray(str) {
+ var length = str.length,
+ result = [],
+ i;
+ for (i = 0; i < length; ++i) {
+ result[i] = str.charAt(i);
+ }
+ return result;
+ }
+
+ function parse(code, options) {
+ var program, toString;
+
+ toString = String;
+ if (typeof code !== 'string' && !(code instanceof String)) {
+ code = toString(code);
+ }
+
+ source = code;
+ index = 0;
+ lineNumber = (source.length > 0) ? 1 : 0;
+ lineStart = 0;
+ length = source.length;
+ buffer = null;
+ state = {
+ allowIn: true,
+ labelSet: {},
+ inFunctionBody: false,
+ inIteration: false,
+ inSwitch: false
+ };
+
+ extra = {};
+ if (typeof options !== 'undefined') {
+ extra.range = (typeof options.range === 'boolean') && options.range;
+ extra.loc = (typeof options.loc === 'boolean') && options.loc;
+ extra.raw = (typeof options.raw === 'boolean') && options.raw;
+ if (typeof options.tokens === 'boolean' && options.tokens) {
+ extra.tokens = [];
+ }
+ if (typeof options.comment === 'boolean' && options.comment) {
+ extra.comments = [];
+ }
+ if (typeof options.tolerant === 'boolean' && options.tolerant) {
+ extra.errors = [];
+ }
+ }
+
+ if (length > 0) {
+ if (typeof source[0] === 'undefined') {
+ // Try first to convert to a string. This is good as fast path
+ // for old IE which understands string indexing for string
+ // literals only and not for string object.
+ if (code instanceof String) {
+ source = code.valueOf();
+ }
+
+ // Force accessing the characters via an array.
+ if (typeof source[0] === 'undefined') {
+ source = stringToArray(code);
+ }
+ }
+ }
+
+ patch();
+ try {
+ program = parseProgram();
+ if (typeof extra.comments !== 'undefined') {
+ filterCommentLocation();
+ program.comments = extra.comments;
+ }
+ if (typeof extra.tokens !== 'undefined') {
+ filterTokenLocation();
+ program.tokens = extra.tokens;
+ }
+ if (typeof extra.errors !== 'undefined') {
+ program.errors = extra.errors;
+ }
+ if (extra.range || extra.loc) {
+ program.body = filterGroup(program.body);
+ }
+ } catch (e) {
+ throw e;
+ } finally {
+ unpatch();
+ extra = {};
+ }
+
+ return program;
+ }
+
+ // Sync with package.json.
+ exports.version = '1.0.4';
+
+ exports.parse = parse;
+
+ // Deep copy.
+ exports.Syntax = (function () {
+ var name, types = {};
+
+ if (typeof Object.create === 'function') {
+ types = Object.create(null);
+ }
+
+ for (name in Syntax) {
+ if (Syntax.hasOwnProperty(name)) {
+ types[name] = Syntax[name];
+ }
+ }
+
+ if (typeof Object.freeze === 'function') {
+ Object.freeze(types);
+ }
+
+ return types;
+ }());
+
+}));
+/* vim: set sw=4 ts=4 et tw=80 : */
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/esprima/package.json b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/esprima/package.json
new file mode 100644
index 0000000..2889ca3
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/esprima/package.json
@@ -0,0 +1,69 @@
+{
+ "name": "esprima",
+ "description": "ECMAScript parsing infrastructure for multipurpose analysis",
+ "homepage": "http://esprima.org",
+ "main": "esprima.js",
+ "bin": {
+ "esparse": "./bin/esparse.js",
+ "esvalidate": "./bin/esvalidate.js"
+ },
+ "files": [
+ "bin",
+ "test/run.js",
+ "test/runner.js",
+ "test/test.js",
+ "test/compat.js",
+ "test/reflect.js",
+ "esprima.js"
+ ],
+ "version": "1.0.4",
+ "engines": {
+ "node": ">=0.4.0"
+ },
+ "maintainers": [
+ {
+ "name": "ariya",
+ "email": "ariya.hidayat@gmail.com"
+ }
+ ],
+ "repository": {
+ "type": "git",
+ "url": "http://github.com/ariya/esprima.git"
+ },
+ "licenses": [
+ {
+ "type": "BSD",
+ "url": "http://github.com/ariya/esprima/raw/master/LICENSE.BSD"
+ }
+ ],
+ "keywords": [
+ "ast",
+ "ecmascript",
+ "javascript",
+ "parser",
+ "syntax"
+ ],
+ "scripts": {
+ "test": "node test/run.js",
+ "benchmark": "node test/benchmarks.js",
+ "benchmark-quick": "node test/benchmarks.js quick"
+ },
+ "_id": "esprima@1.0.4",
+ "dist": {
+ "shasum": "9f557e08fc3b4d26ece9dd34f8fbf476b62585ad",
+ "tarball": "http://registry.npmjs.org/esprima/-/esprima-1.0.4.tgz"
+ },
+ "_npmVersion": "1.1.61",
+ "_npmUser": {
+ "name": "ariya",
+ "email": "ariya.hidayat@gmail.com"
+ },
+ "directories": {},
+ "_shasum": "9f557e08fc3b4d26ece9dd34f8fbf476b62585ad",
+ "_from": "esprima@~ 1.0.2",
+ "_resolved": "https://registry.npmjs.org/esprima/-/esprima-1.0.4.tgz",
+ "bugs": {
+ "url": "https://github.com/ariya/esprima/issues"
+ },
+ "readme": "ERROR: No README data found!"
+}
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/esprima/test/compat.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/esprima/test/compat.js
new file mode 100644
index 0000000..ee3a629
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/esprima/test/compat.js
@@ -0,0 +1,239 @@
+/*
+ Copyright (C) 2012 Joost-Wim Boekesteijn
+ Copyright (C) 2011 Ariya Hidayat
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ ARE DISCLAIMED. IN NO EVENT SHALL BE LIABLE FOR ANY
+ DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+/*jslint node: true */
+/*global document: true, window:true, esprima: true, testReflect: true */
+
+var runTests;
+
+function getContext(esprima, reportCase, reportFailure) {
+ 'use strict';
+
+ var Reflect, Pattern;
+
+ // Maps Mozilla Reflect object to our Esprima parser.
+ Reflect = {
+ parse: function (code) {
+ var result;
+
+ reportCase(code);
+
+ try {
+ result = esprima.parse(code);
+ } catch (error) {
+ result = error;
+ }
+
+ return result;
+ }
+ };
+
+ // This is used by Reflect test suite to match a syntax tree.
+ Pattern = function (obj) {
+ var pattern;
+
+ // Poor man's deep object cloning.
+ pattern = JSON.parse(JSON.stringify(obj));
+
+ // Special handling for regular expression literal since we need to
+ // convert it to a string literal, otherwise it will be decoded
+ // as object "{}" and the regular expression would be lost.
+ if (obj.type && obj.type === 'Literal') {
+ if (obj.value instanceof RegExp) {
+ pattern = {
+ type: obj.type,
+ value: obj.value.toString()
+ };
+ }
+ }
+
+ // Special handling for branch statement because SpiderMonkey
+ // prefers to put the 'alternate' property before 'consequent'.
+ if (obj.type && obj.type === 'IfStatement') {
+ pattern = {
+ type: pattern.type,
+ test: pattern.test,
+ consequent: pattern.consequent,
+ alternate: pattern.alternate
+ };
+ }
+
+ // Special handling for do while statement because SpiderMonkey
+ // prefers to put the 'test' property before 'body'.
+ if (obj.type && obj.type === 'DoWhileStatement') {
+ pattern = {
+ type: pattern.type,
+ body: pattern.body,
+ test: pattern.test
+ };
+ }
+
+ function adjustRegexLiteralAndRaw(key, value) {
+ if (key === 'value' && value instanceof RegExp) {
+ value = value.toString();
+ } else if (key === 'raw' && typeof value === "string") {
+ // Ignore Esprima-specific 'raw' property.
+ return undefined;
+ }
+ return value;
+ }
+
+ if (obj.type && (obj.type === 'Program')) {
+ pattern.assert = function (tree) {
+ var actual, expected;
+ actual = JSON.stringify(tree, adjustRegexLiteralAndRaw, 4);
+ expected = JSON.stringify(obj, null, 4);
+
+ if (expected !== actual) {
+ reportFailure(expected, actual);
+ }
+ };
+ }
+
+ return pattern;
+ };
+
+ return {
+ Reflect: Reflect,
+ Pattern: Pattern
+ };
+}
+
+if (typeof window !== 'undefined') {
+ // Run all tests in a browser environment.
+ runTests = function () {
+ 'use strict';
+
+ var total = 0,
+ failures = 0;
+
+ function setText(el, str) {
+ if (typeof el.innerText === 'string') {
+ el.innerText = str;
+ } else {
+ el.textContent = str;
+ }
+ }
+
+ function reportCase(code) {
+ var report, e;
+ report = document.getElementById('report');
+ e = document.createElement('pre');
+ e.setAttribute('class', 'code');
+ setText(e, code);
+ report.appendChild(e);
+ total += 1;
+ }
+
+ function reportFailure(expected, actual) {
+ var report, e;
+
+ failures += 1;
+
+ report = document.getElementById('report');
+
+ e = document.createElement('p');
+ setText(e, 'Expected');
+ report.appendChild(e);
+
+ e = document.createElement('pre');
+ e.setAttribute('class', 'expected');
+ setText(e, expected);
+ report.appendChild(e);
+
+ e = document.createElement('p');
+ setText(e, 'Actual');
+ report.appendChild(e);
+
+ e = document.createElement('pre');
+ e.setAttribute('class', 'actual');
+ setText(e, actual);
+ report.appendChild(e);
+ }
+
+ setText(document.getElementById('version'), esprima.version);
+
+ window.setTimeout(function () {
+ var tick, context = getContext(esprima, reportCase, reportFailure);
+
+ tick = new Date();
+ testReflect(context.Reflect, context.Pattern);
+ tick = (new Date()) - tick;
+
+ if (failures > 0) {
+ setText(document.getElementById('status'), total + ' tests. ' +
+ 'Failures: ' + failures + '. ' + tick + ' ms');
+ } else {
+ setText(document.getElementById('status'), total + ' tests. ' +
+ 'No failure. ' + tick + ' ms');
+ }
+ }, 513);
+ };
+} else {
+ (function (global) {
+ 'use strict';
+ var esprima = require('../esprima'),
+ tick,
+ total = 0,
+ failures = [],
+ header,
+ current,
+ context;
+
+ function reportCase(code) {
+ total += 1;
+ current = code;
+ }
+
+ function reportFailure(expected, actual) {
+ failures.push({
+ source: current,
+ expected: expected.toString(),
+ actual: actual.toString()
+ });
+ }
+
+ context = getContext(esprima, reportCase, reportFailure);
+
+ tick = new Date();
+ require('./reflect').testReflect(context.Reflect, context.Pattern);
+ tick = (new Date()) - tick;
+
+ header = total + ' tests. ' + failures.length + ' failures. ' +
+ tick + ' ms';
+ if (failures.length) {
+ console.error(header);
+ failures.forEach(function (failure) {
+ console.error(failure.source + ': Expected\n ' +
+ failure.expected.split('\n').join('\n ') +
+ '\nto match\n ' + failure.actual);
+ });
+ } else {
+ console.log(header);
+ }
+ process.exit(failures.length === 0 ? 0 : 1);
+ }(this));
+}
+/* vim: set sw=4 ts=4 et tw=80 : */
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/esprima/test/reflect.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/esprima/test/reflect.js
new file mode 100644
index 0000000..dba1ba8
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/esprima/test/reflect.js
@@ -0,0 +1,422 @@
+// This is modified from Mozilla Reflect.parse test suite (the file is located
+// at js/src/tests/js1_8_5/extensions/reflect-parse.js in the source tree).
+//
+// Some notable changes:
+// * Removed unsupported features (destructuring, let, comprehensions...).
+// * Removed tests for E4X (ECMAScript for XML).
+// * Removed everything related to builder.
+// * Enclosed every 'Pattern' construct with a scope.
+// * Tweaked some expected tree to remove generator field.
+// * Removed the test for bug 632030 and bug 632024.
+
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/licenses/publicdomain/
+ */
+
+(function (exports) {
+
+function testReflect(Reflect, Pattern) {
+
+function program(elts) { return Pattern({ type: "Program", body: elts }) }
+function exprStmt(expr) { return Pattern({ type: "ExpressionStatement", expression: expr }) }
+function throwStmt(expr) { return Pattern({ type: "ThrowStatement", argument: expr }) }
+function returnStmt(expr) { return Pattern({ type: "ReturnStatement", argument: expr }) }
+function yieldExpr(expr) { return Pattern({ type: "YieldExpression", argument: expr }) }
+function lit(val) { return Pattern({ type: "Literal", value: val }) }
+var thisExpr = Pattern({ type: "ThisExpression" });
+function funDecl(id, params, body) { return Pattern({ type: "FunctionDeclaration",
+ id: id,
+ params: params,
+ defaults: [],
+ body: body,
+ rest: null,
+ generator: false,
+ expression: false
+ }) }
+function genFunDecl(id, params, body) { return Pattern({ type: "FunctionDeclaration",
+ id: id,
+ params: params,
+ defaults: [],
+ body: body,
+ rest: null,
+ generator: false,
+ expression: false
+ }) }
+function declarator(id, init) { return Pattern({ type: "VariableDeclarator", id: id, init: init }) }
+function varDecl(decls) { return Pattern({ type: "VariableDeclaration", declarations: decls, kind: "var" }) }
+function letDecl(decls) { return Pattern({ type: "VariableDeclaration", declarations: decls, kind: "let" }) }
+function constDecl(decls) { return Pattern({ type: "VariableDeclaration", declarations: decls, kind: "const" }) }
+function ident(name) { return Pattern({ type: "Identifier", name: name }) }
+function dotExpr(obj, id) { return Pattern({ type: "MemberExpression", computed: false, object: obj, property: id }) }
+function memExpr(obj, id) { return Pattern({ type: "MemberExpression", computed: true, object: obj, property: id }) }
+function forStmt(init, test, update, body) { return Pattern({ type: "ForStatement", init: init, test: test, update: update, body: body }) }
+function forInStmt(lhs, rhs, body) { return Pattern({ type: "ForInStatement", left: lhs, right: rhs, body: body, each: false }) }
+function forEachInStmt(lhs, rhs, body) { return Pattern({ type: "ForInStatement", left: lhs, right: rhs, body: body, each: true }) }
+function breakStmt(lab) { return Pattern({ type: "BreakStatement", label: lab }) }
+function continueStmt(lab) { return Pattern({ type: "ContinueStatement", label: lab }) }
+function blockStmt(body) { return Pattern({ type: "BlockStatement", body: body }) }
+var emptyStmt = Pattern({ type: "EmptyStatement" });
+function ifStmt(test, cons, alt) { return Pattern({ type: "IfStatement", test: test, alternate: alt, consequent: cons }) }
+function labStmt(lab, stmt) { return Pattern({ type: "LabeledStatement", label: lab, body: stmt }) }
+function withStmt(obj, stmt) { return Pattern({ type: "WithStatement", object: obj, body: stmt }) }
+function whileStmt(test, stmt) { return Pattern({ type: "WhileStatement", test: test, body: stmt }) }
+function doStmt(stmt, test) { return Pattern({ type: "DoWhileStatement", test: test, body: stmt }) }
+function switchStmt(disc, cases) { return Pattern({ type: "SwitchStatement", discriminant: disc, cases: cases }) }
+function caseClause(test, stmts) { return Pattern({ type: "SwitchCase", test: test, consequent: stmts }) }
+function defaultClause(stmts) { return Pattern({ type: "SwitchCase", test: null, consequent: stmts }) }
+function catchClause(id, guard, body) { if (guard) { return Pattern({ type: "GuardedCatchClause", param: id, guard: guard, body: body }) } else { return Pattern({ type: "CatchClause", param: id, body: body }) } }
+function tryStmt(body, guarded, catches, fin) { return Pattern({ type: "TryStatement", block: body, guardedHandlers: guarded, handlers: catches, finalizer: fin }) }
+function letStmt(head, body) { return Pattern({ type: "LetStatement", head: head, body: body }) }
+function funExpr(id, args, body, gen) { return Pattern({ type: "FunctionExpression",
+ id: id,
+ params: args,
+ defaults: [],
+ body: body,
+ rest: null,
+ generator: false,
+ expression: false
+ }) }
+function genFunExpr(id, args, body) { return Pattern({ type: "FunctionExpression",
+ id: id,
+ params: args,
+ defaults: [],
+ body: body,
+ rest: null,
+ generator: false,
+ expression: false
+ }) }
+
+function unExpr(op, arg) { return Pattern({ type: "UnaryExpression", operator: op, argument: arg, prefix: true }) }
+function binExpr(op, left, right) { return Pattern({ type: "BinaryExpression", operator: op, left: left, right: right }) }
+function aExpr(op, left, right) { return Pattern({ type: "AssignmentExpression", operator: op, left: left, right: right }) }
+function updExpr(op, arg, prefix) { return Pattern({ type: "UpdateExpression", operator: op, argument: arg, prefix: prefix }) }
+function logExpr(op, left, right) { return Pattern({ type: "LogicalExpression", operator: op, left: left, right: right }) }
+
+function condExpr(test, cons, alt) { return Pattern({ type: "ConditionalExpression", test: test, consequent: cons, alternate: alt }) }
+function seqExpr(exprs) { return Pattern({ type: "SequenceExpression", expressions: exprs }) }
+function newExpr(callee, args) { return Pattern({ type: "NewExpression", callee: callee, arguments: args }) }
+function callExpr(callee, args) { return Pattern({ type: "CallExpression", callee: callee, arguments: args }) }
+function arrExpr(elts) { return Pattern({ type: "ArrayExpression", elements: elts }) }
+function objExpr(elts) { return Pattern({ type: "ObjectExpression", properties: elts }) }
+function objProp(key, value, kind) { return Pattern({ type: "Property", key: key, value: value, kind: kind }) }
+
+function arrPatt(elts) { return Pattern({ type: "ArrayPattern", elements: elts }) }
+function objPatt(elts) { return Pattern({ type: "ObjectPattern", properties: elts }) }
+
+function localSrc(src) { return "(function(){ " + src + " })" }
+function localPatt(patt) { return program([exprStmt(funExpr(null, [], blockStmt([patt])))]) }
+function blockSrc(src) { return "(function(){ { " + src + " } })" }
+function blockPatt(patt) { return program([exprStmt(funExpr(null, [], blockStmt([blockStmt([patt])])))]) }
+
+function assertBlockStmt(src, patt) {
+ blockPatt(patt).assert(Reflect.parse(blockSrc(src)));
+}
+
+function assertBlockExpr(src, patt) {
+ assertBlockStmt(src, exprStmt(patt));
+}
+
+function assertBlockDecl(src, patt, builder) {
+ blockPatt(patt).assert(Reflect.parse(blockSrc(src), {builder: builder}));
+}
+
+function assertLocalStmt(src, patt) {
+ localPatt(patt).assert(Reflect.parse(localSrc(src)));
+}
+
+function assertLocalExpr(src, patt) {
+ assertLocalStmt(src, exprStmt(patt));
+}
+
+function assertLocalDecl(src, patt) {
+ localPatt(patt).assert(Reflect.parse(localSrc(src)));
+}
+
+function assertGlobalStmt(src, patt, builder) {
+ program([patt]).assert(Reflect.parse(src, {builder: builder}));
+}
+
+function assertGlobalExpr(src, patt, builder) {
+ program([exprStmt(patt)]).assert(Reflect.parse(src, {builder: builder}));
+ //assertStmt(src, exprStmt(patt));
+}
+
+function assertGlobalDecl(src, patt) {
+ program([patt]).assert(Reflect.parse(src));
+}
+
+function assertProg(src, patt) {
+ program(patt).assert(Reflect.parse(src));
+}
+
+function assertStmt(src, patt) {
+ assertLocalStmt(src, patt);
+ assertGlobalStmt(src, patt);
+ assertBlockStmt(src, patt);
+}
+
+function assertExpr(src, patt) {
+ assertLocalExpr(src, patt);
+ assertGlobalExpr(src, patt);
+ assertBlockExpr(src, patt);
+}
+
+function assertDecl(src, patt) {
+ assertLocalDecl(src, patt);
+ assertGlobalDecl(src, patt);
+ assertBlockDecl(src, patt);
+}
+
+function assertError(src, errorType) {
+ try {
+ Reflect.parse(src);
+ } catch (e) {
+ return;
+ }
+ throw new Error("expected " + errorType.name + " for " + uneval(src));
+}
+
+
+// general tests
+
+// NB: These are useful but for now jit-test doesn't do I/O reliably.
+
+//program(_).assert(Reflect.parse(snarf('data/flapjax.txt')));
+//program(_).assert(Reflect.parse(snarf('data/jquery-1.4.2.txt')));
+//program(_).assert(Reflect.parse(snarf('data/prototype.js')));
+//program(_).assert(Reflect.parse(snarf('data/dojo.js.uncompressed.js')));
+//program(_).assert(Reflect.parse(snarf('data/mootools-1.2.4-core-nc.js')));
+
+
+// declarations
+
+assertDecl("var x = 1, y = 2, z = 3",
+ varDecl([declarator(ident("x"), lit(1)),
+ declarator(ident("y"), lit(2)),
+ declarator(ident("z"), lit(3))]));
+assertDecl("var x, y, z",
+ varDecl([declarator(ident("x"), null),
+ declarator(ident("y"), null),
+ declarator(ident("z"), null)]));
+assertDecl("function foo() { }",
+ funDecl(ident("foo"), [], blockStmt([])));
+assertDecl("function foo() { return 42 }",
+ funDecl(ident("foo"), [], blockStmt([returnStmt(lit(42))])));
+
+
+// Bug 591437: rebound args have their defs turned into uses
+assertDecl("function f(a) { function a() { } }",
+ funDecl(ident("f"), [ident("a")], blockStmt([funDecl(ident("a"), [], blockStmt([]))])));
+assertDecl("function f(a,b,c) { function b() { } }",
+ funDecl(ident("f"), [ident("a"),ident("b"),ident("c")], blockStmt([funDecl(ident("b"), [], blockStmt([]))])));
+
+// expressions
+
+assertExpr("true", lit(true));
+assertExpr("false", lit(false));
+assertExpr("42", lit(42));
+assertExpr("(/asdf/)", lit(/asdf/));
+assertExpr("this", thisExpr);
+assertExpr("foo", ident("foo"));
+assertExpr("foo.bar", dotExpr(ident("foo"), ident("bar")));
+assertExpr("foo[bar]", memExpr(ident("foo"), ident("bar")));
+assertExpr("(function(){})", funExpr(null, [], blockStmt([])));
+assertExpr("(function f() {})", funExpr(ident("f"), [], blockStmt([])));
+assertExpr("(function f(x,y,z) {})", funExpr(ident("f"), [ident("x"),ident("y"),ident("z")], blockStmt([])));
+assertExpr("(++x)", updExpr("++", ident("x"), true));
+assertExpr("(x++)", updExpr("++", ident("x"), false));
+assertExpr("(+x)", unExpr("+", ident("x")));
+assertExpr("(-x)", unExpr("-", ident("x")));
+assertExpr("(!x)", unExpr("!", ident("x")));
+assertExpr("(~x)", unExpr("~", ident("x")));
+assertExpr("(delete x)", unExpr("delete", ident("x")));
+assertExpr("(typeof x)", unExpr("typeof", ident("x")));
+assertExpr("(void x)", unExpr("void", ident("x")));
+assertExpr("(x == y)", binExpr("==", ident("x"), ident("y")));
+assertExpr("(x != y)", binExpr("!=", ident("x"), ident("y")));
+assertExpr("(x === y)", binExpr("===", ident("x"), ident("y")));
+assertExpr("(x !== y)", binExpr("!==", ident("x"), ident("y")));
+assertExpr("(x < y)", binExpr("<", ident("x"), ident("y")));
+assertExpr("(x <= y)", binExpr("<=", ident("x"), ident("y")));
+assertExpr("(x > y)", binExpr(">", ident("x"), ident("y")));
+assertExpr("(x >= y)", binExpr(">=", ident("x"), ident("y")));
+assertExpr("(x << y)", binExpr("<<", ident("x"), ident("y")));
+assertExpr("(x >> y)", binExpr(">>", ident("x"), ident("y")));
+assertExpr("(x >>> y)", binExpr(">>>", ident("x"), ident("y")));
+assertExpr("(x + y)", binExpr("+", ident("x"), ident("y")));
+assertExpr("(w + x + y + z)", binExpr("+", binExpr("+", binExpr("+", ident("w"), ident("x")), ident("y")), ident("z")));
+assertExpr("(x - y)", binExpr("-", ident("x"), ident("y")));
+assertExpr("(w - x - y - z)", binExpr("-", binExpr("-", binExpr("-", ident("w"), ident("x")), ident("y")), ident("z")));
+assertExpr("(x * y)", binExpr("*", ident("x"), ident("y")));
+assertExpr("(x / y)", binExpr("/", ident("x"), ident("y")));
+assertExpr("(x % y)", binExpr("%", ident("x"), ident("y")));
+assertExpr("(x | y)", binExpr("|", ident("x"), ident("y")));
+assertExpr("(x ^ y)", binExpr("^", ident("x"), ident("y")));
+assertExpr("(x & y)", binExpr("&", ident("x"), ident("y")));
+assertExpr("(x in y)", binExpr("in", ident("x"), ident("y")));
+assertExpr("(x instanceof y)", binExpr("instanceof", ident("x"), ident("y")));
+assertExpr("(x = y)", aExpr("=", ident("x"), ident("y")));
+assertExpr("(x += y)", aExpr("+=", ident("x"), ident("y")));
+assertExpr("(x -= y)", aExpr("-=", ident("x"), ident("y")));
+assertExpr("(x *= y)", aExpr("*=", ident("x"), ident("y")));
+assertExpr("(x /= y)", aExpr("/=", ident("x"), ident("y")));
+assertExpr("(x %= y)", aExpr("%=", ident("x"), ident("y")));
+assertExpr("(x <<= y)", aExpr("<<=", ident("x"), ident("y")));
+assertExpr("(x >>= y)", aExpr(">>=", ident("x"), ident("y")));
+assertExpr("(x >>>= y)", aExpr(">>>=", ident("x"), ident("y")));
+assertExpr("(x |= y)", aExpr("|=", ident("x"), ident("y")));
+assertExpr("(x ^= y)", aExpr("^=", ident("x"), ident("y")));
+assertExpr("(x &= y)", aExpr("&=", ident("x"), ident("y")));
+assertExpr("(x || y)", logExpr("||", ident("x"), ident("y")));
+assertExpr("(x && y)", logExpr("&&", ident("x"), ident("y")));
+assertExpr("(w || x || y || z)", logExpr("||", logExpr("||", logExpr("||", ident("w"), ident("x")), ident("y")), ident("z")))
+assertExpr("(x ? y : z)", condExpr(ident("x"), ident("y"), ident("z")));
+assertExpr("(x,y)", seqExpr([ident("x"),ident("y")]))
+assertExpr("(x,y,z)", seqExpr([ident("x"),ident("y"),ident("z")]))
+assertExpr("(a,b,c,d,e,f,g)", seqExpr([ident("a"),ident("b"),ident("c"),ident("d"),ident("e"),ident("f"),ident("g")]));
+assertExpr("(new Object)", newExpr(ident("Object"), []));
+assertExpr("(new Object())", newExpr(ident("Object"), []));
+assertExpr("(new Object(42))", newExpr(ident("Object"), [lit(42)]));
+assertExpr("(new Object(1,2,3))", newExpr(ident("Object"), [lit(1),lit(2),lit(3)]));
+assertExpr("(String())", callExpr(ident("String"), []));
+assertExpr("(String(42))", callExpr(ident("String"), [lit(42)]));
+assertExpr("(String(1,2,3))", callExpr(ident("String"), [lit(1),lit(2),lit(3)]));
+assertExpr("[]", arrExpr([]));
+assertExpr("[1]", arrExpr([lit(1)]));
+assertExpr("[1,2]", arrExpr([lit(1),lit(2)]));
+assertExpr("[1,2,3]", arrExpr([lit(1),lit(2),lit(3)]));
+assertExpr("[1,,2,3]", arrExpr([lit(1),,lit(2),lit(3)]));
+assertExpr("[1,,,2,3]", arrExpr([lit(1),,,lit(2),lit(3)]));
+assertExpr("[1,,,2,,3]", arrExpr([lit(1),,,lit(2),,lit(3)]));
+assertExpr("[1,,,2,,,3]", arrExpr([lit(1),,,lit(2),,,lit(3)]));
+assertExpr("[,1,2,3]", arrExpr([,lit(1),lit(2),lit(3)]));
+assertExpr("[,,1,2,3]", arrExpr([,,lit(1),lit(2),lit(3)]));
+assertExpr("[,,,1,2,3]", arrExpr([,,,lit(1),lit(2),lit(3)]));
+assertExpr("[,,,1,2,3,]", arrExpr([,,,lit(1),lit(2),lit(3)]));
+assertExpr("[,,,1,2,3,,]", arrExpr([,,,lit(1),lit(2),lit(3),undefined]));
+assertExpr("[,,,1,2,3,,,]", arrExpr([,,,lit(1),lit(2),lit(3),undefined,undefined]));
+assertExpr("[,,,,,]", arrExpr([undefined,undefined,undefined,undefined,undefined]));
+assertExpr("({})", objExpr([]));
+assertExpr("({x:1})", objExpr([objProp(ident("x"), lit(1), "init")]));
+assertExpr("({x:1, y:2})", objExpr([objProp(ident("x"), lit(1), "init"),
+ objProp(ident("y"), lit(2), "init")]));
+assertExpr("({x:1, y:2, z:3})", objExpr([objProp(ident("x"), lit(1), "init"),
+ objProp(ident("y"), lit(2), "init"),
+ objProp(ident("z"), lit(3), "init") ]));
+assertExpr("({x:1, 'y':2, z:3})", objExpr([objProp(ident("x"), lit(1), "init"),
+ objProp(lit("y"), lit(2), "init"),
+ objProp(ident("z"), lit(3), "init") ]));
+assertExpr("({'x':1, 'y':2, z:3})", objExpr([objProp(lit("x"), lit(1), "init"),
+ objProp(lit("y"), lit(2), "init"),
+ objProp(ident("z"), lit(3), "init") ]));
+assertExpr("({'x':1, 'y':2, 3:3})", objExpr([objProp(lit("x"), lit(1), "init"),
+ objProp(lit("y"), lit(2), "init"),
+ objProp(lit(3), lit(3), "init") ]));
+
+// Bug 571617: eliminate constant-folding
+assertExpr("2 + 3", binExpr("+", lit(2), lit(3)));
+
+// Bug 632026: constant-folding
+assertExpr("typeof(0?0:a)", unExpr("typeof", condExpr(lit(0), lit(0), ident("a"))));
+
+// Bug 632056: constant-folding
+program([exprStmt(ident("f")),
+ ifStmt(lit(1),
+ funDecl(ident("f"), [], blockStmt([])),
+ null)]).assert(Reflect.parse("f; if (1) function f(){}"));
+
+// statements
+
+assertStmt("throw 42", throwStmt(lit(42)));
+assertStmt("for (;;) break", forStmt(null, null, null, breakStmt(null)));
+assertStmt("for (x; y; z) break", forStmt(ident("x"), ident("y"), ident("z"), breakStmt(null)));
+assertStmt("for (var x; y; z) break", forStmt(varDecl([declarator(ident("x"), null)]), ident("y"), ident("z"), breakStmt(null)));
+assertStmt("for (var x = 42; y; z) break", forStmt(varDecl([declarator(ident("x"), lit(42))]), ident("y"), ident("z"), breakStmt(null)));
+assertStmt("for (x; ; z) break", forStmt(ident("x"), null, ident("z"), breakStmt(null)));
+assertStmt("for (var x; ; z) break", forStmt(varDecl([declarator(ident("x"), null)]), null, ident("z"), breakStmt(null)));
+assertStmt("for (var x = 42; ; z) break", forStmt(varDecl([declarator(ident("x"), lit(42))]), null, ident("z"), breakStmt(null)));
+assertStmt("for (x; y; ) break", forStmt(ident("x"), ident("y"), null, breakStmt(null)));
+assertStmt("for (var x; y; ) break", forStmt(varDecl([declarator(ident("x"), null)]), ident("y"), null, breakStmt(null)));
+assertStmt("for (var x = 42; y; ) break", forStmt(varDecl([declarator(ident("x"),lit(42))]), ident("y"), null, breakStmt(null)));
+assertStmt("for (var x in y) break", forInStmt(varDecl([declarator(ident("x"),null)]), ident("y"), breakStmt(null)));
+assertStmt("for (x in y) break", forInStmt(ident("x"), ident("y"), breakStmt(null)));
+assertStmt("{ }", blockStmt([]));
+assertStmt("{ throw 1; throw 2; throw 3; }", blockStmt([ throwStmt(lit(1)), throwStmt(lit(2)), throwStmt(lit(3))]));
+assertStmt(";", emptyStmt);
+assertStmt("if (foo) throw 42;", ifStmt(ident("foo"), throwStmt(lit(42)), null));
+assertStmt("if (foo) throw 42; else true;", ifStmt(ident("foo"), throwStmt(lit(42)), exprStmt(lit(true))));
+assertStmt("if (foo) { throw 1; throw 2; throw 3; }",
+ ifStmt(ident("foo"),
+ blockStmt([throwStmt(lit(1)), throwStmt(lit(2)), throwStmt(lit(3))]),
+ null));
+assertStmt("if (foo) { throw 1; throw 2; throw 3; } else true;",
+ ifStmt(ident("foo"),
+ blockStmt([throwStmt(lit(1)), throwStmt(lit(2)), throwStmt(lit(3))]),
+ exprStmt(lit(true))));
+assertStmt("foo: for(;;) break foo;", labStmt(ident("foo"), forStmt(null, null, null, breakStmt(ident("foo")))));
+assertStmt("foo: for(;;) continue foo;", labStmt(ident("foo"), forStmt(null, null, null, continueStmt(ident("foo")))));
+assertStmt("with (obj) { }", withStmt(ident("obj"), blockStmt([])));
+assertStmt("with (obj) { obj; }", withStmt(ident("obj"), blockStmt([exprStmt(ident("obj"))])));
+assertStmt("while (foo) { }", whileStmt(ident("foo"), blockStmt([])));
+assertStmt("while (foo) { foo; }", whileStmt(ident("foo"), blockStmt([exprStmt(ident("foo"))])));
+assertStmt("do { } while (foo);", doStmt(blockStmt([]), ident("foo")));
+assertStmt("do { foo; } while (foo)", doStmt(blockStmt([exprStmt(ident("foo"))]), ident("foo")));
+assertStmt("switch (foo) { case 1: 1; break; case 2: 2; break; default: 3; }",
+ switchStmt(ident("foo"),
+ [ caseClause(lit(1), [ exprStmt(lit(1)), breakStmt(null) ]),
+ caseClause(lit(2), [ exprStmt(lit(2)), breakStmt(null) ]),
+ defaultClause([ exprStmt(lit(3)) ]) ]));
+assertStmt("switch (foo) { case 1: 1; break; case 2: 2; break; default: 3; case 42: 42; }",
+ switchStmt(ident("foo"),
+ [ caseClause(lit(1), [ exprStmt(lit(1)), breakStmt(null) ]),
+ caseClause(lit(2), [ exprStmt(lit(2)), breakStmt(null) ]),
+ defaultClause([ exprStmt(lit(3)) ]),
+ caseClause(lit(42), [ exprStmt(lit(42)) ]) ]));
+assertStmt("try { } catch (e) { }",
+ tryStmt(blockStmt([]),
+ [],
+ [ catchClause(ident("e"), null, blockStmt([])) ],
+ null));
+assertStmt("try { } catch (e) { } finally { }",
+ tryStmt(blockStmt([]),
+ [],
+ [ catchClause(ident("e"), null, blockStmt([])) ],
+ blockStmt([])));
+assertStmt("try { } finally { }",
+ tryStmt(blockStmt([]),
+ [],
+ [],
+ blockStmt([])));
+
+// redeclarations (TOK_NAME nodes with lexdef)
+
+assertStmt("function f() { function g() { } function g() { } }",
+ funDecl(ident("f"), [], blockStmt([funDecl(ident("g"), [], blockStmt([])),
+ funDecl(ident("g"), [], blockStmt([]))])));
+
+assertStmt("function f() { function g() { } function g() { return 42 } }",
+ funDecl(ident("f"), [], blockStmt([funDecl(ident("g"), [], blockStmt([])),
+ funDecl(ident("g"), [], blockStmt([returnStmt(lit(42))]))])));
+
+assertStmt("function f() { var x = 42; var x = 43; }",
+ funDecl(ident("f"), [], blockStmt([varDecl([declarator(ident("x"),lit(42))]),
+ varDecl([declarator(ident("x"),lit(43))])])));
+
+// getters and setters
+
+ assertExpr("({ get x() { return 42 } })",
+ objExpr([ objProp(ident("x"),
+ funExpr(null, [], blockStmt([returnStmt(lit(42))])),
+ "get" ) ]));
+ assertExpr("({ set x(v) { return 42 } })",
+ objExpr([ objProp(ident("x"),
+ funExpr(null, [ident("v")], blockStmt([returnStmt(lit(42))])),
+ "set" ) ]));
+
+}
+
+exports.testReflect = testReflect;
+
+}(typeof exports === 'undefined' ? this : exports));
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/esprima/test/run.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/esprima/test/run.js
new file mode 100644
index 0000000..32ca3fa
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/esprima/test/run.js
@@ -0,0 +1,66 @@
+/*
+ Copyright (C) 2012 Yusuke Suzuki
+ Copyright (C) 2012 Ariya Hidayat
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ ARE DISCLAIMED. IN NO EVENT SHALL BE LIABLE FOR ANY
+ DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+/*jslint node:true */
+
+(function () {
+ 'use strict';
+
+ var child = require('child_process'),
+ nodejs = '"' + process.execPath + '"',
+ ret = 0,
+ suites,
+ index;
+
+ suites = [
+ 'runner',
+ 'compat'
+ ];
+
+ function nextTest() {
+ var suite = suites[index];
+
+ if (index < suites.length) {
+ child.exec(nodejs + ' ./test/' + suite + '.js', function (err, stdout, stderr) {
+ if (stdout) {
+ process.stdout.write(suite + ': ' + stdout);
+ }
+ if (stderr) {
+ process.stderr.write(suite + ': ' + stderr);
+ }
+ if (err) {
+ ret = err.code;
+ }
+ index += 1;
+ nextTest();
+ });
+ } else {
+ process.exit(ret);
+ }
+ }
+
+ index = 0;
+ nextTest();
+}());
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/esprima/test/runner.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/esprima/test/runner.js
new file mode 100644
index 0000000..c1a3fc9
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/esprima/test/runner.js
@@ -0,0 +1,387 @@
+/*
+ Copyright (C) 2012 Ariya Hidayat
+ Copyright (C) 2012 Joost-Wim Boekesteijn
+ Copyright (C) 2012 Yusuke Suzuki
+ Copyright (C) 2012 Arpad Borsos
+ Copyright (C) 2011 Ariya Hidayat
+ Copyright (C) 2011 Yusuke Suzuki
+ Copyright (C) 2011 Arpad Borsos
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ ARE DISCLAIMED. IN NO EVENT SHALL BE LIABLE FOR ANY
+ DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+/*jslint browser:true node:true */
+/*global esprima:true, testFixture:true */
+
+var runTests;
+
+// Special handling for regular expression literal since we need to
+// convert it to a string literal, otherwise it will be decoded
+// as object "{}" and the regular expression would be lost.
+function adjustRegexLiteral(key, value) {
+ 'use strict';
+ if (key === 'value' && value instanceof RegExp) {
+ value = value.toString();
+ }
+ return value;
+}
+
+function NotMatchingError(expected, actual) {
+ 'use strict';
+ Error.call(this, 'Expected ');
+ this.expected = expected;
+ this.actual = actual;
+}
+NotMatchingError.prototype = new Error();
+
+function errorToObject(e) {
+ 'use strict';
+ var msg = e.toString();
+
+ // Opera 9.64 produces an non-standard string in toString().
+ if (msg.substr(0, 6) !== 'Error:') {
+ if (typeof e.message === 'string') {
+ msg = 'Error: ' + e.message;
+ }
+ }
+
+ return {
+ index: e.index,
+ lineNumber: e.lineNumber,
+ column: e.column,
+ message: msg
+ };
+}
+
+function testParse(esprima, code, syntax) {
+ 'use strict';
+ var expected, tree, actual, options, StringObject, i, len, err;
+
+ // alias, so that JSLint does not complain.
+ StringObject = String;
+
+ options = {
+ comment: (typeof syntax.comments !== 'undefined'),
+ range: true,
+ loc: true,
+ tokens: (typeof syntax.tokens !== 'undefined'),
+ raw: true,
+ tolerant: (typeof syntax.errors !== 'undefined')
+ };
+
+ if (typeof syntax.tokens !== 'undefined') {
+ if (syntax.tokens.length > 0) {
+ options.range = (typeof syntax.tokens[0].range !== 'undefined');
+ options.loc = (typeof syntax.tokens[0].loc !== 'undefined');
+ }
+ }
+
+ if (typeof syntax.comments !== 'undefined') {
+ if (syntax.comments.length > 0) {
+ options.range = (typeof syntax.comments[0].range !== 'undefined');
+ options.loc = (typeof syntax.comments[0].loc !== 'undefined');
+ }
+ }
+
+ expected = JSON.stringify(syntax, null, 4);
+ try {
+ tree = esprima.parse(code, options);
+ tree = (options.comment || options.tokens || options.tolerant) ? tree : tree.body[0];
+
+ if (options.tolerant) {
+ for (i = 0, len = tree.errors.length; i < len; i += 1) {
+ tree.errors[i] = errorToObject(tree.errors[i]);
+ }
+ }
+
+ actual = JSON.stringify(tree, adjustRegexLiteral, 4);
+
+ // Only to ensure that there is no error when using string object.
+ esprima.parse(new StringObject(code), options);
+
+ } catch (e) {
+ throw new NotMatchingError(expected, e.toString());
+ }
+ if (expected !== actual) {
+ throw new NotMatchingError(expected, actual);
+ }
+
+ function filter(key, value) {
+ if (key === 'value' && value instanceof RegExp) {
+ value = value.toString();
+ }
+ return (key === 'loc' || key === 'range') ? undefined : value;
+ }
+
+ if (options.tolerant) {
+ return;
+ }
+
+
+ // Check again without any location info.
+ options.range = false;
+ options.loc = false;
+ expected = JSON.stringify(syntax, filter, 4);
+ try {
+ tree = esprima.parse(code, options);
+ tree = (options.comment || options.tokens) ? tree : tree.body[0];
+
+ if (options.tolerant) {
+ for (i = 0, len = tree.errors.length; i < len; i += 1) {
+ tree.errors[i] = errorToObject(tree.errors[i]);
+ }
+ }
+
+ actual = JSON.stringify(tree, filter, 4);
+ } catch (e) {
+ throw new NotMatchingError(expected, e.toString());
+ }
+ if (expected !== actual) {
+ throw new NotMatchingError(expected, actual);
+ }
+}
+
+function testError(esprima, code, exception) {
+ 'use strict';
+ var i, options, expected, actual, handleInvalidRegexFlag;
+
+ // Different parsing options should give the same error.
+ options = [
+ {},
+ { comment: true },
+ { raw: true },
+ { raw: true, comment: true }
+ ];
+
+ // If handleInvalidRegexFlag is true, an invalid flag in a regular expression
+ // will throw an exception. In some old version V8, this is not the case
+ // and hence handleInvalidRegexFlag is false.
+ handleInvalidRegexFlag = false;
+ try {
+ 'test'.match(new RegExp('[a-z]', 'x'));
+ } catch (e) {
+ handleInvalidRegexFlag = true;
+ }
+
+ expected = JSON.stringify(exception);
+
+ for (i = 0; i < options.length; i += 1) {
+
+ try {
+ esprima.parse(code, options[i]);
+ } catch (e) {
+ actual = JSON.stringify(errorToObject(e));
+ }
+
+ if (expected !== actual) {
+
+ // Compensate for old V8 which does not handle invalid flag.
+ if (exception.message.indexOf('Invalid regular expression') > 0) {
+ if (typeof actual === 'undefined' && !handleInvalidRegexFlag) {
+ return;
+ }
+ }
+
+ throw new NotMatchingError(expected, actual);
+ }
+
+ }
+}
+
+function testAPI(esprima, code, result) {
+ 'use strict';
+ var expected, res, actual;
+
+ expected = JSON.stringify(result.result, null, 4);
+ try {
+ if (typeof result.property !== 'undefined') {
+ res = esprima[result.property];
+ } else {
+ res = esprima[result.call].apply(esprima, result.args);
+ }
+ actual = JSON.stringify(res, adjustRegexLiteral, 4);
+ } catch (e) {
+ throw new NotMatchingError(expected, e.toString());
+ }
+ if (expected !== actual) {
+ throw new NotMatchingError(expected, actual);
+ }
+}
+
+function runTest(esprima, code, result) {
+ 'use strict';
+ if (result.hasOwnProperty('lineNumber')) {
+ testError(esprima, code, result);
+ } else if (result.hasOwnProperty('result')) {
+ testAPI(esprima, code, result);
+ } else {
+ testParse(esprima, code, result);
+ }
+}
+
+if (typeof window !== 'undefined') {
+ // Run all tests in a browser environment.
+ runTests = function () {
+ 'use strict';
+ var total = 0,
+ failures = 0,
+ category,
+ fixture,
+ source,
+ tick,
+ expected,
+ index,
+ len;
+
+ function setText(el, str) {
+ if (typeof el.innerText === 'string') {
+ el.innerText = str;
+ } else {
+ el.textContent = str;
+ }
+ }
+
+ function startCategory(category) {
+ var report, e;
+ report = document.getElementById('report');
+ e = document.createElement('h4');
+ setText(e, category);
+ report.appendChild(e);
+ }
+
+ function reportSuccess(code) {
+ var report, e;
+ report = document.getElementById('report');
+ e = document.createElement('pre');
+ e.setAttribute('class', 'code');
+ setText(e, code);
+ report.appendChild(e);
+ }
+
+ function reportFailure(code, expected, actual) {
+ var report, e;
+
+ report = document.getElementById('report');
+
+ e = document.createElement('p');
+ setText(e, 'Code:');
+ report.appendChild(e);
+
+ e = document.createElement('pre');
+ e.setAttribute('class', 'code');
+ setText(e, code);
+ report.appendChild(e);
+
+ e = document.createElement('p');
+ setText(e, 'Expected');
+ report.appendChild(e);
+
+ e = document.createElement('pre');
+ e.setAttribute('class', 'expected');
+ setText(e, expected);
+ report.appendChild(e);
+
+ e = document.createElement('p');
+ setText(e, 'Actual');
+ report.appendChild(e);
+
+ e = document.createElement('pre');
+ e.setAttribute('class', 'actual');
+ setText(e, actual);
+ report.appendChild(e);
+ }
+
+ setText(document.getElementById('version'), esprima.version);
+
+ tick = new Date();
+ for (category in testFixture) {
+ if (testFixture.hasOwnProperty(category)) {
+ startCategory(category);
+ fixture = testFixture[category];
+ for (source in fixture) {
+ if (fixture.hasOwnProperty(source)) {
+ expected = fixture[source];
+ total += 1;
+ try {
+ runTest(esprima, source, expected);
+ reportSuccess(source, JSON.stringify(expected, null, 4));
+ } catch (e) {
+ failures += 1;
+ reportFailure(source, e.expected, e.actual);
+ }
+ }
+ }
+ }
+ }
+ tick = (new Date()) - tick;
+
+ if (failures > 0) {
+ setText(document.getElementById('status'), total + ' tests. ' +
+ 'Failures: ' + failures + '. ' + tick + ' ms');
+ } else {
+ setText(document.getElementById('status'), total + ' tests. ' +
+ 'No failure. ' + tick + ' ms');
+ }
+ };
+} else {
+ (function () {
+ 'use strict';
+
+ var esprima = require('../esprima'),
+ vm = require('vm'),
+ fs = require('fs'),
+ total = 0,
+ failures = [],
+ tick = new Date(),
+ expected,
+ header;
+
+ vm.runInThisContext(fs.readFileSync(__dirname + '/test.js', 'utf-8'));
+
+ Object.keys(testFixture).forEach(function (category) {
+ Object.keys(testFixture[category]).forEach(function (source) {
+ total += 1;
+ expected = testFixture[category][source];
+ try {
+ runTest(esprima, source, expected);
+ } catch (e) {
+ e.source = source;
+ failures.push(e);
+ }
+ });
+ });
+ tick = (new Date()) - tick;
+
+ header = total + ' tests. ' + failures.length + ' failures. ' +
+ tick + ' ms';
+ if (failures.length) {
+ console.error(header);
+ failures.forEach(function (failure) {
+ console.error(failure.source + ': Expected\n ' +
+ failure.expected.split('\n').join('\n ') +
+ '\nto match\n ' + failure.actual);
+ });
+ } else {
+ console.log(header);
+ }
+ process.exit(failures.length === 0 ? 0 : 1);
+ }());
+}
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/esprima/test/test.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/esprima/test/test.js
new file mode 100644
index 0000000..8ceee54
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/node_modules/esprima/test/test.js
@@ -0,0 +1,20238 @@
+/*
+ Copyright (C) 2012 Ariya Hidayat
+ Copyright (C) 2012 Joost-Wim Boekesteijn
+ Copyright (C) 2012 Yusuke Suzuki
+ Copyright (C) 2012 Arpad Borsos
+ Copyright (C) 2011 Ariya Hidayat
+ Copyright (C) 2011 Yusuke Suzuki
+ Copyright (C) 2011 Arpad Borsos
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ ARE DISCLAIMED. IN NO EVENT SHALL BE LIABLE FOR ANY
+ DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+var testFixture = {
+
+ 'Primary Expression': {
+
+ 'this\n': {
+ type: 'Program',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'ThisExpression',
+ range: [0, 4],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 4 }
+ }
+ },
+ range: [0, 5],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 2, column: 0 }
+ }
+ }],
+ range: [0, 5],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 2, column: 0 }
+ },
+ tokens: [{
+ type: 'Keyword',
+ value: 'this',
+ range: [0, 4],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 4 }
+ }
+ }]
+ },
+
+ 'null\n': {
+ type: 'Program',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: null,
+ raw: 'null',
+ range: [0, 4],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 4 }
+ }
+ },
+ range: [0, 5],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 2, column: 0 }
+ }
+ }],
+ range: [0, 5],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 2, column: 0 }
+ },
+ tokens: [{
+ type: 'Null',
+ value: 'null',
+ range: [0, 4],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 4 }
+ }
+ }]
+ },
+
+ '\n 42\n\n': {
+ type: 'Program',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 42,
+ raw: '42',
+ range: [5, 7],
+ loc: {
+ start: { line: 2, column: 4 },
+ end: { line: 2, column: 6 }
+ }
+ },
+ range: [5, 9],
+ loc: {
+ start: { line: 2, column: 4 },
+ end: { line: 4, column: 0 }
+ }
+ }],
+ range: [5, 9],
+ loc: {
+ start: { line: 2, column: 4 },
+ end: { line: 4, column: 0 }
+ },
+ tokens: [{
+ type: 'Numeric',
+ value: '42',
+ range: [5, 7],
+ loc: {
+ start: { line: 2, column: 4 },
+ end: { line: 2, column: 6 }
+ }
+ }]
+ },
+
+ '(1 + 2 ) * 3': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'BinaryExpression',
+ operator: '*',
+ left: {
+ type: 'BinaryExpression',
+ operator: '+',
+ left: {
+ type: 'Literal',
+ value: 1,
+ raw: '1',
+ range: [1, 2],
+ loc: {
+ start: { line: 1, column: 1 },
+ end: { line: 1, column: 2 }
+ }
+ },
+ right: {
+ type: 'Literal',
+ value: 2,
+ raw: '2',
+ range: [5, 6],
+ loc: {
+ start: { line: 1, column: 5 },
+ end: { line: 1, column: 6 }
+ }
+ },
+ range: [1, 6],
+ loc: {
+ start: { line: 1, column: 1 },
+ end: { line: 1, column: 6 }
+ }
+ },
+ right: {
+ type: 'Literal',
+ value: 3,
+ raw: '3',
+ range: [11, 12],
+ loc: {
+ start: { line: 1, column: 11 },
+ end: { line: 1, column: 12 }
+ }
+ },
+ range: [0, 12],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 12 }
+ }
+ },
+ range: [0, 12],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 12 }
+ }
+ }
+
+ },
+
+ 'Grouping Operator': {
+
+ '(1) + (2 ) + 3': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'BinaryExpression',
+ operator: '+',
+ left: {
+ type: 'BinaryExpression',
+ operator: '+',
+ left: {
+ type: 'Literal',
+ value: 1,
+ raw: '1',
+ range: [1, 2],
+ loc: {
+ start: { line: 1, column: 1 },
+ end: { line: 1, column: 2 }
+ }
+ },
+ right: {
+ type: 'Literal',
+ value: 2,
+ raw: '2',
+ range: [7, 8],
+ loc: {
+ start: { line: 1, column: 7 },
+ end: { line: 1, column: 8 }
+ }
+ },
+ range: [0, 11],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 11 }
+ }
+ },
+ right: {
+ type: 'Literal',
+ value: 3,
+ raw: '3',
+ range: [14, 15],
+ loc: {
+ start: { line: 1, column: 14 },
+ end: { line: 1, column: 15 }
+ }
+ },
+ range: [0, 15],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 15 }
+ }
+ },
+ range: [0, 15],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 15 }
+ }
+ },
+
+ '4 + 5 << (6)': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'BinaryExpression',
+ operator: '<<',
+ left: {
+ type: 'BinaryExpression',
+ operator: '+',
+ left: {
+ type: 'Literal',
+ value: 4,
+ raw: '4',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'Literal',
+ value: 5,
+ raw: '5',
+ range: [4, 5],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ range: [0, 5],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ right: {
+ type: 'Literal',
+ value: 6,
+ raw: '6',
+ range: [10, 11],
+ loc: {
+ start: { line: 1, column: 10 },
+ end: { line: 1, column: 11 }
+ }
+ },
+ range: [0, 12],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 12 }
+ }
+ },
+ range: [0, 12],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 12 }
+ }
+ }
+
+ },
+
+ 'Array Initializer': {
+
+ 'x = []': {
+ type: 'Program',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'ArrayExpression',
+ elements: [],
+ range: [4, 6],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 6 }
+ }
+ },
+ range: [0, 6],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 6 }
+ }
+ },
+ range: [0, 6],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 6 }
+ }
+ }],
+ range: [0, 6],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 6 }
+ },
+ tokens: [{
+ type: 'Identifier',
+ value: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ }, {
+ type: 'Punctuator',
+ value: '=',
+ range: [2, 3],
+ loc: {
+ start: { line: 1, column: 2 },
+ end: { line: 1, column: 3 }
+ }
+ }, {
+ type: 'Punctuator',
+ value: '[',
+ range: [4, 5],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ }, {
+ type: 'Punctuator',
+ value: ']',
+ range: [5, 6],
+ loc: {
+ start: { line: 1, column: 5 },
+ end: { line: 1, column: 6 }
+ }
+ }]
+ },
+
+ 'x = [ ]': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'ArrayExpression',
+ elements: [],
+ range: [4, 7],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 7 }
+ }
+ },
+ range: [0, 7],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 7 }
+ }
+ },
+ range: [0, 7],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 7 }
+ }
+ },
+
+ 'x = [ 42 ]': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'ArrayExpression',
+ elements: [{
+ type: 'Literal',
+ value: 42,
+ raw: '42',
+ range: [6, 8],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 8 }
+ }
+ }],
+ range: [4, 10],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 10 }
+ }
+ },
+ range: [0, 10],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 10 }
+ }
+ },
+ range: [0, 10],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 10 }
+ }
+ },
+
+ 'x = [ 42, ]': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'ArrayExpression',
+ elements: [{
+ type: 'Literal',
+ value: 42,
+ raw: '42',
+ range: [6, 8],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 8 }
+ }
+ }],
+ range: [4, 11],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 11 }
+ }
+ },
+ range: [0, 11],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 11 }
+ }
+ },
+ range: [0, 11],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 11 }
+ }
+ },
+
+ 'x = [ ,, 42 ]': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'ArrayExpression',
+ elements: [
+ null,
+ null,
+ {
+ type: 'Literal',
+ value: 42,
+ raw: '42',
+ range: [9, 11],
+ loc: {
+ start: { line: 1, column: 9 },
+ end: { line: 1, column: 11 }
+ }
+ }],
+ range: [4, 13],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 13 }
+ }
+ },
+ range: [0, 13],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 13 }
+ }
+ },
+ range: [0, 13],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 13 }
+ }
+ },
+
+ 'x = [ 1, 2, 3, ]': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'ArrayExpression',
+ elements: [{
+ type: 'Literal',
+ value: 1,
+ raw: '1',
+ range: [6, 7],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 7 }
+ }
+ }, {
+ type: 'Literal',
+ value: 2,
+ raw: '2',
+ range: [9, 10],
+ loc: {
+ start: { line: 1, column: 9 },
+ end: { line: 1, column: 10 }
+ }
+ }, {
+ type: 'Literal',
+ value: 3,
+ raw: '3',
+ range: [12, 13],
+ loc: {
+ start: { line: 1, column: 12 },
+ end: { line: 1, column: 13 }
+ }
+ }],
+ range: [4, 16],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 16 }
+ }
+ },
+ range: [0, 16],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 16 }
+ }
+ },
+ range: [0, 16],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 16 }
+ }
+ },
+
+ 'x = [ 1, 2,, 3, ]': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'ArrayExpression',
+ elements: [{
+ type: 'Literal',
+ value: 1,
+ raw: '1',
+ range: [6, 7],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 7 }
+ }
+ }, {
+ type: 'Literal',
+ value: 2,
+ raw: '2',
+ range: [9, 10],
+ loc: {
+ start: { line: 1, column: 9 },
+ end: { line: 1, column: 10 }
+ }
+ }, null, {
+ type: 'Literal',
+ value: 3,
+ raw: '3',
+ range: [13, 14],
+ loc: {
+ start: { line: 1, column: 13 },
+ end: { line: 1, column: 14 }
+ }
+ }],
+ range: [4, 17],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 17 }
+ }
+ },
+ range: [0, 17],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 17 }
+ }
+ },
+ range: [0, 17],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 17 }
+ }
+ },
+
+ '日本語 = []': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left: {
+ type: 'Identifier',
+ name: '日本語',
+ range: [0, 3],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 3 }
+ }
+ },
+ right: {
+ type: 'ArrayExpression',
+ elements: [],
+ range: [6, 8],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 8 }
+ }
+ },
+ range: [0, 8],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 8 }
+ }
+ },
+ range: [0, 8],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 8 }
+ }
+ },
+
+ 'T\u203F = []': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left: {
+ type: 'Identifier',
+ name: 'T\u203F',
+ range: [0, 2],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 2 }
+ }
+ },
+ right: {
+ type: 'ArrayExpression',
+ elements: [],
+ range: [5, 7],
+ loc: {
+ start: { line: 1, column: 5 },
+ end: { line: 1, column: 7 }
+ }
+ },
+ range: [0, 7],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 7 }
+ }
+ },
+ range: [0, 7],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 7 }
+ }
+ },
+
+ 'T\u200C = []': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left: {
+ type: 'Identifier',
+ name: 'T\u200C',
+ range: [0, 2],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 2 }
+ }
+ },
+ right: {
+ type: 'ArrayExpression',
+ elements: [],
+ range: [5, 7],
+ loc: {
+ start: { line: 1, column: 5 },
+ end: { line: 1, column: 7 }
+ }
+ },
+ range: [0, 7],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 7 }
+ }
+ },
+ range: [0, 7],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 7 }
+ }
+ },
+
+ 'T\u200D = []': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left: {
+ type: 'Identifier',
+ name: 'T\u200D',
+ range: [0, 2],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 2 }
+ }
+ },
+ right: {
+ type: 'ArrayExpression',
+ elements: [],
+ range: [5, 7],
+ loc: {
+ start: { line: 1, column: 5 },
+ end: { line: 1, column: 7 }
+ }
+ },
+ range: [0, 7],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 7 }
+ }
+ },
+ range: [0, 7],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 7 }
+ }
+ },
+
+ '\u2163\u2161 = []': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left: {
+ type: 'Identifier',
+ name: '\u2163\u2161',
+ range: [0, 2],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 2 }
+ }
+ },
+ right: {
+ type: 'ArrayExpression',
+ elements: [],
+ range: [5, 7],
+ loc: {
+ start: { line: 1, column: 5 },
+ end: { line: 1, column: 7 }
+ }
+ },
+ range: [0, 7],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 7 }
+ }
+ },
+ range: [0, 7],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 7 }
+ }
+ },
+
+ '\u2163\u2161\u200A=\u2009[]': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left: {
+ type: 'Identifier',
+ name: '\u2163\u2161',
+ range: [0, 2],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 2 }
+ }
+ },
+ right: {
+ type: 'ArrayExpression',
+ elements: [],
+ range: [5, 7],
+ loc: {
+ start: { line: 1, column: 5 },
+ end: { line: 1, column: 7 }
+ }
+ },
+ range: [0, 7],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 7 }
+ }
+ },
+ range: [0, 7],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 7 }
+ }
+ }
+
+ },
+
+ 'Object Initializer': {
+
+ 'x = {}': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'ObjectExpression',
+ properties: [],
+ range: [4, 6],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 6 }
+ }
+ },
+ range: [0, 6],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 6 }
+ }
+ },
+ range: [0, 6],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 6 }
+ }
+ },
+
+ 'x = { }': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'ObjectExpression',
+ properties: [],
+ range: [4, 7],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 7 }
+ }
+ },
+ range: [0, 7],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 7 }
+ }
+ },
+ range: [0, 7],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 7 }
+ }
+ },
+
+ 'x = { answer: 42 }': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'ObjectExpression',
+ properties: [{
+ type: 'Property',
+ key: {
+ type: 'Identifier',
+ name: 'answer',
+ range: [6, 12],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 12 }
+ }
+ },
+ value: {
+ type: 'Literal',
+ value: 42,
+ raw: '42',
+ range: [14, 16],
+ loc: {
+ start: { line: 1, column: 14 },
+ end: { line: 1, column: 16 }
+ }
+ },
+ kind: 'init',
+ range: [6, 16],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 16 }
+ }
+ }],
+ range: [4, 18],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 18 }
+ }
+ },
+ range: [0, 18],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 18 }
+ }
+ },
+ range: [0, 18],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 18 }
+ }
+ },
+
+ 'x = { if: 42 }': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'ObjectExpression',
+ properties: [{
+ type: 'Property',
+ key: {
+ type: 'Identifier',
+ name: 'if',
+ range: [6, 8],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 8 }
+ }
+ },
+ value: {
+ type: 'Literal',
+ value: 42,
+ raw: '42',
+ range: [10, 12],
+ loc: {
+ start: { line: 1, column: 10 },
+ end: { line: 1, column: 12 }
+ }
+ },
+ kind: 'init',
+ range: [6, 12],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 12 }
+ }
+ }],
+ range: [4, 14],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 14 }
+ }
+ },
+ range: [0, 14],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 14 }
+ }
+ },
+ range: [0, 14],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 14 }
+ }
+ },
+
+ 'x = { true: 42 }': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'ObjectExpression',
+ properties: [{
+ type: 'Property',
+ key: {
+ type: 'Identifier',
+ name: 'true',
+ range: [6, 10],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 10 }
+ }
+ },
+ value: {
+ type: 'Literal',
+ value: 42,
+ raw: '42',
+ range: [12, 14],
+ loc: {
+ start: { line: 1, column: 12 },
+ end: { line: 1, column: 14 }
+ }
+ },
+ kind: 'init',
+ range: [6, 14],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 14 }
+ }
+ }],
+ range: [4, 16],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 16 }
+ }
+ },
+ range: [0, 16],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 16 }
+ }
+ },
+ range: [0, 16],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 16 }
+ }
+ },
+
+ 'x = { false: 42 }': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'ObjectExpression',
+ properties: [{
+ type: 'Property',
+ key: {
+ type: 'Identifier',
+ name: 'false',
+ range: [6, 11],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 11 }
+ }
+ },
+ value: {
+ type: 'Literal',
+ value: 42,
+ raw: '42',
+ range: [13, 15],
+ loc: {
+ start: { line: 1, column: 13 },
+ end: { line: 1, column: 15 }
+ }
+ },
+ kind: 'init',
+ range: [6, 15],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 15 }
+ }
+ }],
+ range: [4, 17],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 17 }
+ }
+ },
+ range: [0, 17],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 17 }
+ }
+ },
+ range: [0, 17],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 17 }
+ }
+ },
+
+ 'x = { null: 42 }': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'ObjectExpression',
+ properties: [{
+ type: 'Property',
+ key: {
+ type: 'Identifier',
+ name: 'null',
+ range: [6, 10],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 10 }
+ }
+ },
+ value: {
+ type: 'Literal',
+ value: 42,
+ raw: '42',
+ range: [12, 14],
+ loc: {
+ start: { line: 1, column: 12 },
+ end: { line: 1, column: 14 }
+ }
+ },
+ kind: 'init',
+ range: [6, 14],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 14 }
+ }
+ }],
+ range: [4, 16],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 16 }
+ }
+ },
+ range: [0, 16],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 16 }
+ }
+ },
+ range: [0, 16],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 16 }
+ }
+ },
+
+ 'x = { "answer": 42 }': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'ObjectExpression',
+ properties: [{
+ type: 'Property',
+ key: {
+ type: 'Literal',
+ value: 'answer',
+ raw: '"answer"',
+ range: [6, 14],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 14 }
+ }
+ },
+ value: {
+ type: 'Literal',
+ value: 42,
+ raw: '42',
+ range: [16, 18],
+ loc: {
+ start: { line: 1, column: 16 },
+ end: { line: 1, column: 18 }
+ }
+ },
+ kind: 'init',
+ range: [6, 18],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 18 }
+ }
+ }],
+ range: [4, 20],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 20 }
+ }
+ },
+ range: [0, 20],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 20 }
+ }
+ },
+ range: [0, 20],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 20 }
+ }
+ },
+
+ 'x = { x: 1, x: 2 }': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'ObjectExpression',
+ properties: [
+ {
+ type: 'Property',
+ key: {
+ type: 'Identifier',
+ name: 'x',
+ range: [6, 7],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 7 }
+ }
+ },
+ value: {
+ type: 'Literal',
+ value: 1,
+ raw: '1',
+ range: [9, 10],
+ loc: {
+ start: { line: 1, column: 9 },
+ end: { line: 1, column: 10 }
+ }
+ },
+ kind: 'init',
+ range: [6, 10],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 10 }
+ }
+ },
+ {
+ type: 'Property',
+ key: {
+ type: 'Identifier',
+ name: 'x',
+ range: [12, 13],
+ loc: {
+ start: { line: 1, column: 12 },
+ end: { line: 1, column: 13 }
+ }
+ },
+ value: {
+ type: 'Literal',
+ value: 2,
+ raw: '2',
+ range: [15, 16],
+ loc: {
+ start: { line: 1, column: 15 },
+ end: { line: 1, column: 16 }
+ }
+ },
+ kind: 'init',
+ range: [12, 16],
+ loc: {
+ start: { line: 1, column: 12 },
+ end: { line: 1, column: 16 }
+ }
+ }
+ ],
+ range: [4, 18],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 18 }
+ }
+ },
+ range: [0, 18],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 18 }
+ }
+ },
+ range: [0, 18],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 18 }
+ }
+ },
+
+ 'x = { get width() { return m_width } }': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'ObjectExpression',
+ properties: [{
+ type: 'Property',
+ key: {
+ type: 'Identifier',
+ name: 'width',
+ range: [10, 15],
+ loc: {
+ start: { line: 1, column: 10 },
+ end: { line: 1, column: 15 }
+ }
+ },
+ value: {
+ type: 'FunctionExpression',
+ id: null,
+ params: [],
+ defaults: [],
+ body: {
+ type: 'BlockStatement',
+ body: [{
+ type: 'ReturnStatement',
+ argument: {
+ type: 'Identifier',
+ name: 'm_width',
+ range: [27, 34],
+ loc: {
+ start: { line: 1, column: 27 },
+ end: { line: 1, column: 34 }
+ }
+ },
+ range: [20, 35],
+ loc: {
+ start: { line: 1, column: 20 },
+ end: { line: 1, column: 35 }
+ }
+ }],
+ range: [18, 36],
+ loc: {
+ start: { line: 1, column: 18 },
+ end: { line: 1, column: 36 }
+ }
+ },
+ rest: null,
+ generator: false,
+ expression: false,
+ range: [18, 36],
+ loc: {
+ start: { line: 1, column: 18 },
+ end: { line: 1, column: 36 }
+ }
+ },
+ kind: 'get',
+ range: [6, 36],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 36 }
+ }
+ }],
+ range: [4, 38],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 38 }
+ }
+ },
+ range: [0, 38],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 38 }
+ }
+ },
+ range: [0, 38],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 38 }
+ }
+ },
+
+ 'x = { get undef() {} }': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'ObjectExpression',
+ properties: [{
+ type: 'Property',
+ key: {
+ type: 'Identifier',
+ name: 'undef',
+ range: [10, 15],
+ loc: {
+ start: { line: 1, column: 10 },
+ end: { line: 1, column: 15 }
+ }
+ },
+ value: {
+ type: 'FunctionExpression',
+ id: null,
+ params: [],
+ defaults: [],
+ body: {
+ type: 'BlockStatement',
+ body: [],
+ range: [18, 20],
+ loc: {
+ start: { line: 1, column: 18 },
+ end: { line: 1, column: 20 }
+ }
+ },
+ rest: null,
+ generator: false,
+ expression: false,
+ range: [18, 20],
+ loc: {
+ start: { line: 1, column: 18 },
+ end: { line: 1, column: 20 }
+ }
+ },
+ kind: 'get',
+ range: [6, 20],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 20 }
+ }
+ }],
+ range: [4, 22],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 22 }
+ }
+ },
+ range: [0, 22],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 22 }
+ }
+ },
+ range: [0, 22],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 22 }
+ }
+ },
+
+ 'x = { get if() {} }': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'ObjectExpression',
+ properties: [{
+ type: 'Property',
+ key: {
+ type: 'Identifier',
+ name: 'if',
+ range: [10, 12],
+ loc: {
+ start: { line: 1, column: 10 },
+ end: { line: 1, column: 12 }
+ }
+ },
+ value: {
+ type: 'FunctionExpression',
+ id: null,
+ params: [],
+ defaults: [],
+ body: {
+ type: 'BlockStatement',
+ body: [],
+ range: [15, 17],
+ loc: {
+ start: { line: 1, column: 15 },
+ end: { line: 1, column: 17 }
+ }
+ },
+ rest: null,
+ generator: false,
+ expression: false,
+ range: [15, 17],
+ loc: {
+ start: { line: 1, column: 15 },
+ end: { line: 1, column: 17 }
+ }
+ },
+ kind: 'get',
+ range: [6, 17],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 17 }
+ }
+ }],
+ range: [4, 19],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 19 }
+ }
+ },
+ range: [0, 19],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 19 }
+ }
+ },
+ range: [0, 19],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 19 }
+ }
+ },
+
+ 'x = { get true() {} }': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'ObjectExpression',
+ properties: [{
+ type: 'Property',
+ key: {
+ type: 'Identifier',
+ name: 'true',
+ range: [10, 14],
+ loc: {
+ start: { line: 1, column: 10 },
+ end: { line: 1, column: 14 }
+ }
+ },
+ value: {
+ type: 'FunctionExpression',
+ id: null,
+ params: [],
+ defaults: [],
+ body: {
+ type: 'BlockStatement',
+ body: [],
+ range: [17, 19],
+ loc: {
+ start: { line: 1, column: 17 },
+ end: { line: 1, column: 19 }
+ }
+ },
+ rest: null,
+ generator: false,
+ expression: false,
+ range: [17, 19],
+ loc: {
+ start: { line: 1, column: 17 },
+ end: { line: 1, column: 19 }
+ }
+ },
+ kind: 'get',
+ range: [6, 19],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 19 }
+ }
+ }],
+ range: [4, 21],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 21 }
+ }
+ },
+ range: [0, 21],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 21 }
+ }
+ },
+ range: [0, 21],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 21 }
+ }
+ },
+
+ 'x = { get false() {} }': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'ObjectExpression',
+ properties: [{
+ type: 'Property',
+ key: {
+ type: 'Identifier',
+ name: 'false',
+ range: [10, 15],
+ loc: {
+ start: { line: 1, column: 10 },
+ end: { line: 1, column: 15 }
+ }
+ },
+ value: {
+ type: 'FunctionExpression',
+ id: null,
+ params: [],
+ defaults: [],
+ body: {
+ type: 'BlockStatement',
+ body: [],
+ range: [18, 20],
+ loc: {
+ start: { line: 1, column: 18 },
+ end: { line: 1, column: 20 }
+ }
+ },
+ rest: null,
+ generator: false,
+ expression: false,
+ range: [18, 20],
+ loc: {
+ start: { line: 1, column: 18 },
+ end: { line: 1, column: 20 }
+ }
+ },
+ kind: 'get',
+ range: [6, 20],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 20 }
+ }
+ }],
+ range: [4, 22],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 22 }
+ }
+ },
+ range: [0, 22],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 22 }
+ }
+ },
+ range: [0, 22],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 22 }
+ }
+ },
+
+ 'x = { get null() {} }': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'ObjectExpression',
+ properties: [{
+ type: 'Property',
+ key: {
+ type: 'Identifier',
+ name: 'null',
+ range: [10, 14],
+ loc: {
+ start: { line: 1, column: 10 },
+ end: { line: 1, column: 14 }
+ }
+ },
+ value: {
+ type: 'FunctionExpression',
+ id: null,
+ params: [],
+ defaults: [],
+ body: {
+ type: 'BlockStatement',
+ body: [],
+ range: [17, 19],
+ loc: {
+ start: { line: 1, column: 17 },
+ end: { line: 1, column: 19 }
+ }
+ },
+ rest: null,
+ generator: false,
+ expression: false,
+ range: [17, 19],
+ loc: {
+ start: { line: 1, column: 17 },
+ end: { line: 1, column: 19 }
+ }
+ },
+ kind: 'get',
+ range: [6, 19],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 19 }
+ }
+ }],
+ range: [4, 21],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 21 }
+ }
+ },
+ range: [0, 21],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 21 }
+ }
+ },
+ range: [0, 21],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 21 }
+ }
+ },
+
+ 'x = { get "undef"() {} }': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'ObjectExpression',
+ properties: [{
+ type: 'Property',
+ key: {
+ type: 'Literal',
+ value: 'undef',
+ raw: '"undef"',
+ range: [10, 17],
+ loc: {
+ start: { line: 1, column: 10 },
+ end: { line: 1, column: 17 }
+ }
+ },
+ value: {
+ type: 'FunctionExpression',
+ id: null,
+ params: [],
+ defaults: [],
+ body: {
+ type: 'BlockStatement',
+ body: [],
+ range: [20, 22],
+ loc: {
+ start: { line: 1, column: 20 },
+ end: { line: 1, column: 22 }
+ }
+ },
+ rest: null,
+ generator: false,
+ expression: false,
+ range: [20, 22],
+ loc: {
+ start: { line: 1, column: 20 },
+ end: { line: 1, column: 22 }
+ }
+ },
+ kind: 'get',
+ range: [6, 22],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 22 }
+ }
+ }],
+ range: [4, 24],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 24 }
+ }
+ },
+ range: [0, 24],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 24 }
+ }
+ },
+ range: [0, 24],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 24 }
+ }
+ },
+
+ 'x = { get 10() {} }': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'ObjectExpression',
+ properties: [{
+ type: 'Property',
+ key: {
+ type: 'Literal',
+ value: 10,
+ raw: '10',
+ range: [10, 12],
+ loc: {
+ start: { line: 1, column: 10 },
+ end: { line: 1, column: 12 }
+ }
+ },
+ value: {
+ type: 'FunctionExpression',
+ id: null,
+ params: [],
+ defaults: [],
+ body: {
+ type: 'BlockStatement',
+ body: [],
+ range: [15, 17],
+ loc: {
+ start: { line: 1, column: 15 },
+ end: { line: 1, column: 17 }
+ }
+ },
+ rest: null,
+ generator: false,
+ expression: false,
+ range: [15, 17],
+ loc: {
+ start: { line: 1, column: 15 },
+ end: { line: 1, column: 17 }
+ }
+ },
+ kind: 'get',
+ range: [6, 17],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 17 }
+ }
+ }],
+ range: [4, 19],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 19 }
+ }
+ },
+ range: [0, 19],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 19 }
+ }
+ },
+ range: [0, 19],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 19 }
+ }
+ },
+
+ 'x = { set width(w) { m_width = w } }': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'ObjectExpression',
+ properties: [{
+ type: 'Property',
+ key: {
+ type: 'Identifier',
+ name: 'width',
+ range: [10, 15],
+ loc: {
+ start: { line: 1, column: 10 },
+ end: { line: 1, column: 15 }
+ }
+ },
+ value: {
+ type: 'FunctionExpression',
+ id: null,
+ params: [{
+ type: 'Identifier',
+ name: 'w',
+ range: [16, 17],
+ loc: {
+ start: { line: 1, column: 16 },
+ end: { line: 1, column: 17 }
+ }
+ }],
+ defaults: [],
+ body: {
+ type: 'BlockStatement',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left: {
+ type: 'Identifier',
+ name: 'm_width',
+ range: [21, 28],
+ loc: {
+ start: { line: 1, column: 21 },
+ end: { line: 1, column: 28 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'w',
+ range: [31, 32],
+ loc: {
+ start: { line: 1, column: 31 },
+ end: { line: 1, column: 32 }
+ }
+ },
+ range: [21, 32],
+ loc: {
+ start: { line: 1, column: 21 },
+ end: { line: 1, column: 32 }
+ }
+ },
+ range: [21, 33],
+ loc: {
+ start: { line: 1, column: 21 },
+ end: { line: 1, column: 33 }
+ }
+ }],
+ range: [19, 34],
+ loc: {
+ start: { line: 1, column: 19 },
+ end: { line: 1, column: 34 }
+ }
+ },
+ rest: null,
+ generator: false,
+ expression: false,
+ range: [19, 34],
+ loc: {
+ start: { line: 1, column: 19 },
+ end: { line: 1, column: 34 }
+ }
+ },
+ kind: 'set',
+ range: [6, 34],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 34 }
+ }
+ }],
+ range: [4, 36],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 36 }
+ }
+ },
+ range: [0, 36],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 36 }
+ }
+ },
+ range: [0, 36],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 36 }
+ }
+ },
+
+ 'x = { set if(w) { m_if = w } }': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'ObjectExpression',
+ properties: [{
+ type: 'Property',
+ key: {
+ type: 'Identifier',
+ name: 'if',
+ range: [10, 12],
+ loc: {
+ start: { line: 1, column: 10 },
+ end: { line: 1, column: 12 }
+ }
+ },
+ value: {
+ type: 'FunctionExpression',
+ id: null,
+ params: [{
+ type: 'Identifier',
+ name: 'w',
+ range: [13, 14],
+ loc: {
+ start: { line: 1, column: 13 },
+ end: { line: 1, column: 14 }
+ }
+ }],
+ defaults: [],
+ body: {
+ type: 'BlockStatement',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left: {
+ type: 'Identifier',
+ name: 'm_if',
+ range: [18, 22],
+ loc: {
+ start: { line: 1, column: 18 },
+ end: { line: 1, column: 22 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'w',
+ range: [25, 26],
+ loc: {
+ start: { line: 1, column: 25 },
+ end: { line: 1, column: 26 }
+ }
+ },
+ range: [18, 26],
+ loc: {
+ start: { line: 1, column: 18 },
+ end: { line: 1, column: 26 }
+ }
+ },
+ range: [18, 27],
+ loc: {
+ start: { line: 1, column: 18 },
+ end: { line: 1, column: 27 }
+ }
+ }],
+ range: [16, 28],
+ loc: {
+ start: { line: 1, column: 16 },
+ end: { line: 1, column: 28 }
+ }
+ },
+ rest: null,
+ generator: false,
+ expression: false,
+ range: [16, 28],
+ loc: {
+ start: { line: 1, column: 16 },
+ end: { line: 1, column: 28 }
+ }
+ },
+ kind: 'set',
+ range: [6, 28],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 28 }
+ }
+ }],
+ range: [4, 30],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 30 }
+ }
+ },
+ range: [0, 30],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 30 }
+ }
+ },
+ range: [0, 30],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 30 }
+ }
+ },
+
+ 'x = { set true(w) { m_true = w } }': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'ObjectExpression',
+ properties: [{
+ type: 'Property',
+ key: {
+ type: 'Identifier',
+ name: 'true',
+ range: [10, 14],
+ loc: {
+ start: { line: 1, column: 10 },
+ end: { line: 1, column: 14 }
+ }
+ },
+ value: {
+ type: 'FunctionExpression',
+ id: null,
+ params: [{
+ type: 'Identifier',
+ name: 'w',
+ range: [15, 16],
+ loc: {
+ start: { line: 1, column: 15 },
+ end: { line: 1, column: 16 }
+ }
+ }],
+ defaults: [],
+ body: {
+ type: 'BlockStatement',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left: {
+ type: 'Identifier',
+ name: 'm_true',
+ range: [20, 26],
+ loc: {
+ start: { line: 1, column: 20 },
+ end: { line: 1, column: 26 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'w',
+ range: [29, 30],
+ loc: {
+ start: { line: 1, column: 29 },
+ end: { line: 1, column: 30 }
+ }
+ },
+ range: [20, 30],
+ loc: {
+ start: { line: 1, column: 20 },
+ end: { line: 1, column: 30 }
+ }
+ },
+ range: [20, 31],
+ loc: {
+ start: { line: 1, column: 20 },
+ end: { line: 1, column: 31 }
+ }
+ }],
+ range: [18, 32],
+ loc: {
+ start: { line: 1, column: 18 },
+ end: { line: 1, column: 32 }
+ }
+ },
+ rest: null,
+ generator: false,
+ expression: false,
+ range: [18, 32],
+ loc: {
+ start: { line: 1, column: 18 },
+ end: { line: 1, column: 32 }
+ }
+ },
+ kind: 'set',
+ range: [6, 32],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 32 }
+ }
+ }],
+ range: [4, 34],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 34 }
+ }
+ },
+ range: [0, 34],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 34 }
+ }
+ },
+ range: [0, 34],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 34 }
+ }
+ },
+
+ 'x = { set false(w) { m_false = w } }': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'ObjectExpression',
+ properties: [{
+ type: 'Property',
+ key: {
+ type: 'Identifier',
+ name: 'false',
+ range: [10, 15],
+ loc: {
+ start: { line: 1, column: 10 },
+ end: { line: 1, column: 15 }
+ }
+ },
+ value: {
+ type: 'FunctionExpression',
+ id: null,
+ params: [{
+ type: 'Identifier',
+ name: 'w',
+ range: [16, 17],
+ loc: {
+ start: { line: 1, column: 16 },
+ end: { line: 1, column: 17 }
+ }
+ }],
+ defaults: [],
+ body: {
+ type: 'BlockStatement',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left: {
+ type: 'Identifier',
+ name: 'm_false',
+ range: [21, 28],
+ loc: {
+ start: { line: 1, column: 21 },
+ end: { line: 1, column: 28 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'w',
+ range: [31, 32],
+ loc: {
+ start: { line: 1, column: 31 },
+ end: { line: 1, column: 32 }
+ }
+ },
+ range: [21, 32],
+ loc: {
+ start: { line: 1, column: 21 },
+ end: { line: 1, column: 32 }
+ }
+ },
+ range: [21, 33],
+ loc: {
+ start: { line: 1, column: 21 },
+ end: { line: 1, column: 33 }
+ }
+ }],
+ range: [19, 34],
+ loc: {
+ start: { line: 1, column: 19 },
+ end: { line: 1, column: 34 }
+ }
+ },
+ rest: null,
+ generator: false,
+ expression: false,
+ range: [19, 34],
+ loc: {
+ start: { line: 1, column: 19 },
+ end: { line: 1, column: 34 }
+ }
+ },
+ kind: 'set',
+ range: [6, 34],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 34 }
+ }
+ }],
+ range: [4, 36],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 36 }
+ }
+ },
+ range: [0, 36],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 36 }
+ }
+ },
+ range: [0, 36],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 36 }
+ }
+ },
+
+ 'x = { set null(w) { m_null = w } }': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'ObjectExpression',
+ properties: [{
+ type: 'Property',
+ key: {
+ type: 'Identifier',
+ name: 'null',
+ range: [10, 14],
+ loc: {
+ start: { line: 1, column: 10 },
+ end: { line: 1, column: 14 }
+ }
+ },
+ value: {
+ type: 'FunctionExpression',
+ id: null,
+ params: [{
+ type: 'Identifier',
+ name: 'w',
+ range: [15, 16],
+ loc: {
+ start: { line: 1, column: 15 },
+ end: { line: 1, column: 16 }
+ }
+ }],
+ defaults: [],
+ body: {
+ type: 'BlockStatement',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left: {
+ type: 'Identifier',
+ name: 'm_null',
+ range: [20, 26],
+ loc: {
+ start: { line: 1, column: 20 },
+ end: { line: 1, column: 26 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'w',
+ range: [29, 30],
+ loc: {
+ start: { line: 1, column: 29 },
+ end: { line: 1, column: 30 }
+ }
+ },
+ range: [20, 30],
+ loc: {
+ start: { line: 1, column: 20 },
+ end: { line: 1, column: 30 }
+ }
+ },
+ range: [20, 31],
+ loc: {
+ start: { line: 1, column: 20 },
+ end: { line: 1, column: 31 }
+ }
+ }],
+ range: [18, 32],
+ loc: {
+ start: { line: 1, column: 18 },
+ end: { line: 1, column: 32 }
+ }
+ },
+ rest: null,
+ generator: false,
+ expression: false,
+ range: [18, 32],
+ loc: {
+ start: { line: 1, column: 18 },
+ end: { line: 1, column: 32 }
+ }
+ },
+ kind: 'set',
+ range: [6, 32],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 32 }
+ }
+ }],
+ range: [4, 34],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 34 }
+ }
+ },
+ range: [0, 34],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 34 }
+ }
+ },
+ range: [0, 34],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 34 }
+ }
+ },
+
+ 'x = { set "null"(w) { m_null = w } }': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'ObjectExpression',
+ properties: [{
+ type: 'Property',
+ key: {
+ type: 'Literal',
+ value: 'null',
+ raw: '"null"',
+ range: [10, 16],
+ loc: {
+ start: { line: 1, column: 10 },
+ end: { line: 1, column: 16 }
+ }
+ },
+ value: {
+ type: 'FunctionExpression',
+ id: null,
+ params: [{
+ type: 'Identifier',
+ name: 'w',
+ range: [17, 18],
+ loc: {
+ start: { line: 1, column: 17 },
+ end: { line: 1, column: 18 }
+ }
+ }],
+ defaults: [],
+ body: {
+ type: 'BlockStatement',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left: {
+ type: 'Identifier',
+ name: 'm_null',
+ range: [22, 28],
+ loc: {
+ start: { line: 1, column: 22 },
+ end: { line: 1, column: 28 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'w',
+ range: [31, 32],
+ loc: {
+ start: { line: 1, column: 31 },
+ end: { line: 1, column: 32 }
+ }
+ },
+ range: [22, 32],
+ loc: {
+ start: { line: 1, column: 22 },
+ end: { line: 1, column: 32 }
+ }
+ },
+ range: [22, 33],
+ loc: {
+ start: { line: 1, column: 22 },
+ end: { line: 1, column: 33 }
+ }
+ }],
+ range: [20, 34],
+ loc: {
+ start: { line: 1, column: 20 },
+ end: { line: 1, column: 34 }
+ }
+ },
+ rest: null,
+ generator: false,
+ expression: false,
+ range: [20, 34],
+ loc: {
+ start: { line: 1, column: 20 },
+ end: { line: 1, column: 34 }
+ }
+ },
+ kind: 'set',
+ range: [6, 34],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 34 }
+ }
+ }],
+ range: [4, 36],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 36 }
+ }
+ },
+ range: [0, 36],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 36 }
+ }
+ },
+ range: [0, 36],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 36 }
+ }
+ },
+
+ 'x = { set 10(w) { m_null = w } }': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'ObjectExpression',
+ properties: [{
+ type: 'Property',
+ key: {
+ type: 'Literal',
+ value: 10,
+ raw: '10',
+ range: [10, 12],
+ loc: {
+ start: { line: 1, column: 10 },
+ end: { line: 1, column: 12 }
+ }
+ },
+ value: {
+ type: 'FunctionExpression',
+ id: null,
+ params: [{
+ type: 'Identifier',
+ name: 'w',
+ range: [13, 14],
+ loc: {
+ start: { line: 1, column: 13 },
+ end: { line: 1, column: 14 }
+ }
+ }],
+ defaults: [],
+ body: {
+ type: 'BlockStatement',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left: {
+ type: 'Identifier',
+ name: 'm_null',
+ range: [18, 24],
+ loc: {
+ start: { line: 1, column: 18 },
+ end: { line: 1, column: 24 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'w',
+ range: [27, 28],
+ loc: {
+ start: { line: 1, column: 27 },
+ end: { line: 1, column: 28 }
+ }
+ },
+ range: [18, 28],
+ loc: {
+ start: { line: 1, column: 18 },
+ end: { line: 1, column: 28 }
+ }
+ },
+ range: [18, 29],
+ loc: {
+ start: { line: 1, column: 18 },
+ end: { line: 1, column: 29 }
+ }
+ }],
+ range: [16, 30],
+ loc: {
+ start: { line: 1, column: 16 },
+ end: { line: 1, column: 30 }
+ }
+ },
+ rest: null,
+ generator: false,
+ expression: false,
+ range: [16, 30],
+ loc: {
+ start: { line: 1, column: 16 },
+ end: { line: 1, column: 30 }
+ }
+ },
+ kind: 'set',
+ range: [6, 30],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 30 }
+ }
+ }],
+ range: [4, 32],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 32 }
+ }
+ },
+ range: [0, 32],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 32 }
+ }
+ },
+ range: [0, 32],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 32 }
+ }
+ },
+
+ 'x = { get: 42 }': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'ObjectExpression',
+ properties: [{
+ type: 'Property',
+ key: {
+ type: 'Identifier',
+ name: 'get',
+ range: [6, 9],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ value: {
+ type: 'Literal',
+ value: 42,
+ raw: '42',
+ range: [11, 13],
+ loc: {
+ start: { line: 1, column: 11 },
+ end: { line: 1, column: 13 }
+ }
+ },
+ kind: 'init',
+ range: [6, 13],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 13 }
+ }
+ }],
+ range: [4, 15],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 15 }
+ }
+ },
+ range: [0, 15],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 15 }
+ }
+ },
+ range: [0, 15],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 15 }
+ }
+ },
+
+ 'x = { set: 43 }': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'ObjectExpression',
+ properties: [{
+ type: 'Property',
+ key: {
+ type: 'Identifier',
+ name: 'set',
+ range: [6, 9],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ value: {
+ type: 'Literal',
+ value: 43,
+ raw: '43',
+ range: [11, 13],
+ loc: {
+ start: { line: 1, column: 11 },
+ end: { line: 1, column: 13 }
+ }
+ },
+ kind: 'init',
+ range: [6, 13],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 13 }
+ }
+ }],
+ range: [4, 15],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 15 }
+ }
+ },
+ range: [0, 15],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 15 }
+ }
+ },
+ range: [0, 15],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 15 }
+ }
+ }
+
+ },
+
+ 'Comments': {
+
+ '/* block comment */ 42': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 42,
+ raw: '42',
+ range: [20, 22],
+ loc: {
+ start: { line: 1, column: 20 },
+ end: { line: 1, column: 22 }
+ }
+ },
+ range: [20, 22],
+ loc: {
+ start: { line: 1, column: 20 },
+ end: { line: 1, column: 22 }
+ }
+ },
+
+ '42 /*The*/ /*Answer*/': {
+ type: 'Program',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 42,
+ raw: '42',
+ range: [0, 2],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 2 }
+ }
+ },
+ range: [0, 21],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 21 }
+ }
+ }],
+ range: [0, 21],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 21 }
+ },
+ comments: [{
+ type: 'Block',
+ value: 'The',
+ range: [3, 10],
+ loc: {
+ start: { line: 1, column: 3 },
+ end: { line: 1, column: 10 }
+ }
+ }, {
+ type: 'Block',
+ value: 'Answer',
+ range: [11, 21],
+ loc: {
+ start: { line: 1, column: 11 },
+ end: { line: 1, column: 21 }
+ }
+ }]
+ },
+
+ '42 /*the*/ /*answer*/': {
+ type: 'Program',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 42,
+ raw: '42',
+ range: [0, 2]
+ },
+ range: [0, 21]
+ }],
+ range: [0, 21],
+ comments: [{
+ type: 'Block',
+ value: 'the',
+ range: [3, 10]
+ }, {
+ type: 'Block',
+ value: 'answer',
+ range: [11, 21]
+ }]
+ },
+
+ '/* multiline\ncomment\nshould\nbe\nignored */ 42': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 42,
+ raw: '42',
+ range: [42, 44],
+ loc: {
+ start: { line: 5, column: 11 },
+ end: { line: 5, column: 13 }
+ }
+ },
+ range: [42, 44],
+ loc: {
+ start: { line: 5, column: 11 },
+ end: { line: 5, column: 13 }
+ }
+ },
+
+ '/*a\r\nb*/ 42': {
+ type: 'Program',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 42,
+ raw: '42',
+ range: [9, 11],
+ loc: {
+ start: { line: 2, column: 4 },
+ end: { line: 2, column: 6 }
+ }
+ },
+ range: [9, 11],
+ loc: {
+ start: { line: 2, column: 4 },
+ end: { line: 2, column: 6 }
+ }
+ }],
+ range: [9, 11],
+ loc: {
+ start: { line: 2, column: 4 },
+ end: { line: 2, column: 6 }
+ },
+ comments: [{
+ type: 'Block',
+ value: 'a\r\nb',
+ range: [0, 8],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 2, column: 3 }
+ }
+ }]
+ },
+
+ '/*a\rb*/ 42': {
+ type: 'Program',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 42,
+ raw: '42',
+ range: [8, 10],
+ loc: {
+ start: { line: 2, column: 4 },
+ end: { line: 2, column: 6 }
+ }
+ },
+ range: [8, 10],
+ loc: {
+ start: { line: 2, column: 4 },
+ end: { line: 2, column: 6 }
+ }
+ }],
+ range: [8, 10],
+ loc: {
+ start: { line: 2, column: 4 },
+ end: { line: 2, column: 6 }
+ },
+ comments: [{
+ type: 'Block',
+ value: 'a\rb',
+ range: [0, 7],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 2, column: 3 }
+ }
+ }]
+ },
+
+ '/*a\nb*/ 42': {
+ type: 'Program',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 42,
+ raw: '42',
+ range: [8, 10],
+ loc: {
+ start: { line: 2, column: 4 },
+ end: { line: 2, column: 6 }
+ }
+ },
+ range: [8, 10],
+ loc: {
+ start: { line: 2, column: 4 },
+ end: { line: 2, column: 6 }
+ }
+ }],
+ range: [8, 10],
+ loc: {
+ start: { line: 2, column: 4 },
+ end: { line: 2, column: 6 }
+ },
+ comments: [{
+ type: 'Block',
+ value: 'a\nb',
+ range: [0, 7],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 2, column: 3 }
+ }
+ }]
+ },
+
+ '/*a\nc*/ 42': {
+ type: 'Program',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 42,
+ raw: '42',
+ loc: {
+ start: { line: 2, column: 4 },
+ end: { line: 2, column: 6 }
+ }
+ },
+ loc: {
+ start: { line: 2, column: 4 },
+ end: { line: 2, column: 6 }
+ }
+ }],
+ loc: {
+ start: { line: 2, column: 4 },
+ end: { line: 2, column: 6 }
+ },
+ comments: [{
+ type: 'Block',
+ value: 'a\nc',
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 2, column: 3 }
+ }
+ }]
+ },
+
+ '// line comment\n42': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 42,
+ raw: '42',
+ range: [16, 18],
+ loc: {
+ start: { line: 2, column: 0 },
+ end: { line: 2, column: 2 }
+ }
+ },
+ range: [16, 18],
+ loc: {
+ start: { line: 2, column: 0 },
+ end: { line: 2, column: 2 }
+ }
+ },
+
+ '42 // line comment': {
+ type: 'Program',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 42,
+ raw: '42',
+ range: [0, 2],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 2 }
+ }
+ },
+ range: [0, 18],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 18 }
+ }
+ }],
+ range: [0, 18],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 18 }
+ },
+ comments: [{
+ type: 'Line',
+ value: ' line comment',
+ range: [3, 18],
+ loc: {
+ start: { line: 1, column: 3 },
+ end: { line: 1, column: 18 }
+ }
+ }]
+ },
+
+ '// Hello, world!\n42': {
+ type: 'Program',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 42,
+ raw: '42',
+ range: [17, 19],
+ loc: {
+ start: { line: 2, column: 0 },
+ end: { line: 2, column: 2 }
+ }
+ },
+ range: [17, 19],
+ loc: {
+ start: { line: 2, column: 0 },
+ end: { line: 2, column: 2 }
+ }
+ }],
+ range: [17, 19],
+ loc: {
+ start: { line: 2, column: 0 },
+ end: { line: 2, column: 2 }
+ },
+ comments: [{
+ type: 'Line',
+ value: ' Hello, world!',
+ range: [0, 16],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 16 }
+ }
+ }]
+ },
+
+ '// Hello, world!\n': {
+ type: 'Program',
+ body: [],
+ range: [17, 17],
+ loc: {
+ start: { line: 2, column: 0 },
+ end: { line: 2, column: 0 }
+ },
+ comments: [{
+ type: 'Line',
+ value: ' Hello, world!',
+ range: [0, 16],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 16 }
+ }
+ }]
+ },
+
+ '// Hallo, world!\n': {
+ type: 'Program',
+ body: [],
+ loc: {
+ start: { line: 2, column: 0 },
+ end: { line: 2, column: 0 }
+ },
+ comments: [{
+ type: 'Line',
+ value: ' Hallo, world!',
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 16 }
+ }
+ }]
+ },
+
+ '//\n42': {
+ type: 'Program',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 42,
+ raw: '42',
+ range: [3, 5],
+ loc: {
+ start: { line: 2, column: 0 },
+ end: { line: 2, column: 2 }
+ }
+ },
+ range: [3, 5],
+ loc: {
+ start: { line: 2, column: 0 },
+ end: { line: 2, column: 2 }
+ }
+ }],
+ range: [3, 5],
+ loc: {
+ start: { line: 2, column: 0 },
+ end: { line: 2, column: 2 }
+ },
+ comments: [{
+ type: 'Line',
+ value: '',
+ range: [0, 2],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 2 }
+ }
+ }]
+ },
+
+ '//': {
+ type: 'Program',
+ body: [],
+ range: [2, 2],
+ loc: {
+ start: { line: 1, column: 2 },
+ end: { line: 1, column: 2 }
+ },
+ comments: [{
+ type: 'Line',
+ value: '',
+ range: [0, 2],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 2 }
+ }
+ }]
+ },
+
+ '// ': {
+ type: 'Program',
+ body: [],
+ range: [3, 3],
+ comments: [{
+ type: 'Line',
+ value: ' ',
+ range: [0, 3]
+ }]
+ },
+
+ '/**/42': {
+ type: 'Program',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 42,
+ raw: '42',
+ range: [4, 6],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 6 }
+ }
+ },
+ range: [4, 6],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 6 }
+ }
+ }],
+ range: [4, 6],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 6 }
+ },
+ comments: [{
+ type: 'Block',
+ value: '',
+ range: [0, 4],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 4 }
+ }
+ }]
+ },
+
+ '// Hello, world!\n\n// Another hello\n42': {
+ type: 'Program',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 42,
+ raw: '42',
+ range: [37, 39],
+ loc: {
+ start: { line: 4, column: 0 },
+ end: { line: 4, column: 2 }
+ }
+ },
+ range: [37, 39],
+ loc: {
+ start: { line: 4, column: 0 },
+ end: { line: 4, column: 2 }
+ }
+ }],
+ range: [37, 39],
+ loc: {
+ start: { line: 4, column: 0 },
+ end: { line: 4, column: 2 }
+ },
+ comments: [{
+ type: 'Line',
+ value: ' Hello, world!',
+ range: [0, 16],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 16 }
+ }
+ }, {
+ type: 'Line',
+ value: ' Another hello',
+ range: [18, 36],
+ loc: {
+ start: { line: 3, column: 0 },
+ end: { line: 3, column: 18 }
+ }
+ }]
+ },
+
+ 'if (x) { // Some comment\ndoThat(); }': {
+ type: 'Program',
+ body: [{
+ type: 'IfStatement',
+ test: {
+ type: 'Identifier',
+ name: 'x',
+ range: [4, 5],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ consequent: {
+ type: 'BlockStatement',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'CallExpression',
+ callee: {
+ type: 'Identifier',
+ name: 'doThat',
+ range: [25, 31],
+ loc: {
+ start: { line: 2, column: 0 },
+ end: { line: 2, column: 6 }
+ }
+ },
+ 'arguments': [],
+ range: [25, 33],
+ loc: {
+ start: { line: 2, column: 0 },
+ end: { line: 2, column: 8 }
+ }
+ },
+ range: [25, 34],
+ loc: {
+ start: { line: 2, column: 0 },
+ end: { line: 2, column: 9 }
+ }
+ }],
+ range: [7, 36],
+ loc: {
+ start: { line: 1, column: 7 },
+ end: { line: 2, column: 11 }
+ }
+ },
+ alternate: null,
+ range: [0, 36],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 2, column: 11 }
+ }
+ }],
+ range: [0, 36],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 2, column: 11 }
+ },
+ comments: [{
+ type: 'Line',
+ value: ' Some comment',
+ range: [9, 24],
+ loc: {
+ start: { line: 1, column: 9 },
+ end: { line: 1, column: 24 }
+ }
+ }]
+ },
+
+ 'switch (answer) { case 42: /* perfect */ bingo() }': {
+ type: 'Program',
+ body: [{
+ type: 'SwitchStatement',
+ discriminant: {
+ type: 'Identifier',
+ name: 'answer',
+ range: [8, 14],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 14 }
+ }
+ },
+ cases: [{
+ type: 'SwitchCase',
+ test: {
+ type: 'Literal',
+ value: 42,
+ raw: '42',
+ range: [23, 25],
+ loc: {
+ start: { line: 1, column: 23 },
+ end: { line: 1, column: 25 }
+ }
+ },
+ consequent: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'CallExpression',
+ callee: {
+ type: 'Identifier',
+ name: 'bingo',
+ range: [41, 46],
+ loc: {
+ start: { line: 1, column: 41 },
+ end: { line: 1, column: 46 }
+ }
+ },
+ 'arguments': [],
+ range: [41, 48],
+ loc: {
+ start: { line: 1, column: 41 },
+ end: { line: 1, column: 48 }
+ }
+ },
+ range: [41, 49],
+ loc: {
+ start: { line: 1, column: 41 },
+ end: { line: 1, column: 49 }
+ }
+ }],
+ range: [18, 49],
+ loc: {
+ start: { line: 1, column: 18 },
+ end: { line: 1, column: 49 }
+ }
+ }],
+ range: [0, 50],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 50 }
+ }
+ }],
+ range: [0, 50],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 50 }
+ },
+ comments: [{
+ type: 'Block',
+ value: ' perfect ',
+ range: [27, 40],
+ loc: {
+ start: { line: 1, column: 27 },
+ end: { line: 1, column: 40 }
+ }
+ }]
+ }
+
+ },
+
+ 'Numeric Literals': {
+
+ '0': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 0,
+ raw: '0',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+
+ '42': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 42,
+ raw: '42',
+ range: [0, 2],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 2 }
+ }
+ },
+ range: [0, 2],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 2 }
+ }
+ },
+
+ '3': {
+ type: 'Program',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 3,
+ raw: '3',
+ range: [0, 1]
+ },
+ range: [0, 1]
+ }],
+ range: [0, 1],
+ tokens: [{
+ type: 'Numeric',
+ value: '3',
+ range: [0, 1]
+ }]
+ },
+
+ '5': {
+ type: 'Program',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 5,
+ raw: '5',
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ }],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ },
+ tokens: [{
+ type: 'Numeric',
+ value: '5',
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ }]
+ },
+
+ '.14': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 0.14,
+ raw: '.14',
+ range: [0, 3],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 3 }
+ }
+ },
+ range: [0, 3],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 3 }
+ }
+ },
+
+ '3.14159': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 3.14159,
+ raw: '3.14159',
+ range: [0, 7],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 7 }
+ }
+ },
+ range: [0, 7],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 7 }
+ }
+ },
+
+ '6.02214179e+23': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 6.02214179e+23,
+ raw: '6.02214179e+23',
+ range: [0, 14],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 14 }
+ }
+ },
+ range: [0, 14],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 14 }
+ }
+ },
+
+ '1.492417830e-10': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 1.49241783e-10,
+ raw: '1.492417830e-10',
+ range: [0, 15],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 15 }
+ }
+ },
+ range: [0, 15],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 15 }
+ }
+ },
+
+ '0x0': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 0,
+ raw: '0x0',
+ range: [0, 3],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 3 }
+ }
+ },
+ range: [0, 3],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 3 }
+ }
+ },
+
+ '0e+100': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 0,
+ raw: '0e+100',
+ range: [0, 6],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 6 }
+ }
+ },
+ range: [0, 6],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 6 }
+ }
+ },
+
+ '0xabc': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 0xabc,
+ raw: '0xabc',
+ range: [0, 5],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ range: [0, 5],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 5 }
+ }
+ },
+
+ '0xdef': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 0xdef,
+ raw: '0xdef',
+ range: [0, 5],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ range: [0, 5],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 5 }
+ }
+ },
+
+ '0X1A': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 0x1A,
+ raw: '0X1A',
+ range: [0, 4],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 4 }
+ }
+ },
+ range: [0, 4],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 4 }
+ }
+ },
+
+ '0x10': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 0x10,
+ raw: '0x10',
+ range: [0, 4],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 4 }
+ }
+ },
+ range: [0, 4],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 4 }
+ }
+ },
+
+ '0x100': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 0x100,
+ raw: '0x100',
+ range: [0, 5],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ range: [0, 5],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 5 }
+ }
+ },
+
+ '0X04': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 0X04,
+ raw: '0X04',
+ range: [0, 4],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 4 }
+ }
+ },
+ range: [0, 4],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 4 }
+ }
+ },
+
+ '02': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 2,
+ raw: '02',
+ range: [0, 2],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 2 }
+ }
+ },
+ range: [0, 2],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 2 }
+ }
+ },
+
+ '012': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 10,
+ raw: '012',
+ range: [0, 3],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 3 }
+ }
+ },
+ range: [0, 3],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 3 }
+ }
+ },
+
+ '0012': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 10,
+ raw: '0012',
+ range: [0, 4],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 4 }
+ }
+ },
+ range: [0, 4],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 4 }
+ }
+ }
+
+ },
+
+ 'String Literals': {
+
+ '"Hello"': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 'Hello',
+ raw: '"Hello"',
+ range: [0, 7],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 7 }
+ }
+ },
+ range: [0, 7],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 7 }
+ }
+ },
+
+ '"\\n\\r\\t\\v\\b\\f\\\\\\\'\\"\\0"': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: '\n\r\t\x0B\b\f\\\'"\x00',
+ raw: '"\\n\\r\\t\\v\\b\\f\\\\\\\'\\"\\0"',
+ range: [0, 22],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 22 }
+ }
+ },
+ range: [0, 22],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 22 }
+ }
+ },
+
+ '"\\u0061"': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 'a',
+ raw: '"\\u0061"',
+ range: [0, 8],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 8 }
+ }
+ },
+ range: [0, 8],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 8 }
+ }
+ },
+
+ '"\\x61"': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 'a',
+ raw: '"\\x61"',
+ range: [0, 6],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 6 }
+ }
+ },
+ range: [0, 6],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 6 }
+ }
+ },
+
+ '"\\u00"': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 'u00',
+ raw: '"\\u00"',
+ range: [0, 6],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 6 }
+ }
+ },
+ range: [0, 6],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 6 }
+ }
+ },
+
+ '"\\xt"': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 'xt',
+ raw: '"\\xt"',
+ range: [0, 5],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ range: [0, 5],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 5 }
+ }
+ },
+
+ '"Hello\\nworld"': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 'Hello\nworld',
+ raw: '"Hello\\nworld"',
+ range: [0, 14],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 14 }
+ }
+ },
+ range: [0, 14],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 14 }
+ }
+ },
+
+ '"Hello\\\nworld"': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 'Helloworld',
+ raw: '"Hello\\\nworld"',
+ range: [0, 14],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 2, column: 14 }
+ }
+ },
+ range: [0, 14],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 2, column: 14 }
+ }
+ },
+
+ '"Hello\\02World"': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 'Hello\u0002World',
+ raw: '"Hello\\02World"',
+ range: [0, 15],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 15 }
+ }
+ },
+ range: [0, 15],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 15 }
+ }
+ },
+
+ '"Hello\\012World"': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 'Hello\u000AWorld',
+ raw: '"Hello\\012World"',
+ range: [0, 16],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 16 }
+ }
+ },
+ range: [0, 16],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 16 }
+ }
+ },
+
+ '"Hello\\122World"': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 'Hello\122World',
+ raw: '"Hello\\122World"',
+ range: [0, 16],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 16 }
+ }
+ },
+ range: [0, 16],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 16 }
+ }
+ },
+
+ '"Hello\\0122World"': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 'Hello\u000A2World',
+ raw: '"Hello\\0122World"',
+ range: [0, 17],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 17 }
+ }
+ },
+ range: [0, 17],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 17 }
+ }
+ },
+
+ '"Hello\\312World"': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 'Hello\u00CAWorld',
+ raw: '"Hello\\312World"',
+ range: [0, 16],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 16 }
+ }
+ },
+ range: [0, 16],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 16 }
+ }
+ },
+
+ '"Hello\\412World"': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 'Hello\412World',
+ raw: '"Hello\\412World"',
+ range: [0, 16],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 16 }
+ }
+ },
+ range: [0, 16],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 16 }
+ }
+ },
+
+ '"Hello\\812World"': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 'Hello812World',
+ raw: '"Hello\\812World"',
+ range: [0, 16],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 16 }
+ }
+ },
+ range: [0, 16],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 16 }
+ }
+ },
+
+ '"Hello\\712World"': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 'Hello\712World',
+ raw: '"Hello\\712World"',
+ range: [0, 16],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 16 }
+ }
+ },
+ range: [0, 16],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 16 }
+ }
+ },
+
+ '"Hello\\0World"': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 'Hello\u0000World',
+ raw: '"Hello\\0World"',
+ range: [0, 14],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 14 }
+ }
+ },
+ range: [0, 14],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 14 }
+ }
+ },
+
+ '"Hello\\\r\nworld"': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 'Helloworld',
+ raw: '"Hello\\\r\nworld"',
+ range: [0, 15],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 2, column: 15 }
+ }
+ },
+ range: [0, 15],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 2, column: 15 }
+ }
+ },
+
+ '"Hello\\1World"': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 'Hello\u0001World',
+ raw: '"Hello\\1World"',
+ range: [0, 14],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 14 }
+ }
+ },
+ range: [0, 14],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 14 }
+ }
+ }
+ },
+
+ 'Regular Expression Literals': {
+
+ 'var x = /[a-z]/i': {
+ type: 'Program',
+ body: [{
+ type: 'VariableDeclaration',
+ declarations: [{
+ type: 'VariableDeclarator',
+ id: {
+ type: 'Identifier',
+ name: 'x',
+ range: [4, 5],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ init: {
+ type: 'Literal',
+ value: '/[a-z]/i',
+ raw: '/[a-z]/i',
+ range: [8, 16],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 16 }
+ }
+ },
+ range: [4, 16],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 16 }
+ }
+ }],
+ kind: 'var',
+ range: [0, 16],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 16 }
+ }
+ }],
+ range: [0, 16],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 16 }
+ },
+ tokens: [{
+ type: 'Keyword',
+ value: 'var',
+ range: [0, 3],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 3 }
+ }
+ }, {
+ type: 'Identifier',
+ value: 'x',
+ range: [4, 5],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ }, {
+ type: 'Punctuator',
+ value: '=',
+ range: [6, 7],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 7 }
+ }
+ }, {
+ type: 'RegularExpression',
+ value: '/[a-z]/i',
+ range: [8, 16],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 16 }
+ }
+ }]
+ },
+
+ 'var x = /[x-z]/i': {
+ type: 'Program',
+ body: [{
+ type: 'VariableDeclaration',
+ declarations: [{
+ type: 'VariableDeclarator',
+ id: {
+ type: 'Identifier',
+ name: 'x',
+ range: [4, 5]
+ },
+ init: {
+ type: 'Literal',
+ value: '/[x-z]/i',
+ raw: '/[x-z]/i',
+ range: [8, 16]
+ },
+ range: [4, 16]
+ }],
+ kind: 'var',
+ range: [0, 16]
+ }],
+ range: [0, 16],
+ tokens: [{
+ type: 'Keyword',
+ value: 'var',
+ range: [0, 3]
+ }, {
+ type: 'Identifier',
+ value: 'x',
+ range: [4, 5]
+ }, {
+ type: 'Punctuator',
+ value: '=',
+ range: [6, 7]
+ }, {
+ type: 'RegularExpression',
+ value: '/[x-z]/i',
+ range: [8, 16]
+ }]
+ },
+
+ 'var x = /[a-c]/i': {
+ type: 'Program',
+ body: [{
+ type: 'VariableDeclaration',
+ declarations: [{
+ type: 'VariableDeclarator',
+ id: {
+ type: 'Identifier',
+ name: 'x',
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ init: {
+ type: 'Literal',
+ value: '/[a-c]/i',
+ raw: '/[a-c]/i',
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 16 }
+ }
+ },
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 16 }
+ }
+ }],
+ kind: 'var',
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 16 }
+ }
+ }],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 16 }
+ },
+ tokens: [{
+ type: 'Keyword',
+ value: 'var',
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 3 }
+ }
+ }, {
+ type: 'Identifier',
+ value: 'x',
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ }, {
+ type: 'Punctuator',
+ value: '=',
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 7 }
+ }
+ }, {
+ type: 'RegularExpression',
+ value: '/[a-c]/i',
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 16 }
+ }
+ }]
+ },
+
+ 'var x = /[P QR]/i': {
+ type: 'Program',
+ body: [{
+ type: 'VariableDeclaration',
+ declarations: [{
+ type: 'VariableDeclarator',
+ id: {
+ type: 'Identifier',
+ name: 'x',
+ range: [4, 5],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ init: {
+ type: 'Literal',
+ value: '/[P QR]/i',
+ raw: '/[P QR]/i',
+ range: [8, 17],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 17 }
+ }
+ },
+ range: [4, 17],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 17 }
+ }
+ }],
+ kind: 'var',
+ range: [0, 17],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 17 }
+ }
+ }],
+ range: [0, 17],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 17 }
+ },
+ tokens: [{
+ type: 'Keyword',
+ value: 'var',
+ range: [0, 3],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 3 }
+ }
+ }, {
+ type: 'Identifier',
+ value: 'x',
+ range: [4, 5],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ }, {
+ type: 'Punctuator',
+ value: '=',
+ range: [6, 7],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 7 }
+ }
+ }, {
+ type: 'RegularExpression',
+ value: '/[P QR]/i',
+ range: [8, 17],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 17 }
+ }
+ }]
+ },
+
+ 'var x = /[\\]/]/': {
+ type: 'Program',
+ body: [{
+ type: 'VariableDeclaration',
+ declarations: [{
+ type: 'VariableDeclarator',
+ id: {
+ type: 'Identifier',
+ name: 'x',
+ range: [4, 5],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ init: {
+ type: 'Literal',
+ value: new RegExp('[\\]/]').toString(),
+ raw: '/[\\]/]/',
+ range: [8, 15],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 15 }
+ }
+ },
+ range: [4, 15],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 15 }
+ }
+ }],
+ kind: 'var',
+ range: [0, 15],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 15 }
+ }
+ }],
+ range: [0, 15],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 15 }
+ },
+ tokens: [{
+ type: 'Keyword',
+ value: 'var',
+ range: [0, 3],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 3 }
+ }
+ }, {
+ type: 'Identifier',
+ value: 'x',
+ range: [4, 5],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ }, {
+ type: 'Punctuator',
+ value: '=',
+ range: [6, 7],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 7 }
+ }
+ }, {
+ type: 'RegularExpression',
+ value: '/[\\]/]/',
+ range: [8, 15],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 15 }
+ }
+ }]
+ },
+
+ 'var x = /foo\\/bar/': {
+ type: 'Program',
+ body: [{
+ type: 'VariableDeclaration',
+ declarations: [{
+ type: 'VariableDeclarator',
+ id: {
+ type: 'Identifier',
+ name: 'x',
+ range: [4, 5],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ init: {
+ type: 'Literal',
+ value: '/foo\\/bar/',
+ raw: '/foo\\/bar/',
+ range: [8, 18],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 18 }
+ }
+ },
+ range: [4, 18],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 18 }
+ }
+ }],
+ kind: 'var',
+ range: [0, 18],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 18 }
+ }
+ }],
+ range: [0, 18],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 18 }
+ },
+ tokens: [{
+ type: 'Keyword',
+ value: 'var',
+ range: [0, 3],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 3 }
+ }
+ }, {
+ type: 'Identifier',
+ value: 'x',
+ range: [4, 5],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ }, {
+ type: 'Punctuator',
+ value: '=',
+ range: [6, 7],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 7 }
+ }
+ }, {
+ type: 'RegularExpression',
+ value: '/foo\\/bar/',
+ range: [8, 18],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 18 }
+ }
+ }]
+ },
+
+ 'var x = /=([^=\\s])+/g': {
+ type: 'Program',
+ body: [{
+ type: 'VariableDeclaration',
+ declarations: [{
+ type: 'VariableDeclarator',
+ id: {
+ type: 'Identifier',
+ name: 'x',
+ range: [4, 5],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ init: {
+ type: 'Literal',
+ value: '/=([^=\\s])+/g',
+ raw: '/=([^=\\s])+/g',
+ range: [8, 21],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 21 }
+ }
+ },
+ range: [4, 21],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 21 }
+ }
+ }],
+ kind: 'var',
+ range: [0, 21],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 21 }
+ }
+ }],
+ range: [0, 21],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 21 }
+ },
+ tokens: [{
+ type: 'Keyword',
+ value: 'var',
+ range: [0, 3],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 3 }
+ }
+ }, {
+ type: 'Identifier',
+ value: 'x',
+ range: [4, 5],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ }, {
+ type: 'Punctuator',
+ value: '=',
+ range: [6, 7],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 7 }
+ }
+ }, {
+ type: 'RegularExpression',
+ value: '/=([^=\\s])+/g',
+ range: [8, 21],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 21 }
+ }
+ }]
+ },
+
+ 'var x = /[P QR]/\\u0067': {
+ type: 'Program',
+ body: [{
+ type: 'VariableDeclaration',
+ declarations: [{
+ type: 'VariableDeclarator',
+ id: {
+ type: 'Identifier',
+ name: 'x',
+ range: [4, 5],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ init: {
+ type: 'Literal',
+ value: '/[P QR]/g',
+ raw: '/[P QR]/\\u0067',
+ range: [8, 22],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 22 }
+ }
+ },
+ range: [4, 22],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 22 }
+ }
+ }],
+ kind: 'var',
+ range: [0, 22],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 22 }
+ }
+ }],
+ range: [0, 22],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 22 }
+ },
+ tokens: [{
+ type: 'Keyword',
+ value: 'var',
+ range: [0, 3],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 3 }
+ }
+ }, {
+ type: 'Identifier',
+ value: 'x',
+ range: [4, 5],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ }, {
+ type: 'Punctuator',
+ value: '=',
+ range: [6, 7],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 7 }
+ }
+ }, {
+ type: 'RegularExpression',
+ value: '/[P QR]/\\u0067',
+ range: [8, 22],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 22 }
+ }
+ }]
+ },
+
+ 'var x = /[P QR]/\\g': {
+ type: 'Program',
+ body: [{
+ type: 'VariableDeclaration',
+ declarations: [{
+ type: 'VariableDeclarator',
+ id: {
+ type: 'Identifier',
+ name: 'x',
+ range: [4, 5],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ init: {
+ type: 'Literal',
+ value: '/[P QR]/g',
+ raw: '/[P QR]/\\g',
+ range: [8, 18],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 18 }
+ }
+ },
+ range: [4, 18],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 18 }
+ }
+ }],
+ kind: 'var',
+ range: [0, 18],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 18 }
+ }
+ }],
+ range: [0, 18],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 18 }
+ },
+ tokens: [{
+ type: 'Keyword',
+ value: 'var',
+ range: [0, 3],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 3 }
+ }
+ }, {
+ type: 'Identifier',
+ value: 'x',
+ range: [4, 5],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ }, {
+ type: 'Punctuator',
+ value: '=',
+ range: [6, 7],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 7 }
+ }
+ }, {
+ type: 'RegularExpression',
+ value: '/[P QR]/\\g',
+ range: [8, 18],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 18 }
+ }
+ }]
+ }
+
+ },
+
+ 'Left-Hand-Side Expression': {
+
+ 'new Button': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'NewExpression',
+ callee: {
+ type: 'Identifier',
+ name: 'Button',
+ range: [4, 10],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 10 }
+ }
+ },
+ 'arguments': [],
+ range: [0, 10],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 10 }
+ }
+ },
+ range: [0, 10],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 10 }
+ }
+ },
+
+ 'new Button()': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'NewExpression',
+ callee: {
+ type: 'Identifier',
+ name: 'Button',
+ range: [4, 10],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 10 }
+ }
+ },
+ 'arguments': [],
+ range: [0, 12],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 12 }
+ }
+ },
+ range: [0, 12],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 12 }
+ }
+ },
+
+ 'new new foo': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'NewExpression',
+ callee: {
+ type: 'NewExpression',
+ callee: {
+ type: 'Identifier',
+ name: 'foo',
+ range: [8, 11],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 11 }
+ }
+ },
+ 'arguments': [],
+ range: [4, 11],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 11 }
+ }
+ },
+ 'arguments': [],
+ range: [0, 11],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 11 }
+ }
+ },
+ range: [0, 11],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 11 }
+ }
+ },
+
+ 'new new foo()': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'NewExpression',
+ callee: {
+ type: 'NewExpression',
+ callee: {
+ type: 'Identifier',
+ name: 'foo',
+ range: [8, 11],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 11 }
+ }
+ },
+ 'arguments': [],
+ range: [4, 13],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 13 }
+ }
+ },
+ 'arguments': [],
+ range: [0, 13],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 13 }
+ }
+ },
+ range: [0, 13],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 13 }
+ }
+ },
+
+ 'new foo().bar()': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'CallExpression',
+ callee: {
+ type: 'MemberExpression',
+ computed: false,
+ object: {
+ type: 'NewExpression',
+ callee: {
+ type: 'Identifier',
+ name: 'foo',
+ range: [4, 7],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 7 }
+ }
+ },
+ 'arguments': [],
+ range: [0, 9],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ property: {
+ type: 'Identifier',
+ name: 'bar',
+ range: [10, 13],
+ loc: {
+ start: { line: 1, column: 10 },
+ end: { line: 1, column: 13 }
+ }
+ },
+ range: [0, 13],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 13 }
+ }
+ },
+ 'arguments': [],
+ range: [0, 15],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 15 }
+ }
+ },
+ range: [0, 15],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 15 }
+ }
+ },
+
+ 'new foo[bar]': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'NewExpression',
+ callee: {
+ type: 'MemberExpression',
+ computed: true,
+ object: {
+ type: 'Identifier',
+ name: 'foo',
+ range: [4, 7],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 7 }
+ }
+ },
+ property: {
+ type: 'Identifier',
+ name: 'bar',
+ range: [8, 11],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 11 }
+ }
+ },
+ range: [4, 12],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 12 }
+ }
+ },
+ 'arguments': [],
+ range: [0, 12],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 12 }
+ }
+ },
+ range: [0, 12],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 12 }
+ }
+ },
+
+ 'new foo.bar()': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'NewExpression',
+ callee: {
+ type: 'MemberExpression',
+ computed: false,
+ object: {
+ type: 'Identifier',
+ name: 'foo',
+ range: [4, 7],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 7 }
+ }
+ },
+ property: {
+ type: 'Identifier',
+ name: 'bar',
+ range: [8, 11],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 11 }
+ }
+ },
+ range: [4, 11],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 11 }
+ }
+ },
+ 'arguments': [],
+ range: [0, 13],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 13 }
+ }
+ },
+ range: [0, 13],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 13 }
+ }
+ },
+
+ '( new foo).bar()': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'CallExpression',
+ callee: {
+ type: 'MemberExpression',
+ computed: false,
+ object: {
+ type: 'NewExpression',
+ callee: {
+ type: 'Identifier',
+ name: 'foo',
+ range: [6, 9],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ 'arguments': [],
+ range: [2, 9],
+ loc: {
+ start: { line: 1, column: 2 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ property: {
+ type: 'Identifier',
+ name: 'bar',
+ range: [11, 14],
+ loc: {
+ start: { line: 1, column: 11 },
+ end: { line: 1, column: 14 }
+ }
+ },
+ range: [0, 14],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 14 }
+ }
+ },
+ 'arguments': [],
+ range: [0, 16],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 16 }
+ }
+ },
+ range: [0, 16],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 16 }
+ }
+ },
+
+ 'foo(bar, baz)': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'CallExpression',
+ callee: {
+ type: 'Identifier',
+ name: 'foo',
+ range: [0, 3],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 3 }
+ }
+ },
+ 'arguments': [{
+ type: 'Identifier',
+ name: 'bar',
+ range: [4, 7],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 7 }
+ }
+ }, {
+ type: 'Identifier',
+ name: 'baz',
+ range: [9, 12],
+ loc: {
+ start: { line: 1, column: 9 },
+ end: { line: 1, column: 12 }
+ }
+ }],
+ range: [0, 13],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 13 }
+ }
+ },
+ range: [0, 13],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 13 }
+ }
+ },
+
+ '( foo )()': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'CallExpression',
+ callee: {
+ type: 'Identifier',
+ name: 'foo',
+ range: [5, 8],
+ loc: {
+ start: { line: 1, column: 5 },
+ end: { line: 1, column: 8 }
+ }
+ },
+ 'arguments': [],
+ range: [0, 13],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 13 }
+ }
+ },
+ range: [0, 13],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 13 }
+ }
+ },
+
+ 'universe.milkyway': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'MemberExpression',
+ computed: false,
+ object: {
+ type: 'Identifier',
+ name: 'universe',
+ range: [0, 8],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 8 }
+ }
+ },
+ property: {
+ type: 'Identifier',
+ name: 'milkyway',
+ range: [9, 17],
+ loc: {
+ start: { line: 1, column: 9 },
+ end: { line: 1, column: 17 }
+ }
+ },
+ range: [0, 17],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 17 }
+ }
+ },
+ range: [0, 17],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 17 }
+ }
+ },
+
+ 'universe.milkyway.solarsystem': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'MemberExpression',
+ computed: false,
+ object: {
+ type: 'MemberExpression',
+ computed: false,
+ object: {
+ type: 'Identifier',
+ name: 'universe',
+ range: [0, 8],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 8 }
+ }
+ },
+ property: {
+ type: 'Identifier',
+ name: 'milkyway',
+ range: [9, 17],
+ loc: {
+ start: { line: 1, column: 9 },
+ end: { line: 1, column: 17 }
+ }
+ },
+ range: [0, 17],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 17 }
+ }
+ },
+ property: {
+ type: 'Identifier',
+ name: 'solarsystem',
+ range: [18, 29],
+ loc: {
+ start: { line: 1, column: 18 },
+ end: { line: 1, column: 29 }
+ }
+ },
+ range: [0, 29],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 29 }
+ }
+ },
+ range: [0, 29],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 29 }
+ }
+ },
+
+ 'universe.milkyway.solarsystem.Earth': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'MemberExpression',
+ computed: false,
+ object: {
+ type: 'MemberExpression',
+ computed: false,
+ object: {
+ type: 'MemberExpression',
+ computed: false,
+ object: {
+ type: 'Identifier',
+ name: 'universe',
+ range: [0, 8],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 8 }
+ }
+ },
+ property: {
+ type: 'Identifier',
+ name: 'milkyway',
+ range: [9, 17],
+ loc: {
+ start: { line: 1, column: 9 },
+ end: { line: 1, column: 17 }
+ }
+ },
+ range: [0, 17],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 17 }
+ }
+ },
+ property: {
+ type: 'Identifier',
+ name: 'solarsystem',
+ range: [18, 29],
+ loc: {
+ start: { line: 1, column: 18 },
+ end: { line: 1, column: 29 }
+ }
+ },
+ range: [0, 29],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 29 }
+ }
+ },
+ property: {
+ type: 'Identifier',
+ name: 'Earth',
+ range: [30, 35],
+ loc: {
+ start: { line: 1, column: 30 },
+ end: { line: 1, column: 35 }
+ }
+ },
+ range: [0, 35],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 35 }
+ }
+ },
+ range: [0, 35],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 35 }
+ }
+ },
+
+ 'universe[galaxyName, otherUselessName]': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'MemberExpression',
+ computed: true,
+ object: {
+ type: 'Identifier',
+ name: 'universe',
+ range: [0, 8],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 8 }
+ }
+ },
+ property: {
+ type: 'SequenceExpression',
+ expressions: [{
+ type: 'Identifier',
+ name: 'galaxyName',
+ range: [9, 19],
+ loc: {
+ start: { line: 1, column: 9 },
+ end: { line: 1, column: 19 }
+ }
+ }, {
+ type: 'Identifier',
+ name: 'otherUselessName',
+ range: [21, 37],
+ loc: {
+ start: { line: 1, column: 21 },
+ end: { line: 1, column: 37 }
+ }
+ }],
+ range: [9, 37],
+ loc: {
+ start: { line: 1, column: 9 },
+ end: { line: 1, column: 37 }
+ }
+ },
+ range: [0, 38],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 38 }
+ }
+ },
+ range: [0, 38],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 38 }
+ }
+ },
+
+ 'universe[galaxyName]': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'MemberExpression',
+ computed: true,
+ object: {
+ type: 'Identifier',
+ name: 'universe',
+ range: [0, 8],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 8 }
+ }
+ },
+ property: {
+ type: 'Identifier',
+ name: 'galaxyName',
+ range: [9, 19],
+ loc: {
+ start: { line: 1, column: 9 },
+ end: { line: 1, column: 19 }
+ }
+ },
+ range: [0, 20],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 20 }
+ }
+ },
+ range: [0, 20],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 20 }
+ }
+ },
+
+ 'universe[42].galaxies': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'MemberExpression',
+ computed: false,
+ object: {
+ type: 'MemberExpression',
+ computed: true,
+ object: {
+ type: 'Identifier',
+ name: 'universe',
+ range: [0, 8],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 8 }
+ }
+ },
+ property: {
+ type: 'Literal',
+ value: 42,
+ raw: '42',
+ range: [9, 11],
+ loc: {
+ start: { line: 1, column: 9 },
+ end: { line: 1, column: 11 }
+ }
+ },
+ range: [0, 12],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 12 }
+ }
+ },
+ property: {
+ type: 'Identifier',
+ name: 'galaxies',
+ range: [13, 21],
+ loc: {
+ start: { line: 1, column: 13 },
+ end: { line: 1, column: 21 }
+ }
+ },
+ range: [0, 21],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 21 }
+ }
+ },
+ range: [0, 21],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 21 }
+ }
+ },
+
+ 'universe(42).galaxies': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'MemberExpression',
+ computed: false,
+ object: {
+ type: 'CallExpression',
+ callee: {
+ type: 'Identifier',
+ name: 'universe',
+ range: [0, 8],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 8 }
+ }
+ },
+ 'arguments': [{
+ type: 'Literal',
+ value: 42,
+ raw: '42',
+ range: [9, 11],
+ loc: {
+ start: { line: 1, column: 9 },
+ end: { line: 1, column: 11 }
+ }
+ }],
+ range: [0, 12],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 12 }
+ }
+ },
+ property: {
+ type: 'Identifier',
+ name: 'galaxies',
+ range: [13, 21],
+ loc: {
+ start: { line: 1, column: 13 },
+ end: { line: 1, column: 21 }
+ }
+ },
+ range: [0, 21],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 21 }
+ }
+ },
+ range: [0, 21],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 21 }
+ }
+ },
+
+ 'universe(42).galaxies(14, 3, 77).milkyway': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'MemberExpression',
+ computed: false,
+ object: {
+ type: 'CallExpression',
+ callee: {
+ type: 'MemberExpression',
+ computed: false,
+ object: {
+ type: 'CallExpression',
+ callee: {
+ type: 'Identifier',
+ name: 'universe',
+ range: [0, 8],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 8 }
+ }
+ },
+ 'arguments': [{
+ type: 'Literal',
+ value: 42,
+ raw: '42',
+ range: [9, 11],
+ loc: {
+ start: { line: 1, column: 9 },
+ end: { line: 1, column: 11 }
+ }
+ }],
+ range: [0, 12],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 12 }
+ }
+ },
+ property: {
+ type: 'Identifier',
+ name: 'galaxies',
+ range: [13, 21],
+ loc: {
+ start: { line: 1, column: 13 },
+ end: { line: 1, column: 21 }
+ }
+ },
+ range: [0, 21],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 21 }
+ }
+ },
+ 'arguments': [{
+ type: 'Literal',
+ value: 14,
+ raw: '14',
+ range: [22, 24],
+ loc: {
+ start: { line: 1, column: 22 },
+ end: { line: 1, column: 24 }
+ }
+ }, {
+ type: 'Literal',
+ value: 3,
+ raw: '3',
+ range: [26, 27],
+ loc: {
+ start: { line: 1, column: 26 },
+ end: { line: 1, column: 27 }
+ }
+ }, {
+ type: 'Literal',
+ value: 77,
+ raw: '77',
+ range: [29, 31],
+ loc: {
+ start: { line: 1, column: 29 },
+ end: { line: 1, column: 31 }
+ }
+ }],
+ range: [0, 32],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 32 }
+ }
+ },
+ property: {
+ type: 'Identifier',
+ name: 'milkyway',
+ range: [33, 41],
+ loc: {
+ start: { line: 1, column: 33 },
+ end: { line: 1, column: 41 }
+ }
+ },
+ range: [0, 41],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 41 }
+ }
+ },
+ range: [0, 41],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 41 }
+ }
+ },
+
+ 'earth.asia.Indonesia.prepareForElection(2014)': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'CallExpression',
+ callee: {
+ type: 'MemberExpression',
+ computed: false,
+ object: {
+ type: 'MemberExpression',
+ computed: false,
+ object: {
+ type: 'MemberExpression',
+ computed: false,
+ object: {
+ type: 'Identifier',
+ name: 'earth',
+ range: [0, 5],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ property: {
+ type: 'Identifier',
+ name: 'asia',
+ range: [6, 10],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 10 }
+ }
+ },
+ range: [0, 10],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 10 }
+ }
+ },
+ property: {
+ type: 'Identifier',
+ name: 'Indonesia',
+ range: [11, 20],
+ loc: {
+ start: { line: 1, column: 11 },
+ end: { line: 1, column: 20 }
+ }
+ },
+ range: [0, 20],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 20 }
+ }
+ },
+ property: {
+ type: 'Identifier',
+ name: 'prepareForElection',
+ range: [21, 39],
+ loc: {
+ start: { line: 1, column: 21 },
+ end: { line: 1, column: 39 }
+ }
+ },
+ range: [0, 39],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 39 }
+ }
+ },
+ 'arguments': [{
+ type: 'Literal',
+ value: 2014,
+ raw: '2014',
+ range: [40, 44],
+ loc: {
+ start: { line: 1, column: 40 },
+ end: { line: 1, column: 44 }
+ }
+ }],
+ range: [0, 45],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 45 }
+ }
+ },
+ range: [0, 45],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 45 }
+ }
+ },
+
+ 'universe.if': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'MemberExpression',
+ computed: false,
+ object: {
+ type: 'Identifier',
+ name: 'universe',
+ range: [0, 8],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 8 }
+ }
+ },
+ property: {
+ type: 'Identifier',
+ name: 'if',
+ range: [9, 11],
+ loc: {
+ start: { line: 1, column: 9 },
+ end: { line: 1, column: 11 }
+ }
+ },
+ range: [0, 11],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 11 }
+ }
+ },
+ range: [0, 11],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 11 }
+ }
+ },
+
+ 'universe.true': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'MemberExpression',
+ computed: false,
+ object: {
+ type: 'Identifier',
+ name: 'universe',
+ range: [0, 8],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 8 }
+ }
+ },
+ property: {
+ type: 'Identifier',
+ name: 'true',
+ range: [9, 13],
+ loc: {
+ start: { line: 1, column: 9 },
+ end: { line: 1, column: 13 }
+ }
+ },
+ range: [0, 13],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 13 }
+ }
+ },
+ range: [0, 13],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 13 }
+ }
+ },
+
+ 'universe.false': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'MemberExpression',
+ computed: false,
+ object: {
+ type: 'Identifier',
+ name: 'universe',
+ range: [0, 8],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 8 }
+ }
+ },
+ property: {
+ type: 'Identifier',
+ name: 'false',
+ range: [9, 14],
+ loc: {
+ start: { line: 1, column: 9 },
+ end: { line: 1, column: 14 }
+ }
+ },
+ range: [0, 14],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 14 }
+ }
+ },
+ range: [0, 14],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 14 }
+ }
+ },
+
+ 'universe.null': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'MemberExpression',
+ computed: false,
+ object: {
+ type: 'Identifier',
+ name: 'universe',
+ range: [0, 8],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 8 }
+ }
+ },
+ property: {
+ type: 'Identifier',
+ name: 'null',
+ range: [9, 13],
+ loc: {
+ start: { line: 1, column: 9 },
+ end: { line: 1, column: 13 }
+ }
+ },
+ range: [0, 13],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 13 }
+ }
+ },
+ range: [0, 13],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 13 }
+ }
+ }
+
+ },
+
+ 'Postfix Expressions': {
+
+ 'x++': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'UpdateExpression',
+ operator: '++',
+ argument: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ prefix: false,
+ range: [0, 3],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 3 }
+ }
+ },
+ range: [0, 3],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 3 }
+ }
+ },
+
+ 'x--': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'UpdateExpression',
+ operator: '--',
+ argument: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ prefix: false,
+ range: [0, 3],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 3 }
+ }
+ },
+ range: [0, 3],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 3 }
+ }
+ },
+
+ 'eval++': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'UpdateExpression',
+ operator: '++',
+ argument: {
+ type: 'Identifier',
+ name: 'eval',
+ range: [0, 4],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 4 }
+ }
+ },
+ prefix: false,
+ range: [0, 6],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 6 }
+ }
+ },
+ range: [0, 6],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 6 }
+ }
+ },
+
+ 'eval--': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'UpdateExpression',
+ operator: '--',
+ argument: {
+ type: 'Identifier',
+ name: 'eval',
+ range: [0, 4],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 4 }
+ }
+ },
+ prefix: false,
+ range: [0, 6],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 6 }
+ }
+ },
+ range: [0, 6],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 6 }
+ }
+ },
+
+ 'arguments++': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'UpdateExpression',
+ operator: '++',
+ argument: {
+ type: 'Identifier',
+ name: 'arguments',
+ range: [0, 9],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ prefix: false,
+ range: [0, 11],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 11 }
+ }
+ },
+ range: [0, 11],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 11 }
+ }
+ },
+
+ 'arguments--': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'UpdateExpression',
+ operator: '--',
+ argument: {
+ type: 'Identifier',
+ name: 'arguments',
+ range: [0, 9],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ prefix: false,
+ range: [0, 11],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 11 }
+ }
+ },
+ range: [0, 11],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 11 }
+ }
+ }
+
+ },
+
+ 'Unary Operators': {
+
+ '++x': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'UpdateExpression',
+ operator: '++',
+ argument: {
+ type: 'Identifier',
+ name: 'x',
+ range: [2, 3],
+ loc: {
+ start: { line: 1, column: 2 },
+ end: { line: 1, column: 3 }
+ }
+ },
+ prefix: true,
+ range: [0, 3],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 3 }
+ }
+ },
+ range: [0, 3],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 3 }
+ }
+ },
+
+ '--x': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'UpdateExpression',
+ operator: '--',
+ argument: {
+ type: 'Identifier',
+ name: 'x',
+ range: [2, 3],
+ loc: {
+ start: { line: 1, column: 2 },
+ end: { line: 1, column: 3 }
+ }
+ },
+ prefix: true,
+ range: [0, 3],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 3 }
+ }
+ },
+ range: [0, 3],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 3 }
+ }
+ },
+
+ '++eval': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'UpdateExpression',
+ operator: '++',
+ argument: {
+ type: 'Identifier',
+ name: 'eval',
+ range: [2, 6],
+ loc: {
+ start: { line: 1, column: 2 },
+ end: { line: 1, column: 6 }
+ }
+ },
+ prefix: true,
+ range: [0, 6],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 6 }
+ }
+ },
+ range: [0, 6],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 6 }
+ }
+ },
+
+ '--eval': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'UpdateExpression',
+ operator: '--',
+ argument: {
+ type: 'Identifier',
+ name: 'eval',
+ range: [2, 6],
+ loc: {
+ start: { line: 1, column: 2 },
+ end: { line: 1, column: 6 }
+ }
+ },
+ prefix: true,
+ range: [0, 6],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 6 }
+ }
+ },
+ range: [0, 6],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 6 }
+ }
+ },
+
+ '++arguments': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'UpdateExpression',
+ operator: '++',
+ argument: {
+ type: 'Identifier',
+ name: 'arguments',
+ range: [2, 11],
+ loc: {
+ start: { line: 1, column: 2 },
+ end: { line: 1, column: 11 }
+ }
+ },
+ prefix: true,
+ range: [0, 11],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 11 }
+ }
+ },
+ range: [0, 11],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 11 }
+ }
+ },
+
+ '--arguments': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'UpdateExpression',
+ operator: '--',
+ argument: {
+ type: 'Identifier',
+ name: 'arguments',
+ range: [2, 11],
+ loc: {
+ start: { line: 1, column: 2 },
+ end: { line: 1, column: 11 }
+ }
+ },
+ prefix: true,
+ range: [0, 11],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 11 }
+ }
+ },
+ range: [0, 11],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 11 }
+ }
+ },
+
+ '+x': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'UnaryExpression',
+ operator: '+',
+ argument: {
+ type: 'Identifier',
+ name: 'x',
+ range: [1, 2],
+ loc: {
+ start: { line: 1, column: 1 },
+ end: { line: 1, column: 2 }
+ }
+ },
+ prefix: true,
+ range: [0, 2],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 2 }
+ }
+ },
+ range: [0, 2],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 2 }
+ }
+ },
+
+ '-x': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'UnaryExpression',
+ operator: '-',
+ argument: {
+ type: 'Identifier',
+ name: 'x',
+ range: [1, 2],
+ loc: {
+ start: { line: 1, column: 1 },
+ end: { line: 1, column: 2 }
+ }
+ },
+ prefix: true,
+ range: [0, 2],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 2 }
+ }
+ },
+ range: [0, 2],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 2 }
+ }
+ },
+
+ '~x': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'UnaryExpression',
+ operator: '~',
+ argument: {
+ type: 'Identifier',
+ name: 'x',
+ range: [1, 2],
+ loc: {
+ start: { line: 1, column: 1 },
+ end: { line: 1, column: 2 }
+ }
+ },
+ prefix: true,
+ range: [0, 2],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 2 }
+ }
+ },
+ range: [0, 2],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 2 }
+ }
+ },
+
+ '!x': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'UnaryExpression',
+ operator: '!',
+ argument: {
+ type: 'Identifier',
+ name: 'x',
+ range: [1, 2],
+ loc: {
+ start: { line: 1, column: 1 },
+ end: { line: 1, column: 2 }
+ }
+ },
+ prefix: true,
+ range: [0, 2],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 2 }
+ }
+ },
+ range: [0, 2],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 2 }
+ }
+ },
+
+ 'void x': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'UnaryExpression',
+ operator: 'void',
+ argument: {
+ type: 'Identifier',
+ name: 'x',
+ range: [5, 6],
+ loc: {
+ start: { line: 1, column: 5 },
+ end: { line: 1, column: 6 }
+ }
+ },
+ prefix: true,
+ range: [0, 6],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 6 }
+ }
+ },
+ range: [0, 6],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 6 }
+ }
+ },
+
+ 'delete x': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'UnaryExpression',
+ operator: 'delete',
+ argument: {
+ type: 'Identifier',
+ name: 'x',
+ range: [7, 8],
+ loc: {
+ start: { line: 1, column: 7 },
+ end: { line: 1, column: 8 }
+ }
+ },
+ prefix: true,
+ range: [0, 8],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 8 }
+ }
+ },
+ range: [0, 8],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 8 }
+ }
+ },
+
+ 'typeof x': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'UnaryExpression',
+ operator: 'typeof',
+ argument: {
+ type: 'Identifier',
+ name: 'x',
+ range: [7, 8],
+ loc: {
+ start: { line: 1, column: 7 },
+ end: { line: 1, column: 8 }
+ }
+ },
+ prefix: true,
+ range: [0, 8],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 8 }
+ }
+ },
+ range: [0, 8],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 8 }
+ }
+ }
+
+ },
+
+ 'Multiplicative Operators': {
+
+ 'x * y': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'BinaryExpression',
+ operator: '*',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'y',
+ range: [4, 5],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ range: [0, 5],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ range: [0, 5],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 5 }
+ }
+ },
+
+ 'x / y': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'BinaryExpression',
+ operator: '/',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'y',
+ range: [4, 5],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ range: [0, 5],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ range: [0, 5],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 5 }
+ }
+ },
+
+ 'x % y': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'BinaryExpression',
+ operator: '%',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'y',
+ range: [4, 5],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ range: [0, 5],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ range: [0, 5],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 5 }
+ }
+ }
+
+ },
+
+ 'Additive Operators': {
+
+ 'x + y': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'BinaryExpression',
+ operator: '+',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'y',
+ range: [4, 5],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ range: [0, 5],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ range: [0, 5],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 5 }
+ }
+ },
+
+ 'x - y': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'BinaryExpression',
+ operator: '-',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'y',
+ range: [4, 5],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ range: [0, 5],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ range: [0, 5],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 5 }
+ }
+ }
+
+ },
+
+ 'Bitwise Shift Operator': {
+
+ 'x << y': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'BinaryExpression',
+ operator: '<<',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'y',
+ range: [5, 6],
+ loc: {
+ start: { line: 1, column: 5 },
+ end: { line: 1, column: 6 }
+ }
+ },
+ range: [0, 6],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 6 }
+ }
+ },
+ range: [0, 6],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 6 }
+ }
+ },
+
+ 'x >> y': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'BinaryExpression',
+ operator: '>>',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'y',
+ range: [5, 6],
+ loc: {
+ start: { line: 1, column: 5 },
+ end: { line: 1, column: 6 }
+ }
+ },
+ range: [0, 6],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 6 }
+ }
+ },
+ range: [0, 6],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 6 }
+ }
+ },
+
+ 'x >>> y': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'BinaryExpression',
+ operator: '>>>',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'y',
+ range: [6, 7],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 7 }
+ }
+ },
+ range: [0, 7],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 7 }
+ }
+ },
+ range: [0, 7],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 7 }
+ }
+ }
+
+ },
+
+ 'Relational Operators': {
+
+ 'x < y': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'BinaryExpression',
+ operator: '<',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'y',
+ range: [4, 5],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ range: [0, 5],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ range: [0, 5],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 5 }
+ }
+ },
+
+ 'x > y': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'BinaryExpression',
+ operator: '>',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'y',
+ range: [4, 5],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ range: [0, 5],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ range: [0, 5],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 5 }
+ }
+ },
+
+ 'x <= y': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'BinaryExpression',
+ operator: '<=',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'y',
+ range: [5, 6],
+ loc: {
+ start: { line: 1, column: 5 },
+ end: { line: 1, column: 6 }
+ }
+ },
+ range: [0, 6],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 6 }
+ }
+ },
+ range: [0, 6],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 6 }
+ }
+ },
+
+ 'x >= y': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'BinaryExpression',
+ operator: '>=',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'y',
+ range: [5, 6],
+ loc: {
+ start: { line: 1, column: 5 },
+ end: { line: 1, column: 6 }
+ }
+ },
+ range: [0, 6],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 6 }
+ }
+ },
+ range: [0, 6],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 6 }
+ }
+ },
+
+ 'x in y': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'BinaryExpression',
+ operator: 'in',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'y',
+ range: [5, 6],
+ loc: {
+ start: { line: 1, column: 5 },
+ end: { line: 1, column: 6 }
+ }
+ },
+ range: [0, 6],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 6 }
+ }
+ },
+ range: [0, 6],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 6 }
+ }
+ },
+
+ 'x instanceof y': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'BinaryExpression',
+ operator: 'instanceof',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'y',
+ range: [13, 14],
+ loc: {
+ start: { line: 1, column: 13 },
+ end: { line: 1, column: 14 }
+ }
+ },
+ range: [0, 14],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 14 }
+ }
+ },
+ range: [0, 14],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 14 }
+ }
+ },
+
+ 'x < y < z': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'BinaryExpression',
+ operator: '<',
+ left: {
+ type: 'BinaryExpression',
+ operator: '<',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'y',
+ range: [4, 5],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ range: [0, 5],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'z',
+ range: [8, 9],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ range: [0, 9],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ range: [0, 9],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 9 }
+ }
+ }
+
+ },
+
+ 'Equality Operators': {
+
+ 'x == y': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'BinaryExpression',
+ operator: '==',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'y',
+ range: [5, 6],
+ loc: {
+ start: { line: 1, column: 5 },
+ end: { line: 1, column: 6 }
+ }
+ },
+ range: [0, 6],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 6 }
+ }
+ },
+ range: [0, 6],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 6 }
+ }
+ },
+
+ 'x != y': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'BinaryExpression',
+ operator: '!=',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'y',
+ range: [5, 6],
+ loc: {
+ start: { line: 1, column: 5 },
+ end: { line: 1, column: 6 }
+ }
+ },
+ range: [0, 6],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 6 }
+ }
+ },
+ range: [0, 6],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 6 }
+ }
+ },
+
+ 'x === y': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'BinaryExpression',
+ operator: '===',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'y',
+ range: [6, 7],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 7 }
+ }
+ },
+ range: [0, 7],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 7 }
+ }
+ },
+ range: [0, 7],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 7 }
+ }
+ },
+
+ 'x !== y': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'BinaryExpression',
+ operator: '!==',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'y',
+ range: [6, 7],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 7 }
+ }
+ },
+ range: [0, 7],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 7 }
+ }
+ },
+ range: [0, 7],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 7 }
+ }
+ }
+
+ },
+
+ 'Binary Bitwise Operators': {
+
+ 'x & y': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'BinaryExpression',
+ operator: '&',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'y',
+ range: [4, 5],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ range: [0, 5],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ range: [0, 5],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 5 }
+ }
+ },
+
+ 'x ^ y': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'BinaryExpression',
+ operator: '^',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'y',
+ range: [4, 5],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ range: [0, 5],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ range: [0, 5],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 5 }
+ }
+ },
+
+ 'x | y': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'BinaryExpression',
+ operator: '|',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'y',
+ range: [4, 5],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ range: [0, 5],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ range: [0, 5],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 5 }
+ }
+ }
+
+ },
+
+ 'Binary Expressions': {
+
+ 'x + y + z': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'BinaryExpression',
+ operator: '+',
+ left: {
+ type: 'BinaryExpression',
+ operator: '+',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'y',
+ range: [4, 5],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ range: [0, 5],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'z',
+ range: [8, 9],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ range: [0, 9],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ range: [0, 9],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 9 }
+ }
+ },
+
+ 'x - y + z': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'BinaryExpression',
+ operator: '+',
+ left: {
+ type: 'BinaryExpression',
+ operator: '-',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'y',
+ range: [4, 5],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ range: [0, 5],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'z',
+ range: [8, 9],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ range: [0, 9],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ range: [0, 9],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 9 }
+ }
+ },
+
+ 'x + y - z': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'BinaryExpression',
+ operator: '-',
+ left: {
+ type: 'BinaryExpression',
+ operator: '+',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'y',
+ range: [4, 5],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ range: [0, 5],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'z',
+ range: [8, 9],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ range: [0, 9],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ range: [0, 9],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 9 }
+ }
+ },
+
+ 'x - y - z': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'BinaryExpression',
+ operator: '-',
+ left: {
+ type: 'BinaryExpression',
+ operator: '-',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'y',
+ range: [4, 5],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ range: [0, 5],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'z',
+ range: [8, 9],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ range: [0, 9],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ range: [0, 9],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 9 }
+ }
+ },
+
+ 'x + y * z': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'BinaryExpression',
+ operator: '+',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'BinaryExpression',
+ operator: '*',
+ left: {
+ type: 'Identifier',
+ name: 'y',
+ range: [4, 5],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'z',
+ range: [8, 9],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ range: [4, 9],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ range: [0, 9],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ range: [0, 9],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 9 }
+ }
+ },
+
+ 'x + y / z': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'BinaryExpression',
+ operator: '+',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'BinaryExpression',
+ operator: '/',
+ left: {
+ type: 'Identifier',
+ name: 'y',
+ range: [4, 5],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'z',
+ range: [8, 9],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ range: [4, 9],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ range: [0, 9],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ range: [0, 9],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 9 }
+ }
+ },
+
+ 'x - y % z': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'BinaryExpression',
+ operator: '-',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'BinaryExpression',
+ operator: '%',
+ left: {
+ type: 'Identifier',
+ name: 'y',
+ range: [4, 5],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'z',
+ range: [8, 9],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ range: [4, 9],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ range: [0, 9],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ range: [0, 9],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 9 }
+ }
+ },
+
+ 'x * y * z': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'BinaryExpression',
+ operator: '*',
+ left: {
+ type: 'BinaryExpression',
+ operator: '*',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'y',
+ range: [4, 5],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ range: [0, 5],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'z',
+ range: [8, 9],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ range: [0, 9],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ range: [0, 9],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 9 }
+ }
+ },
+
+ 'x * y / z': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'BinaryExpression',
+ operator: '/',
+ left: {
+ type: 'BinaryExpression',
+ operator: '*',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'y',
+ range: [4, 5],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ range: [0, 5],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'z',
+ range: [8, 9],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ range: [0, 9],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ range: [0, 9],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 9 }
+ }
+ },
+
+ 'x * y % z': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'BinaryExpression',
+ operator: '%',
+ left: {
+ type: 'BinaryExpression',
+ operator: '*',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'y',
+ range: [4, 5],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ range: [0, 5],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'z',
+ range: [8, 9],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ range: [0, 9],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ range: [0, 9],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 9 }
+ }
+ },
+
+ 'x % y * z': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'BinaryExpression',
+ operator: '*',
+ left: {
+ type: 'BinaryExpression',
+ operator: '%',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'y',
+ range: [4, 5],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ range: [0, 5],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'z',
+ range: [8, 9],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ range: [0, 9],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ range: [0, 9],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 9 }
+ }
+ },
+
+ 'x << y << z': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'BinaryExpression',
+ operator: '<<',
+ left: {
+ type: 'BinaryExpression',
+ operator: '<<',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'y',
+ range: [5, 6],
+ loc: {
+ start: { line: 1, column: 5 },
+ end: { line: 1, column: 6 }
+ }
+ },
+ range: [0, 6],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 6 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'z',
+ range: [10, 11],
+ loc: {
+ start: { line: 1, column: 10 },
+ end: { line: 1, column: 11 }
+ }
+ },
+ range: [0, 11],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 11 }
+ }
+ },
+ range: [0, 11],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 11 }
+ }
+ },
+
+ 'x | y | z': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'BinaryExpression',
+ operator: '|',
+ left: {
+ type: 'BinaryExpression',
+ operator: '|',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'y',
+ range: [4, 5],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ range: [0, 5],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'z',
+ range: [8, 9],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ range: [0, 9],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ range: [0, 9],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 9 }
+ }
+ },
+
+ 'x & y & z': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'BinaryExpression',
+ operator: '&',
+ left: {
+ type: 'BinaryExpression',
+ operator: '&',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'y',
+ range: [4, 5],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ range: [0, 5],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'z',
+ range: [8, 9],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ range: [0, 9],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ range: [0, 9],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 9 }
+ }
+ },
+
+ 'x ^ y ^ z': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'BinaryExpression',
+ operator: '^',
+ left: {
+ type: 'BinaryExpression',
+ operator: '^',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'y',
+ range: [4, 5],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ range: [0, 5],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'z',
+ range: [8, 9],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ range: [0, 9],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ range: [0, 9],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 9 }
+ }
+ },
+
+ 'x & y | z': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'BinaryExpression',
+ operator: '|',
+ left: {
+ type: 'BinaryExpression',
+ operator: '&',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'y',
+ range: [4, 5],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ range: [0, 5],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'z',
+ range: [8, 9],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ range: [0, 9],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ range: [0, 9],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 9 }
+ }
+ },
+
+ 'x | y ^ z': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'BinaryExpression',
+ operator: '|',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'BinaryExpression',
+ operator: '^',
+ left: {
+ type: 'Identifier',
+ name: 'y',
+ range: [4, 5],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'z',
+ range: [8, 9],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ range: [4, 9],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ range: [0, 9],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ range: [0, 9],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 9 }
+ }
+ },
+
+ 'x | y & z': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'BinaryExpression',
+ operator: '|',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'BinaryExpression',
+ operator: '&',
+ left: {
+ type: 'Identifier',
+ name: 'y',
+ range: [4, 5],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'z',
+ range: [8, 9],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ range: [4, 9],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ range: [0, 9],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ range: [0, 9],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 9 }
+ }
+ }
+
+ },
+
+ 'Binary Logical Operators': {
+
+ 'x || y': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'LogicalExpression',
+ operator: '||',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'y',
+ range: [5, 6],
+ loc: {
+ start: { line: 1, column: 5 },
+ end: { line: 1, column: 6 }
+ }
+ },
+ range: [0, 6],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 6 }
+ }
+ },
+ range: [0, 6],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 6 }
+ }
+ },
+
+ 'x && y': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'LogicalExpression',
+ operator: '&&',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'y',
+ range: [5, 6],
+ loc: {
+ start: { line: 1, column: 5 },
+ end: { line: 1, column: 6 }
+ }
+ },
+ range: [0, 6],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 6 }
+ }
+ },
+ range: [0, 6],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 6 }
+ }
+ },
+
+ 'x || y || z': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'LogicalExpression',
+ operator: '||',
+ left: {
+ type: 'LogicalExpression',
+ operator: '||',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'y',
+ range: [5, 6],
+ loc: {
+ start: { line: 1, column: 5 },
+ end: { line: 1, column: 6 }
+ }
+ },
+ range: [0, 6],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 6 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'z',
+ range: [10, 11],
+ loc: {
+ start: { line: 1, column: 10 },
+ end: { line: 1, column: 11 }
+ }
+ },
+ range: [0, 11],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 11 }
+ }
+ },
+ range: [0, 11],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 11 }
+ }
+ },
+
+ 'x && y && z': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'LogicalExpression',
+ operator: '&&',
+ left: {
+ type: 'LogicalExpression',
+ operator: '&&',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'y',
+ range: [5, 6],
+ loc: {
+ start: { line: 1, column: 5 },
+ end: { line: 1, column: 6 }
+ }
+ },
+ range: [0, 6],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 6 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'z',
+ range: [10, 11],
+ loc: {
+ start: { line: 1, column: 10 },
+ end: { line: 1, column: 11 }
+ }
+ },
+ range: [0, 11],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 11 }
+ }
+ },
+ range: [0, 11],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 11 }
+ }
+ },
+
+ 'x || y && z': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'LogicalExpression',
+ operator: '||',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'LogicalExpression',
+ operator: '&&',
+ left: {
+ type: 'Identifier',
+ name: 'y',
+ range: [5, 6],
+ loc: {
+ start: { line: 1, column: 5 },
+ end: { line: 1, column: 6 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'z',
+ range: [10, 11],
+ loc: {
+ start: { line: 1, column: 10 },
+ end: { line: 1, column: 11 }
+ }
+ },
+ range: [5, 11],
+ loc: {
+ start: { line: 1, column: 5 },
+ end: { line: 1, column: 11 }
+ }
+ },
+ range: [0, 11],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 11 }
+ }
+ },
+ range: [0, 11],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 11 }
+ }
+ },
+
+ 'x || y ^ z': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'LogicalExpression',
+ operator: '||',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'BinaryExpression',
+ operator: '^',
+ left: {
+ type: 'Identifier',
+ name: 'y',
+ range: [5, 6],
+ loc: {
+ start: { line: 1, column: 5 },
+ end: { line: 1, column: 6 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'z',
+ range: [9, 10],
+ loc: {
+ start: { line: 1, column: 9 },
+ end: { line: 1, column: 10 }
+ }
+ },
+ range: [5, 10],
+ loc: {
+ start: { line: 1, column: 5 },
+ end: { line: 1, column: 10 }
+ }
+ },
+ range: [0, 10],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 10 }
+ }
+ },
+ range: [0, 10],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 10 }
+ }
+ }
+
+ },
+
+ 'Conditional Operator': {
+
+ 'y ? 1 : 2': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'ConditionalExpression',
+ test: {
+ type: 'Identifier',
+ name: 'y',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ consequent: {
+ type: 'Literal',
+ value: 1,
+ raw: '1',
+ range: [4, 5],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ alternate: {
+ type: 'Literal',
+ value: 2,
+ raw: '2',
+ range: [8, 9],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ range: [0, 9],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ range: [0, 9],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 9 }
+ }
+ },
+
+ 'x && y ? 1 : 2': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'ConditionalExpression',
+ test: {
+ type: 'LogicalExpression',
+ operator: '&&',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'y',
+ range: [5, 6],
+ loc: {
+ start: { line: 1, column: 5 },
+ end: { line: 1, column: 6 }
+ }
+ },
+ range: [0, 6],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 6 }
+ }
+ },
+ consequent: {
+ type: 'Literal',
+ value: 1,
+ raw: '1',
+ range: [9, 10],
+ loc: {
+ start: { line: 1, column: 9 },
+ end: { line: 1, column: 10 }
+ }
+ },
+ alternate: {
+ type: 'Literal',
+ value: 2,
+ raw: '2',
+ range: [13, 14],
+ loc: {
+ start: { line: 1, column: 13 },
+ end: { line: 1, column: 14 }
+ }
+ },
+ range: [0, 14],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 14 }
+ }
+ },
+ range: [0, 14],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 14 }
+ }
+ }
+
+ },
+
+ 'Assignment Operators': {
+
+ 'x = 42': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'Literal',
+ value: 42,
+ raw: '42',
+ range: [4, 6],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 6 }
+ }
+ },
+ range: [0, 6],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 6 }
+ }
+ },
+ range: [0, 6],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 6 }
+ }
+ },
+
+ 'eval = 42': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left: {
+ type: 'Identifier',
+ name: 'eval',
+ range: [0, 4],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 4 }
+ }
+ },
+ right: {
+ type: 'Literal',
+ value: 42,
+ raw: '42',
+ range: [7, 9],
+ loc: {
+ start: { line: 1, column: 7 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ range: [0, 9],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ range: [0, 9],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 9 }
+ }
+ },
+
+ 'arguments = 42': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left: {
+ type: 'Identifier',
+ name: 'arguments',
+ range: [0, 9],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ right: {
+ type: 'Literal',
+ value: 42,
+ raw: '42',
+ range: [12, 14],
+ loc: {
+ start: { line: 1, column: 12 },
+ end: { line: 1, column: 14 }
+ }
+ },
+ range: [0, 14],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 14 }
+ }
+ },
+ range: [0, 14],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 14 }
+ }
+ },
+
+ 'x *= 42': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '*=',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'Literal',
+ value: 42,
+ raw: '42',
+ range: [5, 7],
+ loc: {
+ start: { line: 1, column: 5 },
+ end: { line: 1, column: 7 }
+ }
+ },
+ range: [0, 7],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 7 }
+ }
+ },
+ range: [0, 7],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 7 }
+ }
+ },
+
+ 'x /= 42': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '/=',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'Literal',
+ value: 42,
+ raw: '42',
+ range: [5, 7],
+ loc: {
+ start: { line: 1, column: 5 },
+ end: { line: 1, column: 7 }
+ }
+ },
+ range: [0, 7],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 7 }
+ }
+ },
+ range: [0, 7],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 7 }
+ }
+ },
+
+ 'x %= 42': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '%=',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'Literal',
+ value: 42,
+ raw: '42',
+ range: [5, 7],
+ loc: {
+ start: { line: 1, column: 5 },
+ end: { line: 1, column: 7 }
+ }
+ },
+ range: [0, 7],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 7 }
+ }
+ },
+ range: [0, 7],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 7 }
+ }
+ },
+
+ 'x += 42': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '+=',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'Literal',
+ value: 42,
+ raw: '42',
+ range: [5, 7],
+ loc: {
+ start: { line: 1, column: 5 },
+ end: { line: 1, column: 7 }
+ }
+ },
+ range: [0, 7],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 7 }
+ }
+ },
+ range: [0, 7],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 7 }
+ }
+ },
+
+ 'x -= 42': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '-=',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'Literal',
+ value: 42,
+ raw: '42',
+ range: [5, 7],
+ loc: {
+ start: { line: 1, column: 5 },
+ end: { line: 1, column: 7 }
+ }
+ },
+ range: [0, 7],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 7 }
+ }
+ },
+ range: [0, 7],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 7 }
+ }
+ },
+
+ 'x <<= 42': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '<<=',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'Literal',
+ value: 42,
+ raw: '42',
+ range: [6, 8],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 8 }
+ }
+ },
+ range: [0, 8],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 8 }
+ }
+ },
+ range: [0, 8],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 8 }
+ }
+ },
+
+ 'x >>= 42': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '>>=',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'Literal',
+ value: 42,
+ raw: '42',
+ range: [6, 8],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 8 }
+ }
+ },
+ range: [0, 8],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 8 }
+ }
+ },
+ range: [0, 8],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 8 }
+ }
+ },
+
+ 'x >>>= 42': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '>>>=',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'Literal',
+ value: 42,
+ raw: '42',
+ range: [7, 9],
+ loc: {
+ start: { line: 1, column: 7 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ range: [0, 9],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ range: [0, 9],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 9 }
+ }
+ },
+
+ 'x &= 42': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '&=',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'Literal',
+ value: 42,
+ raw: '42',
+ range: [5, 7],
+ loc: {
+ start: { line: 1, column: 5 },
+ end: { line: 1, column: 7 }
+ }
+ },
+ range: [0, 7],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 7 }
+ }
+ },
+ range: [0, 7],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 7 }
+ }
+ },
+
+ 'x ^= 42': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '^=',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'Literal',
+ value: 42,
+ raw: '42',
+ range: [5, 7],
+ loc: {
+ start: { line: 1, column: 5 },
+ end: { line: 1, column: 7 }
+ }
+ },
+ range: [0, 7],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 7 }
+ }
+ },
+ range: [0, 7],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 7 }
+ }
+ },
+
+ 'x |= 42': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '|=',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'Literal',
+ value: 42,
+ raw: '42',
+ range: [5, 7],
+ loc: {
+ start: { line: 1, column: 5 },
+ end: { line: 1, column: 7 }
+ }
+ },
+ range: [0, 7],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 7 }
+ }
+ },
+ range: [0, 7],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 7 }
+ }
+ }
+
+ },
+
+ 'Block': {
+
+ '{ foo }': {
+ type: 'BlockStatement',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Identifier',
+ name: 'foo',
+ range: [2, 5],
+ loc: {
+ start: { line: 1, column: 2 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ range: [2, 6],
+ loc: {
+ start: { line: 1, column: 2 },
+ end: { line: 1, column: 6 }
+ }
+ }],
+ range: [0, 7],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 7 }
+ }
+ },
+
+ '{ doThis(); doThat(); }': {
+ type: 'BlockStatement',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'CallExpression',
+ callee: {
+ type: 'Identifier',
+ name: 'doThis',
+ range: [2, 8],
+ loc: {
+ start: { line: 1, column: 2 },
+ end: { line: 1, column: 8 }
+ }
+ },
+ 'arguments': [],
+ range: [2, 10],
+ loc: {
+ start: { line: 1, column: 2 },
+ end: { line: 1, column: 10 }
+ }
+ },
+ range: [2, 11],
+ loc: {
+ start: { line: 1, column: 2 },
+ end: { line: 1, column: 11 }
+ }
+ }, {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'CallExpression',
+ callee: {
+ type: 'Identifier',
+ name: 'doThat',
+ range: [12, 18],
+ loc: {
+ start: { line: 1, column: 12 },
+ end: { line: 1, column: 18 }
+ }
+ },
+ 'arguments': [],
+ range: [12, 20],
+ loc: {
+ start: { line: 1, column: 12 },
+ end: { line: 1, column: 20 }
+ }
+ },
+ range: [12, 21],
+ loc: {
+ start: { line: 1, column: 12 },
+ end: { line: 1, column: 21 }
+ }
+ }],
+ range: [0, 23],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 23 }
+ }
+ },
+
+ '{}': {
+ type: 'BlockStatement',
+ body: [],
+ range: [0, 2],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 2 }
+ }
+ }
+
+ },
+
+ 'Variable Statement': {
+
+ 'var x': {
+ type: 'VariableDeclaration',
+ declarations: [{
+ type: 'VariableDeclarator',
+ id: {
+ type: 'Identifier',
+ name: 'x',
+ range: [4, 5],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ init: null,
+ range: [4, 5],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ }],
+ kind: 'var',
+ range: [0, 5],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 5 }
+ }
+ },
+
+ 'var x, y;': {
+ type: 'VariableDeclaration',
+ declarations: [{
+ type: 'VariableDeclarator',
+ id: {
+ type: 'Identifier',
+ name: 'x',
+ range: [4, 5],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ init: null,
+ range: [4, 5],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ }, {
+ type: 'VariableDeclarator',
+ id: {
+ type: 'Identifier',
+ name: 'y',
+ range: [7, 8],
+ loc: {
+ start: { line: 1, column: 7 },
+ end: { line: 1, column: 8 }
+ }
+ },
+ init: null,
+ range: [7, 8],
+ loc: {
+ start: { line: 1, column: 7 },
+ end: { line: 1, column: 8 }
+ }
+ }],
+ kind: 'var',
+ range: [0, 9],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 9 }
+ }
+ },
+
+ 'var x = 42': {
+ type: 'VariableDeclaration',
+ declarations: [{
+ type: 'VariableDeclarator',
+ id: {
+ type: 'Identifier',
+ name: 'x',
+ range: [4, 5],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ init: {
+ type: 'Literal',
+ value: 42,
+ raw: '42',
+ range: [8, 10],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 10 }
+ }
+ },
+ range: [4, 10],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 10 }
+ }
+ }],
+ kind: 'var',
+ range: [0, 10],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 10 }
+ }
+ },
+
+ 'var eval = 42, arguments = 42': {
+ type: 'VariableDeclaration',
+ declarations: [{
+ type: 'VariableDeclarator',
+ id: {
+ type: 'Identifier',
+ name: 'eval',
+ range: [4, 8],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 8 }
+ }
+ },
+ init: {
+ type: 'Literal',
+ value: 42,
+ raw: '42',
+ range: [11, 13],
+ loc: {
+ start: { line: 1, column: 11 },
+ end: { line: 1, column: 13 }
+ }
+ },
+ range: [4, 13],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 13 }
+ }
+ }, {
+ type: 'VariableDeclarator',
+ id: {
+ type: 'Identifier',
+ name: 'arguments',
+ range: [15, 24],
+ loc: {
+ start: { line: 1, column: 15 },
+ end: { line: 1, column: 24 }
+ }
+ },
+ init: {
+ type: 'Literal',
+ value: 42,
+ raw: '42',
+ range: [27, 29],
+ loc: {
+ start: { line: 1, column: 27 },
+ end: { line: 1, column: 29 }
+ }
+ },
+ range: [15, 29],
+ loc: {
+ start: { line: 1, column: 15 },
+ end: { line: 1, column: 29 }
+ }
+ }],
+ kind: 'var',
+ range: [0, 29],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 29 }
+ }
+ },
+
+ 'var x = 14, y = 3, z = 1977': {
+ type: 'VariableDeclaration',
+ declarations: [{
+ type: 'VariableDeclarator',
+ id: {
+ type: 'Identifier',
+ name: 'x',
+ range: [4, 5],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ init: {
+ type: 'Literal',
+ value: 14,
+ raw: '14',
+ range: [8, 10],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 10 }
+ }
+ },
+ range: [4, 10],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 10 }
+ }
+ }, {
+ type: 'VariableDeclarator',
+ id: {
+ type: 'Identifier',
+ name: 'y',
+ range: [12, 13],
+ loc: {
+ start: { line: 1, column: 12 },
+ end: { line: 1, column: 13 }
+ }
+ },
+ init: {
+ type: 'Literal',
+ value: 3,
+ raw: '3',
+ range: [16, 17],
+ loc: {
+ start: { line: 1, column: 16 },
+ end: { line: 1, column: 17 }
+ }
+ },
+ range: [12, 17],
+ loc: {
+ start: { line: 1, column: 12 },
+ end: { line: 1, column: 17 }
+ }
+ }, {
+ type: 'VariableDeclarator',
+ id: {
+ type: 'Identifier',
+ name: 'z',
+ range: [19, 20],
+ loc: {
+ start: { line: 1, column: 19 },
+ end: { line: 1, column: 20 }
+ }
+ },
+ init: {
+ type: 'Literal',
+ value: 1977,
+ raw: '1977',
+ range: [23, 27],
+ loc: {
+ start: { line: 1, column: 23 },
+ end: { line: 1, column: 27 }
+ }
+ },
+ range: [19, 27],
+ loc: {
+ start: { line: 1, column: 19 },
+ end: { line: 1, column: 27 }
+ }
+ }],
+ kind: 'var',
+ range: [0, 27],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 27 }
+ }
+ },
+
+ 'var implements, interface, package': {
+ type: 'VariableDeclaration',
+ declarations: [{
+ type: 'VariableDeclarator',
+ id: {
+ type: 'Identifier',
+ name: 'implements',
+ range: [4, 14],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 14 }
+ }
+ },
+ init: null,
+ range: [4, 14],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 14 }
+ }
+ }, {
+ type: 'VariableDeclarator',
+ id: {
+ type: 'Identifier',
+ name: 'interface',
+ range: [16, 25],
+ loc: {
+ start: { line: 1, column: 16 },
+ end: { line: 1, column: 25 }
+ }
+ },
+ init: null,
+ range: [16, 25],
+ loc: {
+ start: { line: 1, column: 16 },
+ end: { line: 1, column: 25 }
+ }
+ }, {
+ type: 'VariableDeclarator',
+ id: {
+ type: 'Identifier',
+ name: 'package',
+ range: [27, 34],
+ loc: {
+ start: { line: 1, column: 27 },
+ end: { line: 1, column: 34 }
+ }
+ },
+ init: null,
+ range: [27, 34],
+ loc: {
+ start: { line: 1, column: 27 },
+ end: { line: 1, column: 34 }
+ }
+ }],
+ kind: 'var',
+ range: [0, 34],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 34 }
+ }
+ },
+
+ 'var private, protected, public, static': {
+ type: 'VariableDeclaration',
+ declarations: [{
+ type: 'VariableDeclarator',
+ id: {
+ type: 'Identifier',
+ name: 'private',
+ range: [4, 11],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 11 }
+ }
+ },
+ init: null,
+ range: [4, 11],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 11 }
+ }
+ }, {
+ type: 'VariableDeclarator',
+ id: {
+ type: 'Identifier',
+ name: 'protected',
+ range: [13, 22],
+ loc: {
+ start: { line: 1, column: 13 },
+ end: { line: 1, column: 22 }
+ }
+ },
+ init: null,
+ range: [13, 22],
+ loc: {
+ start: { line: 1, column: 13 },
+ end: { line: 1, column: 22 }
+ }
+ }, {
+ type: 'VariableDeclarator',
+ id: {
+ type: 'Identifier',
+ name: 'public',
+ range: [24, 30],
+ loc: {
+ start: { line: 1, column: 24 },
+ end: { line: 1, column: 30 }
+ }
+ },
+ init: null,
+ range: [24, 30],
+ loc: {
+ start: { line: 1, column: 24 },
+ end: { line: 1, column: 30 }
+ }
+ }, {
+ type: 'VariableDeclarator',
+ id: {
+ type: 'Identifier',
+ name: 'static',
+ range: [32, 38],
+ loc: {
+ start: { line: 1, column: 32 },
+ end: { line: 1, column: 38 }
+ }
+ },
+ init: null,
+ range: [32, 38],
+ loc: {
+ start: { line: 1, column: 32 },
+ end: { line: 1, column: 38 }
+ }
+ }],
+ kind: 'var',
+ range: [0, 38],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 38 }
+ }
+ }
+
+ },
+
+ 'Let Statement': {
+
+ 'let x': {
+ type: 'VariableDeclaration',
+ declarations: [{
+ type: 'VariableDeclarator',
+ id: {
+ type: 'Identifier',
+ name: 'x',
+ range: [4, 5],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ init: null,
+ range: [4, 5],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ }],
+ kind: 'let',
+ range: [0, 5],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 5 }
+ }
+ },
+
+ '{ let x }': {
+ type: 'BlockStatement',
+ body: [{
+ type: 'VariableDeclaration',
+ declarations: [{
+ type: 'VariableDeclarator',
+ id: {
+ type: 'Identifier',
+ name: 'x',
+ range: [6, 7],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 7 }
+ }
+ },
+ init: null,
+ range: [6, 7],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 7 }
+ }
+ }],
+ kind: 'let',
+ range: [2, 8],
+ loc: {
+ start: { line: 1, column: 2 },
+ end: { line: 1, column: 8 }
+ }
+ }],
+ range: [0, 9],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 9 }
+ }
+ },
+
+ '{ let x = 42 }': {
+ type: 'BlockStatement',
+ body: [{
+ type: 'VariableDeclaration',
+ declarations: [{
+ type: 'VariableDeclarator',
+ id: {
+ type: 'Identifier',
+ name: 'x',
+ range: [6, 7],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 7 }
+ }
+ },
+ init: {
+ type: 'Literal',
+ value: 42,
+ raw: '42',
+ range: [10, 12],
+ loc: {
+ start: { line: 1, column: 10 },
+ end: { line: 1, column: 12 }
+ }
+ },
+ range: [6, 12],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 12 }
+ }
+ }],
+ kind: 'let',
+ range: [2, 13],
+ loc: {
+ start: { line: 1, column: 2 },
+ end: { line: 1, column: 13 }
+ }
+ }],
+ range: [0, 14],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 14 }
+ }
+ },
+
+ '{ let x = 14, y = 3, z = 1977 }': {
+ type: 'BlockStatement',
+ body: [{
+ type: 'VariableDeclaration',
+ declarations: [{
+ type: 'VariableDeclarator',
+ id: {
+ type: 'Identifier',
+ name: 'x',
+ range: [6, 7],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 7 }
+ }
+ },
+ init: {
+ type: 'Literal',
+ value: 14,
+ raw: '14',
+ range: [10, 12],
+ loc: {
+ start: { line: 1, column: 10 },
+ end: { line: 1, column: 12 }
+ }
+ },
+ range: [6, 12],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 12 }
+ }
+ }, {
+ type: 'VariableDeclarator',
+ id: {
+ type: 'Identifier',
+ name: 'y',
+ range: [14, 15],
+ loc: {
+ start: { line: 1, column: 14 },
+ end: { line: 1, column: 15 }
+ }
+ },
+ init: {
+ type: 'Literal',
+ value: 3,
+ raw: '3',
+ range: [18, 19],
+ loc: {
+ start: { line: 1, column: 18 },
+ end: { line: 1, column: 19 }
+ }
+ },
+ range: [14, 19],
+ loc: {
+ start: { line: 1, column: 14 },
+ end: { line: 1, column: 19 }
+ }
+ }, {
+ type: 'VariableDeclarator',
+ id: {
+ type: 'Identifier',
+ name: 'z',
+ range: [21, 22],
+ loc: {
+ start: { line: 1, column: 21 },
+ end: { line: 1, column: 22 }
+ }
+ },
+ init: {
+ type: 'Literal',
+ value: 1977,
+ raw: '1977',
+ range: [25, 29],
+ loc: {
+ start: { line: 1, column: 25 },
+ end: { line: 1, column: 29 }
+ }
+ },
+ range: [21, 29],
+ loc: {
+ start: { line: 1, column: 21 },
+ end: { line: 1, column: 29 }
+ }
+ }],
+ kind: 'let',
+ range: [2, 30],
+ loc: {
+ start: { line: 1, column: 2 },
+ end: { line: 1, column: 30 }
+ }
+ }],
+ range: [0, 31],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 31 }
+ }
+ }
+
+ },
+
+ 'Const Statement': {
+
+ 'const x = 42': {
+ type: 'VariableDeclaration',
+ declarations: [{
+ type: 'VariableDeclarator',
+ id: {
+ type: 'Identifier',
+ name: 'x',
+ range: [6, 7],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 7 }
+ }
+ },
+ init: {
+ type: 'Literal',
+ value: 42,
+ raw: '42',
+ range: [10, 12],
+ loc: {
+ start: { line: 1, column: 10 },
+ end: { line: 1, column: 12 }
+ }
+ },
+ range: [6, 12],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 12 }
+ }
+ }],
+ kind: 'const',
+ range: [0, 12],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 12 }
+ }
+ },
+
+ '{ const x = 42 }': {
+ type: 'BlockStatement',
+ body: [{
+ type: 'VariableDeclaration',
+ declarations: [{
+ type: 'VariableDeclarator',
+ id: {
+ type: 'Identifier',
+ name: 'x',
+ range: [8, 9],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ init: {
+ type: 'Literal',
+ value: 42,
+ raw: '42',
+ range: [12, 14],
+ loc: {
+ start: { line: 1, column: 12 },
+ end: { line: 1, column: 14 }
+ }
+ },
+ range: [8, 14],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 14 }
+ }
+ }],
+ kind: 'const',
+ range: [2, 15],
+ loc: {
+ start: { line: 1, column: 2 },
+ end: { line: 1, column: 15 }
+ }
+ }],
+ range: [0, 16],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 16 }
+ }
+ },
+
+ '{ const x = 14, y = 3, z = 1977 }': {
+ type: 'BlockStatement',
+ body: [{
+ type: 'VariableDeclaration',
+ declarations: [{
+ type: 'VariableDeclarator',
+ id: {
+ type: 'Identifier',
+ name: 'x',
+ range: [8, 9],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ init: {
+ type: 'Literal',
+ value: 14,
+ raw: '14',
+ range: [12, 14],
+ loc: {
+ start: { line: 1, column: 12 },
+ end: { line: 1, column: 14 }
+ }
+ },
+ range: [8, 14],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 14 }
+ }
+ }, {
+ type: 'VariableDeclarator',
+ id: {
+ type: 'Identifier',
+ name: 'y',
+ range: [16, 17],
+ loc: {
+ start: { line: 1, column: 16 },
+ end: { line: 1, column: 17 }
+ }
+ },
+ init: {
+ type: 'Literal',
+ value: 3,
+ raw: '3',
+ range: [20, 21],
+ loc: {
+ start: { line: 1, column: 20 },
+ end: { line: 1, column: 21 }
+ }
+ },
+ range: [16, 21],
+ loc: {
+ start: { line: 1, column: 16 },
+ end: { line: 1, column: 21 }
+ }
+ }, {
+ type: 'VariableDeclarator',
+ id: {
+ type: 'Identifier',
+ name: 'z',
+ range: [23, 24],
+ loc: {
+ start: { line: 1, column: 23 },
+ end: { line: 1, column: 24 }
+ }
+ },
+ init: {
+ type: 'Literal',
+ value: 1977,
+ raw: '1977',
+ range: [27, 31],
+ loc: {
+ start: { line: 1, column: 27 },
+ end: { line: 1, column: 31 }
+ }
+ },
+ range: [23, 31],
+ loc: {
+ start: { line: 1, column: 23 },
+ end: { line: 1, column: 31 }
+ }
+ }],
+ kind: 'const',
+ range: [2, 32],
+ loc: {
+ start: { line: 1, column: 2 },
+ end: { line: 1, column: 32 }
+ }
+ }],
+ range: [0, 33],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 33 }
+ }
+ }
+
+ },
+
+ 'Empty Statement': {
+
+ ';': {
+ type: 'EmptyStatement',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ }
+
+ },
+
+ 'Expression Statement': {
+
+ 'x': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+
+ 'x, y': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'SequenceExpression',
+ expressions: [{
+ type: 'Identifier',
+ name: 'x',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ }, {
+ type: 'Identifier',
+ name: 'y',
+ range: [3, 4],
+ loc: {
+ start: { line: 1, column: 3 },
+ end: { line: 1, column: 4 }
+ }
+ }],
+ range: [0, 4],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 4 }
+ }
+ },
+ range: [0, 4],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 4 }
+ }
+ },
+
+ '\\u0061': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Identifier',
+ name: 'a',
+ range: [0, 6],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 6 }
+ }
+ },
+ range: [0, 6],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 6 }
+ }
+ },
+
+ 'a\\u0061': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Identifier',
+ name: 'aa',
+ range: [0, 7],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 7 }
+ }
+ },
+ range: [0, 7],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 7 }
+ }
+ },
+
+ '\\ua': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Identifier',
+ name: 'ua',
+ range: [0, 3],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 3 }
+ }
+ },
+ range: [0, 3],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 3 }
+ }
+ },
+
+ 'a\\u': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Identifier',
+ name: 'au',
+ range: [0, 3],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 3 }
+ }
+ },
+ range: [0, 3],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 3 }
+ }
+ }
+
+ },
+
+ 'If Statement': {
+
+ 'if (morning) goodMorning()': {
+ type: 'IfStatement',
+ test: {
+ type: 'Identifier',
+ name: 'morning',
+ range: [4, 11],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 11 }
+ }
+ },
+ consequent: {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'CallExpression',
+ callee: {
+ type: 'Identifier',
+ name: 'goodMorning',
+ range: [13, 24],
+ loc: {
+ start: { line: 1, column: 13 },
+ end: { line: 1, column: 24 }
+ }
+ },
+ 'arguments': [],
+ range: [13, 26],
+ loc: {
+ start: { line: 1, column: 13 },
+ end: { line: 1, column: 26 }
+ }
+ },
+ range: [13, 26],
+ loc: {
+ start: { line: 1, column: 13 },
+ end: { line: 1, column: 26 }
+ }
+ },
+ alternate: null,
+ range: [0, 26],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 26 }
+ }
+ },
+
+ 'if (morning) (function(){})': {
+ type: 'IfStatement',
+ test: {
+ type: 'Identifier',
+ name: 'morning',
+ range: [4, 11],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 11 }
+ }
+ },
+ consequent: {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'FunctionExpression',
+ id: null,
+ params: [],
+ defaults: [],
+ body: {
+ type: 'BlockStatement',
+ body: [],
+ range: [24, 26],
+ loc: {
+ start: { line: 1, column: 24 },
+ end: { line: 1, column: 26 }
+ }
+ },
+ rest: null,
+ generator: false,
+ expression: false,
+ range: [14, 26],
+ loc: {
+ start: { line: 1, column: 14 },
+ end: { line: 1, column: 26 }
+ }
+ },
+ range: [13, 27],
+ loc: {
+ start: { line: 1, column: 13 },
+ end: { line: 1, column: 27 }
+ }
+ },
+ alternate: null,
+ range: [0, 27],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 27 }
+ }
+ },
+
+ 'if (morning) var x = 0;': {
+ type: 'IfStatement',
+ test: {
+ type: 'Identifier',
+ name: 'morning',
+ range: [4, 11],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 11 }
+ }
+ },
+ consequent: {
+ type: 'VariableDeclaration',
+ declarations: [{
+ type: 'VariableDeclarator',
+ id: {
+ type: 'Identifier',
+ name: 'x',
+ range: [17, 18],
+ loc: {
+ start: { line: 1, column: 17 },
+ end: { line: 1, column: 18 }
+ }
+ },
+ init: {
+ type: 'Literal',
+ value: 0,
+ raw: '0',
+ range: [21, 22],
+ loc: {
+ start: { line: 1, column: 21 },
+ end: { line: 1, column: 22 }
+ }
+ },
+ range: [17, 22],
+ loc: {
+ start: { line: 1, column: 17 },
+ end: { line: 1, column: 22 }
+ }
+ }],
+ kind: 'var',
+ range: [13, 23],
+ loc: {
+ start: { line: 1, column: 13 },
+ end: { line: 1, column: 23 }
+ }
+ },
+ alternate: null,
+ range: [0, 23],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 23 }
+ }
+ },
+
+ 'if (morning) function a(){}': {
+ type: 'IfStatement',
+ test: {
+ type: 'Identifier',
+ name: 'morning',
+ range: [4, 11],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 11 }
+ }
+ },
+ consequent: {
+ type: 'FunctionDeclaration',
+ id: {
+ type: 'Identifier',
+ name: 'a',
+ range: [22, 23],
+ loc: {
+ start: { line: 1, column: 22 },
+ end: { line: 1, column: 23 }
+ }
+ },
+ params: [],
+ defaults: [],
+ body: {
+ type: 'BlockStatement',
+ body: [],
+ range: [25, 27],
+ loc: {
+ start: { line: 1, column: 25 },
+ end: { line: 1, column: 27 }
+ }
+ },
+ rest: null,
+ generator: false,
+ expression: false,
+ range: [13, 27],
+ loc: {
+ start: { line: 1, column: 13 },
+ end: { line: 1, column: 27 }
+ }
+ },
+ alternate: null,
+ range: [0, 27],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 27 }
+ }
+ },
+
+ 'if (morning) goodMorning(); else goodDay()': {
+ type: 'IfStatement',
+ test: {
+ type: 'Identifier',
+ name: 'morning',
+ range: [4, 11],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 11 }
+ }
+ },
+ consequent: {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'CallExpression',
+ callee: {
+ type: 'Identifier',
+ name: 'goodMorning',
+ range: [13, 24],
+ loc: {
+ start: { line: 1, column: 13 },
+ end: { line: 1, column: 24 }
+ }
+ },
+ 'arguments': [],
+ range: [13, 26],
+ loc: {
+ start: { line: 1, column: 13 },
+ end: { line: 1, column: 26 }
+ }
+ },
+ range: [13, 27],
+ loc: {
+ start: { line: 1, column: 13 },
+ end: { line: 1, column: 27 }
+ }
+ },
+ alternate: {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'CallExpression',
+ callee: {
+ type: 'Identifier',
+ name: 'goodDay',
+ range: [33, 40],
+ loc: {
+ start: { line: 1, column: 33 },
+ end: { line: 1, column: 40 }
+ }
+ },
+ 'arguments': [],
+ range: [33, 42],
+ loc: {
+ start: { line: 1, column: 33 },
+ end: { line: 1, column: 42 }
+ }
+ },
+ range: [33, 42],
+ loc: {
+ start: { line: 1, column: 33 },
+ end: { line: 1, column: 42 }
+ }
+ },
+ range: [0, 42],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 42 }
+ }
+ }
+
+ },
+
+ 'Iteration Statements': {
+
+ 'do keep(); while (true)': {
+ type: 'DoWhileStatement',
+ body: {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'CallExpression',
+ callee: {
+ type: 'Identifier',
+ name: 'keep',
+ range: [3, 7],
+ loc: {
+ start: { line: 1, column: 3 },
+ end: { line: 1, column: 7 }
+ }
+ },
+ 'arguments': [],
+ range: [3, 9],
+ loc: {
+ start: { line: 1, column: 3 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ range: [3, 10],
+ loc: {
+ start: { line: 1, column: 3 },
+ end: { line: 1, column: 10 }
+ }
+ },
+ test: {
+ type: 'Literal',
+ value: true,
+ raw: 'true',
+ range: [18, 22],
+ loc: {
+ start: { line: 1, column: 18 },
+ end: { line: 1, column: 22 }
+ }
+ },
+ range: [0, 23],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 23 }
+ }
+ },
+
+ 'do keep(); while (true);': {
+ type: 'DoWhileStatement',
+ body: {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'CallExpression',
+ callee: {
+ type: 'Identifier',
+ name: 'keep',
+ range: [3, 7],
+ loc: {
+ start: { line: 1, column: 3 },
+ end: { line: 1, column: 7 }
+ }
+ },
+ 'arguments': [],
+ range: [3, 9],
+ loc: {
+ start: { line: 1, column: 3 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ range: [3, 10],
+ loc: {
+ start: { line: 1, column: 3 },
+ end: { line: 1, column: 10 }
+ }
+ },
+ test: {
+ type: 'Literal',
+ value: true,
+ raw: 'true',
+ range: [18, 22],
+ loc: {
+ start: { line: 1, column: 18 },
+ end: { line: 1, column: 22 }
+ }
+ },
+ range: [0, 24],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 24 }
+ }
+ },
+
+ 'do { x++; y--; } while (x < 10)': {
+ type: 'DoWhileStatement',
+ body: {
+ type: 'BlockStatement',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'UpdateExpression',
+ operator: '++',
+ argument: {
+ type: 'Identifier',
+ name: 'x',
+ range: [5, 6],
+ loc: {
+ start: { line: 1, column: 5 },
+ end: { line: 1, column: 6 }
+ }
+ },
+ prefix: false,
+ range: [5, 8],
+ loc: {
+ start: { line: 1, column: 5 },
+ end: { line: 1, column: 8 }
+ }
+ },
+ range: [5, 9],
+ loc: {
+ start: { line: 1, column: 5 },
+ end: { line: 1, column: 9 }
+ }
+ }, {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'UpdateExpression',
+ operator: '--',
+ argument: {
+ type: 'Identifier',
+ name: 'y',
+ range: [10, 11],
+ loc: {
+ start: { line: 1, column: 10 },
+ end: { line: 1, column: 11 }
+ }
+ },
+ prefix: false,
+ range: [10, 13],
+ loc: {
+ start: { line: 1, column: 10 },
+ end: { line: 1, column: 13 }
+ }
+ },
+ range: [10, 14],
+ loc: {
+ start: { line: 1, column: 10 },
+ end: { line: 1, column: 14 }
+ }
+ }],
+ range: [3, 16],
+ loc: {
+ start: { line: 1, column: 3 },
+ end: { line: 1, column: 16 }
+ }
+ },
+ test: {
+ type: 'BinaryExpression',
+ operator: '<',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [24, 25],
+ loc: {
+ start: { line: 1, column: 24 },
+ end: { line: 1, column: 25 }
+ }
+ },
+ right: {
+ type: 'Literal',
+ value: 10,
+ raw: '10',
+ range: [28, 30],
+ loc: {
+ start: { line: 1, column: 28 },
+ end: { line: 1, column: 30 }
+ }
+ },
+ range: [24, 30],
+ loc: {
+ start: { line: 1, column: 24 },
+ end: { line: 1, column: 30 }
+ }
+ },
+ range: [0, 31],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 31 }
+ }
+ },
+
+ '{ do { } while (false) false }': {
+ type: 'BlockStatement',
+ body: [{
+ type: 'DoWhileStatement',
+ body: {
+ type: 'BlockStatement',
+ body: [],
+ range: [5, 8],
+ loc: {
+ start: { line: 1, column: 5 },
+ end: { line: 1, column: 8 }
+ }
+ },
+ test: {
+ type: 'Literal',
+ value: false,
+ raw: 'false',
+ range: [16, 21],
+ loc: {
+ start: { line: 1, column: 16 },
+ end: { line: 1, column: 21 }
+ }
+ },
+ range: [2, 22],
+ loc: {
+ start: { line: 1, column: 2 },
+ end: { line: 1, column: 22 }
+ }
+ }, {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: false,
+ raw: 'false',
+ range: [23, 28],
+ loc: {
+ start: { line: 1, column: 23 },
+ end: { line: 1, column: 28 }
+ }
+ },
+ range: [23, 29],
+ loc: {
+ start: { line: 1, column: 23 },
+ end: { line: 1, column: 29 }
+ }
+ }],
+ range: [0, 30],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 30 }
+ }
+ },
+
+ 'while (true) doSomething()': {
+ type: 'WhileStatement',
+ test: {
+ type: 'Literal',
+ value: true,
+ raw: 'true',
+ range: [7, 11],
+ loc: {
+ start: { line: 1, column: 7 },
+ end: { line: 1, column: 11 }
+ }
+ },
+ body: {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'CallExpression',
+ callee: {
+ type: 'Identifier',
+ name: 'doSomething',
+ range: [13, 24],
+ loc: {
+ start: { line: 1, column: 13 },
+ end: { line: 1, column: 24 }
+ }
+ },
+ 'arguments': [],
+ range: [13, 26],
+ loc: {
+ start: { line: 1, column: 13 },
+ end: { line: 1, column: 26 }
+ }
+ },
+ range: [13, 26],
+ loc: {
+ start: { line: 1, column: 13 },
+ end: { line: 1, column: 26 }
+ }
+ },
+ range: [0, 26],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 26 }
+ }
+ },
+
+ 'while (x < 10) { x++; y--; }': {
+ type: 'WhileStatement',
+ test: {
+ type: 'BinaryExpression',
+ operator: '<',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [7, 8],
+ loc: {
+ start: { line: 1, column: 7 },
+ end: { line: 1, column: 8 }
+ }
+ },
+ right: {
+ type: 'Literal',
+ value: 10,
+ raw: '10',
+ range: [11, 13],
+ loc: {
+ start: { line: 1, column: 11 },
+ end: { line: 1, column: 13 }
+ }
+ },
+ range: [7, 13],
+ loc: {
+ start: { line: 1, column: 7 },
+ end: { line: 1, column: 13 }
+ }
+ },
+ body: {
+ type: 'BlockStatement',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'UpdateExpression',
+ operator: '++',
+ argument: {
+ type: 'Identifier',
+ name: 'x',
+ range: [17, 18],
+ loc: {
+ start: { line: 1, column: 17 },
+ end: { line: 1, column: 18 }
+ }
+ },
+ prefix: false,
+ range: [17, 20],
+ loc: {
+ start: { line: 1, column: 17 },
+ end: { line: 1, column: 20 }
+ }
+ },
+ range: [17, 21],
+ loc: {
+ start: { line: 1, column: 17 },
+ end: { line: 1, column: 21 }
+ }
+ }, {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'UpdateExpression',
+ operator: '--',
+ argument: {
+ type: 'Identifier',
+ name: 'y',
+ range: [22, 23],
+ loc: {
+ start: { line: 1, column: 22 },
+ end: { line: 1, column: 23 }
+ }
+ },
+ prefix: false,
+ range: [22, 25],
+ loc: {
+ start: { line: 1, column: 22 },
+ end: { line: 1, column: 25 }
+ }
+ },
+ range: [22, 26],
+ loc: {
+ start: { line: 1, column: 22 },
+ end: { line: 1, column: 26 }
+ }
+ }],
+ range: [15, 28],
+ loc: {
+ start: { line: 1, column: 15 },
+ end: { line: 1, column: 28 }
+ }
+ },
+ range: [0, 28],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 28 }
+ }
+ },
+
+ 'for(;;);': {
+ type: 'ForStatement',
+ init: null,
+ test: null,
+ update: null,
+ body: {
+ type: 'EmptyStatement',
+ range: [7, 8],
+ loc: {
+ start: { line: 1, column: 7 },
+ end: { line: 1, column: 8 }
+ }
+ },
+ range: [0, 8],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 8 }
+ }
+ },
+
+ 'for(;;){}': {
+ type: 'ForStatement',
+ init: null,
+ test: null,
+ update: null,
+ body: {
+ type: 'BlockStatement',
+ body: [],
+ range: [7, 9],
+ loc: {
+ start: { line: 1, column: 7 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ range: [0, 9],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 9 }
+ }
+ },
+
+ 'for(x = 0;;);': {
+ type: 'ForStatement',
+ init: {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [4, 5],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ right: {
+ type: 'Literal',
+ value: 0,
+ raw: '0',
+ range: [8, 9],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ range: [4, 9],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ test: null,
+ update: null,
+ body: {
+ type: 'EmptyStatement',
+ range: [12, 13],
+ loc: {
+ start: { line: 1, column: 12 },
+ end: { line: 1, column: 13 }
+ }
+ },
+ range: [0, 13],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 13 }
+ }
+ },
+
+ 'for(var x = 0;;);': {
+ type: 'ForStatement',
+ init: {
+ type: 'VariableDeclaration',
+ declarations: [{
+ type: 'VariableDeclarator',
+ id: {
+ type: 'Identifier',
+ name: 'x',
+ range: [8, 9],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ init: {
+ type: 'Literal',
+ value: 0,
+ raw: '0',
+ range: [12, 13],
+ loc: {
+ start: { line: 1, column: 12 },
+ end: { line: 1, column: 13 }
+ }
+ },
+ range: [8, 13],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 13 }
+ }
+ }],
+ kind: 'var',
+ range: [4, 13],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 13 }
+ }
+ },
+ test: null,
+ update: null,
+ body: {
+ type: 'EmptyStatement',
+ range: [16, 17],
+ loc: {
+ start: { line: 1, column: 16 },
+ end: { line: 1, column: 17 }
+ }
+ },
+ range: [0, 17],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 17 }
+ }
+ },
+
+ 'for(let x = 0;;);': {
+ type: 'ForStatement',
+ init: {
+ type: 'VariableDeclaration',
+ declarations: [{
+ type: 'VariableDeclarator',
+ id: {
+ type: 'Identifier',
+ name: 'x',
+ range: [8, 9],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ init: {
+ type: 'Literal',
+ value: 0,
+ raw: '0',
+ range: [12, 13],
+ loc: {
+ start: { line: 1, column: 12 },
+ end: { line: 1, column: 13 }
+ }
+ },
+ range: [8, 13],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 13 }
+ }
+ }],
+ kind: 'let',
+ range: [4, 13],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 13 }
+ }
+ },
+ test: null,
+ update: null,
+ body: {
+ type: 'EmptyStatement',
+ range: [16, 17],
+ loc: {
+ start: { line: 1, column: 16 },
+ end: { line: 1, column: 17 }
+ }
+ },
+ range: [0, 17],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 17 }
+ }
+ },
+
+ 'for(var x = 0, y = 1;;);': {
+ type: 'ForStatement',
+ init: {
+ type: 'VariableDeclaration',
+ declarations: [{
+ type: 'VariableDeclarator',
+ id: {
+ type: 'Identifier',
+ name: 'x',
+ range: [8, 9],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ init: {
+ type: 'Literal',
+ value: 0,
+ raw: '0',
+ range: [12, 13],
+ loc: {
+ start: { line: 1, column: 12 },
+ end: { line: 1, column: 13 }
+ }
+ },
+ range: [8, 13],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 13 }
+ }
+ }, {
+ type: 'VariableDeclarator',
+ id: {
+ type: 'Identifier',
+ name: 'y',
+ range: [15, 16],
+ loc: {
+ start: { line: 1, column: 15 },
+ end: { line: 1, column: 16 }
+ }
+ },
+ init: {
+ type: 'Literal',
+ value: 1,
+ raw: '1',
+ range: [19, 20],
+ loc: {
+ start: { line: 1, column: 19 },
+ end: { line: 1, column: 20 }
+ }
+ },
+ range: [15, 20],
+ loc: {
+ start: { line: 1, column: 15 },
+ end: { line: 1, column: 20 }
+ }
+ }],
+ kind: 'var',
+ range: [4, 20],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 20 }
+ }
+ },
+ test: null,
+ update: null,
+ body: {
+ type: 'EmptyStatement',
+ range: [23, 24],
+ loc: {
+ start: { line: 1, column: 23 },
+ end: { line: 1, column: 24 }
+ }
+ },
+ range: [0, 24],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 24 }
+ }
+ },
+
+ 'for(x = 0; x < 42;);': {
+ type: 'ForStatement',
+ init: {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [4, 5],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ right: {
+ type: 'Literal',
+ value: 0,
+ raw: '0',
+ range: [8, 9],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ range: [4, 9],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ test: {
+ type: 'BinaryExpression',
+ operator: '<',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [11, 12],
+ loc: {
+ start: { line: 1, column: 11 },
+ end: { line: 1, column: 12 }
+ }
+ },
+ right: {
+ type: 'Literal',
+ value: 42,
+ raw: '42',
+ range: [15, 17],
+ loc: {
+ start: { line: 1, column: 15 },
+ end: { line: 1, column: 17 }
+ }
+ },
+ range: [11, 17],
+ loc: {
+ start: { line: 1, column: 11 },
+ end: { line: 1, column: 17 }
+ }
+ },
+ update: null,
+ body: {
+ type: 'EmptyStatement',
+ range: [19, 20],
+ loc: {
+ start: { line: 1, column: 19 },
+ end: { line: 1, column: 20 }
+ }
+ },
+ range: [0, 20],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 20 }
+ }
+ },
+
+ 'for(x = 0; x < 42; x++);': {
+ type: 'ForStatement',
+ init: {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [4, 5],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ right: {
+ type: 'Literal',
+ value: 0,
+ raw: '0',
+ range: [8, 9],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ range: [4, 9],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ test: {
+ type: 'BinaryExpression',
+ operator: '<',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [11, 12],
+ loc: {
+ start: { line: 1, column: 11 },
+ end: { line: 1, column: 12 }
+ }
+ },
+ right: {
+ type: 'Literal',
+ value: 42,
+ raw: '42',
+ range: [15, 17],
+ loc: {
+ start: { line: 1, column: 15 },
+ end: { line: 1, column: 17 }
+ }
+ },
+ range: [11, 17],
+ loc: {
+ start: { line: 1, column: 11 },
+ end: { line: 1, column: 17 }
+ }
+ },
+ update: {
+ type: 'UpdateExpression',
+ operator: '++',
+ argument: {
+ type: 'Identifier',
+ name: 'x',
+ range: [19, 20],
+ loc: {
+ start: { line: 1, column: 19 },
+ end: { line: 1, column: 20 }
+ }
+ },
+ prefix: false,
+ range: [19, 22],
+ loc: {
+ start: { line: 1, column: 19 },
+ end: { line: 1, column: 22 }
+ }
+ },
+ body: {
+ type: 'EmptyStatement',
+ range: [23, 24],
+ loc: {
+ start: { line: 1, column: 23 },
+ end: { line: 1, column: 24 }
+ }
+ },
+ range: [0, 24],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 24 }
+ }
+ },
+
+ 'for(x = 0; x < 42; x++) process(x);': {
+ type: 'ForStatement',
+ init: {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [4, 5],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ right: {
+ type: 'Literal',
+ value: 0,
+ raw: '0',
+ range: [8, 9],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ range: [4, 9],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ test: {
+ type: 'BinaryExpression',
+ operator: '<',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [11, 12],
+ loc: {
+ start: { line: 1, column: 11 },
+ end: { line: 1, column: 12 }
+ }
+ },
+ right: {
+ type: 'Literal',
+ value: 42,
+ raw: '42',
+ range: [15, 17],
+ loc: {
+ start: { line: 1, column: 15 },
+ end: { line: 1, column: 17 }
+ }
+ },
+ range: [11, 17],
+ loc: {
+ start: { line: 1, column: 11 },
+ end: { line: 1, column: 17 }
+ }
+ },
+ update: {
+ type: 'UpdateExpression',
+ operator: '++',
+ argument: {
+ type: 'Identifier',
+ name: 'x',
+ range: [19, 20],
+ loc: {
+ start: { line: 1, column: 19 },
+ end: { line: 1, column: 20 }
+ }
+ },
+ prefix: false,
+ range: [19, 22],
+ loc: {
+ start: { line: 1, column: 19 },
+ end: { line: 1, column: 22 }
+ }
+ },
+ body: {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'CallExpression',
+ callee: {
+ type: 'Identifier',
+ name: 'process',
+ range: [24, 31],
+ loc: {
+ start: { line: 1, column: 24 },
+ end: { line: 1, column: 31 }
+ }
+ },
+ 'arguments': [{
+ type: 'Identifier',
+ name: 'x',
+ range: [32, 33],
+ loc: {
+ start: { line: 1, column: 32 },
+ end: { line: 1, column: 33 }
+ }
+ }],
+ range: [24, 34],
+ loc: {
+ start: { line: 1, column: 24 },
+ end: { line: 1, column: 34 }
+ }
+ },
+ range: [24, 35],
+ loc: {
+ start: { line: 1, column: 24 },
+ end: { line: 1, column: 35 }
+ }
+ },
+ range: [0, 35],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 35 }
+ }
+ },
+
+ 'for(x in list) process(x);': {
+ type: 'ForInStatement',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [4, 5],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'list',
+ range: [9, 13],
+ loc: {
+ start: { line: 1, column: 9 },
+ end: { line: 1, column: 13 }
+ }
+ },
+ body: {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'CallExpression',
+ callee: {
+ type: 'Identifier',
+ name: 'process',
+ range: [15, 22],
+ loc: {
+ start: { line: 1, column: 15 },
+ end: { line: 1, column: 22 }
+ }
+ },
+ 'arguments': [{
+ type: 'Identifier',
+ name: 'x',
+ range: [23, 24],
+ loc: {
+ start: { line: 1, column: 23 },
+ end: { line: 1, column: 24 }
+ }
+ }],
+ range: [15, 25],
+ loc: {
+ start: { line: 1, column: 15 },
+ end: { line: 1, column: 25 }
+ }
+ },
+ range: [15, 26],
+ loc: {
+ start: { line: 1, column: 15 },
+ end: { line: 1, column: 26 }
+ }
+ },
+ each: false,
+ range: [0, 26],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 26 }
+ }
+ },
+
+ 'for (var x in list) process(x);': {
+ type: 'ForInStatement',
+ left: {
+ type: 'VariableDeclaration',
+ declarations: [{
+ type: 'VariableDeclarator',
+ id: {
+ type: 'Identifier',
+ name: 'x',
+ range: [9, 10],
+ loc: {
+ start: { line: 1, column: 9 },
+ end: { line: 1, column: 10 }
+ }
+ },
+ init: null,
+ range: [9, 10],
+ loc: {
+ start: { line: 1, column: 9 },
+ end: { line: 1, column: 10 }
+ }
+ }],
+ kind: 'var',
+ range: [5, 10],
+ loc: {
+ start: { line: 1, column: 5 },
+ end: { line: 1, column: 10 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'list',
+ range: [14, 18],
+ loc: {
+ start: { line: 1, column: 14 },
+ end: { line: 1, column: 18 }
+ }
+ },
+ body: {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'CallExpression',
+ callee: {
+ type: 'Identifier',
+ name: 'process',
+ range: [20, 27],
+ loc: {
+ start: { line: 1, column: 20 },
+ end: { line: 1, column: 27 }
+ }
+ },
+ 'arguments': [{
+ type: 'Identifier',
+ name: 'x',
+ range: [28, 29],
+ loc: {
+ start: { line: 1, column: 28 },
+ end: { line: 1, column: 29 }
+ }
+ }],
+ range: [20, 30],
+ loc: {
+ start: { line: 1, column: 20 },
+ end: { line: 1, column: 30 }
+ }
+ },
+ range: [20, 31],
+ loc: {
+ start: { line: 1, column: 20 },
+ end: { line: 1, column: 31 }
+ }
+ },
+ each: false,
+ range: [0, 31],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 31 }
+ }
+ },
+
+ 'for (var x = 42 in list) process(x);': {
+ type: 'ForInStatement',
+ left: {
+ type: 'VariableDeclaration',
+ declarations: [{
+ type: 'VariableDeclarator',
+ id: {
+ type: 'Identifier',
+ name: 'x',
+ range: [9, 10],
+ loc: {
+ start: { line: 1, column: 9 },
+ end: { line: 1, column: 10 }
+ }
+ },
+ init: {
+ type: 'Literal',
+ value: 42,
+ raw: '42',
+ range: [13, 15],
+ loc: {
+ start: { line: 1, column: 13 },
+ end: { line: 1, column: 15 }
+ }
+ },
+ range: [9, 15],
+ loc: {
+ start: { line: 1, column: 9 },
+ end: { line: 1, column: 15 }
+ }
+ }],
+ kind: 'var',
+ range: [5, 15],
+ loc: {
+ start: { line: 1, column: 5 },
+ end: { line: 1, column: 15 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'list',
+ range: [19, 23],
+ loc: {
+ start: { line: 1, column: 19 },
+ end: { line: 1, column: 23 }
+ }
+ },
+ body: {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'CallExpression',
+ callee: {
+ type: 'Identifier',
+ name: 'process',
+ range: [25, 32],
+ loc: {
+ start: { line: 1, column: 25 },
+ end: { line: 1, column: 32 }
+ }
+ },
+ 'arguments': [{
+ type: 'Identifier',
+ name: 'x',
+ range: [33, 34],
+ loc: {
+ start: { line: 1, column: 33 },
+ end: { line: 1, column: 34 }
+ }
+ }],
+ range: [25, 35],
+ loc: {
+ start: { line: 1, column: 25 },
+ end: { line: 1, column: 35 }
+ }
+ },
+ range: [25, 36],
+ loc: {
+ start: { line: 1, column: 25 },
+ end: { line: 1, column: 36 }
+ }
+ },
+ each: false,
+ range: [0, 36],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 36 }
+ }
+ },
+
+ 'for (let x in list) process(x);': {
+ type: 'ForInStatement',
+ left: {
+ type: 'VariableDeclaration',
+ declarations: [{
+ type: 'VariableDeclarator',
+ id: {
+ type: 'Identifier',
+ name: 'x',
+ range: [9, 10],
+ loc: {
+ start: { line: 1, column: 9 },
+ end: { line: 1, column: 10 }
+ }
+ },
+ init: null,
+ range: [9, 10],
+ loc: {
+ start: { line: 1, column: 9 },
+ end: { line: 1, column: 10 }
+ }
+ }],
+ kind: 'let',
+ range: [5, 10],
+ loc: {
+ start: { line: 1, column: 5 },
+ end: { line: 1, column: 10 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'list',
+ range: [14, 18],
+ loc: {
+ start: { line: 1, column: 14 },
+ end: { line: 1, column: 18 }
+ }
+ },
+ body: {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'CallExpression',
+ callee: {
+ type: 'Identifier',
+ name: 'process',
+ range: [20, 27],
+ loc: {
+ start: { line: 1, column: 20 },
+ end: { line: 1, column: 27 }
+ }
+ },
+ 'arguments': [{
+ type: 'Identifier',
+ name: 'x',
+ range: [28, 29],
+ loc: {
+ start: { line: 1, column: 28 },
+ end: { line: 1, column: 29 }
+ }
+ }],
+ range: [20, 30],
+ loc: {
+ start: { line: 1, column: 20 },
+ end: { line: 1, column: 30 }
+ }
+ },
+ range: [20, 31],
+ loc: {
+ start: { line: 1, column: 20 },
+ end: { line: 1, column: 31 }
+ }
+ },
+ each: false,
+ range: [0, 31],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 31 }
+ }
+ },
+
+ 'for (let x = 42 in list) process(x);': {
+ type: 'ForInStatement',
+ left: {
+ type: 'VariableDeclaration',
+ declarations: [{
+ type: 'VariableDeclarator',
+ id: {
+ type: 'Identifier',
+ name: 'x',
+ range: [9, 10],
+ loc: {
+ start: { line: 1, column: 9 },
+ end: { line: 1, column: 10 }
+ }
+ },
+ init: {
+ type: 'Literal',
+ value: 42,
+ raw: '42',
+ range: [13, 15],
+ loc: {
+ start: { line: 1, column: 13 },
+ end: { line: 1, column: 15 }
+ }
+ },
+ range: [9, 15],
+ loc: {
+ start: { line: 1, column: 9 },
+ end: { line: 1, column: 15 }
+ }
+ }],
+ kind: 'let',
+ range: [5, 15],
+ loc: {
+ start: { line: 1, column: 5 },
+ end: { line: 1, column: 15 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'list',
+ range: [19, 23],
+ loc: {
+ start: { line: 1, column: 19 },
+ end: { line: 1, column: 23 }
+ }
+ },
+ body: {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'CallExpression',
+ callee: {
+ type: 'Identifier',
+ name: 'process',
+ range: [25, 32],
+ loc: {
+ start: { line: 1, column: 25 },
+ end: { line: 1, column: 32 }
+ }
+ },
+ 'arguments': [{
+ type: 'Identifier',
+ name: 'x',
+ range: [33, 34],
+ loc: {
+ start: { line: 1, column: 33 },
+ end: { line: 1, column: 34 }
+ }
+ }],
+ range: [25, 35],
+ loc: {
+ start: { line: 1, column: 25 },
+ end: { line: 1, column: 35 }
+ }
+ },
+ range: [25, 36],
+ loc: {
+ start: { line: 1, column: 25 },
+ end: { line: 1, column: 36 }
+ }
+ },
+ each: false,
+ range: [0, 36],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 36 }
+ }
+ },
+
+ 'for (var i = function() { return 10 in [] } in list) process(x);': {
+ type: 'ForInStatement',
+ left: {
+ type: 'VariableDeclaration',
+ declarations: [{
+ type: 'VariableDeclarator',
+ id: {
+ type: 'Identifier',
+ name: 'i',
+ range: [9, 10],
+ loc: {
+ start: { line: 1, column: 9 },
+ end: { line: 1, column: 10 }
+ }
+ },
+ init: {
+ type: 'FunctionExpression',
+ id: null,
+ params: [],
+ defaults: [],
+ body: {
+ type: 'BlockStatement',
+ body: [{
+ type: 'ReturnStatement',
+ argument: {
+ type: 'BinaryExpression',
+ operator: 'in',
+ left: {
+ type: 'Literal',
+ value: 10,
+ raw: '10',
+ range: [33, 35],
+ loc: {
+ start: { line: 1, column: 33 },
+ end: { line: 1, column: 35 }
+ }
+ },
+ right: {
+ type: 'ArrayExpression',
+ elements: [],
+ range: [39, 41],
+ loc: {
+ start: { line: 1, column: 39 },
+ end: { line: 1, column: 41 }
+ }
+ },
+ range: [33, 41],
+ loc: {
+ start: { line: 1, column: 33 },
+ end: { line: 1, column: 41 }
+ }
+ },
+ range: [26, 42],
+ loc: {
+ start: { line: 1, column: 26 },
+ end: { line: 1, column: 42 }
+ }
+ }],
+ range: [24, 43],
+ loc: {
+ start: { line: 1, column: 24 },
+ end: { line: 1, column: 43 }
+ }
+ },
+ rest: null,
+ generator: false,
+ expression: false,
+ range: [13, 43],
+ loc: {
+ start: { line: 1, column: 13 },
+ end: { line: 1, column: 43 }
+ }
+ },
+ range: [9, 43],
+ loc: {
+ start: { line: 1, column: 9 },
+ end: { line: 1, column: 43 }
+ }
+ }],
+ kind: 'var',
+ range: [5, 43],
+ loc: {
+ start: { line: 1, column: 5 },
+ end: { line: 1, column: 43 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'list',
+ range: [47, 51],
+ loc: {
+ start: { line: 1, column: 47 },
+ end: { line: 1, column: 51 }
+ }
+ },
+ body: {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'CallExpression',
+ callee: {
+ type: 'Identifier',
+ name: 'process',
+ range: [53, 60],
+ loc: {
+ start: { line: 1, column: 53 },
+ end: { line: 1, column: 60 }
+ }
+ },
+ 'arguments': [{
+ type: 'Identifier',
+ name: 'x',
+ range: [61, 62],
+ loc: {
+ start: { line: 1, column: 61 },
+ end: { line: 1, column: 62 }
+ }
+ }],
+ range: [53, 63],
+ loc: {
+ start: { line: 1, column: 53 },
+ end: { line: 1, column: 63 }
+ }
+ },
+ range: [53, 64],
+ loc: {
+ start: { line: 1, column: 53 },
+ end: { line: 1, column: 64 }
+ }
+ },
+ each: false,
+ range: [0, 64],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 64 }
+ }
+ }
+
+ },
+
+ 'continue statement': {
+
+ 'while (true) { continue; }': {
+ type: 'WhileStatement',
+ test: {
+ type: 'Literal',
+ value: true,
+ raw: 'true',
+ range: [7, 11],
+ loc: {
+ start: { line: 1, column: 7 },
+ end: { line: 1, column: 11 }
+ }
+ },
+ body: {
+ type: 'BlockStatement',
+ body: [
+ {
+ type: 'ContinueStatement',
+ label: null,
+ range: [15, 24],
+ loc: {
+ start: { line: 1, column: 15 },
+ end: { line: 1, column: 24 }
+ }
+ }
+ ],
+ range: [13, 26],
+ loc: {
+ start: { line: 1, column: 13 },
+ end: { line: 1, column: 26 }
+ }
+ },
+ range: [0, 26],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 26 }
+ }
+ },
+
+ 'while (true) { continue }': {
+ type: 'WhileStatement',
+ test: {
+ type: 'Literal',
+ value: true,
+ raw: 'true',
+ range: [7, 11],
+ loc: {
+ start: { line: 1, column: 7 },
+ end: { line: 1, column: 11 }
+ }
+ },
+ body: {
+ type: 'BlockStatement',
+ body: [
+ {
+ type: 'ContinueStatement',
+ label: null,
+ range: [15, 24],
+ loc: {
+ start: { line: 1, column: 15 },
+ end: { line: 1, column: 24 }
+ }
+ }
+ ],
+ range: [13, 25],
+ loc: {
+ start: { line: 1, column: 13 },
+ end: { line: 1, column: 25 }
+ }
+ },
+ range: [0, 25],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 25 }
+ }
+ },
+
+ 'done: while (true) { continue done }': {
+ type: 'LabeledStatement',
+ label: {
+ type: 'Identifier',
+ name: 'done',
+ range: [0, 4],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 4 }
+ }
+ },
+ body: {
+ type: 'WhileStatement',
+ test: {
+ type: 'Literal',
+ value: true,
+ raw: 'true',
+ range: [13, 17],
+ loc: {
+ start: { line: 1, column: 13 },
+ end: { line: 1, column: 17 }
+ }
+ },
+ body: {
+ type: 'BlockStatement',
+ body: [
+ {
+ type: 'ContinueStatement',
+ label: {
+ type: 'Identifier',
+ name: 'done',
+ range: [30, 34],
+ loc: {
+ start: { line: 1, column: 30 },
+ end: { line: 1, column: 34 }
+ }
+ },
+ range: [21, 35],
+ loc: {
+ start: { line: 1, column: 21 },
+ end: { line: 1, column: 35 }
+ }
+ }
+ ],
+ range: [19, 36],
+ loc: {
+ start: { line: 1, column: 19 },
+ end: { line: 1, column: 36 }
+ }
+ },
+ range: [6, 36],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 36 }
+ }
+ },
+ range: [0, 36],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 36 }
+ }
+ },
+
+ 'done: while (true) { continue done; }': {
+ type: 'LabeledStatement',
+ label: {
+ type: 'Identifier',
+ name: 'done',
+ range: [0, 4],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 4 }
+ }
+ },
+ body: {
+ type: 'WhileStatement',
+ test: {
+ type: 'Literal',
+ value: true,
+ raw: 'true',
+ range: [13, 17],
+ loc: {
+ start: { line: 1, column: 13 },
+ end: { line: 1, column: 17 }
+ }
+ },
+ body: {
+ type: 'BlockStatement',
+ body: [
+ {
+ type: 'ContinueStatement',
+ label: {
+ type: 'Identifier',
+ name: 'done',
+ range: [30, 34],
+ loc: {
+ start: { line: 1, column: 30 },
+ end: { line: 1, column: 34 }
+ }
+ },
+ range: [21, 35],
+ loc: {
+ start: { line: 1, column: 21 },
+ end: { line: 1, column: 35 }
+ }
+ }
+ ],
+ range: [19, 37],
+ loc: {
+ start: { line: 1, column: 19 },
+ end: { line: 1, column: 37 }
+ }
+ },
+ range: [6, 37],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 37 }
+ }
+ },
+ range: [0, 37],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 37 }
+ }
+ }
+
+ },
+
+ 'break statement': {
+
+ 'while (true) { break }': {
+ type: 'WhileStatement',
+ test: {
+ type: 'Literal',
+ value: true,
+ raw: 'true',
+ range: [7, 11],
+ loc: {
+ start: { line: 1, column: 7 },
+ end: { line: 1, column: 11 }
+ }
+ },
+ body: {
+ type: 'BlockStatement',
+ body: [
+ {
+ type: 'BreakStatement',
+ label: null,
+ range: [15, 21],
+ loc: {
+ start: { line: 1, column: 15 },
+ end: { line: 1, column: 21 }
+ }
+ }
+ ],
+ range: [13, 22],
+ loc: {
+ start: { line: 1, column: 13 },
+ end: { line: 1, column: 22 }
+ }
+ },
+ range: [0, 22],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 22 }
+ }
+ },
+
+ 'done: while (true) { break done }': {
+ type: 'LabeledStatement',
+ label: {
+ type: 'Identifier',
+ name: 'done',
+ range: [0, 4],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 4 }
+ }
+ },
+ body: {
+ type: 'WhileStatement',
+ test: {
+ type: 'Literal',
+ value: true,
+ raw: 'true',
+ range: [13, 17],
+ loc: {
+ start: { line: 1, column: 13 },
+ end: { line: 1, column: 17 }
+ }
+ },
+ body: {
+ type: 'BlockStatement',
+ body: [
+ {
+ type: 'BreakStatement',
+ label: {
+ type: 'Identifier',
+ name: 'done',
+ range: [27, 31],
+ loc: {
+ start: { line: 1, column: 27 },
+ end: { line: 1, column: 31 }
+ }
+ },
+ range: [21, 32],
+ loc: {
+ start: { line: 1, column: 21 },
+ end: { line: 1, column: 32 }
+ }
+ }
+ ],
+ range: [19, 33],
+ loc: {
+ start: { line: 1, column: 19 },
+ end: { line: 1, column: 33 }
+ }
+ },
+ range: [6, 33],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 33 }
+ }
+ },
+ range: [0, 33],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 33 }
+ }
+ },
+
+ 'done: while (true) { break done; }': {
+ type: 'LabeledStatement',
+ label: {
+ type: 'Identifier',
+ name: 'done',
+ range: [0, 4],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 4 }
+ }
+ },
+ body: {
+ type: 'WhileStatement',
+ test: {
+ type: 'Literal',
+ value: true,
+ raw: 'true',
+ range: [13, 17],
+ loc: {
+ start: { line: 1, column: 13 },
+ end: { line: 1, column: 17 }
+ }
+ },
+ body: {
+ type: 'BlockStatement',
+ body: [
+ {
+ type: 'BreakStatement',
+ label: {
+ type: 'Identifier',
+ name: 'done',
+ range: [27, 31],
+ loc: {
+ start: { line: 1, column: 27 },
+ end: { line: 1, column: 31 }
+ }
+ },
+ range: [21, 32],
+ loc: {
+ start: { line: 1, column: 21 },
+ end: { line: 1, column: 32 }
+ }
+ }
+ ],
+ range: [19, 34],
+ loc: {
+ start: { line: 1, column: 19 },
+ end: { line: 1, column: 34 }
+ }
+ },
+ range: [6, 34],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 34 }
+ }
+ },
+ range: [0, 34],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 34 }
+ }
+ }
+
+ },
+
+ 'return statement': {
+
+ '(function(){ return })': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'FunctionExpression',
+ id: null,
+ params: [],
+ defaults: [],
+ body: {
+ type: 'BlockStatement',
+ body: [
+ {
+ type: 'ReturnStatement',
+ argument: null,
+ range: [13, 20],
+ loc: {
+ start: { line: 1, column: 13 },
+ end: { line: 1, column: 20 }
+ }
+ }
+ ],
+ range: [11, 21],
+ loc: {
+ start: { line: 1, column: 11 },
+ end: { line: 1, column: 21 }
+ }
+ },
+ rest: null,
+ generator: false,
+ expression: false,
+ range: [1, 21],
+ loc: {
+ start: { line: 1, column: 1 },
+ end: { line: 1, column: 21 }
+ }
+ },
+ range: [0, 22],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 22 }
+ }
+ },
+
+ '(function(){ return; })': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'FunctionExpression',
+ id: null,
+ params: [],
+ defaults: [],
+ body: {
+ type: 'BlockStatement',
+ body: [
+ {
+ type: 'ReturnStatement',
+ argument: null,
+ range: [13, 20],
+ loc: {
+ start: { line: 1, column: 13 },
+ end: { line: 1, column: 20 }
+ }
+ }
+ ],
+ range: [11, 22],
+ loc: {
+ start: { line: 1, column: 11 },
+ end: { line: 1, column: 22 }
+ }
+ },
+ rest: null,
+ generator: false,
+ expression: false,
+ range: [1, 22],
+ loc: {
+ start: { line: 1, column: 1 },
+ end: { line: 1, column: 22 }
+ }
+ },
+ range: [0, 23],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 23 }
+ }
+ },
+
+ '(function(){ return x; })': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'FunctionExpression',
+ id: null,
+ params: [],
+ defaults: [],
+ body: {
+ type: 'BlockStatement',
+ body: [
+ {
+ type: 'ReturnStatement',
+ argument: {
+ type: 'Identifier',
+ name: 'x',
+ range: [20, 21],
+ loc: {
+ start: { line: 1, column: 20 },
+ end: { line: 1, column: 21 }
+ }
+ },
+ range: [13, 22],
+ loc: {
+ start: { line: 1, column: 13 },
+ end: { line: 1, column: 22 }
+ }
+ }
+ ],
+ range: [11, 24],
+ loc: {
+ start: { line: 1, column: 11 },
+ end: { line: 1, column: 24 }
+ }
+ },
+ rest: null,
+ generator: false,
+ expression: false,
+ range: [1, 24],
+ loc: {
+ start: { line: 1, column: 1 },
+ end: { line: 1, column: 24 }
+ }
+ },
+ range: [0, 25],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 25 }
+ }
+ },
+
+ '(function(){ return x * y })': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'FunctionExpression',
+ id: null,
+ params: [],
+ defaults: [],
+ body: {
+ type: 'BlockStatement',
+ body: [
+ {
+ type: 'ReturnStatement',
+ argument: {
+ type: 'BinaryExpression',
+ operator: '*',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [20, 21],
+ loc: {
+ start: { line: 1, column: 20 },
+ end: { line: 1, column: 21 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'y',
+ range: [24, 25],
+ loc: {
+ start: { line: 1, column: 24 },
+ end: { line: 1, column: 25 }
+ }
+ },
+ range: [20, 25],
+ loc: {
+ start: { line: 1, column: 20 },
+ end: { line: 1, column: 25 }
+ }
+ },
+ range: [13, 26],
+ loc: {
+ start: { line: 1, column: 13 },
+ end: { line: 1, column: 26 }
+ }
+ }
+ ],
+ range: [11, 27],
+ loc: {
+ start: { line: 1, column: 11 },
+ end: { line: 1, column: 27 }
+ }
+ },
+ rest: null,
+ generator: false,
+ expression: false,
+ range: [1, 27],
+ loc: {
+ start: { line: 1, column: 1 },
+ end: { line: 1, column: 27 }
+ }
+ },
+ range: [0, 28],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 28 }
+ }
+ }
+ },
+
+ 'with statement': {
+
+ 'with (x) foo = bar': {
+ type: 'WithStatement',
+ object: {
+ type: 'Identifier',
+ name: 'x',
+ range: [6, 7],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 7 }
+ }
+ },
+ body: {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left: {
+ type: 'Identifier',
+ name: 'foo',
+ range: [9, 12],
+ loc: {
+ start: { line: 1, column: 9 },
+ end: { line: 1, column: 12 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'bar',
+ range: [15, 18],
+ loc: {
+ start: { line: 1, column: 15 },
+ end: { line: 1, column: 18 }
+ }
+ },
+ range: [9, 18],
+ loc: {
+ start: { line: 1, column: 9 },
+ end: { line: 1, column: 18 }
+ }
+ },
+ range: [9, 18],
+ loc: {
+ start: { line: 1, column: 9 },
+ end: { line: 1, column: 18 }
+ }
+ },
+ range: [0, 18],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 18 }
+ }
+ },
+
+ 'with (x) foo = bar;': {
+ type: 'WithStatement',
+ object: {
+ type: 'Identifier',
+ name: 'x',
+ range: [6, 7],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 7 }
+ }
+ },
+ body: {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left: {
+ type: 'Identifier',
+ name: 'foo',
+ range: [9, 12],
+ loc: {
+ start: { line: 1, column: 9 },
+ end: { line: 1, column: 12 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'bar',
+ range: [15, 18],
+ loc: {
+ start: { line: 1, column: 15 },
+ end: { line: 1, column: 18 }
+ }
+ },
+ range: [9, 18],
+ loc: {
+ start: { line: 1, column: 9 },
+ end: { line: 1, column: 18 }
+ }
+ },
+ range: [9, 19],
+ loc: {
+ start: { line: 1, column: 9 },
+ end: { line: 1, column: 19 }
+ }
+ },
+ range: [0, 19],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 19 }
+ }
+ },
+
+ 'with (x) { foo = bar }': {
+ type: 'WithStatement',
+ object: {
+ type: 'Identifier',
+ name: 'x',
+ range: [6, 7],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 7 }
+ }
+ },
+ body: {
+ type: 'BlockStatement',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left: {
+ type: 'Identifier',
+ name: 'foo',
+ range: [11, 14],
+ loc: {
+ start: { line: 1, column: 11 },
+ end: { line: 1, column: 14 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'bar',
+ range: [17, 20],
+ loc: {
+ start: { line: 1, column: 17 },
+ end: { line: 1, column: 20 }
+ }
+ },
+ range: [11, 20],
+ loc: {
+ start: { line: 1, column: 11 },
+ end: { line: 1, column: 20 }
+ }
+ },
+ range: [11, 21],
+ loc: {
+ start: { line: 1, column: 11 },
+ end: { line: 1, column: 21 }
+ }
+ }],
+ range: [9, 22],
+ loc: {
+ start: { line: 1, column: 9 },
+ end: { line: 1, column: 22 }
+ }
+ },
+ range: [0, 22],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 22 }
+ }
+ }
+
+ },
+
+ 'switch statement': {
+
+ 'switch (x) {}': {
+ type: 'SwitchStatement',
+ discriminant: {
+ type: 'Identifier',
+ name: 'x',
+ range: [8, 9],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ cases:[],
+ range: [0, 13],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 13 }
+ }
+ },
+
+ 'switch (answer) { case 42: hi(); break; }': {
+ type: 'SwitchStatement',
+ discriminant: {
+ type: 'Identifier',
+ name: 'answer',
+ range: [8, 14],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 14 }
+ }
+ },
+ cases: [{
+ type: 'SwitchCase',
+ test: {
+ type: 'Literal',
+ value: 42,
+ raw: '42',
+ range: [23, 25],
+ loc: {
+ start: { line: 1, column: 23 },
+ end: { line: 1, column: 25 }
+ }
+ },
+ consequent: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'CallExpression',
+ callee: {
+ type: 'Identifier',
+ name: 'hi',
+ range: [27, 29],
+ loc: {
+ start: { line: 1, column: 27 },
+ end: { line: 1, column: 29 }
+ }
+ },
+ 'arguments': [],
+ range: [27, 31],
+ loc: {
+ start: { line: 1, column: 27 },
+ end: { line: 1, column: 31 }
+ }
+ },
+ range: [27, 32],
+ loc: {
+ start: { line: 1, column: 27 },
+ end: { line: 1, column: 32 }
+ }
+ }, {
+ type: 'BreakStatement',
+ label: null,
+ range: [33, 39],
+ loc: {
+ start: { line: 1, column: 33 },
+ end: { line: 1, column: 39 }
+ }
+ }],
+ range: [18, 39],
+ loc: {
+ start: { line: 1, column: 18 },
+ end: { line: 1, column: 39 }
+ }
+ }],
+ range: [0, 41],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 41 }
+ }
+ },
+
+ 'switch (answer) { case 42: hi(); break; default: break }': {
+ type: 'SwitchStatement',
+ discriminant: {
+ type: 'Identifier',
+ name: 'answer',
+ range: [8, 14],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 14 }
+ }
+ },
+ cases: [{
+ type: 'SwitchCase',
+ test: {
+ type: 'Literal',
+ value: 42,
+ raw: '42',
+ range: [23, 25],
+ loc: {
+ start: { line: 1, column: 23 },
+ end: { line: 1, column: 25 }
+ }
+ },
+ consequent: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'CallExpression',
+ callee: {
+ type: 'Identifier',
+ name: 'hi',
+ range: [27, 29],
+ loc: {
+ start: { line: 1, column: 27 },
+ end: { line: 1, column: 29 }
+ }
+ },
+ 'arguments': [],
+ range: [27, 31],
+ loc: {
+ start: { line: 1, column: 27 },
+ end: { line: 1, column: 31 }
+ }
+ },
+ range: [27, 32],
+ loc: {
+ start: { line: 1, column: 27 },
+ end: { line: 1, column: 32 }
+ }
+ }, {
+ type: 'BreakStatement',
+ label: null,
+ range: [33, 39],
+ loc: {
+ start: { line: 1, column: 33 },
+ end: { line: 1, column: 39 }
+ }
+ }],
+ range: [18, 39],
+ loc: {
+ start: { line: 1, column: 18 },
+ end: { line: 1, column: 39 }
+ }
+ }, {
+ type: 'SwitchCase',
+ test: null,
+ consequent: [{
+ type: 'BreakStatement',
+ label: null,
+ range: [49, 55],
+ loc: {
+ start: { line: 1, column: 49 },
+ end: { line: 1, column: 55 }
+ }
+ }],
+ range: [40, 55],
+ loc: {
+ start: { line: 1, column: 40 },
+ end: { line: 1, column: 55 }
+ }
+ }],
+ range: [0, 56],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 56 }
+ }
+ }
+
+ },
+
+ 'Labelled Statements': {
+
+ 'start: for (;;) break start': {
+ type: 'LabeledStatement',
+ label: {
+ type: 'Identifier',
+ name: 'start',
+ range: [0, 5],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ body: {
+ type: 'ForStatement',
+ init: null,
+ test: null,
+ update: null,
+ body: {
+ type: 'BreakStatement',
+ label: {
+ type: 'Identifier',
+ name: 'start',
+ range: [22, 27],
+ loc: {
+ start: { line: 1, column: 22 },
+ end: { line: 1, column: 27 }
+ }
+ },
+ range: [16, 27],
+ loc: {
+ start: { line: 1, column: 16 },
+ end: { line: 1, column: 27 }
+ }
+ },
+ range: [7, 27],
+ loc: {
+ start: { line: 1, column: 7 },
+ end: { line: 1, column: 27 }
+ }
+ },
+ range: [0, 27],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 27 }
+ }
+ },
+
+ 'start: while (true) break start': {
+ type: 'LabeledStatement',
+ label: {
+ type: 'Identifier',
+ name: 'start',
+ range: [0, 5],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ body: {
+ type: 'WhileStatement',
+ test: {
+ type: 'Literal',
+ value: true,
+ raw: 'true',
+ range: [14, 18],
+ loc: {
+ start: { line: 1, column: 14 },
+ end: { line: 1, column: 18 }
+ }
+ },
+ body: {
+ type: 'BreakStatement',
+ label: {
+ type: 'Identifier',
+ name: 'start',
+ range: [26, 31],
+ loc: {
+ start: { line: 1, column: 26 },
+ end: { line: 1, column: 31 }
+ }
+ },
+ range: [20, 31],
+ loc: {
+ start: { line: 1, column: 20 },
+ end: { line: 1, column: 31 }
+ }
+ },
+ range: [7, 31],
+ loc: {
+ start: { line: 1, column: 7 },
+ end: { line: 1, column: 31 }
+ }
+ },
+ range: [0, 31],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 31 }
+ }
+ }
+
+ },
+
+ 'throw statement': {
+
+ 'throw x;': {
+ type: 'ThrowStatement',
+ argument: {
+ type: 'Identifier',
+ name: 'x',
+ range: [6, 7],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 7 }
+ }
+ },
+ range: [0, 8],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 8 }
+ }
+ },
+
+ 'throw x * y': {
+ type: 'ThrowStatement',
+ argument: {
+ type: 'BinaryExpression',
+ operator: '*',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [6, 7],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 7 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'y',
+ range: [10, 11],
+ loc: {
+ start: { line: 1, column: 10 },
+ end: { line: 1, column: 11 }
+ }
+ },
+ range: [6, 11],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 11 }
+ }
+ },
+ range: [0, 11],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 11 }
+ }
+ },
+
+ 'throw { message: "Error" }': {
+ type: 'ThrowStatement',
+ argument: {
+ type: 'ObjectExpression',
+ properties: [{
+ type: 'Property',
+ key: {
+ type: 'Identifier',
+ name: 'message',
+ range: [8, 15],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 15 }
+ }
+ },
+ value: {
+ type: 'Literal',
+ value: 'Error',
+ raw: '"Error"',
+ range: [17, 24],
+ loc: {
+ start: { line: 1, column: 17 },
+ end: { line: 1, column: 24 }
+ }
+ },
+ kind: 'init',
+ range: [8, 24],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 24 }
+ }
+ }],
+ range: [6, 26],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 26 }
+ }
+ },
+ range: [0, 26],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 26 }
+ }
+ }
+
+ },
+
+ 'try statement': {
+
+ 'try { } catch (e) { }': {
+ type: 'TryStatement',
+ block: {
+ type: 'BlockStatement',
+ body: [],
+ range: [4, 7],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 7 }
+ }
+ },
+ guardedHandlers: [],
+ handlers: [{
+ type: 'CatchClause',
+ param: {
+ type: 'Identifier',
+ name: 'e',
+ range: [15, 16],
+ loc: {
+ start: { line: 1, column: 15 },
+ end: { line: 1, column: 16 }
+ }
+ },
+ body: {
+ type: 'BlockStatement',
+ body: [],
+ range: [18, 21],
+ loc: {
+ start: { line: 1, column: 18 },
+ end: { line: 1, column: 21 }
+ }
+ },
+ range: [8, 21],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 21 }
+ }
+ }],
+ finalizer: null,
+ range: [0, 21],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 21 }
+ }
+ },
+
+ 'try { } catch (eval) { }': {
+ type: 'TryStatement',
+ block: {
+ type: 'BlockStatement',
+ body: [],
+ range: [4, 7],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 7 }
+ }
+ },
+ guardedHandlers: [],
+ handlers: [{
+ type: 'CatchClause',
+ param: {
+ type: 'Identifier',
+ name: 'eval',
+ range: [15, 19],
+ loc: {
+ start: { line: 1, column: 15 },
+ end: { line: 1, column: 19 }
+ }
+ },
+ body: {
+ type: 'BlockStatement',
+ body: [],
+ range: [21, 24],
+ loc: {
+ start: { line: 1, column: 21 },
+ end: { line: 1, column: 24 }
+ }
+ },
+ range: [8, 24],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 24 }
+ }
+ }],
+ finalizer: null,
+ range: [0, 24],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 24 }
+ }
+ },
+
+ 'try { } catch (arguments) { }': {
+ type: 'TryStatement',
+ block: {
+ type: 'BlockStatement',
+ body: [],
+ range: [4, 7],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 7 }
+ }
+ },
+ guardedHandlers: [],
+ handlers: [{
+ type: 'CatchClause',
+ param: {
+ type: 'Identifier',
+ name: 'arguments',
+ range: [15, 24],
+ loc: {
+ start: { line: 1, column: 15 },
+ end: { line: 1, column: 24 }
+ }
+ },
+ body: {
+ type: 'BlockStatement',
+ body: [],
+ range: [26, 29],
+ loc: {
+ start: { line: 1, column: 26 },
+ end: { line: 1, column: 29 }
+ }
+ },
+ range: [8, 29],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 29 }
+ }
+ }],
+ finalizer: null,
+ range: [0, 29],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 29 }
+ }
+ },
+
+ 'try { } catch (e) { say(e) }': {
+ type: 'TryStatement',
+ block: {
+ type: 'BlockStatement',
+ body: [],
+ range: [4, 7],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 7 }
+ }
+ },
+ guardedHandlers: [],
+ handlers: [{
+ type: 'CatchClause',
+ param: {
+ type: 'Identifier',
+ name: 'e',
+ range: [15, 16],
+ loc: {
+ start: { line: 1, column: 15 },
+ end: { line: 1, column: 16 }
+ }
+ },
+ body: {
+ type: 'BlockStatement',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'CallExpression',
+ callee: {
+ type: 'Identifier',
+ name: 'say',
+ range: [20, 23],
+ loc: {
+ start: { line: 1, column: 20 },
+ end: { line: 1, column: 23 }
+ }
+ },
+ 'arguments': [{
+ type: 'Identifier',
+ name: 'e',
+ range: [24, 25],
+ loc: {
+ start: { line: 1, column: 24 },
+ end: { line: 1, column: 25 }
+ }
+ }],
+ range: [20, 26],
+ loc: {
+ start: { line: 1, column: 20 },
+ end: { line: 1, column: 26 }
+ }
+ },
+ range: [20, 27],
+ loc: {
+ start: { line: 1, column: 20 },
+ end: { line: 1, column: 27 }
+ }
+ }],
+ range: [18, 28],
+ loc: {
+ start: { line: 1, column: 18 },
+ end: { line: 1, column: 28 }
+ }
+ },
+ range: [8, 28],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 28 }
+ }
+ }],
+ finalizer: null,
+ range: [0, 28],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 28 }
+ }
+ },
+
+ 'try { } finally { cleanup(stuff) }': {
+ type: 'TryStatement',
+ block: {
+ type: 'BlockStatement',
+ body: [],
+ range: [4, 7],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 7 }
+ }
+ },
+ guardedHandlers: [],
+ handlers: [],
+ finalizer: {
+ type: 'BlockStatement',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'CallExpression',
+ callee: {
+ type: 'Identifier',
+ name: 'cleanup',
+ range: [18, 25],
+ loc: {
+ start: { line: 1, column: 18 },
+ end: { line: 1, column: 25 }
+ }
+ },
+ 'arguments': [{
+ type: 'Identifier',
+ name: 'stuff',
+ range: [26, 31],
+ loc: {
+ start: { line: 1, column: 26 },
+ end: { line: 1, column: 31 }
+ }
+ }],
+ range: [18, 32],
+ loc: {
+ start: { line: 1, column: 18 },
+ end: { line: 1, column: 32 }
+ }
+ },
+ range: [18, 33],
+ loc: {
+ start: { line: 1, column: 18 },
+ end: { line: 1, column: 33 }
+ }
+ }],
+ range: [16, 34],
+ loc: {
+ start: { line: 1, column: 16 },
+ end: { line: 1, column: 34 }
+ }
+ },
+ range: [0, 34],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 34 }
+ }
+ },
+
+ 'try { doThat(); } catch (e) { say(e) }': {
+ type: 'TryStatement',
+ block: {
+ type: 'BlockStatement',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'CallExpression',
+ callee: {
+ type: 'Identifier',
+ name: 'doThat',
+ range: [6, 12],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 12 }
+ }
+ },
+ 'arguments': [],
+ range: [6, 14],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 14 }
+ }
+ },
+ range: [6, 15],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 15 }
+ }
+ }],
+ range: [4, 17],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 17 }
+ }
+ },
+ guardedHandlers: [],
+ handlers: [{
+ type: 'CatchClause',
+ param: {
+ type: 'Identifier',
+ name: 'e',
+ range: [25, 26],
+ loc: {
+ start: { line: 1, column: 25 },
+ end: { line: 1, column: 26 }
+ }
+ },
+ body: {
+ type: 'BlockStatement',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'CallExpression',
+ callee: {
+ type: 'Identifier',
+ name: 'say',
+ range: [30, 33],
+ loc: {
+ start: { line: 1, column: 30 },
+ end: { line: 1, column: 33 }
+ }
+ },
+ 'arguments': [{
+ type: 'Identifier',
+ name: 'e',
+ range: [34, 35],
+ loc: {
+ start: { line: 1, column: 34 },
+ end: { line: 1, column: 35 }
+ }
+ }],
+ range: [30, 36],
+ loc: {
+ start: { line: 1, column: 30 },
+ end: { line: 1, column: 36 }
+ }
+ },
+ range: [30, 37],
+ loc: {
+ start: { line: 1, column: 30 },
+ end: { line: 1, column: 37 }
+ }
+ }],
+ range: [28, 38],
+ loc: {
+ start: { line: 1, column: 28 },
+ end: { line: 1, column: 38 }
+ }
+ },
+ range: [18, 38],
+ loc: {
+ start: { line: 1, column: 18 },
+ end: { line: 1, column: 38 }
+ }
+ }],
+ finalizer: null,
+ range: [0, 38],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 38 }
+ }
+ },
+
+ 'try { doThat(); } catch (e) { say(e) } finally { cleanup(stuff) }': {
+ type: 'TryStatement',
+ block: {
+ type: 'BlockStatement',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'CallExpression',
+ callee: {
+ type: 'Identifier',
+ name: 'doThat',
+ range: [6, 12],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 12 }
+ }
+ },
+ 'arguments': [],
+ range: [6, 14],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 14 }
+ }
+ },
+ range: [6, 15],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 15 }
+ }
+ }],
+ range: [4, 17],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 17 }
+ }
+ },
+ guardedHandlers: [],
+ handlers: [{
+ type: 'CatchClause',
+ param: {
+ type: 'Identifier',
+ name: 'e',
+ range: [25, 26],
+ loc: {
+ start: { line: 1, column: 25 },
+ end: { line: 1, column: 26 }
+ }
+ },
+ body: {
+ type: 'BlockStatement',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'CallExpression',
+ callee: {
+ type: 'Identifier',
+ name: 'say',
+ range: [30, 33],
+ loc: {
+ start: { line: 1, column: 30 },
+ end: { line: 1, column: 33 }
+ }
+ },
+ 'arguments': [{
+ type: 'Identifier',
+ name: 'e',
+ range: [34, 35],
+ loc: {
+ start: { line: 1, column: 34 },
+ end: { line: 1, column: 35 }
+ }
+ }],
+ range: [30, 36],
+ loc: {
+ start: { line: 1, column: 30 },
+ end: { line: 1, column: 36 }
+ }
+ },
+ range: [30, 37],
+ loc: {
+ start: { line: 1, column: 30 },
+ end: { line: 1, column: 37 }
+ }
+ }],
+ range: [28, 38],
+ loc: {
+ start: { line: 1, column: 28 },
+ end: { line: 1, column: 38 }
+ }
+ },
+ range: [18, 38],
+ loc: {
+ start: { line: 1, column: 18 },
+ end: { line: 1, column: 38 }
+ }
+ }],
+ finalizer: {
+ type: 'BlockStatement',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'CallExpression',
+ callee: {
+ type: 'Identifier',
+ name: 'cleanup',
+ range: [49, 56],
+ loc: {
+ start: { line: 1, column: 49 },
+ end: { line: 1, column: 56 }
+ }
+ },
+ 'arguments': [{
+ type: 'Identifier',
+ name: 'stuff',
+ range: [57, 62],
+ loc: {
+ start: { line: 1, column: 57 },
+ end: { line: 1, column: 62 }
+ }
+ }],
+ range: [49, 63],
+ loc: {
+ start: { line: 1, column: 49 },
+ end: { line: 1, column: 63 }
+ }
+ },
+ range: [49, 64],
+ loc: {
+ start: { line: 1, column: 49 },
+ end: { line: 1, column: 64 }
+ }
+ }],
+ range: [47, 65],
+ loc: {
+ start: { line: 1, column: 47 },
+ end: { line: 1, column: 65 }
+ }
+ },
+ range: [0, 65],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 65 }
+ }
+ }
+
+ },
+
+ 'debugger statement': {
+
+ 'debugger;': {
+ type: 'DebuggerStatement',
+ range: [0, 9],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 9 }
+ }
+ }
+
+ },
+
+ 'Function Definition': {
+
+ 'function hello() { sayHi(); }': {
+ type: 'FunctionDeclaration',
+ id: {
+ type: 'Identifier',
+ name: 'hello',
+ range: [9, 14],
+ loc: {
+ start: { line: 1, column: 9 },
+ end: { line: 1, column: 14 }
+ }
+ },
+ params: [],
+ defaults: [],
+ body: {
+ type: 'BlockStatement',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'CallExpression',
+ callee: {
+ type: 'Identifier',
+ name: 'sayHi',
+ range: [19, 24],
+ loc: {
+ start: { line: 1, column: 19 },
+ end: { line: 1, column: 24 }
+ }
+ },
+ 'arguments': [],
+ range: [19, 26],
+ loc: {
+ start: { line: 1, column: 19 },
+ end: { line: 1, column: 26 }
+ }
+ },
+ range: [19, 27],
+ loc: {
+ start: { line: 1, column: 19 },
+ end: { line: 1, column: 27 }
+ }
+ }],
+ range: [17, 29],
+ loc: {
+ start: { line: 1, column: 17 },
+ end: { line: 1, column: 29 }
+ }
+ },
+ rest: null,
+ generator: false,
+ expression: false,
+ range: [0, 29],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 29 }
+ }
+ },
+
+ 'function eval() { }': {
+ type: 'FunctionDeclaration',
+ id: {
+ type: 'Identifier',
+ name: 'eval',
+ range: [9, 13],
+ loc: {
+ start: { line: 1, column: 9 },
+ end: { line: 1, column: 13 }
+ }
+ },
+ params: [],
+ defaults: [],
+ body: {
+ type: 'BlockStatement',
+ body: [],
+ range: [16, 19],
+ loc: {
+ start: { line: 1, column: 16 },
+ end: { line: 1, column: 19 }
+ }
+ },
+ rest: null,
+ generator: false,
+ expression: false,
+ range: [0, 19],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 19 }
+ }
+ },
+
+ 'function arguments() { }': {
+ type: 'FunctionDeclaration',
+ id: {
+ type: 'Identifier',
+ name: 'arguments',
+ range: [9, 18],
+ loc: {
+ start: { line: 1, column: 9 },
+ end: { line: 1, column: 18 }
+ }
+ },
+ params: [],
+ defaults: [],
+ body: {
+ type: 'BlockStatement',
+ body: [],
+ range: [21, 24],
+ loc: {
+ start: { line: 1, column: 21 },
+ end: { line: 1, column: 24 }
+ }
+ },
+ rest: null,
+ generator: false,
+ expression: false,
+ range: [0, 24],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 24 }
+ }
+ },
+
+ 'function test(t, t) { }': {
+ type: 'FunctionDeclaration',
+ id: {
+ type: 'Identifier',
+ name: 'test',
+ range: [9, 13],
+ loc: {
+ start: { line: 1, column: 9 },
+ end: { line: 1, column: 13 }
+ }
+ },
+ params: [{
+ type: 'Identifier',
+ name: 't',
+ range: [14, 15],
+ loc: {
+ start: { line: 1, column: 14 },
+ end: { line: 1, column: 15 }
+ }
+ }, {
+ type: 'Identifier',
+ name: 't',
+ range: [17, 18],
+ loc: {
+ start: { line: 1, column: 17 },
+ end: { line: 1, column: 18 }
+ }
+ }],
+ defaults: [],
+ body: {
+ type: 'BlockStatement',
+ body: [],
+ range: [20, 23],
+ loc: {
+ start: { line: 1, column: 20 },
+ end: { line: 1, column: 23 }
+ }
+ },
+ rest: null,
+ generator: false,
+ expression: false,
+ range: [0, 23],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 23 }
+ }
+ },
+
+ '(function test(t, t) { })': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'FunctionExpression',
+ id: {
+ type: 'Identifier',
+ name: 'test',
+ range: [10, 14],
+ loc: {
+ start: { line: 1, column: 10 },
+ end: { line: 1, column: 14 }
+ }
+ },
+ params: [{
+ type: 'Identifier',
+ name: 't',
+ range: [15, 16],
+ loc: {
+ start: { line: 1, column: 15 },
+ end: { line: 1, column: 16 }
+ }
+ }, {
+ type: 'Identifier',
+ name: 't',
+ range: [18, 19],
+ loc: {
+ start: { line: 1, column: 18 },
+ end: { line: 1, column: 19 }
+ }
+ }],
+ defaults: [],
+ body: {
+ type: 'BlockStatement',
+ body: [],
+ range: [21, 24],
+ loc: {
+ start: { line: 1, column: 21 },
+ end: { line: 1, column: 24 }
+ }
+ },
+ rest: null,
+ generator: false,
+ expression: false,
+ range: [1, 24],
+ loc: {
+ start: { line: 1, column: 1 },
+ end: { line: 1, column: 24 }
+ }
+ },
+ range: [0, 25],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 25 }
+ }
+ },
+
+ 'function eval() { function inner() { "use strict" } }': {
+ type: 'FunctionDeclaration',
+ id: {
+ type: 'Identifier',
+ name: 'eval',
+ range: [9, 13],
+ loc: {
+ start: { line: 1, column: 9 },
+ end: { line: 1, column: 13 }
+ }
+ },
+ params: [],
+ defaults: [],
+ body: {
+ type: 'BlockStatement',
+ body: [{
+ type: 'FunctionDeclaration',
+ id: {
+ type: 'Identifier',
+ name: 'inner',
+ range: [27, 32],
+ loc: {
+ start: { line: 1, column: 27 },
+ end: { line: 1, column: 32 }
+ }
+ },
+ params: [],
+ defaults: [],
+ body: {
+ type: 'BlockStatement',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 'use strict',
+ raw: '\"use strict\"',
+ range: [37, 49],
+ loc: {
+ start: { line: 1, column: 37 },
+ end: { line: 1, column: 49 }
+ }
+ },
+ range: [37, 50],
+ loc: {
+ start: { line: 1, column: 37 },
+ end: { line: 1, column: 50 }
+ }
+ }],
+ range: [35, 51],
+ loc: {
+ start: { line: 1, column: 35 },
+ end: { line: 1, column: 51 }
+ }
+ },
+ rest: null,
+ generator: false,
+ expression: false,
+ range: [18, 51],
+ loc: {
+ start: { line: 1, column: 18 },
+ end: { line: 1, column: 51 }
+ }
+ }],
+ range: [16, 53],
+ loc: {
+ start: { line: 1, column: 16 },
+ end: { line: 1, column: 53 }
+ }
+ },
+ rest: null,
+ generator: false,
+ expression: false,
+ range: [0, 53],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 53 }
+ }
+ },
+
+ 'function hello(a) { sayHi(); }': {
+ type: 'FunctionDeclaration',
+ id: {
+ type: 'Identifier',
+ name: 'hello',
+ range: [9, 14],
+ loc: {
+ start: { line: 1, column: 9 },
+ end: { line: 1, column: 14 }
+ }
+ },
+ params: [{
+ type: 'Identifier',
+ name: 'a',
+ range: [15, 16],
+ loc: {
+ start: { line: 1, column: 15 },
+ end: { line: 1, column: 16 }
+ }
+ }],
+ defaults: [],
+ body: {
+ type: 'BlockStatement',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'CallExpression',
+ callee: {
+ type: 'Identifier',
+ name: 'sayHi',
+ range: [20, 25],
+ loc: {
+ start: { line: 1, column: 20 },
+ end: { line: 1, column: 25 }
+ }
+ },
+ 'arguments': [],
+ range: [20, 27],
+ loc: {
+ start: { line: 1, column: 20 },
+ end: { line: 1, column: 27 }
+ }
+ },
+ range: [20, 28],
+ loc: {
+ start: { line: 1, column: 20 },
+ end: { line: 1, column: 28 }
+ }
+ }],
+ range: [18, 30],
+ loc: {
+ start: { line: 1, column: 18 },
+ end: { line: 1, column: 30 }
+ }
+ },
+ rest: null,
+ generator: false,
+ expression: false,
+ range: [0, 30],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 30 }
+ }
+ },
+
+ 'function hello(a, b) { sayHi(); }': {
+ type: 'FunctionDeclaration',
+ id: {
+ type: 'Identifier',
+ name: 'hello',
+ range: [9, 14],
+ loc: {
+ start: { line: 1, column: 9 },
+ end: { line: 1, column: 14 }
+ }
+ },
+ params: [{
+ type: 'Identifier',
+ name: 'a',
+ range: [15, 16],
+ loc: {
+ start: { line: 1, column: 15 },
+ end: { line: 1, column: 16 }
+ }
+ }, {
+ type: 'Identifier',
+ name: 'b',
+ range: [18, 19],
+ loc: {
+ start: { line: 1, column: 18 },
+ end: { line: 1, column: 19 }
+ }
+ }],
+ defaults: [],
+ body: {
+ type: 'BlockStatement',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'CallExpression',
+ callee: {
+ type: 'Identifier',
+ name: 'sayHi',
+ range: [23, 28],
+ loc: {
+ start: { line: 1, column: 23 },
+ end: { line: 1, column: 28 }
+ }
+ },
+ 'arguments': [],
+ range: [23, 30],
+ loc: {
+ start: { line: 1, column: 23 },
+ end: { line: 1, column: 30 }
+ }
+ },
+ range: [23, 31],
+ loc: {
+ start: { line: 1, column: 23 },
+ end: { line: 1, column: 31 }
+ }
+ }],
+ range: [21, 33],
+ loc: {
+ start: { line: 1, column: 21 },
+ end: { line: 1, column: 33 }
+ }
+ },
+ rest: null,
+ generator: false,
+ expression: false,
+ range: [0, 33],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 33 }
+ }
+ },
+
+ 'var hi = function() { sayHi() };': {
+ type: 'VariableDeclaration',
+ declarations: [{
+ type: 'VariableDeclarator',
+ id: {
+ type: 'Identifier',
+ name: 'hi',
+ range: [4, 6],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 6 }
+ }
+ },
+ init: {
+ type: 'FunctionExpression',
+ id: null,
+ params: [],
+ defaults: [],
+ body: {
+ type: 'BlockStatement',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'CallExpression',
+ callee: {
+ type: 'Identifier',
+ name: 'sayHi',
+ range: [22, 27],
+ loc: {
+ start: { line: 1, column: 22 },
+ end: { line: 1, column: 27 }
+ }
+ },
+ 'arguments': [],
+ range: [22, 29],
+ loc: {
+ start: { line: 1, column: 22 },
+ end: { line: 1, column: 29 }
+ }
+ },
+ range: [22, 30],
+ loc: {
+ start: { line: 1, column: 22 },
+ end: { line: 1, column: 30 }
+ }
+ }],
+ range: [20, 31],
+ loc: {
+ start: { line: 1, column: 20 },
+ end: { line: 1, column: 31 }
+ }
+ },
+ rest: null,
+ generator: false,
+ expression: false,
+ range: [9, 31],
+ loc: {
+ start: { line: 1, column: 9 },
+ end: { line: 1, column: 31 }
+ }
+ },
+ range: [4, 31],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 31 }
+ }
+ }],
+ kind: 'var',
+ range: [0, 32],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 32 }
+ }
+ },
+
+ 'var hi = function eval() { };': {
+ type: 'VariableDeclaration',
+ declarations: [{
+ type: 'VariableDeclarator',
+ id: {
+ type: 'Identifier',
+ name: 'hi',
+ range: [4, 6],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 6 }
+ }
+ },
+ init: {
+ type: 'FunctionExpression',
+ id: {
+ type: 'Identifier',
+ name: 'eval',
+ range: [18, 22],
+ loc: {
+ start: { line: 1, column: 18 },
+ end: { line: 1, column: 22 }
+ }
+ },
+ params: [],
+ defaults: [],
+ body: {
+ type: 'BlockStatement',
+ body: [],
+ range: [25, 28],
+ loc: {
+ start: { line: 1, column: 25 },
+ end: { line: 1, column: 28 }
+ }
+ },
+ rest: null,
+ generator: false,
+ expression: false,
+ range: [9, 28],
+ loc: {
+ start: { line: 1, column: 9 },
+ end: { line: 1, column: 28 }
+ }
+ },
+ range: [4, 28],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 28 }
+ }
+ }],
+ kind: 'var',
+ range: [0, 29],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 29 }
+ }
+ },
+
+ 'var hi = function arguments() { };': {
+ type: 'VariableDeclaration',
+ declarations: [{
+ type: 'VariableDeclarator',
+ id: {
+ type: 'Identifier',
+ name: 'hi',
+ range: [4, 6],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 6 }
+ }
+ },
+ init: {
+ type: 'FunctionExpression',
+ id: {
+ type: 'Identifier',
+ name: 'arguments',
+ range: [18, 27],
+ loc: {
+ start: { line: 1, column: 18 },
+ end: { line: 1, column: 27 }
+ }
+ },
+ params: [],
+ defaults: [],
+ body: {
+ type: 'BlockStatement',
+ body: [],
+ range: [30, 33],
+ loc: {
+ start: { line: 1, column: 30 },
+ end: { line: 1, column: 33 }
+ }
+ },
+ rest: null,
+ generator: false,
+ expression: false,
+ range: [9, 33],
+ loc: {
+ start: { line: 1, column: 9 },
+ end: { line: 1, column: 33 }
+ }
+ },
+ range: [4, 33],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 33 }
+ }
+ }],
+ kind: 'var',
+ range: [0, 34],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 34 }
+ }
+ },
+
+ 'var hello = function hi() { sayHi() };': {
+ type: 'VariableDeclaration',
+ declarations: [{
+ type: 'VariableDeclarator',
+ id: {
+ type: 'Identifier',
+ name: 'hello',
+ range: [4, 9],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 9 }
+ }
+ },
+ init: {
+ type: 'FunctionExpression',
+ id: {
+ type: 'Identifier',
+ name: 'hi',
+ range: [21, 23],
+ loc: {
+ start: { line: 1, column: 21 },
+ end: { line: 1, column: 23 }
+ }
+ },
+ params: [],
+ defaults: [],
+ body: {
+ type: 'BlockStatement',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'CallExpression',
+ callee: {
+ type: 'Identifier',
+ name: 'sayHi',
+ range: [28, 33],
+ loc: {
+ start: { line: 1, column: 28 },
+ end: { line: 1, column: 33 }
+ }
+ },
+ 'arguments': [],
+ range: [28, 35],
+ loc: {
+ start: { line: 1, column: 28 },
+ end: { line: 1, column: 35 }
+ }
+ },
+ range: [28, 36],
+ loc: {
+ start: { line: 1, column: 28 },
+ end: { line: 1, column: 36 }
+ }
+ }],
+ range: [26, 37],
+ loc: {
+ start: { line: 1, column: 26 },
+ end: { line: 1, column: 37 }
+ }
+ },
+ rest: null,
+ generator: false,
+ expression: false,
+ range: [12, 37],
+ loc: {
+ start: { line: 1, column: 12 },
+ end: { line: 1, column: 37 }
+ }
+ },
+ range: [4, 37],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 37 }
+ }
+ }],
+ kind: 'var',
+ range: [0, 38],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 38 }
+ }
+ },
+
+ '(function(){})': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'FunctionExpression',
+ id: null,
+ params: [],
+ defaults: [],
+ body: {
+ type: 'BlockStatement',
+ body: [],
+ range: [11, 13],
+ loc: {
+ start: { line: 1, column: 11 },
+ end: { line: 1, column: 13 }
+ }
+ },
+ rest: null,
+ generator: false,
+ expression: false,
+ range: [1, 13],
+ loc: {
+ start: { line: 1, column: 1 },
+ end: { line: 1, column: 13 }
+ }
+ },
+ range: [0, 14],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 14 }
+ }
+ }
+
+ },
+
+ 'Automatic semicolon insertion': {
+
+ '{ x\n++y }': {
+ type: 'BlockStatement',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Identifier',
+ name: 'x',
+ range: [2, 3],
+ loc: {
+ start: { line: 1, column: 2 },
+ end: { line: 1, column: 3 }
+ }
+ },
+ range: [2, 4],
+ loc: {
+ start: { line: 1, column: 2 },
+ end: { line: 2, column: 0 }
+ }
+ }, {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'UpdateExpression',
+ operator: '++',
+ argument: {
+ type: 'Identifier',
+ name: 'y',
+ range: [6, 7],
+ loc: {
+ start: { line: 2, column: 2 },
+ end: { line: 2, column: 3 }
+ }
+ },
+ prefix: true,
+ range: [4, 7],
+ loc: {
+ start: { line: 2, column: 0 },
+ end: { line: 2, column: 3 }
+ }
+ },
+ range: [4, 8],
+ loc: {
+ start: { line: 2, column: 0 },
+ end: { line: 2, column: 4 }
+ }
+ }],
+ range: [0, 9],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 2, column: 5 }
+ }
+ },
+
+ '{ x\n--y }': {
+ type: 'BlockStatement',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Identifier',
+ name: 'x',
+ range: [2, 3],
+ loc: {
+ start: { line: 1, column: 2 },
+ end: { line: 1, column: 3 }
+ }
+ },
+ range: [2, 4],
+ loc: {
+ start: { line: 1, column: 2 },
+ end: { line: 2, column: 0 }
+ }
+ }, {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'UpdateExpression',
+ operator: '--',
+ argument: {
+ type: 'Identifier',
+ name: 'y',
+ range: [6, 7],
+ loc: {
+ start: { line: 2, column: 2 },
+ end: { line: 2, column: 3 }
+ }
+ },
+ prefix: true,
+ range: [4, 7],
+ loc: {
+ start: { line: 2, column: 0 },
+ end: { line: 2, column: 3 }
+ }
+ },
+ range: [4, 8],
+ loc: {
+ start: { line: 2, column: 0 },
+ end: { line: 2, column: 4 }
+ }
+ }],
+ range: [0, 9],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 2, column: 5 }
+ }
+ },
+
+ 'var x /* comment */;': {
+ type: 'VariableDeclaration',
+ declarations: [{
+ type: 'VariableDeclarator',
+ id: {
+ type: 'Identifier',
+ name: 'x',
+ range: [4, 5],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ init: null,
+ range: [4, 5],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ }],
+ kind: 'var',
+ range: [0, 20],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 20 }
+ }
+ },
+
+ '{ var x = 14, y = 3\nz; }': {
+ type: 'BlockStatement',
+ body: [{
+ type: 'VariableDeclaration',
+ declarations: [{
+ type: 'VariableDeclarator',
+ id: {
+ type: 'Identifier',
+ name: 'x',
+ range: [6, 7],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 7 }
+ }
+ },
+ init: {
+ type: 'Literal',
+ value: 14,
+ raw: '14',
+ range: [10, 12],
+ loc: {
+ start: { line: 1, column: 10 },
+ end: { line: 1, column: 12 }
+ }
+ },
+ range: [6, 12],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 12 }
+ }
+ }, {
+ type: 'VariableDeclarator',
+ id: {
+ type: 'Identifier',
+ name: 'y',
+ range: [14, 15],
+ loc: {
+ start: { line: 1, column: 14 },
+ end: { line: 1, column: 15 }
+ }
+ },
+ init: {
+ type: 'Literal',
+ value: 3,
+ raw: '3',
+ range: [18, 19],
+ loc: {
+ start: { line: 1, column: 18 },
+ end: { line: 1, column: 19 }
+ }
+ },
+ range: [14, 19],
+ loc: {
+ start: { line: 1, column: 14 },
+ end: { line: 1, column: 19 }
+ }
+ }],
+ kind: 'var',
+ range: [2, 20],
+ loc: {
+ start: { line: 1, column: 2 },
+ end: { line: 2, column: 0 }
+ }
+ }, {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Identifier',
+ name: 'z',
+ range: [20, 21],
+ loc: {
+ start: { line: 2, column: 0 },
+ end: { line: 2, column: 1 }
+ }
+ },
+ range: [20, 22],
+ loc: {
+ start: { line: 2, column: 0 },
+ end: { line: 2, column: 2 }
+ }
+ }],
+ range: [0, 24],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 2, column: 4 }
+ }
+ },
+
+ 'while (true) { continue\nthere; }': {
+ type: 'WhileStatement',
+ test: {
+ type: 'Literal',
+ value: true,
+ raw: 'true',
+ range: [7, 11],
+ loc: {
+ start: { line: 1, column: 7 },
+ end: { line: 1, column: 11 }
+ }
+ },
+ body: {
+ type: 'BlockStatement',
+ body: [{
+ type: 'ContinueStatement',
+ label: null,
+ range: [15, 23],
+ loc: {
+ start: { line: 1, column: 15 },
+ end: { line: 1, column: 23 }
+ }
+ }, {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Identifier',
+ name: 'there',
+ range: [24, 29],
+ loc: {
+ start: { line: 2, column: 0 },
+ end: { line: 2, column: 5 }
+ }
+ },
+ range: [24, 30],
+ loc: {
+ start: { line: 2, column: 0 },
+ end: { line: 2, column: 6 }
+ }
+ }],
+ range: [13, 32],
+ loc: {
+ start: { line: 1, column: 13 },
+ end: { line: 2, column: 8 }
+ }
+ },
+ range: [0, 32],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 2, column: 8 }
+ }
+ },
+
+ 'while (true) { continue // Comment\nthere; }': {
+ type: 'WhileStatement',
+ test: {
+ type: 'Literal',
+ value: true,
+ raw: 'true',
+ range: [7, 11],
+ loc: {
+ start: { line: 1, column: 7 },
+ end: { line: 1, column: 11 }
+ }
+ },
+ body: {
+ type: 'BlockStatement',
+ body: [{
+ type: 'ContinueStatement',
+ label: null,
+ range: [15, 23],
+ loc: {
+ start: { line: 1, column: 15 },
+ end: { line: 1, column: 23 }
+ }
+ }, {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Identifier',
+ name: 'there',
+ range: [35, 40],
+ loc: {
+ start: { line: 2, column: 0 },
+ end: { line: 2, column: 5 }
+ }
+ },
+ range: [35, 41],
+ loc: {
+ start: { line: 2, column: 0 },
+ end: { line: 2, column: 6 }
+ }
+ }],
+ range: [13, 43],
+ loc: {
+ start: { line: 1, column: 13 },
+ end: { line: 2, column: 8 }
+ }
+ },
+ range: [0, 43],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 2, column: 8 }
+ }
+ },
+
+ 'while (true) { continue /* Multiline\nComment */there; }': {
+ type: 'WhileStatement',
+ test: {
+ type: 'Literal',
+ value: true,
+ raw: 'true',
+ range: [7, 11],
+ loc: {
+ start: { line: 1, column: 7 },
+ end: { line: 1, column: 11 }
+ }
+ },
+ body: {
+ type: 'BlockStatement',
+ body: [{
+ type: 'ContinueStatement',
+ label: null,
+ range: [15, 23],
+ loc: {
+ start: { line: 1, column: 15 },
+ end: { line: 1, column: 23 }
+ }
+ }, {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Identifier',
+ name: 'there',
+ range: [47, 52],
+ loc: {
+ start: { line: 2, column: 10 },
+ end: { line: 2, column: 15 }
+ }
+ },
+ range: [47, 53],
+ loc: {
+ start: { line: 2, column: 10 },
+ end: { line: 2, column: 16 }
+ }
+ }],
+ range: [13, 55],
+ loc: {
+ start: { line: 1, column: 13 },
+ end: { line: 2, column: 18 }
+ }
+ },
+ range: [0, 55],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 2, column: 18 }
+ }
+ },
+
+ 'while (true) { break\nthere; }': {
+ type: 'WhileStatement',
+ test: {
+ type: 'Literal',
+ value: true,
+ raw: 'true',
+ range: [7, 11],
+ loc: {
+ start: { line: 1, column: 7 },
+ end: { line: 1, column: 11 }
+ }
+ },
+ body: {
+ type: 'BlockStatement',
+ body: [{
+ type: 'BreakStatement',
+ label: null,
+ range: [15, 20],
+ loc: {
+ start: { line: 1, column: 15 },
+ end: { line: 1, column: 20 }
+ }
+ }, {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Identifier',
+ name: 'there',
+ range: [21, 26],
+ loc: {
+ start: { line: 2, column: 0 },
+ end: { line: 2, column: 5 }
+ }
+ },
+ range: [21, 27],
+ loc: {
+ start: { line: 2, column: 0 },
+ end: { line: 2, column: 6 }
+ }
+ }],
+ range: [13, 29],
+ loc: {
+ start: { line: 1, column: 13 },
+ end: { line: 2, column: 8 }
+ }
+ },
+ range: [0, 29],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 2, column: 8 }
+ }
+ },
+
+ 'while (true) { break // Comment\nthere; }': {
+ type: 'WhileStatement',
+ test: {
+ type: 'Literal',
+ value: true,
+ raw: 'true',
+ range: [7, 11],
+ loc: {
+ start: { line: 1, column: 7 },
+ end: { line: 1, column: 11 }
+ }
+ },
+ body: {
+ type: 'BlockStatement',
+ body: [{
+ type: 'BreakStatement',
+ label: null,
+ range: [15, 20],
+ loc: {
+ start: { line: 1, column: 15 },
+ end: { line: 1, column: 20 }
+ }
+ }, {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Identifier',
+ name: 'there',
+ range: [32, 37],
+ loc: {
+ start: { line: 2, column: 0 },
+ end: { line: 2, column: 5 }
+ }
+ },
+ range: [32, 38],
+ loc: {
+ start: { line: 2, column: 0 },
+ end: { line: 2, column: 6 }
+ }
+ }],
+ range: [13, 40],
+ loc: {
+ start: { line: 1, column: 13 },
+ end: { line: 2, column: 8 }
+ }
+ },
+ range: [0, 40],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 2, column: 8 }
+ }
+ },
+
+ 'while (true) { break /* Multiline\nComment */there; }': {
+ type: 'WhileStatement',
+ test: {
+ type: 'Literal',
+ value: true,
+ raw: 'true',
+ range: [7, 11],
+ loc: {
+ start: { line: 1, column: 7 },
+ end: { line: 1, column: 11 }
+ }
+ },
+ body: {
+ type: 'BlockStatement',
+ body: [{
+ type: 'BreakStatement',
+ label: null,
+ range: [15, 20],
+ loc: {
+ start: { line: 1, column: 15 },
+ end: { line: 1, column: 20 }
+ }
+ }, {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Identifier',
+ name: 'there',
+ range: [44, 49],
+ loc: {
+ start: { line: 2, column: 10 },
+ end: { line: 2, column: 15 }
+ }
+ },
+ range: [44, 50],
+ loc: {
+ start: { line: 2, column: 10 },
+ end: { line: 2, column: 16 }
+ }
+ }],
+ range: [13, 52],
+ loc: {
+ start: { line: 1, column: 13 },
+ end: { line: 2, column: 18 }
+ }
+ },
+ range: [0, 52],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 2, column: 18 }
+ }
+ },
+
+ '(function(){ return\nx; })': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'FunctionExpression',
+ id: null,
+ params: [],
+ defaults: [],
+ body: {
+ type: 'BlockStatement',
+ body: [
+ {
+ type: 'ReturnStatement',
+ argument: null,
+ range: [13, 19],
+ loc: {
+ start: { line: 1, column: 13 },
+ end: { line: 1, column: 19 }
+ }
+ },
+ {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Identifier',
+ name: 'x',
+ range: [20, 21],
+ loc: {
+ start: { line: 2, column: 0 },
+ end: { line: 2, column: 1 }
+ }
+ },
+ range: [20, 22],
+ loc: {
+ start: { line: 2, column: 0 },
+ end: { line: 2, column: 2 }
+ }
+ }
+ ],
+ range: [11, 24],
+ loc: {
+ start: { line: 1, column: 11 },
+ end: { line: 2, column: 4 }
+ }
+ },
+ rest: null,
+ generator: false,
+ expression: false,
+ range: [1, 24],
+ loc: {
+ start: { line: 1, column: 1 },
+ end: { line: 2, column: 4 }
+ }
+ },
+ range: [0, 25],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 2, column: 5 }
+ }
+ },
+
+ '(function(){ return // Comment\nx; })': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'FunctionExpression',
+ id: null,
+ params: [],
+ defaults: [],
+ body: {
+ type: 'BlockStatement',
+ body: [
+ {
+ type: 'ReturnStatement',
+ argument: null,
+ range: [13, 19],
+ loc: {
+ start: { line: 1, column: 13 },
+ end: { line: 1, column: 19 }
+ }
+ },
+ {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Identifier',
+ name: 'x',
+ range: [31, 32],
+ loc: {
+ start: { line: 2, column: 0 },
+ end: { line: 2, column: 1 }
+ }
+ },
+ range: [31, 33],
+ loc: {
+ start: { line: 2, column: 0 },
+ end: { line: 2, column: 2 }
+ }
+ }
+ ],
+ range: [11, 35],
+ loc: {
+ start: { line: 1, column: 11 },
+ end: { line: 2, column: 4 }
+ }
+ },
+ rest: null,
+ generator: false,
+ expression: false,
+ range: [1, 35],
+ loc: {
+ start: { line: 1, column: 1 },
+ end: { line: 2, column: 4 }
+ }
+ },
+ range: [0, 36],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 2, column: 5 }
+ }
+ },
+
+ '(function(){ return/* Multiline\nComment */x; })': {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'FunctionExpression',
+ id: null,
+ params: [],
+ defaults: [],
+ body: {
+ type: 'BlockStatement',
+ body: [
+ {
+ type: 'ReturnStatement',
+ argument: null,
+ range: [13, 19],
+ loc: {
+ start: { line: 1, column: 13 },
+ end: { line: 1, column: 19 }
+ }
+ },
+ {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Identifier',
+ name: 'x',
+ range: [42, 43],
+ loc: {
+ start: { line: 2, column: 10 },
+ end: { line: 2, column: 11 }
+ }
+ },
+ range: [42, 44],
+ loc: {
+ start: { line: 2, column: 10 },
+ end: { line: 2, column: 12 }
+ }
+ }
+ ],
+ range: [11, 46],
+ loc: {
+ start: { line: 1, column: 11 },
+ end: { line: 2, column: 14 }
+ }
+ },
+ rest: null,
+ generator: false,
+ expression: false,
+ range: [1, 46],
+ loc: {
+ start: { line: 1, column: 1 },
+ end: { line: 2, column: 14 }
+ }
+ },
+ range: [0, 47],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 2, column: 15 }
+ }
+ },
+
+ '{ throw error\nerror; }': {
+ type: 'BlockStatement',
+ body: [{
+ type: 'ThrowStatement',
+ argument: {
+ type: 'Identifier',
+ name: 'error',
+ range: [8, 13],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 13 }
+ }
+ },
+ range: [2, 14],
+ loc: {
+ start: { line: 1, column: 2 },
+ end: { line: 2, column: 0 }
+ }
+ }, {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Identifier',
+ name: 'error',
+ range: [14, 19],
+ loc: {
+ start: { line: 2, column: 0 },
+ end: { line: 2, column: 5 }
+ }
+ },
+ range: [14, 20],
+ loc: {
+ start: { line: 2, column: 0 },
+ end: { line: 2, column: 6 }
+ }
+ }],
+ range: [0, 22],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 2, column: 8 }
+ }
+ },
+
+ '{ throw error// Comment\nerror; }': {
+ type: 'BlockStatement',
+ body: [{
+ type: 'ThrowStatement',
+ argument: {
+ type: 'Identifier',
+ name: 'error',
+ range: [8, 13],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 13 }
+ }
+ },
+ range: [2, 24],
+ loc: {
+ start: { line: 1, column: 2 },
+ end: { line: 2, column: 0 }
+ }
+ }, {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Identifier',
+ name: 'error',
+ range: [24, 29],
+ loc: {
+ start: { line: 2, column: 0 },
+ end: { line: 2, column: 5 }
+ }
+ },
+ range: [24, 30],
+ loc: {
+ start: { line: 2, column: 0 },
+ end: { line: 2, column: 6 }
+ }
+ }],
+ range: [0, 32],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 2, column: 8 }
+ }
+ },
+
+ '{ throw error/* Multiline\nComment */error; }': {
+ type: 'BlockStatement',
+ body: [{
+ type: 'ThrowStatement',
+ argument: {
+ type: 'Identifier',
+ name: 'error',
+ range: [8, 13],
+ loc: {
+ start: { line: 1, column: 8 },
+ end: { line: 1, column: 13 }
+ }
+ },
+ range: [2, 36],
+ loc: {
+ start: { line: 1, column: 2 },
+ end: { line: 2, column: 10 }
+ }
+ }, {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Identifier',
+ name: 'error',
+ range: [36, 41],
+ loc: {
+ start: { line: 2, column: 10 },
+ end: { line: 2, column: 15 }
+ }
+ },
+ range: [36, 42],
+ loc: {
+ start: { line: 2, column: 10 },
+ end: { line: 2, column: 16 }
+ }
+ }],
+ range: [0, 44],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 2, column: 18 }
+ }
+ }
+
+ },
+
+ 'Source elements': {
+
+ '': {
+ type: 'Program',
+ body: [],
+ range: [0, 0],
+ loc: {
+ start: { line: 0, column: 0 },
+ end: { line: 0, column: 0 }
+ },
+ tokens: []
+ }
+ },
+
+ 'Invalid syntax': {
+
+ '{': {
+ index: 1,
+ lineNumber: 1,
+ column: 2,
+ message: 'Error: Line 1: Unexpected end of input'
+ },
+
+ '}': {
+ index: 0,
+ lineNumber: 1,
+ column: 1,
+ message: 'Error: Line 1: Unexpected token }'
+ },
+
+ '3ea': {
+ index: 2,
+ lineNumber: 1,
+ column: 3,
+ message: 'Error: Line 1: Unexpected token ILLEGAL'
+ },
+
+ '3in []': {
+ index: 1,
+ lineNumber: 1,
+ column: 2,
+ message: 'Error: Line 1: Unexpected token ILLEGAL'
+ },
+
+ '3e': {
+ index: 2,
+ lineNumber: 1,
+ column: 3,
+ message: 'Error: Line 1: Unexpected token ILLEGAL'
+ },
+
+ '3e+': {
+ index: 3,
+ lineNumber: 1,
+ column: 4,
+ message: 'Error: Line 1: Unexpected token ILLEGAL'
+ },
+
+ '3e-': {
+ index: 3,
+ lineNumber: 1,
+ column: 4,
+ message: 'Error: Line 1: Unexpected token ILLEGAL'
+ },
+
+ '3x': {
+ index: 1,
+ lineNumber: 1,
+ column: 2,
+ message: 'Error: Line 1: Unexpected token ILLEGAL'
+ },
+
+ '3x0': {
+ index: 1,
+ lineNumber: 1,
+ column: 2,
+ message: 'Error: Line 1: Unexpected token ILLEGAL'
+ },
+
+ '0x': {
+ index: 2,
+ lineNumber: 1,
+ column: 3,
+ message: 'Error: Line 1: Unexpected token ILLEGAL'
+ },
+
+ '09': {
+ index: 1,
+ lineNumber: 1,
+ column: 2,
+ message: 'Error: Line 1: Unexpected token ILLEGAL'
+ },
+
+ '018': {
+ index: 2,
+ lineNumber: 1,
+ column: 3,
+ message: 'Error: Line 1: Unexpected token ILLEGAL'
+ },
+
+ '01a': {
+ index: 2,
+ lineNumber: 1,
+ column: 3,
+ message: 'Error: Line 1: Unexpected token ILLEGAL'
+ },
+
+ '3in[]': {
+ index: 1,
+ lineNumber: 1,
+ column: 2,
+ message: 'Error: Line 1: Unexpected token ILLEGAL'
+ },
+
+ '0x3in[]': {
+ index: 3,
+ lineNumber: 1,
+ column: 4,
+ message: 'Error: Line 1: Unexpected token ILLEGAL'
+ },
+
+ '"Hello\nWorld"': {
+ index: 7,
+ lineNumber: 1,
+ column: 8,
+ message: 'Error: Line 1: Unexpected token ILLEGAL'
+ },
+
+ 'x\\': {
+ index: 2,
+ lineNumber: 1,
+ column: 3,
+ message: 'Error: Line 1: Unexpected token ILLEGAL'
+ },
+
+ 'x\\u005c': {
+ index: 7,
+ lineNumber: 1,
+ column: 8,
+ message: 'Error: Line 1: Unexpected token ILLEGAL'
+ },
+
+ 'x\\u002a': {
+ index: 7,
+ lineNumber: 1,
+ column: 8,
+ message: 'Error: Line 1: Unexpected token ILLEGAL'
+ },
+
+ 'var x = /(s/g': {
+ index: 13,
+ lineNumber: 1,
+ column: 14,
+ message: 'Error: Line 1: Invalid regular expression'
+ },
+
+ '/': {
+ index: 1,
+ lineNumber: 1,
+ column: 2,
+ message: 'Error: Line 1: Invalid regular expression: missing /'
+ },
+
+ '/test': {
+ index: 5,
+ lineNumber: 1,
+ column: 6,
+ message: 'Error: Line 1: Invalid regular expression: missing /'
+ },
+
+ 'var x = /[a-z]/\\ux': {
+ index: 18,
+ lineNumber: 1,
+ column: 19,
+ message: 'Error: Line 1: Invalid regular expression'
+ },
+
+ '3 = 4': {
+ index: 1,
+ lineNumber: 1,
+ column: 2,
+ message: 'Error: Line 1: Invalid left-hand side in assignment'
+ },
+
+ 'func() = 4': {
+ index: 6,
+ lineNumber: 1,
+ column: 7,
+ message: 'Error: Line 1: Invalid left-hand side in assignment'
+ },
+
+ '(1 + 1) = 10': {
+ index: 7,
+ lineNumber: 1,
+ column: 8,
+ message: 'Error: Line 1: Invalid left-hand side in assignment'
+ },
+
+ '1++': {
+ index: 1,
+ lineNumber: 1,
+ column: 2,
+ message: 'Error: Line 1: Invalid left-hand side in assignment'
+ },
+
+ '1--': {
+ index: 1,
+ lineNumber: 1,
+ column: 2,
+ message: 'Error: Line 1: Invalid left-hand side in assignment'
+ },
+
+ '++1': {
+ index: 3,
+ lineNumber: 1,
+ column: 4,
+ message: 'Error: Line 1: Invalid left-hand side in assignment'
+ },
+
+ '--1': {
+ index: 3,
+ lineNumber: 1,
+ column: 4,
+ message: 'Error: Line 1: Invalid left-hand side in assignment'
+ },
+
+ 'for((1 + 1) in list) process(x);': {
+ index: 11,
+ lineNumber: 1,
+ column: 12,
+ message: 'Error: Line 1: Invalid left-hand side in for-in'
+ },
+
+ '[': {
+ index: 1,
+ lineNumber: 1,
+ column: 2,
+ message: 'Error: Line 1: Unexpected end of input'
+ },
+
+ '[,': {
+ index: 2,
+ lineNumber: 1,
+ column: 3,
+ message: 'Error: Line 1: Unexpected end of input'
+ },
+
+ '1 + {': {
+ index: 5,
+ lineNumber: 1,
+ column: 6,
+ message: 'Error: Line 1: Unexpected end of input'
+ },
+
+ '1 + { t:t ': {
+ index: 10,
+ lineNumber: 1,
+ column: 11,
+ message: 'Error: Line 1: Unexpected end of input'
+ },
+
+ '1 + { t:t,': {
+ index: 10,
+ lineNumber: 1,
+ column: 11,
+ message: 'Error: Line 1: Unexpected end of input'
+ },
+
+ 'var x = /\n/': {
+ index: 10,
+ lineNumber: 1,
+ column: 11,
+ message: 'Error: Line 1: Invalid regular expression: missing /'
+ },
+
+ 'var x = "\n': {
+ index: 10,
+ lineNumber: 1,
+ column: 11,
+ message: 'Error: Line 1: Unexpected token ILLEGAL'
+ },
+
+ 'var if = 42': {
+ index: 4,
+ lineNumber: 1,
+ column: 5,
+ message: 'Error: Line 1: Unexpected token if'
+ },
+
+ 'i + 2 = 42': {
+ index: 5,
+ lineNumber: 1,
+ column: 6,
+ message: 'Error: Line 1: Invalid left-hand side in assignment'
+ },
+
+ '+i = 42': {
+ index: 2,
+ lineNumber: 1,
+ column: 3,
+ message: 'Error: Line 1: Invalid left-hand side in assignment'
+ },
+
+ '1 + (': {
+ index: 5,
+ lineNumber: 1,
+ column: 6,
+ message: 'Error: Line 1: Unexpected end of input'
+ },
+
+ '\n\n\n{': {
+ index: 4,
+ lineNumber: 4,
+ column: 2,
+ message: 'Error: Line 4: Unexpected end of input'
+ },
+
+ '\n/* Some multiline\ncomment */\n)': {
+ index: 30,
+ lineNumber: 4,
+ column: 1,
+ message: 'Error: Line 4: Unexpected token )'
+ },
+
+ '{ set 1 }': {
+ index: 6,
+ lineNumber: 1,
+ column: 7,
+ message: 'Error: Line 1: Unexpected number'
+ },
+
+ '{ get 2 }': {
+ index: 6,
+ lineNumber: 1,
+ column: 7,
+ message: 'Error: Line 1: Unexpected number'
+ },
+
+ '({ set: s(if) { } })': {
+ index: 10,
+ lineNumber: 1,
+ column: 11,
+ message: 'Error: Line 1: Unexpected token if'
+ },
+
+ '({ set s(.) { } })': {
+ index: 9,
+ lineNumber: 1,
+ column: 10,
+ message: 'Error: Line 1: Unexpected token .'
+ },
+
+ '({ set s() { } })': {
+ index: 9,
+ lineNumber: 1,
+ column: 10,
+ message: 'Error: Line 1: Unexpected token )'
+ },
+
+ '({ set: s() { } })': {
+ index: 12,
+ lineNumber: 1,
+ column: 13,
+ message: 'Error: Line 1: Unexpected token {'
+ },
+
+ '({ set: s(a, b) { } })': {
+ index: 16,
+ lineNumber: 1,
+ column: 17,
+ message: 'Error: Line 1: Unexpected token {'
+ },
+
+ '({ get: g(d) { } })': {
+ index: 13,
+ lineNumber: 1,
+ column: 14,
+ message: 'Error: Line 1: Unexpected token {'
+ },
+
+ '({ get i() { }, i: 42 })': {
+ index: 21,
+ lineNumber: 1,
+ column: 22,
+ message: 'Error: Line 1: Object literal may not have data and accessor property with the same name'
+ },
+
+ '({ i: 42, get i() { } })': {
+ index: 21,
+ lineNumber: 1,
+ column: 22,
+ message: 'Error: Line 1: Object literal may not have data and accessor property with the same name'
+ },
+
+ '({ set i(x) { }, i: 42 })': {
+ index: 22,
+ lineNumber: 1,
+ column: 23,
+ message: 'Error: Line 1: Object literal may not have data and accessor property with the same name'
+ },
+
+ '({ i: 42, set i(x) { } })': {
+ index: 22,
+ lineNumber: 1,
+ column: 23,
+ message: 'Error: Line 1: Object literal may not have data and accessor property with the same name'
+ },
+
+ '({ get i() { }, get i() { } })': {
+ index: 27,
+ lineNumber: 1,
+ column: 28,
+ message: 'Error: Line 1: Object literal may not have multiple get/set accessors with the same name'
+ },
+
+ '({ set i(x) { }, set i(x) { } })': {
+ index: 29,
+ lineNumber: 1,
+ column: 30,
+ message: 'Error: Line 1: Object literal may not have multiple get/set accessors with the same name'
+ },
+
+ 'function t(if) { }': {
+ index: 11,
+ lineNumber: 1,
+ column: 12,
+ message: 'Error: Line 1: Unexpected token if'
+ },
+
+ 'function t(true) { }': {
+ index: 11,
+ lineNumber: 1,
+ column: 12,
+ message: 'Error: Line 1: Unexpected token true'
+ },
+
+ 'function t(false) { }': {
+ index: 11,
+ lineNumber: 1,
+ column: 12,
+ message: 'Error: Line 1: Unexpected token false'
+ },
+
+ 'function t(null) { }': {
+ index: 11,
+ lineNumber: 1,
+ column: 12,
+ message: 'Error: Line 1: Unexpected token null'
+ },
+
+ 'function null() { }': {
+ index: 9,
+ lineNumber: 1,
+ column: 10,
+ message: 'Error: Line 1: Unexpected token null'
+ },
+
+ 'function true() { }': {
+ index: 9,
+ lineNumber: 1,
+ column: 10,
+ message: 'Error: Line 1: Unexpected token true'
+ },
+
+ 'function false() { }': {
+ index: 9,
+ lineNumber: 1,
+ column: 10,
+ message: 'Error: Line 1: Unexpected token false'
+ },
+
+ 'function if() { }': {
+ index: 9,
+ lineNumber: 1,
+ column: 10,
+ message: 'Error: Line 1: Unexpected token if'
+ },
+
+ 'a b;': {
+ index: 2,
+ lineNumber: 1,
+ column: 3,
+ message: 'Error: Line 1: Unexpected identifier'
+ },
+
+ 'if.a;': {
+ index: 2,
+ lineNumber: 1,
+ column: 3,
+ message: 'Error: Line 1: Unexpected token .'
+ },
+
+ 'a if;': {
+ index: 2,
+ lineNumber: 1,
+ column: 3,
+ message: 'Error: Line 1: Unexpected token if'
+ },
+
+ 'a class;': {
+ index: 2,
+ lineNumber: 1,
+ column: 3,
+ message: 'Error: Line 1: Unexpected reserved word'
+ },
+
+ 'break\n': {
+ index: 5,
+ lineNumber: 1,
+ column: 6,
+ message: 'Error: Line 1: Illegal break statement'
+ },
+
+ 'break 1;': {
+ index: 6,
+ lineNumber: 1,
+ column: 7,
+ message: 'Error: Line 1: Unexpected number'
+ },
+
+ 'continue\n': {
+ index: 8,
+ lineNumber: 1,
+ column: 9,
+ message: 'Error: Line 1: Illegal continue statement'
+ },
+
+ 'continue 2;': {
+ index: 9,
+ lineNumber: 1,
+ column: 10,
+ message: 'Error: Line 1: Unexpected number'
+ },
+
+ 'throw': {
+ index: 5,
+ lineNumber: 1,
+ column: 6,
+ message: 'Error: Line 1: Unexpected end of input'
+ },
+
+ 'throw;': {
+ index: 5,
+ lineNumber: 1,
+ column: 6,
+ message: 'Error: Line 1: Unexpected token ;'
+ },
+
+ 'throw\n': {
+ index: 5,
+ lineNumber: 1,
+ column: 6,
+ message: 'Error: Line 1: Illegal newline after throw'
+ },
+
+ 'for (var i, i2 in {});': {
+ index: 15,
+ lineNumber: 1,
+ column: 16,
+ message: 'Error: Line 1: Unexpected token in'
+ },
+
+ 'for ((i in {}));': {
+ index: 14,
+ lineNumber: 1,
+ column: 15,
+ message: 'Error: Line 1: Unexpected token )'
+ },
+
+ 'for (i + 1 in {});': {
+ index: 10,
+ lineNumber: 1,
+ column: 11,
+ message: 'Error: Line 1: Invalid left-hand side in for-in'
+ },
+
+ 'for (+i in {});': {
+ index: 7,
+ lineNumber: 1,
+ column: 8,
+ message: 'Error: Line 1: Invalid left-hand side in for-in'
+ },
+
+ 'if(false)': {
+ index: 9,
+ lineNumber: 1,
+ column: 10,
+ message: 'Error: Line 1: Unexpected end of input'
+ },
+
+ 'if(false) doThis(); else': {
+ index: 24,
+ lineNumber: 1,
+ column: 25,
+ message: 'Error: Line 1: Unexpected end of input'
+ },
+
+ 'do': {
+ index: 2,
+ lineNumber: 1,
+ column: 3,
+ message: 'Error: Line 1: Unexpected end of input'
+ },
+
+ 'while(false)': {
+ index: 12,
+ lineNumber: 1,
+ column: 13,
+ message: 'Error: Line 1: Unexpected end of input'
+ },
+
+ 'for(;;)': {
+ index: 7,
+ lineNumber: 1,
+ column: 8,
+ message: 'Error: Line 1: Unexpected end of input'
+ },
+
+ 'with(x)': {
+ index: 7,
+ lineNumber: 1,
+ column: 8,
+ message: 'Error: Line 1: Unexpected end of input'
+ },
+
+ 'try { }': {
+ index: 7,
+ lineNumber: 1,
+ column: 8,
+ message: 'Error: Line 1: Missing catch or finally after try'
+ },
+
+ 'try {} catch (42) {} ': {
+ index: 14,
+ lineNumber: 1,
+ column: 15,
+ message: 'Error: Line 1: Unexpected number'
+ },
+
+ 'try {} catch (answer()) {} ': {
+ index: 20,
+ lineNumber: 1,
+ column: 21,
+ message: 'Error: Line 1: Unexpected token ('
+ },
+
+ 'try {} catch (-x) {} ': {
+ index: 14,
+ lineNumber: 1,
+ column: 15,
+ message: 'Error: Line 1: Unexpected token -'
+ },
+
+
+ '\u203F = 10': {
+ index: 0,
+ lineNumber: 1,
+ column: 1,
+ message: 'Error: Line 1: Unexpected token ILLEGAL'
+ },
+
+ 'const x = 12, y;': {
+ index: 15,
+ lineNumber: 1,
+ column: 16,
+ message: 'Error: Line 1: Unexpected token ;'
+ },
+
+ 'const x, y = 12;': {
+ index: 7,
+ lineNumber: 1,
+ column: 8,
+ message: 'Error: Line 1: Unexpected token ,'
+ },
+
+ 'const x;': {
+ index: 7,
+ lineNumber: 1,
+ column: 8,
+ message: 'Error: Line 1: Unexpected token ;'
+ },
+
+ 'if(true) let a = 1;': {
+ index: 9,
+ lineNumber: 1,
+ column: 10,
+ message: 'Error: Line 1: Unexpected token let'
+ },
+
+ 'if(true) const a = 1;': {
+ index: 9,
+ lineNumber: 1,
+ column: 10,
+ message: 'Error: Line 1: Unexpected token const'
+ },
+
+ 'switch (c) { default: default: }': {
+ index: 30,
+ lineNumber: 1,
+ column: 31,
+ message: 'Error: Line 1: More than one default clause in switch statement'
+ },
+
+ 'new X()."s"': {
+ index: 8,
+ lineNumber: 1,
+ column: 9,
+ message: 'Error: Line 1: Unexpected string'
+ },
+
+ '/*': {
+ index: 2,
+ lineNumber: 1,
+ column: 3,
+ message: 'Error: Line 1: Unexpected token ILLEGAL'
+ },
+
+ '/*\n\n\n': {
+ index: 5,
+ lineNumber: 4,
+ column: 1,
+ message: 'Error: Line 4: Unexpected token ILLEGAL'
+ },
+
+ '/**': {
+ index: 3,
+ lineNumber: 1,
+ column: 4,
+ message: 'Error: Line 1: Unexpected token ILLEGAL'
+ },
+
+ '/*\n\n*': {
+ index: 5,
+ lineNumber: 3,
+ column: 2,
+ message: 'Error: Line 3: Unexpected token ILLEGAL'
+ },
+
+ '/*hello': {
+ index: 7,
+ lineNumber: 1,
+ column: 8,
+ message: 'Error: Line 1: Unexpected token ILLEGAL'
+ },
+
+ '/*hello *': {
+ index: 10,
+ lineNumber: 1,
+ column: 11,
+ message: 'Error: Line 1: Unexpected token ILLEGAL'
+ },
+
+ '\n]': {
+ index: 1,
+ lineNumber: 2,
+ column: 1,
+ message: 'Error: Line 2: Unexpected token ]'
+ },
+
+ '\r]': {
+ index: 1,
+ lineNumber: 2,
+ column: 1,
+ message: 'Error: Line 2: Unexpected token ]'
+ },
+
+ '\r\n]': {
+ index: 2,
+ lineNumber: 2,
+ column: 1,
+ message: 'Error: Line 2: Unexpected token ]'
+ },
+
+ '\n\r]': {
+ index: 2,
+ lineNumber: 3,
+ column: 1,
+ message: 'Error: Line 3: Unexpected token ]'
+ },
+
+ '//\r\n]': {
+ index: 4,
+ lineNumber: 2,
+ column: 1,
+ message: 'Error: Line 2: Unexpected token ]'
+ },
+
+ '//\n\r]': {
+ index: 4,
+ lineNumber: 3,
+ column: 1,
+ message: 'Error: Line 3: Unexpected token ]'
+ },
+
+ '/a\\\n/': {
+ index: 4,
+ lineNumber: 1,
+ column: 5,
+ message: 'Error: Line 1: Invalid regular expression: missing /'
+ },
+
+ '//\r \n]': {
+ index: 5,
+ lineNumber: 3,
+ column: 1,
+ message: 'Error: Line 3: Unexpected token ]'
+ },
+
+ '/*\r\n*/]': {
+ index: 6,
+ lineNumber: 2,
+ column: 3,
+ message: 'Error: Line 2: Unexpected token ]'
+ },
+
+ '/*\n\r*/]': {
+ index: 6,
+ lineNumber: 3,
+ column: 3,
+ message: 'Error: Line 3: Unexpected token ]'
+ },
+
+ '/*\r \n*/]': {
+ index: 7,
+ lineNumber: 3,
+ column: 3,
+ message: 'Error: Line 3: Unexpected token ]'
+ },
+
+ '\\\\': {
+ index: 1,
+ lineNumber: 1,
+ column: 2,
+ message: 'Error: Line 1: Unexpected token ILLEGAL'
+ },
+
+ '\\u005c': {
+ index: 6,
+ lineNumber: 1,
+ column: 7,
+ message: 'Error: Line 1: Unexpected token ILLEGAL'
+ },
+
+
+ '\\x': {
+ index: 1,
+ lineNumber: 1,
+ column: 2,
+ message: 'Error: Line 1: Unexpected token ILLEGAL'
+ },
+
+ '\\u0000': {
+ index: 6,
+ lineNumber: 1,
+ column: 7,
+ message: 'Error: Line 1: Unexpected token ILLEGAL'
+ },
+
+ '\u200C = []': {
+ index: 0,
+ lineNumber: 1,
+ column: 1,
+ message: 'Error: Line 1: Unexpected token ILLEGAL'
+ },
+
+ '\u200D = []': {
+ index: 0,
+ lineNumber: 1,
+ column: 1,
+ message: 'Error: Line 1: Unexpected token ILLEGAL'
+ },
+
+ '"\\': {
+ index: 3,
+ lineNumber: 1,
+ column: 4,
+ message: 'Error: Line 1: Unexpected token ILLEGAL'
+ },
+
+ '"\\u': {
+ index: 3,
+ lineNumber: 1,
+ column: 4,
+ message: 'Error: Line 1: Unexpected token ILLEGAL'
+ },
+
+ 'try { } catch() {}': {
+ index: 14,
+ lineNumber: 1,
+ column: 15,
+ message: 'Error: Line 1: Unexpected token )'
+ },
+
+ 'return': {
+ index: 6,
+ lineNumber: 1,
+ column: 7,
+ message: 'Error: Line 1: Illegal return statement'
+ },
+
+ 'break': {
+ index: 5,
+ lineNumber: 1,
+ column: 6,
+ message: 'Error: Line 1: Illegal break statement'
+ },
+
+ 'continue': {
+ index: 8,
+ lineNumber: 1,
+ column: 9,
+ message: 'Error: Line 1: Illegal continue statement'
+ },
+
+ 'switch (x) { default: continue; }': {
+ index: 31,
+ lineNumber: 1,
+ column: 32,
+ message: 'Error: Line 1: Illegal continue statement'
+ },
+
+ 'do { x } *': {
+ index: 9,
+ lineNumber: 1,
+ column: 10,
+ message: 'Error: Line 1: Unexpected token *'
+ },
+
+ 'while (true) { break x; }': {
+ index: 22,
+ lineNumber: 1,
+ column: 23,
+ message: 'Error: Line 1: Undefined label \'x\''
+ },
+
+ 'while (true) { continue x; }': {
+ index: 25,
+ lineNumber: 1,
+ column: 26,
+ message: 'Error: Line 1: Undefined label \'x\''
+ },
+
+ 'x: while (true) { (function () { break x; }); }': {
+ index: 40,
+ lineNumber: 1,
+ column: 41,
+ message: 'Error: Line 1: Undefined label \'x\''
+ },
+
+ 'x: while (true) { (function () { continue x; }); }': {
+ index: 43,
+ lineNumber: 1,
+ column: 44,
+ message: 'Error: Line 1: Undefined label \'x\''
+ },
+
+ 'x: while (true) { (function () { break; }); }': {
+ index: 39,
+ lineNumber: 1,
+ column: 40,
+ message: 'Error: Line 1: Illegal break statement'
+ },
+
+ 'x: while (true) { (function () { continue; }); }': {
+ index: 42,
+ lineNumber: 1,
+ column: 43,
+ message: 'Error: Line 1: Illegal continue statement'
+ },
+
+ 'x: while (true) { x: while (true) { } }': {
+ index: 20,
+ lineNumber: 1,
+ column: 21,
+ message: 'Error: Line 1: Label \'x\' has already been declared'
+ },
+
+ '(function () { \'use strict\'; delete i; }())': {
+ index: 37,
+ lineNumber: 1,
+ column: 38,
+ message: 'Error: Line 1: Delete of an unqualified identifier in strict mode.'
+ },
+
+ '(function () { \'use strict\'; with (i); }())': {
+ index: 28,
+ lineNumber: 1,
+ column: 29,
+ message: 'Error: Line 1: Strict mode code may not include a with statement'
+ },
+
+ 'function hello() {\'use strict\'; ({ i: 42, i: 42 }) }': {
+ index: 47,
+ lineNumber: 1,
+ column: 48,
+ message: 'Error: Line 1: Duplicate data property in object literal not allowed in strict mode'
+ },
+
+ 'function hello() {\'use strict\'; ({ hasOwnProperty: 42, hasOwnProperty: 42 }) }': {
+ index: 73,
+ lineNumber: 1,
+ column: 74,
+ message: 'Error: Line 1: Duplicate data property in object literal not allowed in strict mode'
+ },
+
+ 'function hello() {\'use strict\'; var eval = 10; }': {
+ index: 40,
+ lineNumber: 1,
+ column: 41,
+ message: 'Error: Line 1: Variable name may not be eval or arguments in strict mode'
+ },
+
+ 'function hello() {\'use strict\'; var arguments = 10; }': {
+ index: 45,
+ lineNumber: 1,
+ column: 46,
+ message: 'Error: Line 1: Variable name may not be eval or arguments in strict mode'
+ },
+
+ 'function hello() {\'use strict\'; try { } catch (eval) { } }': {
+ index: 51,
+ lineNumber: 1,
+ column: 52,
+ message: 'Error: Line 1: Catch variable may not be eval or arguments in strict mode'
+ },
+
+ 'function hello() {\'use strict\'; try { } catch (arguments) { } }': {
+ index: 56,
+ lineNumber: 1,
+ column: 57,
+ message: 'Error: Line 1: Catch variable may not be eval or arguments in strict mode'
+ },
+
+ 'function hello() {\'use strict\'; eval = 10; }': {
+ index: 32,
+ lineNumber: 1,
+ column: 33,
+ message: 'Error: Line 1: Assignment to eval or arguments is not allowed in strict mode'
+ },
+
+ 'function hello() {\'use strict\'; arguments = 10; }': {
+ index: 32,
+ lineNumber: 1,
+ column: 33,
+ message: 'Error: Line 1: Assignment to eval or arguments is not allowed in strict mode'
+ },
+
+ 'function hello() {\'use strict\'; ++eval; }': {
+ index: 38,
+ lineNumber: 1,
+ column: 39,
+ message: 'Error: Line 1: Prefix increment/decrement may not have eval or arguments operand in strict mode'
+ },
+
+ 'function hello() {\'use strict\'; --eval; }': {
+ index: 38,
+ lineNumber: 1,
+ column: 39,
+ message: 'Error: Line 1: Prefix increment/decrement may not have eval or arguments operand in strict mode'
+ },
+
+ 'function hello() {\'use strict\'; ++arguments; }': {
+ index: 43,
+ lineNumber: 1,
+ column: 44,
+ message: 'Error: Line 1: Prefix increment/decrement may not have eval or arguments operand in strict mode'
+ },
+
+ 'function hello() {\'use strict\'; --arguments; }': {
+ index: 43,
+ lineNumber: 1,
+ column: 44,
+ message: 'Error: Line 1: Prefix increment/decrement may not have eval or arguments operand in strict mode'
+ },
+
+ 'function hello() {\'use strict\'; eval++; }': {
+ index: 36,
+ lineNumber: 1,
+ column: 37,
+ message: 'Error: Line 1: Postfix increment/decrement may not have eval or arguments operand in strict mode'
+ },
+
+ 'function hello() {\'use strict\'; eval--; }': {
+ index: 36,
+ lineNumber: 1,
+ column: 37,
+ message: 'Error: Line 1: Postfix increment/decrement may not have eval or arguments operand in strict mode'
+ },
+
+ 'function hello() {\'use strict\'; arguments++; }': {
+ index: 41,
+ lineNumber: 1,
+ column: 42,
+ message: 'Error: Line 1: Postfix increment/decrement may not have eval or arguments operand in strict mode'
+ },
+
+ 'function hello() {\'use strict\'; arguments--; }': {
+ index: 41,
+ lineNumber: 1,
+ column: 42,
+ message: 'Error: Line 1: Postfix increment/decrement may not have eval or arguments operand in strict mode'
+ },
+
+ 'function hello() {\'use strict\'; function eval() { } }': {
+ index: 41,
+ lineNumber: 1,
+ column: 42,
+ message: 'Error: Line 1: Function name may not be eval or arguments in strict mode'
+ },
+
+ 'function hello() {\'use strict\'; function arguments() { } }': {
+ index: 41,
+ lineNumber: 1,
+ column: 42,
+ message: 'Error: Line 1: Function name may not be eval or arguments in strict mode'
+ },
+
+ 'function eval() {\'use strict\'; }': {
+ index: 9,
+ lineNumber: 1,
+ column: 10,
+ message: 'Error: Line 1: Function name may not be eval or arguments in strict mode'
+ },
+
+ 'function arguments() {\'use strict\'; }': {
+ index: 9,
+ lineNumber: 1,
+ column: 10,
+ message: 'Error: Line 1: Function name may not be eval or arguments in strict mode'
+ },
+
+ 'function hello() {\'use strict\'; (function eval() { }()) }': {
+ index: 42,
+ lineNumber: 1,
+ column: 43,
+ message: 'Error: Line 1: Function name may not be eval or arguments in strict mode'
+ },
+
+ 'function hello() {\'use strict\'; (function arguments() { }()) }': {
+ index: 42,
+ lineNumber: 1,
+ column: 43,
+ message: 'Error: Line 1: Function name may not be eval or arguments in strict mode'
+ },
+
+ '(function eval() {\'use strict\'; })()': {
+ index: 10,
+ lineNumber: 1,
+ column: 11,
+ message: 'Error: Line 1: Function name may not be eval or arguments in strict mode'
+ },
+
+ '(function arguments() {\'use strict\'; })()': {
+ index: 10,
+ lineNumber: 1,
+ column: 11,
+ message: 'Error: Line 1: Function name may not be eval or arguments in strict mode'
+ },
+
+ 'function hello() {\'use strict\'; ({ s: function eval() { } }); }': {
+ index: 47,
+ lineNumber: 1,
+ column: 48,
+ message: 'Error: Line 1: Function name may not be eval or arguments in strict mode'
+ },
+
+ '(function package() {\'use strict\'; })()': {
+ index: 10,
+ lineNumber: 1,
+ column: 11,
+ message: 'Error: Line 1: Use of future reserved word in strict mode'
+ },
+
+ 'function hello() {\'use strict\'; ({ i: 10, set s(eval) { } }); }': {
+ index: 48,
+ lineNumber: 1,
+ column: 49,
+ message: 'Error: Line 1: Parameter name eval or arguments is not allowed in strict mode'
+ },
+
+ 'function hello() {\'use strict\'; ({ set s(eval) { } }); }': {
+ index: 41,
+ lineNumber: 1,
+ column: 42,
+ message: 'Error: Line 1: Parameter name eval or arguments is not allowed in strict mode'
+ },
+
+ 'function hello() {\'use strict\'; ({ s: function s(eval) { } }); }': {
+ index: 49,
+ lineNumber: 1,
+ column: 50,
+ message: 'Error: Line 1: Parameter name eval or arguments is not allowed in strict mode'
+ },
+
+ 'function hello(eval) {\'use strict\';}': {
+ index: 15,
+ lineNumber: 1,
+ column: 16,
+ message: 'Error: Line 1: Parameter name eval or arguments is not allowed in strict mode'
+ },
+
+ 'function hello(arguments) {\'use strict\';}': {
+ index: 15,
+ lineNumber: 1,
+ column: 16,
+ message: 'Error: Line 1: Parameter name eval or arguments is not allowed in strict mode'
+ },
+
+ 'function hello() { \'use strict\'; function inner(eval) {} }': {
+ index: 48,
+ lineNumber: 1,
+ column: 49,
+ message: 'Error: Line 1: Parameter name eval or arguments is not allowed in strict mode'
+ },
+
+ 'function hello() { \'use strict\'; function inner(arguments) {} }': {
+ index: 48,
+ lineNumber: 1,
+ column: 49,
+ message: 'Error: Line 1: Parameter name eval or arguments is not allowed in strict mode'
+ },
+
+ ' "\\1"; \'use strict\';': {
+ index: 1,
+ lineNumber: 1,
+ column: 2,
+ message: 'Error: Line 1: Octal literals are not allowed in strict mode.'
+ },
+
+ 'function hello() { \'use strict\'; "\\1"; }': {
+ index: 33,
+ lineNumber: 1,
+ column: 34,
+ message: 'Error: Line 1: Octal literals are not allowed in strict mode.'
+ },
+
+ 'function hello() { \'use strict\'; 021; }': {
+ index: 33,
+ lineNumber: 1,
+ column: 34,
+ message: 'Error: Line 1: Octal literals are not allowed in strict mode.'
+ },
+
+ 'function hello() { \'use strict\'; ({ "\\1": 42 }); }': {
+ index: 36,
+ lineNumber: 1,
+ column: 37,
+ message: 'Error: Line 1: Octal literals are not allowed in strict mode.'
+ },
+
+ 'function hello() { \'use strict\'; ({ 021: 42 }); }': {
+ index: 36,
+ lineNumber: 1,
+ column: 37,
+ message: 'Error: Line 1: Octal literals are not allowed in strict mode.'
+ },
+
+ 'function hello() { "octal directive\\1"; "use strict"; }': {
+ index: 19,
+ lineNumber: 1,
+ column: 20,
+ message: 'Error: Line 1: Octal literals are not allowed in strict mode.'
+ },
+
+ 'function hello() { "octal directive\\1"; "octal directive\\2"; "use strict"; }': {
+ index: 19,
+ lineNumber: 1,
+ column: 20,
+ message: 'Error: Line 1: Octal literals are not allowed in strict mode.'
+ },
+
+ 'function hello() { "use strict"; function inner() { "octal directive\\1"; } }': {
+ index: 52,
+ lineNumber: 1,
+ column: 53,
+ message: 'Error: Line 1: Octal literals are not allowed in strict mode.'
+ },
+
+ 'function hello() { "use strict"; var implements; }': {
+ index: 37,
+ lineNumber: 1,
+ column: 38,
+ message: 'Error: Line 1: Use of future reserved word in strict mode'
+ },
+
+ 'function hello() { "use strict"; var interface; }': {
+ index: 37,
+ lineNumber: 1,
+ column: 38,
+ message: 'Error: Line 1: Use of future reserved word in strict mode'
+ },
+
+ 'function hello() { "use strict"; var package; }': {
+ index: 37,
+ lineNumber: 1,
+ column: 38,
+ message: 'Error: Line 1: Use of future reserved word in strict mode'
+ },
+
+ 'function hello() { "use strict"; var private; }': {
+ index: 37,
+ lineNumber: 1,
+ column: 38,
+ message: 'Error: Line 1: Use of future reserved word in strict mode'
+ },
+
+ 'function hello() { "use strict"; var protected; }': {
+ index: 37,
+ lineNumber: 1,
+ column: 38,
+ message: 'Error: Line 1: Use of future reserved word in strict mode'
+ },
+
+ 'function hello() { "use strict"; var public; }': {
+ index: 37,
+ lineNumber: 1,
+ column: 38,
+ message: 'Error: Line 1: Use of future reserved word in strict mode'
+ },
+
+ 'function hello() { "use strict"; var static; }': {
+ index: 37,
+ lineNumber: 1,
+ column: 38,
+ message: 'Error: Line 1: Use of future reserved word in strict mode'
+ },
+
+ 'function hello() { "use strict"; var yield; }': {
+ index: 37,
+ lineNumber: 1,
+ column: 38,
+ message: 'Error: Line 1: Use of future reserved word in strict mode'
+ },
+
+ 'function hello() { "use strict"; var let; }': {
+ index: 37,
+ lineNumber: 1,
+ column: 38,
+ message: 'Error: Line 1: Use of future reserved word in strict mode'
+ },
+
+ 'function hello(static) { "use strict"; }': {
+ index: 15,
+ lineNumber: 1,
+ column: 16,
+ message: 'Error: Line 1: Use of future reserved word in strict mode'
+ },
+
+ 'function static() { "use strict"; }': {
+ index: 9,
+ lineNumber: 1,
+ column: 10,
+ message: 'Error: Line 1: Use of future reserved word in strict mode'
+ },
+
+ 'var yield': {
+ index: 4,
+ lineNumber: 1,
+ column: 5,
+ message: 'Error: Line 1: Unexpected token yield'
+ },
+
+ 'var let': {
+ index: 4,
+ lineNumber: 1,
+ column: 5,
+ message: 'Error: Line 1: Unexpected token let'
+ },
+
+ '"use strict"; function static() { }': {
+ index: 23,
+ lineNumber: 1,
+ column: 24,
+ message: 'Error: Line 1: Use of future reserved word in strict mode'
+ },
+
+ 'function a(t, t) { "use strict"; }': {
+ index: 14,
+ lineNumber: 1,
+ column: 15,
+ message: 'Error: Line 1: Strict mode function may not have duplicate parameter names'
+ },
+
+ 'function a(eval) { "use strict"; }': {
+ index: 11,
+ lineNumber: 1,
+ column: 12,
+ message: 'Error: Line 1: Parameter name eval or arguments is not allowed in strict mode'
+ },
+
+ 'function a(package) { "use strict"; }': {
+ index: 11,
+ lineNumber: 1,
+ column: 12,
+ message: 'Error: Line 1: Use of future reserved word in strict mode'
+ },
+
+ 'function a() { "use strict"; function b(t, t) { }; }': {
+ index: 43,
+ lineNumber: 1,
+ column: 44,
+ message: 'Error: Line 1: Strict mode function may not have duplicate parameter names'
+ },
+
+ '(function a(t, t) { "use strict"; })': {
+ index: 15,
+ lineNumber: 1,
+ column: 16,
+ message: 'Error: Line 1: Strict mode function may not have duplicate parameter names'
+ },
+
+ 'function a() { "use strict"; (function b(t, t) { }); }': {
+ index: 44,
+ lineNumber: 1,
+ column: 45,
+ message: 'Error: Line 1: Strict mode function may not have duplicate parameter names'
+ },
+
+ '(function a(eval) { "use strict"; })': {
+ index: 12,
+ lineNumber: 1,
+ column: 13,
+ message: 'Error: Line 1: Parameter name eval or arguments is not allowed in strict mode'
+ },
+
+ '(function a(package) { "use strict"; })': {
+ index: 12,
+ lineNumber: 1,
+ column: 13,
+ message: 'Error: Line 1: Use of future reserved word in strict mode'
+ },
+
+ 'var': {
+ index: 3,
+ lineNumber: 1,
+ column: 4,
+ message: 'Error: Line 1: Unexpected end of input'
+ },
+
+ 'let': {
+ index: 3,
+ lineNumber: 1,
+ column: 4,
+ message: 'Error: Line 1: Unexpected end of input'
+ },
+
+ 'const': {
+ index: 5,
+ lineNumber: 1,
+ column: 6,
+ message: 'Error: Line 1: Unexpected end of input'
+ }
+
+ },
+
+ 'API': {
+ 'parse()': {
+ call: 'parse',
+ args: [],
+ result: {
+ type: 'Program',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Identifier',
+ name: 'undefined'
+ }
+ }]
+ }
+ },
+
+ 'parse(null)': {
+ call: 'parse',
+ args: [null],
+ result: {
+ type: 'Program',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: null
+ }
+ }]
+ }
+ },
+
+ 'parse(42)': {
+ call: 'parse',
+ args: [42],
+ result: {
+ type: 'Program',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 42
+ }
+ }]
+ }
+ },
+
+ 'parse(true)': {
+ call: 'parse',
+ args: [true],
+ result: {
+ type: 'Program',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: true
+ }
+ }]
+ }
+ },
+
+ 'parse(undefined)': {
+ call: 'parse',
+ args: [void 0],
+ result: {
+ type: 'Program',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Identifier',
+ name: 'undefined'
+ }
+ }]
+ }
+ },
+
+ 'parse(new String("test"))': {
+ call: 'parse',
+ args: [new String('test')],
+ result: {
+ type: 'Program',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Identifier',
+ name: 'test'
+ }
+ }]
+ }
+ },
+
+ 'parse(new Number(42))': {
+ call: 'parse',
+ args: [new Number(42)],
+ result: {
+ type: 'Program',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 42
+ }
+ }]
+ }
+ },
+
+ 'parse(new Boolean(true))': {
+ call: 'parse',
+ args: [new Boolean(true)],
+ result: {
+ type: 'Program',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: true
+ }
+ }]
+ }
+ },
+
+ 'Syntax': {
+ property: 'Syntax',
+ result: {
+ AssignmentExpression: 'AssignmentExpression',
+ ArrayExpression: 'ArrayExpression',
+ BlockStatement: 'BlockStatement',
+ BinaryExpression: 'BinaryExpression',
+ BreakStatement: 'BreakStatement',
+ CallExpression: 'CallExpression',
+ CatchClause: 'CatchClause',
+ ConditionalExpression: 'ConditionalExpression',
+ ContinueStatement: 'ContinueStatement',
+ DoWhileStatement: 'DoWhileStatement',
+ DebuggerStatement: 'DebuggerStatement',
+ EmptyStatement: 'EmptyStatement',
+ ExpressionStatement: 'ExpressionStatement',
+ ForStatement: 'ForStatement',
+ ForInStatement: 'ForInStatement',
+ FunctionDeclaration: 'FunctionDeclaration',
+ FunctionExpression: 'FunctionExpression',
+ Identifier: 'Identifier',
+ IfStatement: 'IfStatement',
+ Literal: 'Literal',
+ LabeledStatement: 'LabeledStatement',
+ LogicalExpression: 'LogicalExpression',
+ MemberExpression: 'MemberExpression',
+ NewExpression: 'NewExpression',
+ ObjectExpression: 'ObjectExpression',
+ Program: 'Program',
+ Property: 'Property',
+ ReturnStatement: 'ReturnStatement',
+ SequenceExpression: 'SequenceExpression',
+ SwitchStatement: 'SwitchStatement',
+ SwitchCase: 'SwitchCase',
+ ThisExpression: 'ThisExpression',
+ ThrowStatement: 'ThrowStatement',
+ TryStatement: 'TryStatement',
+ UnaryExpression: 'UnaryExpression',
+ UpdateExpression: 'UpdateExpression',
+ VariableDeclaration: 'VariableDeclaration',
+ VariableDeclarator: 'VariableDeclarator',
+ WhileStatement: 'WhileStatement',
+ WithStatement: 'WithStatement'
+ }
+ }
+
+ },
+
+ 'Tolerant parse': {
+ 'return': {
+ type: 'Program',
+ body: [{
+ type: 'ReturnStatement',
+ 'argument': null,
+ range: [0, 6],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 6 }
+ }
+ }],
+ range: [0, 6],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 6 }
+ },
+ errors: [{
+ index: 6,
+ lineNumber: 1,
+ column: 7,
+ message: 'Error: Line 1: Illegal return statement'
+ }]
+ },
+
+ '(function () { \'use strict\'; with (i); }())': {
+ type: 'Program',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'CallExpression',
+ callee: {
+ type: 'FunctionExpression',
+ id: null,
+ params: [],
+ defaults: [],
+ body: {
+ type: 'BlockStatement',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 'use strict',
+ raw: '\'use strict\'',
+ range: [15, 27],
+ loc: {
+ start: { line: 1, column: 15 },
+ end: { line: 1, column: 27 }
+ }
+ },
+ range: [15, 28],
+ loc: {
+ start: { line: 1, column: 15 },
+ end: { line: 1, column: 28 }
+ }
+ }, {
+ type: 'WithStatement',
+ object: {
+ type: 'Identifier',
+ name: 'i',
+ range: [35, 36],
+ loc: {
+ start: { line: 1, column: 35 },
+ end: { line: 1, column: 36 }
+ }
+ },
+ body: {
+ type: 'EmptyStatement',
+ range: [37, 38],
+ loc: {
+ start: { line: 1, column: 37 },
+ end: { line: 1, column: 38 }
+ }
+ },
+ range: [29, 38],
+ loc: {
+ start: { line: 1, column: 29 },
+ end: { line: 1, column: 38 }
+ }
+ }],
+ range: [13, 40],
+ loc: {
+ start: { line: 1, column: 13 },
+ end: { line: 1, column: 40 }
+ }
+ },
+ rest: null,
+ generator: false,
+ expression: false,
+ range: [1, 40],
+ loc: {
+ start: { line: 1, column: 1 },
+ end: { line: 1, column: 40 }
+ }
+ },
+ 'arguments': [],
+ range: [1, 42],
+ loc: {
+ start: { line: 1, column: 1 },
+ end: { line: 1, column: 42 }
+ }
+ },
+ range: [0, 43],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 43 }
+ }
+ }],
+ range: [0, 43],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 43 }
+ },
+ errors: [{
+ index: 29,
+ lineNumber: 1,
+ column: 30,
+ message: 'Error: Line 1: Strict mode code may not include a with statement'
+ }]
+ },
+
+ '(function () { \'use strict\'; 021 }())': {
+ type: 'Program',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'CallExpression',
+ callee: {
+ type: 'FunctionExpression',
+ id: null,
+ params: [],
+ defaults: [],
+ body: {
+ type: 'BlockStatement',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 'use strict',
+ raw: '\'use strict\'',
+ range: [15, 27],
+ loc: {
+ start: { line: 1, column: 15 },
+ end: { line: 1, column: 27 }
+ }
+ },
+ range: [15, 28],
+ loc: {
+ start: { line: 1, column: 15 },
+ end: { line: 1, column: 28 }
+ }
+ }, {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 17,
+ raw: "021",
+ range: [29, 32],
+ loc: {
+ start: { line: 1, column: 29 },
+ end: { line: 1, column: 32 }
+ }
+ },
+ range: [29, 33],
+ loc: {
+ start: { line: 1, column: 29 },
+ end: { line: 1, column: 33 }
+ }
+ }],
+ range: [13, 34],
+ loc: {
+ start: { line: 1, column: 13 },
+ end: { line: 1, column: 34 }
+ }
+ },
+ rest: null,
+ generator: false,
+ expression: false,
+ range: [1, 34],
+ loc: {
+ start: { line: 1, column: 1 },
+ end: { line: 1, column: 34 }
+ }
+ },
+ 'arguments': [],
+ range: [1, 36],
+ loc: {
+ start: { line: 1, column: 1 },
+ end: { line: 1, column: 36 }
+ }
+ },
+ range: [0, 37],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 37 }
+ }
+ }],
+ range: [0, 37],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 37 }
+ },
+ errors: [{
+ index: 29,
+ lineNumber: 1,
+ column: 30,
+ message: 'Error: Line 1: Octal literals are not allowed in strict mode.'
+ }]
+ },
+
+ '"use strict"; delete x': {
+ type: 'Program',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 'use strict',
+ raw: '"use strict"',
+ range: [0, 12],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 12 }
+ }
+ },
+ range: [0, 13],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 13 }
+ }
+ }, {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'UnaryExpression',
+ operator: 'delete',
+ argument: {
+ type: 'Identifier',
+ name: 'x',
+ range: [21, 22],
+ loc: {
+ start: { line: 1, column: 21 },
+ end: { line: 1, column: 22 }
+ }
+ },
+ prefix: true,
+ range: [14, 22],
+ loc: {
+ start: { line: 1, column: 14 },
+ end: { line: 1, column: 22 }
+ }
+ },
+ range: [14, 22],
+ loc: {
+ start: { line: 1, column: 14 },
+ end: { line: 1, column: 22 }
+ }
+ }],
+ range: [0, 22],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 22 }
+ },
+ errors: [{
+ index: 22,
+ lineNumber: 1,
+ column: 23,
+ message: 'Error: Line 1: Delete of an unqualified identifier in strict mode.'
+ }]
+ },
+
+ '"use strict"; try {} catch (eval) {}': {
+ type: 'Program',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 'use strict',
+ raw: '"use strict"',
+ range: [0, 12],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 12 }
+ }
+ },
+ range: [0, 13],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 13 }
+ }
+ }, {
+ type: 'TryStatement',
+ block: {
+ type: 'BlockStatement',
+ body: [],
+ range: [18, 20],
+ loc: {
+ start: { line: 1, column: 18 },
+ end: { line: 1, column: 20 }
+ }
+ },
+ guardedHandlers: [],
+ handlers: [{
+ type: 'CatchClause',
+ param: {
+ type: 'Identifier',
+ name: 'eval',
+ range: [28, 32],
+ loc: {
+ start: { line: 1, column: 28 },
+ end: { line: 1, column: 32 }
+ }
+ },
+ body: {
+ type: 'BlockStatement',
+ body: [],
+ range: [34, 36],
+ loc: {
+ start: { line: 1, column: 34 },
+ end: { line: 1, column: 36 }
+ }
+ },
+ range: [21, 36],
+ loc: {
+ start: { line: 1, column: 21 },
+ end: { line: 1, column: 36 }
+ }
+ }],
+ finalizer: null,
+ range: [14, 36],
+ loc: {
+ start: { line: 1, column: 14 },
+ end: { line: 1, column: 36 }
+ }
+ }],
+ range: [0, 36],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 36 }
+ },
+ errors: [{
+ index: 32,
+ lineNumber: 1,
+ column: 33,
+ message: 'Error: Line 1: Catch variable may not be eval or arguments in strict mode'
+ }]
+ },
+
+ '"use strict"; try {} catch (arguments) {}': {
+ type: 'Program',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 'use strict',
+ raw: '"use strict"',
+ range: [0, 12],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 12 }
+ }
+ },
+ range: [0, 13],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 13 }
+ }
+ }, {
+ type: 'TryStatement',
+ block: {
+ type: 'BlockStatement',
+ body: [],
+ range: [18, 20],
+ loc: {
+ start: { line: 1, column: 18 },
+ end: { line: 1, column: 20 }
+ }
+ },
+ guardedHandlers: [],
+ handlers: [{
+ type: 'CatchClause',
+ param: {
+ type: 'Identifier',
+ name: 'arguments',
+ range: [28, 37],
+ loc: {
+ start: { line: 1, column: 28 },
+ end: { line: 1, column: 37 }
+ }
+ },
+ body: {
+ type: 'BlockStatement',
+ body: [],
+ range: [39, 41],
+ loc: {
+ start: { line: 1, column: 39 },
+ end: { line: 1, column: 41 }
+ }
+ },
+ range: [21, 41],
+ loc: {
+ start: { line: 1, column: 21 },
+ end: { line: 1, column: 41 }
+ }
+ }],
+ finalizer: null,
+ range: [14, 41],
+ loc: {
+ start: { line: 1, column: 14 },
+ end: { line: 1, column: 41 }
+ }
+ }],
+ range: [0, 41],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 41 }
+ },
+ errors: [{
+ index: 37,
+ lineNumber: 1,
+ column: 38,
+ message: 'Error: Line 1: Catch variable may not be eval or arguments in strict mode'
+ }]
+ },
+
+ '"use strict"; var eval;': {
+ type: 'Program',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 'use strict',
+ raw: '"use strict"',
+ range: [0, 12],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 12 }
+ }
+ },
+ range: [0, 13],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 13 }
+ }
+ }, {
+ type: 'VariableDeclaration',
+ declarations: [{
+ type: 'VariableDeclarator',
+ id: {
+ type: 'Identifier',
+ name: 'eval',
+ range: [18, 22],
+ loc: {
+ start: { line: 1, column: 18 },
+ end: { line: 1, column: 22 }
+ }
+ },
+ init: null,
+ range: [18, 22],
+ loc: {
+ start: { line: 1, column: 18 },
+ end: { line: 1, column: 22 }
+ }
+ }],
+ kind: 'var',
+ range: [14, 23],
+ loc: {
+ start: { line: 1, column: 14 },
+ end: { line: 1, column: 23 }
+ }
+ }],
+ range: [0, 23],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 23 }
+ },
+ errors: [{
+ index: 22,
+ lineNumber: 1,
+ column: 23,
+ message: 'Error: Line 1: Variable name may not be eval or arguments in strict mode'
+ }]
+ },
+
+ '"use strict"; var arguments;': {
+ type: 'Program',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 'use strict',
+ raw: '"use strict"',
+ range: [0, 12],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 12 }
+ }
+ },
+ range: [0, 13],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 13 }
+ }
+ }, {
+ type: 'VariableDeclaration',
+ declarations: [{
+ type: 'VariableDeclarator',
+ id: {
+ type: 'Identifier',
+ name: 'arguments',
+ range: [18, 27],
+ loc: {
+ start: { line: 1, column: 18 },
+ end: { line: 1, column: 27 }
+ }
+ },
+ init: null,
+ range: [18, 27],
+ loc: {
+ start: { line: 1, column: 18 },
+ end: { line: 1, column: 27 }
+ }
+ }],
+ kind: 'var',
+ range: [14, 28],
+ loc: {
+ start: { line: 1, column: 14 },
+ end: { line: 1, column: 28 }
+ }
+ }],
+ range: [0, 28],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 28 }
+ },
+ errors: [{
+ index: 27,
+ lineNumber: 1,
+ column: 28,
+ message: 'Error: Line 1: Variable name may not be eval or arguments in strict mode'
+ }]
+ },
+
+ '"use strict"; eval = 0;': {
+ type: 'Program',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 'use strict',
+ raw: '"use strict"',
+ range: [0, 12],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 12 }
+ }
+ },
+ range: [0, 13],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 13 }
+ }
+ }, {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left: {
+ type: 'Identifier',
+ name: 'eval',
+ range: [14, 18],
+ loc: {
+ start: { line: 1, column: 14 },
+ end: { line: 1, column: 18 }
+ }
+ },
+ right: {
+ type: 'Literal',
+ value: 0,
+ raw: '0',
+ range: [21, 22],
+ loc: {
+ start: { line: 1, column: 21 },
+ end: { line: 1, column: 22 }
+ }
+ },
+ range: [14, 22],
+ loc: {
+ start: { line: 1, column: 14 },
+ end: { line: 1, column: 22 }
+ }
+ },
+ range: [14, 23],
+ loc: {
+ start: { line: 1, column: 14 },
+ end: { line: 1, column: 23 }
+ }
+ }],
+ range: [0, 23],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 23 }
+ },
+ errors: [{
+ index: 14,
+ lineNumber: 1,
+ column: 15,
+ message: 'Error: Line 1: Assignment to eval or arguments is not allowed in strict mode'
+ }]
+ },
+
+ '"use strict"; eval++;': {
+ type: 'Program',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 'use strict',
+ raw: '"use strict"',
+ range: [0, 12],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 12 }
+ }
+ },
+ range: [0, 13],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 13 }
+ }
+ }, {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'UpdateExpression',
+ operator: '++',
+ argument: {
+ type: 'Identifier',
+ name: 'eval',
+ range: [14, 18],
+ loc: {
+ start: { line: 1, column: 14 },
+ end: { line: 1, column: 18 }
+ }
+ },
+ prefix: false,
+ range: [14, 20],
+ loc: {
+ start: { line: 1, column: 14 },
+ end: { line: 1, column: 20 }
+ }
+ },
+ range: [14, 21],
+ loc: {
+ start: { line: 1, column: 14 },
+ end: { line: 1, column: 21 }
+ }
+ }],
+ range: [0, 21],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 21 }
+ },
+ errors: [{
+ index: 18,
+ lineNumber: 1,
+ column: 19,
+ message: 'Error: Line 1: Postfix increment/decrement may not have eval or arguments operand in strict mode'
+ }]
+ },
+
+ '"use strict"; --eval;': {
+ type: 'Program',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 'use strict',
+ raw: '"use strict"',
+ range: [0, 12],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 12 }
+ }
+ },
+ range: [0, 13],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 13 }
+ }
+ }, {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'UpdateExpression',
+ operator: '--',
+ argument: {
+ type: 'Identifier',
+ name: 'eval',
+ range: [16, 20],
+ loc: {
+ start: { line: 1, column: 16 },
+ end: { line: 1, column: 20 }
+ }
+ },
+ prefix: true,
+ range: [14, 20],
+ loc: {
+ start: { line: 1, column: 14 },
+ end: { line: 1, column: 20 }
+ }
+ },
+ range: [14, 21],
+ loc: {
+ start: { line: 1, column: 14 },
+ end: { line: 1, column: 21 }
+ }
+ }],
+ range: [0, 21],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 21 }
+ },
+ errors: [{
+ index: 20,
+ lineNumber: 1,
+ column: 21,
+ message: 'Error: Line 1: Prefix increment/decrement may not have eval or arguments operand in strict mode'
+ }]
+ },
+
+ '"use strict"; arguments = 0;': {
+ type: 'Program',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 'use strict',
+ raw: '"use strict"',
+ range: [0, 12],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 12 }
+ }
+ },
+ range: [0, 13],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 13 }
+ }
+ }, {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left: {
+ type: 'Identifier',
+ name: 'arguments',
+ range: [14, 23],
+ loc: {
+ start: { line: 1, column: 14 },
+ end: { line: 1, column: 23 }
+ }
+ },
+ right: {
+ type: 'Literal',
+ value: 0,
+ raw: '0',
+ range: [26, 27],
+ loc: {
+ start: { line: 1, column: 26 },
+ end: { line: 1, column: 27 }
+ }
+ },
+ range: [14, 27],
+ loc: {
+ start: { line: 1, column: 14 },
+ end: { line: 1, column: 27 }
+ }
+ },
+ range: [14, 28],
+ loc: {
+ start: { line: 1, column: 14 },
+ end: { line: 1, column: 28 }
+ }
+ }],
+ range: [0, 28],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 28 }
+ },
+ errors: [{
+ index: 14,
+ lineNumber: 1,
+ column: 15,
+ message: 'Error: Line 1: Assignment to eval or arguments is not allowed in strict mode'
+ }]
+ },
+
+ '"use strict"; arguments--;': {
+ type: 'Program',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 'use strict',
+ raw: '"use strict"',
+ range: [0, 12],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 12 }
+ }
+ },
+ range: [0, 13],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 13 }
+ }
+ }, {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'UpdateExpression',
+ operator: '--',
+ argument: {
+ type: 'Identifier',
+ name: 'arguments',
+ range: [14, 23],
+ loc: {
+ start: { line: 1, column: 14 },
+ end: { line: 1, column: 23 }
+ }
+ },
+ prefix: false,
+ range: [14, 25],
+ loc: {
+ start: { line: 1, column: 14 },
+ end: { line: 1, column: 25 }
+ }
+ },
+ range: [14, 26],
+ loc: {
+ start: { line: 1, column: 14 },
+ end: { line: 1, column: 26 }
+ }
+ }],
+ range: [0, 26],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 26 }
+ },
+ errors: [{
+ index: 23,
+ lineNumber: 1,
+ column: 24,
+ message: 'Error: Line 1: Postfix increment/decrement may not have eval or arguments operand in strict mode'
+ }]
+ },
+
+ '"use strict"; ++arguments;': {
+ type: 'Program',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 'use strict',
+ raw: '"use strict"',
+ range: [0, 12],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 12 }
+ }
+ },
+ range: [0, 13],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 13 }
+ }
+ }, {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'UpdateExpression',
+ operator: '++',
+ argument: {
+ type: 'Identifier',
+ name: 'arguments',
+ range: [16, 25],
+ loc: {
+ start: { line: 1, column: 16 },
+ end: { line: 1, column: 25 }
+ }
+ },
+ prefix: true,
+ range: [14, 25],
+ loc: {
+ start: { line: 1, column: 14 },
+ end: { line: 1, column: 25 }
+ }
+ },
+ range: [14, 26],
+ loc: {
+ start: { line: 1, column: 14 },
+ end: { line: 1, column: 26 }
+ }
+ }],
+ range: [0, 26],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 26 }
+ },
+ errors: [{
+ index: 25,
+ lineNumber: 1,
+ column: 26,
+ message: 'Error: Line 1: Prefix increment/decrement may not have eval or arguments operand in strict mode'
+ }]
+ },
+
+
+ '"use strict";x={y:1,y:1}': {
+ type: 'Program',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 'use strict',
+ raw: '"use strict"',
+ range: [0, 12],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 12 }
+ }
+ },
+ range: [0, 13],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 13 }
+ }
+ }, {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [13, 14],
+ loc: {
+ start: { line: 1, column: 13 },
+ end: { line: 1, column: 14 }
+ }
+ },
+ right: {
+ type: 'ObjectExpression',
+ properties: [{
+ type: 'Property',
+ key: {
+ type: 'Identifier',
+ name: 'y',
+ range: [16, 17],
+ loc: {
+ start: { line: 1, column: 16 },
+ end: { line: 1, column: 17 }
+ }
+ },
+ value: {
+ type: 'Literal',
+ value: 1,
+ raw: '1',
+ range: [18, 19],
+ loc: {
+ start: { line: 1, column: 18 },
+ end: { line: 1, column: 19 }
+ }
+ },
+ kind: 'init',
+ range: [16, 19],
+ loc: {
+ start: { line: 1, column: 16 },
+ end: { line: 1, column: 19 }
+ }
+ }, {
+ type: 'Property',
+ key: {
+ type: 'Identifier',
+ name: 'y',
+ range: [20, 21],
+ loc: {
+ start: { line: 1, column: 20 },
+ end: { line: 1, column: 21 }
+ }
+ },
+ value: {
+ type: 'Literal',
+ value: 1,
+ raw: '1',
+ range: [22, 23],
+ loc: {
+ start: { line: 1, column: 22 },
+ end: { line: 1, column: 23 }
+ }
+ },
+ kind: 'init',
+ range: [20, 23],
+ loc: {
+ start: { line: 1, column: 20 },
+ end: { line: 1, column: 23 }
+ }
+ }],
+ range: [15, 24],
+ loc: {
+ start: { line: 1, column: 15 },
+ end: { line: 1, column: 24 }
+ }
+ },
+ range: [13, 24],
+ loc: {
+ start: { line: 1, column: 13 },
+ end: { line: 1, column: 24 }
+ }
+ },
+ range: [13, 24],
+ loc: {
+ start: { line: 1, column: 13 },
+ end: { line: 1, column: 24 }
+ }
+ }],
+ range: [0, 24],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 24 }
+ },
+ errors: [{
+ index: 23,
+ lineNumber: 1,
+ column: 24,
+ message: 'Error: Line 1: Duplicate data property in object literal not allowed in strict mode'
+ }]
+ },
+
+ '"use strict"; function eval() {};': {
+ type: 'Program',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 'use strict',
+ raw: '"use strict"',
+ range: [0, 12],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 12 }
+ }
+ },
+ range: [0, 13],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 13 }
+ }
+ }, {
+ type: 'FunctionDeclaration',
+ id: {
+ type: 'Identifier',
+ name: 'eval',
+ range: [23, 27],
+ loc: {
+ start: { line: 1, column: 23 },
+ end: { line: 1, column: 27 }
+ }
+ },
+ params: [],
+ defaults: [],
+ body: {
+ type: 'BlockStatement',
+ body: [],
+ range: [30, 32],
+ loc: {
+ start: { line: 1, column: 30 },
+ end: { line: 1, column: 32 }
+ }
+ },
+ rest: null,
+ generator: false,
+ expression: false,
+ range: [14, 32],
+ loc: {
+ start: { line: 1, column: 14 },
+ end: { line: 1, column: 32 }
+ }
+ }, {
+ type: 'EmptyStatement',
+ range: [32, 33],
+ loc: {
+ start: { line: 1, column: 32 },
+ end: { line: 1, column: 33 }
+ }
+ }],
+ range: [0, 33],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 33 }
+ },
+ errors: [{
+ index: 23,
+ lineNumber: 1,
+ column: 24,
+ message: 'Error: Line 1: Function name may not be eval or arguments in strict mode'
+ }]
+ },
+
+ '"use strict"; function arguments() {};': {
+ type: 'Program',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 'use strict',
+ raw: '"use strict"',
+ range: [0, 12],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 12 }
+ }
+ },
+ range: [0, 13],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 13 }
+ }
+ }, {
+ type: 'FunctionDeclaration',
+ id: {
+ type: 'Identifier',
+ name: 'arguments',
+ range: [23, 32],
+ loc: {
+ start: { line: 1, column: 23 },
+ end: { line: 1, column: 32 }
+ }
+ },
+ params: [],
+ defaults: [],
+ body: {
+ type: 'BlockStatement',
+ body: [],
+ range: [35, 37],
+ loc: {
+ start: { line: 1, column: 35 },
+ end: { line: 1, column: 37 }
+ }
+ },
+ rest: null,
+ generator: false,
+ expression: false,
+ range: [14, 37],
+ loc: {
+ start: { line: 1, column: 14 },
+ end: { line: 1, column: 37 }
+ }
+ }, {
+ type: 'EmptyStatement',
+ range: [37, 38],
+ loc: {
+ start: { line: 1, column: 37 },
+ end: { line: 1, column: 38 }
+ }
+ }],
+ range: [0, 38],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 38 }
+ },
+ errors: [{
+ index: 23,
+ lineNumber: 1,
+ column: 24,
+ message: 'Error: Line 1: Function name may not be eval or arguments in strict mode'
+ }]
+ },
+
+ '"use strict"; function interface() {};': {
+ type: 'Program',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 'use strict',
+ raw: '"use strict"',
+ range: [0, 12],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 12 }
+ }
+ },
+ range: [0, 13],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 13 }
+ }
+ }, {
+ type: 'FunctionDeclaration',
+ id: {
+ type: 'Identifier',
+ name: 'interface',
+ range: [23, 32],
+ loc: {
+ start: { line: 1, column: 23 },
+ end: { line: 1, column: 32 }
+ }
+ },
+ params: [],
+ defaults: [],
+ body: {
+ type: 'BlockStatement',
+ body: [],
+ range: [35, 37],
+ loc: {
+ start: { line: 1, column: 35 },
+ end: { line: 1, column: 37 }
+ }
+ },
+ rest: null,
+ generator: false,
+ expression: false,
+ range: [14, 37],
+ loc: {
+ start: { line: 1, column: 14 },
+ end: { line: 1, column: 37 }
+ }
+ }, {
+ type: 'EmptyStatement',
+ range: [37, 38],
+ loc: {
+ start: { line: 1, column: 37 },
+ end: { line: 1, column: 38 }
+ }
+ }],
+ range: [0, 38],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 38 }
+ },
+ errors: [{
+ index: 23,
+ lineNumber: 1,
+ column: 24,
+ message: 'Error: Line 1: Use of future reserved word in strict mode'
+ }]
+ },
+
+ '"use strict"; (function eval() {});': {
+ type: 'Program',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 'use strict',
+ raw: '"use strict"',
+ range: [0, 12],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 12 }
+ }
+ },
+ range: [0, 13],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 13 }
+ }
+ }, {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'FunctionExpression',
+ id: {
+ type: 'Identifier',
+ name: 'eval',
+ range: [24, 28],
+ loc: {
+ start: { line: 1, column: 24 },
+ end: { line: 1, column: 28 }
+ }
+ },
+ params: [],
+ defaults: [],
+ body: {
+ type: 'BlockStatement',
+ body: [],
+ range: [31, 33],
+ loc: {
+ start: { line: 1, column: 31 },
+ end: { line: 1, column: 33 }
+ }
+ },
+ rest: null,
+ generator: false,
+ expression: false,
+ range: [15, 33],
+ loc: {
+ start: { line: 1, column: 15 },
+ end: { line: 1, column: 33 }
+ }
+ },
+ range: [14, 35],
+ loc: {
+ start: { line: 1, column: 14 },
+ end: { line: 1, column: 35 }
+ }
+ }],
+ range: [0, 35],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 35 }
+ },
+ errors: [{
+ index: 24,
+ lineNumber: 1,
+ column: 25,
+ message: 'Error: Line 1: Function name may not be eval or arguments in strict mode'
+ }]
+ },
+
+ '"use strict"; (function arguments() {});': {
+ type: 'Program',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 'use strict',
+ raw: '"use strict"',
+ range: [0, 12],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 12 }
+ }
+ },
+ range: [0, 13],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 13 }
+ }
+ }, {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'FunctionExpression',
+ id: {
+ type: 'Identifier',
+ name: 'arguments',
+ range: [24, 33],
+ loc: {
+ start: { line: 1, column: 24 },
+ end: { line: 1, column: 33 }
+ }
+ },
+ params: [],
+ defaults: [],
+ body: {
+ type: 'BlockStatement',
+ body: [],
+ range: [36, 38],
+ loc: {
+ start: { line: 1, column: 36 },
+ end: { line: 1, column: 38 }
+ }
+ },
+ rest: null,
+ generator: false,
+ expression: false,
+ range: [15, 38],
+ loc: {
+ start: { line: 1, column: 15 },
+ end: { line: 1, column: 38 }
+ }
+ },
+ range: [14, 40],
+ loc: {
+ start: { line: 1, column: 14 },
+ end: { line: 1, column: 40 }
+ }
+ }],
+ range: [0, 40],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 40 }
+ },
+ errors: [{
+ index: 24,
+ lineNumber: 1,
+ column: 25,
+ message: 'Error: Line 1: Function name may not be eval or arguments in strict mode'
+ }]
+ },
+
+ '"use strict"; (function interface() {});': {
+ type: 'Program',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 'use strict',
+ raw: '"use strict"',
+ range: [0, 12],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 12 }
+ }
+ },
+ range: [0, 13],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 13 }
+ }
+ }, {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'FunctionExpression',
+ id: {
+ type: 'Identifier',
+ name: 'interface',
+ range: [24, 33],
+ loc: {
+ start: { line: 1, column: 24 },
+ end: { line: 1, column: 33 }
+ }
+ },
+ params: [],
+ defaults: [],
+ body: {
+ type: 'BlockStatement',
+ body: [],
+ range: [36, 38],
+ loc: {
+ start: { line: 1, column: 36 },
+ end: { line: 1, column: 38 }
+ }
+ },
+ rest: null,
+ generator: false,
+ expression: false,
+ range: [15, 38],
+ loc: {
+ start: { line: 1, column: 15 },
+ end: { line: 1, column: 38 }
+ }
+ },
+ range: [14, 40],
+ loc: {
+ start: { line: 1, column: 14 },
+ end: { line: 1, column: 40 }
+ }
+ }],
+ range: [0, 40],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 40 }
+ },
+ errors: [{
+ index: 24,
+ lineNumber: 1,
+ column: 25,
+ message: 'Error: Line 1: Use of future reserved word in strict mode'
+ }]
+ },
+
+ '"use strict"; function f(eval) {};': {
+ type: 'Program',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 'use strict',
+ raw: '"use strict"',
+ range: [0, 12],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 12 }
+ }
+ },
+ range: [0, 13],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 13 }
+ }
+ }, {
+ type: 'FunctionDeclaration',
+ id: {
+ type: 'Identifier',
+ name: 'f',
+ range: [23, 24],
+ loc: {
+ start: { line: 1, column: 23 },
+ end: { line: 1, column: 24 }
+ }
+ },
+ params: [{
+ type: 'Identifier',
+ name: 'eval',
+ range: [25, 29],
+ loc: {
+ start: { line: 1, column: 25 },
+ end: { line: 1, column: 29 }
+ }
+ }],
+ defaults: [],
+ body: {
+ type: 'BlockStatement',
+ body: [],
+ range: [31, 33],
+ loc: {
+ start: { line: 1, column: 31 },
+ end: { line: 1, column: 33 }
+ }
+ },
+ rest: null,
+ generator: false,
+ expression: false,
+ range: [14, 33],
+ loc: {
+ start: { line: 1, column: 14 },
+ end: { line: 1, column: 33 }
+ }
+ }, {
+ type: 'EmptyStatement',
+ range: [33, 34],
+ loc: {
+ start: { line: 1, column: 33 },
+ end: { line: 1, column: 34 }
+ }
+ }],
+ range: [0, 34],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 34 }
+ },
+ errors: [{
+ index: 25,
+ lineNumber: 1,
+ column: 26,
+ message: 'Error: Line 1: Parameter name eval or arguments is not allowed in strict mode'
+ }]
+ },
+
+ '"use strict"; function f(arguments) {};': {
+ type: 'Program',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 'use strict',
+ raw: '"use strict"',
+ range: [0, 12],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 12 }
+ }
+ },
+ range: [0, 13],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 13 }
+ }
+ }, {
+ type: 'FunctionDeclaration',
+ id: {
+ type: 'Identifier',
+ name: 'f',
+ range: [23, 24],
+ loc: {
+ start: { line: 1, column: 23 },
+ end: { line: 1, column: 24 }
+ }
+ },
+ params: [{
+ type: 'Identifier',
+ name: 'arguments',
+ range: [25, 34],
+ loc: {
+ start: { line: 1, column: 25 },
+ end: { line: 1, column: 34 }
+ }
+ }],
+ defaults: [],
+ body: {
+ type: 'BlockStatement',
+ body: [],
+ range: [36, 38],
+ loc: {
+ start: { line: 1, column: 36 },
+ end: { line: 1, column: 38 }
+ }
+ },
+ rest: null,
+ generator: false,
+ expression: false,
+ range: [14, 38],
+ loc: {
+ start: { line: 1, column: 14 },
+ end: { line: 1, column: 38 }
+ }
+ }, {
+ type: 'EmptyStatement',
+ range: [38, 39],
+ loc: {
+ start: { line: 1, column: 38 },
+ end: { line: 1, column: 39 }
+ }
+ }],
+ range: [0, 39],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 39 }
+ },
+ errors: [{
+ index: 25,
+ lineNumber: 1,
+ column: 26,
+ message: 'Error: Line 1: Parameter name eval or arguments is not allowed in strict mode'
+ }]
+ },
+
+ '"use strict"; function f(foo, foo) {};': {
+ type: 'Program',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 'use strict',
+ raw: '"use strict"',
+ range: [0, 12],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 12 }
+ }
+ },
+ range: [0, 13],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 13 }
+ }
+ }, {
+ type: 'FunctionDeclaration',
+ id: {
+ type: 'Identifier',
+ name: 'f',
+ range: [23, 24],
+ loc: {
+ start: { line: 1, column: 23 },
+ end: { line: 1, column: 24 }
+ }
+ },
+ params: [{
+ type: 'Identifier',
+ name: 'foo',
+ range: [25, 28],
+ loc: {
+ start: { line: 1, column: 25 },
+ end: { line: 1, column: 28 }
+ }
+ }, {
+ type: 'Identifier',
+ name: 'foo',
+ range: [31, 34],
+ loc: {
+ start: { line: 1, column: 31 },
+ end: { line: 1, column: 34 }
+ }
+ }],
+ defaults: [],
+ body: {
+ type: 'BlockStatement',
+ body: [],
+ range: [36, 38],
+ loc: {
+ start: { line: 1, column: 36 },
+ end: { line: 1, column: 38 }
+ }
+ },
+ rest: null,
+ generator: false,
+ expression: false,
+ range: [14, 38],
+ loc: {
+ start: { line: 1, column: 14 },
+ end: { line: 1, column: 38 }
+ }
+ }, {
+ type: 'EmptyStatement',
+ range: [38, 39],
+ loc: {
+ start: { line: 1, column: 38 },
+ end: { line: 1, column: 39 }
+ }
+ }],
+ range: [0, 39],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 39 }
+ },
+ errors: [{
+ index: 31,
+ lineNumber: 1,
+ column: 32,
+ message: 'Error: Line 1: Strict mode function may not have duplicate parameter names'
+ }]
+ },
+
+ '"use strict"; (function f(eval) {});': {
+ type: 'Program',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 'use strict',
+ raw: '"use strict"',
+ range: [0, 12],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 12 }
+ }
+ },
+ range: [0, 13],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 13 }
+ }
+ }, {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'FunctionExpression',
+ id: {
+ type: 'Identifier',
+ name: 'f',
+ range: [24, 25],
+ loc: {
+ start: { line: 1, column: 24 },
+ end: { line: 1, column: 25 }
+ }
+ },
+ params: [{
+ type: 'Identifier',
+ name: 'eval',
+ range: [26, 30],
+ loc: {
+ start: { line: 1, column: 26 },
+ end: { line: 1, column: 30 }
+ }
+ }],
+ defaults: [],
+ body: {
+ type: 'BlockStatement',
+ body: [],
+ range: [32, 34],
+ loc: {
+ start: { line: 1, column: 32 },
+ end: { line: 1, column: 34 }
+ }
+ },
+ rest: null,
+ generator: false,
+ expression: false,
+ range: [15, 34],
+ loc: {
+ start: { line: 1, column: 15 },
+ end: { line: 1, column: 34 }
+ }
+ },
+ range: [14, 36],
+ loc: {
+ start: { line: 1, column: 14 },
+ end: { line: 1, column: 36 }
+ }
+ }],
+ range: [0, 36],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 36 }
+ },
+ errors: [{
+ index: 26,
+ lineNumber: 1,
+ column: 27,
+ message: 'Error: Line 1: Parameter name eval or arguments is not allowed in strict mode'
+ }]
+ },
+
+
+ '"use strict"; (function f(arguments) {});': {
+ type: 'Program',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 'use strict',
+ raw: '"use strict"',
+ range: [0, 12],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 12 }
+ }
+ },
+ range: [0, 13],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 13 }
+ }
+ }, {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'FunctionExpression',
+ id: {
+ type: 'Identifier',
+ name: 'f',
+ range: [24, 25],
+ loc: {
+ start: { line: 1, column: 24 },
+ end: { line: 1, column: 25 }
+ }
+ },
+ params: [{
+ type: 'Identifier',
+ name: 'arguments',
+ range: [26, 35],
+ loc: {
+ start: { line: 1, column: 26 },
+ end: { line: 1, column: 35 }
+ }
+ }],
+ defaults: [],
+ body: {
+ type: 'BlockStatement',
+ body: [],
+ range: [37, 39],
+ loc: {
+ start: { line: 1, column: 37 },
+ end: { line: 1, column: 39 }
+ }
+ },
+ rest: null,
+ generator: false,
+ expression: false,
+ range: [15, 39],
+ loc: {
+ start: { line: 1, column: 15 },
+ end: { line: 1, column: 39 }
+ }
+ },
+ range: [14, 41],
+ loc: {
+ start: { line: 1, column: 14 },
+ end: { line: 1, column: 41 }
+ }
+ }],
+ range: [0, 41],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 41 }
+ },
+ errors: [{
+ index: 26,
+ lineNumber: 1,
+ column: 27,
+ message: 'Error: Line 1: Parameter name eval or arguments is not allowed in strict mode'
+ }]
+ },
+
+ '"use strict"; (function f(foo, foo) {});': {
+ type: 'Program',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 'use strict',
+ raw: '"use strict"',
+ range: [0, 12],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 12 }
+ }
+ },
+ range: [0, 13],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 13 }
+ }
+ }, {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'FunctionExpression',
+ id: {
+ type: 'Identifier',
+ name: 'f',
+ range: [24, 25],
+ loc: {
+ start: { line: 1, column: 24 },
+ end: { line: 1, column: 25 }
+ }
+ },
+ params: [{
+ type: 'Identifier',
+ name: 'foo',
+ range: [26, 29],
+ loc: {
+ start: { line: 1, column: 26 },
+ end: { line: 1, column: 29 }
+ }
+ }, {
+ type: 'Identifier',
+ name: 'foo',
+ range: [32, 35],
+ loc: {
+ start: { line: 1, column: 32 },
+ end: { line: 1, column: 35 }
+ }
+ }],
+ defaults: [],
+ body: {
+ type: 'BlockStatement',
+ body: [],
+ range: [37, 39],
+ loc: {
+ start: { line: 1, column: 37 },
+ end: { line: 1, column: 39 }
+ }
+ },
+ rest: null,
+ generator: false,
+ expression: false,
+ range: [15, 39],
+ loc: {
+ start: { line: 1, column: 15 },
+ end: { line: 1, column: 39 }
+ }
+ },
+ range: [14, 41],
+ loc: {
+ start: { line: 1, column: 14 },
+ end: { line: 1, column: 41 }
+ }
+ }],
+ range: [0, 41],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 41 }
+ },
+ errors: [{
+ index: 32,
+ lineNumber: 1,
+ column: 33,
+ message: 'Error: Line 1: Strict mode function may not have duplicate parameter names'
+ }]
+ },
+
+ '"use strict"; x = { set f(eval) {} }' : {
+ type: 'Program',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 'use strict',
+ raw: '"use strict"',
+ range: [0, 12],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 12 }
+ }
+ },
+ range: [0, 13],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 13 }
+ }
+ }, {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left: {
+ type: 'Identifier',
+ name: 'x',
+ range: [14, 15],
+ loc: {
+ start: { line: 1, column: 14 },
+ end: { line: 1, column: 15 }
+ }
+ },
+ right: {
+ type: 'ObjectExpression',
+ properties: [{
+ type: 'Property',
+ key: {
+ type: 'Identifier',
+ name: 'f',
+ range: [24, 25],
+ loc: {
+ start: { line: 1, column: 24 },
+ end: { line: 1, column: 25 }
+ }
+ },
+ value : {
+ type: 'FunctionExpression',
+ id: null,
+ params: [{
+ type: 'Identifier',
+ name: 'eval',
+ range: [26, 30],
+ loc: {
+ start: { line: 1, column: 26 },
+ end: { line: 1, column: 30 }
+ }
+ }],
+ defaults: [],
+ body: {
+ type: 'BlockStatement',
+ body: [],
+ range: [32, 34],
+ loc: {
+ start: { line: 1, column: 32 },
+ end: { line: 1, column: 34 }
+ }
+ },
+ rest: null,
+ generator: false,
+ expression: false,
+ range: [32, 34],
+ loc: {
+ start: { line: 1, column: 32 },
+ end: { line: 1, column: 34 }
+ }
+ },
+ kind: 'set',
+ range: [20, 34],
+ loc: {
+ start: { line: 1, column: 20 },
+ end: { line: 1, column: 34 }
+ }
+ }],
+ range: [18, 36],
+ loc: {
+ start: { line: 1, column: 18 },
+ end: { line: 1, column: 36 }
+ }
+ },
+ range: [14, 36],
+ loc: {
+ start: { line: 1, column: 14 },
+ end: { line: 1, column: 36 }
+ }
+ },
+ range: [14, 36],
+ loc: {
+ start: { line: 1, column: 14 },
+ end: { line: 1, column: 36 }
+ }
+ }],
+ range: [0, 36],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 36 }
+ },
+ errors: [{
+ index: 26,
+ lineNumber: 1,
+ column: 27,
+ message: 'Error: Line 1: Parameter name eval or arguments is not allowed in strict mode'
+ }]
+ },
+
+ 'function hello() { "octal directive\\1"; "use strict"; }': {
+ type: 'Program',
+ body: [{
+ type: 'FunctionDeclaration',
+ id: {
+ type: 'Identifier',
+ name: 'hello',
+ range: [9, 14],
+ loc: {
+ start: { line: 1, column: 9 },
+ end: { line: 1, column: 14 }
+ }
+ },
+ params: [],
+ defaults: [],
+ body: {
+ type: 'BlockStatement',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 'octal directive\u0001',
+ raw: '"octal directive\\1"',
+ range: [19, 38],
+ loc: {
+ start: { line: 1, column: 19 },
+ end: { line: 1, column: 38 }
+ }
+ },
+ range: [19, 39],
+ loc: {
+ start: { line: 1, column: 19 },
+ end: { line: 1, column: 39 }
+ }
+ }, {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 'use strict',
+ raw: '"use strict"',
+ range: [40, 52],
+ loc: {
+ start: { line: 1, column: 40 },
+ end: { line: 1, column: 52 }
+ }
+ },
+ range: [40, 53],
+ loc: {
+ start: { line: 1, column: 40 },
+ end: { line: 1, column: 53 }
+ }
+ }],
+ range: [17, 55],
+ loc: {
+ start: { line: 1, column: 17 },
+ end: { line: 1, column: 55 }
+ }
+ },
+ rest: null,
+ generator: false,
+ expression: false,
+ range: [0, 55],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 55 }
+ }
+ }],
+ range: [0, 55],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 55 }
+ },
+ errors: [{
+ index: 19,
+ lineNumber: 1,
+ column: 20,
+ message: 'Error: Line 1: Octal literals are not allowed in strict mode.'
+ }]
+ },
+
+ '"\\1"; \'use strict\';': {
+ type: 'Program',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: '\u0001',
+ raw: '"\\1"',
+ range: [0, 4],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 4 }
+ }
+ },
+ range: [0, 5],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 5 }
+ }
+ }, {
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 'use strict',
+ raw: '\'use strict\'',
+ range: [6, 18],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 18 }
+ }
+ },
+ range: [6, 19],
+ loc: {
+ start: { line: 1, column: 6 },
+ end: { line: 1, column: 19 }
+ }
+ }],
+ range: [0, 19],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 19 }
+ },
+ errors: [{
+ index: 0,
+ lineNumber: 1,
+ column: 1,
+ message: 'Error: Line 1: Octal literals are not allowed in strict mode.'
+ }]
+ },
+
+ '"use strict"; var x = { 014: 3}': {
+ type: 'Program',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 'use strict',
+ raw: '"use strict"',
+ range: [0, 12],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 12 }
+ }
+ },
+ range: [0, 13],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 13 }
+ }
+ }, {
+ type: 'VariableDeclaration',
+ declarations: [{
+ type: 'VariableDeclarator',
+ id: {
+ type: 'Identifier',
+ name: 'x',
+ range: [18, 19],
+ loc: {
+ start: { line: 1, column: 18 },
+ end: { line: 1, column: 19 }
+ }
+ },
+ init: {
+ type: 'ObjectExpression',
+ properties: [{
+ type: 'Property',
+ key: {
+ type: 'Literal',
+ value: 12,
+ raw: '014',
+ range: [24, 27],
+ loc: {
+ start: { line: 1, column: 24 },
+ end: { line: 1, column: 27 }
+ }
+ },
+ value: {
+ type: 'Literal',
+ value: 3,
+ raw: '3',
+ range: [29, 30],
+ loc: {
+ start: { line: 1, column: 29 },
+ end: { line: 1, column: 30 }
+ }
+ },
+ kind: 'init',
+ range: [24, 30],
+ loc: {
+ start: { line: 1, column: 24 },
+ end: { line: 1, column: 30 }
+ }
+ }],
+ range: [22, 31],
+ loc: {
+ start: { line: 1, column: 22 },
+ end: { line: 1, column: 31 }
+ }
+ },
+ range: [18, 31],
+ loc: {
+ start: { line: 1, column: 18 },
+ end: { line: 1, column: 31 }
+ }
+ }],
+ kind: 'var',
+ range: [14, 31],
+ loc: {
+ start: { line: 1, column: 14 },
+ end: { line: 1, column: 31 }
+ }
+ }],
+ range: [0, 31],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 31 }
+ },
+ errors: [{
+ index: 24,
+ lineNumber: 1,
+ column: 25,
+ message: 'Error: Line 1: Octal literals are not allowed in strict mode.'
+ }]
+ },
+
+ '"use strict"; var x = { get i() {}, get i() {} }': {
+ type: 'Program',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 'use strict',
+ raw: '"use strict"',
+ range: [0, 12],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 12 }
+ }
+ },
+ range: [0, 13],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 13 }
+ }
+ }, {
+ type: 'VariableDeclaration',
+ declarations: [{
+ type: 'VariableDeclarator',
+ id: {
+ type: 'Identifier',
+ name: 'x',
+ range: [18, 19],
+ loc: {
+ start: { line: 1, column: 18 },
+ end: { line: 1, column: 19 }
+ }
+ },
+ init: {
+ type: 'ObjectExpression',
+ properties: [{
+ type: 'Property',
+ key: {
+ type: 'Identifier',
+ name: 'i',
+ range: [28, 29],
+ loc: {
+ start: { line: 1, column: 28 },
+ end: { line: 1, column: 29 }
+ }
+ },
+ value: {
+ type: 'FunctionExpression',
+ id: null,
+ params: [],
+ defaults: [],
+ body: {
+ type: 'BlockStatement',
+ body: [],
+ range: [32, 34],
+ loc: {
+ start: { line: 1, column: 32 },
+ end: { line: 1, column: 34 }
+ }
+ },
+ rest: null,
+ generator: false,
+ expression: false,
+ range: [32, 34],
+ loc: {
+ start: { line: 1, column: 32 },
+ end: { line: 1, column: 34 }
+ }
+ },
+ kind: 'get',
+ range: [24, 34],
+ loc: {
+ start: { line: 1, column: 24 },
+ end: { line: 1, column: 34 }
+ }
+ }, {
+ type: 'Property',
+ key: {
+ type: 'Identifier',
+ name: 'i',
+ range: [40, 41],
+ loc: {
+ start: { line: 1, column: 40 },
+ end: { line: 1, column: 41 }
+ }
+ },
+ value: {
+ type: 'FunctionExpression',
+ id: null,
+ params: [],
+ defaults: [],
+ body: {
+ type: 'BlockStatement',
+ body: [],
+ range: [44, 46],
+ loc: {
+ start: { line: 1, column: 44 },
+ end: { line: 1, column: 46 }
+ }
+ },
+ rest: null,
+ generator: false,
+ expression: false,
+ range: [44, 46],
+ loc: {
+ start: { line: 1, column: 44 },
+ end: { line: 1, column: 46 }
+ }
+ },
+ kind: 'get',
+ range: [36, 46],
+ loc: {
+ start: { line: 1, column: 36 },
+ end: { line: 1, column: 46 }
+ }
+ }],
+ range: [22, 48],
+ loc: {
+ start: { line: 1, column: 22 },
+ end: { line: 1, column: 48 }
+ }
+ },
+ range: [18, 48],
+ loc: {
+ start: { line: 1, column: 18 },
+ end: { line: 1, column: 48 }
+ }
+ }],
+ kind: 'var',
+ range: [14, 48],
+ loc: {
+ start: { line: 1, column: 14 },
+ end: { line: 1, column: 48 }
+ }
+ }],
+ range: [0, 48],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 48 }
+ },
+ errors: [{
+ index: 46,
+ lineNumber: 1,
+ column: 47,
+ message: 'Error: Line 1: Object literal may not have multiple get/set accessors with the same name'
+ }]
+ },
+
+ '"use strict"; var x = { i: 42, get i() {} }': {
+ type: 'Program',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 'use strict',
+ raw: '"use strict"',
+ range: [0, 12],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 12 }
+ }
+ },
+ range: [0, 13],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 13 }
+ }
+ }, {
+ type: 'VariableDeclaration',
+ declarations: [{
+ type: 'VariableDeclarator',
+ id: {
+ type: 'Identifier',
+ name: 'x',
+ range: [18, 19],
+ loc: {
+ start: { line: 1, column: 18 },
+ end: { line: 1, column: 19 }
+ }
+ },
+ init: {
+ type: 'ObjectExpression',
+ properties: [{
+ type: 'Property',
+ key: {
+ type: 'Identifier',
+ name: 'i',
+ range: [24, 25],
+ loc: {
+ start: { line: 1, column: 24 },
+ end: { line: 1, column: 25 }
+ }
+ },
+ value: {
+ type: 'Literal',
+ value: 42,
+ raw: '42',
+ range: [27, 29],
+ loc: {
+ start: { line: 1, column: 27 },
+ end: { line: 1, column: 29 }
+ }
+ },
+ kind: 'init',
+ range: [24, 29],
+ loc: {
+ start: { line: 1, column: 24 },
+ end: { line: 1, column: 29 }
+ }
+ }, {
+ type: 'Property',
+ key: {
+ type: 'Identifier',
+ name: 'i',
+ range: [35, 36],
+ loc: {
+ start: { line: 1, column: 35 },
+ end: { line: 1, column: 36 }
+ }
+ },
+ value: {
+ type: 'FunctionExpression',
+ id: null,
+ params: [],
+ defaults: [],
+ body: {
+ type: 'BlockStatement',
+ body: [],
+ range: [39, 41],
+ loc: {
+ start: { line: 1, column: 39 },
+ end: { line: 1, column: 41 }
+ }
+ },
+ rest: null,
+ generator: false,
+ expression: false,
+ range: [39, 41],
+ loc: {
+ start: { line: 1, column: 39 },
+ end: { line: 1, column: 41 }
+ }
+ },
+ kind: 'get',
+ range: [31, 41],
+ loc: {
+ start: { line: 1, column: 31 },
+ end: { line: 1, column: 41 }
+ }
+ }],
+ range: [22, 43],
+ loc: {
+ start: { line: 1, column: 22 },
+ end: { line: 1, column: 43 }
+ }
+ },
+ range: [18, 43],
+ loc: {
+ start: { line: 1, column: 18 },
+ end: { line: 1, column: 43 }
+ }
+ }],
+ kind: 'var',
+ range: [14, 43],
+ loc: {
+ start: { line: 1, column: 14 },
+ end: { line: 1, column: 43 }
+ }
+ }],
+ range: [0, 43],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 43 }
+ },
+ errors: [{
+ index: 41,
+ lineNumber: 1,
+ column: 42,
+ message: 'Error: Line 1: Object literal may not have data and accessor property with the same name'
+ }]
+ },
+
+ '"use strict"; var x = { set i(x) {}, i: 42 }': {
+ type: 'Program',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'Literal',
+ value: 'use strict',
+ raw: '"use strict"',
+ range: [0, 12],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 12 }
+ }
+ },
+ range: [0, 13],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 13 }
+ }
+ }, {
+ type: 'VariableDeclaration',
+ declarations: [{
+ type: 'VariableDeclarator',
+ id: {
+ type: 'Identifier',
+ name: 'x',
+ range: [18, 19],
+ loc: {
+ start: { line: 1, column: 18 },
+ end: { line: 1, column: 19 }
+ }
+ },
+ init: {
+ type: 'ObjectExpression',
+ properties: [{
+ type: 'Property',
+ key: {
+ type: 'Identifier',
+ name: 'i',
+ range: [28, 29],
+ loc: {
+ start: { line: 1, column: 28 },
+ end: { line: 1, column: 29 }
+ }
+ },
+ value: {
+ type: 'FunctionExpression',
+ id: null,
+ params: [{
+ type: 'Identifier',
+ name: 'x',
+ range: [30, 31],
+ loc: {
+ start: { line: 1, column: 30 },
+ end: { line: 1, column: 31 }
+ }
+ }],
+ defaults: [],
+ body: {
+ type: 'BlockStatement',
+ body: [],
+ range: [33, 35],
+ loc: {
+ start: { line: 1, column: 33 },
+ end: { line: 1, column: 35 }
+ }
+ },
+ rest: null,
+ generator: false,
+ expression: false,
+ range: [33, 35],
+ loc: {
+ start: { line: 1, column: 33 },
+ end: { line: 1, column: 35 }
+ }
+ },
+ kind: 'set',
+ range: [24, 35],
+ loc: {
+ start: { line: 1, column: 24 },
+ end: { line: 1, column: 35 }
+ }
+ }, {
+ type: 'Property',
+ key: {
+ type: 'Identifier',
+ name: 'i',
+ range: [37, 38],
+ loc: {
+ start: { line: 1, column: 37 },
+ end: { line: 1, column: 38 }
+ }
+ },
+ value: {
+ type: 'Literal',
+ value: 42,
+ raw: '42',
+ range: [40, 42],
+ loc: {
+ start: { line: 1, column: 40 },
+ end: { line: 1, column: 42 }
+ }
+ },
+ kind: 'init',
+ range: [37, 42],
+ loc: {
+ start: { line: 1, column: 37 },
+ end: { line: 1, column: 42 }
+ }
+ }],
+ range: [22, 44],
+ loc: {
+ start: { line: 1, column: 22 },
+ end: { line: 1, column: 44 }
+ }
+ },
+ range: [18, 44],
+ loc: {
+ start: { line: 1, column: 18 },
+ end: { line: 1, column: 44 }
+ }
+ }],
+ kind: 'var',
+ range: [14, 44],
+ loc: {
+ start: { line: 1, column: 14 },
+ end: { line: 1, column: 44 }
+ }
+ }],
+ range: [0, 44],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 44 }
+ },
+ errors: [{
+ index: 42,
+ lineNumber: 1,
+ column: 43,
+ message: 'Error: Line 1: Object literal may not have data and accessor property with the same name'
+ }]
+
+
+ },
+
+ '({ set s() { } })': {
+ type: 'Program',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'ObjectExpression',
+ properties: [{
+ type: 'Property',
+ key: {
+ type: 'Identifier',
+ name: 's',
+ range: [7, 8],
+ loc: {
+ start: { line: 1, column: 7 },
+ end: { line: 1, column: 8 }
+ }
+ },
+ value: {
+ type: 'FunctionExpression',
+ id: null,
+ params: [],
+ defaults: [],
+ body: {
+ type: 'BlockStatement',
+ body: [],
+ range: [11, 14],
+ loc: {
+ start: { line: 1, column: 11 },
+ end: { line: 1, column: 14 }
+ }
+ },
+ rest: null,
+ generator: false,
+ expression: false,
+ range: [11, 14],
+ loc: {
+ start: { line: 1, column: 11 },
+ end: { line: 1, column: 14 }
+ }
+ },
+ kind: 'set',
+ range: [3, 14],
+ loc: {
+ start: { line: 1, column: 3 },
+ end: { line: 1, column: 14 }
+ }
+ }],
+ range: [1, 16],
+ loc: {
+ start: { line: 1, column: 1 },
+ end: { line: 1, column: 16 }
+ }
+ },
+ range: [0, 17],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 17 }
+ }
+ }],
+ range: [0, 17],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 17 }
+ },
+ errors: [{
+ index: 9,
+ lineNumber: 1,
+ column: 10,
+ message: 'Error: Line 1: Unexpected token )'
+ }]
+ },
+
+ 'foo("bar") = baz': {
+ type: 'Program',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left: {
+ type: 'CallExpression',
+ callee: {
+ type: 'Identifier',
+ name: 'foo',
+ range: [0, 3],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 3 }
+ }
+ },
+ 'arguments': [{
+ type: 'Literal',
+ value: 'bar',
+ raw: '"bar"',
+ range: [4, 9],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 9 }
+ }
+ }],
+ range: [0, 10],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 10 }
+ }
+ },
+ right: {
+ type: 'Identifier',
+ name: 'baz',
+ range: [13, 16],
+ loc: {
+ start: { line: 1, column: 13 },
+ end: { line: 1, column: 16 }
+ }
+ },
+ range: [0, 16],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 16 }
+ }
+ },
+ range: [0, 16],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 16 }
+ }
+ }],
+ range: [0, 16],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 16 }
+ },
+ errors: [{
+ index: 10,
+ lineNumber: 1,
+ column: 11,
+ message: 'Error: Line 1: Invalid left-hand side in assignment'
+ }]
+ },
+
+ '1 = 2': {
+ type: 'Program',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left: {
+ type: 'Literal',
+ value: 1,
+ raw: '1',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ right: {
+ type: 'Literal',
+ value: 2,
+ raw: '2',
+ range: [4, 5],
+ loc: {
+ start: { line: 1, column: 4 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ range: [0, 5],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 5 }
+ }
+ },
+ range: [0, 5],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 5 }
+ }
+ }],
+ range: [0, 5],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 5 }
+ },
+ errors: [{
+ index: 1,
+ lineNumber: 1,
+ column: 2,
+ message: 'Error: Line 1: Invalid left-hand side in assignment'
+ }]
+ },
+
+ '3++': {
+ type: 'Program',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'UpdateExpression',
+ operator: '++',
+ argument: {
+ type: 'Literal',
+ value: 3,
+ raw: '3',
+ range: [0, 1],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 1 }
+ }
+ },
+ prefix: false,
+ range: [0, 3],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 3 }
+ }
+ },
+ range: [0, 3],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 3 }
+ }
+ }],
+ range: [0, 3],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 3 }
+ },
+ errors: [{
+ index: 1,
+ lineNumber: 1,
+ column: 2,
+ message: 'Error: Line 1: Invalid left-hand side in assignment'
+ }]
+ },
+
+ '--4': {
+ type: 'Program',
+ body: [{
+ type: 'ExpressionStatement',
+ expression: {
+ type: 'UpdateExpression',
+ operator: '--',
+ argument: {
+ type: 'Literal',
+ value: 4,
+ raw: '4',
+ range: [2, 3],
+ loc: {
+ start: { line: 1, column: 2 },
+ end: { line: 1, column: 3 }
+ }
+ },
+ prefix: true,
+ range: [0, 3],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 3 }
+ }
+ },
+ range: [0, 3],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 3 }
+ }
+ }],
+ range: [0, 3],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 3 }
+ },
+ errors: [{
+ index: 3,
+ lineNumber: 1,
+ column: 4,
+ message: 'Error: Line 1: Invalid left-hand side in assignment'
+ }]
+ },
+
+ 'for (5 in []) {}': {
+ type: 'Program',
+ body: [{
+ type: 'ForInStatement',
+ left: {
+ type: 'Literal',
+ value: 5,
+ raw: '5',
+ range: [5, 6],
+ loc: {
+ start: { line: 1, column: 5 },
+ end: { line: 1, column: 6 }
+ }
+ },
+ right: {
+ type: 'ArrayExpression',
+ elements: [],
+ range: [10, 12],
+ loc: {
+ start: { line: 1, column: 10 },
+ end: { line: 1, column: 12 }
+ }
+ },
+ body: {
+ type: 'BlockStatement',
+ body: [],
+ range: [14, 16],
+ loc: {
+ start: { line: 1, column: 14 },
+ end: { line: 1, column: 16 }
+ }
+ },
+ each: false,
+ range: [0, 16],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 16 }
+ }
+ }],
+ range: [0, 16],
+ loc: {
+ start: { line: 1, column: 0 },
+ end: { line: 1, column: 16 }
+ },
+ errors: [{
+ index: 6,
+ lineNumber: 1,
+ column: 7,
+ message: 'Error: Line 1: Invalid left-hand side in for-in'
+ }]
+ }
+
+
+ }
+};
+
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/package.json b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/package.json
new file mode 100644
index 0000000..112abb2
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/js-yaml/package.json
@@ -0,0 +1,77 @@
+{
+ "name": "js-yaml",
+ "version": "2.0.5",
+ "description": "YAML 1.2 parser and serializer",
+ "keywords": [
+ "yaml",
+ "parser",
+ "serializer",
+ "pyyaml"
+ ],
+ "homepage": "https://github.com/nodeca/js-yaml",
+ "author": {
+ "name": "Dervus Grim",
+ "email": "dervus@lavabit.com"
+ },
+ "contributors": [
+ {
+ "name": "Aleksey V Zapparov",
+ "email": "ixti@member.fsf.org",
+ "url": "http://www.ixti.net/"
+ },
+ {
+ "name": "Martin Grenfell",
+ "email": "martin.grenfell@gmail.com",
+ "url": "http://got-ravings.blogspot.com"
+ }
+ ],
+ "bugs": {
+ "url": "https://github.com/nodeca/js-yaml/issues"
+ },
+ "license": {
+ "type": "MIT",
+ "url": "https://github.com/nodeca/js-yaml/blob/master/LICENSE"
+ },
+ "repository": {
+ "type": "git",
+ "url": "git://github.com/nodeca/js-yaml.git"
+ },
+ "main": "./index.js",
+ "bin": {
+ "js-yaml": "bin/js-yaml.js"
+ },
+ "scripts": {
+ "test": "make test"
+ },
+ "dependencies": {
+ "argparse": "~ 0.1.11",
+ "esprima": "~ 1.0.2"
+ },
+ "devDependencies": {
+ "mocha": "*"
+ },
+ "engines": {
+ "node": ">= 0.6.0"
+ },
+ "_id": "js-yaml@2.0.5",
+ "dist": {
+ "shasum": "a25ae6509999e97df278c6719da11bd0687743a8",
+ "tarball": "http://registry.npmjs.org/js-yaml/-/js-yaml-2.0.5.tgz"
+ },
+ "_from": "js-yaml@~2.0.5",
+ "_resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-2.0.5.tgz",
+ "_npmVersion": "1.2.14",
+ "_npmUser": {
+ "name": "vitaly",
+ "email": "vitaly@rcdesign.ru"
+ },
+ "maintainers": [
+ {
+ "name": "vitaly",
+ "email": "vitaly@rcdesign.ru"
+ }
+ ],
+ "directories": {},
+ "_shasum": "a25ae6509999e97df278c6719da11bd0687743a8",
+ "readme": "ERROR: No README data found!"
+}
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/lodash/README.md b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/lodash/README.md
new file mode 100644
index 0000000..55dae80
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/lodash/README.md
@@ -0,0 +1,140 @@
+# Lo-Dash v0.9.2
+
+A utility library delivering consistency, [customization](http://lodash.com/custom-builds), [performance](http://lodash.com/benchmarks), & [extras](http://lodash.com/#features).
+
+## Download
+
+ * [Development build](https://raw.github.com/lodash/lodash/0.9.2/lodash.js)
+ * [Production build](https://raw.github.com/lodash/lodash/0.9.2/lodash.min.js)
+ * [Underscore build](https://raw.github.com/lodash/lodash/0.9.2/lodash.underscore.min.js) tailored for projects already using Underscore
+ * CDN copies of ≤ v0.9.2’s [Production](http://cdnjs.cloudflare.com/ajax/libs/lodash.js/0.9.2/lodash.min.js), [Underscore](http://cdnjs.cloudflare.com/ajax/libs/lodash.js/0.9.2/lodash.underscore.min.js), and [Development](http://cdnjs.cloudflare.com/ajax/libs/lodash.js/0.9.2/lodash.js) builds are available on [cdnjs](http://cdnjs.com/) thanks to [CloudFlare](http://www.cloudflare.com/)
+ * For optimal file size, [create a custom build](http://lodash.com/custom-builds) with only the features you need
+
+## Dive in
+
+We’ve got [API docs](http://lodash.com/docs), [benchmarks](http://lodash.com/benchmarks), and [unit tests](http://lodash.com/tests).
+
+Create your own benchmarks at [jsPerf](http://jsperf.com), or [search](http://jsperf.com/search?q=lodash) for existing ones.
+
+For a list of upcoming features, check out our [roadmap](https://github.com/lodash/lodash/wiki/Roadmap).
+
+## Screencasts
+
+For more information check out these screencasts over Lo-Dash:
+
+ * [Introducing Lo-Dash](https://vimeo.com/44154599)
+ * [Lo-Dash optimizations and custom builds](https://vimeo.com/44154601)
+ * [Lo-Dash’s origin and why it’s a better utility belt](https://vimeo.com/44154600)
+ * [Unit testing in Lo-Dash](https://vimeo.com/45865290)
+ * [Lo-Dash’s approach to native method use](https://vimeo.com/48576012)
+
+## Features
+
+ * AMD loader support ([RequireJS](http://requirejs.org/), [curl.js](https://github.com/cujojs/curl), etc.)
+ * [_.clone](http://lodash.com/docs#clone) supports *“deep”* cloning
+ * [_.contains](http://lodash.com/docs#contains) accepts a `fromIndex` argument
+ * [_.forEach](http://lodash.com/docs#forEach) is chainable and supports exiting iteration early
+ * [_.forIn](http://lodash.com/docs#forIn) for iterating over an object’s own and inherited properties
+ * [_.forOwn](http://lodash.com/docs#forOwn) for iterating over an object’s own properties
+ * [_.isPlainObject](http://lodash.com/docs#isPlainObject) checks if values are created by the `Object` constructor
+ * [_.lateBind](http://lodash.com/docs#lateBind) for late binding
+ * [_.merge](http://lodash.com/docs#merge) for a *“deep”* [_.extend](http://lodash.com/docs#extend)
+ * [_.partial](http://lodash.com/docs#partial) for partial application without `this` binding
+ * [_.pick](http://lodash.com/docs#pick) and [_.omit](http://lodash.com/docs#omit) accepts `callback` and `thisArg` arguments
+ * [_.template](http://lodash.com/docs#template) supports [ES6 delimiters](http://people.mozilla.org/~jorendorff/es6-draft.html#sec-7.8.6) and utilizes [sourceURLs](http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl) for easier debugging
+ * [_.contains](http://lodash.com/docs#contains), [_.size](http://lodash.com/docs#size), [_.toArray](http://lodash.com/docs#toArray),
+ [and more…](http://lodash.com/docs "_.countBy, _.every, _.filter, _.find, _.forEach, _.groupBy, _.invoke, _.map, _.max, _.min, _.pluck, _.reduce, _.reduceRight, _.reject, _.shuffle, _.some, _.sortBy, _.where") accept strings
+
+## Support
+
+Lo-Dash has been tested in at least Chrome 5~23, Firefox 1~16, IE 6-10, Opera 9.25-12, Safari 3-6, Node.js 0.4.8-0.8.14, Narwhal 0.3.2, RingoJS 0.8, and Rhino 1.7RC5.
+
+## Installation and usage
+
+In browsers:
+
+```html
+
+```
+
+Using [npm](http://npmjs.org/):
+
+```bash
+npm install lodash
+
+npm install -g lodash
+npm link lodash
+```
+
+In [Node.js](http://nodejs.org/) and [RingoJS v0.8.0+](http://ringojs.org/):
+
+```js
+var _ = require('lodash');
+```
+
+**Note:** If Lo-Dash is installed globally, [run `npm link lodash`](http://blog.nodejs.org/2011/03/23/npm-1-0-global-vs-local-installation/) in your project’s root directory before requiring it.
+
+In [RingoJS v0.7.0-](http://ringojs.org/):
+
+```js
+var _ = require('lodash')._;
+```
+
+In [Rhino](http://www.mozilla.org/rhino/):
+
+```js
+load('lodash.js');
+```
+
+In an AMD loader like [RequireJS](http://requirejs.org/):
+
+```js
+require({
+ 'paths': {
+ 'underscore': 'path/to/lodash'
+ }
+},
+['underscore'], function(_) {
+ console.log(_.VERSION);
+});
+```
+
+## Resolved Underscore.js issues
+
+ * Allow iteration of objects with a `length` property [[#799](https://github.com/documentcloud/underscore/pull/799), [test](https://github.com/lodash/lodash/blob/0.9.2/test/test.js#L545-551)]
+ * Fix cross-browser object iteration bugs [[#60](https://github.com/documentcloud/underscore/issues/60), [#376](https://github.com/documentcloud/underscore/issues/376), [test](https://github.com/lodash/lodash/blob/0.9.2/test/test.js#L558-582)]
+ * Methods should work on pages with incorrectly shimmed native methods [[#7](https://github.com/documentcloud/underscore/issues/7), [#742](https://github.com/documentcloud/underscore/issues/742), [test](https://github.com/lodash/lodash/blob/0.9.2/test/test.js#L140-146)]
+ * `_.isEmpty` should support jQuery/MooTools DOM query collections [[#690](https://github.com/documentcloud/underscore/pull/690), [test](https://github.com/lodash/lodash/blob/0.9.2/test/test.js#L747-752)]
+ * `_.isObject` should avoid V8 bug [#2291](http://code.google.com/p/8/issues/detail?id=2291) [[#605](https://github.com/documentcloud/underscore/issues/605), [test](https://github.com/lodash/lodash/blob/0.9.2/test/test.js#L828-840)]
+ * `_.keys` should work with `arguments` objects cross-browser [[#396](https://github.com/documentcloud/underscore/issues/396), [test](https://github.com/lodash/lodash/blob/0.9.2/test/test.js#L921-923)]
+ * `_.range` should coerce arguments to numbers [[#634](https://github.com/documentcloud/underscore/issues/634), [#683](https://github.com/documentcloud/underscore/issues/683), [test](https://github.com/lodash/lodash/blob/0.9.2/test/test.js#L1337-1340)]
+
+## Release Notes
+
+### v0.9.2
+
+ * Added `fromIndex` argument to `_.contains`
+ * Added `moduleId` build option
+ * Added Closure Compiler *“simple”* optimizations to the build process
+ * Added support for strings in `_.max` and `_.min`
+ * Added support for ES6 template delimiters to `_.template`
+ * Ensured re-minification of Lo-Dash by third parties avoids Closure Compiler bugs
+ * Optimized `_.every`, `_.find`, `_.some`, and `_.uniq`
+
+The full changelog is available [here](https://github.com/lodash/lodash/wiki/Changelog).
+
+## BestieJS
+
+Lo-Dash is part of the [BestieJS](https://github.com/bestiejs) *“Best in Class”* module collection. This means we promote solid browser/environment support, ES5 precedents, unit testing, and plenty of documentation.
+
+## Author
+
+| [](http://twitter.com/jdalton "Follow @jdalton on Twitter") |
+|---|
+| [John-David Dalton](http://allyoucanleet.com/) |
+
+## Contributors
+
+| [](http://twitter.com/blainebublitz "Follow @BlaineBublitz on Twitter") | [](https://twitter.com/kitcambridge "Follow @kitcambridge on Twitter") | [](http://twitter.com/mathias "Follow @mathias on Twitter") |
+|---|---|---|
+| [Blaine Bublitz](http://iceddev.com/) | [Kit Cambridge](http://kitcambridge.github.io/) | [Mathias Bynens](http://mathiasbynens.be/) |
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/lodash/lodash.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/lodash/lodash.js
new file mode 100644
index 0000000..9eae931
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/lodash/lodash.js
@@ -0,0 +1,4258 @@
+/*!
+ * Lo-Dash v0.9.2
+ * (c) 2012 John-David Dalton
+ * Based on Underscore.js 1.4.2
+ * (c) 2009-2012 Jeremy Ashkenas, DocumentCloud Inc.
+ * Available under MIT license
+ */
+;(function(window, undefined) {
+
+ /** Detect free variable `exports` */
+ var freeExports = typeof exports == 'object' && exports;
+
+ /** Detect free variable `global` and use it as `window` */
+ var freeGlobal = typeof global == 'object' && global;
+ if (freeGlobal.global === freeGlobal) {
+ window = freeGlobal;
+ }
+
+ /** Used for array and object method references */
+ var arrayRef = [],
+ // avoid a Closure Compiler bug by creatively creating an object
+ objectRef = new function(){};
+
+ /** Used to generate unique IDs */
+ var idCounter = 0;
+
+ /** Used internally to indicate various things */
+ var indicatorObject = objectRef;
+
+ /** Used by `cachedContains` as the default size when optimizations are enabled for large arrays */
+ var largeArraySize = 30;
+
+ /** Used to restore the original `_` reference in `noConflict` */
+ var oldDash = window._;
+
+ /** Used to detect template delimiter values that require a with-statement */
+ var reComplexDelimiter = /[-?+=!~*%&^<>|{(\/]|\[\D|\b(?:delete|in|instanceof|new|typeof|void)\b/;
+
+ /** Used to match HTML entities */
+ var reEscapedHtml = /&(?:amp|lt|gt|quot|#x27);/g;
+
+ /** Used to match empty string literals in compiled template source */
+ var reEmptyStringLeading = /\b__p \+= '';/g,
+ reEmptyStringMiddle = /\b(__p \+=) '' \+/g,
+ reEmptyStringTrailing = /(__e\(.*?\)|\b__t\)) \+\n'';/g;
+
+ /** Used to match regexp flags from their coerced string values */
+ var reFlags = /\w*$/;
+
+ /** Used to insert the data object variable into compiled template source */
+ var reInsertVariable = /(?:__e|__t = )\(\s*(?![\d\s"']|this\.)/g;
+
+ /** Used to detect if a method is native */
+ var reNative = RegExp('^' +
+ (objectRef.valueOf + '')
+ .replace(/[.*+?^=!:${}()|[\]\/\\]/g, '\\$&')
+ .replace(/valueOf|for [^\]]+/g, '.+?') + '$'
+ );
+
+ /**
+ * Used to match ES6 template delimiters
+ * http://people.mozilla.org/~jorendorff/es6-draft.html#sec-7.8.6
+ */
+ var reEsTemplate = /\$\{((?:(?=\\?)\\?[\s\S])*?)}/g;
+
+ /** Used to match "interpolate" template delimiters */
+ var reInterpolate = /<%=([\s\S]+?)%>/g;
+
+ /** Used to ensure capturing order of template delimiters */
+ var reNoMatch = /($^)/;
+
+ /** Used to match HTML characters */
+ var reUnescapedHtml = /[&<>"']/g;
+
+ /** Used to match unescaped characters in compiled string literals */
+ var reUnescapedString = /['\n\r\t\u2028\u2029\\]/g;
+
+ /** Used to fix the JScript [[DontEnum]] bug */
+ var shadowed = [
+ 'constructor', 'hasOwnProperty', 'isPrototypeOf', 'propertyIsEnumerable',
+ 'toLocaleString', 'toString', 'valueOf'
+ ];
+
+ /** Used to make template sourceURLs easier to identify */
+ var templateCounter = 0;
+
+ /** Native method shortcuts */
+ var ceil = Math.ceil,
+ concat = arrayRef.concat,
+ floor = Math.floor,
+ getPrototypeOf = reNative.test(getPrototypeOf = Object.getPrototypeOf) && getPrototypeOf,
+ hasOwnProperty = objectRef.hasOwnProperty,
+ push = arrayRef.push,
+ propertyIsEnumerable = objectRef.propertyIsEnumerable,
+ slice = arrayRef.slice,
+ toString = objectRef.toString;
+
+ /* Native method shortcuts for methods with the same name as other `lodash` methods */
+ var nativeBind = reNative.test(nativeBind = slice.bind) && nativeBind,
+ nativeIsArray = reNative.test(nativeIsArray = Array.isArray) && nativeIsArray,
+ nativeIsFinite = window.isFinite,
+ nativeIsNaN = window.isNaN,
+ nativeKeys = reNative.test(nativeKeys = Object.keys) && nativeKeys,
+ nativeMax = Math.max,
+ nativeMin = Math.min,
+ nativeRandom = Math.random;
+
+ /** `Object#toString` result shortcuts */
+ var argsClass = '[object Arguments]',
+ arrayClass = '[object Array]',
+ boolClass = '[object Boolean]',
+ dateClass = '[object Date]',
+ funcClass = '[object Function]',
+ numberClass = '[object Number]',
+ objectClass = '[object Object]',
+ regexpClass = '[object RegExp]',
+ stringClass = '[object String]';
+
+ /**
+ * Detect the JScript [[DontEnum]] bug:
+ *
+ * In IE < 9 an objects own properties, shadowing non-enumerable ones, are
+ * made non-enumerable as well.
+ */
+ var hasDontEnumBug;
+
+ /** Detect if own properties are iterated after inherited properties (IE < 9) */
+ var iteratesOwnLast;
+
+ /**
+ * Detect if `Array#shift` and `Array#splice` augment array-like objects
+ * incorrectly:
+ *
+ * Firefox < 10, IE compatibility mode, and IE < 9 have buggy Array `shift()`
+ * and `splice()` functions that fail to remove the last element, `value[0]`,
+ * of array-like objects even though the `length` property is set to `0`.
+ * The `shift()` method is buggy in IE 8 compatibility mode, while `splice()`
+ * is buggy regardless of mode in IE < 9 and buggy in compatibility mode in IE 9.
+ */
+ var hasObjectSpliceBug = (hasObjectSpliceBug = { '0': 1, 'length': 1 },
+ arrayRef.splice.call(hasObjectSpliceBug, 0, 1), hasObjectSpliceBug[0]);
+
+ /** Detect if an `arguments` object's indexes are non-enumerable (IE < 9) */
+ var noArgsEnum = true;
+
+ (function() {
+ var props = [];
+ function ctor() { this.x = 1; }
+ ctor.prototype = { 'valueOf': 1, 'y': 1 };
+ for (var prop in new ctor) { props.push(prop); }
+ for (prop in arguments) { noArgsEnum = !prop; }
+
+ hasDontEnumBug = !/valueOf/.test(props);
+ iteratesOwnLast = props[0] != 'x';
+ }(1));
+
+ /** Detect if an `arguments` object's [[Class]] is unresolvable (Firefox < 4, IE < 9) */
+ var noArgsClass = !isArguments(arguments);
+
+ /** Detect if `Array#slice` cannot be used to convert strings to arrays (Opera < 10.52) */
+ var noArraySliceOnStrings = slice.call('x')[0] != 'x';
+
+ /**
+ * Detect lack of support for accessing string characters by index:
+ *
+ * IE < 8 can't access characters by index and IE 8 can only access
+ * characters by index on string literals.
+ */
+ var noCharByIndex = ('x'[0] + Object('x')[0]) != 'xx';
+
+ /**
+ * Detect if a node's [[Class]] is unresolvable (IE < 9)
+ * and that the JS engine won't error when attempting to coerce an object to
+ * a string without a `toString` property value of `typeof` "function".
+ */
+ try {
+ var noNodeClass = ({ 'toString': 0 } + '', toString.call(window.document || 0) == objectClass);
+ } catch(e) { }
+
+ /* Detect if `Function#bind` exists and is inferred to be fast (all but V8) */
+ var isBindFast = nativeBind && /\n|Opera/.test(nativeBind + toString.call(window.opera));
+
+ /* Detect if `Object.keys` exists and is inferred to be fast (IE, Opera, V8) */
+ var isKeysFast = nativeKeys && /^.+$|true/.test(nativeKeys + !!window.attachEvent);
+
+ /**
+ * Detect if sourceURL syntax is usable without erroring:
+ *
+ * The JS engine in Adobe products, like InDesign, will throw a syntax error
+ * when it encounters a single line comment beginning with the `@` symbol.
+ *
+ * The JS engine in Narwhal will generate the function `function anonymous(){//}`
+ * and throw a syntax error.
+ *
+ * Avoid comments beginning `@` symbols in IE because they are part of its
+ * non-standard conditional compilation support.
+ * http://msdn.microsoft.com/en-us/library/121hztk3(v=vs.94).aspx
+ */
+ try {
+ var useSourceURL = (Function('//@')(), !window.attachEvent);
+ } catch(e) { }
+
+ /** Used to identify object classifications that `_.clone` supports */
+ var cloneableClasses = {};
+ cloneableClasses[argsClass] = cloneableClasses[funcClass] = false;
+ cloneableClasses[arrayClass] = cloneableClasses[boolClass] = cloneableClasses[dateClass] =
+ cloneableClasses[numberClass] = cloneableClasses[objectClass] = cloneableClasses[regexpClass] =
+ cloneableClasses[stringClass] = true;
+
+ /** Used to determine if values are of the language type Object */
+ var objectTypes = {
+ 'boolean': false,
+ 'function': true,
+ 'object': true,
+ 'number': false,
+ 'string': false,
+ 'undefined': false
+ };
+
+ /** Used to escape characters for inclusion in compiled string literals */
+ var stringEscapes = {
+ '\\': '\\',
+ "'": "'",
+ '\n': 'n',
+ '\r': 'r',
+ '\t': 't',
+ '\u2028': 'u2028',
+ '\u2029': 'u2029'
+ };
+
+ /*--------------------------------------------------------------------------*/
+
+ /**
+ * The `lodash` function.
+ *
+ * @name _
+ * @constructor
+ * @category Chaining
+ * @param {Mixed} value The value to wrap in a `lodash` instance.
+ * @returns {Object} Returns a `lodash` instance.
+ */
+ function lodash(value) {
+ // exit early if already wrapped
+ if (value && value.__wrapped__) {
+ return value;
+ }
+ // allow invoking `lodash` without the `new` operator
+ if (!(this instanceof lodash)) {
+ return new lodash(value);
+ }
+ this.__wrapped__ = value;
+ }
+
+ /**
+ * By default, the template delimiters used by Lo-Dash are similar to those in
+ * embedded Ruby (ERB). Change the following template settings to use alternative
+ * delimiters.
+ *
+ * @static
+ * @memberOf _
+ * @type Object
+ */
+ lodash.templateSettings = {
+
+ /**
+ * Used to detect `data` property values to be HTML-escaped.
+ *
+ * @static
+ * @memberOf _.templateSettings
+ * @type RegExp
+ */
+ 'escape': /<%-([\s\S]+?)%>/g,
+
+ /**
+ * Used to detect code to be evaluated.
+ *
+ * @static
+ * @memberOf _.templateSettings
+ * @type RegExp
+ */
+ 'evaluate': /<%([\s\S]+?)%>/g,
+
+ /**
+ * Used to detect `data` property values to inject.
+ *
+ * @static
+ * @memberOf _.templateSettings
+ * @type RegExp
+ */
+ 'interpolate': reInterpolate,
+
+ /**
+ * Used to reference the data object in the template text.
+ *
+ * @static
+ * @memberOf _.templateSettings
+ * @type String
+ */
+ 'variable': ''
+ };
+
+ /*--------------------------------------------------------------------------*/
+
+ /**
+ * The template used to create iterator functions.
+ *
+ * @private
+ * @param {Obect} data The data object used to populate the text.
+ * @returns {String} Returns the interpolated text.
+ */
+ var iteratorTemplate = template(
+ // conditional strict mode
+ '<% if (obj.useStrict) { %>\'use strict\';\n<% } %>' +
+
+ // the `iteratee` may be reassigned by the `top` snippet
+ 'var index, value, iteratee = <%= firstArg %>, ' +
+ // assign the `result` variable an initial value
+ 'result = <%= firstArg %>;\n' +
+ // exit early if the first argument is falsey
+ 'if (!<%= firstArg %>) return result;\n' +
+ // add code before the iteration branches
+ '<%= top %>;\n' +
+
+ // array-like iteration:
+ '<% if (arrayLoop) { %>' +
+ 'var length = iteratee.length; index = -1;\n' +
+ 'if (typeof length == \'number\') {' +
+
+ // add support for accessing string characters by index if needed
+ ' <% if (noCharByIndex) { %>\n' +
+ ' if (isString(iteratee)) {\n' +
+ ' iteratee = iteratee.split(\'\')\n' +
+ ' }' +
+ ' <% } %>\n' +
+
+ // iterate over the array-like value
+ ' while (++index < length) {\n' +
+ ' value = iteratee[index];\n' +
+ ' <%= arrayLoop %>\n' +
+ ' }\n' +
+ '}\n' +
+ 'else {' +
+
+ // object iteration:
+ // add support for iterating over `arguments` objects if needed
+ ' <% } else if (noArgsEnum) { %>\n' +
+ ' var length = iteratee.length; index = -1;\n' +
+ ' if (length && isArguments(iteratee)) {\n' +
+ ' while (++index < length) {\n' +
+ ' value = iteratee[index += \'\'];\n' +
+ ' <%= objectLoop %>\n' +
+ ' }\n' +
+ ' } else {' +
+ ' <% } %>' +
+
+ // Firefox < 3.6, Opera > 9.50 - Opera < 11.60, and Safari < 5.1
+ // (if the prototype or a property on the prototype has been set)
+ // incorrectly sets a function's `prototype` property [[Enumerable]]
+ // value to `true`. Because of this Lo-Dash standardizes on skipping
+ // the the `prototype` property of functions regardless of its
+ // [[Enumerable]] value.
+ ' <% if (!hasDontEnumBug) { %>\n' +
+ ' var skipProto = typeof iteratee == \'function\' && \n' +
+ ' propertyIsEnumerable.call(iteratee, \'prototype\');\n' +
+ ' <% } %>' +
+
+ // iterate own properties using `Object.keys` if it's fast
+ ' <% if (isKeysFast && useHas) { %>\n' +
+ ' var ownIndex = -1,\n' +
+ ' ownProps = objectTypes[typeof iteratee] ? nativeKeys(iteratee) : [],\n' +
+ ' length = ownProps.length;\n\n' +
+ ' while (++ownIndex < length) {\n' +
+ ' index = ownProps[ownIndex];\n' +
+ ' <% if (!hasDontEnumBug) { %>if (!(skipProto && index == \'prototype\')) {\n <% } %>' +
+ ' value = iteratee[index];\n' +
+ ' <%= objectLoop %>\n' +
+ ' <% if (!hasDontEnumBug) { %>}\n<% } %>' +
+ ' }' +
+
+ // else using a for-in loop
+ ' <% } else { %>\n' +
+ ' for (index in iteratee) {<%' +
+ ' if (!hasDontEnumBug || useHas) { %>\n if (<%' +
+ ' if (!hasDontEnumBug) { %>!(skipProto && index == \'prototype\')<% }' +
+ ' if (!hasDontEnumBug && useHas) { %> && <% }' +
+ ' if (useHas) { %>hasOwnProperty.call(iteratee, index)<% }' +
+ ' %>) {' +
+ ' <% } %>\n' +
+ ' value = iteratee[index];\n' +
+ ' <%= objectLoop %>;' +
+ ' <% if (!hasDontEnumBug || useHas) { %>\n }<% } %>\n' +
+ ' }' +
+ ' <% } %>' +
+
+ // Because IE < 9 can't set the `[[Enumerable]]` attribute of an
+ // existing property and the `constructor` property of a prototype
+ // defaults to non-enumerable, Lo-Dash skips the `constructor`
+ // property when it infers it's iterating over a `prototype` object.
+ ' <% if (hasDontEnumBug) { %>\n\n' +
+ ' var ctor = iteratee.constructor;\n' +
+ ' <% for (var k = 0; k < 7; k++) { %>\n' +
+ ' index = \'<%= shadowed[k] %>\';\n' +
+ ' if (<%' +
+ ' if (shadowed[k] == \'constructor\') {' +
+ ' %>!(ctor && ctor.prototype === iteratee) && <%' +
+ ' } %>hasOwnProperty.call(iteratee, index)) {\n' +
+ ' value = iteratee[index];\n' +
+ ' <%= objectLoop %>\n' +
+ ' }' +
+ ' <% } %>' +
+ ' <% } %>' +
+ ' <% if (arrayLoop || noArgsEnum) { %>\n}<% } %>\n' +
+
+ // add code to the bottom of the iteration function
+ '<%= bottom %>;\n' +
+ // finally, return the `result`
+ 'return result'
+ );
+
+ /**
+ * Reusable iterator options shared by `forEach`, `forIn`, and `forOwn`.
+ */
+ var forEachIteratorOptions = {
+ 'args': 'collection, callback, thisArg',
+ 'top': 'callback = createCallback(callback, thisArg)',
+ 'arrayLoop': 'if (callback(value, index, collection) === false) return result',
+ 'objectLoop': 'if (callback(value, index, collection) === false) return result'
+ };
+
+ /** Reusable iterator options for `defaults`, and `extend` */
+ var extendIteratorOptions = {
+ 'useHas': false,
+ 'args': 'object',
+ 'top':
+ 'for (var argsIndex = 1, argsLength = arguments.length; argsIndex < argsLength; argsIndex++) {\n' +
+ ' if (iteratee = arguments[argsIndex]) {',
+ 'objectLoop': 'result[index] = value',
+ 'bottom': ' }\n}'
+ };
+
+ /** Reusable iterator options for `forIn` and `forOwn` */
+ var forOwnIteratorOptions = {
+ 'arrayLoop': null
+ };
+
+ /*--------------------------------------------------------------------------*/
+
+ /**
+ * Creates a function optimized to search large arrays for a given `value`,
+ * starting at `fromIndex`, using strict equality for comparisons, i.e. `===`.
+ *
+ * @private
+ * @param {Array} array The array to search.
+ * @param {Mixed} value The value to search for.
+ * @param {Number} [fromIndex=0] The index to search from.
+ * @param {Number} [largeSize=30] The length at which an array is considered large.
+ * @returns {Boolean} Returns `true` if `value` is found, else `false`.
+ */
+ function cachedContains(array, fromIndex, largeSize) {
+ fromIndex || (fromIndex = 0);
+
+ var length = array.length,
+ isLarge = (length - fromIndex) >= (largeSize || largeArraySize);
+
+ if (isLarge) {
+ var cache = {},
+ index = fromIndex - 1;
+
+ while (++index < length) {
+ // manually coerce `value` to a string because `hasOwnProperty`, in some
+ // older versions of Firefox, coerces objects incorrectly
+ var key = array[index] + '';
+ (hasOwnProperty.call(cache, key) ? cache[key] : (cache[key] = [])).push(array[index]);
+ }
+ }
+ return function(value) {
+ if (isLarge) {
+ var key = value + '';
+ return hasOwnProperty.call(cache, key) && indexOf(cache[key], value) > -1;
+ }
+ return indexOf(array, value, fromIndex) > -1;
+ }
+ }
+
+ /**
+ * Used by `_.max` and `_.min` as the default `callback` when a given
+ * `collection` is a string value.
+ *
+ * @private
+ * @param {String} value The character to inspect.
+ * @returns {Number} Returns the code unit of given character.
+ */
+ function charAtCallback(value) {
+ return value.charCodeAt(0);
+ }
+
+ /**
+ * Used by `sortBy` to compare transformed `collection` values, stable sorting
+ * them in ascending order.
+ *
+ * @private
+ * @param {Object} a The object to compare to `b`.
+ * @param {Object} b The object to compare to `a`.
+ * @returns {Number} Returns the sort order indicator of `1` or `-1`.
+ */
+ function compareAscending(a, b) {
+ var ai = a.index,
+ bi = b.index;
+
+ a = a.criteria;
+ b = b.criteria;
+
+ // ensure a stable sort in V8 and other engines
+ // http://code.google.com/p/v8/issues/detail?id=90
+ if (a !== b) {
+ if (a > b || a === undefined) {
+ return 1;
+ }
+ if (a < b || b === undefined) {
+ return -1;
+ }
+ }
+ return ai < bi ? -1 : 1;
+ }
+
+ /**
+ * Creates a function that, when called, invokes `func` with the `this`
+ * binding of `thisArg` and prepends any `partailArgs` to the arguments passed
+ * to the bound function.
+ *
+ * @private
+ * @param {Function|String} func The function to bind or the method name.
+ * @param {Mixed} [thisArg] The `this` binding of `func`.
+ * @param {Array} partialArgs An array of arguments to be partially applied.
+ * @returns {Function} Returns the new bound function.
+ */
+ function createBound(func, thisArg, partialArgs) {
+ var isFunc = isFunction(func),
+ isPartial = !partialArgs,
+ methodName = func;
+
+ // juggle arguments
+ if (isPartial) {
+ partialArgs = thisArg;
+ }
+
+ function bound() {
+ // `Function#bind` spec
+ // http://es5.github.com/#x15.3.4.5
+ var args = arguments,
+ thisBinding = isPartial ? this : thisArg;
+
+ if (!isFunc) {
+ func = thisArg[methodName];
+ }
+ if (partialArgs.length) {
+ args = args.length
+ ? partialArgs.concat(slice.call(args))
+ : partialArgs;
+ }
+ if (this instanceof bound) {
+ // get `func` instance if `bound` is invoked in a `new` expression
+ noop.prototype = func.prototype;
+ thisBinding = new noop;
+
+ // mimic the constructor's `return` behavior
+ // http://es5.github.com/#x13.2.2
+ var result = func.apply(thisBinding, args);
+ return isObject(result)
+ ? result
+ : thisBinding
+ }
+ return func.apply(thisBinding, args);
+ }
+ return bound;
+ }
+
+ /**
+ * Produces an iteration callback bound to an optional `thisArg`. If `func` is
+ * a property name, the callback will return the property value for a given element.
+ *
+ * @private
+ * @param {Function|String} [func=identity|property] The function called per
+ * iteration or property name to query.
+ * @param {Mixed} [thisArg] The `this` binding of `callback`.
+ * @returns {Function} Returns a callback function.
+ */
+ function createCallback(func, thisArg) {
+ if (!func) {
+ return identity;
+ }
+ if (typeof func != 'function') {
+ return function(object) {
+ return object[func];
+ };
+ }
+ if (thisArg !== undefined) {
+ return function(value, index, object) {
+ return func.call(thisArg, value, index, object);
+ };
+ }
+ return func;
+ }
+
+ /**
+ * Creates compiled iteration functions.
+ *
+ * @private
+ * @param {Object} [options1, options2, ...] The compile options object(s).
+ * useHas - A boolean to specify using `hasOwnProperty` checks in the object loop.
+ * args - A string of comma separated arguments the iteration function will accept.
+ * top - A string of code to execute before the iteration branches.
+ * arrayLoop - A string of code to execute in the array loop.
+ * objectLoop - A string of code to execute in the object loop.
+ * bottom - A string of code to execute after the iteration branches.
+ *
+ * @returns {Function} Returns the compiled function.
+ */
+ function createIterator() {
+ var data = {
+ 'arrayLoop': '',
+ 'bottom': '',
+ 'hasDontEnumBug': hasDontEnumBug,
+ 'isKeysFast': isKeysFast,
+ 'objectLoop': '',
+ 'noArgsEnum': noArgsEnum,
+ 'noCharByIndex': noCharByIndex,
+ 'shadowed': shadowed,
+ 'top': '',
+ 'useHas': true
+ };
+
+ // merge options into a template data object
+ for (var object, index = 0; object = arguments[index]; index++) {
+ for (var key in object) {
+ data[key] = object[key];
+ }
+ }
+ var args = data.args;
+ data.firstArg = /^[^,]+/.exec(args)[0];
+
+ // create the function factory
+ var factory = Function(
+ 'createCallback, hasOwnProperty, isArguments, isString, objectTypes, ' +
+ 'nativeKeys, propertyIsEnumerable',
+ 'return function(' + args + ') {\n' + iteratorTemplate(data) + '\n}'
+ );
+ // return the compiled function
+ return factory(
+ createCallback, hasOwnProperty, isArguments, isString, objectTypes,
+ nativeKeys, propertyIsEnumerable
+ );
+ }
+
+ /**
+ * Used by `template` to escape characters for inclusion in compiled
+ * string literals.
+ *
+ * @private
+ * @param {String} match The matched character to escape.
+ * @returns {String} Returns the escaped character.
+ */
+ function escapeStringChar(match) {
+ return '\\' + stringEscapes[match];
+ }
+
+ /**
+ * Used by `escape` to convert characters to HTML entities.
+ *
+ * @private
+ * @param {String} match The matched character to escape.
+ * @returns {String} Returns the escaped character.
+ */
+ function escapeHtmlChar(match) {
+ return htmlEscapes[match];
+ }
+
+ /**
+ * A no-operation function.
+ *
+ * @private
+ */
+ function noop() {
+ // no operation performed
+ }
+
+ /**
+ * Used by `unescape` to convert HTML entities to characters.
+ *
+ * @private
+ * @param {String} match The matched character to unescape.
+ * @returns {String} Returns the unescaped character.
+ */
+ function unescapeHtmlChar(match) {
+ return htmlUnescapes[match];
+ }
+
+ /*--------------------------------------------------------------------------*/
+
+ /**
+ * Checks if `value` is an `arguments` object.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Mixed} value The value to check.
+ * @returns {Boolean} Returns `true` if the `value` is an `arguments` object, else `false`.
+ * @example
+ *
+ * (function() { return _.isArguments(arguments); })(1, 2, 3);
+ * // => true
+ *
+ * _.isArguments([1, 2, 3]);
+ * // => false
+ */
+ function isArguments(value) {
+ return toString.call(value) == argsClass;
+ }
+ // fallback for browsers that can't detect `arguments` objects by [[Class]]
+ if (noArgsClass) {
+ isArguments = function(value) {
+ return value ? hasOwnProperty.call(value, 'callee') : false;
+ };
+ }
+
+ /**
+ * Iterates over `object`'s own and inherited enumerable properties, executing
+ * the `callback` for each property. The `callback` is bound to `thisArg` and
+ * invoked with three arguments; (value, key, object). Callbacks may exit iteration
+ * early by explicitly returning `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Object} object The object to iterate over.
+ * @param {Function} callback The function called per iteration.
+ * @param {Mixed} [thisArg] The `this` binding of `callback`.
+ * @returns {Object} Returns `object`.
+ * @example
+ *
+ * function Dog(name) {
+ * this.name = name;
+ * }
+ *
+ * Dog.prototype.bark = function() {
+ * alert('Woof, woof!');
+ * };
+ *
+ * _.forIn(new Dog('Dagny'), function(value, key) {
+ * alert(key);
+ * });
+ * // => alerts 'name' and 'bark' (order is not guaranteed)
+ */
+ var forIn = createIterator(forEachIteratorOptions, forOwnIteratorOptions, {
+ 'useHas': false
+ });
+
+ /**
+ * Iterates over `object`'s own enumerable properties, executing the `callback`
+ * for each property. The `callback` is bound to `thisArg` and invoked with three
+ * arguments; (value, key, object). Callbacks may exit iteration early by explicitly
+ * returning `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Object} object The object to iterate over.
+ * @param {Function} callback The function called per iteration.
+ * @param {Mixed} [thisArg] The `this` binding of `callback`.
+ * @returns {Object} Returns `object`.
+ * @example
+ *
+ * _.forOwn({ '0': 'zero', '1': 'one', 'length': 2 }, function(num, key) {
+ * alert(key);
+ * });
+ * // => alerts '0', '1', and 'length' (order is not guaranteed)
+ */
+ var forOwn = createIterator(forEachIteratorOptions, forOwnIteratorOptions);
+
+ /**
+ * A fallback implementation of `isPlainObject` that checks if a given `value`
+ * is an object created by the `Object` constructor, assuming objects created
+ * by the `Object` constructor have no inherited enumerable properties and that
+ * there are no `Object.prototype` extensions.
+ *
+ * @private
+ * @param {Mixed} value The value to check.
+ * @returns {Boolean} Returns `true` if `value` is a plain object, else `false`.
+ */
+ function shimIsPlainObject(value) {
+ // avoid non-objects and false positives for `arguments` objects
+ var result = false;
+ if (!(value && typeof value == 'object') || isArguments(value)) {
+ return result;
+ }
+ // IE < 9 presents DOM nodes as `Object` objects except they have `toString`
+ // methods that are `typeof` "string" and still can coerce nodes to strings.
+ // Also check that the constructor is `Object` (i.e. `Object instanceof Object`)
+ var ctor = value.constructor;
+ if ((!noNodeClass || !(typeof value.toString != 'function' && typeof (value + '') == 'string')) &&
+ (!isFunction(ctor) || ctor instanceof ctor)) {
+ // IE < 9 iterates inherited properties before own properties. If the first
+ // iterated property is an object's own property then there are no inherited
+ // enumerable properties.
+ if (iteratesOwnLast) {
+ forIn(value, function(value, key, object) {
+ result = !hasOwnProperty.call(object, key);
+ return false;
+ });
+ return result === false;
+ }
+ // In most environments an object's own properties are iterated before
+ // its inherited properties. If the last iterated property is an object's
+ // own property then there are no inherited enumerable properties.
+ forIn(value, function(value, key) {
+ result = key;
+ });
+ return result === false || hasOwnProperty.call(value, result);
+ }
+ return result;
+ }
+
+ /**
+ * A fallback implementation of `Object.keys` that produces an array of the
+ * given object's own enumerable property names.
+ *
+ * @private
+ * @param {Object} object The object to inspect.
+ * @returns {Array} Returns a new array of property names.
+ */
+ function shimKeys(object) {
+ var result = [];
+ forOwn(object, function(value, key) {
+ result.push(key);
+ });
+ return result;
+ }
+
+ /**
+ * Used to convert characters to HTML entities:
+ *
+ * Though the `>` character is escaped for symmetry, characters like `>` and `/`
+ * don't require escaping in HTML and have no special meaning unless they're part
+ * of a tag or an unquoted attribute value.
+ * http://mathiasbynens.be/notes/ambiguous-ampersands (under "semi-related fun fact")
+ */
+ var htmlEscapes = {
+ '&': '&',
+ '<': '<',
+ '>': '>',
+ '"': '"',
+ "'": '''
+ };
+
+ /** Used to convert HTML entities to characters */
+ var htmlUnescapes = invert(htmlEscapes);
+
+ /*--------------------------------------------------------------------------*/
+
+ /**
+ * Creates a clone of `value`. If `deep` is `true`, all nested objects will
+ * also be cloned otherwise they will be assigned by reference. Functions, DOM
+ * nodes, `arguments` objects, and objects created by constructors other than
+ * `Object` are **not** cloned.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Mixed} value The value to clone.
+ * @param {Boolean} deep A flag to indicate a deep clone.
+ * @param- {Object} [guard] Internally used to allow this method to work with
+ * others like `_.map` without using their callback `index` argument for `deep`.
+ * @param- {Array} [stackA=[]] Internally used to track traversed source objects.
+ * @param- {Array} [stackB=[]] Internally used to associate clones with their
+ * source counterparts.
+ * @returns {Mixed} Returns the cloned `value`.
+ * @example
+ *
+ * var stooges = [
+ * { 'name': 'moe', 'age': 40 },
+ * { 'name': 'larry', 'age': 50 },
+ * { 'name': 'curly', 'age': 60 }
+ * ];
+ *
+ * _.clone({ 'name': 'moe' });
+ * // => { 'name': 'moe' }
+ *
+ * var shallow = _.clone(stooges);
+ * shallow[0] === stooges[0];
+ * // => true
+ *
+ * var deep = _.clone(stooges, true);
+ * shallow[0] === stooges[0];
+ * // => false
+ */
+ function clone(value, deep, guard, stackA, stackB) {
+ if (value == null) {
+ return value;
+ }
+ if (guard) {
+ deep = false;
+ }
+ // inspect [[Class]]
+ var isObj = isObject(value);
+ if (isObj) {
+ // don't clone `arguments` objects, functions, or non-object Objects
+ var className = toString.call(value);
+ if (!cloneableClasses[className] || (noArgsClass && isArguments(value))) {
+ return value;
+ }
+ var isArr = className == arrayClass;
+ isObj = isArr || (className == objectClass ? isPlainObject(value) : isObj);
+ }
+ // shallow clone
+ if (!isObj || !deep) {
+ // don't clone functions
+ return isObj
+ ? (isArr ? slice.call(value) : extend({}, value))
+ : value;
+ }
+
+ var ctor = value.constructor;
+ switch (className) {
+ case boolClass:
+ case dateClass:
+ return new ctor(+value);
+
+ case numberClass:
+ case stringClass:
+ return new ctor(value);
+
+ case regexpClass:
+ return ctor(value.source, reFlags.exec(value));
+ }
+ // check for circular references and return corresponding clone
+ stackA || (stackA = []);
+ stackB || (stackB = []);
+
+ var length = stackA.length;
+ while (length--) {
+ if (stackA[length] == value) {
+ return stackB[length];
+ }
+ }
+ // init cloned object
+ var result = isArr ? ctor(value.length) : {};
+
+ // add the source value to the stack of traversed objects
+ // and associate it with its clone
+ stackA.push(value);
+ stackB.push(result);
+
+ // recursively populate clone (susceptible to call stack limits)
+ (isArr ? forEach : forOwn)(value, function(objValue, key) {
+ result[key] = clone(objValue, deep, null, stackA, stackB);
+ });
+
+ return result;
+ }
+
+ /**
+ * Assigns enumerable properties of the default object(s) to the `destination`
+ * object for all `destination` properties that resolve to `null`/`undefined`.
+ * Once a property is set, additional defaults of the same property will be
+ * ignored.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Object} object The destination object.
+ * @param {Object} [default1, default2, ...] The default objects.
+ * @returns {Object} Returns the destination object.
+ * @example
+ *
+ * var iceCream = { 'flavor': 'chocolate' };
+ * _.defaults(iceCream, { 'flavor': 'vanilla', 'sprinkles': 'rainbow' });
+ * // => { 'flavor': 'chocolate', 'sprinkles': 'rainbow' }
+ */
+ var defaults = createIterator(extendIteratorOptions, {
+ 'objectLoop': 'if (result[index] == null) ' + extendIteratorOptions.objectLoop
+ });
+
+ /**
+ * Assigns enumerable properties of the source object(s) to the `destination`
+ * object. Subsequent sources will overwrite propery assignments of previous
+ * sources.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Object} object The destination object.
+ * @param {Object} [source1, source2, ...] The source objects.
+ * @returns {Object} Returns the destination object.
+ * @example
+ *
+ * _.extend({ 'name': 'moe' }, { 'age': 40 });
+ * // => { 'name': 'moe', 'age': 40 }
+ */
+ var extend = createIterator(extendIteratorOptions);
+
+ /**
+ * Creates a sorted array of all enumerable properties, own and inherited,
+ * of `object` that have function values.
+ *
+ * @static
+ * @memberOf _
+ * @alias methods
+ * @category Objects
+ * @param {Object} object The object to inspect.
+ * @returns {Array} Returns a new array of property names that have function values.
+ * @example
+ *
+ * _.functions(_);
+ * // => ['all', 'any', 'bind', 'bindAll', 'clone', 'compact', 'compose', ...]
+ */
+ function functions(object) {
+ var result = [];
+ forIn(object, function(value, key) {
+ if (isFunction(value)) {
+ result.push(key);
+ }
+ });
+ return result.sort();
+ }
+
+ /**
+ * Checks if the specified object `property` exists and is a direct property,
+ * instead of an inherited property.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Object} object The object to check.
+ * @param {String} property The property to check for.
+ * @returns {Boolean} Returns `true` if key is a direct property, else `false`.
+ * @example
+ *
+ * _.has({ 'a': 1, 'b': 2, 'c': 3 }, 'b');
+ * // => true
+ */
+ function has(object, property) {
+ return object ? hasOwnProperty.call(object, property) : false;
+ }
+
+ /**
+ * Creates an object composed of the inverted keys and values of the given `object`.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Object} object The object to invert.
+ * @returns {Object} Returns the created inverted object.
+ * @example
+ *
+ * _.invert({ 'first': 'Moe', 'second': 'Larry', 'third': 'Curly' });
+ * // => { 'Moe': 'first', 'Larry': 'second', 'Curly': 'third' } (order is not guaranteed)
+ */
+ function invert(object) {
+ var result = {};
+ forOwn(object, function(value, key) {
+ result[value] = key;
+ });
+ return result;
+ }
+
+ /**
+ * Checks if `value` is an array.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Mixed} value The value to check.
+ * @returns {Boolean} Returns `true` if the `value` is an array, else `false`.
+ * @example
+ *
+ * (function() { return _.isArray(arguments); })();
+ * // => false
+ *
+ * _.isArray([1, 2, 3]);
+ * // => true
+ */
+ var isArray = nativeIsArray || function(value) {
+ return toString.call(value) == arrayClass;
+ };
+
+ /**
+ * Checks if `value` is a boolean (`true` or `false`) value.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Mixed} value The value to check.
+ * @returns {Boolean} Returns `true` if the `value` is a boolean value, else `false`.
+ * @example
+ *
+ * _.isBoolean(null);
+ * // => false
+ */
+ function isBoolean(value) {
+ return value === true || value === false || toString.call(value) == boolClass;
+ }
+
+ /**
+ * Checks if `value` is a date.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Mixed} value The value to check.
+ * @returns {Boolean} Returns `true` if the `value` is a date, else `false`.
+ * @example
+ *
+ * _.isDate(new Date);
+ * // => true
+ */
+ function isDate(value) {
+ return toString.call(value) == dateClass;
+ }
+
+ /**
+ * Checks if `value` is a DOM element.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Mixed} value The value to check.
+ * @returns {Boolean} Returns `true` if the `value` is a DOM element, else `false`.
+ * @example
+ *
+ * _.isElement(document.body);
+ * // => true
+ */
+ function isElement(value) {
+ return value ? value.nodeType === 1 : false;
+ }
+
+ /**
+ * Checks if `value` is empty. Arrays, strings, or `arguments` objects with a
+ * length of `0` and objects with no own enumerable properties are considered
+ * "empty".
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Array|Object|String} value The value to inspect.
+ * @returns {Boolean} Returns `true` if the `value` is empty, else `false`.
+ * @example
+ *
+ * _.isEmpty([1, 2, 3]);
+ * // => false
+ *
+ * _.isEmpty({});
+ * // => true
+ *
+ * _.isEmpty('');
+ * // => true
+ */
+ function isEmpty(value) {
+ var result = true;
+ if (!value) {
+ return result;
+ }
+ var className = toString.call(value),
+ length = value.length;
+
+ if ((className == arrayClass || className == stringClass ||
+ className == argsClass || (noArgsClass && isArguments(value))) ||
+ (className == objectClass && typeof length == 'number' && isFunction(value.splice))) {
+ return !length;
+ }
+ forOwn(value, function() {
+ return (result = false);
+ });
+ return result;
+ }
+
+ /**
+ * Performs a deep comparison between two values to determine if they are
+ * equivalent to each other.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Mixed} a The value to compare.
+ * @param {Mixed} b The other value to compare.
+ * @param- {Object} [stackA=[]] Internally used track traversed `a` objects.
+ * @param- {Object} [stackB=[]] Internally used track traversed `b` objects.
+ * @returns {Boolean} Returns `true` if the values are equvalent, else `false`.
+ * @example
+ *
+ * var moe = { 'name': 'moe', 'luckyNumbers': [13, 27, 34] };
+ * var clone = { 'name': 'moe', 'luckyNumbers': [13, 27, 34] };
+ *
+ * moe == clone;
+ * // => false
+ *
+ * _.isEqual(moe, clone);
+ * // => true
+ */
+ function isEqual(a, b, stackA, stackB) {
+ // exit early for identical values
+ if (a === b) {
+ // treat `+0` vs. `-0` as not equal
+ return a !== 0 || (1 / a == 1 / b);
+ }
+ // a strict comparison is necessary because `null == undefined`
+ if (a == null || b == null) {
+ return a === b;
+ }
+ // compare [[Class]] names
+ var className = toString.call(a);
+ if (className != toString.call(b)) {
+ return false;
+ }
+ switch (className) {
+ case boolClass:
+ case dateClass:
+ // coerce dates and booleans to numbers, dates to milliseconds and booleans
+ // to `1` or `0`, treating invalid dates coerced to `NaN` as not equal
+ return +a == +b;
+
+ case numberClass:
+ // treat `NaN` vs. `NaN` as equal
+ return a != +a
+ ? b != +b
+ // but treat `+0` vs. `-0` as not equal
+ : (a == 0 ? (1 / a == 1 / b) : a == +b);
+
+ case regexpClass:
+ case stringClass:
+ // coerce regexes to strings (http://es5.github.com/#x15.10.6.4)
+ // treat string primitives and their corresponding object instances as equal
+ return a == b + '';
+ }
+ // exit early, in older browsers, if `a` is array-like but not `b`
+ var isArr = className == arrayClass || className == argsClass;
+ if (noArgsClass && !isArr && (isArr = isArguments(a)) && !isArguments(b)) {
+ return false;
+ }
+ if (!isArr) {
+ // unwrap any `lodash` wrapped values
+ if (a.__wrapped__ || b.__wrapped__) {
+ return isEqual(a.__wrapped__ || a, b.__wrapped__ || b);
+ }
+ // exit for functions and DOM nodes
+ if (className != objectClass || (noNodeClass && (
+ (typeof a.toString != 'function' && typeof (a + '') == 'string') ||
+ (typeof b.toString != 'function' && typeof (b + '') == 'string')))) {
+ return false;
+ }
+ var ctorA = a.constructor,
+ ctorB = b.constructor;
+
+ // non `Object` object instances with different constructors are not equal
+ if (ctorA != ctorB && !(
+ isFunction(ctorA) && ctorA instanceof ctorA &&
+ isFunction(ctorB) && ctorB instanceof ctorB
+ )) {
+ return false;
+ }
+ }
+ // assume cyclic structures are equal
+ // the algorithm for detecting cyclic structures is adapted from ES 5.1
+ // section 15.12.3, abstract operation `JO` (http://es5.github.com/#x15.12.3)
+ stackA || (stackA = []);
+ stackB || (stackB = []);
+
+ var length = stackA.length;
+ while (length--) {
+ if (stackA[length] == a) {
+ return stackB[length] == b;
+ }
+ }
+
+ var index = -1,
+ result = true,
+ size = 0;
+
+ // add `a` and `b` to the stack of traversed objects
+ stackA.push(a);
+ stackB.push(b);
+
+ // recursively compare objects and arrays (susceptible to call stack limits)
+ if (isArr) {
+ // compare lengths to determine if a deep comparison is necessary
+ size = a.length;
+ result = size == b.length;
+
+ if (result) {
+ // deep compare the contents, ignoring non-numeric properties
+ while (size--) {
+ if (!(result = isEqual(a[size], b[size], stackA, stackB))) {
+ break;
+ }
+ }
+ }
+ return result;
+ }
+ // deep compare objects
+ for (var key in a) {
+ if (hasOwnProperty.call(a, key)) {
+ // count the number of properties.
+ size++;
+ // deep compare each property value.
+ if (!(hasOwnProperty.call(b, key) && isEqual(a[key], b[key], stackA, stackB))) {
+ return false;
+ }
+ }
+ }
+ // ensure both objects have the same number of properties
+ for (key in b) {
+ // The JS engine in Adobe products, like InDesign, has a bug that causes
+ // `!size--` to throw an error so it must be wrapped in parentheses.
+ // https://github.com/documentcloud/underscore/issues/355
+ if (hasOwnProperty.call(b, key) && !(size--)) {
+ // `size` will be `-1` if `b` has more properties than `a`
+ return false;
+ }
+ }
+ // handle JScript [[DontEnum]] bug
+ if (hasDontEnumBug) {
+ while (++index < 7) {
+ key = shadowed[index];
+ if (hasOwnProperty.call(a, key) &&
+ !(hasOwnProperty.call(b, key) && isEqual(a[key], b[key], stackA, stackB))) {
+ return false;
+ }
+ }
+ }
+ return true;
+ }
+
+ /**
+ * Checks if `value` is, or can be coerced to, a finite number.
+ *
+ * Note: This is not the same as native `isFinite`, which will return true for
+ * booleans and empty strings. See http://es5.github.com/#x15.1.2.5.
+ *
+ * @deprecated
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Mixed} value The value to check.
+ * @returns {Boolean} Returns `true` if the `value` is a finite number, else `false`.
+ * @example
+ *
+ * _.isFinite(-101);
+ * // => true
+ *
+ * _.isFinite('10');
+ * // => true
+ *
+ * _.isFinite(true);
+ * // => false
+ *
+ * _.isFinite('');
+ * // => false
+ *
+ * _.isFinite(Infinity);
+ * // => false
+ */
+ function isFinite(value) {
+ return nativeIsFinite(value) && !nativeIsNaN(parseFloat(value));
+ }
+
+ /**
+ * Checks if `value` is a function.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Mixed} value The value to check.
+ * @returns {Boolean} Returns `true` if the `value` is a function, else `false`.
+ * @example
+ *
+ * _.isFunction(_);
+ * // => true
+ */
+ function isFunction(value) {
+ return typeof value == 'function';
+ }
+ // fallback for older versions of Chrome and Safari
+ if (isFunction(/x/)) {
+ isFunction = function(value) {
+ return toString.call(value) == funcClass;
+ };
+ }
+
+ /**
+ * Checks if `value` is the language type of Object.
+ * (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Mixed} value The value to check.
+ * @returns {Boolean} Returns `true` if the `value` is an object, else `false`.
+ * @example
+ *
+ * _.isObject({});
+ * // => true
+ *
+ * _.isObject([1, 2, 3]);
+ * // => true
+ *
+ * _.isObject(1);
+ * // => false
+ */
+ function isObject(value) {
+ // check if the value is the ECMAScript language type of Object
+ // http://es5.github.com/#x8
+ // and avoid a V8 bug
+ // http://code.google.com/p/v8/issues/detail?id=2291
+ return value ? objectTypes[typeof value] : false;
+ }
+
+ /**
+ * Checks if `value` is `NaN`.
+ *
+ * Note: This is not the same as native `isNaN`, which will return true for
+ * `undefined` and other values. See http://es5.github.com/#x15.1.2.4.
+ *
+ * @deprecated
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Mixed} value The value to check.
+ * @returns {Boolean} Returns `true` if the `value` is `NaN`, else `false`.
+ * @example
+ *
+ * _.isNaN(NaN);
+ * // => true
+ *
+ * _.isNaN(new Number(NaN));
+ * // => true
+ *
+ * isNaN(undefined);
+ * // => true
+ *
+ * _.isNaN(undefined);
+ * // => false
+ */
+ function isNaN(value) {
+ // `NaN` as a primitive is the only value that is not equal to itself
+ // (perform the [[Class]] check first to avoid errors with some host objects in IE)
+ return toString.call(value) == numberClass && value != +value
+ }
+
+ /**
+ * Checks if `value` is `null`.
+ *
+ * @deprecated
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Mixed} value The value to check.
+ * @returns {Boolean} Returns `true` if the `value` is `null`, else `false`.
+ * @example
+ *
+ * _.isNull(null);
+ * // => true
+ *
+ * _.isNull(undefined);
+ * // => false
+ */
+ function isNull(value) {
+ return value === null;
+ }
+
+ /**
+ * Checks if `value` is a number.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Mixed} value The value to check.
+ * @returns {Boolean} Returns `true` if the `value` is a number, else `false`.
+ * @example
+ *
+ * _.isNumber(8.4 * 5);
+ * // => true
+ */
+ function isNumber(value) {
+ return toString.call(value) == numberClass;
+ }
+
+ /**
+ * Checks if a given `value` is an object created by the `Object` constructor.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Mixed} value The value to check.
+ * @returns {Boolean} Returns `true` if `value` is a plain object, else `false`.
+ * @example
+ *
+ * function Stooge(name, age) {
+ * this.name = name;
+ * this.age = age;
+ * }
+ *
+ * _.isPlainObject(new Stooge('moe', 40));
+ * // => false
+ *
+ * _.isPlainObject([1, 2, 3]);
+ * // => false
+ *
+ * _.isPlainObject({ 'name': 'moe', 'age': 40 });
+ * // => true
+ */
+ var isPlainObject = !getPrototypeOf ? shimIsPlainObject : function(value) {
+ if (!(value && typeof value == 'object')) {
+ return false;
+ }
+ var valueOf = value.valueOf,
+ objProto = typeof valueOf == 'function' && (objProto = getPrototypeOf(valueOf)) && getPrototypeOf(objProto);
+
+ return objProto
+ ? value == objProto || (getPrototypeOf(value) == objProto && !isArguments(value))
+ : shimIsPlainObject(value);
+ };
+
+ /**
+ * Checks if `value` is a regular expression.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Mixed} value The value to check.
+ * @returns {Boolean} Returns `true` if the `value` is a regular expression, else `false`.
+ * @example
+ *
+ * _.isRegExp(/moe/);
+ * // => true
+ */
+ function isRegExp(value) {
+ return toString.call(value) == regexpClass;
+ }
+
+ /**
+ * Checks if `value` is a string.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Mixed} value The value to check.
+ * @returns {Boolean} Returns `true` if the `value` is a string, else `false`.
+ * @example
+ *
+ * _.isString('moe');
+ * // => true
+ */
+ function isString(value) {
+ return toString.call(value) == stringClass;
+ }
+
+ /**
+ * Checks if `value` is `undefined`.
+ *
+ * @deprecated
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Mixed} value The value to check.
+ * @returns {Boolean} Returns `true` if the `value` is `undefined`, else `false`.
+ * @example
+ *
+ * _.isUndefined(void 0);
+ * // => true
+ */
+ function isUndefined(value) {
+ return value === undefined;
+ }
+
+ /**
+ * Creates an array composed of the own enumerable property names of `object`.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Object} object The object to inspect.
+ * @returns {Array} Returns a new array of property names.
+ * @example
+ *
+ * _.keys({ 'one': 1, 'two': 2, 'three': 3 });
+ * // => ['one', 'two', 'three'] (order is not guaranteed)
+ */
+ var keys = !nativeKeys ? shimKeys : function(object) {
+ // avoid iterating over the `prototype` property
+ return typeof object == 'function' && propertyIsEnumerable.call(object, 'prototype')
+ ? shimKeys(object)
+ : (isObject(object) ? nativeKeys(object) : []);
+ };
+
+ /**
+ * Merges enumerable properties of the source object(s) into the `destination`
+ * object. Subsequent sources will overwrite propery assignments of previous
+ * sources.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Object} object The destination object.
+ * @param {Object} [source1, source2, ...] The source objects.
+ * @param- {Object} [indicator] Internally used to indicate that the `stack`
+ * argument is an array of traversed objects instead of another source object.
+ * @param- {Array} [stackA=[]] Internally used to track traversed source objects.
+ * @param- {Array} [stackB=[]] Internally used to associate values with their
+ * source counterparts.
+ * @returns {Object} Returns the destination object.
+ * @example
+ *
+ * var stooges = [
+ * { 'name': 'moe' },
+ * { 'name': 'larry' }
+ * ];
+ *
+ * var ages = [
+ * { 'age': 40 },
+ * { 'age': 50 }
+ * ];
+ *
+ * _.merge(stooges, ages);
+ * // => [{ 'name': 'moe', 'age': 40 }, { 'name': 'larry', 'age': 50 }]
+ */
+ function merge(object, source, indicator) {
+ var args = arguments,
+ index = 0,
+ length = 2,
+ stackA = args[3],
+ stackB = args[4];
+
+ if (indicator !== objectRef) {
+ stackA = [];
+ stackB = [];
+ length = args.length;
+ }
+ while (++index < length) {
+ forOwn(args[index], function(source, key) {
+ var found, isArr, value;
+ if (source && ((isArr = isArray(source)) || isPlainObject(source))) {
+ // avoid merging previously merged cyclic sources
+ var stackLength = stackA.length;
+ while (stackLength--) {
+ found = stackA[stackLength] == source;
+ if (found) {
+ break;
+ }
+ }
+ if (found) {
+ object[key] = stackB[stackLength];
+ }
+ else {
+ // add `source` and associated `value` to the stack of traversed objects
+ stackA.push(source);
+ stackB.push(value = (value = object[key], isArr)
+ ? (isArray(value) ? value : [])
+ : (isPlainObject(value) ? value : {})
+ );
+ // recursively merge objects and arrays (susceptible to call stack limits)
+ object[key] = merge(value, source, objectRef, stackA, stackB);
+ }
+ } else if (source != null) {
+ object[key] = source;
+ }
+ });
+ }
+ return object;
+ }
+
+ /**
+ * Creates a shallow clone of `object` excluding the specified properties.
+ * Property names may be specified as individual arguments or as arrays of
+ * property names. If `callback` is passed, it will be executed for each property
+ * in the `object`, omitting the properties `callback` returns truthy for. The
+ * `callback` is bound to `thisArg` and invoked with three arguments; (value, key, object).
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Object} object The source object.
+ * @param {Function|String} callback|[prop1, prop2, ...] The properties to omit
+ * or the function called per iteration.
+ * @param {Mixed} [thisArg] The `this` binding of `callback`.
+ * @returns {Object} Returns an object without the omitted properties.
+ * @example
+ *
+ * _.omit({ 'name': 'moe', 'age': 40, 'userid': 'moe1' }, 'userid');
+ * // => { 'name': 'moe', 'age': 40 }
+ *
+ * _.omit({ 'name': 'moe', '_hint': 'knucklehead', '_seed': '96c4eb' }, function(value, key) {
+ * return key.charAt(0) == '_';
+ * });
+ * // => { 'name': 'moe' }
+ */
+ function omit(object, callback, thisArg) {
+ var isFunc = typeof callback == 'function',
+ result = {};
+
+ if (isFunc) {
+ callback = createCallback(callback, thisArg);
+ } else {
+ var props = concat.apply(arrayRef, arguments);
+ }
+ forIn(object, function(value, key, object) {
+ if (isFunc
+ ? !callback(value, key, object)
+ : indexOf(props, key, 1) < 0
+ ) {
+ result[key] = value;
+ }
+ });
+ return result;
+ }
+
+ /**
+ * Creates a two dimensional array of the given object's key-value pairs,
+ * i.e. `[[key1, value1], [key2, value2]]`.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Object} object The object to inspect.
+ * @returns {Array} Returns new array of key-value pairs.
+ * @example
+ *
+ * _.pairs({ 'moe': 30, 'larry': 40, 'curly': 50 });
+ * // => [['moe', 30], ['larry', 40], ['curly', 50]] (order is not guaranteed)
+ */
+ function pairs(object) {
+ var result = [];
+ forOwn(object, function(value, key) {
+ result.push([key, value]);
+ });
+ return result;
+ }
+
+ /**
+ * Creates a shallow clone of `object` composed of the specified properties.
+ * Property names may be specified as individual arguments or as arrays of
+ * property names. If `callback` is passed, it will be executed for each property
+ * in the `object`, picking the properties `callback` returns truthy for. The
+ * `callback` is bound to `thisArg` and invoked with three arguments; (value, key, object).
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Object} object The source object.
+ * @param {Function|String} callback|[prop1, prop2, ...] The properties to pick
+ * or the function called per iteration.
+ * @param {Mixed} [thisArg] The `this` binding of `callback`.
+ * @returns {Object} Returns an object composed of the picked properties.
+ * @example
+ *
+ * _.pick({ 'name': 'moe', 'age': 40, 'userid': 'moe1' }, 'name', 'age');
+ * // => { 'name': 'moe', 'age': 40 }
+ *
+ * _.pick({ 'name': 'moe', '_hint': 'knucklehead', '_seed': '96c4eb' }, function(value, key) {
+ * return key.charAt(0) != '_';
+ * });
+ * // => { 'name': 'moe' }
+ */
+ function pick(object, callback, thisArg) {
+ var result = {};
+ if (typeof callback != 'function') {
+ var index = 0,
+ props = concat.apply(arrayRef, arguments),
+ length = props.length;
+
+ while (++index < length) {
+ var key = props[index];
+ if (key in object) {
+ result[key] = object[key];
+ }
+ }
+ } else {
+ callback = createCallback(callback, thisArg);
+ forIn(object, function(value, key, object) {
+ if (callback(value, key, object)) {
+ result[key] = value;
+ }
+ });
+ }
+ return result;
+ }
+
+ /**
+ * Creates an array composed of the own enumerable property values of `object`.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Object} object The object to inspect.
+ * @returns {Array} Returns a new array of property values.
+ * @example
+ *
+ * _.values({ 'one': 1, 'two': 2, 'three': 3 });
+ * // => [1, 2, 3]
+ */
+ function values(object) {
+ var result = [];
+ forOwn(object, function(value) {
+ result.push(value);
+ });
+ return result;
+ }
+
+ /*--------------------------------------------------------------------------*/
+
+ /**
+ * Checks if a given `target` element is present in a `collection` using strict
+ * equality for comparisons, i.e. `===`. If `fromIndex` is negative, it is used
+ * as the offset from the end of the collection.
+ *
+ * @static
+ * @memberOf _
+ * @alias include
+ * @category Collections
+ * @param {Array|Object|String} collection The collection to iterate over.
+ * @param {Mixed} target The value to check for.
+ * @param {Number} [fromIndex=0] The index to search from.
+ * @returns {Boolean} Returns `true` if the `target` element is found, else `false`.
+ * @example
+ *
+ * _.contains([1, 2, 3], 1);
+ * // => true
+ *
+ * _.contains([1, 2, 3], 1, 2);
+ * // => false
+ *
+ * _.contains({ 'name': 'moe', 'age': 40 }, 'moe');
+ * // => true
+ *
+ * _.contains('curly', 'ur');
+ * // => true
+ */
+ function contains(collection, target, fromIndex) {
+ var index = -1,
+ length = collection ? collection.length : 0;
+
+ fromIndex = (fromIndex < 0 ? nativeMax(0, length + fromIndex) : fromIndex) || 0;
+ if (typeof length == 'number') {
+ return (isString(collection)
+ ? collection.indexOf(target, fromIndex)
+ : indexOf(collection, target, fromIndex)
+ ) > -1;
+ }
+ return some(collection, function(value) {
+ return ++index >= fromIndex && value === target;
+ });
+ }
+
+ /**
+ * Creates an object composed of keys returned from running each element of
+ * `collection` through a `callback`. The corresponding value of each key is
+ * the number of times the key was returned by `callback`. The `callback` is
+ * bound to `thisArg` and invoked with three arguments; (value, index|key, collection).
+ * The `callback` argument may also be the name of a property to count by (e.g. 'length').
+ *
+ * @static
+ * @memberOf _
+ * @category Collections
+ * @param {Array|Object|String} collection The collection to iterate over.
+ * @param {Function|String} callback|property The function called per iteration
+ * or property name to count by.
+ * @param {Mixed} [thisArg] The `this` binding of `callback`.
+ * @returns {Object} Returns the composed aggregate object.
+ * @example
+ *
+ * _.countBy([4.3, 6.1, 6.4], function(num) { return Math.floor(num); });
+ * // => { '4': 1, '6': 2 }
+ *
+ * _.countBy([4.3, 6.1, 6.4], function(num) { return this.floor(num); }, Math);
+ * // => { '4': 1, '6': 2 }
+ *
+ * _.countBy(['one', 'two', 'three'], 'length');
+ * // => { '3': 2, '5': 1 }
+ */
+ function countBy(collection, callback, thisArg) {
+ var result = {};
+ callback = createCallback(callback, thisArg);
+ forEach(collection, function(value, key, collection) {
+ key = callback(value, key, collection);
+ (hasOwnProperty.call(result, key) ? result[key]++ : result[key] = 1);
+ });
+ return result;
+ }
+
+ /**
+ * Checks if the `callback` returns a truthy value for **all** elements of a
+ * `collection`. The `callback` is bound to `thisArg` and invoked with three
+ * arguments; (value, index|key, collection).
+ *
+ * @static
+ * @memberOf _
+ * @alias all
+ * @category Collections
+ * @param {Array|Object|String} collection The collection to iterate over.
+ * @param {Function} [callback=identity] The function called per iteration.
+ * @param {Mixed} [thisArg] The `this` binding of `callback`.
+ * @returns {Boolean} Returns `true` if all elements pass the callback check,
+ * else `false`.
+ * @example
+ *
+ * _.every([true, 1, null, 'yes'], Boolean);
+ * // => false
+ */
+ function every(collection, callback, thisArg) {
+ var result = true;
+ callback = createCallback(callback, thisArg);
+
+ if (isArray(collection)) {
+ var index = -1,
+ length = collection.length;
+
+ while (++index < length) {
+ if (!(result = !!callback(collection[index], index, collection))) {
+ break;
+ }
+ }
+ } else {
+ forEach(collection, function(value, index, collection) {
+ return (result = !!callback(value, index, collection));
+ });
+ }
+ return result;
+ }
+
+ /**
+ * Examines each element in a `collection`, returning an array of all elements
+ * the `callback` returns truthy for. The `callback` is bound to `thisArg` and
+ * invoked with three arguments; (value, index|key, collection).
+ *
+ * @static
+ * @memberOf _
+ * @alias select
+ * @category Collections
+ * @param {Array|Object|String} collection The collection to iterate over.
+ * @param {Function} [callback=identity] The function called per iteration.
+ * @param {Mixed} [thisArg] The `this` binding of `callback`.
+ * @returns {Array} Returns a new array of elements that passed the callback check.
+ * @example
+ *
+ * var evens = _.filter([1, 2, 3, 4, 5, 6], function(num) { return num % 2 == 0; });
+ * // => [2, 4, 6]
+ */
+ function filter(collection, callback, thisArg) {
+ var result = [];
+ callback = createCallback(callback, thisArg);
+ forEach(collection, function(value, index, collection) {
+ if (callback(value, index, collection)) {
+ result.push(value);
+ }
+ });
+ return result;
+ }
+
+ /**
+ * Examines each element in a `collection`, returning the first one the `callback`
+ * returns truthy for. The function returns as soon as it finds an acceptable
+ * element, and does not iterate over the entire `collection`. The `callback` is
+ * bound to `thisArg` and invoked with three arguments; (value, index|key, collection).
+ *
+ * @static
+ * @memberOf _
+ * @alias detect
+ * @category Collections
+ * @param {Array|Object|String} collection The collection to iterate over.
+ * @param {Function} callback The function called per iteration.
+ * @param {Mixed} [thisArg] The `this` binding of `callback`.
+ * @returns {Mixed} Returns the element that passed the callback check,
+ * else `undefined`.
+ * @example
+ *
+ * var even = _.find([1, 2, 3, 4, 5, 6], function(num) { return num % 2 == 0; });
+ * // => 2
+ */
+ function find(collection, callback, thisArg) {
+ var result;
+ callback = createCallback(callback, thisArg);
+ forEach(collection, function(value, index, collection) {
+ if (callback(value, index, collection)) {
+ result = value;
+ return false;
+ }
+ });
+ return result;
+ }
+
+ /**
+ * Iterates over a `collection`, executing the `callback` for each element in
+ * the `collection`. The `callback` is bound to `thisArg` and invoked with three
+ * arguments; (value, index|key, collection). Callbacks may exit iteration early
+ * by explicitly returning `false`.
+ *
+ * @static
+ * @memberOf _
+ * @alias each
+ * @category Collections
+ * @param {Array|Object|String} collection The collection to iterate over.
+ * @param {Function} callback The function called per iteration.
+ * @param {Mixed} [thisArg] The `this` binding of `callback`.
+ * @returns {Array|Object|String} Returns `collection`.
+ * @example
+ *
+ * _([1, 2, 3]).forEach(alert).join(',');
+ * // => alerts each number and returns '1,2,3'
+ *
+ * _.forEach({ 'one': 1, 'two': 2, 'three': 3 }, alert);
+ * // => alerts each number (order is not guaranteed)
+ */
+ var forEach = createIterator(forEachIteratorOptions);
+
+ /**
+ * Creates an object composed of keys returned from running each element of
+ * `collection` through a `callback`. The corresponding value of each key is an
+ * array of elements passed to `callback` that returned the key. The `callback`
+ * is bound to `thisArg` and invoked with three arguments; (value, index|key, collection).
+ * The `callback` argument may also be the name of a property to group by (e.g. 'length').
+ *
+ * @static
+ * @memberOf _
+ * @category Collections
+ * @param {Array|Object|String} collection The collection to iterate over.
+ * @param {Function|String} callback|property The function called per iteration
+ * or property name to group by.
+ * @param {Mixed} [thisArg] The `this` binding of `callback`.
+ * @returns {Object} Returns the composed aggregate object.
+ * @example
+ *
+ * _.groupBy([4.2, 6.1, 6.4], function(num) { return Math.floor(num); });
+ * // => { '4': [4.2], '6': [6.1, 6.4] }
+ *
+ * _.groupBy([4.2, 6.1, 6.4], function(num) { return this.floor(num); }, Math);
+ * // => { '4': [4.2], '6': [6.1, 6.4] }
+ *
+ * _.groupBy(['one', 'two', 'three'], 'length');
+ * // => { '3': ['one', 'two'], '5': ['three'] }
+ */
+ function groupBy(collection, callback, thisArg) {
+ var result = {};
+ callback = createCallback(callback, thisArg);
+ forEach(collection, function(value, key, collection) {
+ key = callback(value, key, collection);
+ (hasOwnProperty.call(result, key) ? result[key] : result[key] = []).push(value);
+ });
+ return result;
+ }
+
+ /**
+ * Invokes the method named by `methodName` on each element in the `collection`,
+ * returning an array of the results of each invoked method. Additional arguments
+ * will be passed to each invoked method. If `methodName` is a function it will
+ * be invoked for, and `this` bound to, each element in the `collection`.
+ *
+ * @static
+ * @memberOf _
+ * @category Collections
+ * @param {Array|Object|String} collection The collection to iterate over.
+ * @param {Function|String} methodName The name of the method to invoke or
+ * the function invoked per iteration.
+ * @param {Mixed} [arg1, arg2, ...] Arguments to invoke the method with.
+ * @returns {Array} Returns a new array of the results of each invoked method.
+ * @example
+ *
+ * _.invoke([[5, 1, 7], [3, 2, 1]], 'sort');
+ * // => [[1, 5, 7], [1, 2, 3]]
+ *
+ * _.invoke([123, 456], String.prototype.split, '');
+ * // => [['1', '2', '3'], ['4', '5', '6']]
+ */
+ function invoke(collection, methodName) {
+ var args = slice.call(arguments, 2),
+ isFunc = typeof methodName == 'function',
+ result = [];
+
+ forEach(collection, function(value) {
+ result.push((isFunc ? methodName : value[methodName]).apply(value, args));
+ });
+ return result;
+ }
+
+ /**
+ * Creates an array of values by running each element in the `collection`
+ * through a `callback`. The `callback` is bound to `thisArg` and invoked with
+ * three arguments; (value, index|key, collection).
+ *
+ * @static
+ * @memberOf _
+ * @alias collect
+ * @category Collections
+ * @param {Array|Object|String} collection The collection to iterate over.
+ * @param {Function} [callback=identity] The function called per iteration.
+ * @param {Mixed} [thisArg] The `this` binding of `callback`.
+ * @returns {Array} Returns a new array of the results of each `callback` execution.
+ * @example
+ *
+ * _.map([1, 2, 3], function(num) { return num * 3; });
+ * // => [3, 6, 9]
+ *
+ * _.map({ 'one': 1, 'two': 2, 'three': 3 }, function(num) { return num * 3; });
+ * // => [3, 6, 9] (order is not guaranteed)
+ */
+ function map(collection, callback, thisArg) {
+ var index = -1,
+ length = collection ? collection.length : 0,
+ result = Array(typeof length == 'number' ? length : 0);
+
+ callback = createCallback(callback, thisArg);
+ if (isArray(collection)) {
+ while (++index < length) {
+ result[index] = callback(collection[index], index, collection);
+ }
+ } else {
+ forEach(collection, function(value, key, collection) {
+ result[++index] = callback(value, key, collection);
+ });
+ }
+ return result;
+ }
+
+ /**
+ * Retrieves the maximum value of an `array`. If `callback` is passed,
+ * it will be executed for each value in the `array` to generate the
+ * criterion by which the value is ranked. The `callback` is bound to
+ * `thisArg` and invoked with three arguments; (value, index, collection).
+ *
+ * @static
+ * @memberOf _
+ * @category Collections
+ * @param {Array|Object|String} collection The collection to iterate over.
+ * @param {Function} [callback] The function called per iteration.
+ * @param {Mixed} [thisArg] The `this` binding of `callback`.
+ * @returns {Mixed} Returns the maximum value.
+ * @example
+ *
+ * var stooges = [
+ * { 'name': 'moe', 'age': 40 },
+ * { 'name': 'larry', 'age': 50 },
+ * { 'name': 'curly', 'age': 60 }
+ * ];
+ *
+ * _.max(stooges, function(stooge) { return stooge.age; });
+ * // => { 'name': 'curly', 'age': 60 };
+ */
+ function max(collection, callback, thisArg) {
+ var computed = -Infinity,
+ index = -1,
+ length = collection ? collection.length : 0,
+ result = computed;
+
+ if (callback || !isArray(collection)) {
+ callback = !callback && isString(collection)
+ ? charAtCallback
+ : createCallback(callback, thisArg);
+
+ forEach(collection, function(value, index, collection) {
+ var current = callback(value, index, collection);
+ if (current > computed) {
+ computed = current;
+ result = value;
+ }
+ });
+ } else {
+ while (++index < length) {
+ if (collection[index] > result) {
+ result = collection[index];
+ }
+ }
+ }
+ return result;
+ }
+
+ /**
+ * Retrieves the minimum value of an `array`. If `callback` is passed,
+ * it will be executed for each value in the `array` to generate the
+ * criterion by which the value is ranked. The `callback` is bound to `thisArg`
+ * and invoked with three arguments; (value, index, collection).
+ *
+ * @static
+ * @memberOf _
+ * @category Collections
+ * @param {Array|Object|String} collection The collection to iterate over.
+ * @param {Function} [callback] The function called per iteration.
+ * @param {Mixed} [thisArg] The `this` binding of `callback`.
+ * @returns {Mixed} Returns the minimum value.
+ * @example
+ *
+ * _.min([10, 5, 100, 2, 1000]);
+ * // => 2
+ */
+ function min(collection, callback, thisArg) {
+ var computed = Infinity,
+ index = -1,
+ length = collection ? collection.length : 0,
+ result = computed;
+
+ if (callback || !isArray(collection)) {
+ callback = !callback && isString(collection)
+ ? charAtCallback
+ : createCallback(callback, thisArg);
+
+ forEach(collection, function(value, index, collection) {
+ var current = callback(value, index, collection);
+ if (current < computed) {
+ computed = current;
+ result = value;
+ }
+ });
+ } else {
+ while (++index < length) {
+ if (collection[index] < result) {
+ result = collection[index];
+ }
+ }
+ }
+ return result;
+ }
+
+ /**
+ * Retrieves the value of a specified property from all elements in
+ * the `collection`.
+ *
+ * @static
+ * @memberOf _
+ * @category Collections
+ * @param {Array|Object|String} collection The collection to iterate over.
+ * @param {String} property The property to pluck.
+ * @returns {Array} Returns a new array of property values.
+ * @example
+ *
+ * var stooges = [
+ * { 'name': 'moe', 'age': 40 },
+ * { 'name': 'larry', 'age': 50 },
+ * { 'name': 'curly', 'age': 60 }
+ * ];
+ *
+ * _.pluck(stooges, 'name');
+ * // => ['moe', 'larry', 'curly']
+ */
+ function pluck(collection, property) {
+ var result = [];
+ forEach(collection, function(value) {
+ result.push(value[property]);
+ });
+ return result;
+ }
+
+ /**
+ * Boils down a `collection` to a single value. The initial state of the
+ * reduction is `accumulator` and each successive step of it should be returned
+ * by the `callback`. The `callback` is bound to `thisArg` and invoked with 4
+ * arguments; for arrays they are (accumulator, value, index|key, collection).
+ *
+ * @static
+ * @memberOf _
+ * @alias foldl, inject
+ * @category Collections
+ * @param {Array|Object|String} collection The collection to iterate over.
+ * @param {Function} callback The function called per iteration.
+ * @param {Mixed} [accumulator] Initial value of the accumulator.
+ * @param {Mixed} [thisArg] The `this` binding of `callback`.
+ * @returns {Mixed} Returns the accumulated value.
+ * @example
+ *
+ * var sum = _.reduce([1, 2, 3], function(memo, num) { return memo + num; });
+ * // => 6
+ */
+ function reduce(collection, callback, accumulator, thisArg) {
+ var noaccum = arguments.length < 3;
+ callback = createCallback(callback, thisArg);
+ forEach(collection, function(value, index, collection) {
+ accumulator = noaccum
+ ? (noaccum = false, value)
+ : callback(accumulator, value, index, collection)
+ });
+ return accumulator;
+ }
+
+ /**
+ * The right-associative version of `_.reduce`.
+ *
+ * @static
+ * @memberOf _
+ * @alias foldr
+ * @category Collections
+ * @param {Array|Object|String} collection The collection to iterate over.
+ * @param {Function} callback The function called per iteration.
+ * @param {Mixed} [accumulator] Initial value of the accumulator.
+ * @param {Mixed} [thisArg] The `this` binding of `callback`.
+ * @returns {Mixed} Returns the accumulated value.
+ * @example
+ *
+ * var list = [[0, 1], [2, 3], [4, 5]];
+ * var flat = _.reduceRight(list, function(a, b) { return a.concat(b); }, []);
+ * // => [4, 5, 2, 3, 0, 1]
+ */
+ function reduceRight(collection, callback, accumulator, thisArg) {
+ var iteratee = collection,
+ length = collection ? collection.length : 0,
+ noaccum = arguments.length < 3;
+
+ if (typeof length != 'number') {
+ var props = keys(collection);
+ length = props.length;
+ } else if (noCharByIndex && isString(collection)) {
+ iteratee = collection.split('');
+ }
+ forEach(collection, function(value, index, collection) {
+ index = props ? props[--length] : --length;
+ accumulator = noaccum
+ ? (noaccum = false, iteratee[index])
+ : callback.call(thisArg, accumulator, iteratee[index], index, collection);
+ });
+ return accumulator;
+ }
+
+ /**
+ * The opposite of `_.filter`, this method returns the values of a
+ * `collection` that `callback` does **not** return truthy for.
+ *
+ * @static
+ * @memberOf _
+ * @category Collections
+ * @param {Array|Object|String} collection The collection to iterate over.
+ * @param {Function} [callback=identity] The function called per iteration.
+ * @param {Mixed} [thisArg] The `this` binding of `callback`.
+ * @returns {Array} Returns a new array of elements that did **not** pass the
+ * callback check.
+ * @example
+ *
+ * var odds = _.reject([1, 2, 3, 4, 5, 6], function(num) { return num % 2 == 0; });
+ * // => [1, 3, 5]
+ */
+ function reject(collection, callback, thisArg) {
+ callback = createCallback(callback, thisArg);
+ return filter(collection, function(value, index, collection) {
+ return !callback(value, index, collection);
+ });
+ }
+
+ /**
+ * Creates an array of shuffled `array` values, using a version of the
+ * Fisher-Yates shuffle. See http://en.wikipedia.org/wiki/Fisher-Yates_shuffle.
+ *
+ * @static
+ * @memberOf _
+ * @category Collections
+ * @param {Array|Object|String} collection The collection to shuffle.
+ * @returns {Array} Returns a new shuffled collection.
+ * @example
+ *
+ * _.shuffle([1, 2, 3, 4, 5, 6]);
+ * // => [4, 1, 6, 3, 5, 2]
+ */
+ function shuffle(collection) {
+ var index = -1,
+ result = Array(collection ? collection.length : 0);
+
+ forEach(collection, function(value) {
+ var rand = floor(nativeRandom() * (++index + 1));
+ result[index] = result[rand];
+ result[rand] = value;
+ });
+ return result;
+ }
+
+ /**
+ * Gets the size of the `collection` by returning `collection.length` for arrays
+ * and array-like objects or the number of own enumerable properties for objects.
+ *
+ * @static
+ * @memberOf _
+ * @category Collections
+ * @param {Array|Object|String} collection The collection to inspect.
+ * @returns {Number} Returns `collection.length` or number of own enumerable properties.
+ * @example
+ *
+ * _.size([1, 2]);
+ * // => 2
+ *
+ * _.size({ 'one': 1, 'two': 2, 'three': 3 });
+ * // => 3
+ *
+ * _.size('curly');
+ * // => 5
+ */
+ function size(collection) {
+ var length = collection ? collection.length : 0;
+ return typeof length == 'number' ? length : keys(collection).length;
+ }
+
+ /**
+ * Checks if the `callback` returns a truthy value for **any** element of a
+ * `collection`. The function returns as soon as it finds passing value, and
+ * does not iterate over the entire `collection`. The `callback` is bound to
+ * `thisArg` and invoked with three arguments; (value, index|key, collection).
+ *
+ * @static
+ * @memberOf _
+ * @alias any
+ * @category Collections
+ * @param {Array|Object|String} collection The collection to iterate over.
+ * @param {Function} [callback=identity] The function called per iteration.
+ * @param {Mixed} [thisArg] The `this` binding of `callback`.
+ * @returns {Boolean} Returns `true` if any element passes the callback check,
+ * else `false`.
+ * @example
+ *
+ * _.some([null, 0, 'yes', false]);
+ * // => true
+ */
+ function some(collection, callback, thisArg) {
+ var result;
+ callback = createCallback(callback, thisArg);
+
+ if (isArray(collection)) {
+ var index = -1,
+ length = collection.length;
+
+ while (++index < length) {
+ if (result = callback(collection[index], index, collection)) {
+ break;
+ }
+ }
+ } else {
+ forEach(collection, function(value, index, collection) {
+ return !(result = callback(value, index, collection));
+ });
+ }
+ return !!result;
+ }
+
+ /**
+ * Creates an array, stable sorted in ascending order by the results of
+ * running each element of `collection` through a `callback`. The `callback`
+ * is bound to `thisArg` and invoked with three arguments; (value, index|key, collection).
+ * The `callback` argument may also be the name of a property to sort by (e.g. 'length').
+ *
+ * @static
+ * @memberOf _
+ * @category Collections
+ * @param {Array|Object|String} collection The collection to iterate over.
+ * @param {Function|String} callback|property The function called per iteration
+ * or property name to sort by.
+ * @param {Mixed} [thisArg] The `this` binding of `callback`.
+ * @returns {Array} Returns a new array of sorted elements.
+ * @example
+ *
+ * _.sortBy([1, 2, 3], function(num) { return Math.sin(num); });
+ * // => [3, 1, 2]
+ *
+ * _.sortBy([1, 2, 3], function(num) { return this.sin(num); }, Math);
+ * // => [3, 1, 2]
+ *
+ * _.sortBy(['larry', 'brendan', 'moe'], 'length');
+ * // => ['moe', 'larry', 'brendan']
+ */
+ function sortBy(collection, callback, thisArg) {
+ var result = [];
+ callback = createCallback(callback, thisArg);
+ forEach(collection, function(value, index, collection) {
+ result.push({
+ 'criteria': callback(value, index, collection),
+ 'index': index,
+ 'value': value
+ });
+ });
+
+ var length = result.length;
+ result.sort(compareAscending);
+ while (length--) {
+ result[length] = result[length].value;
+ }
+ return result;
+ }
+
+ /**
+ * Converts the `collection`, to an array.
+ *
+ * @static
+ * @memberOf _
+ * @category Collections
+ * @param {Array|Object|String} collection The collection to convert.
+ * @returns {Array} Returns the new converted array.
+ * @example
+ *
+ * (function() { return _.toArray(arguments).slice(1); })(1, 2, 3, 4);
+ * // => [2, 3, 4]
+ */
+ function toArray(collection) {
+ if (collection && typeof collection.length == 'number') {
+ return (noArraySliceOnStrings ? isString(collection) : typeof collection == 'string')
+ ? collection.split('')
+ : slice.call(collection);
+ }
+ return values(collection);
+ }
+
+ /**
+ * Examines each element in a `collection`, returning an array of all elements
+ * that contain the given `properties`.
+ *
+ * @static
+ * @memberOf _
+ * @category Collections
+ * @param {Array|Object|String} collection The collection to iterate over.
+ * @param {Object} properties The object of property values to filter by.
+ * @returns {Array} Returns a new array of elements that contain the given `properties`.
+ * @example
+ *
+ * var stooges = [
+ * { 'name': 'moe', 'age': 40 },
+ * { 'name': 'larry', 'age': 50 },
+ * { 'name': 'curly', 'age': 60 }
+ * ];
+ *
+ * _.where(stooges, { 'age': 40 });
+ * // => [{ 'name': 'moe', 'age': 40 }]
+ */
+ function where(collection, properties) {
+ var props = [];
+ forIn(properties, function(value, prop) {
+ props.push(prop);
+ });
+ return filter(collection, function(object) {
+ var length = props.length;
+ while (length--) {
+ var result = object[props[length]] === properties[props[length]];
+ if (!result) {
+ break;
+ }
+ }
+ return !!result;
+ });
+ }
+
+ /*--------------------------------------------------------------------------*/
+
+ /**
+ * Creates an array with all falsey values of `array` removed. The values
+ * `false`, `null`, `0`, `""`, `undefined` and `NaN` are all falsey.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {Array} array The array to compact.
+ * @returns {Array} Returns a new filtered array.
+ * @example
+ *
+ * _.compact([0, 1, false, 2, '', 3]);
+ * // => [1, 2, 3]
+ */
+ function compact(array) {
+ var index = -1,
+ length = array ? array.length : 0,
+ result = [];
+
+ while (++index < length) {
+ var value = array[index];
+ if (value) {
+ result.push(value);
+ }
+ }
+ return result;
+ }
+
+ /**
+ * Creates an array of `array` elements not present in the other arrays
+ * using strict equality for comparisons, i.e. `===`.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {Array} array The array to process.
+ * @param {Array} [array1, array2, ...] Arrays to check.
+ * @returns {Array} Returns a new array of `array` elements not present in the
+ * other arrays.
+ * @example
+ *
+ * _.difference([1, 2, 3, 4, 5], [5, 2, 10]);
+ * // => [1, 3, 4]
+ */
+ function difference(array) {
+ var index = -1,
+ length = array ? array.length : 0,
+ flattened = concat.apply(arrayRef, arguments),
+ contains = cachedContains(flattened, length),
+ result = [];
+
+ while (++index < length) {
+ var value = array[index];
+ if (!contains(value)) {
+ result.push(value);
+ }
+ }
+ return result;
+ }
+
+ /**
+ * Gets the first element of the `array`. Pass `n` to return the first `n`
+ * elements of the `array`.
+ *
+ * @static
+ * @memberOf _
+ * @alias head, take
+ * @category Arrays
+ * @param {Array} array The array to query.
+ * @param {Number} [n] The number of elements to return.
+ * @param- {Object} [guard] Internally used to allow this method to work with
+ * others like `_.map` without using their callback `index` argument for `n`.
+ * @returns {Mixed} Returns the first element or an array of the first `n`
+ * elements of `array`.
+ * @example
+ *
+ * _.first([5, 4, 3, 2, 1]);
+ * // => 5
+ */
+ function first(array, n, guard) {
+ if (array) {
+ return (n == null || guard) ? array[0] : slice.call(array, 0, n);
+ }
+ }
+
+ /**
+ * Flattens a nested array (the nesting can be to any depth). If `shallow` is
+ * truthy, `array` will only be flattened a single level.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {Array} array The array to compact.
+ * @param {Boolean} shallow A flag to indicate only flattening a single level.
+ * @returns {Array} Returns a new flattened array.
+ * @example
+ *
+ * _.flatten([1, [2], [3, [[4]]]]);
+ * // => [1, 2, 3, 4];
+ *
+ * _.flatten([1, [2], [3, [[4]]]], true);
+ * // => [1, 2, 3, [[4]]];
+ */
+ function flatten(array, shallow) {
+ var index = -1,
+ length = array ? array.length : 0,
+ result = [];
+
+ while (++index < length) {
+ var value = array[index];
+
+ // recursively flatten arrays (susceptible to call stack limits)
+ if (isArray(value)) {
+ push.apply(result, shallow ? value : flatten(value));
+ } else {
+ result.push(value);
+ }
+ }
+ return result;
+ }
+
+ /**
+ * Gets the index at which the first occurrence of `value` is found using
+ * strict equality for comparisons, i.e. `===`. If the `array` is already
+ * sorted, passing `true` for `fromIndex` will run a faster binary search.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {Array} array The array to search.
+ * @param {Mixed} value The value to search for.
+ * @param {Boolean|Number} [fromIndex=0] The index to search from or `true` to
+ * perform a binary search on a sorted `array`.
+ * @returns {Number} Returns the index of the matched value or `-1`.
+ * @example
+ *
+ * _.indexOf([1, 2, 3, 1, 2, 3], 2);
+ * // => 1
+ *
+ * _.indexOf([1, 2, 3, 1, 2, 3], 2, 3);
+ * // => 4
+ *
+ * _.indexOf([1, 1, 2, 2, 3, 3], 2, true);
+ * // => 2
+ */
+ function indexOf(array, value, fromIndex) {
+ var index = -1,
+ length = array ? array.length : 0;
+
+ if (typeof fromIndex == 'number') {
+ index = (fromIndex < 0 ? nativeMax(0, length + fromIndex) : fromIndex || 0) - 1;
+ } else if (fromIndex) {
+ index = sortedIndex(array, value);
+ return array[index] === value ? index : -1;
+ }
+ while (++index < length) {
+ if (array[index] === value) {
+ return index;
+ }
+ }
+ return -1;
+ }
+
+ /**
+ * Gets all but the last element of `array`. Pass `n` to exclude the last `n`
+ * elements from the result.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {Array} array The array to query.
+ * @param {Number} [n=1] The number of elements to exclude.
+ * @param- {Object} [guard] Internally used to allow this method to work with
+ * others like `_.map` without using their callback `index` argument for `n`.
+ * @returns {Array} Returns all but the last element or `n` elements of `array`.
+ * @example
+ *
+ * _.initial([3, 2, 1]);
+ * // => [3, 2]
+ */
+ function initial(array, n, guard) {
+ return array
+ ? slice.call(array, 0, -((n == null || guard) ? 1 : n))
+ : [];
+ }
+
+ /**
+ * Computes the intersection of all the passed-in arrays using strict equality
+ * for comparisons, i.e. `===`.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {Array} [array1, array2, ...] Arrays to process.
+ * @returns {Array} Returns a new array of unique elements, in order, that are
+ * present in **all** of the arrays.
+ * @example
+ *
+ * _.intersection([1, 2, 3], [101, 2, 1, 10], [2, 1]);
+ * // => [1, 2]
+ */
+ function intersection(array) {
+ var args = arguments,
+ argsLength = args.length,
+ cache = {},
+ result = [];
+
+ forEach(array, function(value) {
+ if (indexOf(result, value) < 0) {
+ var length = argsLength;
+ while (--length) {
+ if (!(cache[length] || (cache[length] = cachedContains(args[length])))(value)) {
+ return;
+ }
+ }
+ result.push(value);
+ }
+ });
+ return result;
+ }
+
+ /**
+ * Gets the last element of the `array`. Pass `n` to return the last `n`
+ * elements of the `array`.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {Array} array The array to query.
+ * @param {Number} [n] The number of elements to return.
+ * @param- {Object} [guard] Internally used to allow this method to work with
+ * others like `_.map` without using their callback `index` argument for `n`.
+ * @returns {Mixed} Returns the last element or an array of the last `n`
+ * elements of `array`.
+ * @example
+ *
+ * _.last([3, 2, 1]);
+ * // => 1
+ */
+ function last(array, n, guard) {
+ if (array) {
+ var length = array.length;
+ return (n == null || guard) ? array[length - 1] : slice.call(array, -n || length);
+ }
+ }
+
+ /**
+ * Gets the index at which the last occurrence of `value` is found using strict
+ * equality for comparisons, i.e. `===`. If `fromIndex` is negative, it is used
+ * as the offset from the end of the collection.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {Array} array The array to search.
+ * @param {Mixed} value The value to search for.
+ * @param {Number} [fromIndex=array.length-1] The index to search from.
+ * @returns {Number} Returns the index of the matched value or `-1`.
+ * @example
+ *
+ * _.lastIndexOf([1, 2, 3, 1, 2, 3], 2);
+ * // => 4
+ *
+ * _.lastIndexOf([1, 2, 3, 1, 2, 3], 2, 3);
+ * // => 1
+ */
+ function lastIndexOf(array, value, fromIndex) {
+ var index = array ? array.length : 0;
+ if (typeof fromIndex == 'number') {
+ index = (fromIndex < 0 ? nativeMax(0, index + fromIndex) : nativeMin(fromIndex, index - 1)) + 1;
+ }
+ while (index--) {
+ if (array[index] === value) {
+ return index;
+ }
+ }
+ return -1;
+ }
+
+ /**
+ * Creates an object composed from arrays of `keys` and `values`. Pass either
+ * a single two dimensional array, i.e. `[[key1, value1], [key2, value2]]`, or
+ * two arrays, one of `keys` and one of corresponding `values`.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {Array} keys The array of keys.
+ * @param {Array} [values=[]] The array of values.
+ * @returns {Object} Returns an object composed of the given keys and
+ * corresponding values.
+ * @example
+ *
+ * _.object(['moe', 'larry', 'curly'], [30, 40, 50]);
+ * // => { 'moe': 30, 'larry': 40, 'curly': 50 }
+ */
+ function object(keys, values) {
+ var index = -1,
+ length = keys ? keys.length : 0,
+ result = {};
+
+ while (++index < length) {
+ var key = keys[index];
+ if (values) {
+ result[key] = values[index];
+ } else {
+ result[key[0]] = key[1];
+ }
+ }
+ return result;
+ }
+
+ /**
+ * Creates an array of numbers (positive and/or negative) progressing from
+ * `start` up to but not including `stop`. This method is a port of Python's
+ * `range()` function. See http://docs.python.org/library/functions.html#range.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {Number} [start=0] The start of the range.
+ * @param {Number} end The end of the range.
+ * @param {Number} [step=1] The value to increment or descrement by.
+ * @returns {Array} Returns a new range array.
+ * @example
+ *
+ * _.range(10);
+ * // => [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+ *
+ * _.range(1, 11);
+ * // => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+ *
+ * _.range(0, 30, 5);
+ * // => [0, 5, 10, 15, 20, 25]
+ *
+ * _.range(0, -10, -1);
+ * // => [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
+ *
+ * _.range(0);
+ * // => []
+ */
+ function range(start, end, step) {
+ start = +start || 0;
+ step = +step || 1;
+
+ if (end == null) {
+ end = start;
+ start = 0;
+ }
+ // use `Array(length)` so V8 will avoid the slower "dictionary" mode
+ // http://www.youtube.com/watch?v=XAqIpGU8ZZk#t=16m27s
+ var index = -1,
+ length = nativeMax(0, ceil((end - start) / step)),
+ result = Array(length);
+
+ while (++index < length) {
+ result[index] = start;
+ start += step;
+ }
+ return result;
+ }
+
+ /**
+ * The opposite of `_.initial`, this method gets all but the first value of
+ * `array`. Pass `n` to exclude the first `n` values from the result.
+ *
+ * @static
+ * @memberOf _
+ * @alias drop, tail
+ * @category Arrays
+ * @param {Array} array The array to query.
+ * @param {Number} [n=1] The number of elements to exclude.
+ * @param- {Object} [guard] Internally used to allow this method to work with
+ * others like `_.map` without using their callback `index` argument for `n`.
+ * @returns {Array} Returns all but the first value or `n` values of `array`.
+ * @example
+ *
+ * _.rest([3, 2, 1]);
+ * // => [2, 1]
+ */
+ function rest(array, n, guard) {
+ return array
+ ? slice.call(array, (n == null || guard) ? 1 : n)
+ : [];
+ }
+
+ /**
+ * Uses a binary search to determine the smallest index at which the `value`
+ * should be inserted into `array` in order to maintain the sort order of the
+ * sorted `array`. If `callback` is passed, it will be executed for `value` and
+ * each element in `array` to compute their sort ranking. The `callback` is
+ * bound to `thisArg` and invoked with one argument; (value). The `callback`
+ * argument may also be the name of a property to order by.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {Array} array The array to iterate over.
+ * @param {Mixed} value The value to evaluate.
+ * @param {Function|String} [callback=identity|property] The function called
+ * per iteration or property name to order by.
+ * @param {Mixed} [thisArg] The `this` binding of `callback`.
+ * @returns {Number} Returns the index at which the value should be inserted
+ * into `array`.
+ * @example
+ *
+ * _.sortedIndex([20, 30, 50], 40);
+ * // => 2
+ *
+ * _.sortedIndex([{ 'x': 20 }, { 'x': 30 }, { 'x': 50 }], { 'x': 40 }, 'x');
+ * // => 2
+ *
+ * var dict = {
+ * 'wordToNumber': { 'twenty': 20, 'thirty': 30, 'fourty': 40, 'fifty': 50 }
+ * };
+ *
+ * _.sortedIndex(['twenty', 'thirty', 'fifty'], 'fourty', function(word) {
+ * return dict.wordToNumber[word];
+ * });
+ * // => 2
+ *
+ * _.sortedIndex(['twenty', 'thirty', 'fifty'], 'fourty', function(word) {
+ * return this.wordToNumber[word];
+ * }, dict);
+ * // => 2
+ */
+ function sortedIndex(array, value, callback, thisArg) {
+ var low = 0,
+ high = array ? array.length : low;
+
+ // explicitly reference `identity` for better engine inlining
+ callback = callback ? createCallback(callback, thisArg) : identity;
+ value = callback(value);
+ while (low < high) {
+ var mid = (low + high) >>> 1;
+ callback(array[mid]) < value
+ ? low = mid + 1
+ : high = mid;
+ }
+ return low;
+ }
+
+ /**
+ * Computes the union of the passed-in arrays using strict equality for
+ * comparisons, i.e. `===`.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {Array} [array1, array2, ...] Arrays to process.
+ * @returns {Array} Returns a new array of unique values, in order, that are
+ * present in one or more of the arrays.
+ * @example
+ *
+ * _.union([1, 2, 3], [101, 2, 1, 10], [2, 1]);
+ * // => [1, 2, 3, 101, 10]
+ */
+ function union() {
+ return uniq(concat.apply(arrayRef, arguments));
+ }
+
+ /**
+ * Creates a duplicate-value-free version of the `array` using strict equality
+ * for comparisons, i.e. `===`. If the `array` is already sorted, passing `true`
+ * for `isSorted` will run a faster algorithm. If `callback` is passed, each
+ * element of `array` is passed through a callback` before uniqueness is computed.
+ * The `callback` is bound to `thisArg` and invoked with three arguments; (value, index, array).
+ *
+ * @static
+ * @memberOf _
+ * @alias unique
+ * @category Arrays
+ * @param {Array} array The array to process.
+ * @param {Boolean} [isSorted=false] A flag to indicate that the `array` is already sorted.
+ * @param {Function} [callback=identity] The function called per iteration.
+ * @param {Mixed} [thisArg] The `this` binding of `callback`.
+ * @returns {Array} Returns a duplicate-value-free array.
+ * @example
+ *
+ * _.uniq([1, 2, 1, 3, 1]);
+ * // => [1, 2, 3]
+ *
+ * _.uniq([1, 1, 2, 2, 3], true);
+ * // => [1, 2, 3]
+ *
+ * _.uniq([1, 2, 1.5, 3, 2.5], function(num) { return Math.floor(num); });
+ * // => [1, 2, 3]
+ *
+ * _.uniq([1, 2, 1.5, 3, 2.5], function(num) { return this.floor(num); }, Math);
+ * // => [1, 2, 3]
+ */
+ function uniq(array, isSorted, callback, thisArg) {
+ var index = -1,
+ length = array ? array.length : 0,
+ result = [],
+ seen = result;
+
+ // juggle arguments
+ if (typeof isSorted == 'function') {
+ thisArg = callback;
+ callback = isSorted;
+ isSorted = false;
+ }
+ // init value cache for large arrays
+ var isLarge = !isSorted && length > 74;
+ if (isLarge) {
+ var cache = {};
+ }
+ if (callback) {
+ seen = [];
+ callback = createCallback(callback, thisArg);
+ }
+ while (++index < length) {
+ var value = array[index],
+ computed = callback ? callback(value, index, array) : value;
+
+ if (isLarge) {
+ // manually coerce `computed` to a string because `hasOwnProperty`, in
+ // some older versions of Firefox, coerces objects incorrectly
+ seen = hasOwnProperty.call(cache, computed + '') ? cache[computed] : (cache[computed] = []);
+ }
+ if (isSorted
+ ? !index || seen[seen.length - 1] !== computed
+ : indexOf(seen, computed) < 0
+ ) {
+ if (callback || isLarge) {
+ seen.push(computed);
+ }
+ result.push(value);
+ }
+ }
+ return result;
+ }
+
+ /**
+ * Creates an array with all occurrences of the passed values removed using
+ * strict equality for comparisons, i.e. `===`.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {Array} array The array to filter.
+ * @param {Mixed} [value1, value2, ...] Values to remove.
+ * @returns {Array} Returns a new filtered array.
+ * @example
+ *
+ * _.without([1, 2, 1, 0, 3, 1, 4], 0, 1);
+ * // => [2, 3, 4]
+ */
+ function without(array) {
+ var index = -1,
+ length = array ? array.length : 0,
+ contains = cachedContains(arguments, 1, 20),
+ result = [];
+
+ while (++index < length) {
+ var value = array[index];
+ if (!contains(value)) {
+ result.push(value);
+ }
+ }
+ return result;
+ }
+
+ /**
+ * Groups the elements of each array at their corresponding indexes. Useful for
+ * separate data sources that are coordinated through matching array indexes.
+ * For a matrix of nested arrays, `_.zip.apply(...)` can transpose the matrix
+ * in a similar fashion.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {Array} [array1, array2, ...] Arrays to process.
+ * @returns {Array} Returns a new array of grouped elements.
+ * @example
+ *
+ * _.zip(['moe', 'larry', 'curly'], [30, 40, 50], [true, false, false]);
+ * // => [['moe', 30, true], ['larry', 40, false], ['curly', 50, false]]
+ */
+ function zip(array) {
+ var index = -1,
+ length = array ? max(pluck(arguments, 'length')) : 0,
+ result = Array(length);
+
+ while (++index < length) {
+ result[index] = pluck(arguments, index);
+ }
+ return result;
+ }
+
+ /*--------------------------------------------------------------------------*/
+
+ /**
+ * Creates a function that is restricted to executing `func` only after it is
+ * called `n` times. The `func` is executed with the `this` binding of the
+ * created function.
+ *
+ * @static
+ * @memberOf _
+ * @category Functions
+ * @param {Number} n The number of times the function must be called before
+ * it is executed.
+ * @param {Function} func The function to restrict.
+ * @returns {Function} Returns the new restricted function.
+ * @example
+ *
+ * var renderNotes = _.after(notes.length, render);
+ * _.forEach(notes, function(note) {
+ * note.asyncSave({ 'success': renderNotes });
+ * });
+ * // `renderNotes` is run once, after all notes have saved
+ */
+ function after(n, func) {
+ if (n < 1) {
+ return func();
+ }
+ return function() {
+ if (--n < 1) {
+ return func.apply(this, arguments);
+ }
+ };
+ }
+
+ /**
+ * Creates a function that, when called, invokes `func` with the `this`
+ * binding of `thisArg` and prepends any additional `bind` arguments to those
+ * passed to the bound function.
+ *
+ * @static
+ * @memberOf _
+ * @category Functions
+ * @param {Function} func The function to bind.
+ * @param {Mixed} [thisArg] The `this` binding of `func`.
+ * @param {Mixed} [arg1, arg2, ...] Arguments to be partially applied.
+ * @returns {Function} Returns the new bound function.
+ * @example
+ *
+ * var func = function(greeting) {
+ * return greeting + ' ' + this.name;
+ * };
+ *
+ * func = _.bind(func, { 'name': 'moe' }, 'hi');
+ * func();
+ * // => 'hi moe'
+ */
+ function bind(func, thisArg) {
+ // use `Function#bind` if it exists and is fast
+ // (in V8 `Function#bind` is slower except when partially applied)
+ return isBindFast || (nativeBind && arguments.length > 2)
+ ? nativeBind.call.apply(nativeBind, arguments)
+ : createBound(func, thisArg, slice.call(arguments, 2));
+ }
+
+ /**
+ * Binds methods on `object` to `object`, overwriting the existing method.
+ * If no method names are provided, all the function properties of `object`
+ * will be bound.
+ *
+ * @static
+ * @memberOf _
+ * @category Functions
+ * @param {Object} object The object to bind and assign the bound methods to.
+ * @param {String} [methodName1, methodName2, ...] Method names on the object to bind.
+ * @returns {Object} Returns `object`.
+ * @example
+ *
+ * var buttonView = {
+ * 'label': 'lodash',
+ * 'onClick': function() { alert('clicked: ' + this.label); }
+ * };
+ *
+ * _.bindAll(buttonView);
+ * jQuery('#lodash_button').on('click', buttonView.onClick);
+ * // => When the button is clicked, `this.label` will have the correct value
+ */
+ function bindAll(object) {
+ var funcs = arguments,
+ index = funcs.length > 1 ? 0 : (funcs = functions(object), -1),
+ length = funcs.length;
+
+ while (++index < length) {
+ var key = funcs[index];
+ object[key] = bind(object[key], object);
+ }
+ return object;
+ }
+
+ /**
+ * Creates a function that is the composition of the passed functions,
+ * where each function consumes the return value of the function that follows.
+ * In math terms, composing the functions `f()`, `g()`, and `h()` produces `f(g(h()))`.
+ * Each function is executed with the `this` binding of the composed function.
+ *
+ * @static
+ * @memberOf _
+ * @category Functions
+ * @param {Function} [func1, func2, ...] Functions to compose.
+ * @returns {Function} Returns the new composed function.
+ * @example
+ *
+ * var greet = function(name) { return 'hi: ' + name; };
+ * var exclaim = function(statement) { return statement + '!'; };
+ * var welcome = _.compose(exclaim, greet);
+ * welcome('moe');
+ * // => 'hi: moe!'
+ */
+ function compose() {
+ var funcs = arguments;
+ return function() {
+ var args = arguments,
+ length = funcs.length;
+
+ while (length--) {
+ args = [funcs[length].apply(this, args)];
+ }
+ return args[0];
+ };
+ }
+
+ /**
+ * Creates a function that will delay the execution of `func` until after
+ * `wait` milliseconds have elapsed since the last time it was invoked. Pass
+ * `true` for `immediate` to cause debounce to invoke `func` on the leading,
+ * instead of the trailing, edge of the `wait` timeout. Subsequent calls to
+ * the debounced function will return the result of the last `func` call.
+ *
+ * @static
+ * @memberOf _
+ * @category Functions
+ * @param {Function} func The function to debounce.
+ * @param {Number} wait The number of milliseconds to delay.
+ * @param {Boolean} immediate A flag to indicate execution is on the leading
+ * edge of the timeout.
+ * @returns {Function} Returns the new debounced function.
+ * @example
+ *
+ * var lazyLayout = _.debounce(calculateLayout, 300);
+ * jQuery(window).on('resize', lazyLayout);
+ */
+ function debounce(func, wait, immediate) {
+ var args,
+ result,
+ thisArg,
+ timeoutId;
+
+ function delayed() {
+ timeoutId = null;
+ if (!immediate) {
+ result = func.apply(thisArg, args);
+ }
+ }
+ return function() {
+ var isImmediate = immediate && !timeoutId;
+ args = arguments;
+ thisArg = this;
+
+ clearTimeout(timeoutId);
+ timeoutId = setTimeout(delayed, wait);
+
+ if (isImmediate) {
+ result = func.apply(thisArg, args);
+ }
+ return result;
+ };
+ }
+
+ /**
+ * Executes the `func` function after `wait` milliseconds. Additional arguments
+ * will be passed to `func` when it is invoked.
+ *
+ * @static
+ * @memberOf _
+ * @category Functions
+ * @param {Function} func The function to delay.
+ * @param {Number} wait The number of milliseconds to delay execution.
+ * @param {Mixed} [arg1, arg2, ...] Arguments to invoke the function with.
+ * @returns {Number} Returns the `setTimeout` timeout id.
+ * @example
+ *
+ * var log = _.bind(console.log, console);
+ * _.delay(log, 1000, 'logged later');
+ * // => 'logged later' (Appears after one second.)
+ */
+ function delay(func, wait) {
+ var args = slice.call(arguments, 2);
+ return setTimeout(function() { func.apply(undefined, args); }, wait);
+ }
+
+ /**
+ * Defers executing the `func` function until the current call stack has cleared.
+ * Additional arguments will be passed to `func` when it is invoked.
+ *
+ * @static
+ * @memberOf _
+ * @category Functions
+ * @param {Function} func The function to defer.
+ * @param {Mixed} [arg1, arg2, ...] Arguments to invoke the function with.
+ * @returns {Number} Returns the `setTimeout` timeout id.
+ * @example
+ *
+ * _.defer(function() { alert('deferred'); });
+ * // returns from the function before `alert` is called
+ */
+ function defer(func) {
+ var args = slice.call(arguments, 1);
+ return setTimeout(function() { func.apply(undefined, args); }, 1);
+ }
+
+ /**
+ * Creates a function that, when called, invokes `object[methodName]` and
+ * prepends any additional `lateBind` arguments to those passed to the bound
+ * function. This method differs from `_.bind` by allowing bound functions to
+ * reference methods that will be redefined or don't yet exist.
+ *
+ * @static
+ * @memberOf _
+ * @category Functions
+ * @param {Object} object The object the method belongs to.
+ * @param {String} methodName The method name.
+ * @param {Mixed} [arg1, arg2, ...] Arguments to be partially applied.
+ * @returns {Function} Returns the new bound function.
+ * @example
+ *
+ * var object = {
+ * 'name': 'moe',
+ * 'greet': function(greeting) {
+ * return greeting + ' ' + this.name;
+ * }
+ * };
+ *
+ * var func = _.lateBind(object, 'greet', 'hi');
+ * func();
+ * // => 'hi moe'
+ *
+ * object.greet = function(greeting) {
+ * return greeting + ', ' + this.name + '!';
+ * };
+ *
+ * func();
+ * // => 'hi, moe!'
+ */
+ function lateBind(object, methodName) {
+ return createBound(methodName, object, slice.call(arguments, 2));
+ }
+
+ /**
+ * Creates a function that memoizes the result of `func`. If `resolver` is
+ * passed, it will be used to determine the cache key for storing the result
+ * based on the arguments passed to the memoized function. By default, the first
+ * argument passed to the memoized function is used as the cache key. The `func`
+ * is executed with the `this` binding of the memoized function.
+ *
+ * @static
+ * @memberOf _
+ * @category Functions
+ * @param {Function} func The function to have its output memoized.
+ * @param {Function} [resolver] A function used to resolve the cache key.
+ * @returns {Function} Returns the new memoizing function.
+ * @example
+ *
+ * var fibonacci = _.memoize(function(n) {
+ * return n < 2 ? n : fibonacci(n - 1) + fibonacci(n - 2);
+ * });
+ */
+ function memoize(func, resolver) {
+ var cache = {};
+ return function() {
+ var key = resolver ? resolver.apply(this, arguments) : arguments[0];
+ return hasOwnProperty.call(cache, key)
+ ? cache[key]
+ : (cache[key] = func.apply(this, arguments));
+ };
+ }
+
+ /**
+ * Creates a function that is restricted to execute `func` once. Repeat calls to
+ * the function will return the value of the first call. The `func` is executed
+ * with the `this` binding of the created function.
+ *
+ * @static
+ * @memberOf _
+ * @category Functions
+ * @param {Function} func The function to restrict.
+ * @returns {Function} Returns the new restricted function.
+ * @example
+ *
+ * var initialize = _.once(createApplication);
+ * initialize();
+ * initialize();
+ * // Application is only created once.
+ */
+ function once(func) {
+ var result,
+ ran = false;
+
+ return function() {
+ if (ran) {
+ return result;
+ }
+ ran = true;
+ result = func.apply(this, arguments);
+
+ // clear the `func` variable so the function may be garbage collected
+ func = null;
+ return result;
+ };
+ }
+
+ /**
+ * Creates a function that, when called, invokes `func` with any additional
+ * `partial` arguments prepended to those passed to the new function. This
+ * method is similar to `bind`, except it does **not** alter the `this` binding.
+ *
+ * @static
+ * @memberOf _
+ * @category Functions
+ * @param {Function} func The function to partially apply arguments to.
+ * @param {Mixed} [arg1, arg2, ...] Arguments to be partially applied.
+ * @returns {Function} Returns the new partially applied function.
+ * @example
+ *
+ * var greet = function(greeting, name) { return greeting + ': ' + name; };
+ * var hi = _.partial(greet, 'hi');
+ * hi('moe');
+ * // => 'hi: moe'
+ */
+ function partial(func) {
+ return createBound(func, slice.call(arguments, 1));
+ }
+
+ /**
+ * Creates a function that, when executed, will only call the `func`
+ * function at most once per every `wait` milliseconds. If the throttled
+ * function is invoked more than once during the `wait` timeout, `func` will
+ * also be called on the trailing edge of the timeout. Subsequent calls to the
+ * throttled function will return the result of the last `func` call.
+ *
+ * @static
+ * @memberOf _
+ * @category Functions
+ * @param {Function} func The function to throttle.
+ * @param {Number} wait The number of milliseconds to throttle executions to.
+ * @returns {Function} Returns the new throttled function.
+ * @example
+ *
+ * var throttled = _.throttle(updatePosition, 100);
+ * jQuery(window).on('scroll', throttled);
+ */
+ function throttle(func, wait) {
+ var args,
+ result,
+ thisArg,
+ timeoutId,
+ lastCalled = 0;
+
+ function trailingCall() {
+ lastCalled = new Date;
+ timeoutId = null;
+ result = func.apply(thisArg, args);
+ }
+ return function() {
+ var now = new Date,
+ remaining = wait - (now - lastCalled);
+
+ args = arguments;
+ thisArg = this;
+
+ if (remaining <= 0) {
+ clearTimeout(timeoutId);
+ lastCalled = now;
+ result = func.apply(thisArg, args);
+ }
+ else if (!timeoutId) {
+ timeoutId = setTimeout(trailingCall, remaining);
+ }
+ return result;
+ };
+ }
+
+ /**
+ * Creates a function that passes `value` to the `wrapper` function as its
+ * first argument. Additional arguments passed to the function are appended
+ * to those passed to the `wrapper` function. The `wrapper` is executed with
+ * the `this` binding of the created function.
+ *
+ * @static
+ * @memberOf _
+ * @category Functions
+ * @param {Mixed} value The value to wrap.
+ * @param {Function} wrapper The wrapper function.
+ * @returns {Function} Returns the new function.
+ * @example
+ *
+ * var hello = function(name) { return 'hello ' + name; };
+ * hello = _.wrap(hello, function(func) {
+ * return 'before, ' + func('moe') + ', after';
+ * });
+ * hello();
+ * // => 'before, hello moe, after'
+ */
+ function wrap(value, wrapper) {
+ return function() {
+ var args = [value];
+ push.apply(args, arguments);
+ return wrapper.apply(this, args);
+ };
+ }
+
+ /*--------------------------------------------------------------------------*/
+
+ /**
+ * Converts the characters `&`, `<`, `>`, `"`, and `'` in `string` to their
+ * corresponding HTML entities.
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @param {String} string The string to escape.
+ * @returns {String} Returns the escaped string.
+ * @example
+ *
+ * _.escape('Moe, Larry & Curly');
+ * // => "Moe, Larry & Curly"
+ */
+ function escape(string) {
+ return string == null ? '' : (string + '').replace(reUnescapedHtml, escapeHtmlChar);
+ }
+
+ /**
+ * This function returns the first argument passed to it.
+ *
+ * Note: It is used throughout Lo-Dash as a default callback.
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @param {Mixed} value Any value.
+ * @returns {Mixed} Returns `value`.
+ * @example
+ *
+ * var moe = { 'name': 'moe' };
+ * moe === _.identity(moe);
+ * // => true
+ */
+ function identity(value) {
+ return value;
+ }
+
+ /**
+ * Adds functions properties of `object` to the `lodash` function and chainable
+ * wrapper.
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @param {Object} object The object of function properties to add to `lodash`.
+ * @example
+ *
+ * _.mixin({
+ * 'capitalize': function(string) {
+ * return string.charAt(0).toUpperCase() + string.slice(1).toLowerCase();
+ * }
+ * });
+ *
+ * _.capitalize('larry');
+ * // => 'Larry'
+ *
+ * _('curly').capitalize();
+ * // => 'Curly'
+ */
+ function mixin(object) {
+ forEach(functions(object), function(methodName) {
+ var func = lodash[methodName] = object[methodName];
+
+ lodash.prototype[methodName] = function() {
+ var args = [this.__wrapped__];
+ push.apply(args, arguments);
+
+ var result = func.apply(lodash, args);
+ if (this.__chain__) {
+ result = new lodash(result);
+ result.__chain__ = true;
+ }
+ return result;
+ };
+ });
+ }
+
+ /**
+ * Reverts the '_' variable to its previous value and returns a reference to
+ * the `lodash` function.
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @returns {Function} Returns the `lodash` function.
+ * @example
+ *
+ * var lodash = _.noConflict();
+ */
+ function noConflict() {
+ window._ = oldDash;
+ return this;
+ }
+
+ /**
+ * Produces a random number between `min` and `max` (inclusive). If only one
+ * argument is passed, a number between `0` and the given number will be returned.
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @param {Number} [min=0] The minimum possible value.
+ * @param {Number} [max=1] The maximum possible value.
+ * @returns {Number} Returns a random number.
+ * @example
+ *
+ * _.random(0, 5);
+ * // => a number between 1 and 5
+ *
+ * _.random(5);
+ * // => also a number between 1 and 5
+ */
+ function random(min, max) {
+ if (min == null && max == null) {
+ max = 1;
+ }
+ min = +min || 0;
+ if (max == null) {
+ max = min;
+ min = 0;
+ }
+ return min + floor(nativeRandom() * ((+max || 0) - min + 1));
+ }
+
+ /**
+ * Resolves the value of `property` on `object`. If `property` is a function
+ * it will be invoked and its result returned, else the property value is
+ * returned. If `object` is falsey, then `null` is returned.
+ *
+ * @deprecated
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @param {Object} object The object to inspect.
+ * @param {String} property The property to get the value of.
+ * @returns {Mixed} Returns the resolved value.
+ * @example
+ *
+ * var object = {
+ * 'cheese': 'crumpets',
+ * 'stuff': function() {
+ * return 'nonsense';
+ * }
+ * };
+ *
+ * _.result(object, 'cheese');
+ * // => 'crumpets'
+ *
+ * _.result(object, 'stuff');
+ * // => 'nonsense'
+ */
+ function result(object, property) {
+ // based on Backbone's private `getValue` function
+ // https://github.com/documentcloud/backbone/blob/0.9.2/backbone.js#L1419-1424
+ var value = object ? object[property] : null;
+ return isFunction(value) ? object[property]() : value;
+ }
+
+ /**
+ * A micro-templating method that handles arbitrary delimiters, preserves
+ * whitespace, and correctly escapes quotes within interpolated code.
+ *
+ * Note: In the development build `_.template` utilizes sourceURLs for easier
+ * debugging. See http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl
+ *
+ * Note: Lo-Dash may be used in Chrome extensions by either creating a `lodash csp`
+ * build and avoiding `_.template` use, or loading Lo-Dash in a sandboxed page.
+ * See http://developer.chrome.com/trunk/extensions/sandboxingEval.html
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @param {String} text The template text.
+ * @param {Obect} data The data object used to populate the text.
+ * @param {Object} options The options object.
+ * escape - The "escape" delimiter regexp.
+ * evaluate - The "evaluate" delimiter regexp.
+ * interpolate - The "interpolate" delimiter regexp.
+ * sourceURL - The sourceURL of the template's compiled source.
+ * variable - The data object variable name.
+ *
+ * @returns {Function|String} Returns a compiled function when no `data` object
+ * is given, else it returns the interpolated text.
+ * @example
+ *
+ * // using a compiled template
+ * var compiled = _.template('hello <%= name %>');
+ * compiled({ 'name': 'moe' });
+ * // => 'hello moe'
+ *
+ * var list = '<% _.forEach(people, function(name) { %><%= name %><% }); %>';
+ * _.template(list, { 'people': ['moe', 'larry', 'curly'] });
+ * // => 'moelarrycurly'
+ *
+ * // using the "escape" delimiter to escape HTML in data property values
+ * _.template('<%- value %>', { 'value': '').stripTags()
+=> 'a linkalert("hello world!")'
+```
+
+**toSentence** _.toSentence(array, [delimiter, lastDelimiter])
+
+Join an array into a human readable sentence.
+
+```javascript
+_.toSentence(['jQuery', 'Mootools', 'Prototype'])
+=> 'jQuery, Mootools and Prototype';
+
+_.toSentence(['jQuery', 'Mootools', 'Prototype'], ', ', ' unt ')
+=> 'jQuery, Mootools unt Prototype';
+```
+
+**repeat** _.repeat(string, count, [separator])
+
+Repeats a string count times.
+
+```javascript
+_.repeat("foo", 3)
+=> 'foofoofoo';
+
+_.repeat("foo", 3, "bar")
+=> 'foobarfoobarfoo'
+```
+
+**slugify** _.slugify(string)
+
+Transform text into a URL slug. Replaces whitespaces, accentuated, and special characters with a dash.
+
+```javascript
+_.slugify("Un éléphant à l'orée du bois")
+=> 'un-elephant-a-loree-du-bois';
+```
+
+***Caution: this function is charset dependent***
+
+## Roadmap ##
+
+Any suggestions or bug reports are welcome. Just email me or more preferably open an issue.
+
+## Changelog ##
+
+### 2.0.0 ###
+
+* Added prune, humanize functions
+* Added _.string (_.str) namespace for Underscore.string library
+* Removed includes function
+
+#### Problems
+
+We lose two things for `include` and `reverse` methods from `_.string`:
+
+* Calls like `_('foobar').include('bar')` aren't available;
+* Chaining isn't available too.
+
+But if you need this functionality you can create aliases for conflict functions which will be convenient for you:
+
+```javascript
+_.mixin({
+ includeString: _.str.include,
+ reverseString: _.str.reverse
+})
+
+// Now wrapper calls and chaining are available.
+_('foobar').chain().reverseString().includeString('rab').value()
+```
+
+#### Standalone Usage
+
+If you are using Underscore.string without Underscore. You also have `_.string` namespace for it and `_.str` alias
+But of course you can just reassign `_` variable with `_.string`
+
+```javascript
+_ = _.string
+```
+### 2.2.0 ###
+
+* Capitalize method behavior changed
+* Various perfomance tweaks
+
+### 2.1.1###
+
+* Fixed words method bug
+* Added classify method
+
+### 2.1.0 ###
+
+* AMD support
+* Added toSentence method
+* Added slugify method
+* Lots of speed optimizations
+
+### 2.0.0 ###
+
+For upgrading to this version you need to mix in Underscore.string library to Underscore object:
+
+```javascript
+_.mixin(_.string.exports());
+```
+
+and all non-conflict Underscore.string functions will be available through Underscore object.
+Also function `includes` has been removed, you should replace this function by `_.str.include`
+or create alias `_.includes = _.str.include` and all your code will work fine.
+
+### 1.1.6 ###
+
+* Fixed reverse and truncate
+* Added isBlank, stripTags, inlude(alias for includes)
+* Added uglifier compression
+
+### 1.1.5 ###
+
+* Added strRight, strRightBack, strLeft, strLeftBack
+
+### 1.1.4 ###
+
+* Added pad, lpad, rpad, lrpad methods and aliases center, ljust, rjust
+* Integration with Underscore 1.1.6
+
+### 1.1.3 ###
+
+* Added methods: underscored, camelize, dasherize
+* Support newer version of npm
+
+### 1.1.2 ###
+
+* Created functions: lines, chars, words functions
+
+### 1.0.2 ###
+
+* Created integration test suite with underscore.js 1.1.4 (now it's absolutely compatible)
+* Removed 'reverse' function, because this function override underscore.js 'reverse'
+
+## Contribute ##
+
+* Fork & pull request. Don't forget about tests.
+* If you planning add some feature please create issue before.
+
+Otherwise changes will be rejected.
+
+## Contributors list ##
+
+* Esa-Matti Suuronen (),
+* Edward Tsech ,
+* Sasha Koss (),
+* Vladimir Dronnikov ,
+* Pete Kruckenberg (),
+* Paul Chavard (),
+* Ed Finkler ()
+* Pavel Pravosud
+* Anton Lindqvist ()
+
+## Licence ##
+
+The MIT License
+
+Copyright (c) 2011 Esa-Matti Suuronen esa-matti@suuronen.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/underscore.string/Rakefile b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/underscore.string/Rakefile
new file mode 100644
index 0000000..baa164c
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/underscore.string/Rakefile
@@ -0,0 +1,28 @@
+# encoding: utf-8
+task default: :test
+
+desc 'Use UglifyJS to compress Underscore.string'
+task :build do
+ require 'uglifier'
+ source = File.read('lib/underscore.string.js')
+ compressed = Uglifier.compile(source, copyright: false)
+ File.open('dist/underscore.string.min.js', 'w'){ |f| f.write compressed }
+ compression_rate = compressed.length.to_f/source.length
+ puts "compressed dist/underscore.string.min.js: #{compressed.length}/#{source.length} #{(compression_rate * 100).round}%"
+end
+
+desc 'Run tests'
+task :test do
+ pid = spawn('bundle exec serve', err: '/dev/null')
+ sleep 2
+
+ puts "Running underscore.string test suite."
+ result1 = system %{phantomjs ./test/run-qunit.js "http://localhost:4000/test/test.html"}
+
+ puts "Running Underscore test suite."
+ result2 = system %{phantomjs ./test/run-qunit.js "http://localhost:4000/test/test_underscore/test.html"}
+
+ Process.kill 'INT', pid
+
+ exit(result1 && result2 ? 0 : 1)
+end
\ No newline at end of file
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/underscore.string/lib/underscore.string.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/underscore.string/lib/underscore.string.js
new file mode 100644
index 0000000..b0be69b
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/underscore.string/lib/underscore.string.js
@@ -0,0 +1,525 @@
+// Underscore.string
+// (c) 2010 Esa-Matti Suuronen
+// Underscore.strings is freely distributable under the terms of the MIT license.
+// Documentation: https://github.com/epeli/underscore.string
+// Some code is borrowed from MooTools and Alexandru Marasteanu.
+
+// Version 2.2.0rc
+
+(function(root){
+ 'use strict';
+
+ // Defining helper functions.
+
+ var nativeTrim = String.prototype.trim;
+ var nativeTrimRight = String.prototype.trimRight;
+ var nativeTrimLeft = String.prototype.trimLeft;
+
+ var parseNumber = function(source) { return source * 1 || 0; };
+
+ var strRepeat = function(str, qty, separator){
+ // ~~var — is the fastest available way to convert anything to Integer in javascript.
+ // We'll use it extensively in this lib.
+ str += ''; qty = ~~qty;
+ for (var repeat = []; qty > 0; repeat[--qty] = str) {}
+ return repeat.join(separator == null ? '' : separator);
+ };
+
+ var slice = function(a){
+ return Array.prototype.slice.call(a);
+ };
+
+ var defaultToWhiteSpace = function(characters){
+ if (characters != null) {
+ return '[' + _s.escapeRegExp(''+characters) + ']';
+ }
+ return '\\s';
+ };
+
+ var escapeChars = {
+ lt: '<',
+ gt: '>',
+ quot: '"',
+ apos: "'",
+ amp: '&'
+ };
+
+ var reversedEscapeChars = {};
+ for(var key in escapeChars){ reversedEscapeChars[escapeChars[key]] = key; }
+
+ // sprintf() for JavaScript 0.7-beta1
+ // http://www.diveintojavascript.com/projects/javascript-sprintf
+ //
+ // Copyright (c) Alexandru Marasteanu
+ // All rights reserved.
+
+ var sprintf = (function() {
+ function get_type(variable) {
+ return Object.prototype.toString.call(variable).slice(8, -1).toLowerCase();
+ }
+
+ var str_repeat = strRepeat;
+
+ var str_format = function() {
+ if (!str_format.cache.hasOwnProperty(arguments[0])) {
+ str_format.cache[arguments[0]] = str_format.parse(arguments[0]);
+ }
+ return str_format.format.call(null, str_format.cache[arguments[0]], arguments);
+ };
+
+ str_format.format = function(parse_tree, argv) {
+ var cursor = 1, tree_length = parse_tree.length, node_type = '', arg, output = [], i, k, match, pad, pad_character, pad_length;
+ for (i = 0; i < tree_length; i++) {
+ node_type = get_type(parse_tree[i]);
+ if (node_type === 'string') {
+ output.push(parse_tree[i]);
+ }
+ else if (node_type === 'array') {
+ match = parse_tree[i]; // convenience purposes only
+ if (match[2]) { // keyword argument
+ arg = argv[cursor];
+ for (k = 0; k < match[2].length; k++) {
+ if (!arg.hasOwnProperty(match[2][k])) {
+ throw new Error(sprintf('[_.sprintf] property "%s" does not exist', match[2][k]));
+ }
+ arg = arg[match[2][k]];
+ }
+ } else if (match[1]) { // positional argument (explicit)
+ arg = argv[match[1]];
+ }
+ else { // positional argument (implicit)
+ arg = argv[cursor++];
+ }
+
+ if (/[^s]/.test(match[8]) && (get_type(arg) != 'number')) {
+ throw new Error(sprintf('[_.sprintf] expecting number but found %s', get_type(arg)));
+ }
+ switch (match[8]) {
+ case 'b': arg = arg.toString(2); break;
+ case 'c': arg = String.fromCharCode(arg); break;
+ case 'd': arg = parseInt(arg, 10); break;
+ case 'e': arg = match[7] ? arg.toExponential(match[7]) : arg.toExponential(); break;
+ case 'f': arg = match[7] ? parseFloat(arg).toFixed(match[7]) : parseFloat(arg); break;
+ case 'o': arg = arg.toString(8); break;
+ case 's': arg = ((arg = String(arg)) && match[7] ? arg.substring(0, match[7]) : arg); break;
+ case 'u': arg = Math.abs(arg); break;
+ case 'x': arg = arg.toString(16); break;
+ case 'X': arg = arg.toString(16).toUpperCase(); break;
+ }
+ arg = (/[def]/.test(match[8]) && match[3] && arg >= 0 ? '+'+ arg : arg);
+ pad_character = match[4] ? match[4] == '0' ? '0' : match[4].charAt(1) : ' ';
+ pad_length = match[6] - String(arg).length;
+ pad = match[6] ? str_repeat(pad_character, pad_length) : '';
+ output.push(match[5] ? arg + pad : pad + arg);
+ }
+ }
+ return output.join('');
+ };
+
+ str_format.cache = {};
+
+ str_format.parse = function(fmt) {
+ var _fmt = fmt, match = [], parse_tree = [], arg_names = 0;
+ while (_fmt) {
+ if ((match = /^[^\x25]+/.exec(_fmt)) !== null) {
+ parse_tree.push(match[0]);
+ }
+ else if ((match = /^\x25{2}/.exec(_fmt)) !== null) {
+ parse_tree.push('%');
+ }
+ else if ((match = /^\x25(?:([1-9]\d*)\$|\(([^\)]+)\))?(\+)?(0|'[^$])?(-)?(\d+)?(?:\.(\d+))?([b-fosuxX])/.exec(_fmt)) !== null) {
+ if (match[2]) {
+ arg_names |= 1;
+ var field_list = [], replacement_field = match[2], field_match = [];
+ if ((field_match = /^([a-z_][a-z_\d]*)/i.exec(replacement_field)) !== null) {
+ field_list.push(field_match[1]);
+ while ((replacement_field = replacement_field.substring(field_match[0].length)) !== '') {
+ if ((field_match = /^\.([a-z_][a-z_\d]*)/i.exec(replacement_field)) !== null) {
+ field_list.push(field_match[1]);
+ }
+ else if ((field_match = /^\[(\d+)\]/.exec(replacement_field)) !== null) {
+ field_list.push(field_match[1]);
+ }
+ else {
+ throw new Error('[_.sprintf] huh?');
+ }
+ }
+ }
+ else {
+ throw new Error('[_.sprintf] huh?');
+ }
+ match[2] = field_list;
+ }
+ else {
+ arg_names |= 2;
+ }
+ if (arg_names === 3) {
+ throw new Error('[_.sprintf] mixing positional and named placeholders is not (yet) supported');
+ }
+ parse_tree.push(match);
+ }
+ else {
+ throw new Error('[_.sprintf] huh?');
+ }
+ _fmt = _fmt.substring(match[0].length);
+ }
+ return parse_tree;
+ };
+
+ return str_format;
+ })();
+
+
+
+ // Defining underscore.string
+
+ var _s = {
+
+ VERSION: '2.2.0rc',
+
+ isBlank: function(str){
+ return (/^\s*$/).test(str);
+ },
+
+ stripTags: function(str){
+ return (''+str).replace(/<\/?[^>]+>/g, '');
+ },
+
+ capitalize : function(str) {
+ str += '';
+ return str.charAt(0).toUpperCase() + str.substring(1);
+ },
+
+ chop: function(str, step){
+ str = str+'';
+ step = ~~step || str.length;
+ var arr = [];
+ for (var i = 0; i < str.length; i += step)
+ arr.push(str.slice(i,i + step));
+ return arr;
+ },
+
+ clean: function(str){
+ return _s.strip(str).replace(/\s+/g, ' ');
+ },
+
+ count: function(str, substr){
+ str += ''; substr += '';
+ return str.split(substr).length - 1;
+ },
+
+ chars: function(str) {
+ return (''+str).split('');
+ },
+
+ escapeHTML: function(str) {
+ return (''+str).replace(/[&<>"']/g, function(match){ return '&' + reversedEscapeChars[match] + ';'; });
+ },
+
+ unescapeHTML: function(str) {
+ return (''+str).replace(/\&([^;]+);/g, function(entity, entityCode){
+ var match;
+
+ if (entityCode in escapeChars) {
+ return escapeChars[entityCode];
+ } else if (match = entityCode.match(/^#x([\da-fA-F]+)$/)) {
+ return String.fromCharCode(parseInt(match[1], 16));
+ } else if (match = entityCode.match(/^#(\d+)$/)) {
+ return String.fromCharCode(~~match[1]);
+ } else {
+ return entity;
+ }
+ });
+ },
+
+ escapeRegExp: function(str){
+ // From MooTools core 1.2.4
+ return str.replace(/([-.*+?^${}()|[\]\/\\])/g, '\\$1');
+ },
+
+ insert: function(str, i, substr){
+ var arr = _s.chars(str);
+ arr.splice(~~i, 0, ''+substr);
+ return arr.join('');
+ },
+
+ include: function(str, needle){
+ return !!~(''+str).indexOf(needle);
+ },
+
+ join: function() {
+ var args = slice(arguments);
+ return args.join(args.shift());
+ },
+
+ lines: function(str) {
+ return (''+str).split("\n");
+ },
+
+ reverse: function(str){
+ return _s.chars(str).reverse().join('');
+ },
+
+ splice: function(str, i, howmany, substr){
+ var arr = _s.chars(str);
+ arr.splice(~~i, ~~howmany, substr);
+ return arr.join('');
+ },
+
+ startsWith: function(str, starts){
+ str += ''; starts += '';
+ return str.length >= starts.length && str.substring(0, starts.length) === starts;
+ },
+
+ endsWith: function(str, ends){
+ str += ''; ends += '';
+ return str.length >= ends.length && str.substring(str.length - ends.length) === ends;
+ },
+
+ succ: function(str){
+ str += '';
+ var arr = _s.chars(str);
+ arr.splice(str.length-1, 1, String.fromCharCode(str.charCodeAt(str.length-1) + 1));
+ return arr.join('');
+ },
+
+ titleize: function(str){
+ return (''+str).replace(/\b./g, function(ch){ return ch.toUpperCase(); });
+ },
+
+ camelize: function(str){
+ return _s.trim(str).replace(/[-_\s]+(.)?/g, function(match, chr){
+ return chr && chr.toUpperCase();
+ });
+ },
+
+ underscored: function(str){
+ return _s.trim(str).replace(/([a-z\d])([A-Z]+)/g, '$1_$2').replace(/[-\s]+/g, '_').toLowerCase();
+ },
+
+ dasherize: function(str){
+ return _s.trim(str).replace(/[_\s]+/g, '-').replace(/([A-Z])/g, '-$1').replace(/-+/g, '-').toLowerCase();
+ },
+
+ classify: function(str){
+ str += '';
+ return _s.titleize(str.replace(/_/g, ' ')).replace(/\s/g, '')
+ },
+
+ humanize: function(str){
+ return _s.capitalize(this.underscored(str).replace(/_id$/,'').replace(/_/g, ' '));
+ },
+
+ trim: function(str, characters){
+ str += '';
+ if (!characters && nativeTrim) { return nativeTrim.call(str); }
+ characters = defaultToWhiteSpace(characters);
+ return str.replace(new RegExp('\^' + characters + '+|' + characters + '+$', 'g'), '');
+ },
+
+ ltrim: function(str, characters){
+ str+='';
+ if (!characters && nativeTrimLeft) {
+ return nativeTrimLeft.call(str);
+ }
+ characters = defaultToWhiteSpace(characters);
+ return str.replace(new RegExp('^' + characters + '+'), '');
+ },
+
+ rtrim: function(str, characters){
+ str+='';
+ if (!characters && nativeTrimRight) {
+ return nativeTrimRight.call(str);
+ }
+ characters = defaultToWhiteSpace(characters);
+ return str.replace(new RegExp(characters + '+$'), '');
+ },
+
+ truncate: function(str, length, truncateStr){
+ str += ''; truncateStr = truncateStr || '...';
+ length = ~~length;
+ return str.length > length ? str.slice(0, length) + truncateStr : str;
+ },
+
+ /**
+ * _s.prune: a more elegant version of truncate
+ * prune extra chars, never leaving a half-chopped word.
+ * @author github.com/sergiokas
+ */
+ prune: function(str, length, pruneStr){
+ str += ''; length = ~~length;
+ pruneStr = pruneStr != null ? ''+pruneStr : '...';
+
+ var pruned, borderChar, template = str.replace(/\W/g, function(ch){
+ return (ch.toUpperCase() !== ch.toLowerCase()) ? 'A' : ' ';
+ });
+
+ borderChar = template.charAt(length);
+
+ pruned = template.slice(0, length);
+
+ // Check if we're in the middle of a word
+ if (borderChar && borderChar.match(/\S/))
+ pruned = pruned.replace(/\s\S+$/, '');
+
+ pruned = _s.rtrim(pruned);
+
+ return (pruned+pruneStr).length > str.length ? str : str.substring(0, pruned.length)+pruneStr;
+ },
+
+ words: function(str, delimiter) {
+ return _s.trim(str, delimiter).split(delimiter || /\s+/);
+ },
+
+ pad: function(str, length, padStr, type) {
+ str += '';
+
+ var padlen = 0;
+
+ length = ~~length;
+
+ if (!padStr) {
+ padStr = ' ';
+ } else if (padStr.length > 1) {
+ padStr = padStr.charAt(0);
+ }
+
+ switch(type) {
+ case 'right':
+ padlen = (length - str.length);
+ return str + strRepeat(padStr, padlen);
+ case 'both':
+ padlen = (length - str.length);
+ return strRepeat(padStr, Math.ceil(padlen/2)) +
+ str +
+ strRepeat(padStr, Math.floor(padlen/2));
+ default: // 'left'
+ padlen = (length - str.length);
+ return strRepeat(padStr, padlen) + str;
+ }
+ },
+
+ lpad: function(str, length, padStr) {
+ return _s.pad(str, length, padStr);
+ },
+
+ rpad: function(str, length, padStr) {
+ return _s.pad(str, length, padStr, 'right');
+ },
+
+ lrpad: function(str, length, padStr) {
+ return _s.pad(str, length, padStr, 'both');
+ },
+
+ sprintf: sprintf,
+
+ vsprintf: function(fmt, argv){
+ argv.unshift(fmt);
+ return sprintf.apply(null, argv);
+ },
+
+ toNumber: function(str, decimals) {
+ str += '';
+ var num = parseNumber(parseNumber(str).toFixed(~~decimals));
+ return num === 0 && !str.match(/^0+$/) ? Number.NaN : num;
+ },
+
+ strRight: function(str, sep){
+ str += ''; sep = sep != null ? ''+sep : sep;
+ var pos = !sep ? -1 : str.indexOf(sep);
+ return ~pos ? str.slice(pos+sep.length, str.length) : str;
+ },
+
+ strRightBack: function(str, sep){
+ str += ''; sep = sep != null ? ''+sep : sep;
+ var pos = !sep ? -1 : str.lastIndexOf(sep);
+ return ~pos ? str.slice(pos+sep.length, str.length) : str;
+ },
+
+ strLeft: function(str, sep){
+ str += ''; sep = sep != null ? ''+sep : sep;
+ var pos = !sep ? -1 : str.indexOf(sep);
+ return ~pos ? str.slice(0, pos) : str;
+ },
+
+ strLeftBack: function(str, sep){
+ str += ''; sep = sep != null ? ''+sep : sep;
+ var pos = str.lastIndexOf(sep);
+ return ~pos ? str.slice(0, pos) : str;
+ },
+
+ toSentence: function(array, separator, lastSeparator) {
+ separator || (separator = ', ');
+ lastSeparator || (lastSeparator = ' and ');
+ var length = array.length, str = '';
+
+ for (var i = 0; i < length; i++) {
+ str += array[i];
+ if (i === (length - 2)) { str += lastSeparator; }
+ else if (i < (length - 1)) { str += separator; }
+ }
+
+ return str;
+ },
+
+ slugify: function(str) {
+ var from = "ąàáäâãćęèéëêìíïîłńòóöôõùúüûñçżź",
+ to = "aaaaaaceeeeeiiiilnooooouuuunczz",
+ regex = new RegExp(defaultToWhiteSpace(from), 'g');
+
+ str = (''+str).toLowerCase();
+
+ str = str.replace(regex, function(ch){
+ var index = from.indexOf(ch);
+ return to.charAt(index) || '-';
+ });
+
+ return _s.trim(str.replace(/[^\w\s-]/g, '').replace(/[-\s]+/g, '-'), '-');
+ },
+
+ exports: function() {
+ var result = {};
+
+ for (var prop in this) {
+ if (!this.hasOwnProperty(prop) || ~_s.words('include contains reverse').indexOf(prop)) continue;
+ result[prop] = this[prop];
+ }
+
+ return result;
+ },
+
+ repeat: strRepeat
+ };
+
+ // Aliases
+
+ _s.strip = _s.trim;
+ _s.lstrip = _s.ltrim;
+ _s.rstrip = _s.rtrim;
+ _s.center = _s.lrpad;
+ _s.rjust = _s.lpad;
+ _s.ljust = _s.rpad;
+ _s.contains = _s.include;
+
+ // CommonJS module is defined
+ if (typeof exports !== 'undefined') {
+ if (typeof module !== 'undefined' && module.exports) {
+ // Export module
+ module.exports = _s;
+ }
+ exports._s = _s;
+
+ } else if (typeof define === 'function' && define.amd) {
+ // Register as a named module with AMD.
+ define('underscore.string', function() {
+ return _s;
+ });
+
+ } else {
+ // Integrate with Underscore.js if defined
+ // or create our own underscore object.
+ root._ = root._ || {};
+ root._.string = root._.str = _s;
+ }
+
+}(this || window));
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/underscore.string/package.json b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/underscore.string/package.json
new file mode 100644
index 0000000..a692a1d
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/underscore.string/package.json
@@ -0,0 +1,96 @@
+{
+ "name": "underscore.string",
+ "version": "2.2.1",
+ "description": "String manipulation extensions for Underscore.js javascript library.",
+ "homepage": "http://epeli.github.com/underscore.string/",
+ "contributors": [
+ {
+ "name": "Esa-Matti Suuronen",
+ "email": "esa-matti@suuronen.org",
+ "url": "http://esa-matti.suuronen.org/"
+ },
+ {
+ "name": "Edward Tsech",
+ "email": "edtsech@gmail.com"
+ },
+ {
+ "name": "Sasha Koss",
+ "email": "kossnocorp@gmail.com",
+ "url": "http://koss.nocorp.me/"
+ },
+ {
+ "name": "Vladimir Dronnikov",
+ "email": "dronnikov@gmail.com"
+ },
+ {
+ "name": "Pete Kruckenberg",
+ "email": "https://github.com/kruckenb",
+ "url": ""
+ },
+ {
+ "name": "Paul Chavard",
+ "email": "paul@chavard.net",
+ "url": ""
+ },
+ {
+ "name": "Ed Finkler",
+ "email": "coj@funkatron.com",
+ "url": ""
+ },
+ {
+ "name": "Pavel Pravosud",
+ "email": "rwz@duckroll.ru"
+ }
+ ],
+ "keywords": [
+ "underscore",
+ "string"
+ ],
+ "main": "./lib/underscore.string",
+ "directories": {
+ "lib": "./lib"
+ },
+ "engines": {
+ "node": "*"
+ },
+ "repository": {
+ "type": "git",
+ "url": "https://github.com/epeli/underscore.string.git"
+ },
+ "bugs": {
+ "url": "https://github.com/epeli/underscore.string/issues"
+ },
+ "licenses": [
+ {
+ "type": "MIT"
+ }
+ ],
+ "_id": "underscore.string@2.2.1",
+ "dist": {
+ "shasum": "d7c0fa2af5d5a1a67f4253daee98132e733f0f19",
+ "tarball": "http://registry.npmjs.org/underscore.string/-/underscore.string-2.2.1.tgz"
+ },
+ "_from": "underscore.string@~2.2.1",
+ "_npmVersion": "1.2.32",
+ "_npmUser": {
+ "name": "epeli",
+ "email": "esa-matti@suuronen.org"
+ },
+ "maintainers": [
+ {
+ "name": "edtsech",
+ "email": "edtsech@gmail.com"
+ },
+ {
+ "name": "rwz",
+ "email": "rwz@duckroll.ru"
+ },
+ {
+ "name": "epeli",
+ "email": "esa-matti@suuronen.org"
+ }
+ ],
+ "_shasum": "d7c0fa2af5d5a1a67f4253daee98132e733f0f19",
+ "_resolved": "https://registry.npmjs.org/underscore.string/-/underscore.string-2.2.1.tgz",
+ "readme": "ERROR: No README data found!"
+}
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/underscore.string/test/run-qunit.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/underscore.string/test/run-qunit.js
new file mode 100644
index 0000000..326658e
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/underscore.string/test/run-qunit.js
@@ -0,0 +1,44 @@
+function waitFor(test, complete, timeout) {
+ var result, start = new Date().getTime()
+ setInterval(function interval() {
+ if ((new Date().getTime() - start < timeout) && !result) {
+ result = test()
+ } else {
+ if (!result) {
+ phantom.exit(1)
+ } else {
+ complete()
+ clearInterval(interval)
+ }
+ }
+ }, 100)
+}
+
+
+var page = new WebPage()
+
+page.onConsoleMessage = function(msg) {
+ console.log(msg)
+}
+
+page.open(phantom.args[0], function(status) {
+ waitFor(function() {
+ return page.evaluate(function(){
+ var el = document.getElementById('qunit-testresult')
+ return el && el.innerText.match('completed')
+ })
+ }, function() {
+ var failures = page.evaluate(function() {
+ var el = document.getElementById('qunit-testresult'),
+ fails = document.getElementsByClassName('fail')
+
+ for (var i = 0; i < fails.length; i++)
+ console.log(fails[i].innerText)
+
+ console.log(el.innerText)
+
+ return parseInt(el.getElementsByClassName('failed')[0].innerHTML)
+ })
+ phantom.exit(failures > 0 ? 1 : 0)
+ }, 10000)
+})
\ No newline at end of file
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/underscore.string/test/speed.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/underscore.string/test/speed.js
new file mode 100644
index 0000000..4346414
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/underscore.string/test/speed.js
@@ -0,0 +1,138 @@
+(function() {
+
+ JSLitmus.test('trimNoNative', function() {
+ return _.trim(" foobar ", " ");
+ });
+
+ JSLitmus.test('trim', function() {
+ return _.trim(" foobar ");
+ });
+
+ JSLitmus.test('trim object-oriented', function() {
+ return _(" foobar ").trim();
+ });
+
+ JSLitmus.test('trim jQuery', function() {
+ return jQuery.trim(" foobar ");
+ });
+
+ JSLitmus.test('ltrimp', function() {
+ return _.ltrim(" foobar ", " ");
+ });
+
+ JSLitmus.test('rtrimp', function() {
+ return _.rtrim(" foobar ", " ");
+ });
+
+ JSLitmus.test('startsWith', function() {
+ return _.startsWith("foobar", "foo");
+ });
+
+ JSLitmus.test('endsWith', function() {
+ return _.endsWith("foobar", "xx");
+ });
+
+ JSLitmus.test('chop', function(){
+ return _('whitespace').chop(2);
+ });
+
+ JSLitmus.test('count', function(){
+ return _('Hello worls').count('l');
+ });
+
+ JSLitmus.test('insert', function() {
+ return _('Hello ').insert(6, 'world');
+ });
+
+ JSLitmus.test('splice', function() {
+ return _('https://edtsech@bitbucket.org/edtsech/underscore.strings').splice(30, 7, 'epeli');
+ });
+
+ JSLitmus.test('succ', function(){
+ var let = 'a', alphabet = [];
+
+ for (var i=0; i < 26; i++) {
+ alphabet.push(let);
+ let = _(let).succ();
+ }
+
+ return alphabet;
+ });
+
+ JSLitmus.test('titleize', function(){
+ return _('the titleize string method').titleize();
+ });
+
+ JSLitmus.test('truncate', function(){
+ return _('Hello world').truncate(5);
+ });
+
+ JSLitmus.test('prune', function(){
+ return _('Hello world').prune(5);
+ });
+
+ JSLitmus.test('isBlank', function(){
+ return _('').isBlank();
+ });
+
+ JSLitmus.test('escapeHTML', function(){
+ _('Blah blah blah
').escapeHTML();
+ });
+
+ JSLitmus.test('unescapeHTML', function(){
+ _('<div>Blah blah blah</div>').unescapeHTML();
+ });
+
+ JSLitmus.test('reverse', function(){
+ _('Hello World').reverse();
+ });
+
+ JSLitmus.test('pad default', function(){
+ _('foo').pad(12);
+ });
+
+ JSLitmus.test('pad hash left', function(){
+ _('foo').pad(12, '#');
+ });
+
+ JSLitmus.test('pad hash right', function(){
+ _('foo').pad(12, '#', 'right');
+ });
+
+ JSLitmus.test('pad hash both', function(){
+ _('foo').pad(12, '#', 'both');
+ });
+
+ JSLitmus.test('pad hash both longPad', function(){
+ _('foo').pad(12, 'f00f00f00', 'both');
+ });
+
+ JSLitmus.test('toNumber', function(){
+ _('10.232323').toNumber(2);
+ });
+
+ JSLitmus.test('strRight', function(){
+ _('aaa_bbb_ccc').strRight('_');
+ });
+
+ JSLitmus.test('strRightBack', function(){
+ _('aaa_bbb_ccc').strRightBack('_');
+ });
+
+ JSLitmus.test('strLeft', function(){
+ _('aaa_bbb_ccc').strLeft('_');
+ });
+
+ JSLitmus.test('strLeftBack', function(){
+ _('aaa_bbb_ccc').strLeftBack('_');
+ });
+
+ JSLitmus.test('join', function(){
+ _('separator').join(1, 2, 3, 4, 5, 6, 7, 8, 'foo', 'bar', 'lol', 'wut');
+ });
+
+ JSLitmus.test('slugify', function(){
+ _("Un éléphant à l'orée du bois").slugify();
+ });
+
+})();
diff --git a/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/underscore.string/test/strings.js b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/underscore.string/test/strings.js
new file mode 100644
index 0000000..f700abf
--- /dev/null
+++ b/javascript/base/exercices/pipeline/grunt/node_modules/grunt/node_modules/underscore.string/test/strings.js
@@ -0,0 +1,438 @@
+$(document).ready(function() {
+
+ // Include Underscore.string methods to Underscore namespace
+ _.mixin(_.str.exports());
+
+ module("String extensions");
+
+ test("Strings: trim", function() {
+ equals(_.trim(123), "123", "Non string");
+ equals(_(" foo").trim(), "foo");
+ equals(_("foo ").trim(), "foo");
+ equals(_(" foo ").trim(), "foo");
+ equals(_(" foo ").trim(), "foo");
+ equals(_(" foo ", " ").trim(), "foo", "Manually set whitespace");
+
+ equals(_("ffoo").trim("f"), "oo");
+ equals(_("ooff").trim("f"), "oo");
+ equals(_("ffooff").trim("f"), "oo");
+
+
+ equals(_("_-foobar-_").trim("_-"), "foobar");
+
+ equals(_("http://foo/").trim("/"), "http://foo");
+ equals(_("c:\\").trim('\\'), "c:");
+
+ equals(_(123).trim(), '123');
+ equals(_(123).trim(3), '12');
+ });
+
+ test("Strings: ltrim", function() {
+ equals(_(" foo").ltrim(), "foo");
+ equals(_(" foo").ltrim(), "foo");
+ equals(_("foo ").ltrim(), "foo ");
+ equals(_(" foo ").ltrim(), "foo ");
+
+
+ equals(_("ffoo").ltrim("f"), "oo");
+ equals(_("ooff").ltrim("f"), "ooff");
+ equals(_("ffooff").ltrim("f"), "ooff");
+
+ equals(_("_-foobar-_").ltrim("_-"), "foobar-_");
+
+ equals(_(123).ltrim(1), '23');
+ });
+
+ test("Strings: rtrim", function() {
+ equals(_("http://foo/").rtrim("/"), "http://foo", 'clean trailing slash');
+ equals(_(" foo").rtrim(), " foo");
+ equals(_("foo ").rtrim(), "foo");
+ equals(_("foo ").rtrim(), "foo");
+ equals(_("foo bar ").rtrim(), "foo bar");
+ equals(_(" foo ").rtrim(), " foo");
+
+ equals(_("ffoo").rtrim("f"), "ffoo");
+ equals(_("ooff").rtrim("f"), "oo");
+ equals(_("ffooff").rtrim("f"), "ffoo");
+
+ equals(_("_-foobar-_").rtrim("_-"), "_-foobar");
+
+ equals(_(123).rtrim(3), '12');
+ });
+
+ test("Strings: capitalize", function() {
+ equals(_("fabio").capitalize(), "Fabio", 'First letter is upper case');
+ equals(_.capitalize("fabio"), "Fabio", 'First letter is upper case');
+ equals(_.capitalize('FOO'), 'FOO', 'Other letters unchanged');
+ equals(_(123).capitalize(), "123", "Non string");
+ });
+
+ test("Strings: join", function() {
+ equals(_.join("", "foo", "bar"), "foobar", 'basic join');
+ equals(_.join("", 1, "foo", 2), "1foo2", 'join numbers and strings');
+ equals(_.join(" ","foo", "bar"), "foo bar", 'join with spaces');
+ equals(_.join("1", "2", "2"), "212", 'join number strings');
+ equals(_.join(1, 2, 2), "212", 'join numbers');
+ equals(_(" ").join("foo", "bar"), "foo bar", 'join object oriented');
+ });
+
+ test("Strings: reverse", function() {
+ equals(_.str.reverse("foo"), "oof" );
+ equals(_.str.reverse("foobar"), "raboof" );
+ equals(_.str.reverse("foo bar"), "rab oof" );
+ equals(_.str.reverse("saippuakauppias"), "saippuakauppias" );
+ equals(_.str.reverse(123), "321", "Non string");
+ equals(_.str.reverse(123.45), "54.321", "Non string");
+ });
+
+ test("Strings: clean", function() {
+ equals(_(" foo bar ").clean(), "foo bar");
+ equals(_(123).clean(), "123");
+ });
+
+ test("Strings: sprintf", function() {
+ // Should be very tested function already. Thanks to
+ // http://www.diveintojavascript.com/projects/sprintf-for-javascript
+ equals(_.sprintf("Hello %s", "me"), "Hello me", 'basic');
+ equals(_("Hello %s").sprintf("me"), "Hello me", 'object');
+ equals(_("hello %s").chain().sprintf("me").capitalize().value(), "Hello me", 'Chaining works');
+ equals(_.sprintf("%.1f", 1.22222), "1.2", 'round');
+ equals(_.sprintf("%.1f", 1.17), "1.2", 'round 2');
+ equals(_.sprintf("%(id)d - %(name)s", {id: 824, name: "Hello World"}), "824 - Hello World", 'Named replacements work');
+ equals(_.sprintf("%(args[0].id)d - %(args[1].name)s", {args: [{id: 824}, {name: "Hello World"}]}), "824 - Hello World", 'Named replacements with arrays work');
+ });
+
+
+ test("Strings: vsprintf", function() {
+ equals(_.vsprintf("Hello %s", ["me"]), "Hello me", 'basic');
+ equals(_("Hello %s").vsprintf(["me"]), "Hello me", 'object');
+ equals(_("hello %s").chain().vsprintf(["me"]).capitalize().value(), "Hello me", 'Chaining works');
+ equals(_.vsprintf("%.1f", [1.22222]), "1.2", 'round');
+ equals(_.vsprintf("%.1f", [1.17]), "1.2", 'round 2');
+ equals(_.vsprintf("%(id)d - %(name)s", [{id: 824, name: "Hello World"}]), "824 - Hello World", 'Named replacement works');
+ equals(_.vsprintf("%(args[0].id)d - %(args[1].name)s", [{args: [{id: 824}, {name: "Hello World"}]}]), "824 - Hello World", 'Named replacement with arrays works');
+ });
+
+ test("Strings: startsWith", function() {
+ ok(_("foobar").startsWith("foo"), 'foobar starts with foo');
+ ok(!_("oobar").startsWith("foo"), 'oobar does not start with foo');
+ ok(_(12345).startsWith(123), '12345 starts with 123');
+ ok(!_(2345).startsWith(123), '2345 does not start with 123');
+ });
+
+ test("Strings: endsWith", function() {
+ ok(_("foobar").endsWith("bar"), 'foobar ends with bar');
+ ok(_.endsWith("foobar", "bar"), 'foobar ends with bar');
+ ok(_.endsWith("00018-0000062.Plone.sdh264.1a7264e6912a91aa4a81b64dc5517df7b8875994.mp4", "mp4"), 'endsWith .mp4');
+ ok(!_("fooba").endsWith("bar"), 'fooba does not end with bar');
+ ok(_.endsWith(12345, 45), '12345 ends with 45');
+ ok(!_.endsWith(12345, 6), '12345 does not end with 6');
+ });
+
+ test("Strings: include", function() {
+ ok(_.str.include("foobar", "bar"), 'foobar includes bar');
+ ok(!_.str.include("foobar", "buzz"), 'foobar does not includes buzz');
+ ok(_.str.include(12345, 34), '12345 includes 34');
+ ok(!_.str.contains(12345, 6), '12345 does not includes 6');
+ });
+
+ test('String: chop', function(){
+ ok(_('whitespace').chop(2).length === 5, "output ['wh','it','es','pa','ce']");
+ ok(_('whitespace').chop(3).length === 4, "output ['whi','tes','pac','e']");
+ ok(_('whitespace').chop()[0].length === 10, "output ['whitespace']");
+ ok(_(12345).chop(1).length === 5, "output ['1','2','3','4','5']");
+ });
+
+ test('String: clean', function(){
+ equals(_.clean(' foo bar '), 'foo bar');
+ equals(_.clean(1), '1');
+ });
+
+ test('String: count', function(){
+ equals(_('Hello world').count('l'), 3);
+ equals(_('Hello world').count('Hello'), 1);
+ equals(_('Hello world').count('foo'), 0);
+ equals(_('x.xx....x.x').count('x'), 5);
+ equals(_(12345).count(1), 1);
+ equals(_(11345).count(1), 2);
+ });
+
+ test('String: insert', function(){
+ equals(_('Hello ').insert(6, 'Jessy'), 'Hello Jessy');
+ equals(_('Hello ').insert(100, 'Jessy'), 'Hello Jessy');
+ equals(_(12345).insert(6, 'Jessy'), '12345Jessy');
+ });
+
+ test('String: splice', function(){
+ equals(_('https://edtsech@bitbucket.org/edtsech/underscore.strings').splice(30, 7, 'epeli'),
+ 'https://edtsech@bitbucket.org/epeli/underscore.strings');
+ equals(_.splice(12345, 1, 2, 321), '132145', 'Non strings');
+ });
+
+ test('String: succ', function(){
+ equals(_('a').succ(), 'b');
+ equals(_('A').succ(), 'B');
+ equals(_('+').succ(), ',');
+ equals(_(1).succ(), '2');
+ });
+
+ test('String: titleize', function(){
+ equals(_('the titleize string method').titleize(), 'The Titleize String Method');
+ equals(_('the titleize string method').titleize(), 'The Titleize String Method');
+ equals(_(123).titleize(), '123');
+ });
+
+ test('String: camelize', function(){
+ equals(_('the_camelize_string_method').camelize(), 'theCamelizeStringMethod');
+ equals(_('-the-camelize-string-method').camelize(), 'TheCamelizeStringMethod');
+ equals(_('the camelize string method').camelize(), 'theCamelizeStringMethod');
+ equals(_(' the camelize string method').camelize(), 'theCamelizeStringMethod');
+ equals(_('the camelize string method').camelize(), 'theCamelizeStringMethod');
+ equals(_(123).camelize(), '123');
+ });
+
+ test('String: underscored', function(){
+ equals(_('the-underscored-string-method').underscored(), 'the_underscored_string_method');
+ equals(_('theUnderscoredStringMethod').underscored(), 'the_underscored_string_method');
+ equals(_('TheUnderscoredStringMethod').underscored(), 'the_underscored_string_method');
+ equals(_(' the underscored string method').underscored(), 'the_underscored_string_method');
+ equals(_(123).underscored(), '123');
+ });
+
+ test('String: dasherize', function(){
+ equals(_('the_dasherize_string_method').dasherize(), 'the-dasherize-string-method');
+ equals(_('TheDasherizeStringMethod').dasherize(), '-the-dasherize-string-method');
+ equals(_('thisIsATest').dasherize(), 'this-is-a-test');
+ equals(_('this Is A Test').dasherize(), 'this-is-a-test');
+ equals(_('thisIsATest123').dasherize(), 'this-is-a-test123');
+ equals(_('123thisIsATest').dasherize(), '123this-is-a-test');
+ equals(_('the dasherize string method').dasherize(), 'the-dasherize-string-method');
+ equals(_('the dasherize string method ').dasherize(), 'the-dasherize-string-method');
+ equals(_('téléphone').dasherize(), 'téléphone');
+ equals(_('foo$bar').dasherize(), 'foo$bar');
+ equals(_(123).dasherize(), '123');
+ });
+
+ test('String: camelize', function(){
+ equals(_.camelize('-moz-transform'), 'MozTransform');
+ equals(_.camelize('webkit-transform'), 'webkitTransform');
+ equals(_.camelize('under_scored'), 'underScored');
+ equals(_.camelize(' with spaces'), 'withSpaces');
+ });
+
+ test('String: join', function(){
+ equals(_.join(1, 2, 3, 4), '21314');
+ equals(_.join('|', 'foo', 'bar', 'baz'), 'foo|bar|baz');
+ });
+
+ test('String: classify', function(){
+ equals(_.classify(1), '1');
+ equals(_('some_class_name').classify(), 'SomeClassName');
+ });
+
+ test('String: humanize', function(){
+ equals(_('the_humanize_string_method').humanize(), 'The humanize string method');
+ equals(_('ThehumanizeStringMethod').humanize(), 'Thehumanize string method');
+ equals(_('the humanize string method').humanize(), 'The humanize string method');
+ equals(_('the humanize_id string method_id').humanize(), 'The humanize id string method');
+ equals(_('the humanize string method ').humanize(), 'The humanize string method');
+ equals(_(' capitalize dash-CamelCase_underscore trim ').humanize(), 'Capitalize dash camel case underscore trim');
+ equals(_(123).humanize(), '123');
+ });
+
+ test('String: truncate', function(){
+ equals(_('Hello world').truncate(6, 'read more'), 'Hello read more');
+ equals(_('Hello world').truncate(5), 'Hello...');
+ equals(_('Hello').truncate(10), 'Hello');
+ equals(_(1234567890).truncate(5), '12345...');
+ });
+
+ test('String: prune', function(){
+ equals(_('Hello, cruel world').prune(6, ' read more'), 'Hello read more');
+ equals(_('Hello, world').prune(5, 'read a lot more'), 'Hello, world');
+ equals(_('Hello, world').prune(5), 'Hello...');
+ equals(_('Hello, world').prune(8), 'Hello...');
+ equals(_('Hello, cruel world').prune(15), 'Hello, cruel...');
+ equals(_('Hello world').prune(22), 'Hello world');
+ equals(_('Привет, жестокий мир').prune(6, ' read more'), 'Привет read more');
+ equals(_('Привет, мир').prune(6, 'read a lot more'), 'Привет, мир');
+ equals(_('Привет, мир').prune(6), 'Привет...');
+ equals(_('Привет, мир').prune(8), 'Привет...');
+ equals(_('Привет, жестокий мир').prune(16), 'Привет, жестокий...');
+ equals(_('Привет, мир').prune(22), 'Привет, мир');
+ equals(_(123).prune(10), '123');
+ equals(_(123).prune(1,1), '11');
+ });
+
+ test('String: isBlank', function(){
+ ok(_('').isBlank());
+ ok(_(' ').isBlank());
+ ok(_('\n').isBlank());
+ ok(!_('a').isBlank());
+ ok(!_('0').isBlank());
+ ok(!_(0).isBlank());
+ });
+
+ test('String: escapeHTML', function(){
+ equals(_('Blah & "blah" & \'blah\'
').escapeHTML(),
+ '<div>Blah & "blah" & 'blah'</div>');
+ equals(_('<').escapeHTML(), '<');
+ equals(_(5).escapeHTML(), '5');
+ // equals(_(undefined).escapeHTML(), '');
+ });
+
+ test('String: unescapeHTML', function(){
+ equals(_('<div>Blah & "blah" & 'blah'</div>').unescapeHTML(),
+ 'Blah & "blah" & \'blah\'
');
+ equals(_('<').unescapeHTML(), '<');
+ equals(_(''').unescapeHTML(), "'");
+ equals(_(''').unescapeHTML(), "'");
+ equals(_('J').unescapeHTML(), "J");
+ equals(_('J').unescapeHTML(), "J");
+ equals(_('J').unescapeHTML(), "J");
+ equals(_('&_#39;').unescapeHTML(), "&_#39;");
+ equals(_(''_;').unescapeHTML(), "'_;");
+ equals(_('&').unescapeHTML(), "&");
+ equals(_('&').unescapeHTML(), "&");
+ equals(_(5).unescapeHTML(), '5');
+ // equals(_(undefined).unescapeHTML(), '');
+ });
+
+ test('String: words', function() {
+ equals(_("I love you!").words().length, 3);
+ equals(_(" I love you! ").words().length, 3);
+ equals(_("I_love_you!").words('_').length, 3);
+ equals(_("I-love-you!").words(/-/).length, 3);
+ equals(_(123).words().length, 1);
+ });
+
+ test('String: chars', function() {
+ equals(_("Hello").chars().length, 5);
+ equals(_(123).chars().length, 3);
+ });
+
+ test('String: lines', function() {
+ equals(_("Hello\nWorld").lines().length, 2);
+ equals(_("Hello World").lines().length, 1);
+ equals(_(123).lines().length, 1);
+ });
+
+ test('String: pad', function() {
+ equals(_("1").pad(8), ' 1');
+ equals(_(1).pad(8), ' 1');
+ equals(_("1").pad(8, '0'), '00000001');
+ equals(_("1").pad(8, '0', 'left'), '00000001');
+ equals(_("1").pad(8, '0', 'right'), '10000000');
+ equals(_("1").pad(8, '0', 'both'), '00001000');
+ equals(_("foo").pad(8, '0', 'both'), '000foo00');
+ equals(_("foo").pad(7, '0', 'both'), '00foo00');
+ equals(_("foo").pad(7, '!@$%dofjrofj', 'both'), '!!foo!!');
+ });
+
+ test('String: lpad', function() {
+ equals(_("1").lpad(8), ' 1');
+ equals(_(1).lpad(8), ' 1');
+ equals(_("1").lpad(8, '0'), '00000001');
+ equals(_("1").lpad(8, '0', 'left'), '00000001');
+ });
+
+ test('String: rpad', function() {
+ equals(_("1").rpad(8), '1 ');
+ equals(_(1).lpad(8), ' 1');
+ equals(_("1").rpad(8, '0'), '10000000');
+ equals(_("foo").rpad(8, '0'), 'foo00000');
+ equals(_("foo").rpad(7, '0'), 'foo0000');
+ });
+
+ test('String: lrpad', function() {
+ equals(_("1").lrpad(8), ' 1 ');
+ equals(_(1).lrpad(8), ' 1 ');
+ equals(_("1").lrpad(8, '0'), '00001000');
+ equals(_("foo").lrpad(8, '0'), '000foo00');
+ equals(_("foo").lrpad(7, '0'), '00foo00');
+ equals(_("foo").lrpad(7, '!@$%dofjrofj'), '!!foo!!');
+ });
+
+ test('String: toNumber', function() {
+ deepEqual(_("not a number").toNumber(), Number.NaN);
+ equals(_(0).toNumber(), 0);
+ equals(_("0").toNumber(), 0);
+ equals(_("0000").toNumber(), 0);
+ equals(_("2.345").toNumber(), 2);
+ equals(_("2.345").toNumber(NaN), 2);
+ equals(_("2.345").toNumber(2), 2.35);
+ equals(_("2.344").toNumber(2), 2.34);
+ equals(_("2").toNumber(2), 2.00);
+ equals(_(2).toNumber(2), 2.00);
+ equals(_(-2).toNumber(), -2);
+ equals(_("-2").toNumber(), -2);
+ });
+
+ test('String: strRight', function() {
+ equals(_("This_is_a_test_string").strRight("_"), "is_a_test_string");
+ equals(_("This_is_a_test_string").strRight("string"), "");
+ equals(_("This_is_a_test_string").strRight(), "This_is_a_test_string");
+ equals(_("This_is_a_test_string").strRight(""), "This_is_a_test_string");
+ equals(_("This_is_a_test_string").strRight("-"), "This_is_a_test_string");
+ equals(_(12345).strRight(2), "345");
+ });
+
+ test('String: strRightBack', function() {
+ equals(_("This_is_a_test_string").strRightBack("_"), "string");
+ equals(_("This_is_a_test_string").strRightBack("string"), "");
+ equals(_("This_is_a_test_string").strRightBack(), "This_is_a_test_string");
+ equals(_("This_is_a_test_string").strRightBack(""), "This_is_a_test_string");
+ equals(_("This_is_a_test_string").strRightBack("-"), "This_is_a_test_string");
+ equals(_(12345).strRightBack(2), "345");
+ });
+
+ test('String: strLeft', function() {
+ equals(_("This_is_a_test_string").strLeft("_"), "This");
+ equals(_("This_is_a_test_string").strLeft("This"), "");
+ equals(_("This_is_a_test_string").strLeft(), "This_is_a_test_string");
+ equals(_("This_is_a_test_string").strLeft(""), "This_is_a_test_string");
+ equals(_("This_is_a_test_string").strLeft("-"), "This_is_a_test_string");
+ equals(_(123454321).strLeft(3), "12");
+ });
+
+ test('String: strLeftBack', function() {
+ equals(_("This_is_a_test_string").strLeftBack("_"), "This_is_a_test");
+ equals(_("This_is_a_test_string").strLeftBack("This"), "");
+ equals(_("This_is_a_test_string").strLeftBack(), "This_is_a_test_string");
+ equals(_("This_is_a_test_string").strLeftBack(""), "This_is_a_test_string");
+ equals(_("This_is_a_test_string").strLeftBack("-"), "This_is_a_test_string");
+ equals(_(123454321).strLeftBack(3), "123454");
+ });
+
+ test('Strings: stripTags', function() {
+ equals(_('a link').stripTags(), 'a link');
+ equals(_('a link
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+