POLICY-SDK-APP/src/main/webapp/app/policyApp/CSS/bootstrap/docs/assets/js/vendor/autoprefixer.js

   1 !function(e){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=e();else if("function"==typeof define&&define.amd)define([],e);else{var f;"undefined"!=typeof window?f=window:"undefined"!=typeof global?f=global:"undefined"!=typeof self&&(f=self),f.autoprefixer=e()}}(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
   2 (function() {
   3   var Autoprefixer, Browsers, Prefixes, autoprefixer, browserslist, infoCache, isPlainObject, postcss,
   4     __slice = [].slice,
   5     __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; };
   6
   7   browserslist = require('browserslist');
   8
   9   postcss = require('postcss');
  10
  11   Browsers = require('./browsers');
  12
  13   Prefixes = require('./prefixes');
  14
  15   infoCache = null;
  16
  17   isPlainObject = function(obj) {
  18     return Object.prototype.toString.apply(obj) === '[object Object]';
  19   };
  20
  21   autoprefixer = function() {
  22     var options, reqs;
  23     reqs = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
  24     if (reqs.length === 1 && isPlainObject(reqs[0])) {
  25       options = reqs[0];
  26       reqs = void 0;
  27     } else if (reqs.length === 0 || (reqs.length === 1 && (reqs[0] == null))) {
  28       reqs = void 0;
  29     } else if (reqs.length <= 2 && (reqs[0] instanceof Array || (reqs[0] == null))) {
  30       options = reqs[1];
  31       reqs = reqs[0];
  32     } else if (typeof reqs[reqs.length - 1] === 'object') {
  33       options = reqs.pop();
  34     }
  35     if ((options != null ? options.browsers : void 0) != null) {
  36       reqs = options.browsers;
  37     }
  38     return new Autoprefixer(autoprefixer.data, reqs, options);
  39   };
  40
  41   autoprefixer.data = {
  42     browsers: require('../data/browsers'),
  43     prefixes: require('../data/prefixes')
  44   };
  45
  46   Autoprefixer = (function() {
  47     function Autoprefixer(data, reqs, options) {
  48       this.data = data;
  49       this.reqs = reqs;
  50       this.options = options != null ? options : {};
  51       this.postcss = __bind(this.postcss, this);
  52     }
  53
  54     Autoprefixer.prototype.process = function(str, options) {
  55       if (options == null) {
  56         options = {};
  57       }
  58       return postcss(this.postcss).process(str, options);
  59     };
  60
  61     Autoprefixer.prototype.postcss = function(css) {
  62       var prefixes;
  63       prefixes = this.prefixes({
  64         from: css.source.input.file
  65       });
  66       if (this.options.remove !== false) {
  67         prefixes.processor.remove(css);
  68       }
  69       return prefixes.processor.add(css);
  70     };
  71
  72     Autoprefixer.prototype.prefixes = function(opts) {
  73       var browsers;
  74       browsers = new Browsers(autoprefixer.data.browsers, this.reqs, opts);
  75       return new Prefixes(autoprefixer.data.prefixes, browsers, this.options);
  76     };
  77
  78     Autoprefixer.prototype.info = function(opts) {
  79       infoCache || (infoCache = require('./info'));
  80       return infoCache(this.prefixes(opts));
  81     };
  82
  83     return Autoprefixer;
  84
  85   })();
  86
  87   autoprefixer.defaults = browserslist.defaults;
  88
  89   autoprefixer.loadDefault = function() {
  90     return this.defaultCache || (this.defaultCache = autoprefixer());
  91   };
  92
  93   autoprefixer.process = function(str, options) {
  94     if (options == null) {
  95       options = {};
  96     }
  97     return this.loadDefault().process(str, options);
  98   };
  99
 100   autoprefixer.postcss = function(css) {
 101     return autoprefixer.loadDefault().postcss(css);
 102   };
 103
 104   autoprefixer.info = function() {
 105     return this.loadDefault().info();
 106   };
 107
 108   module.exports = autoprefixer;
 109
 110 }).call(this);
 111
 112 },{"../data/browsers":2,"../data/prefixes":3,"./browsers":5,"./info":37,"./prefixes":41,"browserslist":55,"postcss":107}],2:[function(require,module,exports){
 113 (function() {
 114   var data, name, _ref;
 115
 116   module.exports = {};
 117
 118   _ref = require('caniuse-db/data').agents;
 119   for (name in _ref) {
 120     data = _ref[name];
 121     module.exports[name] = {
 122       prefix: name === 'opera' ? '-o-' : "-" + data.prefix + "-"
 123     };
 124   }
 125
 126 }).call(this);
 127
 128 },{"caniuse-db/data":56}],3:[function(require,module,exports){
 129 (function() {
 130   var browsers, feature, filter, logicalProps, map, prefix, resolution, textDecoration,
 131     __slice = [].slice;
 132
 133   browsers = require('./browsers');
 134
 135   feature = function(data, opts, callback) {
 136     var browser, match, need, sorted, support, version, versions, _ref, _ref1;
 137     if (!callback) {
 138       _ref = [opts, {}], callback = _ref[0], opts = _ref[1];
 139     }
 140     match = opts.match || /\sx($|\s)/;
 141     need = [];
 142     _ref1 = data.stats;
 143     for (browser in _ref1) {
 144       versions = _ref1[browser];
 145       for (version in versions) {
 146         support = versions[version];
 147         if (browsers[browser] && support.match(match)) {
 148           need.push(browser + ' ' + version);
 149         }
 150       }
 151     }
 152     sorted = need.sort(function(a, b) {
 153       a = a.split(' ');
 154       b = b.split(' ');
 155       if (a[0] > b[0]) {
 156         return 1;
 157       } else if (a[0] < b[0]) {
 158         return -1;
 159       } else {
 160         return parseFloat(a[1]) - parseFloat(b[1]);
 161       }
 162     });
 163     return callback(sorted);
 164   };
 165
 166   map = function(browsers, callback) {
 167     var browser, name, version, _i, _len, _ref, _results;
 168     _results = [];
 169     for (_i = 0, _len = browsers.length; _i < _len; _i++) {
 170       browser = browsers[_i];
 171       _ref = browser.split(' '), name = _ref[0], version = _ref[1];
 172       version = parseFloat(version);
 173       _results.push(callback(browser, name, version));
 174     }
 175     return _results;
 176   };
 177
 178   filter = function(browsers, callback) {
 179     return browsers.filter(function(browser) {
 180       var name, version, _ref;
 181       _ref = browser.split(' '), name = _ref[0], version = _ref[1];
 182       version = parseFloat(version);
 183       return callback(name, version);
 184     });
 185   };
 186
 187   prefix = function() {
 188     var data, name, names, _i, _j, _len, _results;
 189     names = 2 <= arguments.length ? __slice.call(arguments, 0, _i = arguments.length - 1) : (_i = 0, []), data = arguments[_i++];
 190     _results = [];
 191     for (_j = 0, _len = names.length; _j < _len; _j++) {
 192       name = names[_j];
 193       _results.push(module.exports[name] = data);
 194     }
 195     return _results;
 196   };
 197
 198   module.exports = {};
 199
 200   feature(require('caniuse-db/features-json/border-radius'), function(browsers) {
 201     return prefix('border-radius', 'border-top-left-radius', 'border-top-right-radius', 'border-bottom-right-radius', 'border-bottom-left-radius', {
 202       mistakes: ['-ms-', '-o-'],
 203       transition: true,
 204       browsers: browsers
 205     });
 206   });
 207
 208   feature(require('caniuse-db/features-json/css-boxshadow'), function(browsers) {
 209     return prefix('box-shadow', {
 210       transition: true,
 211       browsers: browsers
 212     });
 213   });
 214
 215   feature(require('caniuse-db/features-json/css-animation'), function(browsers) {
 216     return prefix('animation', 'animation-name', 'animation-duration', 'animation-delay', 'animation-direction', 'animation-fill-mode', 'animation-iteration-count', 'animation-play-state', 'animation-timing-function', '@keyframes', {
 217       browsers: browsers
 218     });
 219   });
 220
 221   feature(require('caniuse-db/features-json/css-transitions'), function(browsers) {
 222     return prefix('transition', 'transition-property', 'transition-duration', 'transition-delay', 'transition-timing-function', {
 223       mistakes: ['-ms-'],
 224       browsers: browsers
 225     });
 226   });
 227
 228   feature(require('caniuse-db/features-json/transforms2d'), function(browsers) {
 229     return prefix('transform', 'transform-origin', {
 230       transition: true,
 231       browsers: browsers
 232     });
 233   });
 234
 235   feature(require('caniuse-db/features-json/transforms3d'), function(browsers) {
 236     prefix('perspective', 'perspective-origin', {
 237       transition: true,
 238       browsers: browsers
 239     });
 240     return prefix('transform-style', 'backface-visibility', {
 241       browsers: browsers
 242     });
 243   });
 244
 245   feature(require('caniuse-db/features-json/css-gradients'), function(browsers) {
 246     browsers = map(browsers, function(browser, name, version) {
 247       if (name === 'android' && version < 4 || name === 'ios_saf' && version < 5 || name === 'safari' && version < 5.1) {
 248         return browser + ' old';
 249       } else {
 250         return browser;
 251       }
 252     });
 253     return prefix('linear-gradient', 'repeating-linear-gradient', 'radial-gradient', 'repeating-radial-gradient', {
 254       props: ['background', 'background-image', 'border-image', 'list-style', 'list-style-image', 'content'],
 255       mistakes: ['-ms-'],
 256       browsers: browsers
 257     });
 258   });
 259
 260   feature(require('caniuse-db/features-json/css3-boxsizing'), function(browsers) {
 261     return prefix('box-sizing', {
 262       browsers: browsers
 263     });
 264   });
 265
 266   feature(require('caniuse-db/features-json/css-filters'), function(browsers) {
 267     return prefix('filter', {
 268       transition: true,
 269       browsers: browsers
 270     });
 271   });
 272
 273   feature(require('caniuse-db/features-json/multicolumn'), function(browsers) {
 274     prefix('columns', 'column-width', 'column-gap', 'column-rule', 'column-rule-color', 'column-rule-width', {
 275       transition: true,
 276       browsers: browsers
 277     });
 278     return prefix('column-count', 'column-rule-style', 'column-span', 'column-fill', 'break-before', 'break-after', 'break-inside', {
 279       browsers: browsers
 280     });
 281   });
 282
 283   feature(require('caniuse-db/features-json/user-select-none'), function(browsers) {
 284     return prefix('user-select', {
 285       browsers: browsers
 286     });
 287   });
 288
 289   feature(require('caniuse-db/features-json/flexbox'), function(browsers) {
 290     browsers = map(browsers, function(browser, name, version) {
 291       if (name === 'safari' && version < 6.1) {
 292         return browser + ' 2009';
 293       } else if (name === 'ios_saf' && version < 7) {
 294         return browser + ' 2009';
 295       } else if (name === 'chrome' && version < 21) {
 296         return browser + ' 2009';
 297       } else if (name === 'android' && version < 4.4) {
 298         return browser + ' 2009';
 299       } else {
 300         return browser;
 301       }
 302     });
 303     prefix('display-flex', 'inline-flex', {
 304       props: ['display'],
 305       browsers: browsers
 306     });
 307     prefix('flex', 'flex-grow', 'flex-shrink', 'flex-basis', {
 308       transition: true,
 309       browsers: browsers
 310     });
 311     return prefix('flex-direction', 'flex-wrap', 'flex-flow', 'justify-content', 'order', 'align-items', 'align-self', 'align-content', {
 312       browsers: browsers
 313     });
 314   });
 315
 316   feature(require('caniuse-db/features-json/calc'), function(browsers) {
 317     return prefix('calc', {
 318       props: ['*'],
 319       browsers: browsers
 320     });
 321   });
 322
 323   feature(require('caniuse-db/features-json/background-img-opts'), function(browsers) {
 324     return prefix('background-clip', 'background-origin', 'background-size', {
 325       browsers: browsers
 326     });
 327   });
 328
 329   feature(require('caniuse-db/features-json/font-feature'), function(browsers) {
 330     return prefix('font-feature-settings', 'font-variant-ligatures', 'font-language-override', 'font-kerning', {
 331       browsers: browsers
 332     });
 333   });
 334
 335   feature(require('caniuse-db/features-json/border-image'), function(browsers) {
 336     return prefix('border-image', {
 337       browsers: browsers
 338     });
 339   });
 340
 341   feature(require('caniuse-db/features-json/css-selection'), function(browsers) {
 342     return prefix('::selection', {
 343       selector: true,
 344       browsers: browsers
 345     });
 346   });
 347
 348   feature(require('caniuse-db/features-json/css-placeholder'), function(browsers) {
 349     browsers = map(browsers, function(browser, name, version) {
 350       if (name === 'firefox' && version <= 18) {
 351         return browser + ' old';
 352       } else {
 353         return browser;
 354       }
 355     });
 356     return prefix('::placeholder', {
 357       selector: true,
 358       browsers: browsers
 359     });
 360   });
 361
 362   feature(require('caniuse-db/features-json/css-hyphens'), function(browsers) {
 363     return prefix('hyphens', {
 364       browsers: browsers
 365     });
 366   });
 367
 368   feature(require('caniuse-db/features-json/fullscreen'), function(browsers) {
 369     return prefix(':fullscreen', {
 370       selector: true,
 371       browsers: browsers
 372     });
 373   });
 374
 375   feature(require('caniuse-db/features-json/css3-tabsize'), function(browsers) {
 376     return prefix('tab-size', {
 377       browsers: browsers
 378     });
 379   });
 380
 381   feature(require('caniuse-db/features-json/intrinsic-width'), function(browsers) {
 382     return prefix('max-content', 'min-content', 'fit-content', 'fill-available', {
 383       props: ['width', 'min-width', 'max-width', 'height', 'min-height', 'max-height'],
 384       browsers: browsers
 385     });
 386   });
 387
 388   feature(require('caniuse-db/features-json/css3-cursors-newer'), function(browsers) {
 389     prefix('zoom-in', 'zoom-out', {
 390       props: ['cursor'],
 391       browsers: browsers.concat(['chrome 3'])
 392     });
 393     return prefix('grab', 'grabbing', {
 394       props: ['cursor'],
 395       browsers: browsers.concat(['firefox 24', 'firefox 25', 'firefox 26'])
 396     });
 397   });
 398
 399   feature(require('caniuse-db/features-json/css-sticky'), function(browsers) {
 400     return prefix('sticky', {
 401       props: ['position'],
 402       browsers: browsers
 403     });
 404   });
 405
 406   feature(require('caniuse-db/features-json/pointer'), function(browsers) {
 407     return prefix('touch-action', {
 408       browsers: browsers
 409     });
 410   });
 411
 412   textDecoration = require('caniuse-db/features-json/text-decoration');
 413
 414   feature(textDecoration, function(browsers) {
 415     return prefix('text-decoration-style', {
 416       browsers: browsers
 417     });
 418   });
 419
 420   feature(textDecoration, {
 421     match: /y\sx($|\s)/
 422   }, function(browsers) {
 423     return prefix('text-decoration-line', 'text-decoration-color', {
 424       browsers: browsers
 425     });
 426   });
 427
 428   feature(require('caniuse-db/features-json/text-size-adjust'), function(browsers) {
 429     return prefix('text-size-adjust', {
 430       browsers: browsers
 431     });
 432   });
 433
 434   feature(require('caniuse-db/features-json/css-masks'), function(browsers) {
 435     return prefix('clip-path', 'mask', 'mask-clip', 'mask-composite', 'mask-image', 'mask-origin', 'mask-position', 'mask-repeat', 'mask-size', {
 436       browsers: browsers
 437     });
 438   });
 439
 440   feature(require('caniuse-db/features-json/css-boxdecorationbreak'), function(brwsrs) {
 441     return prefix('box-decoration-break', {
 442       browsers: brwsrs
 443     });
 444   });
 445
 446   feature(require('caniuse-db/features-json/object-fit'), function(browsers) {
 447     return prefix('object-fit', 'object-position', {
 448       browsers: browsers
 449     });
 450   });
 451
 452   feature(require('caniuse-db/features-json/css-shapes'), function(browsers) {
 453     return prefix('shape-margin', 'shape-outside', 'shape-image-threshold', {
 454       browsers: browsers
 455     });
 456   });
 457
 458   feature(require('caniuse-db/features-json/text-overflow'), function(browsers) {
 459     return prefix('text-overflow', {
 460       browsers: browsers
 461     });
 462   });
 463
 464   feature(require('caniuse-db/features-json/text-emphasis'), function(browsers) {
 465     return prefix('text-emphasis', {
 466       browsers: browsers
 467     });
 468   });
 469
 470   feature(require('caniuse-db/features-json/css-deviceadaptation'), function(browsers) {
 471     return prefix('@viewport', {
 472       browsers: browsers
 473     });
 474   });
 475
 476   resolution = require('caniuse-db/features-json/css-media-resolution');
 477
 478   feature(resolution, {
 479     match: /( x($| )|a #3)/
 480   }, function(browsers) {
 481     return prefix('@resolution', {
 482       browsers: browsers
 483     });
 484   });
 485
 486   feature(require('caniuse-db/features-json/css-text-align-last'), function(browsers) {
 487     return prefix('text-align-last', {
 488       browsers: browsers
 489     });
 490   });
 491
 492   feature(require('caniuse-db/features-json/css-crisp-edges'), function(browsers) {
 493     return prefix('crisp-edges', {
 494       props: ['image-rendering'],
 495       browsers: browsers
 496     });
 497   });
 498
 499   logicalProps = require('caniuse-db/features-json/css-logical-props');
 500
 501   feature(logicalProps, function(browsers) {
 502     return prefix('border-inline-start', 'border-inline-end', 'margin-inline-start', 'margin-inline-end', 'padding-inline-start', 'padding-inline-end', {
 503       transition: true,
 504       browsers: browsers
 505     });
 506   });
 507
 508   feature(logicalProps, function(browsers) {
 509     browsers = filter(browsers, function(i) {
 510       return i !== 'firefox' && i !== 'and_ff';
 511     });
 512     return prefix('border-block-start', 'border-block-end', 'margin-block-start', 'margin-block-end', 'padding-block-start', 'padding-block-end', {
 513       transition: true,
 514       browsers: browsers
 515     });
 516   });
 517
 518 }).call(this);
 519
 520 },{"./browsers":2,"caniuse-db/features-json/background-img-opts":57,"caniuse-db/features-json/border-image":58,"caniuse-db/features-json/border-radius":59,"caniuse-db/features-json/calc":60,"caniuse-db/features-json/css-animation":61,"caniuse-db/features-json/css-boxdecorationbreak":62,"caniuse-db/features-json/css-boxshadow":63,"caniuse-db/features-json/css-crisp-edges":64,"caniuse-db/features-json/css-deviceadaptation":65,"caniuse-db/features-json/css-filters":66,"caniuse-db/features-json/css-gradients":67,"caniuse-db/features-json/css-hyphens":68,"caniuse-db/features-json/css-logical-props":69,"caniuse-db/features-json/css-masks":70,"caniuse-db/features-json/css-media-resolution":71,"caniuse-db/features-json/css-placeholder":72,"caniuse-db/features-json/css-selection":73,"caniuse-db/features-json/css-shapes":74,"caniuse-db/features-json/css-sticky":75,"caniuse-db/features-json/css-text-align-last":76,"caniuse-db/features-json/css-transitions":77,"caniuse-db/features-json/css3-boxsizing":78,"caniuse-db/features-json/css3-cursors-newer":79,"caniuse-db/features-json/css3-tabsize":80,"caniuse-db/features-json/flexbox":81,"caniuse-db/features-json/font-feature":82,"caniuse-db/features-json/fullscreen":83,"caniuse-db/features-json/intrinsic-width":84,"caniuse-db/features-json/multicolumn":85,"caniuse-db/features-json/object-fit":86,"caniuse-db/features-json/pointer":87,"caniuse-db/features-json/text-decoration":88,"caniuse-db/features-json/text-emphasis":89,"caniuse-db/features-json/text-overflow":90,"caniuse-db/features-json/text-size-adjust":91,"caniuse-db/features-json/transforms2d":92,"caniuse-db/features-json/transforms3d":93,"caniuse-db/features-json/user-select-none":94}],4:[function(require,module,exports){
 521 (function() {
 522   var AtRule, Prefixer,
 523     __hasProp = {}.hasOwnProperty,
 524     __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
 525
 526   Prefixer = require('./prefixer');
 527
 528   AtRule = (function(_super) {
 529     __extends(AtRule, _super);
 530
 531     function AtRule() {
 532       return AtRule.__super__.constructor.apply(this, arguments);
 533     }
 534
 535     AtRule.prototype.add = function(rule, prefix) {
 536       var already, cloned, prefixed;
 537       prefixed = prefix + rule.name;
 538       already = rule.parent.some(function(i) {
 539         return i.name === prefixed && i.params === rule.params;
 540       });
 541       if (already) {
 542         return;
 543       }
 544       cloned = this.clone(rule, {
 545         name: prefixed
 546       });
 547       return rule.parent.insertBefore(rule, cloned);
 548     };
 549
 550     AtRule.prototype.process = function(node) {
 551       var parent, prefix, _i, _len, _ref, _results;
 552       parent = this.parentPrefix(node);
 553       _ref = this.prefixes;
 554       _results = [];
 555       for (_i = 0, _len = _ref.length; _i < _len; _i++) {
 556         prefix = _ref[_i];
 557         if (parent && parent !== prefix) {
 558           continue;
 559         }
 560         _results.push(this.add(node, prefix));
 561       }
 562       return _results;
 563     };
 564
 565     return AtRule;
 566
 567   })(Prefixer);
 568
 569   module.exports = AtRule;
 570
 571 }).call(this);
 572
 573 },{"./prefixer":40}],5:[function(require,module,exports){
 574 (function() {
 575   var Browsers, browserslist, utils;
 576
 577   browserslist = require('browserslist');
 578
 579   utils = require('./utils');
 580
 581   Browsers = (function() {
 582     Browsers.prefixes = function() {
 583       var data, i, name;
 584       if (this.prefixesCache) {
 585         return this.prefixesCache;
 586       }
 587       data = require('../data/browsers');
 588       return this.prefixesCache = utils.uniq((function() {
 589         var _results;
 590         _results = [];
 591         for (name in data) {
 592           i = data[name];
 593           _results.push(i.prefix);
 594         }
 595         return _results;
 596       })()).sort(function(a, b) {
 597         return b.length - a.length;
 598       });
 599     };
 600
 601     Browsers.withPrefix = function(value) {
 602       if (!this.prefixesRegexp) {
 603         this.prefixesRegexp = RegExp("" + (this.prefixes().join('|')));
 604       }
 605       return this.prefixesRegexp.test(value);
 606     };
 607
 608     function Browsers(data, requirements, options) {
 609       this.data = data;
 610       this.options = options;
 611       this.selected = this.parse(requirements);
 612     }
 613
 614     Browsers.prototype.parse = function(requirements) {
 615       var _ref;
 616       return browserslist(requirements, {
 617         path: (_ref = this.options) != null ? _ref.from : void 0
 618       });
 619     };
 620
 621     Browsers.prototype.browsers = function(criteria) {
 622       var browser, data, selected, versions, _ref;
 623       selected = [];
 624       _ref = this.data;
 625       for (browser in _ref) {
 626         data = _ref[browser];
 627         versions = criteria(data).map(function(version) {
 628           return "" + browser + " " + version;
 629         });
 630         selected = selected.concat(versions);
 631       }
 632       return selected;
 633     };
 634
 635     Browsers.prototype.prefix = function(browser) {
 636       var name, version, _ref;
 637       _ref = browser.split(' '), name = _ref[0], version = _ref[1];
 638       if (name === 'opera' && parseFloat(version) >= 15) {
 639         return '-webkit-';
 640       } else {
 641         return this.data[name].prefix;
 642       }
 643     };
 644
 645     Browsers.prototype.isSelected = function(browser) {
 646       return this.selected.indexOf(browser) !== -1;
 647     };
 648
 649     return Browsers;
 650
 651   })();
 652
 653   module.exports = Browsers;
 654
 655 }).call(this);
 656
 657 },{"../data/browsers":2,"./utils":46,"browserslist":55}],6:[function(require,module,exports){
 658 (function() {
 659   var Browsers, Declaration, Prefixer, utils, vendor,
 660     __hasProp = {}.hasOwnProperty,
 661     __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
 662
 663   Prefixer = require('./prefixer');
 664
 665   Browsers = require('./browsers');
 666
 667   vendor = require('postcss/lib/vendor');
 668
 669   utils = require('./utils');
 670
 671   Declaration = (function(_super) {
 672     __extends(Declaration, _super);
 673
 674     function Declaration() {
 675       return Declaration.__super__.constructor.apply(this, arguments);
 676     }
 677
 678     Declaration.prototype.check = function(decl) {
 679       return true;
 680     };
 681
 682     Declaration.prototype.prefixed = function(prop, prefix) {
 683       return prefix + prop;
 684     };
 685
 686     Declaration.prototype.normalize = function(prop) {
 687       return prop;
 688     };
 689
 690     Declaration.prototype.otherPrefixes = function(value, prefix) {
 691       var other, _i, _len, _ref;
 692       _ref = Browsers.prefixes();
 693       for (_i = 0, _len = _ref.length; _i < _len; _i++) {
 694         other = _ref[_i];
 695         if (other === prefix) {
 696           continue;
 697         }
 698         if (value.indexOf(other) !== -1) {
 699           return true;
 700         }
 701       }
 702       return false;
 703     };
 704
 705     Declaration.prototype.set = function(decl, prefix) {
 706       decl.prop = this.prefixed(decl.prop, prefix);
 707       return decl;
 708     };
 709
 710     Declaration.prototype.needCascade = function(decl) {
 711       return decl._autoprefixerCascade || (decl._autoprefixerCascade = this.all.options.cascade !== false && decl.style('before').indexOf('\n') !== -1);
 712     };
 713
 714     Declaration.prototype.maxPrefixed = function(prefixes, decl) {
 715       var max, prefix, _i, _len;
 716       if (decl._autoprefixerMax) {
 717         return decl._autoprefixerMax;
 718       }
 719       max = 0;
 720       for (_i = 0, _len = prefixes.length; _i < _len; _i++) {
 721         prefix = prefixes[_i];
 722         prefix = utils.removeNote(prefix);
 723         if (prefix.length > max) {
 724           max = prefix.length;
 725         }
 726       }
 727       return decl._autoprefixerMax = max;
 728     };
 729
 730     Declaration.prototype.calcBefore = function(prefixes, decl, prefix) {
 731       var before, diff, i, max, _i;
 732       if (prefix == null) {
 733         prefix = '';
 734       }
 735       before = decl.style('before');
 736       max = this.maxPrefixed(prefixes, decl);
 737       diff = max - utils.removeNote(prefix).length;
 738       for (i = _i = 0; 0 <= diff ? _i < diff : _i > diff; i = 0 <= diff ? ++_i : --_i) {
 739         before += ' ';
 740       }
 741       return before;
 742     };
 743
 744     Declaration.prototype.restoreBefore = function(decl) {
 745       var lines, min;
 746       lines = decl.style('before').split("\n");
 747       min = lines[lines.length - 1];
 748       this.all.group(decl).up(function(prefixed) {
 749         var array, last;
 750         array = prefixed.style('before').split("\n");
 751         last = array[array.length - 1];
 752         if (last.length < min.length) {
 753           return min = last;
 754         }
 755       });
 756       lines[lines.length - 1] = min;
 757       return decl.before = lines.join("\n");
 758     };
 759
 760     Declaration.prototype.insert = function(decl, prefix, prefixes) {
 761       var cloned;
 762       cloned = this.set(this.clone(decl), prefix);
 763       if (!cloned) {
 764         return;
 765       }
 766       if (this.needCascade(decl)) {
 767         cloned.before = this.calcBefore(prefixes, decl, prefix);
 768       }
 769       return decl.parent.insertBefore(decl, cloned);
 770     };
 771
 772     Declaration.prototype.add = function(decl, prefix, prefixes) {
 773       var already, prefixed;
 774       prefixed = this.prefixed(decl.prop, prefix);
 775       already = this.all.group(decl).up(function(i) {
 776         return i.prop === prefixed;
 777       });
 778       already || (already = this.all.group(decl).down(function(i) {
 779         return i.prop === prefixed;
 780       }));
 781       if (already || this.otherPrefixes(decl.value, prefix)) {
 782         return;
 783       }
 784       return this.insert(decl, prefix, prefixes);
 785     };
 786
 787     Declaration.prototype.process = function(decl) {
 788       var prefixes;
 789       if (this.needCascade(decl)) {
 790         prefixes = Declaration.__super__.process.apply(this, arguments);
 791         if (prefixes != null ? prefixes.length : void 0) {
 792           this.restoreBefore(decl);
 793           return decl.before = this.calcBefore(prefixes, decl);
 794         }
 795       } else {
 796         return Declaration.__super__.process.apply(this, arguments);
 797       }
 798     };
 799
 800     Declaration.prototype.old = function(prop, prefix) {
 801       return [this.prefixed(prop, prefix)];
 802     };
 803
 804     return Declaration;
 805
 806   })(Prefixer);
 807
 808   module.exports = Declaration;
 809
 810 }).call(this);
 811
 812 },{"./browsers":5,"./prefixer":40,"./utils":46,"postcss/lib/vendor":113}],7:[function(require,module,exports){
 813 (function() {
 814   var AlignContent, Declaration, flexSpec,
 815     __hasProp = {}.hasOwnProperty,
 816     __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
 817
 818   flexSpec = require('./flex-spec');
 819
 820   Declaration = require('../declaration');
 821
 822   AlignContent = (function(_super) {
 823     __extends(AlignContent, _super);
 824
 825     function AlignContent() {
 826       return AlignContent.__super__.constructor.apply(this, arguments);
 827     }
 828
 829     AlignContent.names = ['align-content', 'flex-line-pack'];
 830
 831     AlignContent.oldValues = {
 832       'flex-end': 'end',
 833       'flex-start': 'start',
 834       'space-between': 'justify',
 835       'space-around': 'distribute'
 836     };
 837
 838     AlignContent.prototype.prefixed = function(prop, prefix) {
 839       var spec, _ref;
 840       _ref = flexSpec(prefix), spec = _ref[0], prefix = _ref[1];
 841       if (spec === 2012) {
 842         return prefix + 'flex-line-pack';
 843       } else {
 844         return AlignContent.__super__.prefixed.apply(this, arguments);
 845       }
 846     };
 847
 848     AlignContent.prototype.normalize = function(prop) {
 849       return 'align-content';
 850     };
 851
 852     AlignContent.prototype.set = function(decl, prefix) {
 853       var spec;
 854       spec = flexSpec(prefix)[0];
 855       if (spec === 2012) {
 856         decl.value = AlignContent.oldValues[decl.value] || decl.value;
 857         return AlignContent.__super__.set.call(this, decl, prefix);
 858       } else if (spec === 'final') {
 859         return AlignContent.__super__.set.apply(this, arguments);
 860       }
 861     };
 862
 863     return AlignContent;
 864
 865   })(Declaration);
 866
 867   module.exports = AlignContent;
 868
 869 }).call(this);
 870
 871 },{"../declaration":6,"./flex-spec":25}],8:[function(require,module,exports){
 872 (function() {
 873   var AlignItems, Declaration, flexSpec,
 874     __hasProp = {}.hasOwnProperty,
 875     __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
 876
 877   flexSpec = require('./flex-spec');
 878
 879   Declaration = require('../declaration');
 880
 881   AlignItems = (function(_super) {
 882     __extends(AlignItems, _super);
 883
 884     function AlignItems() {
 885       return AlignItems.__super__.constructor.apply(this, arguments);
 886     }
 887
 888     AlignItems.names = ['align-items', 'flex-align', 'box-align'];
 889
 890     AlignItems.oldValues = {
 891       'flex-end': 'end',
 892       'flex-start': 'start'
 893     };
 894
 895     AlignItems.prototype.prefixed = function(prop, prefix) {
 896       var spec, _ref;
 897       _ref = flexSpec(prefix), spec = _ref[0], prefix = _ref[1];
 898       if (spec === 2009) {
 899         return prefix + 'box-align';
 900       } else if (spec === 2012) {
 901         return prefix + 'flex-align';
 902       } else {
 903         return AlignItems.__super__.prefixed.apply(this, arguments);
 904       }
 905     };
 906
 907     AlignItems.prototype.normalize = function(prop) {
 908       return 'align-items';
 909     };
 910
 911     AlignItems.prototype.set = function(decl, prefix) {
 912       var spec;
 913       spec = flexSpec(prefix)[0];
 914       if (spec === 2009 || spec === 2012) {
 915         decl.value = AlignItems.oldValues[decl.value] || decl.value;
 916         return AlignItems.__super__.set.call(this, decl, prefix);
 917       } else {
 918         return AlignItems.__super__.set.apply(this, arguments);
 919       }
 920     };
 921
 922     return AlignItems;
 923
 924   })(Declaration);
 925
 926   module.exports = AlignItems;
 927
 928 }).call(this);
 929
 930 },{"../declaration":6,"./flex-spec":25}],9:[function(require,module,exports){
 931 (function() {
 932   var AlignSelf, Declaration, flexSpec,
 933     __hasProp = {}.hasOwnProperty,
 934     __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
 935
 936   flexSpec = require('./flex-spec');
 937
 938   Declaration = require('../declaration');
 939
 940   AlignSelf = (function(_super) {
 941     __extends(AlignSelf, _super);
 942
 943     function AlignSelf() {
 944       return AlignSelf.__super__.constructor.apply(this, arguments);
 945     }
 946
 947     AlignSelf.names = ['align-self', 'flex-item-align'];
 948
 949     AlignSelf.oldValues = {
 950       'flex-end': 'end',
 951       'flex-start': 'start'
 952     };
 953
 954     AlignSelf.prototype.prefixed = function(prop, prefix) {
 955       var spec, _ref;
 956       _ref = flexSpec(prefix), spec = _ref[0], prefix = _ref[1];
 957       if (spec === 2012) {
 958         return prefix + 'flex-item-align';
 959       } else {
 960         return AlignSelf.__super__.prefixed.apply(this, arguments);
 961       }
 962     };
 963
 964     AlignSelf.prototype.normalize = function(prop) {
 965       return 'align-self';
 966     };
 967
 968     AlignSelf.prototype.set = function(decl, prefix) {
 969       var spec;
 970       spec = flexSpec(prefix)[0];
 971       if (spec === 2012) {
 972         decl.value = AlignSelf.oldValues[decl.value] || decl.value;
 973         return AlignSelf.__super__.set.call(this, decl, prefix);
 974       } else if (spec === 'final') {
 975         return AlignSelf.__super__.set.apply(this, arguments);
 976       }
 977     };
 978
 979     return AlignSelf;
 980
 981   })(Declaration);
 982
 983   module.exports = AlignSelf;
 984
 985 }).call(this);
 986
 987 },{"../declaration":6,"./flex-spec":25}],10:[function(require,module,exports){
 988 (function() {
 989   var BackgroundSize, Declaration,
 990     __hasProp = {}.hasOwnProperty,
 991     __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
 992
 993   Declaration = require('../declaration');
 994
 995   BackgroundSize = (function(_super) {
 996     __extends(BackgroundSize, _super);
 997
 998     function BackgroundSize() {
 999       return BackgroundSize.__super__.constructor.apply(this, arguments);
1000     }
1001
1002     BackgroundSize.names = ['background-size'];
1003
1004     BackgroundSize.prototype.set = function(decl, prefix) {
1005       var value;
1006       value = decl.value.toLowerCase();
1007       if (prefix === '-webkit-' && value.indexOf(' ') === -1 && value !== 'contain' && value !== 'cover') {
1008         decl.value = decl.value + ' ' + decl.value;
1009       }
1010       return BackgroundSize.__super__.set.call(this, decl, prefix);
1011     };
1012
1013     return BackgroundSize;
1014
1015   })(Declaration);
1016
1017   module.exports = BackgroundSize;
1018
1019 }).call(this);
1020
1021 },{"../declaration":6}],11:[function(require,module,exports){
1022 (function() {
1023   var BlockLogical, Declaration,
1024     __hasProp = {}.hasOwnProperty,
1025     __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
1026
1027   Declaration = require('../declaration');
1028
1029   BlockLogical = (function(_super) {
1030     __extends(BlockLogical, _super);
1031
1032     function BlockLogical() {
1033       return BlockLogical.__super__.constructor.apply(this, arguments);
1034     }
1035
1036     BlockLogical.names = ['border-block-start', 'border-block-end', 'margin-block-start', 'margin-block-end', 'padding-block-start', 'padding-block-end', 'border-before', 'border-after', 'margin-before', 'margin-after', 'padding-before', 'padding-after'];
1037
1038     BlockLogical.prototype.prefixed = function(prop, prefix) {
1039       return prefix + (prop.indexOf('-start') !== -1 ? prop.replace('-block-start', '-before') : prop.replace('-block-end', '-after'));
1040     };
1041
1042     BlockLogical.prototype.normalize = function(prop) {
1043       if (prop.indexOf('-before') !== -1) {
1044         return prop.replace('-before', '-block-start');
1045       } else {
1046         return prop.replace('-after', '-block-end');
1047       }
1048     };
1049
1050     return BlockLogical;
1051
1052   })(Declaration);
1053
1054   module.exports = BlockLogical;
1055
1056 }).call(this);
1057
1058 },{"../declaration":6}],12:[function(require,module,exports){
1059 (function() {
1060   var BorderImage, Declaration,
1061     __hasProp = {}.hasOwnProperty,
1062     __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
1063
1064   Declaration = require('../declaration');
1065
1066   BorderImage = (function(_super) {
1067     __extends(BorderImage, _super);
1068
1069     function BorderImage() {
1070       return BorderImage.__super__.constructor.apply(this, arguments);
1071     }
1072
1073     BorderImage.names = ['border-image'];
1074
1075     BorderImage.prototype.set = function(decl, prefix) {
1076       decl.value = decl.value.replace(/\s+fill(\s)/, '$1');
1077       return BorderImage.__super__.set.call(this, decl, prefix);
1078     };
1079
1080     return BorderImage;
1081
1082   })(Declaration);
1083
1084   module.exports = BorderImage;
1085
1086 }).call(this);
1087
1088 },{"../declaration":6}],13:[function(require,module,exports){
1089 (function() {
1090   var BorderRadius, Declaration,
1091     __hasProp = {}.hasOwnProperty,
1092     __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
1093
1094   Declaration = require('../declaration');
1095
1096   BorderRadius = (function(_super) {
1097     var hor, mozilla, normal, ver, _i, _j, _len, _len1, _ref, _ref1;
1098
1099     __extends(BorderRadius, _super);
1100
1101     function BorderRadius() {
1102       return BorderRadius.__super__.constructor.apply(this, arguments);
1103     }
1104
1105     BorderRadius.names = ['border-radius'];
1106
1107     BorderRadius.toMozilla = {};
1108
1109     BorderRadius.toNormal = {};
1110
1111     _ref = ['top', 'bottom'];
1112     for (_i = 0, _len = _ref.length; _i < _len; _i++) {
1113       ver = _ref[_i];
1114       _ref1 = ['left', 'right'];
1115       for (_j = 0, _len1 = _ref1.length; _j < _len1; _j++) {
1116         hor = _ref1[_j];
1117         normal = "border-" + ver + "-" + hor + "-radius";
1118         mozilla = "border-radius-" + ver + hor;
1119         BorderRadius.names.push(normal);
1120         BorderRadius.names.push(mozilla);
1121         BorderRadius.toMozilla[normal] = mozilla;
1122         BorderRadius.toNormal[mozilla] = normal;
1123       }
1124     }
1125
1126     BorderRadius.prototype.prefixed = function(prop, prefix) {
1127       if (prefix === '-moz-') {
1128         return prefix + (BorderRadius.toMozilla[prop] || prop);
1129       } else {
1130         return BorderRadius.__super__.prefixed.apply(this, arguments);
1131       }
1132     };
1133
1134     BorderRadius.prototype.normalize = function(prop) {
1135       return BorderRadius.toNormal[prop] || prop;
1136     };
1137
1138     return BorderRadius;
1139
1140   })(Declaration);
1141
1142   module.exports = BorderRadius;
1143
1144 }).call(this);
1145
1146 },{"../declaration":6}],14:[function(require,module,exports){
1147 (function() {
1148   var BreakInside, Declaration,
1149     __hasProp = {}.hasOwnProperty,
1150     __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
1151
1152   Declaration = require('../declaration');
1153
1154   BreakInside = (function(_super) {
1155     __extends(BreakInside, _super);
1156
1157     function BreakInside() {
1158       return BreakInside.__super__.constructor.apply(this, arguments);
1159     }
1160
1161     BreakInside.names = ['break-inside', 'page-break-inside', 'column-break-inside'];
1162
1163     BreakInside.prototype.prefixed = function(prop, prefix) {
1164       if (prefix === '-webkit-') {
1165         return prefix + 'column-break-inside';
1166       } else if (prefix === '-moz-') {
1167         return 'page-break-inside';
1168       } else {
1169         return BreakInside.__super__.prefixed.apply(this, arguments);
1170       }
1171     };
1172
1173     BreakInside.prototype.normalize = function() {
1174       return 'break-inside';
1175     };
1176
1177     BreakInside.prototype.set = function(decl, prefix) {
1178       if (decl.value === 'avoid-column' || decl.value === 'avoid-page') {
1179         decl.value = 'avoid';
1180       }
1181       return BreakInside.__super__.set.apply(this, arguments);
1182     };
1183
1184     BreakInside.prototype.insert = function(decl, prefix, prefixes) {
1185       if (decl.value === 'avoid-region') {
1186
1187       } else if (decl.value === 'avoid-page' && prefix === '-webkit-') {
1188
1189       } else {
1190         return BreakInside.__super__.insert.apply(this, arguments);
1191       }
1192     };
1193
1194     return BreakInside;
1195
1196   })(Declaration);
1197
1198   module.exports = BreakInside;
1199
1200 }).call(this);
1201
1202 },{"../declaration":6}],15:[function(require,module,exports){
1203 (function() {
1204   var CrispEdges, Value,
1205     __hasProp = {}.hasOwnProperty,
1206     __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
1207
1208   Value = require('../value');
1209
1210   CrispEdges = (function(_super) {
1211     __extends(CrispEdges, _super);
1212
1213     function CrispEdges() {
1214       return CrispEdges.__super__.constructor.apply(this, arguments);
1215     }
1216
1217     CrispEdges.names = ['crisp-edges'];
1218
1219     CrispEdges.prototype.replace = function(string, prefix) {
1220       if (prefix === '-webkit-') {
1221         return string.replace(this.regexp(), '$1-webkit-optimize-contrast');
1222       } else {
1223         return CrispEdges.__super__.replace.apply(this, arguments);
1224       }
1225     };
1226
1227     return CrispEdges;
1228
1229   })(Value);
1230
1231   module.exports = CrispEdges;
1232
1233 }).call(this);
1234
1235 },{"../value":47}],16:[function(require,module,exports){
1236 (function() {
1237   var DisplayFlex, OldDisplayFlex, OldValue, Value, flexSpec,
1238     __hasProp = {}.hasOwnProperty,
1239     __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
1240
1241   flexSpec = require('./flex-spec');
1242
1243   OldValue = require('../old-value');
1244
1245   Value = require('../value');
1246
1247   OldDisplayFlex = (function(_super) {
1248     __extends(OldDisplayFlex, _super);
1249
1250     function OldDisplayFlex(unprefixed, prefixed) {
1251       this.unprefixed = unprefixed;
1252       this.prefixed = prefixed;
1253     }
1254
1255     OldDisplayFlex.prototype.check = function(value) {
1256       return value === this.name;
1257     };
1258
1259     return OldDisplayFlex;
1260
1261   })(OldValue);
1262
1263   DisplayFlex = (function(_super) {
1264     __extends(DisplayFlex, _super);
1265
1266     DisplayFlex.names = ['display-flex', 'inline-flex'];
1267
1268     function DisplayFlex(name, prefixes) {
1269       DisplayFlex.__super__.constructor.apply(this, arguments);
1270       if (name === 'display-flex') {
1271         this.name = 'flex';
1272       }
1273     }
1274
1275     DisplayFlex.prototype.check = function(decl) {
1276       return decl.value === this.name;
1277     };
1278
1279     DisplayFlex.prototype.prefixed = function(prefix) {
1280       var spec, _ref;
1281       _ref = flexSpec(prefix), spec = _ref[0], prefix = _ref[1];
1282       return prefix + (spec === 2009 ? this.name === 'flex' ? 'box' : 'inline-box' : spec === 2012 ? this.name === 'flex' ? 'flexbox' : 'inline-flexbox' : spec === 'final' ? this.name : void 0);
1283     };
1284
1285     DisplayFlex.prototype.replace = function(string, prefix) {
1286       return this.prefixed(prefix);
1287     };
1288
1289     DisplayFlex.prototype.old = function(prefix) {
1290       var prefixed;
1291       prefixed = this.prefixed(prefix);
1292       if (prefixed) {
1293         return new OldValue(this.name, prefixed);
1294       }
1295     };
1296
1297     return DisplayFlex;
1298
1299   })(Value);
1300
1301   module.exports = DisplayFlex;
1302
1303 }).call(this);
1304
1305 },{"../old-value":39,"../value":47,"./flex-spec":25}],17:[function(require,module,exports){
1306 (function() {
1307   var FillAvailable, OldValue, Value,
1308     __hasProp = {}.hasOwnProperty,
1309     __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
1310
1311   OldValue = require('../old-value');
1312
1313   Value = require('../value');
1314
1315   FillAvailable = (function(_super) {
1316     __extends(FillAvailable, _super);
1317
1318     function FillAvailable() {
1319       return FillAvailable.__super__.constructor.apply(this, arguments);
1320     }
1321
1322     FillAvailable.names = ['fill-available'];
1323
1324     FillAvailable.prototype.replace = function(string, prefix) {
1325       if (prefix === '-moz-') {
1326         return string.replace(this.regexp(), '$1-moz-available$3');
1327       } else {
1328         return FillAvailable.__super__.replace.apply(this, arguments);
1329       }
1330     };
1331
1332     FillAvailable.prototype.old = function(prefix) {
1333       if (prefix === '-moz-') {
1334         return new OldValue(this.name, '-moz-available');
1335       } else {
1336         return FillAvailable.__super__.old.apply(this, arguments);
1337       }
1338     };
1339
1340     return FillAvailable;
1341
1342   })(Value);
1343
1344   module.exports = FillAvailable;
1345
1346 }).call(this);
1347
1348 },{"../old-value":39,"../value":47}],18:[function(require,module,exports){
1349 (function() {
1350   var FilterValue, OldFilterValue, OldValue, Value, utils,
1351     __hasProp = {}.hasOwnProperty,
1352     __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
1353
1354   OldValue = require('../old-value');
1355
1356   Value = require('../value');
1357
1358   utils = require('../utils');
1359
1360   OldFilterValue = (function(_super) {
1361     __extends(OldFilterValue, _super);
1362
1363     function OldFilterValue() {
1364       return OldFilterValue.__super__.constructor.apply(this, arguments);
1365     }
1366
1367     OldFilterValue.prototype.clean = function(decl) {
1368       return decl.value = utils.editList(decl.value, (function(_this) {
1369         return function(props) {
1370           if (props.every(function(i) {
1371             return i.indexOf(_this.unprefixed) !== 0;
1372           })) {
1373             return props;
1374           }
1375           return props.filter(function(i) {
1376             return i.indexOf(_this.prefixed) === -1;
1377           });
1378         };
1379       })(this));
1380     };
1381
1382     return OldFilterValue;
1383
1384   })(OldValue);
1385
1386   FilterValue = (function(_super) {
1387     __extends(FilterValue, _super);
1388
1389     function FilterValue() {
1390       return FilterValue.__super__.constructor.apply(this, arguments);
1391     }
1392
1393     FilterValue.names = ['filter'];
1394
1395     FilterValue.prototype.replace = function(value, prefix) {
1396       if (prefix === '-webkit-') {
1397         if (value.indexOf('-webkit-filter') === -1) {
1398           return FilterValue.__super__.replace.apply(this, arguments) + ', ' + value;
1399         } else {
1400           return value;
1401         }
1402       } else {
1403         return FilterValue.__super__.replace.apply(this, arguments);
1404       }
1405     };
1406
1407     FilterValue.prototype.old = function(prefix) {
1408       return new OldFilterValue(this.name, prefix + this.name);
1409     };
1410
1411     return FilterValue;
1412
1413   })(Value);
1414
1415   module.exports = FilterValue;
1416
1417 }).call(this);
1418
1419 },{"../old-value":39,"../utils":46,"../value":47}],19:[function(require,module,exports){
1420 (function() {
1421   var Declaration, Filter,
1422     __hasProp = {}.hasOwnProperty,
1423     __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
1424
1425   Declaration = require('../declaration');
1426
1427   Filter = (function(_super) {
1428     __extends(Filter, _super);
1429
1430     function Filter() {
1431       return Filter.__super__.constructor.apply(this, arguments);
1432     }
1433
1434     Filter.names = ['filter'];
1435
1436     Filter.prototype.check = function(decl) {
1437       var v;
1438       v = decl.value;
1439       return v.toLowerCase().indexOf('alpha(') === -1 && v.indexOf('DXImageTransform.Microsoft') === -1 && v.indexOf('data:image/svg+xml') === -1;
1440     };
1441
1442     return Filter;
1443
1444   })(Declaration);
1445
1446   module.exports = Filter;
1447
1448 }).call(this);
1449
1450 },{"../declaration":6}],20:[function(require,module,exports){
1451 (function() {
1452   var Declaration, FlexBasis, flexSpec,
1453     __hasProp = {}.hasOwnProperty,
1454     __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
1455
1456   flexSpec = require('./flex-spec');
1457
1458   Declaration = require('../declaration');
1459
1460   FlexBasis = (function(_super) {
1461     __extends(FlexBasis, _super);
1462
1463     function FlexBasis() {
1464       return FlexBasis.__super__.constructor.apply(this, arguments);
1465     }
1466
1467     FlexBasis.names = ['flex-basis', 'flex-preferred-size'];
1468
1469     FlexBasis.prototype.normalize = function() {
1470       return 'flex-basis';
1471     };
1472
1473     FlexBasis.prototype.prefixed = function(prop, prefix) {
1474       var spec, _ref;
1475       _ref = flexSpec(prefix), spec = _ref[0], prefix = _ref[1];
1476       if (spec === 2012) {
1477         return prefix + 'flex-preferred-size';
1478       } else {
1479         return FlexBasis.__super__.prefixed.apply(this, arguments);
1480       }
1481     };
1482
1483     FlexBasis.prototype.set = function(decl, prefix) {
1484       var spec, _ref;
1485       _ref = flexSpec(prefix), spec = _ref[0], prefix = _ref[1];
1486       if (spec === 2012 || spec === 'final') {
1487         return FlexBasis.__super__.set.apply(this, arguments);
1488       }
1489     };
1490
1491     return FlexBasis;
1492
1493   })(Declaration);
1494
1495   module.exports = FlexBasis;
1496
1497 }).call(this);
1498
1499 },{"../declaration":6,"./flex-spec":25}],21:[function(require,module,exports){
1500 (function() {
1501   var Declaration, FlexDirection, flexSpec,
1502     __hasProp = {}.hasOwnProperty,
1503     __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
1504
1505   flexSpec = require('./flex-spec');
1506
1507   Declaration = require('../declaration');
1508
1509   FlexDirection = (function(_super) {
1510     __extends(FlexDirection, _super);
1511
1512     function FlexDirection() {
1513       return FlexDirection.__super__.constructor.apply(this, arguments);
1514     }
1515
1516     FlexDirection.names = ['flex-direction', 'box-direction', 'box-orient'];
1517
1518     FlexDirection.prototype.normalize = function(prop) {
1519       return 'flex-direction';
1520     };
1521
1522     FlexDirection.prototype.insert = function(decl, prefix, prefixes) {
1523       var already, cloned, dir, orient, spec, value, _ref;
1524       _ref = flexSpec(prefix), spec = _ref[0], prefix = _ref[1];
1525       if (spec === 2009) {
1526         already = decl.parent.some(function(i) {
1527           return i.prop === prefix + 'box-orient' || i.prop === prefix + 'box-direction';
1528         });
1529         if (already) {
1530           return;
1531         }
1532         value = decl.value;
1533         orient = value.indexOf('row') !== -1 ? 'horizontal' : 'vertical';
1534         dir = value.indexOf('reverse') !== -1 ? 'reverse' : 'normal';
1535         cloned = this.clone(decl);
1536         cloned.prop = prefix + 'box-orient';
1537         cloned.value = orient;
1538         if (this.needCascade(decl)) {
1539           cloned.before = this.calcBefore(prefixes, decl, prefix);
1540         }
1541         decl.parent.insertBefore(decl, cloned);
1542         cloned = this.clone(decl);
1543         cloned.prop = prefix + 'box-direction';
1544         cloned.value = dir;
1545         if (this.needCascade(decl)) {
1546           cloned.before = this.calcBefore(prefixes, decl, prefix);
1547         }
1548         return decl.parent.insertBefore(decl, cloned);
1549       } else {
1550         return FlexDirection.__super__.insert.apply(this, arguments);
1551       }
1552     };
1553
1554     FlexDirection.prototype.old = function(prop, prefix) {
1555       var spec, _ref;
1556       _ref = flexSpec(prefix), spec = _ref[0], prefix = _ref[1];
1557       if (spec === 2009) {
1558         return [prefix + 'box-orient', prefix + 'box-direction'];
1559       } else {
1560         return FlexDirection.__super__.old.apply(this, arguments);
1561       }
1562     };
1563
1564     return FlexDirection;
1565
1566   })(Declaration);
1567
1568   module.exports = FlexDirection;
1569
1570 }).call(this);
1571
1572 },{"../declaration":6,"./flex-spec":25}],22:[function(require,module,exports){
1573 (function() {
1574   var Declaration, FlexFlow, flexSpec,
1575     __hasProp = {}.hasOwnProperty,
1576     __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
1577
1578   flexSpec = require('./flex-spec');
1579
1580   Declaration = require('../declaration');
1581
1582   FlexFlow = (function(_super) {
1583     __extends(FlexFlow, _super);
1584
1585     function FlexFlow() {
1586       return FlexFlow.__super__.constructor.apply(this, arguments);
1587     }
1588
1589     FlexFlow.names = ['flex-flow'];
1590
1591     FlexFlow.prototype.set = function(decl, prefix) {
1592       var spec, _ref;
1593       _ref = flexSpec(prefix), spec = _ref[0], prefix = _ref[1];
1594       if (spec === 2012) {
1595         return FlexFlow.__super__.set.apply(this, arguments);
1596       } else if (spec === 'final') {
1597         return FlexFlow.__super__.set.apply(this, arguments);
1598       }
1599     };
1600
1601     return FlexFlow;
1602
1603   })(Declaration);
1604
1605   module.exports = FlexFlow;
1606
1607 }).call(this);
1608
1609 },{"../declaration":6,"./flex-spec":25}],23:[function(require,module,exports){
1610 (function() {
1611   var Declaration, Flex, flexSpec,
1612     __hasProp = {}.hasOwnProperty,
1613     __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
1614
1615   flexSpec = require('./flex-spec');
1616
1617   Declaration = require('../declaration');
1618
1619   Flex = (function(_super) {
1620     __extends(Flex, _super);
1621
1622     function Flex() {
1623       return Flex.__super__.constructor.apply(this, arguments);
1624     }
1625
1626     Flex.names = ['flex-grow', 'flex-positive'];
1627
1628     Flex.prototype.normalize = function() {
1629       return 'flex';
1630     };
1631
1632     Flex.prototype.prefixed = function(prop, prefix) {
1633       var spec, _ref;
1634       _ref = flexSpec(prefix), spec = _ref[0], prefix = _ref[1];
1635       if (spec === 2009) {
1636         return prefix + 'box-flex';
1637       } else if (spec === 2012) {
1638         return prefix + 'flex-positive';
1639       } else {
1640         return Flex.__super__.prefixed.apply(this, arguments);
1641       }
1642     };
1643
1644     return Flex;
1645
1646   })(Declaration);
1647
1648   module.exports = Flex;
1649
1650 }).call(this);
1651
1652 },{"../declaration":6,"./flex-spec":25}],24:[function(require,module,exports){
1653 (function() {
1654   var Declaration, FlexShrink, flexSpec,
1655     __hasProp = {}.hasOwnProperty,
1656     __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
1657
1658   flexSpec = require('./flex-spec');
1659
1660   Declaration = require('../declaration');
1661
1662   FlexShrink = (function(_super) {
1663     __extends(FlexShrink, _super);
1664
1665     function FlexShrink() {
1666       return FlexShrink.__super__.constructor.apply(this, arguments);
1667     }
1668
1669     FlexShrink.names = ['flex-shrink', 'flex-negative'];
1670
1671     FlexShrink.prototype.normalize = function() {
1672       return 'flex-shrink';
1673     };
1674
1675     FlexShrink.prototype.prefixed = function(prop, prefix) {
1676       var spec, _ref;
1677       _ref = flexSpec(prefix), spec = _ref[0], prefix = _ref[1];
1678       if (spec === 2012) {
1679         return prefix + 'flex-negative';
1680       } else {
1681         return FlexShrink.__super__.prefixed.apply(this, arguments);
1682       }
1683     };
1684
1685     FlexShrink.prototype.set = function(decl, prefix) {
1686       var spec, _ref;
1687       _ref = flexSpec(prefix), spec = _ref[0], prefix = _ref[1];
1688       if (spec === 2012 || spec === 'final') {
1689         return FlexShrink.__super__.set.apply(this, arguments);
1690       }
1691     };
1692
1693     return FlexShrink;
1694
1695   })(Declaration);
1696
1697   module.exports = FlexShrink;
1698
1699 }).call(this);
1700
1701 },{"../declaration":6,"./flex-spec":25}],25:[function(require,module,exports){
1702 (function() {
1703   module.exports = function(prefix) {
1704     var spec;
1705     spec = prefix === '-webkit- 2009' || prefix === '-moz-' ? 2009 : prefix === '-ms-' ? 2012 : prefix === '-webkit-' ? 'final' : void 0;
1706     if (prefix === '-webkit- 2009') {
1707       prefix = '-webkit-';
1708     }
1709     return [spec, prefix];
1710   };
1711
1712 }).call(this);
1713
1714 },{}],26:[function(require,module,exports){
1715 (function() {
1716   var FlexValues, OldValue, Value,
1717     __hasProp = {}.hasOwnProperty,
1718     __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
1719
1720   OldValue = require('../old-value');
1721
1722   Value = require('../value');
1723
1724   FlexValues = (function(_super) {
1725     __extends(FlexValues, _super);
1726
1727     function FlexValues() {
1728       return FlexValues.__super__.constructor.apply(this, arguments);
1729     }
1730
1731     FlexValues.names = ['flex', 'flex-grow', 'flex-shrink', 'flex-basis'];
1732
1733     FlexValues.prototype.prefixed = function(prefix) {
1734       return this.all.prefixed(this.name, prefix);
1735     };
1736
1737     FlexValues.prototype.replace = function(string, prefix) {
1738       return string.replace(this.regexp(), '$1' + this.prefixed(prefix) + '$3');
1739     };
1740
1741     FlexValues.prototype.old = function(prefix) {
1742       return new OldValue(this.name, this.prefixed(prefix));
1743     };
1744
1745     return FlexValues;
1746
1747   })(Value);
1748
1749   module.exports = FlexValues;
1750
1751 }).call(this);
1752
1753 },{"../old-value":39,"../value":47}],27:[function(require,module,exports){
1754 (function() {
1755   var Declaration, FlexWrap, flexSpec,
1756     __hasProp = {}.hasOwnProperty,
1757     __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
1758
1759   flexSpec = require('./flex-spec');
1760
1761   Declaration = require('../declaration');
1762
1763   FlexWrap = (function(_super) {
1764     __extends(FlexWrap, _super);
1765
1766     function FlexWrap() {
1767       return FlexWrap.__super__.constructor.apply(this, arguments);
1768     }
1769
1770     FlexWrap.names = ['flex-wrap'];
1771
1772     FlexWrap.prototype.set = function(decl, prefix) {
1773       var spec;
1774       spec = flexSpec(prefix)[0];
1775       if (spec !== 2009) {
1776         return FlexWrap.__super__.set.apply(this, arguments);
1777       }
1778     };
1779
1780     return FlexWrap;
1781
1782   })(Declaration);
1783
1784   module.exports = FlexWrap;
1785
1786 }).call(this);
1787
1788 },{"../declaration":6,"./flex-spec":25}],28:[function(require,module,exports){
1789 (function() {
1790   var Declaration, Flex, flexSpec,
1791     __hasProp = {}.hasOwnProperty,
1792     __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
1793
1794   flexSpec = require('./flex-spec');
1795
1796   Declaration = require('../declaration');
1797
1798   Flex = (function(_super) {
1799     __extends(Flex, _super);
1800
1801     function Flex() {
1802       return Flex.__super__.constructor.apply(this, arguments);
1803     }
1804
1805     Flex.names = ['flex', 'box-flex'];
1806
1807     Flex.oldValues = {
1808       'auto': '1',
1809       'none': '0'
1810     };
1811
1812     Flex.prototype.prefixed = function(prop, prefix) {
1813       var spec, _ref;
1814       _ref = flexSpec(prefix), spec = _ref[0], prefix = _ref[1];
1815       if (spec === 2009) {
1816         return prefix + 'box-flex';
1817       } else {
1818         return Flex.__super__.prefixed.apply(this, arguments);
1819       }
1820     };
1821
1822     Flex.prototype.normalize = function() {
1823       return 'flex';
1824     };
1825
1826     Flex.prototype.set = function(decl, prefix) {
1827       var spec;
1828       spec = flexSpec(prefix)[0];
1829       if (spec === 2009) {
1830         decl.value = decl.value.split(' ')[0];
1831         decl.value = Flex.oldValues[decl.value] || decl.value;
1832         return Flex.__super__.set.call(this, decl, prefix);
1833       } else {
1834         return Flex.__super__.set.apply(this, arguments);
1835       }
1836     };
1837
1838     return Flex;
1839
1840   })(Declaration);
1841
1842   module.exports = Flex;
1843
1844 }).call(this);
1845
1846 },{"../declaration":6,"./flex-spec":25}],29:[function(require,module,exports){
1847 (function() {
1848   var Fullscreen, Selector,
1849     __hasProp = {}.hasOwnProperty,
1850     __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
1851
1852   Selector = require('../selector');
1853
1854   Fullscreen = (function(_super) {
1855     __extends(Fullscreen, _super);
1856
1857     function Fullscreen() {
1858       return Fullscreen.__super__.constructor.apply(this, arguments);
1859     }
1860
1861     Fullscreen.names = [':fullscreen'];
1862
1863     Fullscreen.prototype.prefixed = function(prefix) {
1864       if ('-webkit-' === prefix) {
1865         return ':-webkit-full-screen';
1866       } else if ('-moz-' === prefix) {
1867         return ':-moz-full-screen';
1868       } else {
1869         return ":" + prefix + "fullscreen";
1870       }
1871     };
1872
1873     return Fullscreen;
1874
1875   })(Selector);
1876
1877   module.exports = Fullscreen;
1878
1879 }).call(this);
1880
1881 },{"../selector":44}],30:[function(require,module,exports){
1882 (function() {
1883   var Gradient, OldValue, Value, isDirection, list, utils,
1884     __hasProp = {}.hasOwnProperty,
1885     __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
1886
1887   OldValue = require('../old-value');
1888
1889   Value = require('../value');
1890
1891   utils = require('../utils');
1892
1893   list = require('postcss/lib/list');
1894
1895   isDirection = /top|left|right|bottom/gi;
1896
1897   Gradient = (function(_super) {
1898     __extends(Gradient, _super);
1899
1900     function Gradient() {
1901       return Gradient.__super__.constructor.apply(this, arguments);
1902     }
1903
1904     Gradient.names = ['linear-gradient', 'repeating-linear-gradient', 'radial-gradient', 'repeating-radial-gradient'];
1905
1906     Gradient.prototype.replace = function(string, prefix) {
1907       return list.space(string).map((function(_this) {
1908         return function(value) {
1909           var after, args, close, params;
1910           if (value.slice(0, +_this.name.length + 1 || 9e9) !== _this.name + '(') {
1911             return value;
1912           }
1913           close = value.lastIndexOf(')');
1914           after = value.slice(close + 1);
1915           args = value.slice(_this.name.length + 1, +(close - 1) + 1 || 9e9);
1916           params = list.comma(args);
1917           params = _this.newDirection(params);
1918           if (prefix === '-webkit- old') {
1919             if (args.indexOf('px') === -1) {
1920               return _this.oldWebkit(value, args, params, after);
1921             }
1922           } else {
1923             _this.convertDirection(params);
1924             return prefix + _this.name + '(' + params.join(', ') + ')' + after;
1925           }
1926         };
1927       })(this)).join(' ');
1928     };
1929
1930     Gradient.prototype.directions = {
1931       top: 'bottom',
1932       left: 'right',
1933       bottom: 'top',
1934       right: 'left'
1935     };
1936
1937     Gradient.prototype.oldDirections = {
1938       'top': 'left bottom, left top',
1939       'left': 'right top, left top',
1940       'bottom': 'left top, left bottom',
1941       'right': 'left top, right top',
1942       'top right': 'left bottom, right top',
1943       'top left': 'right bottom, left top',
1944       'right top': 'left bottom, right top',
1945       'right bottom': 'left top, right bottom',
1946       'bottom right': 'left top, right bottom',
1947       'bottom left': 'right top, left bottom',
1948       'left top': 'right bottom, left top',
1949       'left bottom': 'right top, left bottom'
1950     };
1951
1952     Gradient.prototype.newDirection = function(params) {
1953       var first, value;
1954       first = params[0];
1955       if (first.indexOf('to ') === -1 && isDirection.test(first)) {
1956         first = first.split(' ');
1957         first = (function() {
1958           var _i, _len, _results;
1959           _results = [];
1960           for (_i = 0, _len = first.length; _i < _len; _i++) {
1961             value = first[_i];
1962             _results.push(this.directions[value.toLowerCase()] || value);
1963           }
1964           return _results;
1965         }).call(this);
1966         params[0] = 'to ' + first.join(' ');
1967       }
1968       return params;
1969     };
1970
1971     Gradient.prototype.oldWebkit = function(value, args, params, after) {
1972       if (this.name !== 'linear-gradient') {
1973         return value;
1974       }
1975       if (params[0] && params[0].indexOf('deg') !== -1) {
1976         return value;
1977       }
1978       if (args.indexOf('-corner') !== -1) {
1979         return value;
1980       }
1981       if (args.indexOf('-side') !== -1) {
1982         return value;
1983       }
1984       params = this.oldDirection(params);
1985       params = this.colorStops(params);
1986       return '-webkit-gradient(linear, ' + params.join(', ') + ')' + after;
1987     };
1988
1989     Gradient.prototype.convertDirection = function(params) {
1990       if (params.length > 0) {
1991         if (params[0].slice(0, 3) === 'to ') {
1992           return params[0] = this.fixDirection(params[0]);
1993         } else if (params[0].indexOf('deg') !== -1) {
1994           return params[0] = this.fixAngle(params[0]);
1995         } else if (params[0].indexOf(' at ') !== -1) {
1996           return this.fixRadial(params);
1997         }
1998       }
1999     };
2000
2001     Gradient.prototype.fixDirection = function(param) {
2002       var value;
2003       param = param.split(' ');
2004       param.splice(0, 1);
2005       param = (function() {
2006         var _i, _len, _results;
2007         _results = [];
2008         for (_i = 0, _len = param.length; _i < _len; _i++) {
2009           value = param[_i];
2010           _results.push(this.directions[value.toLowerCase()] || value);
2011         }
2012         return _results;
2013       }).call(this);
2014       return param.join(' ');
2015     };
2016
2017     Gradient.prototype.roundFloat = function(float, digits) {
2018       return parseFloat(float.toFixed(digits));
2019     };
2020
2021     Gradient.prototype.fixAngle = function(param) {
2022       param = parseFloat(param);
2023       param = Math.abs(450 - param) % 360;
2024       param = this.roundFloat(param, 3);
2025       return "" + param + "deg";
2026     };
2027
2028     Gradient.prototype.oldDirection = function(params) {
2029       var direction;
2030       if (params.length === 0) {
2031         params;
2032       }
2033       if (params[0].indexOf('to ') !== -1) {
2034         direction = params[0].replace(/^to\s+/, '');
2035         direction = this.oldDirections[direction];
2036         params[0] = direction;
2037         return params;
2038       } else {
2039         direction = this.oldDirections.bottom;
2040         return [direction].concat(params);
2041       }
2042     };
2043
2044     Gradient.prototype.colorStops = function(params) {
2045       return params.map(function(param, i) {
2046         var color, match, position, _ref;
2047         if (i === 0) {
2048           return param;
2049         }
2050         _ref = list.space(param), color = _ref[0], position = _ref[1];
2051         if (position == null) {
2052           match = param.match(/^(.*\))(\d.*)$/);
2053           if (match) {
2054             color = match[1];
2055             position = match[2];
2056           }
2057         }
2058         if (position && position.indexOf(')') !== -1) {
2059           color += ' ' + position;
2060           position = void 0;
2061         }
2062         if (i === 1 && (position === void 0 || position === '0%')) {
2063           return "from(" + color + ")";
2064         } else if (i === params.length - 1 && (position === void 0 || position === '100%')) {
2065           return "to(" + color + ")";
2066         } else if (position) {
2067           return "color-stop(" + position + ", " + color + ")";
2068         } else {
2069           return "color-stop(" + color + ")";
2070         }
2071       });
2072     };
2073
2074     Gradient.prototype.fixRadial = function(params) {
2075       var first;
2076       first = params[0].split(/\s+at\s+/);
2077       return params.splice(0, 1, first[1], first[0]);
2078     };
2079
2080     Gradient.prototype.old = function(prefix) {
2081       var regexp, string, type;
2082       if (prefix === '-webkit-') {
2083         type = this.name === 'linear-gradient' ? 'linear' : 'radial';
2084         string = '-gradient';
2085         regexp = utils.regexp("-webkit-(" + type + "-gradient|gradient\\(\\s*" + type + ")", false);
2086         return new OldValue(this.name, prefix + this.name, string, regexp);
2087       } else {
2088         return Gradient.__super__.old.apply(this, arguments);
2089       }
2090     };
2091
2092     Gradient.prototype.add = function(decl, prefix) {
2093       var prop;
2094       prop = decl.prop;
2095       if (prop === 'list-style' || prop === 'list-style-image' || prop === 'content') {
2096         if (prefix === '-webkit-' || prefix === '-webkit- old') {
2097           return Gradient.__super__.add.apply(this, arguments);
2098         }
2099       } else {
2100         return Gradient.__super__.add.apply(this, arguments);
2101       }
2102     };
2103
2104     return Gradient;
2105
2106   })(Value);
2107
2108   module.exports = Gradient;
2109
2110 }).call(this);
2111
2112 },{"../old-value":39,"../utils":46,"../value":47,"postcss/lib/list":102}],31:[function(require,module,exports){
2113 (function() {
2114   var Declaration, InlineLogical,
2115     __hasProp = {}.hasOwnProperty,
2116     __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
2117
2118   Declaration = require('../declaration');
2119
2120   InlineLogical = (function(_super) {
2121     __extends(InlineLogical, _super);
2122
2123     function InlineLogical() {
2124       return InlineLogical.__super__.constructor.apply(this, arguments);
2125     }
2126
2127     InlineLogical.names = ['border-inline-start', 'border-inline-end', 'margin-inline-start', 'margin-inline-end', 'padding-inline-start', 'padding-inline-end', 'border-start', 'border-end', 'margin-start', 'margin-end', 'padding-start', 'padding-end'];
2128
2129     InlineLogical.prototype.prefixed = function(prop, prefix) {
2130       return prefix + prop.replace('-inline', '');
2131     };
2132
2133     InlineLogical.prototype.normalize = function(prop) {
2134       return prop.replace(/(margin|padding|border)-(start|end)/, '$1-inline-$2');
2135     };
2136
2137     return InlineLogical;
2138
2139   })(Declaration);
2140
2141   module.exports = InlineLogical;
2142
2143 }).call(this);
2144
2145 },{"../declaration":6}],32:[function(require,module,exports){
2146 (function() {
2147   var Declaration, JustifyContent, flexSpec,
2148     __hasProp = {}.hasOwnProperty,
2149     __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
2150
2151   flexSpec = require('./flex-spec');
2152
2153   Declaration = require('../declaration');
2154
2155   JustifyContent = (function(_super) {
2156     __extends(JustifyContent, _super);
2157
2158     function JustifyContent() {
2159       return JustifyContent.__super__.constructor.apply(this, arguments);
2160     }
2161
2162     JustifyContent.names = ['justify-content', 'flex-pack', 'box-pack'];
2163
2164     JustifyContent.oldValues = {
2165       'flex-end': 'end',
2166       'flex-start': 'start',
2167       'space-between': 'justify',
2168       'space-around': 'distribute'
2169     };
2170
2171     JustifyContent.prototype.prefixed = function(prop, prefix) {
2172       var spec, _ref;
2173       _ref = flexSpec(prefix), spec = _ref[0], prefix = _ref[1];
2174       if (spec === 2009) {
2175         return prefix + 'box-pack';
2176       } else if (spec === 2012) {
2177         return prefix + 'flex-pack';
2178       } else {
2179         return JustifyContent.__super__.prefixed.apply(this, arguments);
2180       }
2181     };
2182
2183     JustifyContent.prototype.normalize = function(prop) {
2184       return 'justify-content';
2185     };
2186
2187     JustifyContent.prototype.set = function(decl, prefix) {
2188       var spec, value;
2189       spec = flexSpec(prefix)[0];
2190       if (spec === 2009 || spec === 2012) {
2191         value = JustifyContent.oldValues[decl.value] || decl.value;
2192         decl.value = value;
2193         if (spec !== 2009 || value !== 'distribute') {
2194           return JustifyContent.__super__.set.call(this, decl, prefix);
2195         }
2196       } else if (spec === 'final') {
2197         return JustifyContent.__super__.set.apply(this, arguments);
2198       }
2199     };
2200
2201     return JustifyContent;
2202
2203   })(Declaration);
2204
2205   module.exports = JustifyContent;
2206
2207 }).call(this);
2208
2209 },{"../declaration":6,"./flex-spec":25}],33:[function(require,module,exports){
2210 (function() {
2211   var Declaration, Order, flexSpec,
2212     __hasProp = {}.hasOwnProperty,
2213     __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
2214
2215   flexSpec = require('./flex-spec');
2216
2217   Declaration = require('../declaration');
2218
2219   Order = (function(_super) {
2220     __extends(Order, _super);
2221
2222     function Order() {
2223       return Order.__super__.constructor.apply(this, arguments);
2224     }
2225
2226     Order.names = ['order', 'flex-order', 'box-ordinal-group'];
2227
2228     Order.prototype.prefixed = function(prop, prefix) {
2229       var spec, _ref;
2230       _ref = flexSpec(prefix), spec = _ref[0], prefix = _ref[1];
2231       if (spec === 2009) {
2232         return prefix + 'box-ordinal-group';
2233       } else if (spec === 2012) {
2234         return prefix + 'flex-order';
2235       } else {
2236         return Order.__super__.prefixed.apply(this, arguments);
2237       }
2238     };
2239
2240     Order.prototype.normalize = function(prop) {
2241       return 'order';
2242     };
2243
2244     Order.prototype.set = function(decl, prefix) {
2245       var spec;
2246       spec = flexSpec(prefix)[0];
2247       if (spec === 2009) {
2248         decl.value = (parseInt(decl.value) + 1).toString();
2249         return Order.__super__.set.call(this, decl, prefix);
2250       } else {
2251         return Order.__super__.set.apply(this, arguments);
2252       }
2253     };
2254
2255     return Order;
2256
2257   })(Declaration);
2258
2259   module.exports = Order;
2260
2261 }).call(this);
2262
2263 },{"../declaration":6,"./flex-spec":25}],34:[function(require,module,exports){
2264 (function() {
2265   var Placeholder, Selector,
2266     __hasProp = {}.hasOwnProperty,
2267     __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
2268
2269   Selector = require('../selector');
2270
2271   Placeholder = (function(_super) {
2272     __extends(Placeholder, _super);
2273
2274     function Placeholder() {
2275       return Placeholder.__super__.constructor.apply(this, arguments);
2276     }
2277
2278     Placeholder.names = ['::placeholder'];
2279
2280     Placeholder.prototype.possible = function() {
2281       return Placeholder.__super__.possible.apply(this, arguments).concat('-moz- old');
2282     };
2283
2284     Placeholder.prototype.prefixed = function(prefix) {
2285       if ('-webkit-' === prefix) {
2286         return '::-webkit-input-placeholder';
2287       } else if ('-ms-' === prefix) {
2288         return ':-ms-input-placeholder';
2289       } else if ('-moz- old' === prefix) {
2290         return ':-moz-placeholder';
2291       } else {
2292         return "::" + prefix + "placeholder";
2293       }
2294     };
2295
2296     return Placeholder;
2297
2298   })(Selector);
2299
2300   module.exports = Placeholder;
2301
2302 }).call(this);
2303
2304 },{"../selector":44}],35:[function(require,module,exports){
2305 (function() {
2306   var Declaration, TransformDecl,
2307     __hasProp = {}.hasOwnProperty,
2308     __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
2309
2310   Declaration = require('../declaration');
2311
2312   TransformDecl = (function(_super) {
2313     __extends(TransformDecl, _super);
2314
2315     function TransformDecl() {
2316       return TransformDecl.__super__.constructor.apply(this, arguments);
2317     }
2318
2319     TransformDecl.names = ['transform', 'transform-origin'];
2320
2321     TransformDecl.functions3d = ['matrix3d', 'translate3d', 'translateZ', 'scale3d', 'scaleZ', 'rotate3d', 'rotateX', 'rotateY', 'rotateZ', 'perspective'];
2322
2323     TransformDecl.prototype.keykrameParents = function(decl) {
2324       var parent;
2325       parent = decl.parent;
2326       while (parent) {
2327         if (parent.type === 'atrule' && parent.name === 'keyframes') {
2328           return true;
2329         }
2330         parent = parent.parent;
2331       }
2332       return false;
2333     };
2334
2335     TransformDecl.prototype.contain3d = function(decl) {
2336       var func, _i, _len, _ref;
2337       if (decl.prop === 'transform-origin') {
2338         return false;
2339       }
2340       _ref = TransformDecl.functions3d;
2341       for (_i = 0, _len = _ref.length; _i < _len; _i++) {
2342         func = _ref[_i];
2343         if (decl.value.indexOf("" + func + "(") !== -1) {
2344           return true;
2345         }
2346       }
2347       return false;
2348     };
2349
2350     TransformDecl.prototype.insert = function(decl, prefix, prefixes) {
2351       if (prefix === '-ms-') {
2352         if (!this.contain3d(decl) && !this.keykrameParents(decl)) {
2353           return TransformDecl.__super__.insert.apply(this, arguments);
2354         }
2355       } else if (prefix === '-o-') {
2356         if (!this.contain3d(decl)) {
2357           return TransformDecl.__super__.insert.apply(this, arguments);
2358         }
2359       } else {
2360         return TransformDecl.__super__.insert.apply(this, arguments);
2361       }
2362     };
2363
2364     return TransformDecl;
2365
2366   })(Declaration);
2367
2368   module.exports = TransformDecl;
2369
2370 }).call(this);
2371
2372 },{"../declaration":6}],36:[function(require,module,exports){
2373 (function() {
2374   var TransformValue, Value,
2375     __hasProp = {}.hasOwnProperty,
2376     __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
2377
2378   Value = require('../value');
2379
2380   TransformValue = (function(_super) {
2381     __extends(TransformValue, _super);
2382
2383     function TransformValue() {
2384       return TransformValue.__super__.constructor.apply(this, arguments);
2385     }
2386
2387     TransformValue.names = ['transform'];
2388
2389     TransformValue.prototype.replace = function(value, prefix) {
2390       if (prefix === '-ms-') {
2391         return value;
2392       } else {
2393         return TransformValue.__super__.replace.apply(this, arguments);
2394       }
2395     };
2396
2397     return TransformValue;
2398
2399   })(Value);
2400
2401   module.exports = TransformValue;
2402
2403 }).call(this);
2404
2405 },{"../value":47}],37:[function(require,module,exports){
2406 (function() {
2407   var capitalize, names, prefix;
2408
2409   capitalize = function(str) {
2410     return str.slice(0, 1).toUpperCase() + str.slice(1);
2411   };
2412
2413   names = {
2414     ie: 'IE',
2415     ie_mob: 'IE Mobile',
2416     ios_saf: 'iOS',
2417     op_mini: 'Opera Mini',
2418     op_mob: 'Opera Mobile',
2419     and_chr: 'Chrome for Android',
2420     and_ff: 'Firefox for Android',
2421     and_uc: 'UC for Android'
2422   };
2423
2424   prefix = function(name, transition, prefixes) {
2425     var out;
2426     out = '  ' + name + (transition ? '*' : '') + ': ';
2427     out += prefixes.map(function(i) {
2428       return i.replace(/^-(.*)-$/g, '$1');
2429     }).join(', ');
2430     out += "\n";
2431     return out;
2432   };
2433
2434   module.exports = function(prefixes) {
2435     var atrules, browser, data, list, name, needTransition, out, props, selector, selectors, string, transitionProp, useTransition, value, values, version, versions, _i, _j, _k, _len, _len1, _len2, _ref, _ref1, _ref2, _ref3, _ref4, _ref5, _ref6;
2436     if (prefixes.browsers.selected.length === 0) {
2437       return "No browsers selected";
2438     }
2439     versions = [];
2440     _ref = prefixes.browsers.selected;
2441     for (_i = 0, _len = _ref.length; _i < _len; _i++) {
2442       browser = _ref[_i];
2443       _ref1 = browser.split(' '), name = _ref1[0], version = _ref1[1];
2444       name = names[name] || capitalize(name);
2445       if (versions[name]) {
2446         versions[name].push(version);
2447       } else {
2448         versions[name] = [version];
2449       }
2450     }
2451     out = "Browsers:\n";
2452     for (browser in versions) {
2453       list = versions[browser];
2454       list = list.sort(function(a, b) {
2455         return parseFloat(b) - parseFloat(a);
2456       });
2457       out += '  ' + browser + ': ' + list.join(', ') + "\n";
2458     }
2459     atrules = '';
2460     _ref2 = prefixes.add;
2461     for (name in _ref2) {
2462       data = _ref2[name];
2463       if (name[0] === '@' && data.prefixes) {
2464         atrules += prefix(name, false, data.prefixes);
2465       }
2466     }
2467     if (atrules !== '') {
2468       out += "\nAt-Rules:\n" + atrules;
2469     }
2470     selectors = '';
2471     _ref3 = prefixes.add.selectors;
2472     for (_j = 0, _len1 = _ref3.length; _j < _len1; _j++) {
2473       selector = _ref3[_j];
2474       if (selector.prefixes) {
2475         selectors += prefix(selector.name, false, selector.prefixes);
2476       }
2477     }
2478     if (selectors !== '') {
2479       out += "\nSelectors:\n" + selectors;
2480     }
2481     values = '';
2482     props = '';
2483     useTransition = false;
2484     needTransition = (_ref4 = prefixes.add.transition) != null ? _ref4.prefixes : void 0;
2485     _ref5 = prefixes.add;
2486     for (name in _ref5) {
2487       data = _ref5[name];
2488       if (name[0] !== '@' && data.prefixes) {
2489         transitionProp = needTransition && prefixes.data[name].transition;
2490         if (transitionProp) {
2491           useTransition = true;
2492         }
2493         props += prefix(name, transitionProp, data.prefixes);
2494       }
2495       if (!data.values) {
2496         continue;
2497       }
2498       if (prefixes.transitionProps.some(function(i) {
2499         return i === name;
2500       })) {
2501         continue;
2502       }
2503       _ref6 = data.values;
2504       for (_k = 0, _len2 = _ref6.length; _k < _len2; _k++) {
2505         value = _ref6[_k];
2506         string = prefix(value.name, false, value.prefixes);
2507         if (values.indexOf(string) === -1) {
2508           values += string;
2509         }
2510       }
2511     }
2512     if (useTransition) {
2513       props += "  * - can be used in transition\n";
2514     }
2515     if (props !== '') {
2516       out += "\nProperties:\n" + props;
2517     }
2518     if (values !== '') {
2519       out += "\nValues:\n" + values;
2520     }
2521     if (atrules === '' && selectors === '' && props === '' && values === '') {
2522       out += '\nAwesome! Your browsers don\'t require any vendor prefixes.' + '\nNow you can remove Autoprefixer from build steps.';
2523     }
2524     return out;
2525   };
2526
2527 }).call(this);
2528
2529 },{}],38:[function(require,module,exports){
2530 (function() {
2531   var OldSelector;
2532
2533   OldSelector = (function() {
2534     function OldSelector(selector, prefix) {
2535       var _i, _len, _ref;
2536       this.prefix = prefix;
2537       this.prefixed = selector.prefixed(this.prefix);
2538       this.regexp = selector.regexp(this.prefix);
2539       this.prefixeds = [];
2540       _ref = selector.possible();
2541       for (_i = 0, _len = _ref.length; _i < _len; _i++) {
2542         prefix = _ref[_i];
2543         this.prefixeds.push([selector.prefixed(prefix), selector.regexp(prefix)]);
2544       }
2545       this.unprefixed = selector.name;
2546       this.nameRegexp = selector.regexp();
2547     }
2548
2549     OldSelector.prototype.isHack = function(rule) {
2550       var before, index, regexp, rules, some, string, _i, _len, _ref, _ref1;
2551       index = rule.parent.index(rule) + 1;
2552       rules = rule.parent.nodes;
2553       while (index < rules.length) {
2554         before = rules[index].selector;
2555         if (!before) {
2556           return true;
2557         }
2558         if (before.indexOf(this.unprefixed) !== -1 && before.match(this.nameRegexp)) {
2559           return false;
2560         }
2561         some = false;
2562         _ref = this.prefixeds;
2563         for (_i = 0, _len = _ref.length; _i < _len; _i++) {
2564           _ref1 = _ref[_i], string = _ref1[0], regexp = _ref1[1];
2565           if (before.indexOf(string) !== -1 && before.match(regexp)) {
2566             some = true;
2567             break;
2568           }
2569         }
2570         if (!some) {
2571           return true;
2572         }
2573         index += 1;
2574       }
2575       return true;
2576     };
2577
2578     OldSelector.prototype.check = function(rule) {
2579       if (rule.selector.indexOf(this.prefixed) === -1) {
2580         return false;
2581       }
2582       if (!rule.selector.match(this.regexp)) {
2583         return false;
2584       }
2585       if (this.isHack(rule)) {
2586         return false;
2587       }
2588       return true;
2589     };
2590
2591     return OldSelector;
2592
2593   })();
2594
2595   module.exports = OldSelector;
2596
2597 }).call(this);
2598
2599 },{}],39:[function(require,module,exports){
2600 (function() {
2601   var OldValue, utils;
2602
2603   utils = require('./utils');
2604
2605   OldValue = (function() {
2606     function OldValue(unprefixed, prefixed, string, regexp) {
2607       this.unprefixed = unprefixed;
2608       this.prefixed = prefixed;
2609       this.string = string;
2610       this.regexp = regexp;
2611       this.regexp || (this.regexp = utils.regexp(this.prefixed));
2612       this.string || (this.string = this.prefixed);
2613     }
2614
2615     OldValue.prototype.check = function(value) {
2616       if (value.indexOf(this.string) !== -1) {
2617         return !!value.match(this.regexp);
2618       } else {
2619         return false;
2620       }
2621     };
2622
2623     return OldValue;
2624
2625   })();
2626
2627   module.exports = OldValue;
2628
2629 }).call(this);
2630
2631 },{"./utils":46}],40:[function(require,module,exports){
2632 (function() {
2633   var Browsers, Prefixer, clone, utils, vendor,
2634     __hasProp = {}.hasOwnProperty;
2635
2636   Browsers = require('./browsers');
2637
2638   utils = require('./utils');
2639
2640   vendor = require('postcss/lib/vendor');
2641
2642   clone = function(obj, parent) {
2643     var cloned, i, value;
2644     if (typeof obj !== 'object') {
2645       return obj;
2646     }
2647     cloned = new obj.constructor();
2648     for (i in obj) {
2649       if (!__hasProp.call(obj, i)) continue;
2650       value = obj[i];
2651       if (i === 'parent' && typeof value === 'object') {
2652         if (parent) {
2653           cloned[i] = parent;
2654         }
2655       } else if (i === 'source') {
2656         cloned[i] = value;
2657       } else if (value instanceof Array) {
2658         cloned[i] = value.map(function(i) {
2659           return clone(i, cloned);
2660         });
2661       } else if (i !== '_autoprefixerPrefix' && i !== '_autoprefixerValues') {
2662         cloned[i] = clone(value, cloned);
2663       }
2664     }
2665     return cloned;
2666   };
2667
2668   Prefixer = (function() {
2669     Prefixer.hack = function(klass) {
2670       var name, _i, _len, _ref, _results;
2671       this.hacks || (this.hacks = {});
2672       _ref = klass.names;
2673       _results = [];
2674       for (_i = 0, _len = _ref.length; _i < _len; _i++) {
2675         name = _ref[_i];
2676         _results.push(this.hacks[name] = klass);
2677       }
2678       return _results;
2679     };
2680
2681     Prefixer.load = function(name, prefixes, all) {
2682       var klass, _ref;
2683       klass = (_ref = this.hacks) != null ? _ref[name] : void 0;
2684       if (klass) {
2685         return new klass(name, prefixes, all);
2686       } else {
2687         return new this(name, prefixes, all);
2688       }
2689     };
2690
2691     Prefixer.clone = function(node, overrides) {
2692       var cloned, name;
2693       cloned = clone(node);
2694       for (name in overrides) {
2695         cloned[name] = overrides[name];
2696       }
2697       return cloned;
2698     };
2699
2700     function Prefixer(name, prefixes, all) {
2701       this.name = name;
2702       this.prefixes = prefixes;
2703       this.all = all;
2704     }
2705
2706     Prefixer.prototype.parentPrefix = function(node) {
2707       var prefix;
2708       prefix = node._autoprefixerPrefix != null ? node._autoprefixerPrefix : node.type === 'decl' && node.prop[0] === '-' ? vendor.prefix(node.prop) : node.type === 'root' ? false : node.type === 'rule' && node.selector.indexOf(':-') !== -1 ? node.selector.match(/:(-\w+-)/)[1] : node.type === 'atrule' && node.name[0] === '-' ? vendor.prefix(node.name) : this.parentPrefix(node.parent);
2709       if (Browsers.prefixes().indexOf(prefix) === -1) {
2710         prefix = false;
2711       }
2712       return node._autoprefixerPrefix = prefix;
2713     };
2714
2715     Prefixer.prototype.process = function(node) {
2716       var added, parent, prefix, prefixes, _i, _j, _len, _len1, _ref;
2717       if (!this.check(node)) {
2718         return;
2719       }
2720       parent = this.parentPrefix(node);
2721       prefixes = [];
2722       _ref = this.prefixes;
2723       for (_i = 0, _len = _ref.length; _i < _len; _i++) {
2724         prefix = _ref[_i];
2725         if (parent && parent !== utils.removeNote(prefix)) {
2726           continue;
2727         }
2728         prefixes.push(prefix);
2729       }
2730       added = [];
2731       for (_j = 0, _len1 = prefixes.length; _j < _len1; _j++) {
2732         prefix = prefixes[_j];
2733         if (this.add(node, prefix, added.concat([prefix]))) {
2734           added.push(prefix);
2735         }
2736       }
2737       return added;
2738     };
2739
2740     Prefixer.prototype.clone = function(node, overrides) {
2741       return Prefixer.clone(node, overrides);
2742     };
2743
2744     return Prefixer;
2745
2746   })();
2747
2748   module.exports = Prefixer;
2749
2750 }).call(this);
2751
2752 },{"./browsers":5,"./utils":46,"postcss/lib/vendor":113}],41:[function(require,module,exports){
2753 (function() {
2754   var AtRule, Browsers, Declaration, Prefixes, Processor, Resolution, Selector, Supports, Value, declsCache, utils, vendor;
2755
2756   Declaration = require('./declaration');
2757
2758   Resolution = require('./resolution');
2759
2760   Processor = require('./processor');
2761
2762   Supports = require('./supports');
2763
2764   Browsers = require('./browsers');
2765
2766   Selector = require('./selector');
2767
2768   AtRule = require('./at-rule');
2769
2770   Value = require('./value');
2771
2772   utils = require('./utils');
2773
2774   vendor = require('postcss/lib/vendor');
2775
2776   Selector.hack(require('./hacks/fullscreen'));
2777
2778   Selector.hack(require('./hacks/placeholder'));
2779
2780   Declaration.hack(require('./hacks/flex'));
2781
2782   Declaration.hack(require('./hacks/order'));
2783
2784   Declaration.hack(require('./hacks/filter'));
2785
2786   Declaration.hack(require('./hacks/flex-flow'));
2787
2788   Declaration.hack(require('./hacks/flex-grow'));
2789
2790   Declaration.hack(require('./hacks/flex-wrap'));
2791
2792   Declaration.hack(require('./hacks/align-self'));
2793
2794   Declaration.hack(require('./hacks/flex-basis'));
2795
2796   Declaration.hack(require('./hacks/align-items'));
2797
2798   Declaration.hack(require('./hacks/flex-shrink'));
2799
2800   Declaration.hack(require('./hacks/break-inside'));
2801
2802   Declaration.hack(require('./hacks/border-image'));
2803
2804   Declaration.hack(require('./hacks/align-content'));
2805
2806   Declaration.hack(require('./hacks/border-radius'));
2807
2808   Declaration.hack(require('./hacks/block-logical'));
2809
2810   Declaration.hack(require('./hacks/inline-logical'));
2811
2812   Declaration.hack(require('./hacks/transform-decl'));
2813
2814   Declaration.hack(require('./hacks/flex-direction'));
2815
2816   Declaration.hack(require('./hacks/justify-content'));
2817
2818   Declaration.hack(require('./hacks/background-size'));
2819
2820   Value.hack(require('./hacks/gradient'));
2821
2822   Value.hack(require('./hacks/crisp-edges'));
2823
2824   Value.hack(require('./hacks/flex-values'));
2825
2826   Value.hack(require('./hacks/display-flex'));
2827
2828   Value.hack(require('./hacks/filter-value'));
2829
2830   Value.hack(require('./hacks/fill-available'));
2831
2832   Value.hack(require('./hacks/transform-value'));
2833
2834   declsCache = {};
2835
2836   Prefixes = (function() {
2837     function Prefixes(data, browsers, options) {
2838       var _ref;
2839       this.data = data;
2840       this.browsers = browsers;
2841       this.options = options != null ? options : {};
2842       _ref = this.preprocess(this.select(this.data)), this.add = _ref[0], this.remove = _ref[1];
2843       this.processor = new Processor(this);
2844     }
2845
2846     Prefixes.prototype.transitionProps = ['transition', 'transition-property'];
2847
2848     Prefixes.prototype.cleaner = function() {
2849       var empty;
2850       if (!this.cleanerCache) {
2851         if (this.browsers.selected.length) {
2852           empty = new Browsers(this.browsers.data, []);
2853           this.cleanerCache = new Prefixes(this.data, empty, this.options);
2854         } else {
2855           return this;
2856         }
2857       }
2858       return this.cleanerCache;
2859     };
2860
2861     Prefixes.prototype.select = function(list) {
2862       var add, all, data, name, notes, selected;
2863       selected = {
2864         add: {},
2865         remove: {}
2866       };
2867       for (name in list) {
2868         data = list[name];
2869         add = data.browsers.map(function(i) {
2870           var params;
2871           params = i.split(' ');
2872           return {
2873             browser: params[0] + ' ' + params[1],
2874             note: params[2]
2875           };
2876         });
2877         notes = add.filter(function(i) {
2878           return i.note;
2879         }).map((function(_this) {
2880           return function(i) {
2881             return _this.browsers.prefix(i.browser) + ' ' + i.note;
2882           };
2883         })(this));
2884         notes = utils.uniq(notes);
2885         add = add.filter((function(_this) {
2886           return function(i) {
2887             return _this.browsers.isSelected(i.browser);
2888           };
2889         })(this)).map((function(_this) {
2890           return function(i) {
2891             var prefix;
2892             prefix = _this.browsers.prefix(i.browser);
2893             if (i.note) {
2894               return prefix + ' ' + i.note;
2895             } else {
2896               return prefix;
2897             }
2898           };
2899         })(this));
2900         add = this.sort(utils.uniq(add));
2901         all = data.browsers.map((function(_this) {
2902           return function(i) {
2903             return _this.browsers.prefix(i);
2904           };
2905         })(this));
2906         if (data.mistakes) {
2907           all = all.concat(data.mistakes);
2908         }
2909         all = all.concat(notes);
2910         all = utils.uniq(all);
2911         if (add.length) {
2912           selected.add[name] = add;
2913           if (add.length < all.length) {
2914             selected.remove[name] = all.filter(function(i) {
2915               return add.indexOf(i) === -1;
2916             });
2917           }
2918         } else {
2919           selected.remove[name] = all;
2920         }
2921       }
2922       return selected;
2923     };
2924
2925     Prefixes.prototype.sort = function(prefixes) {
2926       return prefixes.sort(function(a, b) {
2927         var aLength, bLength;
2928         aLength = utils.removeNote(a).length;
2929         bLength = utils.removeNote(b).length;
2930         if (aLength === bLength) {
2931           return b.length - a.length;
2932         } else {
2933           return bLength - aLength;
2934         }
2935       });
2936     };
2937
2938     Prefixes.prototype.preprocess = function(selected) {
2939       var add, name, old, olds, prefix, prefixed, prefixes, prop, props, remove, selector, value, values, _i, _j, _k, _l, _len, _len1, _len2, _len3, _len4, _len5, _len6, _m, _n, _o, _ref, _ref1, _ref2;
2940       add = {
2941         selectors: [],
2942         '@supports': new Supports(this)
2943       };
2944       _ref = selected.add;
2945       for (name in _ref) {
2946         prefixes = _ref[name];
2947         if (name === '@keyframes' || name === '@viewport') {
2948           add[name] = new AtRule(name, prefixes, this);
2949         } else if (name === '@resolution') {
2950           add[name] = new Resolution(name, prefixes, this);
2951         } else if (this.data[name].selector) {
2952           add.selectors.push(Selector.load(name, prefixes, this));
2953         } else {
2954           props = this.data[name].transition ? this.transitionProps : this.data[name].props;
2955           if (props) {
2956             value = Value.load(name, prefixes, this);
2957             for (_i = 0, _len = props.length; _i < _len; _i++) {
2958               prop = props[_i];
2959               if (!add[prop]) {
2960                 add[prop] = {
2961                   values: []
2962                 };
2963               }
2964               add[prop].values.push(value);
2965             }
2966           }
2967           if (!this.data[name].props) {
2968             values = ((_ref1 = add[name]) != null ? _ref1.values : void 0) || [];
2969             add[name] = Declaration.load(name, prefixes, this);
2970             add[name].values = values;
2971           }
2972         }
2973       }
2974       remove = {
2975         selectors: []
2976       };
2977       _ref2 = selected.remove;
2978       for (name in _ref2) {
2979         prefixes = _ref2[name];
2980         if (this.data[name].selector) {
2981           selector = Selector.load(name, prefixes);
2982           for (_j = 0, _len1 = prefixes.length; _j < _len1; _j++) {
2983             prefix = prefixes[_j];
2984             remove.selectors.push(selector.old(prefix));
2985           }
2986         } else if (name === '@keyframes' || name === '@viewport') {
2987           for (_k = 0, _len2 = prefixes.length; _k < _len2; _k++) {
2988             prefix = prefixes[_k];
2989             prefixed = '@' + prefix + name.slice(1);
2990             remove[prefixed] = {
2991               remove: true
2992             };
2993           }
2994         } else if (name === '@resolution') {
2995           remove[name] = new Resolution(name, prefixes, this);
2996         } else {
2997           props = this.data[name].transition ? this.transitionProps : this.data[name].props;
2998           if (props) {
2999             value = Value.load(name, [], this);
3000             for (_l = 0, _len3 = prefixes.length; _l < _len3; _l++) {
3001               prefix = prefixes[_l];
3002               old = value.old(prefix);
3003               if (old) {
3004                 for (_m = 0, _len4 = props.length; _m < _len4; _m++) {
3005                   prop = props[_m];
3006                   if (!remove[prop]) {
3007                     remove[prop] = {};
3008                   }
3009                   if (!remove[prop].values) {
3010                     remove[prop].values = [];
3011                   }
3012                   remove[prop].values.push(old);
3013                 }
3014               }
3015             }
3016           }
3017           if (!this.data[name].props) {
3018             for (_n = 0, _len5 = prefixes.length; _n < _len5; _n++) {
3019               prefix = prefixes[_n];
3020               prop = vendor.unprefixed(name);
3021               olds = this.decl(name).old(name, prefix);
3022               for (_o = 0, _len6 = olds.length; _o < _len6; _o++) {
3023                 prefixed = olds[_o];
3024                 if (!remove[prefixed]) {
3025                   remove[prefixed] = {};
3026                 }
3027                 remove[prefixed].remove = true;
3028               }
3029             }
3030           }
3031         }
3032       }
3033       return [add, remove];
3034     };
3035
3036     Prefixes.prototype.decl = function(prop) {
3037       var decl;
3038       decl = declsCache[prop];
3039       if (decl) {
3040         return decl;
3041       } else {
3042         return declsCache[prop] = Declaration.load(prop);
3043       }
3044     };
3045
3046     Prefixes.prototype.unprefixed = function(prop) {
3047       prop = vendor.unprefixed(prop);
3048       return this.decl(prop).normalize(prop);
3049     };
3050
3051     Prefixes.prototype.prefixed = function(prop, prefix) {
3052       prop = vendor.unprefixed(prop);
3053       return this.decl(prop).prefixed(prop, prefix);
3054     };
3055
3056     Prefixes.prototype.values = function(type, prop) {
3057       var data, global, values, _ref, _ref1;
3058       data = this[type];
3059       global = (_ref = data['*']) != null ? _ref.values : void 0;
3060       values = (_ref1 = data[prop]) != null ? _ref1.values : void 0;
3061       if (global && values) {
3062         return utils.uniq(global.concat(values));
3063       } else {
3064         return global || values || [];
3065       }
3066     };
3067
3068     Prefixes.prototype.group = function(decl) {
3069       var checker, index, length, rule, unprefixed;
3070       rule = decl.parent;
3071       index = rule.index(decl);
3072       length = rule.nodes.length;
3073       unprefixed = this.unprefixed(decl.prop);
3074       checker = (function(_this) {
3075         return function(step, callback) {
3076           var other;
3077           index += step;
3078           while (index >= 0 && index < length) {
3079             other = rule.nodes[index];
3080             if (other.type === 'decl') {
3081               if (step === -1 && other.prop === unprefixed) {
3082                 if (!Browsers.withPrefix(other.value)) {
3083                   break;
3084                 }
3085               }
3086               if (_this.unprefixed(other.prop) !== unprefixed) {
3087                 break;
3088               } else if (callback(other) === true) {
3089                 return true;
3090               }
3091               if (step === +1 && other.prop === unprefixed) {
3092                 if (!Browsers.withPrefix(other.value)) {
3093                   break;
3094                 }
3095               }
3096             }
3097             index += step;
3098           }
3099           return false;
3100         };
3101       })(this);
3102       return {
3103         up: function(callback) {
3104           return checker(-1, callback);
3105         },
3106         down: function(callback) {
3107           return checker(+1, callback);
3108         }
3109       };
3110     };
3111
3112     return Prefixes;
3113
3114   })();
3115
3116   module.exports = Prefixes;
3117
3118 }).call(this);
3119
3120 },{"./at-rule":4,"./browsers":5,"./declaration":6,"./hacks/align-content":7,"./hacks/align-items":8,"./hacks/align-self":9,"./hacks/background-size":10,"./hacks/block-logical":11,"./hacks/border-image":12,"./hacks/border-radius":13,"./hacks/break-inside":14,"./hacks/crisp-edges":15,"./hacks/display-flex":16,"./hacks/fill-available":17,"./hacks/filter":19,"./hacks/filter-value":18,"./hacks/flex":28,"./hacks/flex-basis":20,"./hacks/flex-direction":21,"./hacks/flex-flow":22,"./hacks/flex-grow":23,"./hacks/flex-shrink":24,"./hacks/flex-values":26,"./hacks/flex-wrap":27,"./hacks/fullscreen":29,"./hacks/gradient":30,"./hacks/inline-logical":31,"./hacks/justify-content":32,"./hacks/order":33,"./hacks/placeholder":34,"./hacks/transform-decl":35,"./hacks/transform-value":36,"./processor":42,"./resolution":43,"./selector":44,"./supports":45,"./utils":46,"./value":47,"postcss/lib/vendor":113}],42:[function(require,module,exports){
3121 (function() {
3122   var Processor, Value, utils, vendor;
3123
3124   vendor = require('postcss/lib/vendor');
3125
3126   Value = require('./value');
3127
3128   utils = require('./utils');
3129
3130   Processor = (function() {
3131     function Processor(prefixes) {
3132       this.prefixes = prefixes;
3133     }
3134
3135     Processor.prototype.add = function(css) {
3136       var keyframes, resolution, supports, viewport;
3137       resolution = this.prefixes.add['@resolution'];
3138       keyframes = this.prefixes.add['@keyframes'];
3139       viewport = this.prefixes.add['@viewport'];
3140       supports = this.prefixes.add['@supports'];
3141       css.eachAtRule((function(_this) {
3142         return function(rule) {
3143           if (rule.name === 'keyframes') {
3144             if (!_this.disabled(rule)) {
3145               return keyframes != null ? keyframes.process(rule) : void 0;
3146             }
3147           } else if (rule.name === 'viewport') {
3148             if (!_this.disabled(rule)) {
3149               return viewport != null ? viewport.process(rule) : void 0;
3150             }
3151           } else if (rule.name === 'supports') {
3152             if (!_this.disabled(rule)) {
3153               return supports.process(rule);
3154             }
3155           } else if (rule.name === 'media' && rule.params.indexOf('-resolution') !== -1) {
3156             if (!_this.disabled(rule)) {
3157               return resolution != null ? resolution.process(rule) : void 0;
3158             }
3159           }
3160         };
3161       })(this));
3162       css.eachRule((function(_this) {
3163         return function(rule) {
3164           var selector, _i, _len, _ref, _results;
3165           if (_this.disabled(rule)) {
3166             return;
3167           }
3168           _ref = _this.prefixes.add.selectors;
3169           _results = [];
3170           for (_i = 0, _len = _ref.length; _i < _len; _i++) {
3171             selector = _ref[_i];
3172             _results.push(selector.process(rule));
3173           }
3174           return _results;
3175         };
3176       })(this));
3177       css.eachDecl((function(_this) {
3178         return function(decl) {
3179           var prefix;
3180           prefix = _this.prefixes.add[decl.prop];
3181           if (prefix && prefix.prefixes) {
3182             if (!_this.disabled(decl)) {
3183               return prefix.process(decl);
3184             }
3185           }
3186         };
3187       })(this));
3188       return css.eachDecl((function(_this) {
3189         return function(decl) {
3190           var unprefixed, value, _i, _len, _ref;
3191           if (_this.disabled(decl)) {
3192             return;
3193           }
3194           unprefixed = _this.prefixes.unprefixed(decl.prop);
3195           _ref = _this.prefixes.values('add', unprefixed);
3196           for (_i = 0, _len = _ref.length; _i < _len; _i++) {
3197             value = _ref[_i];
3198             value.process(decl);
3199           }
3200           return Value.save(_this.prefixes, decl);
3201         };
3202       })(this));
3203     };
3204
3205     Processor.prototype.remove = function(css) {
3206       var checker, resolution, _i, _len, _ref;
3207       resolution = this.prefixes.remove['@resolution'];
3208       css.eachAtRule((function(_this) {
3209         return function(rule, i) {
3210           if (_this.prefixes.remove['@' + rule.name]) {
3211             if (!_this.disabled(rule)) {
3212               return rule.parent.remove(i);
3213             }
3214           } else if (rule.name === 'media' && rule.params.indexOf('-resolution') !== -1) {
3215             return resolution != null ? resolution.clean(rule) : void 0;
3216           }
3217         };
3218       })(this));
3219       _ref = this.prefixes.remove.selectors;
3220       for (_i = 0, _len = _ref.length; _i < _len; _i++) {
3221         checker = _ref[_i];
3222         css.eachRule((function(_this) {
3223           return function(rule, i) {
3224             if (checker.check(rule)) {
3225               if (!_this.disabled(rule)) {
3226                 return rule.parent.remove(i);
3227               }
3228             }
3229           };
3230         })(this));
3231       }
3232       return css.eachDecl((function(_this) {
3233         return function(decl, i) {
3234           var notHack, rule, unprefixed, _j, _len1, _ref1, _ref2;
3235           if (_this.disabled(decl)) {
3236             return;
3237           }
3238           rule = decl.parent;
3239           unprefixed = _this.prefixes.unprefixed(decl.prop);
3240           if ((_ref1 = _this.prefixes.remove[decl.prop]) != null ? _ref1.remove : void 0) {
3241             notHack = _this.prefixes.group(decl).down(function(other) {
3242               return other.prop === unprefixed;
3243             });
3244             if (notHack && !_this.withHackValue(decl)) {
3245               if (decl.style('before').indexOf("\n") > -1) {
3246                 _this.reduceSpaces(decl);
3247               }
3248               rule.remove(i);
3249               return;
3250             }
3251           }
3252           _ref2 = _this.prefixes.values('remove', unprefixed);
3253           for (_j = 0, _len1 = _ref2.length; _j < _len1; _j++) {
3254             checker = _ref2[_j];
3255             if (checker.check(decl.value)) {
3256               unprefixed = checker.unprefixed;
3257               notHack = _this.prefixes.group(decl).down(function(other) {
3258                 return other.value.indexOf(unprefixed) !== -1;
3259               });
3260               if (notHack) {
3261                 rule.remove(i);
3262                 return;
3263               } else if (checker.clean) {
3264                 checker.clean(decl);
3265                 return;
3266               }
3267             }
3268           }
3269         };
3270       })(this));
3271     };
3272
3273     Processor.prototype.withHackValue = function(decl) {
3274       return decl.prop === '-webkit-background-clip' && decl.value === 'text';
3275     };
3276
3277     Processor.prototype.disabled = function(node) {
3278       var status;
3279       if (node._autoprefixerDisabled != null) {
3280         return node._autoprefixerDisabled;
3281       } else if (node.nodes) {
3282         status = void 0;
3283         node.each(function(i) {
3284           if (i.type !== 'comment') {
3285             return;
3286           }
3287           if (i.text === 'autoprefixer: off') {
3288             status = false;
3289             return false;
3290           } else if (i.text === 'autoprefixer: on') {
3291             status = true;
3292             return false;
3293           }
3294         });
3295         return node._autoprefixerDisabled = status != null ? !status : node.parent ? this.disabled(node.parent) : false;
3296       } else {
3297         return node._autoprefixerDisabled = this.disabled(node.parent);
3298       }
3299     };
3300
3301     Processor.prototype.reduceSpaces = function(decl) {
3302       var diff, parts, prevMin, stop;
3303       stop = false;
3304       this.prefixes.group(decl).up(function(other) {
3305         return stop = true;
3306       });
3307       if (stop) {
3308         return;
3309       }
3310       parts = decl.style('before').split("\n");
3311       prevMin = parts[parts.length - 1].length;
3312       diff = false;
3313       return this.prefixes.group(decl).down(function(other) {
3314         var last;
3315         parts = other.style('before').split("\n");
3316         last = parts.length - 1;
3317         if (parts[last].length > prevMin) {
3318           if (diff === false) {
3319             diff = parts[last].length - prevMin;
3320           }
3321           parts[last] = parts[last].slice(0, -diff);
3322           return other.before = parts.join("\n");
3323         }
3324       });
3325     };
3326
3327     return Processor;
3328
3329   })();
3330
3331   module.exports = Processor;
3332
3333 }).call(this);
3334
3335 },{"./utils":46,"./value":47,"postcss/lib/vendor":113}],43:[function(require,module,exports){
3336 (function() {
3337   var Prefixer, Resolution, n2f, regexp, split, utils,
3338     __hasProp = {}.hasOwnProperty,
3339     __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
3340
3341   Prefixer = require('./prefixer');
3342
3343   utils = require('./utils');
3344
3345   n2f = require('num2fraction');
3346
3347   regexp = /(min|max)-resolution\s*:\s*\d*\.?\d+(dppx|dpi)/gi;
3348
3349   split = /(min|max)-resolution(\s*:\s*)(\d*\.?\d+)(dppx|dpi)/i;
3350
3351   Resolution = (function(_super) {
3352     __extends(Resolution, _super);
3353
3354     function Resolution() {
3355       return Resolution.__super__.constructor.apply(this, arguments);
3356     }
3357
3358     Resolution.prototype.prefixName = function(prefix, name) {
3359       return name = prefix === '-moz-' ? name + '--moz-device-pixel-ratio' : prefix + name + '-device-pixel-ratio';
3360     };
3361
3362     Resolution.prototype.prefixQuery = function(prefix, name, colon, value, units) {
3363       if (units === 'dpi') {
3364         value = Number(value / 96);
3365       }
3366       if (prefix === '-o-') {
3367         value = n2f(value);
3368       }
3369       return this.prefixName(prefix, name) + colon + value;
3370     };
3371
3372     Resolution.prototype.clean = function(rule) {
3373       var prefix, _i, _len, _ref;
3374       if (!this.bad) {
3375         this.bad = [];
3376         _ref = this.prefixes;
3377         for (_i = 0, _len = _ref.length; _i < _len; _i++) {
3378           prefix = _ref[_i];
3379           this.bad.push(this.prefixName(prefix, 'min'));
3380           this.bad.push(this.prefixName(prefix, 'max'));
3381         }
3382       }
3383       return rule.params = utils.editList(rule.params, (function(_this) {
3384         return function(queries) {
3385           return queries.filter(function(query) {
3386             return _this.bad.every(function(i) {
3387               return query.indexOf(i) === -1;
3388             });
3389           });
3390         };
3391       })(this));
3392     };
3393
3394     Resolution.prototype.process = function(rule) {
3395       var parent, prefixes;
3396       parent = this.parentPrefix(rule);
3397       prefixes = parent ? [parent] : this.prefixes;
3398       return rule.params = utils.editList(rule.params, (function(_this) {
3399         return function(origin, prefixed) {
3400           var prefix, processed, query, _i, _j, _len, _len1;
3401           for (_i = 0, _len = origin.length; _i < _len; _i++) {
3402             query = origin[_i];
3403             if (query.indexOf('min-resolution') === -1 && query.indexOf('max-resolution') === -1) {
3404               prefixed.push(query);
3405               continue;
3406             }
3407             for (_j = 0, _len1 = prefixes.length; _j < _len1; _j++) {
3408               prefix = prefixes[_j];
3409               if (prefix !== '-moz-' || query.indexOf('dppx') !== -1) {
3410                 processed = query.replace(regexp, function(str) {
3411                   var parts;
3412                   parts = str.match(split);
3413                   return _this.prefixQuery(prefix, parts[1], parts[2], parts[3], parts[4]);
3414                 });
3415                 prefixed.push(processed);
3416               }
3417             }
3418             prefixed.push(query);
3419           }
3420           return utils.uniq(prefixed);
3421         };
3422       })(this));
3423     };
3424
3425     return Resolution;
3426
3427   })(Prefixer);
3428
3429   module.exports = Resolution;
3430
3431 }).call(this);
3432
3433 },{"./prefixer":40,"./utils":46,"num2fraction":95}],44:[function(require,module,exports){
3434 (function() {
3435   var Browsers, OldSelector, Prefixer, Selector, utils,
3436     __hasProp = {}.hasOwnProperty,
3437     __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
3438
3439   OldSelector = require('./old-selector');
3440
3441   Prefixer = require('./prefixer');
3442
3443   Browsers = require('./browsers');
3444
3445   utils = require('./utils');
3446
3447   Selector = (function(_super) {
3448     __extends(Selector, _super);
3449
3450     function Selector(name, prefixes, all) {
3451       this.name = name;
3452       this.prefixes = prefixes;
3453       this.all = all;
3454       this.regexpCache = {};
3455     }
3456
3457     Selector.prototype.check = function(rule) {
3458       if (rule.selector.indexOf(this.name) !== -1) {
3459         return !!rule.selector.match(this.regexp());
3460       } else {
3461         return false;
3462       }
3463     };
3464
3465     Selector.prototype.prefixed = function(prefix) {
3466       return this.name.replace(/^([^\w]*)/, '$1' + prefix);
3467     };
3468
3469     Selector.prototype.regexp = function(prefix) {
3470       var name;
3471       if (this.regexpCache[prefix]) {
3472         return this.regexpCache[prefix];
3473       }
3474       name = prefix ? this.prefixed(prefix) : this.name;
3475       return this.regexpCache[prefix] = RegExp("(^|[^:\"'=])" + (utils.escapeRegexp(name)), "gi");
3476     };
3477
3478     Selector.prototype.possible = function() {
3479       return Browsers.prefixes();
3480     };
3481
3482     Selector.prototype.prefixeds = function(rule) {
3483       var prefix, prefixeds, _i, _len, _ref;
3484       if (rule._autoprefixerPrefixeds) {
3485         return rule._autoprefixerPrefixeds;
3486       }
3487       prefixeds = {};
3488       _ref = this.possible();
3489       for (_i = 0, _len = _ref.length; _i < _len; _i++) {
3490         prefix = _ref[_i];
3491         prefixeds[prefix] = this.replace(rule.selector, prefix);
3492       }
3493       return rule._autoprefixerPrefixeds = prefixeds;
3494     };
3495
3496     Selector.prototype.already = function(rule, prefixeds, prefix) {
3497       var before, index, key, prefixed, some;
3498       index = rule.parent.index(rule) - 1;
3499       while (index >= 0) {
3500         before = rule.parent.nodes[index];
3501         if (before.type !== 'rule') {
3502           return false;
3503         }
3504         some = false;
3505         for (key in prefixeds) {
3506           prefixed = prefixeds[key];
3507           if (before.selector === prefixed) {
3508             if (prefix === key) {
3509               return true;
3510             } else {
3511               some = true;
3512               break;
3513             }
3514           }
3515         }
3516         if (!some) {
3517           return false;
3518         }
3519         index -= 1;
3520       }
3521       return false;
3522     };
3523
3524     Selector.prototype.replace = function(selector, prefix) {
3525       return selector.replace(this.regexp(), '$1' + this.prefixed(prefix));
3526     };
3527
3528     Selector.prototype.add = function(rule, prefix) {
3529       var cloned, prefixeds;
3530       prefixeds = this.prefixeds(rule);
3531       if (this.already(rule, prefixeds, prefix)) {
3532         return;
3533       }
3534       cloned = this.clone(rule, {
3535         selector: prefixeds[prefix]
3536       });
3537       return rule.parent.insertBefore(rule, cloned);
3538     };
3539
3540     Selector.prototype.old = function(prefix) {
3541       return new OldSelector(this, prefix);
3542     };
3543
3544     return Selector;
3545
3546   })(Prefixer);
3547
3548   module.exports = Selector;
3549
3550 }).call(this);
3551
3552 },{"./browsers":5,"./old-selector":38,"./prefixer":40,"./utils":46}],45:[function(require,module,exports){
3553 (function() {
3554   var Prefixes, Supports, Value, findCondition, findDecl, list, postcss, split, utils;
3555
3556   Prefixes = require('./prefixes');
3557
3558   Value = require('./value');
3559
3560   utils = require('./utils');
3561
3562   postcss = require('postcss');
3563
3564   list = require('postcss/lib/list');
3565
3566   split = /\(\s*([^\(\):]+)\s*:([^\)]+)/;
3567
3568   findDecl = /\(\s*([^\(\):]+)\s*:\s*(.+)\s*\)/g;
3569
3570   findCondition = /(not\s*)?\(\s*([^\(\):]+)\s*:\s*(.+?(?!\s*or\s*).+?)\s*\)*\s*\)\s*or\s*/gi;
3571
3572   Supports = (function() {
3573     function Supports(all) {
3574       this.all = all;
3575     }
3576
3577     Supports.prototype.virtual = function(prop, value) {
3578       var rule;
3579       rule = postcss.parse('a{}').first;
3580       rule.append({
3581         prop: prop,
3582         value: value,
3583         before: ''
3584       });
3585       return rule;
3586     };
3587
3588     Supports.prototype.prefixed = function(prop, value) {
3589       var decl, prefixer, rule, _i, _j, _len, _len1, _ref, _ref1;
3590       rule = this.virtual(prop, value);
3591       prefixer = this.all.add[prop];
3592       if (prefixer != null) {
3593         if (typeof prefixer.process === "function") {
3594           prefixer.process(rule.first);
3595         }
3596       }
3597       _ref = rule.nodes;
3598       for (_i = 0, _len = _ref.length; _i < _len; _i++) {
3599         decl = _ref[_i];
3600         _ref1 = this.all.values('add', prop);
3601         for (_j = 0, _len1 = _ref1.length; _j < _len1; _j++) {
3602           value = _ref1[_j];
3603           value.process(decl);
3604         }
3605         Value.save(this.all, decl);
3606       }
3607       return rule.nodes;
3608     };
3609
3610     Supports.prototype.clean = function(params) {
3611       return params.replace(findCondition, (function(_this) {
3612         return function(all) {
3613           var check, checker, prop, unprefixed, value, _, _i, _len, _ref, _ref1, _ref2;
3614           if (all.slice(0, 3).toLowerCase() === 'not') {
3615             return all;
3616           }
3617           _ref = all.match(split), _ = _ref[0], prop = _ref[1], value = _ref[2];
3618           unprefixed = _this.all.unprefixed(prop);
3619           if ((_ref1 = _this.all.cleaner().remove[prop]) != null ? _ref1.remove : void 0) {
3620             check = new RegExp('(\\(|\\s)' + utils.escapeRegexp(unprefixed) + ':');
3621             if (check.test(params)) {
3622               return '';
3623             }
3624           }
3625           _ref2 = _this.all.cleaner().values('remove', unprefixed);
3626           for (_i = 0, _len = _ref2.length; _i < _len; _i++) {
3627             checker = _ref2[_i];
3628             if (checker.check(value)) {
3629               return '';
3630             }
3631           }
3632           return all;
3633         };
3634       })(this)).replace(/\(\s*\((.*)\)\s*\)/g, '($1)');
3635     };
3636
3637     Supports.prototype.process = function(rule) {
3638       rule.params = this.clean(rule.params);
3639       return rule.params = rule.params.replace(findDecl, (function(_this) {
3640         return function(all, prop, value) {
3641           var i, stringed;
3642           stringed = (function() {
3643             var _i, _len, _ref, _results;
3644             _ref = this.prefixed(prop, value);
3645             _results = [];
3646             for (_i = 0, _len = _ref.length; _i < _len; _i++) {
3647               i = _ref[_i];
3648               _results.push("(" + i.prop + ": " + i.value + ")");
3649             }
3650             return _results;
3651           }).call(_this);
3652           if (stringed.length === 1) {
3653             return stringed[0];
3654           } else {
3655             return '(' + stringed.join(' or ') + ')';
3656           }
3657         };
3658       })(this));
3659     };
3660
3661     return Supports;
3662
3663   })();
3664
3665   module.exports = Supports;
3666
3667 }).call(this);
3668
3669 },{"./prefixes":41,"./utils":46,"./value":47,"postcss":107,"postcss/lib/list":102}],46:[function(require,module,exports){
3670 (function() {
3671   var list;
3672
3673   list = require('postcss/lib/list');
3674
3675   module.exports = {
3676     error: function(text) {
3677       var err;
3678       err = new Error(text);
3679       err.autoprefixer = true;
3680       throw err;
3681     },
3682     uniq: function(array) {
3683       var filtered, i, _i, _len;
3684       filtered = [];
3685       for (_i = 0, _len = array.length; _i < _len; _i++) {
3686         i = array[_i];
3687         if (filtered.indexOf(i) === -1) {
3688           filtered.push(i);
3689         }
3690       }
3691       return filtered;
3692     },
3693     removeNote: function(string) {
3694       if (string.indexOf(' ') === -1) {
3695         return string;
3696       } else {
3697         return string.split(' ')[0];
3698       }
3699     },
3700     escapeRegexp: function(string) {
3701       return string.replace(/[.?*+\^\$\[\]\\(){}|\-]/g, '\\$&');
3702     },
3703     regexp: function(word, escape) {
3704       if (escape == null) {
3705         escape = true;
3706       }
3707       if (escape) {
3708         word = this.escapeRegexp(word);
3709       }
3710       return RegExp("(^|[\\s,(])(" + word + "($|[\\s(,]))", "gi");
3711     },
3712     editList: function(value, callback) {
3713       var changed, join, origin;
3714       origin = list.comma(value);
3715       changed = callback(origin, []);
3716       if (origin === changed) {
3717         return value;
3718       } else {
3719         join = value.match(/,\s*/);
3720         join = join ? join[0] : ', ';
3721         return changed.join(join);
3722       }
3723     }
3724   };
3725
3726 }).call(this);
3727
3728 },{"postcss/lib/list":102}],47:[function(require,module,exports){
3729 (function() {
3730   var OldValue, Prefixer, Value, utils, vendor,
3731     __hasProp = {}.hasOwnProperty,
3732     __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
3733
3734   Prefixer = require('./prefixer');
3735
3736   OldValue = require('./old-value');
3737
3738   utils = require('./utils');
3739
3740   vendor = require('postcss/lib/vendor');
3741
3742   Value = (function(_super) {
3743     __extends(Value, _super);
3744
3745     function Value() {
3746       return Value.__super__.constructor.apply(this, arguments);
3747     }
3748
3749     Value.save = function(prefixes, decl) {
3750       var already, cloned, prefix, prefixed, propPrefix, rule, trimmed, value, _ref, _results;
3751       _ref = decl._autoprefixerValues;
3752       _results = [];
3753       for (prefix in _ref) {
3754         value = _ref[prefix];
3755         if (value === decl.value) {
3756           continue;
3757         }
3758         propPrefix = vendor.prefix(decl.prop);
3759         if (propPrefix === prefix) {
3760           _results.push(decl.value = value);
3761         } else if (propPrefix === '-pie-') {
3762           continue;
3763         } else {
3764           prefixed = prefixes.prefixed(decl.prop, prefix);
3765           rule = decl.parent;
3766           if (rule.every(function(i) {
3767             return i.prop !== prefixed;
3768           })) {
3769             trimmed = value.replace(/\s+/, ' ');
3770             already = rule.some(function(i) {
3771               return i.prop === decl.prop && i.value.replace(/\s+/, ' ') === trimmed;
3772             });
3773             if (!already) {
3774               if (value.indexOf('-webkit-filter') !== -1 && (decl.prop === 'transition' || decl.prop === 'trasition-property')) {
3775                 _results.push(decl.value = value);
3776               } else {
3777                 cloned = this.clone(decl, {
3778                   value: value
3779                 });
3780                 _results.push(decl.parent.insertBefore(decl, cloned));
3781               }
3782             } else {
3783               _results.push(void 0);
3784             }
3785           } else {
3786             _results.push(void 0);
3787           }
3788         }
3789       }
3790       return _results;
3791     };
3792
3793     Value.prototype.check = function(decl) {
3794       var value;
3795       value = decl.value;
3796       if (value.indexOf(this.name) !== -1) {
3797         return !!value.match(this.regexp());
3798       } else {
3799         return false;
3800       }
3801     };
3802
3803     Value.prototype.regexp = function() {
3804       return this.regexpCache || (this.regexpCache = utils.regexp(this.name));
3805     };
3806
3807     Value.prototype.replace = function(string, prefix) {
3808       return string.replace(this.regexp(), '$1' + prefix + '$2');
3809     };
3810
3811     Value.prototype.add = function(decl, prefix) {
3812       var value, _ref;
3813       decl._autoprefixerValues || (decl._autoprefixerValues = {});
3814       value = decl._autoprefixerValues[prefix] || ((_ref = decl._value) != null ? _ref.raw : void 0) || decl.value;
3815       value = this.replace(value, prefix);
3816       if (value) {
3817         return decl._autoprefixerValues[prefix] = value;
3818       }
3819     };
3820
3821     Value.prototype.old = function(prefix) {
3822       return new OldValue(this.name, prefix + this.name);
3823     };
3824
3825     return Value;
3826
3827   })(Prefixer);
3828
3829   module.exports = Value;
3830
3831 }).call(this);
3832
3833 },{"./old-value":39,"./prefixer":40,"./utils":46,"postcss/lib/vendor":113}],48:[function(require,module,exports){
3834
3835 },{}],49:[function(require,module,exports){
3836 /*!
3837  * The buffer module from node.js, for the browser.
3838  *
3839  * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
3840  * @license  MIT
3841  */
3842
3843 var base64 = require('base64-js')
3844 var ieee754 = require('ieee754')
3845 var isArray = require('is-array')
3846
3847 exports.Buffer = Buffer
3848 exports.SlowBuffer = SlowBuffer
3849 exports.INSPECT_MAX_BYTES = 50
3850 Buffer.poolSize = 8192 // not used by this implementation
3851
3852 var kMaxLength = 0x3fffffff
3853 var rootParent = {}
3854
3855 /**
3856  * If `Buffer.TYPED_ARRAY_SUPPORT`:
3857  *   === true    Use Uint8Array implementation (fastest)
3858  *   === false   Use Object implementation (most compatible, even IE6)
3859  *
3860  * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
3861  * Opera 11.6+, iOS 4.2+.
3862  *
3863  * Note:
3864  *
3865  * - Implementation must support adding new properties to `Uint8Array` instances.
3866  *   Firefox 4-29 lacked support, fixed in Firefox 30+.
3867  *   See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.
3868  *
3869  *  - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.
3870  *
3871  *  - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of
3872  *    incorrect length in some situations.
3873  *
3874  * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they will
3875  * get the Object implementation, which is slower but will work correctly.
3876  */
3877 Buffer.TYPED_ARRAY_SUPPORT = (function () {
3878   try {
3879     var buf = new ArrayBuffer(0)
3880     var arr = new Uint8Array(buf)
3881     arr.foo = function () { return 42 }
3882     return 42 === arr.foo() && // typed array instances can be augmented
3883         typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`
3884         new Uint8Array(1).subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`
3885   } catch (e) {
3886     return false
3887   }
3888 })()
3889
3890 /**
3891  * Class: Buffer
3892  * =============
3893  *
3894  * The Buffer constructor returns instances of `Uint8Array` that are augmented
3895  * with function properties for all the node `Buffer` API functions. We use
3896  * `Uint8Array` so that square bracket notation works as expected -- it returns
3897  * a single octet.
3898  *
3899  * By augmenting the instances, we can avoid modifying the `Uint8Array`
3900  * prototype.
3901  */
3902 function Buffer (subject, encoding, noZero) {
3903   if (!(this instanceof Buffer))
3904     return new Buffer(subject, encoding, noZero)
3905
3906   var type = typeof subject
3907
3908   // Find the length
3909   var length
3910   if (type === 'number')
3911     length = subject > 0 ? subject >>> 0 : 0
3912   else if (type === 'string') {
3913     length = Buffer.byteLength(subject, encoding)
3914   } else if (type === 'object' && subject !== null) { // assume object is array-like
3915     if (subject.type === 'Buffer' && isArray(subject.data))
3916       subject = subject.data
3917     length = +subject.length > 0 ? Math.floor(+subject.length) : 0
3918   } else
3919     throw new TypeError('must start with number, buffer, array or string')
3920
3921   if (length > kMaxLength)
3922     throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
3923       'size: 0x' + kMaxLength.toString(16) + ' bytes')
3924
3925   var buf
3926   if (Buffer.TYPED_ARRAY_SUPPORT) {
3927     // Preferred: Return an augmented `Uint8Array` instance for best performance
3928     buf = Buffer._augment(new Uint8Array(length))
3929   } else {
3930     // Fallback: Return THIS instance of Buffer (created by `new`)
3931     buf = this
3932     buf.length = length
3933     buf._isBuffer = true
3934   }
3935
3936   var i
3937   if (Buffer.TYPED_ARRAY_SUPPORT && typeof subject.byteLength === 'number') {
3938     // Speed optimization -- use set if we're copying from a typed array
3939     buf._set(subject)
3940   } else if (isArrayish(subject)) {
3941     // Treat array-ish objects as a byte array
3942     if (Buffer.isBuffer(subject)) {
3943       for (i = 0; i < length; i++)
3944         buf[i] = subject.readUInt8(i)
3945     } else {
3946       for (i = 0; i < length; i++)
3947         buf[i] = ((subject[i] % 256) + 256) % 256
3948     }
3949   } else if (type === 'string') {
3950     buf.write(subject, 0, encoding)
3951   } else if (type === 'number' && !Buffer.TYPED_ARRAY_SUPPORT && !noZero) {
3952     for (i = 0; i < length; i++) {
3953       buf[i] = 0
3954     }
3955   }
3956
3957   if (length > 0 && length <= Buffer.poolSize)
3958     buf.parent = rootParent
3959
3960   return buf
3961 }
3962
3963 function SlowBuffer(subject, encoding, noZero) {
3964   if (!(this instanceof SlowBuffer))
3965     return new SlowBuffer(subject, encoding, noZero)
3966
3967   var buf = new Buffer(subject, encoding, noZero)
3968   delete buf.parent
3969   return buf
3970 }
3971
3972 Buffer.isBuffer = function (b) {
3973   return !!(b != null && b._isBuffer)
3974 }
3975
3976 Buffer.compare = function (a, b) {
3977   if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b))
3978     throw new TypeError('Arguments must be Buffers')
3979
3980   var x = a.length
3981   var y = b.length
3982   for (var i = 0, len = Math.min(x, y); i < len && a[i] === b[i]; i++) {}
3983   if (i !== len) {
3984     x = a[i]
3985     y = b[i]
3986   }
3987   if (x < y) return -1
3988   if (y < x) return 1
3989   return 0
3990 }
3991
3992 Buffer.isEncoding = function (encoding) {
3993   switch (String(encoding).toLowerCase()) {
3994     case 'hex':
3995     case 'utf8':
3996     case 'utf-8':
3997     case 'ascii':
3998     case 'binary':
3999     case 'base64':
4000     case 'raw':
4001     case 'ucs2':
4002     case 'ucs-2':
4003     case 'utf16le':
4004     case 'utf-16le':
4005       return true
4006     default:
4007       return false
4008   }
4009 }
4010
4011 Buffer.concat = function (list, totalLength) {
4012   if (!isArray(list)) throw new TypeError('Usage: Buffer.concat(list[, length])')
4013
4014   if (list.length === 0) {
4015     return new Buffer(0)
4016   } else if (list.length === 1) {
4017     return list[0]
4018   }
4019
4020   var i
4021   if (totalLength === undefined) {
4022     totalLength = 0
4023     for (i = 0; i < list.length; i++) {
4024       totalLength += list[i].length
4025     }
4026   }
4027
4028   var buf = new Buffer(totalLength)
4029   var pos = 0
4030   for (i = 0; i < list.length; i++) {
4031     var item = list[i]
4032     item.copy(buf, pos)
4033     pos += item.length
4034   }
4035   return buf
4036 }
4037
4038 Buffer.byteLength = function (str, encoding) {
4039   var ret
4040   str = str + ''
4041   switch (encoding || 'utf8') {
4042     case 'ascii':
4043     case 'binary':
4044     case 'raw':
4045       ret = str.length
4046       break
4047     case 'ucs2':
4048     case 'ucs-2':
4049     case 'utf16le':
4050     case 'utf-16le':
4051       ret = str.length * 2
4052       break
4053     case 'hex':
4054       ret = str.length >>> 1
4055       break
4056     case 'utf8':
4057     case 'utf-8':
4058       ret = utf8ToBytes(str).length
4059       break
4060     case 'base64':
4061       ret = base64ToBytes(str).length
4062       break
4063     default:
4064       ret = str.length
4065   }
4066   return ret
4067 }
4068
4069 // pre-set for values that may exist in the future
4070 Buffer.prototype.length = undefined
4071 Buffer.prototype.parent = undefined
4072
4073 // toString(encoding, start=0, end=buffer.length)
4074 Buffer.prototype.toString = function (encoding, start, end) {
4075   var loweredCase = false
4076
4077   start = start >>> 0
4078   end = end === undefined || end === Infinity ? this.length : end >>> 0
4079
4080   if (!encoding) encoding = 'utf8'
4081   if (start < 0) start = 0
4082   if (end > this.length) end = this.length
4083   if (end <= start) return ''
4084
4085   while (true) {
4086     switch (encoding) {
4087       case 'hex':
4088         return hexSlice(this, start, end)
4089
4090       case 'utf8':
4091       case 'utf-8':
4092         return utf8Slice(this, start, end)
4093
4094       case 'ascii':
4095         return asciiSlice(this, start, end)
4096
4097       case 'binary':
4098         return binarySlice(this, start, end)
4099
4100       case 'base64':
4101         return base64Slice(this, start, end)
4102
4103       case 'ucs2':
4104       case 'ucs-2':
4105       case 'utf16le':
4106       case 'utf-16le':
4107         return utf16leSlice(this, start, end)
4108
4109       default:
4110         if (loweredCase)
4111           throw new TypeError('Unknown encoding: ' + encoding)
4112         encoding = (encoding + '').toLowerCase()
4113         loweredCase = true
4114     }
4115   }
4116 }
4117
4118 Buffer.prototype.equals = function (b) {
4119   if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')
4120   return Buffer.compare(this, b) === 0
4121 }
4122
4123 Buffer.prototype.inspect = function () {
4124   var str = ''
4125   var max = exports.INSPECT_MAX_BYTES
4126   if (this.length > 0) {
4127     str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')
4128     if (this.length > max)
4129       str += ' ... '
4130   }
4131   return '<Buffer ' + str + '>'
4132 }
4133
4134 Buffer.prototype.compare = function (b) {
4135   if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')
4136   return Buffer.compare(this, b)
4137 }
4138
4139 // `get` will be removed in Node 0.13+
4140 Buffer.prototype.get = function (offset) {
4141   console.log('.get() is deprecated. Access using array indexes instead.')
4142   return this.readUInt8(offset)
4143 }
4144
4145 // `set` will be removed in Node 0.13+
4146 Buffer.prototype.set = function (v, offset) {
4147   console.log('.set() is deprecated. Access using array indexes instead.')
4148   return this.writeUInt8(v, offset)
4149 }
4150
4151 function hexWrite (buf, string, offset, length) {
4152   offset = Number(offset) || 0
4153   var remaining = buf.length - offset
4154   if (!length) {
4155     length = remaining
4156   } else {
4157     length = Number(length)
4158     if (length > remaining) {
4159       length = remaining
4160     }
4161   }
4162
4163   // must be an even number of digits
4164   var strLen = string.length
4165   if (strLen % 2 !== 0) throw new Error('Invalid hex string')
4166
4167   if (length > strLen / 2) {
4168     length = strLen / 2
4169   }
4170   for (var i = 0; i < length; i++) {
4171     var byte = parseInt(string.substr(i * 2, 2), 16)
4172     if (isNaN(byte)) throw new Error('Invalid hex string')
4173     buf[offset + i] = byte
4174   }
4175   return i
4176 }
4177
4178 function utf8Write (buf, string, offset, length) {
4179   var charsWritten = blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)
4180   return charsWritten
4181 }
4182
4183 function asciiWrite (buf, string, offset, length) {
4184   var charsWritten = blitBuffer(asciiToBytes(string), buf, offset, length)
4185   return charsWritten
4186 }
4187
4188 function binaryWrite (buf, string, offset, length) {
4189   return asciiWrite(buf, string, offset, length)
4190 }
4191
4192 function base64Write (buf, string, offset, length) {
4193   var charsWritten = blitBuffer(base64ToBytes(string), buf, offset, length)
4194   return charsWritten
4195 }
4196
4197 function utf16leWrite (buf, string, offset, length) {
4198   var charsWritten = blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length, 2)
4199   return charsWritten
4200 }
4201
4202 Buffer.prototype.write = function (string, offset, length, encoding) {
4203   // Support both (string, offset, length, encoding)
4204   // and the legacy (string, encoding, offset, length)
4205   if (isFinite(offset)) {
4206     if (!isFinite(length)) {
4207       encoding = length
4208       length = undefined
4209     }
4210   } else {  // legacy
4211     var swap = encoding
4212     encoding = offset
4213     offset = length
4214     length = swap
4215   }
4216
4217   offset = Number(offset) || 0
4218
4219   if (length < 0 || offset < 0 || offset > this.length)
4220     throw new RangeError('attempt to write outside buffer bounds');
4221
4222   var remaining = this.length - offset
4223   if (!length) {
4224     length = remaining
4225   } else {
4226     length = Number(length)
4227     if (length > remaining) {
4228       length = remaining
4229     }
4230   }
4231   encoding = String(encoding || 'utf8').toLowerCase()
4232
4233   var ret
4234   switch (encoding) {
4235     case 'hex':
4236       ret = hexWrite(this, string, offset, length)
4237       break
4238     case 'utf8':
4239     case 'utf-8':
4240       ret = utf8Write(this, string, offset, length)
4241       break
4242     case 'ascii':
4243       ret = asciiWrite(this, string, offset, length)
4244       break
4245     case 'binary':
4246       ret = binaryWrite(this, string, offset, length)
4247       break
4248     case 'base64':
4249       ret = base64Write(this, string, offset, length)
4250       break
4251     case 'ucs2':
4252     case 'ucs-2':
4253     case 'utf16le':
4254     case 'utf-16le':
4255       ret = utf16leWrite(this, string, offset, length)
4256       break
4257     default:
4258       throw new TypeError('Unknown encoding: ' + encoding)
4259   }
4260   return ret
4261 }
4262
4263 Buffer.prototype.toJSON = function () {
4264   return {
4265     type: 'Buffer',
4266     data: Array.prototype.slice.call(this._arr || this, 0)
4267   }
4268 }
4269
4270 function base64Slice (buf, start, end) {
4271   if (start === 0 && end === buf.length) {
4272     return base64.fromByteArray(buf)
4273   } else {
4274     return base64.fromByteArray(buf.slice(start, end))
4275   }
4276 }
4277
4278 function utf8Slice (buf, start, end) {
4279   var res = ''
4280   var tmp = ''
4281   end = Math.min(buf.length, end)
4282
4283   for (var i = start; i < end; i++) {
4284     if (buf[i] <= 0x7F) {
4285       res += decodeUtf8Char(tmp) + String.fromCharCode(buf[i])
4286       tmp = ''
4287     } else {
4288       tmp += '%' + buf[i].toString(16)
4289     }
4290   }
4291
4292   return res + decodeUtf8Char(tmp)
4293 }
4294
4295 function asciiSlice (buf, start, end) {
4296   var ret = ''
4297   end = Math.min(buf.length, end)
4298
4299   for (var i = start; i < end; i++) {
4300     ret += String.fromCharCode(buf[i] & 0x7F)
4301   }
4302   return ret
4303 }
4304
4305 function binarySlice (buf, start, end) {
4306   var ret = ''
4307   end = Math.min(buf.length, end)
4308
4309   for (var i = start; i < end; i++) {
4310     ret += String.fromCharCode(buf[i])
4311   }
4312   return ret
4313 }
4314
4315 function hexSlice (buf, start, end) {
4316   var len = buf.length
4317
4318   if (!start || start < 0) start = 0
4319   if (!end || end < 0 || end > len) end = len
4320
4321   var out = ''
4322   for (var i = start; i < end; i++) {
4323     out += toHex(buf[i])
4324   }
4325   return out
4326 }
4327
4328 function utf16leSlice (buf, start, end) {
4329   var bytes = buf.slice(start, end)
4330   var res = ''
4331   for (var i = 0; i < bytes.length; i += 2) {
4332     res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)
4333   }
4334   return res
4335 }
4336
4337 Buffer.prototype.slice = function (start, end) {
4338   var len = this.length
4339   start = ~~start
4340   end = end === undefined ? len : ~~end
4341
4342   if (start < 0) {
4343     start += len;
4344     if (start < 0)
4345       start = 0
4346   } else if (start > len) {
4347     start = len
4348   }
4349
4350   if (end < 0) {
4351     end += len
4352     if (end < 0)
4353       end = 0
4354   } else if (end > len) {
4355     end = len
4356   }
4357
4358   if (end < start)
4359     end = start
4360
4361   var newBuf
4362   if (Buffer.TYPED_ARRAY_SUPPORT) {
4363     newBuf = Buffer._augment(this.subarray(start, end))
4364   } else {
4365     var sliceLen = end - start
4366     newBuf = new Buffer(sliceLen, undefined, true)
4367     for (var i = 0; i < sliceLen; i++) {
4368       newBuf[i] = this[i + start]
4369     }
4370   }
4371
4372   if (newBuf.length)
4373     newBuf.parent = this.parent || this
4374
4375   return newBuf
4376 }
4377
4378 /*
4379  * Need to make sure that buffer isn't trying to write out of bounds.
4380  */
4381 function checkOffset (offset, ext, length) {
4382   if ((offset % 1) !== 0 || offset < 0)
4383     throw new RangeError('offset is not uint')
4384   if (offset + ext > length)
4385     throw new RangeError('Trying to access beyond buffer length')
4386 }
4387
4388 Buffer.prototype.readUIntLE = function (offset, byteLength, noAssert) {
4389   offset = offset >>> 0
4390   byteLength = byteLength >>> 0
4391   if (!noAssert)
4392     checkOffset(offset, byteLength, this.length)
4393
4394   var val = this[offset]
4395   var mul = 1
4396   var i = 0
4397   while (++i < byteLength && (mul *= 0x100))
4398     val += this[offset + i] * mul
4399
4400   return val
4401 }
4402
4403 Buffer.prototype.readUIntBE = function (offset, byteLength, noAssert) {
4404   offset = offset >>> 0
4405   byteLength = byteLength >>> 0
4406   if (!noAssert)
4407     checkOffset(offset, byteLength, this.length)
4408
4409   var val = this[offset + --byteLength]
4410   var mul = 1
4411   while (byteLength > 0 && (mul *= 0x100))
4412     val += this[offset + --byteLength] * mul;
4413
4414   return val
4415 }
4416
4417 Buffer.prototype.readUInt8 = function (offset, noAssert) {
4418   if (!noAssert)
4419     checkOffset(offset, 1, this.length)
4420   return this[offset]
4421 }
4422
4423 Buffer.prototype.readUInt16LE = function (offset, noAssert) {
4424   if (!noAssert)
4425     checkOffset(offset, 2, this.length)
4426   return this[offset] | (this[offset + 1] << 8)
4427 }
4428
4429 Buffer.prototype.readUInt16BE = function (offset, noAssert) {
4430   if (!noAssert)
4431     checkOffset(offset, 2, this.length)
4432   return (this[offset] << 8) | this[offset + 1]
4433 }
4434
4435 Buffer.prototype.readUInt32LE = function (offset, noAssert) {
4436   if (!noAssert)
4437     checkOffset(offset, 4, this.length)
4438
4439   return ((this[offset]) |
4440       (this[offset + 1] << 8) |
4441       (this[offset + 2] << 16)) +
4442       (this[offset + 3] * 0x1000000)
4443 }
4444
4445 Buffer.prototype.readUInt32BE = function (offset, noAssert) {
4446   if (!noAssert)
4447     checkOffset(offset, 4, this.length)
4448
4449   return (this[offset] * 0x1000000) +
4450       ((this[offset + 1] << 16) |
4451       (this[offset + 2] << 8) |
4452       this[offset + 3])
4453 }
4454
4455 Buffer.prototype.readIntLE = function (offset, byteLength, noAssert) {
4456   offset = offset >>> 0
4457   byteLength = byteLength >>> 0
4458   if (!noAssert)
4459     checkOffset(offset, byteLength, this.length)
4460
4461   var val = this[offset]
4462   var mul = 1
4463   var i = 0
4464   while (++i < byteLength && (mul *= 0x100))
4465     val += this[offset + i] * mul
4466   mul *= 0x80
4467
4468   if (val >= mul)
4469     val -= Math.pow(2, 8 * byteLength)
4470
4471   return val
4472 }
4473
4474 Buffer.prototype.readIntBE = function (offset, byteLength, noAssert) {
4475   offset = offset >>> 0
4476   byteLength = byteLength >>> 0
4477   if (!noAssert)
4478     checkOffset(offset, byteLength, this.length)
4479
4480   var i = byteLength
4481   var mul = 1
4482   var val = this[offset + --i]
4483   while (i > 0 && (mul *= 0x100))
4484     val += this[offset + --i] * mul
4485   mul *= 0x80
4486
4487   if (val >= mul)
4488     val -= Math.pow(2, 8 * byteLength)
4489
4490   return val
4491 }
4492
4493 Buffer.prototype.readInt8 = function (offset, noAssert) {
4494   if (!noAssert)
4495     checkOffset(offset, 1, this.length)
4496   if (!(this[offset] & 0x80))
4497     return (this[offset])
4498   return ((0xff - this[offset] + 1) * -1)
4499 }
4500
4501 Buffer.prototype.readInt16LE = function (offset, noAssert) {
4502   if (!noAssert)
4503     checkOffset(offset, 2, this.length)
4504   var val = this[offset] | (this[offset + 1] << 8)
4505   return (val & 0x8000) ? val | 0xFFFF0000 : val
4506 }
4507
4508 Buffer.prototype.readInt16BE = function (offset, noAssert) {
4509   if (!noAssert)
4510     checkOffset(offset, 2, this.length)
4511   var val = this[offset + 1] | (this[offset] << 8)
4512   return (val & 0x8000) ? val | 0xFFFF0000 : val
4513 }
4514
4515 Buffer.prototype.readInt32LE = function (offset, noAssert) {
4516   if (!noAssert)
4517     checkOffset(offset, 4, this.length)
4518
4519   return (this[offset]) |
4520       (this[offset + 1] << 8) |
4521       (this[offset + 2] << 16) |
4522       (this[offset + 3] << 24)
4523 }
4524
4525 Buffer.prototype.readInt32BE = function (offset, noAssert) {
4526   if (!noAssert)
4527     checkOffset(offset, 4, this.length)
4528
4529   return (this[offset] << 24) |
4530       (this[offset + 1] << 16) |
4531       (this[offset + 2] << 8) |
4532       (this[offset + 3])
4533 }
4534
4535 Buffer.prototype.readFloatLE = function (offset, noAssert) {
4536   if (!noAssert)
4537     checkOffset(offset, 4, this.length)
4538   return ieee754.read(this, offset, true, 23, 4)
4539 }
4540
4541 Buffer.prototype.readFloatBE = function (offset, noAssert) {
4542   if (!noAssert)
4543     checkOffset(offset, 4, this.length)
4544   return ieee754.read(this, offset, false, 23, 4)
4545 }
4546
4547 Buffer.prototype.readDoubleLE = function (offset, noAssert) {
4548   if (!noAssert)
4549     checkOffset(offset, 8, this.length)
4550   return ieee754.read(this, offset, true, 52, 8)
4551 }
4552
4553 Buffer.prototype.readDoubleBE = function (offset, noAssert) {
4554   if (!noAssert)
4555     checkOffset(offset, 8, this.length)
4556   return ieee754.read(this, offset, false, 52, 8)
4557 }
4558
4559 function checkInt (buf, value, offset, ext, max, min) {
4560   if (!Buffer.isBuffer(buf)) throw new TypeError('buffer must be a Buffer instance')
4561   if (value > max || value < min) throw new RangeError('value is out of bounds')
4562   if (offset + ext > buf.length) throw new RangeError('index out of range')
4563 }
4564
4565 Buffer.prototype.writeUIntLE = function (value, offset, byteLength, noAssert) {
4566   value = +value
4567   offset = offset >>> 0
4568   byteLength = byteLength >>> 0
4569   if (!noAssert)
4570     checkInt(this, value, offset, byteLength, Math.pow(2, 8 * byteLength), 0)
4571
4572   var mul = 1
4573   var i = 0
4574   this[offset] = value & 0xFF
4575   while (++i < byteLength && (mul *= 0x100))
4576     this[offset + i] = (value / mul) >>> 0 & 0xFF
4577
4578   return offset + byteLength
4579 }
4580
4581 Buffer.prototype.writeUIntBE = function (value, offset, byteLength, noAssert) {
4582   value = +value
4583   offset = offset >>> 0
4584   byteLength = byteLength >>> 0
4585   if (!noAssert)
4586     checkInt(this, value, offset, byteLength, Math.pow(2, 8 * byteLength), 0)
4587
4588   var i = byteLength - 1
4589   var mul = 1
4590   this[offset + i] = value & 0xFF
4591   while (--i >= 0 && (mul *= 0x100))
4592     this[offset + i] = (value / mul) >>> 0 & 0xFF
4593
4594   return offset + byteLength
4595 }
4596
4597 Buffer.prototype.writeUInt8 = function (value, offset, noAssert) {
4598   value = +value
4599   offset = offset >>> 0
4600   if (!noAssert)
4601     checkInt(this, value, offset, 1, 0xff, 0)
4602   if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)
4603   this[offset] = value
4604   return offset + 1
4605 }
4606
4607 function objectWriteUInt16 (buf, value, offset, littleEndian) {
4608   if (value < 0) value = 0xffff + value + 1
4609   for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; i++) {
4610     buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>
4611       (littleEndian ? i : 1 - i) * 8
4612   }
4613 }
4614
4615 Buffer.prototype.writeUInt16LE = function (value, offset, noAssert) {
4616   value = +value
4617   offset = offset >>> 0
4618   if (!noAssert)
4619     checkInt(this, value, offset, 2, 0xffff, 0)
4620   if (Buffer.TYPED_ARRAY_SUPPORT) {
4621     this[offset] = value
4622     this[offset + 1] = (value >>> 8)
4623   } else objectWriteUInt16(this, value, offset, true)
4624   return offset + 2
4625 }
4626
4627 Buffer.prototype.writeUInt16BE = function (value, offset, noAssert) {
4628   value = +value
4629   offset = offset >>> 0
4630   if (!noAssert)
4631     checkInt(this, value, offset, 2, 0xffff, 0)
4632   if (Buffer.TYPED_ARRAY_SUPPORT) {
4633     this[offset] = (value >>> 8)
4634     this[offset + 1] = value
4635   } else objectWriteUInt16(this, value, offset, false)
4636   return offset + 2
4637 }
4638
4639 function objectWriteUInt32 (buf, value, offset, littleEndian) {
4640   if (value < 0) value = 0xffffffff + value + 1
4641   for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; i++) {
4642     buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff
4643   }
4644 }
4645
4646 Buffer.prototype.writeUInt32LE = function (value, offset, noAssert) {
4647   value = +value
4648   offset = offset >>> 0
4649   if (!noAssert)
4650     checkInt(this, value, offset, 4, 0xffffffff, 0)
4651   if (Buffer.TYPED_ARRAY_SUPPORT) {
4652     this[offset + 3] = (value >>> 24)
4653     this[offset + 2] = (value >>> 16)
4654     this[offset + 1] = (value >>> 8)
4655     this[offset] = value
4656   } else objectWriteUInt32(this, value, offset, true)
4657   return offset + 4
4658 }
4659
4660 Buffer.prototype.writeUInt32BE = function (value, offset, noAssert) {
4661   value = +value
4662   offset = offset >>> 0
4663   if (!noAssert)
4664     checkInt(this, value, offset, 4, 0xffffffff, 0)
4665   if (Buffer.TYPED_ARRAY_SUPPORT) {
4666     this[offset] = (value >>> 24)
4667     this[offset + 1] = (value >>> 16)
4668     this[offset + 2] = (value >>> 8)
4669     this[offset + 3] = value
4670   } else objectWriteUInt32(this, value, offset, false)
4671   return offset + 4
4672 }
4673
4674 Buffer.prototype.writeIntLE = function (value, offset, byteLength, noAssert) {
4675   value = +value
4676   offset = offset >>> 0
4677   if (!noAssert) {
4678     checkInt(this,
4679              value,
4680              offset,
4681              byteLength,
4682              Math.pow(2, 8 * byteLength - 1) - 1,
4683              -Math.pow(2, 8 * byteLength - 1))
4684   }
4685
4686   var i = 0
4687   var mul = 1
4688   var sub = value < 0 ? 1 : 0
4689   this[offset] = value & 0xFF
4690   while (++i < byteLength && (mul *= 0x100))
4691     this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
4692
4693   return offset + byteLength
4694 }
4695
4696 Buffer.prototype.writeIntBE = function (value, offset, byteLength, noAssert) {
4697   value = +value
4698   offset = offset >>> 0
4699   if (!noAssert) {
4700     checkInt(this,
4701              value,
4702              offset,
4703              byteLength,
4704              Math.pow(2, 8 * byteLength - 1) - 1,
4705              -Math.pow(2, 8 * byteLength - 1))
4706   }
4707
4708   var i = byteLength - 1
4709   var mul = 1
4710   var sub = value < 0 ? 1 : 0
4711   this[offset + i] = value & 0xFF
4712   while (--i >= 0 && (mul *= 0x100))
4713     this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
4714
4715   return offset + byteLength
4716 }
4717
4718 Buffer.prototype.writeInt8 = function (value, offset, noAssert) {
4719   value = +value
4720   offset = offset >>> 0
4721   if (!noAssert)
4722     checkInt(this, value, offset, 1, 0x7f, -0x80)
4723   if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)
4724   if (value < 0) value = 0xff + value + 1
4725   this[offset] = value
4726   return offset + 1
4727 }
4728
4729 Buffer.prototype.writeInt16LE = function (value, offset, noAssert) {
4730   value = +value
4731   offset = offset >>> 0
4732   if (!noAssert)
4733     checkInt(this, value, offset, 2, 0x7fff, -0x8000)
4734   if (Buffer.TYPED_ARRAY_SUPPORT) {
4735     this[offset] = value
4736     this[offset + 1] = (value >>> 8)
4737   } else objectWriteUInt16(this, value, offset, true)
4738   return offset + 2
4739 }
4740
4741 Buffer.prototype.writeInt16BE = function (value, offset, noAssert) {
4742   value = +value
4743   offset = offset >>> 0
4744   if (!noAssert)
4745     checkInt(this, value, offset, 2, 0x7fff, -0x8000)
4746   if (Buffer.TYPED_ARRAY_SUPPORT) {
4747     this[offset] = (value >>> 8)
4748     this[offset + 1] = value
4749   } else objectWriteUInt16(this, value, offset, false)
4750   return offset + 2
4751 }
4752
4753 Buffer.prototype.writeInt32LE = function (value, offset, noAssert) {
4754   value = +value
4755   offset = offset >>> 0
4756   if (!noAssert)
4757     checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
4758   if (Buffer.TYPED_ARRAY_SUPPORT) {
4759     this[offset] = value
4760     this[offset + 1] = (value >>> 8)
4761     this[offset + 2] = (value >>> 16)
4762     this[offset + 3] = (value >>> 24)
4763   } else objectWriteUInt32(this, value, offset, true)
4764   return offset + 4
4765 }
4766
4767 Buffer.prototype.writeInt32BE = function (value, offset, noAssert) {
4768   value = +value
4769   offset = offset >>> 0
4770   if (!noAssert)
4771     checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
4772   if (value < 0) value = 0xffffffff + value + 1
4773   if (Buffer.TYPED_ARRAY_SUPPORT) {
4774     this[offset] = (value >>> 24)
4775     this[offset + 1] = (value >>> 16)
4776     this[offset + 2] = (value >>> 8)
4777     this[offset + 3] = value
4778   } else objectWriteUInt32(this, value, offset, false)
4779   return offset + 4
4780 }
4781
4782 function checkIEEE754 (buf, value, offset, ext, max, min) {
4783   if (value > max || value < min) throw new RangeError('value is out of bounds')
4784   if (offset + ext > buf.length) throw new RangeError('index out of range')
4785   if (offset < 0) throw new RangeError('index out of range')
4786 }
4787
4788 function writeFloat (buf, value, offset, littleEndian, noAssert) {
4789   if (!noAssert)
4790     checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)
4791   ieee754.write(buf, value, offset, littleEndian, 23, 4)
4792   return offset + 4
4793 }
4794
4795 Buffer.prototype.writeFloatLE = function (value, offset, noAssert) {
4796   return writeFloat(this, value, offset, true, noAssert)
4797 }
4798
4799 Buffer.prototype.writeFloatBE = function (value, offset, noAssert) {
4800   return writeFloat(this, value, offset, false, noAssert)
4801 }
4802
4803 function writeDouble (buf, value, offset, littleEndian, noAssert) {
4804   if (!noAssert)
4805     checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)
4806   ieee754.write(buf, value, offset, littleEndian, 52, 8)
4807   return offset + 8
4808 }
4809
4810 Buffer.prototype.writeDoubleLE = function (value, offset, noAssert) {
4811   return writeDouble(this, value, offset, true, noAssert)
4812 }
4813
4814 Buffer.prototype.writeDoubleBE = function (value, offset, noAssert) {
4815   return writeDouble(this, value, offset, false, noAssert)
4816 }
4817
4818 // copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
4819 Buffer.prototype.copy = function (target, target_start, start, end) {
4820   var source = this
4821
4822   if (!start) start = 0
4823   if (!end && end !== 0) end = this.length
4824   if (target_start >= target.length) target_start = target.length
4825   if (!target_start) target_start = 0
4826   if (end > 0 && end < start) end = start
4827
4828   // Copy 0 bytes; we're done
4829   if (end === start) return 0
4830   if (target.length === 0 || source.length === 0) return 0
4831
4832   // Fatal error conditions
4833   if (target_start < 0)
4834     throw new RangeError('targetStart out of bounds')
4835   if (start < 0 || start >= source.length) throw new RangeError('sourceStart out of bounds')
4836   if (end < 0) throw new RangeError('sourceEnd out of bounds')
4837
4838   // Are we oob?
4839   if (end > this.length)
4840     end = this.length
4841   if (target.length - target_start < end - start)
4842     end = target.length - target_start + start
4843
4844   var len = end - start
4845
4846   if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {
4847     for (var i = 0; i < len; i++) {
4848       target[i + target_start] = this[i + start]
4849     }
4850   } else {
4851     target._set(this.subarray(start, start + len), target_start)
4852   }
4853
4854   return len
4855 }
4856
4857 // fill(value, start=0, end=buffer.length)
4858 Buffer.prototype.fill = function (value, start, end) {
4859   if (!value) value = 0
4860   if (!start) start = 0
4861   if (!end) end = this.length
4862
4863   if (end < start) throw new RangeError('end < start')
4864
4865   // Fill 0 bytes; we're done
4866   if (end === start) return
4867   if (this.length === 0) return
4868
4869   if (start < 0 || start >= this.length) throw new RangeError('start out of bounds')
4870   if (end < 0 || end > this.length) throw new RangeError('end out of bounds')
4871
4872   var i
4873   if (typeof value === 'number') {
4874     for (i = start; i < end; i++) {
4875       this[i] = value
4876     }
4877   } else {
4878     var bytes = utf8ToBytes(value.toString())
4879     var len = bytes.length
4880     for (i = start; i < end; i++) {
4881       this[i] = bytes[i % len]
4882     }
4883   }
4884
4885   return this
4886 }
4887
4888 /**
4889  * Creates a new `ArrayBuffer` with the *copied* memory of the buffer instance.
4890  * Added in Node 0.12. Only available in browsers that support ArrayBuffer.
4891  */
4892 Buffer.prototype.toArrayBuffer = function () {
4893   if (typeof Uint8Array !== 'undefined') {
4894     if (Buffer.TYPED_ARRAY_SUPPORT) {
4895       return (new Buffer(this)).buffer
4896     } else {
4897       var buf = new Uint8Array(this.length)
4898       for (var i = 0, len = buf.length; i < len; i += 1) {
4899         buf[i] = this[i]
4900       }
4901       return buf.buffer
4902     }
4903   } else {
4904     throw new TypeError('Buffer.toArrayBuffer not supported in this browser')
4905   }
4906 }
4907
4908 // HELPER FUNCTIONS
4909 // ================
4910
4911 var BP = Buffer.prototype
4912
4913 /**
4914  * Augment a Uint8Array *instance* (not the Uint8Array class!) with Buffer methods
4915  */
4916 Buffer._augment = function (arr) {
4917   arr.constructor = Buffer
4918   arr._isBuffer = true
4919
4920   // save reference to original Uint8Array get/set methods before overwriting
4921   arr._get = arr.get
4922   arr._set = arr.set
4923
4924   // deprecated, will be removed in node 0.13+
4925   arr.get = BP.get
4926   arr.set = BP.set
4927
4928   arr.write = BP.write
4929   arr.toString = BP.toString
4930   arr.toLocaleString = BP.toString
4931   arr.toJSON = BP.toJSON
4932   arr.equals = BP.equals
4933   arr.compare = BP.compare
4934   arr.copy = BP.copy
4935   arr.slice = BP.slice
4936   arr.readUIntLE = BP.readUIntLE
4937   arr.readUIntBE = BP.readUIntBE
4938   arr.readUInt8 = BP.readUInt8
4939   arr.readUInt16LE = BP.readUInt16LE
4940   arr.readUInt16BE = BP.readUInt16BE
4941   arr.readUInt32LE = BP.readUInt32LE
4942   arr.readUInt32BE = BP.readUInt32BE
4943   arr.readIntLE = BP.readIntLE
4944   arr.readIntBE = BP.readIntBE
4945   arr.readInt8 = BP.readInt8
4946   arr.readInt16LE = BP.readInt16LE
4947   arr.readInt16BE = BP.readInt16BE
4948   arr.readInt32LE = BP.readInt32LE
4949   arr.readInt32BE = BP.readInt32BE
4950   arr.readFloatLE = BP.readFloatLE
4951   arr.readFloatBE = BP.readFloatBE
4952   arr.readDoubleLE = BP.readDoubleLE
4953   arr.readDoubleBE = BP.readDoubleBE
4954   arr.writeUInt8 = BP.writeUInt8
4955   arr.writeUIntLE = BP.writeUIntLE
4956   arr.writeUIntBE = BP.writeUIntBE
4957   arr.writeUInt16LE = BP.writeUInt16LE
4958   arr.writeUInt16BE = BP.writeUInt16BE
4959   arr.writeUInt32LE = BP.writeUInt32LE
4960   arr.writeUInt32BE = BP.writeUInt32BE
4961   arr.writeIntLE = BP.writeIntLE
4962   arr.writeIntBE = BP.writeIntBE
4963   arr.writeInt8 = BP.writeInt8
4964   arr.writeInt16LE = BP.writeInt16LE
4965   arr.writeInt16BE = BP.writeInt16BE
4966   arr.writeInt32LE = BP.writeInt32LE
4967   arr.writeInt32BE = BP.writeInt32BE
4968   arr.writeFloatLE = BP.writeFloatLE
4969   arr.writeFloatBE = BP.writeFloatBE
4970   arr.writeDoubleLE = BP.writeDoubleLE
4971   arr.writeDoubleBE = BP.writeDoubleBE
4972   arr.fill = BP.fill
4973   arr.inspect = BP.inspect
4974   arr.toArrayBuffer = BP.toArrayBuffer
4975
4976   return arr
4977 }
4978
4979 var INVALID_BASE64_RE = /[^+\/0-9A-z\-]/g
4980
4981 function base64clean (str) {
4982   // Node strips out invalid characters like \n and \t from the string, base64-js does not
4983   str = stringtrim(str).replace(INVALID_BASE64_RE, '')
4984   // Node converts strings with length < 2 to ''
4985   if (str.length < 2) return ''
4986   // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not
4987   while (str.length % 4 !== 0) {
4988     str = str + '='
4989   }
4990   return str
4991 }
4992
4993 function stringtrim (str) {
4994   if (str.trim) return str.trim()
4995   return str.replace(/^\s+|\s+$/g, '')
4996 }
4997
4998 function isArrayish (subject) {
4999   return isArray(subject) || Buffer.isBuffer(subject) ||
5000       subject && typeof subject === 'object' &&
5001       typeof subject.length === 'number'
5002 }
5003
5004 function toHex (n) {
5005   if (n < 16) return '0' + n.toString(16)
5006   return n.toString(16)
5007 }
5008
5009 function utf8ToBytes(string, units) {
5010   var codePoint, length = string.length
5011   var leadSurrogate = null
5012   units = units || Infinity
5013   var bytes = []
5014   var i = 0
5015
5016   for (; i<length; i++) {
5017     codePoint = string.charCodeAt(i)
5018
5019     // is surrogate component
5020     if (codePoint > 0xD7FF && codePoint < 0xE000) {
5021
5022       // last char was a lead
5023       if (leadSurrogate) {
5024
5025         // 2 leads in a row
5026         if (codePoint < 0xDC00) {
5027           if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
5028           leadSurrogate = codePoint
5029           continue
5030         }
5031
5032         // valid surrogate pair
5033         else {
5034           codePoint = leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00 | 0x10000
5035           leadSurrogate = null
5036         }
5037       }
5038
5039       // no lead yet
5040       else {
5041
5042         // unexpected trail
5043         if (codePoint > 0xDBFF) {
5044           if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
5045           continue
5046         }
5047
5048         // unpaired lead
5049         else if (i + 1 === length) {
5050           if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
5051           continue
5052         }
5053
5054         // valid lead
5055         else {
5056           leadSurrogate = codePoint
5057           continue
5058         }
5059       }
5060     }
5061
5062     // valid bmp char, but last char was a lead
5063     else if (leadSurrogate) {
5064       if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
5065       leadSurrogate = null
5066     }
5067
5068     // encode utf8
5069     if (codePoint < 0x80) {
5070       if ((units -= 1) < 0) break
5071       bytes.push(codePoint)
5072     }
5073     else if (codePoint < 0x800) {
5074       if ((units -= 2) < 0) break
5075       bytes.push(
5076         codePoint >> 0x6 | 0xC0,
5077         codePoint & 0x3F | 0x80
5078       );
5079     }
5080     else if (codePoint < 0x10000) {
5081       if ((units -= 3) < 0) break
5082       bytes.push(
5083         codePoint >> 0xC | 0xE0,
5084         codePoint >> 0x6 & 0x3F | 0x80,
5085         codePoint & 0x3F | 0x80
5086       );
5087     }
5088     else if (codePoint < 0x200000) {
5089       if ((units -= 4) < 0) break
5090       bytes.push(
5091         codePoint >> 0x12 | 0xF0,
5092         codePoint >> 0xC & 0x3F | 0x80,
5093         codePoint >> 0x6 & 0x3F | 0x80,
5094         codePoint & 0x3F | 0x80
5095       );
5096     }
5097     else {
5098       throw new Error('Invalid code point')
5099     }
5100   }
5101
5102   return bytes
5103 }
5104
5105 function asciiToBytes (str) {
5106   var byteArray = []
5107   for (var i = 0; i < str.length; i++) {
5108     // Node's code seems to be doing this and not & 0x7F..
5109     byteArray.push(str.charCodeAt(i) & 0xFF)
5110   }
5111   return byteArray
5112 }
5113
5114 function utf16leToBytes (str, units) {
5115   var c, hi, lo
5116   var byteArray = []
5117   for (var i = 0; i < str.length; i++) {
5118
5119     if ((units -= 2) < 0) break
5120
5121     c = str.charCodeAt(i)
5122     hi = c >> 8
5123     lo = c % 256
5124     byteArray.push(lo)
5125     byteArray.push(hi)
5126   }
5127
5128   return byteArray
5129 }
5130
5131 function base64ToBytes (str) {
5132   return base64.toByteArray(base64clean(str))
5133 }
5134
5135 function blitBuffer (src, dst, offset, length, unitSize) {
5136   if (unitSize) length -= length % unitSize;
5137   for (var i = 0; i < length; i++) {
5138     if ((i + offset >= dst.length) || (i >= src.length))
5139       break
5140     dst[i + offset] = src[i]
5141   }
5142   return i
5143 }
5144
5145 function decodeUtf8Char (str) {
5146   try {
5147     return decodeURIComponent(str)
5148   } catch (err) {
5149     return String.fromCharCode(0xFFFD) // UTF 8 invalid char
5150   }
5151 }
5152
5153 },{"base64-js":50,"ieee754":51,"is-array":52}],50:[function(require,module,exports){
5154 var lookup = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
5155
5156 ;(function (exports) {
5157         'use strict';
5158
5159   var Arr = (typeof Uint8Array !== 'undefined')
5160     ? Uint8Array
5161     : Array
5162
5163         var PLUS   = '+'.charCodeAt(0)
5164         var SLASH  = '/'.charCodeAt(0)
5165         var NUMBER = '0'.charCodeAt(0)
5166         var LOWER  = 'a'.charCodeAt(0)
5167         var UPPER  = 'A'.charCodeAt(0)
5168         var PLUS_URL_SAFE = '-'.charCodeAt(0)
5169         var SLASH_URL_SAFE = '_'.charCodeAt(0)
5170
5171         function decode (elt) {
5172                 var code = elt.charCodeAt(0)
5173                 if (code === PLUS ||
5174                     code === PLUS_URL_SAFE)
5175                         return 62 // '+'
5176                 if (code === SLASH ||
5177                     code === SLASH_URL_SAFE)
5178                         return 63 // '/'
5179                 if (code < NUMBER)
5180                         return -1 //no match
5181                 if (code < NUMBER + 10)
5182                         return code - NUMBER + 26 + 26
5183                 if (code < UPPER + 26)
5184                         return code - UPPER
5185                 if (code < LOWER + 26)
5186                         return code - LOWER + 26
5187         }
5188
5189         function b64ToByteArray (b64) {
5190                 var i, j, l, tmp, placeHolders, arr
5191
5192                 if (b64.length % 4 > 0) {
5193                         throw new Error('Invalid string. Length must be a multiple of 4')
5194                 }
5195
5196                 // the number of equal signs (place holders)
5197                 // if there are two placeholders, than the two characters before it
5198                 // represent one byte
5199                 // if there is only one, then the three characters before it represent 2 bytes
5200                 // this is just a cheap hack to not do indexOf twice
5201                 var len = b64.length
5202                 placeHolders = '=' === b64.charAt(len - 2) ? 2 : '=' === b64.charAt(len - 1) ? 1 : 0
5203
5204                 // base64 is 4/3 + up to two characters of the original data
5205                 arr = new Arr(b64.length * 3 / 4 - placeHolders)
5206
5207                 // if there are placeholders, only get up to the last complete 4 chars
5208                 l = placeHolders > 0 ? b64.length - 4 : b64.length
5209
5210                 var L = 0
5211
5212                 function push (v) {
5213                         arr[L++] = v
5214                 }
5215
5216                 for (i = 0, j = 0; i < l; i += 4, j += 3) {
5217                         tmp = (decode(b64.charAt(i)) << 18) | (decode(b64.charAt(i + 1)) << 12) | (decode(b64.charAt(i + 2)) << 6) | decode(b64.charAt(i + 3))
5218                         push((tmp & 0xFF0000) >> 16)
5219                         push((tmp & 0xFF00) >> 8)
5220                         push(tmp & 0xFF)
5221                 }
5222
5223                 if (placeHolders === 2) {
5224                         tmp = (decode(b64.charAt(i)) << 2) | (decode(b64.charAt(i + 1)) >> 4)
5225                         push(tmp & 0xFF)
5226                 } else if (placeHolders === 1) {
5227                         tmp = (decode(b64.charAt(i)) << 10) | (decode(b64.charAt(i + 1)) << 4) | (decode(b64.charAt(i + 2)) >> 2)
5228                         push((tmp >> 8) & 0xFF)
5229                         push(tmp & 0xFF)
5230                 }
5231
5232                 return arr
5233         }
5234
5235         function uint8ToBase64 (uint8) {
5236                 var i,
5237                         extraBytes = uint8.length % 3, // if we have 1 byte left, pad 2 bytes
5238                         output = "",
5239                         temp, length
5240
5241                 function encode (num) {
5242                         return lookup.charAt(num)
5243                 }
5244
5245                 function tripletToBase64 (num) {
5246                         return encode(num >> 18 & 0x3F) + encode(num >> 12 & 0x3F) + encode(num >> 6 & 0x3F) + encode(num & 0x3F)
5247                 }
5248
5249                 // go through the array every three bytes, we'll deal with trailing stuff later
5250                 for (i = 0, length = uint8.length - extraBytes; i < length; i += 3) {
5251                         temp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2])
5252                         output += tripletToBase64(temp)
5253                 }
5254
5255                 // pad the end with zeros, but make sure to not forget the extra bytes
5256                 switch (extraBytes) {
5257                         case 1:
5258                                 temp = uint8[uint8.length - 1]
5259                                 output += encode(temp >> 2)
5260                                 output += encode((temp << 4) & 0x3F)
5261                                 output += '=='
5262                                 break
5263                         case 2:
5264                                 temp = (uint8[uint8.length - 2] << 8) + (uint8[uint8.length - 1])
5265                                 output += encode(temp >> 10)
5266                                 output += encode((temp >> 4) & 0x3F)
5267                                 output += encode((temp << 2) & 0x3F)
5268                                 output += '='
5269                                 break
5270                 }
5271
5272                 return output
5273         }
5274
5275         exports.toByteArray = b64ToByteArray
5276         exports.fromByteArray = uint8ToBase64
5277 }(typeof exports === 'undefined' ? (this.base64js = {}) : exports))
5278
5279 },{}],51:[function(require,module,exports){
5280 exports.read = function(buffer, offset, isLE, mLen, nBytes) {
5281   var e, m,
5282       eLen = nBytes * 8 - mLen - 1,
5283       eMax = (1 << eLen) - 1,
5284       eBias = eMax >> 1,
5285       nBits = -7,
5286       i = isLE ? (nBytes - 1) : 0,
5287       d = isLE ? -1 : 1,
5288       s = buffer[offset + i];
5289
5290   i += d;
5291
5292   e = s & ((1 << (-nBits)) - 1);
5293   s >>= (-nBits);
5294   nBits += eLen;
5295   for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8);
5296
5297   m = e & ((1 << (-nBits)) - 1);
5298   e >>= (-nBits);
5299   nBits += mLen;
5300   for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8);
5301
5302   if (e === 0) {
5303     e = 1 - eBias;
5304   } else if (e === eMax) {
5305     return m ? NaN : ((s ? -1 : 1) * Infinity);
5306   } else {
5307     m = m + Math.pow(2, mLen);
5308     e = e - eBias;
5309   }
5310   return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
5311 };
5312
5313 exports.write = function(buffer, value, offset, isLE, mLen, nBytes) {
5314   var e, m, c,
5315       eLen = nBytes * 8 - mLen - 1,
5316       eMax = (1 << eLen) - 1,
5317       eBias = eMax >> 1,
5318       rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0),
5319       i = isLE ? 0 : (nBytes - 1),
5320       d = isLE ? 1 : -1,
5321       s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0;
5322
5323   value = Math.abs(value);
5324
5325   if (isNaN(value) || value === Infinity) {
5326     m = isNaN(value) ? 1 : 0;
5327     e = eMax;
5328   } else {
5329     e = Math.floor(Math.log(value) / Math.LN2);
5330     if (value * (c = Math.pow(2, -e)) < 1) {
5331       e--;
5332       c *= 2;
5333     }
5334     if (e + eBias >= 1) {
5335       value += rt / c;
5336     } else {
5337       value += rt * Math.pow(2, 1 - eBias);
5338     }
5339     if (value * c >= 2) {
5340       e++;
5341       c /= 2;
5342     }
5343
5344     if (e + eBias >= eMax) {
5345       m = 0;
5346       e = eMax;
5347     } else if (e + eBias >= 1) {
5348       m = (value * c - 1) * Math.pow(2, mLen);
5349       e = e + eBias;
5350     } else {
5351       m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
5352       e = 0;
5353     }
5354   }
5355
5356   for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8);
5357
5358   e = (e << mLen) | m;
5359   eLen += mLen;
5360   for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8);
5361
5362   buffer[offset + i - d] |= s * 128;
5363 };
5364
5365 },{}],52:[function(require,module,exports){
5366
5367 /**
5368  * isArray
5369  */
5370
5371 var isArray = Array.isArray;
5372
5373 /**
5374  * toString
5375  */
5376
5377 var str = Object.prototype.toString;
5378
5379 /**
5380  * Whether or not the given `val`
5381  * is an array.
5382  *
5383  * example:
5384  *
5385  *        isArray([]);
5386  *        // > true
5387  *        isArray(arguments);
5388  *        // > false
5389  *        isArray('');
5390  *        // > false
5391  *
5392  * @param {mixed} val
5393  * @return {bool}
5394  */
5395
5396 module.exports = isArray || function (val) {
5397   return !! val && '[object Array]' == str.call(val);
5398 };
5399
5400 },{}],53:[function(require,module,exports){
5401 (function (process){
5402 // Copyright Joyent, Inc. and other Node contributors.
5403 //
5404 // Permission is hereby granted, free of charge, to any person obtaining a
5405 // copy of this software and associated documentation files (the
5406 // "Software"), to deal in the Software without restriction, including
5407 // without limitation the rights to use, copy, modify, merge, publish,
5408 // distribute, sublicense, and/or sell copies of the Software, and to permit
5409 // persons to whom the Software is furnished to do so, subject to the
5410 // following conditions:
5411 //
5412 // The above copyright notice and this permission notice shall be included
5413 // in all copies or substantial portions of the Software.
5414 //
5415 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
5416 // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
5417 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
5418 // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
5419 // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
5420 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
5421 // USE OR OTHER DEALINGS IN THE SOFTWARE.
5422
5423 // resolves . and .. elements in a path array with directory names there
5424 // must be no slashes, empty elements, or device names (c:\) in the array
5425 // (so also no leading and trailing slashes - it does not distinguish
5426 // relative and absolute paths)
5427 function normalizeArray(parts, allowAboveRoot) {
5428   // if the path tries to go above the root, `up` ends up > 0
5429   var up = 0;
5430   for (var i = parts.length - 1; i >= 0; i--) {
5431     var last = parts[i];
5432     if (last === '.') {
5433       parts.splice(i, 1);
5434     } else if (last === '..') {
5435       parts.splice(i, 1);
5436       up++;
5437     } else if (up) {
5438       parts.splice(i, 1);
5439       up--;
5440     }
5441   }
5442
5443   // if the path is allowed to go above the root, restore leading ..s
5444   if (allowAboveRoot) {
5445     for (; up--; up) {
5446       parts.unshift('..');
5447     }
5448   }
5449
5450   return parts;
5451 }
5452
5453 // Split a filename into [root, dir, basename, ext], unix version
5454 // 'root' is just a slash, or nothing.
5455 var splitPathRe =
5456     /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
5457 var splitPath = function(filename) {
5458   return splitPathRe.exec(filename).slice(1);
5459 };
5460
5461 // path.resolve([from ...], to)
5462 // posix version
5463 exports.resolve = function() {
5464   var resolvedPath = '',
5465       resolvedAbsolute = false;
5466
5467   for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
5468     var path = (i >= 0) ? arguments[i] : process.cwd();
5469
5470     // Skip empty and invalid entries
5471     if (typeof path !== 'string') {
5472       throw new TypeError('Arguments to path.resolve must be strings');
5473     } else if (!path) {
5474       continue;
5475     }
5476
5477     resolvedPath = path + '/' + resolvedPath;
5478     resolvedAbsolute = path.charAt(0) === '/';
5479   }
5480
5481   // At this point the path should be resolved to a full absolute path, but
5482   // handle relative paths to be safe (might happen when process.cwd() fails)
5483
5484   // Normalize the path
5485   resolvedPath = normalizeArray(filter(resolvedPath.split('/'), function(p) {
5486     return !!p;
5487   }), !resolvedAbsolute).join('/');
5488
5489   return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';
5490 };
5491
5492 // path.normalize(path)
5493 // posix version
5494 exports.normalize = function(path) {
5495   var isAbsolute = exports.isAbsolute(path),
5496       trailingSlash = substr(path, -1) === '/';
5497
5498   // Normalize the path
5499   path = normalizeArray(filter(path.split('/'), function(p) {
5500     return !!p;
5501   }), !isAbsolute).join('/');
5502
5503   if (!path && !isAbsolute) {
5504     path = '.';
5505   }
5506   if (path && trailingSlash) {
5507     path += '/';
5508   }
5509
5510   return (isAbsolute ? '/' : '') + path;
5511 };
5512
5513 // posix version
5514 exports.isAbsolute = function(path) {
5515   return path.charAt(0) === '/';
5516 };
5517
5518 // posix version
5519 exports.join = function() {
5520   var paths = Array.prototype.slice.call(arguments, 0);
5521   return exports.normalize(filter(paths, function(p, index) {
5522     if (typeof p !== 'string') {
5523       throw new TypeError('Arguments to path.join must be strings');
5524     }
5525     return p;
5526   }).join('/'));
5527 };
5528
5529
5530 // path.relative(from, to)
5531 // posix version
5532 exports.relative = function(from, to) {
5533   from = exports.resolve(from).substr(1);
5534   to = exports.resolve(to).substr(1);
5535
5536   function trim(arr) {
5537     var start = 0;
5538     for (; start < arr.length; start++) {
5539       if (arr[start] !== '') break;
5540     }
5541
5542     var end = arr.length - 1;
5543     for (; end >= 0; end--) {
5544       if (arr[end] !== '') break;
5545     }
5546
5547     if (start > end) return [];
5548     return arr.slice(start, end - start + 1);
5549   }
5550
5551   var fromParts = trim(from.split('/'));
5552   var toParts = trim(to.split('/'));
5553
5554   var length = Math.min(fromParts.length, toParts.length);
5555   var samePartsLength = length;
5556   for (var i = 0; i < length; i++) {
5557     if (fromParts[i] !== toParts[i]) {
5558       samePartsLength = i;
5559       break;
5560     }
5561   }
5562
5563   var outputParts = [];
5564   for (var i = samePartsLength; i < fromParts.length; i++) {
5565     outputParts.push('..');
5566   }
5567
5568   outputParts = outputParts.concat(toParts.slice(samePartsLength));
5569
5570   return outputParts.join('/');
5571 };
5572
5573 exports.sep = '/';
5574 exports.delimiter = ':';
5575
5576 exports.dirname = function(path) {
5577   var result = splitPath(path),
5578       root = result[0],
5579       dir = result[1];
5580
5581   if (!root && !dir) {
5582     // No dirname whatsoever
5583     return '.';
5584   }
5585
5586   if (dir) {
5587     // It has a dirname, strip trailing slash
5588     dir = dir.substr(0, dir.length - 1);
5589   }
5590
5591   return root + dir;
5592 };
5593
5594
5595 exports.basename = function(path, ext) {
5596   var f = splitPath(path)[2];
5597   // TODO: make this comparison case-insensitive on windows?
5598   if (ext && f.substr(-1 * ext.length) === ext) {
5599     f = f.substr(0, f.length - ext.length);
5600   }
5601   return f;
5602 };
5603
5604
5605 exports.extname = function(path) {
5606   return splitPath(path)[3];
5607 };
5608
5609 function filter (xs, f) {
5610     if (xs.filter) return xs.filter(f);
5611     var res = [];
5612     for (var i = 0; i < xs.length; i++) {
5613         if (f(xs[i], i, xs)) res.push(xs[i]);
5614     }
5615     return res;
5616 }
5617
5618 // String.prototype.substr - negative index don't work in IE8
5619 var substr = 'ab'.substr(-1) === 'b'
5620     ? function (str, start, len) { return str.substr(start, len) }
5621     : function (str, start, len) {
5622         if (start < 0) start = str.length + start;
5623         return str.substr(start, len);
5624     }
5625 ;
5626
5627 }).call(this,require('_process'))
5628 },{"_process":54}],54:[function(require,module,exports){
5629 // shim for using process in browser
5630
5631 var process = module.exports = {};
5632 var queue = [];
5633 var draining = false;
5634
5635 function drainQueue() {
5636     if (draining) {
5637         return;
5638     }
5639     draining = true;
5640     var currentQueue;
5641     var len = queue.length;
5642     while(len) {
5643         currentQueue = queue;
5644         queue = [];
5645         var i = -1;
5646         while (++i < len) {
5647             currentQueue[i]();
5648         }
5649         len = queue.length;
5650     }
5651     draining = false;
5652 }
5653 process.nextTick = function (fun) {
5654     queue.push(fun);
5655     if (!draining) {
5656         setTimeout(drainQueue, 0);
5657     }
5658 };
5659
5660 process.title = 'browser';
5661 process.browser = true;
5662 process.env = {};
5663 process.argv = [];
5664 process.version = ''; // empty string to avoid regexp issues
5665
5666 function noop() {}
5667
5668 process.on = noop;
5669 process.addListener = noop;
5670 process.once = noop;
5671 process.off = noop;
5672 process.removeListener = noop;
5673 process.removeAllListeners = noop;
5674 process.emit = noop;
5675
5676 process.binding = function (name) {
5677     throw new Error('process.binding is not supported');
5678 };
5679
5680 // TODO(shtylman)
5681 process.cwd = function () { return '/' };
5682 process.chdir = function (dir) {
5683     throw new Error('process.chdir is not supported');
5684 };
5685 process.umask = function() { return 0; };
5686
5687 },{}],55:[function(require,module,exports){
5688 var caniuse = require('caniuse-db/data').agents;
5689 var path    = require('path');
5690 var fs      = require('fs');
5691
5692 var uniq = function (array) {
5693     var filtered = [];
5694     for ( var i = 0; i < array.length; i++ ) {
5695         if ( filtered.indexOf(array[i]) == -1 ) filtered.push(array[i]);
5696     }
5697     return filtered;
5698 };
5699
5700 normalizeVersion = function (data, version) {
5701     if ( data.versions.indexOf(version) != -1 ) {
5702         return version;
5703     } else {
5704         var alias = browserslist.versionAliases[data.name][version];
5705         if ( alias ) return alias;
5706     }
5707 };
5708
5709 // Return array of browsers by selection queries:
5710 //
5711 //   browserslist('IE >= 10, IE 8') //=> ['ie 11', 'ie 10', 'ie 8']
5712 var browserslist = function (selections, opts) {
5713     if ( typeof(opts) == 'undefined' ) opts = { };
5714
5715     if ( typeof(selections) == 'undefined' || selections === null ) {
5716         var config = browserslist.readConfig(opts.path);
5717         if ( config === false ) {
5718             selections = browserslist.defaults;
5719         } else {
5720             selections = config;
5721         }
5722     }
5723
5724     if ( typeof(selections) == 'string' ) {
5725         selections = selections.split(/,\s*/);
5726     }
5727
5728     var result = [];
5729
5730     var query, match, array, used;
5731     selections.forEach(function (selection) {
5732         if ( selection.trim() === '' ) return;
5733         used = false;
5734
5735         for ( var i in browserslist.queries ) {
5736             query = browserslist.queries[i];
5737             match = selection.match(query.regexp);
5738             if ( match ) {
5739                 array  = query.select.apply(browserslist, match.slice(1));
5740                 result = result.concat(array);
5741                 used   = true;
5742                 break;
5743             }
5744         }
5745
5746         if ( !used ) {
5747             throw 'Unknown browser query `' + selection + '`';
5748         }
5749     });
5750
5751     return uniq(result).sort(function (name1, name2) {
5752         name1 = name1.split(' ');
5753         name2 = name2.split(' ');
5754         if ( name1[0] == name2[0] ) {
5755             return parseFloat(name2[1]) - parseFloat(name1[1]);
5756         } else {
5757             return name1[0].localeCompare(name2[0]);
5758         }
5759     });
5760 };
5761
5762 // Will be filled by Can I Use data below
5763 browserslist.data  = { };
5764 browserslist.usage = {
5765     global: { }
5766 };
5767
5768 // Default browsers query
5769 browserslist.defaults = [
5770     '> 1%',
5771     'last 2 versions',
5772     'Firefox ESR',
5773     'Opera 12.1'
5774 ];
5775
5776 // What browsers will be used in `last n version` query
5777 browserslist.major = ['safari', 'opera', 'ios_saf', 'ie_mob', 'ie',
5778                       'firefox', 'chrome'];
5779
5780 // Browser names aliases
5781 browserslist.aliases = {
5782     fx:             'firefox',
5783     ff:             'firefox',
5784     ios:            'ios_saf',
5785     explorer:       'ie',
5786     blackberry:     'bb',
5787     explorermobile: 'ie_mob',
5788     operamini:      'op_mini',
5789     operamobile:    'op_mob',
5790     chromeandroid:  'and_chr',
5791     firefoxandroid: 'and_ff'
5792 };
5793
5794 // Aliases ot work with joined versions like `ios_saf 7.0-7.1`
5795 browserslist.versionAliases = { };
5796
5797 // Get browser data by alias or case insensitive name
5798 browserslist.byName = function (name) {
5799     name = name.toLowerCase();
5800     name = browserslist.aliases[name] || name;
5801
5802     var data = browserslist.data[name];
5803     if ( !data ) throw 'Unknown browser ' + name;
5804     return data;
5805 };
5806
5807 // Find config, read file and parse it
5808 browserslist.readConfig = function (from) {
5809     if ( from === false )   return false;
5810     if ( !fs.readFileSync ) return false;
5811     if ( typeof(from) == 'undefined' ) from = '.';
5812
5813     var dirs = path.resolve(from).split(path.sep);
5814     var config, stat;
5815     while ( dirs.length ) {
5816         config = dirs.concat(['browserslist']).join(path.sep);
5817
5818         if ( fs.existsSync(config) && fs.lstatSync(config).isFile() ) {
5819             return browserslist.parseConfig( fs.readFileSync(config) );
5820         }
5821
5822         dirs.pop();
5823     }
5824
5825     return false;
5826 };
5827
5828 // Return array of queries from config content
5829 browserslist.parseConfig = function (string) {
5830     return string.toString()
5831                  .replace(/#[^\n]*/g, '')
5832                  .split(/\n/)
5833                  .map(function (i) {
5834                     return i.trim();
5835                  })
5836                  .filter(function (i) {
5837                     return i !== '';
5838                  });
5839 };
5840
5841 browserslist.queries = {
5842
5843     lastVersions: {
5844         regexp: /^last (\d+) versions?$/i,
5845         select: function (versions) {
5846             var selected = [];
5847             browserslist.major.forEach(function (name) {
5848                 var data  = browserslist.byName(name);
5849                 var array = data.released.slice(-versions);
5850
5851                 array = array.map(function (v) {
5852                     return data.name + ' ' + v;
5853                 });
5854                 selected = selected.concat(array);
5855             });
5856             return selected;
5857         }
5858     },
5859
5860     lastByBrowser: {
5861         regexp: /^last (\d+) (\w+) versions?$/i,
5862         select: function (versions, name) {
5863             var data = browserslist.byName(name);
5864             return data.released.slice(-versions).map(function (v) {
5865                 return data.name + ' ' + v;
5866             });
5867         }
5868     },
5869
5870     globalStatistics: {
5871         regexp: /^> (\d+\.?\d*)%$/,
5872         select: function (popularity) {
5873             popularity = parseFloat(popularity);
5874             var result = [];
5875
5876             for ( var version in browserslist.usage.global ) {
5877                 if ( browserslist.usage.global[version] > popularity ) {
5878                     result.push(version);
5879                 }
5880             }
5881
5882             return result;
5883         }
5884     },
5885
5886     countryStatistics: {
5887         regexp: /^> (\d+\.?\d*)% in (\w\w)$/,
5888         select: function (popularity, country) {
5889             popularity = parseFloat(popularity);
5890             country    = country.toUpperCase();
5891             var result = [];
5892
5893             var usage = browserslist.usage[country];
5894             if ( !usage ) {
5895                 usage = { };
5896                 var data = require('caniuse-db/region-usage-json/' + country);
5897                 for ( var i in data.data ) {
5898                     fillUsage(usage, i, data.data[i]);
5899                 }
5900                 browserslist.usage[country] = usage;
5901             }
5902
5903             for ( var version in usage ) {
5904                 if ( usage[version] > popularity ) {
5905                     result.push(version);
5906                 }
5907             }
5908
5909             return result;
5910         }
5911     },
5912
5913     versions: {
5914         regexp: /^(\w+) (>=?|<=?)\s*([\d\.]+)/,
5915         select: function (name, sign, version) {
5916             var data = browserslist.byName(name);
5917             version  = parseFloat(version);
5918
5919             var filter;
5920             if ( sign == '>' ) {
5921                 filter = function (v) {
5922                     return parseFloat(v) > version;
5923                 };
5924             } else if ( sign == '>=' ) {
5925                 filter = function (v) {
5926                     return parseFloat(v) >= version;
5927                 };
5928             } else if ( sign == '<' ) {
5929                 filter = function (v) {
5930                     return parseFloat(v) < version;
5931                 };
5932             } else if ( sign == '<=' ) {
5933                 filter = function (v) {
5934                     return parseFloat(v) <= version;
5935                 };
5936             }
5937
5938             return data.released.filter(filter).map(function (v) {
5939                 return data.name + ' ' + v;
5940             });
5941         }
5942     },
5943
5944     esr: {
5945         regexp: /^(firefox|ff|fx) esr$/i,
5946         select: function (versions) {
5947             return ['firefox 31'];
5948         }
5949     },
5950
5951     direct: {
5952         regexp: /^(\w+) ([\d\.]+)$/,
5953         select: function (name, version) {
5954             var data  = browserslist.byName(name);
5955             var alias = normalizeVersion(data, version);
5956             if ( alias ) {
5957                 version = alias;
5958             } else {
5959                 if ( version.indexOf('.') == -1 ) {
5960                     alias = version + '.0';
5961                 } else if ( /\.0$/.test(version) ) {
5962                     alias = version.replace(/\.0$/, '');
5963                 }
5964                 alias = normalizeVersion(data, alias);
5965                 if ( alias ) {
5966                     version = alias;
5967                 } else {
5968                     throw 'Unknown version ' + version + ' of ' + name;
5969                 }
5970             }
5971
5972             return [data.name + ' ' + version];
5973         }
5974     }
5975
5976 };
5977
5978 // Get and convert Can I Use data
5979
5980 var normalize = function (versions) {
5981     return versions.filter(function (version) {
5982         return typeof(version) == 'string';
5983     });
5984 };
5985
5986 var fillUsage = function (result, name, data) {
5987     for ( var i in data ) {
5988         result[name + ' ' + i] = data[i];
5989     }
5990 };
5991
5992 for ( var name in caniuse ) {
5993     browserslist.data[name] = {
5994         name:     name,
5995         versions: normalize(caniuse[name].versions),
5996         released: normalize(caniuse[name].versions.slice(0, -3))
5997     };
5998     fillUsage(browserslist.usage.global, name, caniuse[name].usage_global);
5999
6000     browserslist.versionAliases[name] = { };
6001     for ( var i = 0; i < caniuse[name].versions.length; i++ ) {
6002         if ( !caniuse[name].versions[i] ) continue;
6003         var full = caniuse[name].versions[i];
6004
6005         if ( full.indexOf('-') != -1 ) {
6006             var interval = full.split('-');
6007             for ( var j = 0; j < interval.length; j++ ) {
6008                 browserslist.versionAliases[name][ interval[j] ] = full;
6009             }
6010         }
6011     }
6012 }
6013
6014 module.exports = browserslist;
6015
6016 },{"caniuse-db/data":56,"fs":48,"path":53}],56:[function(require,module,exports){
6017 module.exports={"eras":{"e-36":"36 versions back","e-35":"35 versions back","e-34":"34 versions back","e-33":"33 versions back","e-32":"32 versions back","e-31":"31 versions back","e-30":"30 versions back","e-29":"29 versions back","e-28":"28 versions back","e-27":"27 versions back","e-26":"26 versions back","e-25":"25 versions back","e-24":"24 versions back","e-23":"23 versions back","e-22":"22 versions back","e-21":"21 versions back","e-20":"20 versions back","e-19":"19 versions back","e-18":"18 versions back","e-17":"17 versions back","e-16":"16 versions back","e-15":"15 versions back","e-14":"14 versions back","e-13":"13 versions back","e-12":"12 versions back","e-11":"11 versions back","e-10":"10 versions back","e-9":"9 versions back","e-8":"8 versions back","e-7":"7 versions back","e-6":"6 versions back","e-5":"5 versions back","e-4":"4 versions back","e-3":"3 versions back","e-2":"2 versions back","e-1":"Previous version","e0":"Current","e1":"Near future","e2":"Farther future","e3":"3 versions ahead"},"agents":{"ie":{"browser":"IE","abbr":"IE","prefix":"ms","type":"desktop","usage_global":{"5.5":0.009298,"6":0.0737794,"7":0.187802,"8":4.07799,"9":2.1329,"10":1.63656,"11":8.33707,"TP":0},"versions":[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,"5.5","6","7","8","9","10","11","TP",null,null]},"firefox":{"browser":"Firefox","abbr":"FF","prefix":"moz","type":"desktop","usage_global":{"2":0.006597,"3":0.026388,"3.5":0.013194,"3.6":0.092358,"4":0.026388,"5":0.013194,"6":0.026388,"7":0.013194,"8":0.046179,"9":0.013194,"10":0.026388,"11":0.046179,"12":0.059373,"13":0.026388,"14":0.026388,"15":0.032985,"16":0.052776,"17":0.039582,"18":0.032985,"19":0.026388,"20":0.032985,"21":0.039582,"22":0.032985,"23":0.046179,"24":0.079164,"25":0.052776,"26":0.059373,"27":0.098955,"28":0.059373,"29":0.092358,"30":0.151731,"31":0.448596,"32":0.369432,"33":2.90928,"34":6.50464,"35":0.237492,"36":0.006597,"37":0.006597,"38":0},"versions":[null,"2","3","3.5","3.6","4","5","6","7","8","9","10","11","12","13","14","15","16","17","18","19","20","21","22","23","24","25","26","27","28","29","30","31","32","33","34","35","36","37","38"]},"chrome":{"browser":"Chrome","abbr":"Chr.","prefix":"webkit","type":"desktop","usage_global":{"4":0.026388,"5":0.013194,"6":0.019791,"7":0.013194,"8":0.013194,"9":0.013194,"10":0.019791,"11":0.098955,"12":0.039582,"13":0.026388,"14":0.026388,"15":0.026388,"16":0.019791,"17":0.013194,"18":0.032985,"19":0.013194,"20":0.013194,"21":0.072567,"22":0.059373,"23":0.032985,"24":0.039582,"25":0.032985,"26":0.052776,"27":0.072567,"28":0.079164,"29":0.06597,"30":0.13194,"31":0.752058,"32":0.145134,"33":0.46179,"34":0.32985,"35":0.613521,"36":0.890595,"37":1.02253,"38":1.326,"39":25.3919,"40":0.125343,"41":0.184716,"42":0,"43":0},"versions":["4","5","6","7","8","9","10","11","12","13","14","15","16","17","18","19","20","21","22","23","24","25","26","27","28","29","30","31","32","33","34","35","36","37","38","39","40","41","42","43"]},"safari":{"browser":"Safari","abbr":"Saf.","prefix":"webkit","type":"desktop","usage_global":{"3.1":0,"3.2":0.008692,"4":0.052776,"5":0.125343,"5.1":0.409014,"6":0.098955,"6.1":0.277074,"7":0.448596,"7.1":0.567342,"8":1.00274},"versions":[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,"3.1","3.2","4","5","5.1","6","6.1","7","7.1","8",null,null,null]},"opera":{"browser":"Opera","abbr":"Op.","prefix":"webkit","type":"desktop","usage_global":{"9.5-9.6":0.00685,"10.0-10.1":0.013194,"10.5":0.008392,"10.6":0.007296,"11":0.014996,"11.1":0.008219,"11.5":0.00685,"11.6":0.013194,"12":0.013194,"12.1":0.19791,"15":0.00685,"16":0.00685,"17":0.00685,"18":0.013194,"19":0.006597,"20":0.013194,"21":0.006597,"22":0.006597,"23":0.013434,"24":0.013194,"25":0.026388,"26":0.606924,"27":0.006597,"28":0,"29":0},"versions":[null,null,null,null,null,null,null,null,null,null,null,null,null,null,"9.5-9.6","10.0-10.1","10.5","10.6","11","11.1","11.5","11.6","12","12.1","15","16","17","18","19","20","21","22","23","24","25","26","27","28","29",null],"prefix_exceptions":{"9.5-9.6":"o","10.0-10.1":"o","10.5":"o","10.6":"o","11":"o","11.1":"o","11.5":"o","11.6":"o","12":"o","12.1":"o"}},"ios_saf":{"browser":"iOS Safari","abbr":"iOS","prefix":"webkit","type":"mobile","usage_global":{"3.2":0,"4.0-4.1":0,"4.2-4.3":0,"5.0-5.1":0.0454654,"6.0-6.1":0.188026,"7.0-7.1":2.22703,"8":0.631121,"8.1":4.58892},"versions":[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,"3.2","4.0-4.1","4.2-4.3","5.0-5.1","6.0-6.1","7.0-7.1","8","8.1",null,null,null]},"op_mini":{"browser":"Opera Mini","abbr":"O.Mini","prefix":"o","type":"mobile","usage_global":{"5.0-8.0":3.0738},"versions":[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,"5.0-8.0",null,null,null]},"android":{"browser":"Android Browser","abbr":"And.","prefix":"webkit","type":"mobile","usage_global":{"2.1":0,"2.2":0.00527484,"2.3":0.148355,"3":0,"4":0.305941,"4.1":0.937603,"4.2-4.3":1.49344,"4.4":2.50621,"4.4.3-4.4.4":1.02464,"37":0},"versions":[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,"2.1","2.2","2.3","3","4","4.1","4.2-4.3","4.4","4.4.3-4.4.4","37",null,null,null]},"op_mob":{"browser":"Opera Mobile","abbr":"O.Mob","prefix":"o","type":"mobile","usage_global":{"10":0,"11.5":0,"12":0.00438935,"12.1":0.0219467,"24":0},"versions":[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,"10",null,null,"11.5","12","12.1","24",null,null,null],"prefix_exceptions":{"24":"webkit"}},"bb":{"browser":"Blackberry Browser","abbr":"BB","prefix":"webkit","type":"mobile","usage_global":{"7":0.0935825,"10":0},"versions":[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,"7","10",null,null,null]},"and_chr":{"browser":"Chrome for Android","abbr":"Chr/And.","prefix":"webkit","type":"mobile","usage_global":{"40":10.5231},"versions":[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,"40",null,null,null]},"and_ff":{"browser":"Firefox for Android","abbr":"FF/And.","prefix":"moz","type":"mobile","usage_global":{"33":0.129314},"versions":[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,"33",null,null,null]},"ie_mob":{"browser":"IE Mobile","abbr":"IE.Mob","prefix":"ms","type":"mobile","usage_global":{"10":0.331242,"11":0.400403},"versions":[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,"10","11",null,null,null]},"and_uc":{"browser":"UC Browser for Android","abbr":"UC","prefix":"webkit","type":"mobile","usage_global":{"9.9":3.77733},"versions":[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,"9.9",null,null,null],"prefix_exceptions":{"9.9":"webkit"}}},"statuses":{"rec":"W3C Recommendation","pr":"W3C Proposed Recommendation","cr":"W3C Candidate Recommendation","wd":"W3C Working Draft","ls":"WHATWG Living Standard","other":"Other","unoff":"Unofficial / Note"},"cats":{"CSS":["CSS","CSS2","CSS3"],"HTML5":["Canvas","HTML5"],"JS API":["JS API"],"Other":["PNG","Other","DOM"],"SVG":["SVG"]},"updated":1422423430,"data":{"png-alpha":{"title":"PNG alpha transparency","description":"Semi-transparent areas in PNG files","spec":"http://www.w3.org/TR/PNG/","status":"rec","links":[{"url":"http://en.wikipedia.org/wiki/Portable_Network_Graphics","title":"Wikipedia"},{"url":"http://dillerdesign.com/experiment/DD_belatedPNG/","title":"Workaround for IE6"}],"categories":["PNG"],"stats":{"ie":{"5.5":"n","6":"p","7":"y","8":"y","9":"y","10":"y","11":"y","TP":"y"},"firefox":{"2":"y","3":"y","3.5":"y","3.6":"y","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"y","3.2":"y","4":"y","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"y","9.5-9.6":"y","10.0-10.1":"y","10.5":"y","10.6":"y","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"y","4.0-4.1":"y","4.2-4.3":"y","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"y"},"android":{"2.1":"y","2.2":"y","2.3":"y","3":"y","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"y","11":"y","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y"}},"notes":"IE6 does support full transparency in 8-bit PNGs, which can sometimes be an alternative to 24-bit PNGs.","notes_by_num":{},"usage_perc_y":97.04,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"","ie_id":"","chrome_id":""},"apng":{"title":"Animated PNG (APNG)","description":"Like animated GIFs, but allowing 24-bit colors and alpha transparency","spec":"https://wiki.mozilla.org/APNG_Specification","status":"unoff","links":[{"url":"http://en.wikipedia.org/wiki/APNG","title":"Wikipedia"},{"url":"https://github.com/davidmz/apng-canvas","title":"Polyfill using canvas"},{"url":"https://chrome.google.com/webstore/detail/ehkepjiconegkhpodgoaeamnpckdbblp","title":"Chrome extension providing support"}],"categories":["PNG"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"y","3.5":"y","3.6":"y","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"n","34":"n","35":"n","36":"n","37":"n","38":"n","39":"n","40":"n","41":"n","42":"n","43":"n"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"n","7":"n","7.1":"n","8":"y"},"opera":{"9":"n","9.5-9.6":"y","10.0-10.1":"y","10.5":"y","10.6":"y","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"n","4.4.3-4.4.4":"n","37":"n"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"y","11":"y","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"n"},"and_chr":{"40":"n"},"and_ff":{"33":"y"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"n"}},"notes":"Where support for APNG is missing, only the first frame is displayed","notes_by_num":{},"usage_perc_y":18.54,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"","ie_id":"","chrome_id":""},"video":{"title":"Video element","description":"Method of playing videos on webpages (without requiring a plug-in).","spec":"https://html.spec.whatwg.org/multipage/embedded-content.html#the-video-element","status":"ls","links":[{"url":"https://dev.opera.com/articles/view/everything-you-need-to-know-about-html5-video-and-audio/","title":"Detailed article on video/audio elements"},{"url":"http://webmproject.org","title":"WebM format information"},{"url":"http://camendesign.co.uk/code/video_for_everybody","title":"Video for Everybody"},{"url":"http://diveintohtml5.info/video.html","title":"Video on the Web - includes info on Android support"},{"url":"https://raw.github.com/phiggins42/has.js/master/detect/video.js#video","title":"has.js test"},{"url":"http://docs.webplatform.org/wiki/html/elements/video","title":"WebPlatform Docs"}],"categories":["HTML5"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"y","10":"y","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"y","3.6":"y","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"y","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"y","10.6":"y","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"y","4.0-4.1":"y","4.2-4.3":"y","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"a","2.2":"a","2.3":"y","3":"y","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"n","11":"y","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y"}},"notes":"Different browsers have support for different video formats, see sub-features for details. \r\n\r\nThe Android browser (before 2.3) requires [specific handling](http://www.broken-links.com/2010/07/08/making-html5-video-work-on-android-phones/) to run the video element.","notes_by_num":{},"usage_perc_y":89.62,"usage_perc_a":0.01,"ucprefix":false,"parent":"","keywords":"<video>","ie_id":"","chrome_id":""},"audio":{"title":"Audio element","description":"Method of playing sound on webpages (without requiring a plug-in).","spec":"https://html.spec.whatwg.org/multipage/embedded-content.html#the-audio-element","status":"ls","links":[{"url":"http://html5doctor.com/native-audio-in-the-browser/","title":"HTML5 Doctor article"},{"url":"https://dev.opera.com/articles/view/everything-you-need-to-know-about-html5-video-and-audio/","title":"Detailed article on video/audio elements"},{"url":"http://www.jplayer.org/latest/demos/","title":"Demos of audio player that uses the audio element"},{"url":"http://24ways.org/2010/the-state-of-html5-audio","title":"Detailed article on support"},{"url":"http://textopia.org/androidsoundformats.html","title":"File format test page"},{"url":"http://www.phoboslab.org/log/2011/03/the-state-of-html5-audio","title":"The State of HTML5 Audio"},{"url":"https://raw.github.com/phiggins42/has.js/master/detect/audio.js#audio","title":"has.js test"},{"url":"http://docs.webplatform.org/wiki/html/elements/audio","title":"WebPlatform Docs"}],"categories":["HTML5"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"y","10":"y","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"y","3.6":"y","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"y","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"a","10.0-10.1":"a","10.5":"y","10.6":"y","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"y","4.2-4.3":"y","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"y","3":"y","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"n","11":"y","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y"}},"notes":"","notes_by_num":{},"usage_perc_y":89.62,"usage_perc_a":0.02,"ucprefix":false,"parent":"","keywords":"<audio>","ie_id":"","chrome_id":""},"contenteditable":{"title":"contenteditable attribute (basic support)","description":"Method of making any HTML element editable.","spec":"https://html.spec.whatwg.org/multipage/interaction.html#contenteditable","status":"ls","links":[{"url":"http://html5demos.com/contenteditable","title":"Demo page"},{"url":"https://blog.whatwg.org/the-road-to-html-5-contenteditable","title":"WHATWG blog post"},{"url":"http://accessgarage.wordpress.com/2009/05/08/how-to-hack-your-app-to-make-contenteditable-work/","title":"Blog post on usage problems"},{"url":"http://docs.webplatform.org/wiki/html/attributes/contentEditable","title":"WebPlatform Docs"}],"categories":["HTML5"],"stats":{"ie":{"5.5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","TP":"y"},"firefox":{"2":"n","3":"a","3.5":"y","3.6":"y","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"y","3.2":"y","4":"y","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"y","9.5-9.6":"y","10.0-10.1":"y","10.5":"y","10.6":"y","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"y","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y"}},"notes":"This support only refers to very basic editing capability, implementations vary significantly on how certain elements can be edited.","notes_by_num":{},"usage_perc_y":93.86,"usage_perc_a":0.03,"ucprefix":false,"parent":"","keywords":"","ie_id":"","chrome_id":""},"dragndrop":{"title":"Drag and Drop","description":"Method of easily dragging and dropping elements on a page, requiring minimal JavaScript.","spec":"https://html.spec.whatwg.org/multipage/interaction.html#dnd","status":"ls","links":[{"url":"http://html5doctor.com/native-drag-and-drop/","title":"HTML5 Doctor article"},{"url":"http://nettutsplus.s3.amazonaws.com/64_html5dragdrop/demo/index.html","title":"Shopping cart demo"},{"url":"http://html5demos.com/drag","title":"Demo with link blocks"},{"url":"http://docs.webplatform.org/wiki/dom/DragEvent","title":"WebPlatform Docs"},{"url":"https://github.com/MihaiValentin/setDragImage-IE","title":"Polyfill for setDragImage in IE"},{"url":"http://blog.teamtreehouse.com/implementing-native-drag-and-drop","title":"Implementing Native Drag and Drop"}],"categories":["HTML5"],"stats":{"ie":{"5.5":"a #1","6":"a #1","7":"a #1","8":"a #1","9":"a #1","10":"a #2","11":"a #2","TP":"a #2"},"firefox":{"2":"p","3":"p","3.5":"y","3.6":"y","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"y","3.2":"y","4":"y","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"p","9.5-9.6":"p","10.0-10.1":"p","10.5":"p","10.6":"p","11":"p","11.1":"p","11.5":"p","11.6":"p","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"n","8.1":"n"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"n","4.4.3-4.4.4":"n","37":"n"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"p","11":"p","11.1":"p","11.5":"p","12":"p","12.1":"y","24":"n"},"and_chr":{"40":"n"},"and_ff":{"33":"n"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"n"}},"notes":"`dataTransfer.items` only supported by Chrome.\r\n\r\nCurrently no browser supports the `dropzone` attribute.\r\n\r\nFirefox supports any kind of DOM elements for `.setDragImage`. Chrome must have either an `HTMLImageElement` or any kind of DOM elements attached to the DOM and within the viewport of the browser for `.setDragImage`.","notes_by_num":{"1":"Partial support refers to no support for the `dataTransfer.files` or `.types` objects and limited supported formats for `dataTransfer.setData`/`getData`.","2":"Partial support refers to not supporting `.setDragImage`"},"usage_perc_y":48.84,"usage_perc_a":16.46,"ucprefix":false,"parent":"","keywords":"draganddrop","ie_id":"","chrome_id":""},"internationalization":{"title":"Internationalization API","description":"Locale-sensitive collation (string comparison), number formatting, and date and time formatting.","spec":"http://www.ecma-international.org/ecma-402/1.0/","status":"other","links":[{"url":"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl","title":"MDN reference"},{"url":"http://norbertlindenberg.com/2012/12/ecmascript-internationalization-api/","title":"The ECMAScript Internationalization API"}],"categories":["JS API"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"n","7":"n","7.1":"n","8":"n"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"n","8.1":"n"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"u","4.4.3-4.4.4":"u","37":"y"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"n","11":"y"},"and_uc":{"9.9":"n"}},"notes":"","notes_by_num":{},"usage_perc_y":62.57,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"Intl,Collator,NumberFormat,DateTimeFormat","ie_id":"ecmascriptinternationalizationapi","chrome_id":""},"queryselector":{"title":"querySelector/querySelectorAll","description":"Method of accessing DOM elements using CSS selectors","spec":"http://www.w3.org/TR/selectors-api/","status":"rec","links":[{"url":"https://developer.mozilla.org/en/DOM/element.querySelector","title":"MDN article on querySelector"},{"url":"https://developer.mozilla.org/En/DOM/Element.querySelectorAll","title":"MDN article on querySelectorAll"},{"url":"http://cjihrig.com/blog/javascripts-selectors-api/","title":"Blog post"},{"url":"http://docs.webplatform.org/wiki/css/selectors_api/querySelector","title":"WebPlatform Docs"}],"categories":["DOM"],"stats":{"ie":{"5.5":"n","6":"p","7":"p","8":"a #1","9":"y","10":"y","11":"y","TP":"y"},"firefox":{"2":"p","3":"p","3.5":"y","3.6":"y","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"y","3.2":"y","4":"y","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"p","9.5-9.6":"p","10.0-10.1":"y","10.5":"y","10.6":"y","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"y","4.0-4.1":"y","4.2-4.3":"y","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"y"},"android":{"2.1":"y","2.2":"y","2.3":"y","3":"y","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"y","11":"y","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y"}},"notes":"","notes_by_num":{"1":"Partial support in IE8 is due to being limited to [CSS 2.1 selectors](/#feat=css-sel2). Additionally, it will have trouble with selectors including unrecognized tags (for example HTML5 ones)."},"usage_perc_y":92.72,"usage_perc_a":4.08,"ucprefix":false,"parent":"","keywords":"query,selectors,selectors api","ie_id":"","chrome_id":""},"getelementsbyclassname":{"title":"getElementsByClassName","description":"Method of accessing DOM elements by class name","spec":"http://www.w3.org/TR/dom/#dom-document-getelementsbyclassname","status":"wd","links":[{"url":"http://www.quirksmode.org/dom/tests/basics.html#getElementsByClassName","title":"Test page"},{"url":"http://docs.webplatform.org/wiki/dom/HTMLElement/getElementsByClassName","title":"WebPlatform Docs"}],"categories":["DOM","HTML5"],"stats":{"ie":{"5.5":"n","6":"p","7":"p","8":"p","9":"y","10":"y","11":"y","TP":"y"},"firefox":{"2":"p","3":"y","3.5":"y","3.6":"y","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"y","3.2":"y","4":"y","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"y","10.0-10.1":"y","10.5":"y","10.6":"y","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"y","4.0-4.1":"y","4.2-4.3":"y","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"y"},"android":{"2.1":"y","2.2":"y","2.3":"y","3":"y","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"y","11":"y","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y"}},"notes":"","notes_by_num":{},"usage_perc_y":92.76,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"byclassname","ie_id":"","chrome_id":""},"forms":{"title":"HTML5 form features","description":"Expanded form options, including things like date pickers, sliders, validation, placeholders and multiple file uploads. Previously known as \"Web forms 2.0\".","spec":"https://html.spec.whatwg.org/multipage/forms.html#forms","status":"ls","links":[{"url":"https://miketaylr.com/code/input-type-attr.html","title":"HTML5 inputs and attribute support page"},{"url":"https://github.com/westonruter/webforms2","title":"Cross-browser JS implementation (based on original spec)"}],"categories":["HTML5"],"stats":{"ie":{"5.5":"n","6":"p","7":"p","8":"p","9":"p","10":"a","11":"a","TP":"a"},"firefox":{"2":"p","3":"p","3.5":"p","3.6":"p","4":"a","5":"a","6":"a","7":"a","8":"a","9":"a","10":"a","11":"a","12":"a","13":"a","14":"a","15":"a","16":"a","17":"a","18":"a","19":"a","20":"a","21":"a","22":"a","23":"a","24":"a","25":"a","26":"a","27":"a","28":"a","29":"a","30":"a","31":"a","32":"a","33":"a","34":"a","35":"a","36":"a","37":"a","38":"a"},"chrome":{"4":"a","5":"a","6":"a","7":"a","8":"a","9":"a","10":"a","11":"a","12":"a","13":"a","14":"a","15":"a","16":"a","17":"a","18":"a","19":"a","20":"a","21":"a","22":"a","23":"a","24":"a","25":"a","26":"a","27":"a","28":"a","29":"a","30":"a","31":"a","32":"a","33":"a","34":"a","35":"a","36":"a","37":"a","38":"a","39":"a","40":"a","41":"a","42":"a","43":"a"},"safari":{"3.1":"p","3.2":"p","4":"a","5":"a","5.1":"a","6":"a","6.1":"a","7":"a","7.1":"a","8":"a"},"opera":{"9":"y","9.5-9.6":"y","10.0-10.1":"y","10.5":"y","10.6":"y","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"a","16":"a","17":"a","18":"a","19":"a","20":"a","21":"a","22":"a","23":"a","24":"a","25":"a","26":"a","27":"a","28":"a","29":"a"},"ios_saf":{"3.2":"n","4.0-4.1":"a","4.2-4.3":"a","5.0-5.1":"a","6.0-6.1":"a","7.0-7.1":"a","8":"a","8.1":"a"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"a","4.4.3-4.4.4":"a","37":"a"},"bb":{"7":"n","10":"a"},"op_mob":{"10":"y","11":"y","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"a"},"and_chr":{"40":"a"},"and_ff":{"33":"a"},"ie_mob":{"10":"a","11":"a"},"and_uc":{"9.9":"y"}},"notes":"","notes_by_num":{},"usage_perc_y":4.1,"usage_perc_a":80.33,"ucprefix":false,"parent":"","keywords":"input,datepicker","ie_id":"","chrome_id":""},"html5semantic":{"title":"New semantic elements","description":"HTML5 offers some new elements, primarily for semantic purposes. The elements include: section, article, aside, header, footer, nav, figure, figcaption, time, mark, main.","spec":"https://html.spec.whatwg.org/multipage/semantics.html#sections","status":"ls","links":[{"url":"https://blog.whatwg.org/supporting-new-elements-in-ie","title":"Workaround for IE"},{"url":"https://blog.whatwg.org/styling-ie-noscript","title":"Alternate workaround"},{"url":"http://oli.jp/2009/html5-structure3/","title":"Article on structural elements"},{"url":"https://raw.github.com/phiggins42/has.js/master/detect/dom.js#dom-html5-elements","title":"has.js test"}],"categories":["HTML5"],"stats":{"ie":{"5.5":"n","6":"p","7":"p","8":"p","9":"y #1","10":"y #1","11":"y #1","TP":"y #1"},"firefox":{"2":"n","3":"a #1","3.5":"a #1","3.6":"a #1","4":"y #1","5":"y #1","6":"y #1","7":"y #1","8":"y #1","9":"y #1","10":"y #1","11":"y #1","12":"y #1","13":"y #1","14":"y #1","15":"y #1","16":"y #1","17":"y #1","18":"y #1","19":"y #1","20":"y #1","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"a #1","5":"a #1","6":"y #1","7":"y #1","8":"y #1","9":"y #1","10":"y #1","11":"y #1","12":"y #1","13":"y #1","14":"y #1","15":"y #1","16":"y #1","17":"y #1","18":"y #1","19":"y #1","20":"y #1","21":"y #1","22":"y #1","23":"y #1","24":"y #1","25":"y #1","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"a #1","3.2":"a #1","4":"a #1","5":"y #1","5.1":"y #1","6":"y #1","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"a #1","9.5-9.6":"a #1","10.0-10.1":"a #1","10.5":"a #1","10.6":"a #1","11":"a #1","11.1":"y #1","11.5":"y #1","11.6":"y #1","12":"y #1","12.1":"y #1","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"a #1","4.0-4.1":"y #1","4.2-4.3":"y #1","5.0-5.1":"y #1","6.0-6.1":"y #1","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"a #1"},"android":{"2.1":"a #1","2.2":"y #1","2.3":"y #1","3":"y #1","4":"y #1","4.1":"y #1","4.2-4.3":"y #1","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y #1","10":"y #1"},"op_mob":{"10":"a #1","11":"y #1","11.1":"y #1","11.5":"y #1","12":"y #1","12.1":"y #1","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y #1","11":"y #1"},"and_uc":{"9.9":"y #1"}},"notes":"Partial support refers to missing the default styling. This is easily taken care of by using display:block for all new elements (except time and mark, these should be display:inline anyway). IE11 and older versions of other browsers do not support the <main> element.","notes_by_num":{"1":"Does not include support for the <main> element "},"usage_perc_y":89.4,"usage_perc_a":3.37,"ucprefix":false,"parent":"","keywords":"","ie_id":"","chrome_id":""},"offline-apps":{"title":"Offline web applications","description":"Method of defining web page files to be cached using a cache manifest file, allowing them to work offline on subsequent visits to the page","spec":"https://html.spec.whatwg.org/multipage/browsers.html#offline","status":"ls","links":[{"url":"http://www.sitepoint.com/offline-web-application-tutorial/","title":"Sitepoint tutorial"},{"url":"http://diveintohtml5.info/offline.html","title":"Dive Into HTML5 article"},{"url":"http://hacks.mozilla.org/2010/01/offline-web-applications/","title":"Mozilla Hacks article/demo"},{"url":"http://docs.webplatform.org/wiki/apis/appcache/ApplicationCache","title":"WebPlatform Docs"}],"categories":["HTML5"],"stats":{"ie":{"5.5":"n","6":"p","7":"p","8":"p","9":"n","10":"y","11":"y","TP":"y"},"firefox":{"2":"p","3":"a","3.5":"y","3.6":"y","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"p","3.2":"p","4":"y","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"p","10.5":"p","10.6":"y","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"y","4.0-4.1":"y","4.2-4.3":"y","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"y","2.2":"y","2.3":"y","3":"y","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"n","11":"y","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y"}},"notes":"","notes_by_num":{},"usage_perc_y":87.49,"usage_perc_a":0.03,"ucprefix":false,"parent":"","keywords":"appcache,app cache,application cache,online","ie_id":"applicationcache","chrome_id":"6192449487634432"},"webworkers":{"title":"Web Workers","description":"Method of running scripts in the background, isolated from the web page","spec":"http://www.w3.org/TR/workers/","status":"cr","links":[{"url":"https://developer.mozilla.org/En/Using_web_workers","title":"MDN article"},{"url":"http://nerget.com/rayjs-mt/rayjs.html","title":"Web Worker demo"},{"url":"http://code.google.com/p/ie-web-worker/","title":"Polyfill for IE (single threaded)"},{"url":"http://net.tutsplus.com/tutorials/javascript-ajax/getting-started-with-web-workers/","title":"Tutorial"}],"categories":["JS API"],"stats":{"ie":{"5.5":"n","6":"p","7":"p","8":"p","9":"p","10":"y","11":"y","TP":"y"},"firefox":{"2":"p","3":"p","3.5":"y","3.6":"y","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"p","3.2":"p","4":"y","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"p","10.5":"p","10.6":"y","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"y","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"p","11":"y","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y"}},"notes":"","notes_by_num":{},"usage_perc_y":84.6,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"","ie_id":"","chrome_id":""},"fontface":{"title":"@font-face Web fonts","description":"Method of displaying fonts downloaded from websites","spec":"http://www.w3.org/TR/css3-webfonts/","status":"cr","links":[{"url":"http://webfonts.info","title":"News and information site"},{"url":"http://en.wikipedia.org/wiki/Web_typography","title":"Wikipedia"},{"url":"http://www.css3files.com/font/","title":"Information page"},{"url":"http://docs.webplatform.org/wiki/css/atrules/@font-face","title":"WebPlatform Docs"}],"categories":["CSS3"],"stats":{"ie":{"5.5":"a","6":"a","7":"a","8":"a","9":"y","10":"y","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"y","3.6":"y","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"y","4":"y","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"y","10.5":"y","10.6":"y","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"a","4.0-4.1":"a","4.2-4.3":"y","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"a","2.3":"a","3":"a","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"a","10":"y"},"op_mob":{"10":"y","11":"y","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y"}},"notes":"Partial support before IE9 refers to only supporting EOT fonts. Safari for iOS 4.1 and below only supports SVG fonts.","notes_by_num":{},"usage_perc_y":89.4,"usage_perc_a":4.6,"ucprefix":false,"parent":"","keywords":"font face","ie_id":"","chrome_id":""},"eot":{"title":"EOT - Embedded OpenType fonts","description":"Type of font that can be derived from a regular font, allowing small files and legal use of high-quality fonts. Usage is restricted by the file being tied to the website","spec":"http://www.w3.org/Submission/EOT/","status":"unoff","links":[{"url":"http://en.wikipedia.org/wiki/Embedded_OpenType","title":"Wikipedia"},{"url":"http://www.microsoft.com/typography/web/embedding/default.aspx","title":"Example pages"}],"categories":["Other"],"stats":{"ie":{"5.5":"n","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"n","34":"n","35":"n","36":"n","37":"n","38":"n"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"n","34":"n","35":"n","36":"n","37":"n","38":"n","39":"n","40":"n","41":"n","42":"n","43":"n"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"n","7":"n","7.1":"n","8":"n"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"n","8.1":"n"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"n","4.4.3-4.4.4":"n","37":"n"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"n"},"and_chr":{"40":"n"},"and_ff":{"33":"n"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"n"}},"notes":"Proposal by Microsoft, being considered for W3C standardization.","notes_by_num":{},"usage_perc_y":16.45,"usage_perc_a":0,"ucprefix":false,"parent":"fontface","keywords":"","ie_id":"","chrome_id":""},"woff":{"title":"WOFF - Web Open Font Format","description":"Compressed TrueType/OpenType font that contains information about the font's source.","spec":"http://www.w3.org/TR/WOFF/","status":"rec","links":[{"url":"http://hacks.mozilla.org/2009/10/woff/","title":"Mozilla hacks blog post"}],"categories":["Other"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"y","10":"y","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"y","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"n","11":"y","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y"}},"notes":"Reported to be supported in some modified versions of the Android 4.0 browser.","notes_by_num":{},"usage_perc_y":86.49,"usage_perc_a":0,"ucprefix":false,"parent":"fontface","keywords":"","ie_id":"","chrome_id":""},"multibackgrounds":{"title":"CSS3 Multiple backgrounds","description":"Method of using multiple images as a background","spec":"http://www.w3.org/TR/css3-background/","status":"cr","links":[{"url":"http://www.css3.info/preview/multiple-backgrounds/","title":"Demo & information page"},{"url":"http://www.css3files.com/background/","title":"Information page"},{"url":"http://docs.webplatform.org/wiki/css/properties/background-image","title":"WebPlatform Docs"}],"categories":["CSS3"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"y","10":"y","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"y","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"y","3.2":"y","4":"y","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"y","10.6":"y","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"y","4.0-4.1":"y","4.2-4.3":"y","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"y"},"android":{"2.1":"y","2.2":"y","2.3":"y","3":"y","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"y","11":"y","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y"}},"notes":"","notes_by_num":{},"usage_perc_y":92.7,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"","ie_id":"","chrome_id":""},"border-image":{"title":"CSS3 Border images","description":"Method of using images for borders","spec":"http://www.w3.org/TR/css3-background/#the-border-image","status":"cr","links":[{"url":"http://www.css3files.com/border/","title":"Information page"},{"url":"http://docs.webplatform.org/wiki/css/properties/border-image","title":"WebPlatform Docs"}],"categories":["CSS3"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"a x","3.6":"a x","4":"a x","5":"a x","6":"a x","7":"a x","8":"a x","9":"a x","10":"a x","11":"a x","12":"a x","13":"a x","14":"a x","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"a x","5":"a x","6":"a x","7":"a x","8":"a x","9":"a x","10":"a x","11":"a x","12":"a x","13":"a x","14":"a x","15":"y x","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"a x","3.2":"a x","4":"a x","5":"a x","5.1":"a x","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"a","10.6":"a","11":"a x","11.1":"a x","11.5":"a x","11.6":"a x","12":"a x","12.1":"a x","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"a x","4.0-4.1":"a x","4.2-4.3":"a x","5.0-5.1":"a x","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"a x","2.2":"a x","2.3":"a x","3":"a x","4":"a x","4.1":"a x","4.2-4.3":"a x","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"a x","10":"y"},"op_mob":{"10":"n","11":"a x","11.1":"a x","11.5":"a x","12":"a x","12.1":"a x","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"n","11":"y"},"and_uc":{"9.9":"y"}},"notes":"Note that both the border-style and border-width must be specified for border-images to work according to spec, though older implementations may not have this requirement. Partial support refers to supporting the shorthand syntax, but not the individual properties (border-image-source, border-image-slice, etc). ","notes_by_num":{},"usage_perc_y":80.88,"usage_perc_a":4.66,"ucprefix":false,"parent":"","keywords":"","ie_id":"","chrome_id":""},"background-img-opts":{"title":"CSS3 Background-image options","description":"New properties to affect background images, including background-clip, background-origin and background-size","spec":"http://www.w3.org/TR/css3-background/#backgrounds","status":"cr","links":[{"url":"http://www.standardista.com/css3/css3-background-properties","title":"Detailed compatibility tables and demos"},{"url":"http://www.css3files.com/background/","title":"Information page"},{"url":"https://github.com/louisremi/background-size-polyfill","title":"Polyfill for IE7-8"}],"categories":["CSS3"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"y","10":"y","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"a x","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"a #3","5":"a #3","6":"a #3","7":"a #3","8":"a #3","9":"a #3","10":"a #3","11":"a #3","12":"a #3","13":"a #3","14":"a #3","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"a #2 #3","3.2":"a #2 #3","4":"a #2 #3","5":"a #2 #3","5.1":"a #2 #3","6":"a #2 #3","6.1":"a #2 #3","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"a x","10.5":"y","10.6":"y","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"a","4.0-4.1":"a","4.2-4.3":"a","5.0-5.1":"a #3","6.0-6.1":"a","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"a #1"},"android":{"2.1":"a x","2.2":"a x #3","2.3":"a x #3","3":"a #3","4":"a #3","4.1":"a #3","4.2-4.3":"a #3","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"y","11":"y","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y"}},"notes":"","notes_by_num":{"1":"Partial support in Opera Mini refers to not supporting background sizing or background attachments. However Opera Mini 7.5 supports background sizing (including cover and contain values).","2":"Partial support in Safari 6 refers to not supporting background sizing offset from edges syntax.","3":"Does not support `background-size` values in the `background` shorthand"},"usage_perc_y":85.13,"usage_perc_a":7.59,"ucprefix":false,"parent":"","keywords":"","ie_id":"","chrome_id":""},"css-table":{"title":"CSS Table display","description":"Method of displaying elements as tables, rows, and cells","spec":"http://www.w3.org/TR/CSS21/tables.html","status":"rec","links":[{"url":"http://www.onenaught.com/posts/201/use-css-displaytable-for-layout","title":"Blog post on usage"}],"categories":["CSS2"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"y","9":"y","10":"y","11":"y","TP":"y"},"firefox":{"2":"y","3":"y","3.5":"y","3.6":"y","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"y","3.2":"y","4":"y","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"y","9.5-9.6":"y","10.0-10.1":"y","10.5":"y","10.6":"y","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"y","4.0-4.1":"y","4.2-4.3":"y","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"y"},"android":{"2.1":"y","2.2":"y","2.3":"y","3":"y","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"y","11":"y","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y"}},"notes":"","notes_by_num":{},"usage_perc_y":96.85,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"display:table, display: table,table-cell,table-row,table-layout","ie_id":"","chrome_id":""},"css-gencontent":{"title":"CSS Generated content for pseudo-elements","description":"Method of displaying text or images before or after the given element's contents using the ::before and ::after pseudo-elements. All browsers with support also support the `attr()` notation in the `content` property. ","spec":"http://www.w3.org/TR/CSS21/generate.html","status":"rec","links":[{"url":"http://www.westciv.com/style_master/academy/css_tutorial/advanced/generated_content.html","title":"Guide on usage"},{"url":"https://dev.opera.com/articles/view/css-generated-content-techniques/","title":"Dev.Opera article"},{"url":"http://docs.webplatform.org/wiki/css/generated_and_replaced_content","title":"WebPlatform Docs"}],"categories":["CSS2","CSS3"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"a","9":"y","10":"y","11":"y","TP":"y"},"firefox":{"2":"y","3":"y","3.5":"y","3.6":"y","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"y","3.2":"y","4":"y","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"y","9.5-9.6":"y","10.0-10.1":"y","10.5":"y","10.6":"y","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"y","4.0-4.1":"y","4.2-4.3":"y","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"y"},"android":{"2.1":"y","2.2":"y","2.3":"y","3":"y","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"y","11":"y","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y"}},"notes":"IE8 only supports the single-colon CSS 2.1 syntax (i.e. :pseudo-class). It does not support the double-colon CSS3 syntax (i.e. ::pseudo-element)\r\n\r\nFor content to appear in pseudo-elements, the `content` property must be set (but may be an empty string).","notes_by_num":{},"usage_perc_y":92.77,"usage_perc_a":4.08,"ucprefix":false,"parent":"","keywords":"before,after","ie_id":"","chrome_id":""},"css-fixed":{"title":"CSS position:fixed","description":"Method of keeping an element in a fixed location regardless of scroll position","spec":"http://www.w3.org/TR/CSS21/visuren.html#fixed-positioning","status":"rec","links":[{"url":"http://www.css-101.org/fixed-positioning/05.php","title":"Workaround for IE6"},{"url":"http://bradfrostweb.com/blog/mobile/fixed-position/","title":"Article on mobile support"},{"url":"http://docs.webplatform.org/wiki/css/properties/position","title":"WebPlatform Docs"}],"categories":["CSS"],"stats":{"ie":{"5.5":"n","6":"p","7":"y","8":"y","9":"y","10":"y","11":"y","TP":"y"},"firefox":{"2":"y","3":"y","3.5":"y","3.6":"y","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"y","3.2":"y","4":"y","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"y","9.5-9.6":"y","10.0-10.1":"y","10.5":"y","10.6":"y","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"a","6.0-6.1":"a","7.0-7.1":"a","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"a","2.2":"a","2.3":"a","3":"y","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"y","11":"y","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y"}},"notes":"Only works in Android 2.2+ by using the following meta tag: <meta name=\"viewport\" content=\"width=device-width, user-scalable=no\">. \r\n\r\nPartial support in older iOS Safari refers to [buggy behavior](http://remysharp.com/2012/05/24/issues-with-position-fixed-scrolling-on-ios/).","notes_by_num":{},"usage_perc_y":91.35,"usage_perc_a":2.61,"ucprefix":false,"parent":"","keywords":"","ie_id":"","chrome_id":""},"hashchange":{"title":"Hashchange event","description":"Event triggered in JavaScript when the URL's hash has changed (for example: page.html#foo to page.html#bar) ","spec":"https://html.spec.whatwg.org/multipage/browsers.html#the-hashchangeevent-interface","status":"ls","links":[{"url":"https://developer.mozilla.org/en/DOM/window.onhashchange","title":"MDN article"},{"url":"http://msdn.microsoft.com/en-us/library/cc288209(VS.85).aspx","title":"MSDN article"},{"url":"http://www.quirksmode.org/dom/events/tests/hashchange.html","title":"Simple demo"},{"url":"http://github.com/3nr1c/jUri.js","title":"Polyfill"},{"url":"http://docs.webplatform.org/wiki/dom/Element/hashchange","title":"WebPlatform Docs"}],"categories":["HTML5","JS API"],"stats":{"ie":{"5.5":"p","6":"p","7":"p","8":"y","9":"y","10":"y","11":"y","TP":"y"},"firefox":{"2":"p","3":"p","3.5":"p","3.6":"y","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"p","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"p","3.2":"p","4":"p","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"p","9.5-9.6":"p","10.0-10.1":"p","10.5":"p","10.6":"y","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"y","4.2-4.3":"y","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"y","2.3":"y","3":"y","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"p","11":"y","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y"}},"notes":"","notes_by_num":{},"usage_perc_y":93.61,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"onhashchange,HashChangeEvent","ie_id":"","chrome_id":""},"css-sel2":{"title":"CSS 2.1 selectors","description":"Basic CSS selectors including: `*` (universal selector), `>` (child selector), `:first-child`, `:link`, `:visited`, `:active`, `:hover`, `:focus`, `:lang()`, `+` (adjacent sibling selector), `[attr]`, `[attr=\"val\"]`, `[attr~=\"val\"]`, `[attr|=\"bar\"]`, `.foo` (class selector), `#foo` (id selector)","spec":"http://www.w3.org/TR/CSS21/selector.html","status":"rec","links":[{"url":"http://www.quirksmode.org/css/contents.html","title":"Detailed support information"},{"url":"http://www.yourhtmlsource.com/stylesheets/advancedselectors.html","title":"Examples of advanced selectors"},{"url":"http://selectivizr.com","title":"Selectivizr: Polyfill for IE6-8"},{"url":"http://docs.webplatform.org/wiki/css/selectors","title":"WebPlatform Docs"}],"categories":["CSS2"],"stats":{"ie":{"5.5":"n","6":"p","7":"y","8":"y","9":"y","10":"y","11":"y","TP":"y"},"firefox":{"2":"y","3":"y","3.5":"y","3.6":"y","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"y","3.2":"y","4":"y","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"y","9.5-9.6":"y","10.0-10.1":"y","10.5":"y","10.6":"y","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"y","4.0-4.1":"y","4.2-4.3":"y","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"y"},"android":{"2.1":"y","2.2":"y","2.3":"y","3":"y","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"y","11":"y","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y"}},"notes":"","notes_by_num":{},"usage_perc_y":97.04,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"","ie_id":"","chrome_id":""},"css-sel3":{"title":"CSS3 selectors","description":"Advanced element selection using selectors including: `[foo^=\"bar\"]`, `[foo$=\"bar\"]`, `[foo*=\"bar\"]`, `:root`, `:nth-child()`,  `:nth-last-child()`, `nth-of-type`, `nth-last-of-type()`, `:last-child`, `:first-of-type`, `:last-of-type`, `:only-child`, `:only-of-type`, `:empty`, `:target`, `:enabled`, `:disabled`, `:checked`, `:not()`, `~` (general sibling)","spec":"http://www.w3.org/TR/css3-selectors/","status":"rec","links":[{"url":"http://www.quirksmode.org/css/selectors/","title":"Detailed support information"},{"url":"http://www.css3.info/selectors-test/","title":"Automated CSS3 selector test"},{"url":"http://selectivizr.com","title":"Selectivizr: Polyfill for IE6-8"},{"url":"http://docs.webplatform.org/wiki/css/selectors","title":"WebPlatform Docs"}],"categories":["CSS3"],"stats":{"ie":{"5.5":"n","6":"p","7":"a","8":"a","9":"y","10":"y","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"y","3.6":"y","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"y","4":"y","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"y","10.0-10.1":"y","10.5":"y","10.6":"y","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"y","4.0-4.1":"y","4.2-4.3":"y","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"y"},"android":{"2.1":"y","2.2":"y","2.3":"y","3":"y","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"y","11":"y","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y"}},"notes":"IE7 and IE8 support only these CSS3 selectors: General siblings (`element1~element2`) and Attribute selectors `[attr^=val]`, `[attr$=val]`, and `[attr*=val]`","notes_by_num":{},"usage_perc_y":92.73,"usage_perc_a":4.27,"ucprefix":false,"parent":"","keywords":"","ie_id":"","chrome_id":""},"css-textshadow":{"title":"CSS3 Text-shadow","description":"Method of applying one or more shadow or blur effects to text","spec":"http://www.w3.org/TR/css-text-decor-3/#text-shadow-property","status":"wd","links":[{"url":"http://hacks.mozilla.org/2009/06/text-shadow/","title":"Mozilla hacks article"},{"url":"http://ie.microsoft.com/testdrive/Graphics/hands-on-css3/hands-on_text-shadow.htm","title":"Live editor"},{"url":"http://www.css3files.com/shadow/#textshadow","title":"Information page"},{"url":"http://docs.webplatform.org/wiki/css/properties/text-shadow","title":"WebPlatform Docs"}],"categories":["CSS3"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"y #1","11":"y #1","TP":"y #1"},"firefox":{"2":"n","3":"n","3.5":"y","3.6":"y","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"a","3.2":"a","4":"y","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"y","10.0-10.1":"y","10.5":"y","10.6":"y","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"y","4.0-4.1":"y","4.2-4.3":"y","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"a"},"android":{"2.1":"y","2.2":"y","2.3":"y","3":"y","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"a","10":"y"},"op_mob":{"10":"y","11":"y","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y #1","11":"y #1"},"and_uc":{"9.9":"y"}},"notes":"Opera Mini ignores the blur-radius set, so no blur effect is visible. Text-shadow behavior can be somewhat emulated in older IE versions using the non-standard \"dropshadow\" or \"glow\" filters. ","notes_by_num":{"1":"IE 10+ supports a fourth length value for the shadow's \"spread\". This is not (yet) part of the specification. "},"usage_perc_y":87.42,"usage_perc_a":3.18,"ucprefix":false,"parent":"","keywords":"text shadow","ie_id":"","chrome_id":""},"css-boxshadow":{"title":"CSS3 Box-shadow","description":"Method of displaying an inner or outer shadow effect to elements","spec":"http://www.w3.org/TR/css3-background/#box-shadow","status":"cr","links":[{"url":"https://developer.mozilla.org/En/CSS/-moz-box-shadow","title":"MDN article"},{"url":"http://westciv.com/tools/boxshadows/index.html","title":"Live editor"},{"url":"http://tests.themasta.com/blogstuff/boxshadowdemo.html","title":"Demo of various effects"},{"url":"http://www.css3files.com/shadow/","title":"Information page"},{"url":"http://docs.webplatform.org/wiki/css/properties/box-shadow","title":"WebPlatform Docs"}],"categories":["CSS3"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"y","10":"y","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"y x","3.6":"y x","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"y x","5":"y x","6":"y x","7":"y x","8":"y x","9":"y x","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"a x","3.2":"a x","4":"a x","5":"y x","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"y","10.6":"y","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"a x","4.0-4.1":"y x","4.2-4.3":"y x","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"a x","2.2":"a x","2.3":"a x","3":"a x","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y x","10":"y"},"op_mob":{"10":"n","11":"y","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y"}},"notes":"Can be partially emulated in older IE versions using the non-standard \"shadow\" filter. Partial support in Safari, iOS Safari and Android Browser refers to missing \"inset\" and blur radius value support.","notes_by_num":{},"usage_perc_y":89.42,"usage_perc_a":0.22,"ucprefix":false,"parent":"","keywords":"box-shadows,boxshadows,box shadow,shaow","ie_id":"","chrome_id":""},"css3-colors":{"title":"CSS3 Colors","description":"Method of describing colors using Hue, Saturation and Lightness (hsl()) rather than just RGB, as well as allowing alpha-transparency with rgba() and hsla().","spec":"http://www.w3.org/TR/css3-color/","status":"rec","links":[{"url":"https://dev.opera.com/articles/view/color-in-opera-10-hsl-rgb-and-alpha-transparency/","title":"Dev.Opera article"},{"url":"http://www.css3files.com/color/","title":"Information page"},{"url":"http://docs.webplatform.org/wiki/css/color#RGBA_Notation","title":"WebPlatform Docs"}],"categories":["CSS3"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"y","10":"y","11":"y","TP":"y"},"firefox":{"2":"a","3":"y","3.5":"y","3.6":"y","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"y","3.2":"y","4":"y","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"a","10.0-10.1":"y","10.5":"y","10.6":"y","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"y","4.0-4.1":"y","4.2-4.3":"y","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"y"},"android":{"2.1":"y","2.2":"y","2.3":"y","3":"y","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"y","11":"y","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y"}},"notes":"","notes_by_num":{},"usage_perc_y":92.75,"usage_perc_a":0.01,"ucprefix":false,"parent":"","keywords":"rgb,hsl,rgba,hsla","ie_id":"","chrome_id":""},"css3-boxsizing":{"title":"CSS3 Box-sizing","description":"Method of specifying whether or not an element's borders and padding should be included in size units","spec":"http://www.w3.org/TR/css3-ui/#box-sizing","status":"wd","links":[{"url":"https://developer.mozilla.org/En/CSS/Box-sizing","title":"MDN article"},{"url":"http://www.456bereastreet.com/archive/201104/controlling_width_with_css3_box-sizing/","title":"Blog post"},{"url":"https://github.com/Schepp/box-sizing-polyfill","title":"Polyfill for IE"},{"url":"http://css-tricks.com/box-sizing/","title":"CSS Tricks"},{"url":"http://docs.webplatform.org/wiki/css/properties/box-sizing","title":"WebPlatform Docs"}],"categories":["CSS3"],"stats":{"ie":{"5.5":"p","6":"p","7":"p","8":"a","9":"a","10":"a","11":"a","TP":"a"},"firefox":{"2":"y x","3":"y x","3.5":"y x","3.6":"y x","4":"y x","5":"y x","6":"y x","7":"y x","8":"y x","9":"y x","10":"y x","11":"y x","12":"y x","13":"y x","14":"y x","15":"y x","16":"y x","17":"y x","18":"y x","19":"y x","20":"y x","21":"y x","22":"y x","23":"y x","24":"y x","25":"y x","26":"y x","27":"y x","28":"y x","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"a x","5":"a x","6":"a x","7":"a x","8":"a x","9":"a x","10":"a","11":"a","12":"a","13":"a","14":"a","15":"a","16":"a","17":"a","18":"a","19":"a","20":"a","21":"a","22":"a","23":"a","24":"a","25":"a","26":"a","27":"a","28":"a","29":"a","30":"a","31":"a","32":"a","33":"a","34":"a","35":"a","36":"a","37":"a","38":"a","39":"a","40":"a","41":"a","42":"a","43":"a"},"safari":{"3.1":"a x","3.2":"a x","4":"a x","5":"a x","5.1":"a","6":"a","6.1":"a","7":"a","7.1":"a","8":"a"},"opera":{"9":"n","9.5-9.6":"a","10.0-10.1":"a","10.5":"a","10.6":"a","11":"a","11.1":"a","11.5":"a","11.6":"a","12":"a","12.1":"a","15":"a","16":"a","17":"a","18":"a","19":"a","20":"a","21":"a","22":"a","23":"a","24":"a","25":"a","26":"a","27":"a","28":"a","29":"a"},"ios_saf":{"3.2":"a x","4.0-4.1":"a x","4.2-4.3":"a x","5.0-5.1":"a","6.0-6.1":"a","7.0-7.1":"a","8":"a","8.1":"a"},"op_mini":{"5.0-8.0":"a"},"android":{"2.1":"a x","2.2":"a x","2.3":"a x","3":"a x","4":"a","4.1":"a","4.2-4.3":"a","4.4":"a","4.4.3-4.4.4":"a","37":"a"},"bb":{"7":"a x","10":"a"},"op_mob":{"10":"a","11":"a","11.1":"a","11.5":"a","12":"a","12.1":"a","24":"a"},"and_chr":{"40":"a"},"and_ff":{"33":"y"},"ie_mob":{"10":"a","11":"a"},"and_uc":{"9.9":"a"}},"notes":"Partial support refers to supporting only the `content-box` and `border-box` values, not `padding-box` (which was added to the spec later).","notes_by_num":{},"usage_perc_y":12,"usage_perc_a":84.84,"ucprefix":false,"parent":"","keywords":"border-box,content-box,padding-box","ie_id":"","chrome_id":""},"css-mediaqueries":{"title":"CSS3 Media Queries","description":"Method of applying styles based on media information. Includes things like page and device dimensions","spec":"http://www.w3.org/TR/css3-mediaqueries/","status":"rec","links":[{"url":"http://ie.microsoft.com/testdrive/HTML5/85CSS3_MediaQueries/","title":"IE demo page with information"},{"url":"http://webdesignerwall.com/tutorials/responsive-design-with-css3-media-queries","title":"Media Queries tutorial"},{"url":"https://github.com/scottjehl/Respond","title":"Polyfill for IE"},{"url":"http://docs.webplatform.org/wiki/css/atrules/@media","title":"WebPlatform Docs"}],"categories":["CSS3"],"stats":{"ie":{"5.5":"p","6":"p","7":"p","8":"p","9":"y","10":"y","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"y","3.6":"y","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"a","3.2":"a","4":"y","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"y","10.0-10.1":"y","10.5":"y","10.6":"y","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"y","4.0-4.1":"y","4.2-4.3":"y","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"y"},"android":{"2.1":"y","2.2":"y","2.3":"y","3":"y","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"y","11":"y","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y"}},"notes":"Incomplete support by older webkit browsers refers to only acknowledging different media rules on page reload","notes_by_num":{},"usage_perc_y":92.72,"usage_perc_a":0.01,"ucprefix":false,"parent":"","keywords":"@media","ie_id":"","chrome_id":""},"multicolumn":{"title":"CSS3 Multiple column layout","description":"Method of flowing information in multiple columns","spec":"http://www.w3.org/TR/css3-multicol/","status":"cr","links":[{"url":"https://dev.opera.com/articles/view/css3-multi-column-layout/","title":"Dev.Opera article"},{"url":"http://webdesign.tutsplus.com/tutorials/htmlcss-tutorials/an-introduction-to-the-css3-multiple-column-layout-module/","title":"Introduction page"},{"url":"http://docs.webplatform.org/wiki/css/properties/column-width","title":"WebPlatform Docs"},{"url":"https://github.com/BetleyWhitehorne/CSS3MultiColumn","title":"Polyfill"}],"categories":["CSS3"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"y","11":"y","TP":"y"},"firefox":{"2":"a x","3":"a x","3.5":"a x","3.6":"a x","4":"a x","5":"a x","6":"a x","7":"a x","8":"a x","9":"a x","10":"a x","11":"a x","12":"a x","13":"a x","14":"a x","15":"a x","16":"a x","17":"a x","18":"a x","19":"a x","20":"a x","21":"a x","22":"a x","23":"a x","24":"a x","25":"a x","26":"a x","27":"a x","28":"a x","29":"a x","30":"a x","31":"a x","32":"a x","33":"a x","34":"a x","35":"a x","36":"a x","37":"a x","38":"a x"},"chrome":{"4":"a x","5":"a x","6":"a x","7":"a x","8":"a x","9":"a x","10":"a x","11":"a x","12":"a x","13":"a x","14":"a x","15":"a x","16":"a x","17":"a x","18":"a x","19":"a x","20":"a x","21":"a x","22":"a x","23":"a x","24":"a x","25":"a x","26":"a x","27":"a x","28":"a x","29":"a x","30":"a x","31":"a x","32":"a x","33":"a x","34":"a x","35":"a x","36":"a x","37":"a x","38":"a x","39":"a x","40":"a x","41":"a x","42":"a x","43":"a x"},"safari":{"3.1":"a x","3.2":"a x","4":"a x","5":"a x","5.1":"a x","6":"a x","6.1":"a x","7":"a x","7.1":"a x","8":"a x"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"a x","16":"a x","17":"a x","18":"a x","19":"a x","20":"a x","21":"a x","22":"a x","23":"a x","24":"a x","25":"a x","26":"a x","27":"a x","28":"a x","29":"a x"},"ios_saf":{"3.2":"a x","4.0-4.1":"a x","4.2-4.3":"a x","5.0-5.1":"a x","6.0-6.1":"a x","7.0-7.1":"a x","8":"a x","8.1":"a x"},"op_mini":{"5.0-8.0":"y"},"android":{"2.1":"a x","2.2":"a x","2.3":"a x","3":"a x","4":"a x","4.1":"a x","4.2-4.3":"a x","4.4":"a x","4.4.3-4.4.4":"a x","37":"a x"},"bb":{"7":"a x","10":"a x"},"op_mob":{"10":"n","11":"n","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"a x"},"and_chr":{"40":"a x"},"and_ff":{"33":"a x"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"a x"}},"notes":"Partial support refers to not supporting the `break-before`, `break-after`, `break-inside` properties. Webkit browsers do have equivalent support for the non-standard `-webkit-column-break-*` properties while Firefox supports `page-break-*` to accomplish the same result.","notes_by_num":{},"usage_perc_y":14.04,"usage_perc_a":76.54,"ucprefix":false,"parent":"","keywords":"column-count","ie_id":"multicolumnfullsupport","chrome_id":"6526151266664448"},"border-radius":{"title":"CSS3 Border-radius (rounded corners)","description":"Method of making the border corners round","spec":"http://www.w3.org/TR/css3-background/#the-border-radius","status":"cr","links":[{"url":"http://border-radius.com","title":"Border-radius CSS Generator"},{"url":"http://muddledramblings.com/table-of-css3-border-radius-compliance","title":"Detailed compliance table"},{"url":"http://www.css3files.com/border/#borderradius","title":"Information page"},{"url":"http://css3pie.com/","title":"Polyfill which includes border-radius"},{"url":"http://docs.webplatform.org/wiki/css/properties/border-radius","title":"WebPlatform Docs"}],"categories":["CSS3"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"y","10":"y","11":"y","TP":"y"},"firefox":{"2":"a x","3":"y x","3.5":"y x","3.6":"y x","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"y x","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"y x","3.2":"y x","4":"y x","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"y","10.6":"y","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"y x","4.0-4.1":"y","4.2-4.3":"y","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"y x","2.2":"y","2.3":"y","3":"y","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"n","11":"y","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y"}},"notes":"","notes_by_num":{},"usage_perc_y":89.66,"usage_perc_a":0.01,"ucprefix":false,"parent":"","keywords":"roundedcorners, border radius,-moz-border-radius","ie_id":"","chrome_id":""},"transforms2d":{"title":"CSS3 Transforms","description":"Method of transforming an element including rotating, scaling, etc.","spec":"http://www.w3.org/TR/css3-2d-transforms/","status":"wd","links":[{"url":"http://www.westciv.com/tools/transforms/","title":"Live editor"},{"url":"https://developer.mozilla.org/en/CSS/-moz-transform","title":"MDN article"},{"url":"http://www.webresourcesdepot.com/cross-browser-css-transforms-csssandpaper/","title":"Workaround script for IE"},{"url":"http://www.css3files.com/transform/","title":"Information page"},{"url":"http://www.useragentman.com/IETransformsTranslator/","title":"Converter for IE"},{"url":"https://raw.github.com/phiggins42/has.js/master/detect/css.js#css-transform","title":"has.js test"},{"url":"http://docs.webplatform.org/wiki/css/transforms/transform","title":"WebPlatform Docs"}],"categories":["CSS3"],"stats":{"ie":{"5.5":"n","6":"p","7":"p","8":"p","9":"y x","10":"y","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"y x","3.6":"y x","4":"y x","5":"y x","6":"y x","7":"y x","8":"y x","9":"y x","10":"y x","11":"y x","12":"y x","13":"y x","14":"y x","15":"y x","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"y x","5":"y x","6":"y x","7":"y x","8":"y x","9":"y x","10":"y x","11":"y x","12":"y x","13":"y x","14":"y x","15":"y x","16":"y x","17":"y x","18":"y x","19":"y x","20":"y x","21":"y x","22":"y x","23":"y x","24":"y x","25":"y x","26":"y x","27":"y x","28":"y x","29":"y x","30":"y x","31":"y x","32":"y x","33":"y x","34":"y x","35":"y x","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"y x","3.2":"y x","4":"y x","5":"y x","5.1":"y x","6":"y x","6.1":"y x","7":"y x","7.1":"y x","8":"y x"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"y x","10.6":"y x","11":"y x","11.1":"y x","11.5":"y x","11.6":"y x","12":"y x","12.1":"y","15":"y x","16":"y x","17":"y x","18":"y x","19":"y x","20":"y x","21":"y x","22":"y x","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"y x","4.0-4.1":"y x","4.2-4.3":"y x","5.0-5.1":"y x","6.0-6.1":"y x","7.0-7.1":"y x","8":"y x","8.1":"y x"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"y x","2.2":"y x","2.3":"y x","3":"y x","4":"y x","4.1":"y x","4.2-4.3":"y x","4.4":"y x","4.4.3-4.4.4":"y x","37":"y"},"bb":{"7":"y x","10":"y x"},"op_mob":{"10":"n","11":"y","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y x"}},"notes":"The scale transform can be emulated in IE < 9 using Microsoft's \"zoom\" extension, others are (not easily) possible using the MS Matrix filter","notes_by_num":{},"usage_perc_y":89.64,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"transformation,translate,rotation,rotate,scale,css-transforms","ie_id":"transforms","chrome_id":"6437640580628480"},"use-strict":{"title":"ECMAScript 5 Strict Mode","description":"Method of placing code in a \"strict\" operating context.","spec":"http://ecma-international.org/ecma-262/5.1/#sec-14.1","status":"other","links":[{"url":"http://ejohn.org/blog/ecmascript-5-strict-mode-json-and-more/","title":"Information page"},{"url":"http://javascriptweblog.wordpress.com/2011/05/03/javascript-strict-mode/","title":"Article with test suite"}],"categories":["Other"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"y","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"a","5.1":"a","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"y","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y"}},"notes":"Partial support in older Safari refers to strict mode still accepting a lot of JS that should be considered invalid.","notes_by_num":{},"usage_perc_y":86.35,"usage_perc_a":0.53,"ucprefix":false,"parent":"","keywords":"","ie_id":"","chrome_id":""},"transforms3d":{"title":"CSS3 3D Transforms","description":"Method of transforming an element in the third dimension using the `transform` property. Includes support for the `perspective` property to set the perspective in z-space and the `backface-visibility` property to toggle display of the reverse side of a 3D-transformed element.","spec":"http://www.w3.org/TR/css3-3d-transforms/","status":"wd","links":[{"url":"http://css3.bradshawenterprises.com/flip/","title":"Multi-browser demo"},{"url":"http://hacks.mozilla.org/2011/10/css-3d-transformations-in-firefox-nightly/","title":"Mozilla hacks article"},{"url":"http://thewebrocks.com/demos/3D-css-tester/","title":"3D CSS Tester"},{"url":"https://raw.github.com/phiggins42/has.js/master/detect/css.js#css-transform","title":"has.js test"},{"url":"http://docs.webplatform.org/wiki/css/transforms/transform","title":"WebPlatform Docs"},{"url":"http://desandro.github.io/3dtransforms/","title":"Intro to CSS 3D transforms"}],"categories":["CSS3"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"a","11":"a","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"y x","11":"y x","12":"y x","13":"y x","14":"y x","15":"y x","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"y x","13":"y x","14":"y x","15":"y x","16":"y x","17":"y x","18":"y x","19":"y x","20":"y x","21":"y x","22":"y x","23":"y x","24":"y x","25":"y x","26":"y x","27":"y x","28":"y x","29":"y x","30":"y x","31":"y x","32":"y x","33":"y x","34":"y x","35":"y x","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"y x","5":"y x","5.1":"y x","6":"y x","6.1":"y x","7":"y x","7.1":"y x","8":"y x"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"y x","16":"y x","17":"y x","18":"y x","19":"y x","20":"y x","21":"y x","22":"y x","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"y x","4.0-4.1":"y x","4.2-4.3":"y x","5.0-5.1":"y x","6.0-6.1":"y x","7.0-7.1":"y x","8":"y x","8.1":"y x"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"y x","4":"y x","4.1":"y x","4.2-4.3":"y x","4.4":"y x","4.4.3-4.4.4":"y x","37":"y"},"bb":{"7":"y x","10":"y x"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"a","11":"a"},"and_uc":{"9.9":"y x"}},"notes":"Partial support in IE refers to not supporting [the transform-style: preserve-3d property](http://msdn.microsoft.com/en-us/library/ie/hh673529%28v=vs.85%29.aspx#the_ms_transform_style_property). This prevents nesting 3D transformed elements.","notes_by_num":{},"usage_perc_y":75.88,"usage_perc_a":10.71,"ucprefix":false,"parent":"","keywords":"css 3d,3dtransforms,translate3d,backface visibility,perspective","ie_id":"transforms,csstransformspreserve3d","chrome_id":"6437640580628480"},"sharedworkers":{"title":"Shared Web Workers","description":"Method of allowing multiple scripts to communicate with a single web worker.","spec":"https://html.spec.whatwg.org/multipage/workers.html#shared-workers-introduction","status":"cr","links":[{"url":"http://www.sitepoint.com/javascript-shared-web-workers-html5/","title":"Sitepoint article"},{"url":"http://greenido.wordpress.com/2011/11/03/web-workers-part-3-out-of-3-shared-wrokers/","title":"Blog post"}],"categories":["JS API"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"y","5.1":"y","6":"y","6.1":"n","7":"n","7.1":"n","8":"n"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"y","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"n","8":"n","8.1":"n"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"n","4.4.3-4.4.4":"n","37":"n"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"u","11":"y","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"n"},"and_chr":{"40":"n"},"and_ff":{"33":"y"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"y"}},"notes":"","notes_by_num":{},"usage_perc_y":48.93,"usage_perc_a":0,"ucprefix":false,"parent":"webworkers","keywords":"shared worker","ie_id":"","chrome_id":""},"css-hyphens":{"title":"CSS Hyphenation","description":"Method of controlling when words at the end of lines should be hyphenated using the \"hyphens\" property.","spec":"http://www.w3.org/TR/css3-text/#hyphenation","status":"wd","links":[{"url":"https://developer.mozilla.org/en/CSS/hyphens","title":"MDN article"},{"url":"http://blog.fontdeck.com/post/9037028497/hyphens","title":"Blog post"},{"url":"http://docs.webplatform.org/wiki/css/properties/hyphens","title":"WebPlatform Docs"}],"categories":["CSS3"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"y x","11":"y x","TP":"y x"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"y x","7":"y x","8":"y x","9":"y x","10":"y x","11":"y x","12":"y x","13":"y x","14":"y x","15":"y x","16":"y x","17":"y x","18":"y x","19":"y x","20":"y x","21":"y x","22":"y x","23":"y x","24":"y x","25":"y x","26":"y x","27":"y x","28":"y x","29":"y x","30":"y x","31":"y x","32":"y x","33":"y x","34":"y x","35":"y x","36":"y x","37":"y x","38":"y x"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"n","34":"n","35":"n","36":"n","37":"n","38":"n","39":"n","40":"n","41":"n","42":"n","43":"n"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"y x","6":"y x","6.1":"y x","7":"y x","7.1":"y x","8":"y x"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"y x","5.0-5.1":"y x","6.0-6.1":"y x","7.0-7.1":"y x","8":"y x","8.1":"y x"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"n","4.4.3-4.4.4":"n","37":"n"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"n"},"and_chr":{"40":"n"},"and_ff":{"33":"y x"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"a x"}},"notes":"Chrome 29- and Android 4.0 Browser support \"-webkit-hyphens: none\", but not the \"auto\" property. Chrome 30+ doesn't support it either.","notes_by_num":{},"usage_perc_y":32.28,"usage_perc_a":3.78,"ucprefix":false,"parent":"","keywords":"hyphen,shy","ie_id":"","chrome_id":""},"css-transitions":{"title":"CSS3 Transitions","description":"Simple method of animating certain properties of an element","spec":"http://www.w3.org/TR/css3-transitions/","status":"wd","links":[{"url":"http://www.webdesignerdepot.com/2010/01/css-transitions-101/","title":"Article on usage"},{"url":"http://www.css3files.com/transition/","title":"Information page"},{"url":"http://www.the-art-of-web.com/css/timing-function/","title":"Examples on timing functions"},{"url":"http://www.opera.com/docs/specs/presto2.12/css/transitions/","title":"Animation of property types support in Opera"},{"url":"http://docs.webplatform.org/wiki/css/properties/transition","title":"WebPlatform Docs"}],"categories":["CSS3"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"y","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"y x","5":"y x","6":"y x","7":"y x","8":"y x","9":"y x","10":"y x","11":"y x","12":"y x","13":"y x","14":"y x","15":"y x","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"y x","5":"y x","6":"y x","7":"y x","8":"y x","9":"y x","10":"y x","11":"y x","12":"y x","13":"y x","14":"y x","15":"y x","16":"y x","17":"y x","18":"y x","19":"y x","20":"y x","21":"y x","22":"y x","23":"y x","24":"y x","25":"y x","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"y x","3.2":"y x","4":"y x","5":"y x","5.1":"y x","6":"y x","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"y x","10.6":"y x","11":"y x","11.1":"y x","11.5":"y x","11.6":"y x","12":"y x","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"y x","4.0-4.1":"y x","4.2-4.3":"y x","5.0-5.1":"y x","6.0-6.1":"y x","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"y x","2.2":"y x","2.3":"y x","3":"y x","4":"y x","4.1":"y x","4.2-4.3":"y x","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y x","10":"y x"},"op_mob":{"10":"y x","11":"y x","11.1":"y x","11.5":"y x","12":"y x","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y x"}},"notes":"","notes_by_num":{},"usage_perc_y":87.4,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"css transition","ie_id":"","chrome_id":""},"font-feature":{"title":"Font feature settings","description":"Method of applying advanced typographic and language-specific font features to supported OpenType fonts.","spec":"http://w3.org/TR/css3-fonts/#font-rend-props","status":"wd","links":[{"url":"http://ie.microsoft.com/testdrive/Graphics/opentype/","title":"Demo pages (IE/Firefox only)"},{"url":"http://hacks.mozilla.org/2010/11/firefox-4-font-feature-support/","title":"Mozilla hacks article"},{"url":"http://html5accessibility.com/","title":"Detailed tables on accessability support"},{"url":"http://docs.webplatform.org/wiki/css/properties/font-feature-settings","title":"WebPlatform Docs"}],"categories":["CSS3"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"y","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"a x","5":"a x","6":"a x","7":"a x","8":"a x","9":"a x","10":"a x","11":"a x","12":"a x","13":"a x","14":"a x","15":"y x","16":"y x","17":"y x","18":"y x","19":"y x","20":"y x","21":"y x","22":"y x","23":"y x","24":"y x","25":"y x","26":"y x","27":"y x","28":"y x","29":"y x","30":"y x","31":"y x","32":"y x","33":"y x","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"a x","17":"a x","18":"a x","19":"a x","20":"a x","21":"y x","22":"y x","23":"y x","24":"y x","25":"y x","26":"y x","27":"y x","28":"y x","29":"y x","30":"y x","31":"y x","32":"y x","33":"y x","34":"y x","35":"y x","36":"y x","37":"y x","38":"y x","39":"y x","40":"y x","41":"y x","42":"y x","43":"y x"},"safari":{"3.1":"n","3.2":"n","4":"a","5":"a","5.1":"a","6":"a","6.1":"n","7":"n","7.1":"n","8":"n"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"y x","16":"y x","17":"y x","18":"y x","19":"y x","20":"y x","21":"y x","22":"y x","23":"y x","24":"y x","25":"y x","26":"y x","27":"y x","28":"y x","29":"y x"},"ios_saf":{"3.2":"a","4.0-4.1":"a","4.2-4.3":"a","5.0-5.1":"a","6.0-6.1":"a","7.0-7.1":"n","8":"n","8.1":"n"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"y x","4.4.3-4.4.4":"y x","37":"y x"},"bb":{"7":"n","10":"y x"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"y x"},"and_chr":{"40":"y x"},"and_ff":{"33":"y x"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"y x"}},"notes":"Partial support in older Firefox versions refers to using an older syntax. Partial support in older Chrome versions refers to lacking support in Mac OS X. ","notes_by_num":{},"usage_perc_y":71.96,"usage_perc_a":1.34,"ucprefix":false,"parent":"","keywords":"font-feature,font-feature-settings,kern,kerning,font-variant-alternates,ligatures,font-variant-ligatures","ie_id":"","chrome_id":""},"css-animation":{"title":"CSS3 Animation","description":"Complex method of animating certain properties of an element","spec":"http://www.w3.org/TR/css3-animations/","status":"wd","links":[{"url":"http://robertnyman.com/2010/05/06/css3-animations/","title":"Blog post on usage"},{"url":"http://www.css3files.com/animation/","title":"Information page"},{"url":"http://docs.webplatform.org/wiki/css/properties/animations","title":"WebPlatform Docs"}],"categories":["CSS3"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"y","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"y x","6":"y x","7":"y x","8":"y x","9":"y x","10":"y x","11":"y x","12":"y x","13":"y x","14":"y x","15":"y x","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"y x","5":"y x","6":"y x","7":"y x","8":"y x","9":"y x","10":"y x","11":"y x","12":"y x","13":"y x","14":"y x","15":"y x","16":"y x","17":"y x","18":"y x","19":"y x","20":"y x","21":"y x","22":"y x","23":"y x","24":"y x","25":"y x","26":"y x","27":"y x","28":"y x","29":"y x","30":"y x","31":"y x","32":"y x","33":"y x","34":"y x","35":"y x","36":"y x","37":"y x","38":"y x","39":"y x","40":"y x","41":"y x","42":"y x","43":"y x"},"safari":{"3.1":"n","3.2":"n","4":"y x","5":"y x","5.1":"y x","6":"y x","6.1":"y x","7":"y x","7.1":"y x","8":"y x"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"y x","12.1":"y","15":"y x","16":"y x","17":"y x","18":"y x","19":"y x","20":"y x","21":"y x","22":"y x","23":"y x","24":"y x","25":"y x","26":"y x","27":"y x","28":"y x","29":"y x"},"ios_saf":{"3.2":"y x","4.0-4.1":"y x","4.2-4.3":"y x","5.0-5.1":"y x","6.0-6.1":"y x","7.0-7.1":"y x","8":"y x","8.1":"y x"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"a x","2.2":"a x","2.3":"a x","3":"a x","4":"y x","4.1":"y x","4.2-4.3":"y x","4.4":"y x","4.4.3-4.4.4":"y x","37":"y x"},"bb":{"7":"y x","10":"y x"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"y","24":"y x"},"and_chr":{"40":"y x"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y x"}},"notes":"Partial support in Android browser refers to buggy behavior in different scenarios.","notes_by_num":{},"usage_perc_y":87.15,"usage_perc_a":0.15,"ucprefix":false,"parent":"","keywords":"animations,css-animations,keyframe,keyframes","ie_id":"","chrome_id":""},"css-gradients":{"title":"CSS Gradients","description":"Method of defining a linear or radial color gradient as a CSS image.","spec":"http://www.w3.org/TR/css3-images/","status":"cr","links":[{"url":"http://www.colorzilla.com/gradient-editor/","title":"Cross-browser editor"},{"url":"http://www.css3files.com/gradient/","title":"Information page"},{"url":"http://css3pie.com/","title":"Tool to emulate support in IE"},{"url":"http://docs.webplatform.org/wiki/css/functions/linear-gradient","title":"WebPlatform Docs"}],"categories":["CSS3"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"y","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"y x","4":"y x","5":"y x","6":"y x","7":"y x","8":"y x","9":"y x","10":"y x","11":"y x","12":"y x","13":"y x","14":"y x","15":"y x","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"a x","5":"a x","6":"a x","7":"a x","8":"a x","9":"a x","10":"y x","11":"y x","12":"y x","13":"y x","14":"y x","15":"y x","16":"y x","17":"y x","18":"y x","19":"y x","20":"y x","21":"y x","22":"y x","23":"y x","24":"y x","25":"y x","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"a x","5":"a x","5.1":"y x","6":"y x","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"a x","11.5":"a x","11.6":"y x","12":"y x","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"a x","4.0-4.1":"a x","4.2-4.3":"a x","5.0-5.1":"y x","6.0-6.1":"y x","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"a x","2.2":"a x","2.3":"a x","3":"a x","4":"y x","4.1":"y x","4.2-4.3":"y x","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"a x","10":"y x"},"op_mob":{"10":"n","11":"n","11.1":"a x","11.5":"a x","12":"y x","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y x"}},"notes":"Syntax used by browsers with prefixed support may be incompatible with that for proper support. \r\n\r\nPartial support in Opera 11.10 and 11.50 also refers to only having support for linear gradients.\r\n\r\nSupport can be somewhat emulated in older IE versions using the non-standard \"gradient\" filter. \r\n\r\nFirefox 10+, Opera 11.6+, Chrome 26+ and IE10+ also support the new \"to (side)\" syntax.","notes_by_num":{},"usage_perc_y":86.91,"usage_perc_a":0.54,"ucprefix":false,"parent":"","keywords":"linear,linear-gradient,gradiant","ie_id":"gradients","chrome_id":"5785905063264256"},"css-canvas":{"title":"CSS Canvas Drawings","description":"Method of using HTML5 Canvas as a background image. Not currently part of any specification.","spec":"http://webkit.org/blog/176/css-canvas-drawing/","status":"unoff","links":[{"url":"http://webkit.org/blog/176/css-canvas-drawing/","title":"Webkit blog post"}],"categories":["CSS"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"n","34":"n","35":"n","36":"u","37":"u","38":"u"},"chrome":{"4":"y x","5":"y x","6":"y x","7":"y x","8":"y x","9":"y x","10":"y x","11":"y x","12":"y x","13":"y x","14":"y x","15":"y x","16":"y x","17":"y x","18":"y x","19":"y x","20":"y x","21":"y x","22":"y x","23":"y x","24":"y x","25":"y x","26":"y x","27":"y x","28":"y x","29":"y x","30":"y x","31":"y x","32":"y x","33":"y x","34":"y x","35":"y x","36":"y x","37":"y x","38":"y x","39":"y x","40":"y x","41":"y x","42":"y x","43":"y x"},"safari":{"3.1":"n","3.2":"n","4":"y x","5":"y x","5.1":"y x","6":"y x","6.1":"y x","7":"y x","7.1":"y x","8":"y x"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"y x","16":"y x","17":"y x","18":"y x","19":"y x","20":"y x","21":"y x","22":"y x","23":"y x","24":"y x","25":"y x","26":"y x","27":"y x","28":"y x","29":"y x"},"ios_saf":{"3.2":"y x","4.0-4.1":"y x","4.2-4.3":"y x","5.0-5.1":"y x","6.0-6.1":"y x","7.0-7.1":"y x","8":"y x","8.1":"y x"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"y x","2.2":"y x","2.3":"y x","3":"y x","4":"y x","4.1":"y x","4.2-4.3":"y x","4.4":"y x","4.4.3-4.4.4":"y x","37":"y x"},"bb":{"7":"y x","10":"y x"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"y x"},"and_chr":{"40":"y x"},"and_ff":{"33":"n"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"y x"}},"notes":"A similar effect can be achieved in Firefox 4+ using the -moz-element() background property","notes_by_num":{},"usage_perc_y":64.52,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"","ie_id":"","chrome_id":""},"css-reflections":{"title":"CSS Reflections","description":"Method of displaying a reflection of an element","spec":"http://webkit.org/blog/182/css-reflections/","status":"unoff","links":[{"url":"http://webkit.org/blog/182/css-reflections/","title":"Webkit blog post"}],"categories":["CSS"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"n","34":"n","35":"n","36":"n","37":"n","38":"n"},"chrome":{"4":"y x","5":"y x","6":"y x","7":"y x","8":"y x","9":"y x","10":"y x","11":"y x","12":"y x","13":"y x","14":"y x","15":"y x","16":"y x","17":"y x","18":"y x","19":"y x","20":"y x","21":"y x","22":"y x","23":"y x","24":"y x","25":"y x","26":"y x","27":"y x","28":"y x","29":"y x","30":"y x","31":"y x","32":"y x","33":"y x","34":"y x","35":"y x","36":"y x","37":"y x","38":"y x","39":"y x","40":"y x","41":"y x","42":"y x","43":"y x"},"safari":{"3.1":"n","3.2":"n","4":"y x","5":"y x","5.1":"y x","6":"y x","6.1":"y x","7":"y x","7.1":"y x","8":"y x"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"y x","16":"y x","17":"y x","18":"y x","19":"y x","20":"y x","21":"y x","22":"y x","23":"y x","24":"y x","25":"y x","26":"y x","27":"y x","28":"y x","29":"y x"},"ios_saf":{"3.2":"y x","4.0-4.1":"y x","4.2-4.3":"y x","5.0-5.1":"y x","6.0-6.1":"y x","7.0-7.1":"y x","8":"y x","8.1":"y x"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"y x","2.2":"y x","2.3":"y x","3":"y x","4":"y x","4.1":"y x","4.2-4.3":"y x","4.4":"y x","4.4.3-4.4.4":"y x","37":"y x"},"bb":{"7":"y x","10":"y x"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"y x"},"and_chr":{"40":"y x"},"and_ff":{"33":"n"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"n"}},"notes":"Similar effect can be achieved in Firefox 4+ using the -moz-element() background property","notes_by_num":{},"usage_perc_y":60.75,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"box-reflect","ie_id":"","chrome_id":"5627300510957568"},"css-masks":{"title":"CSS Masks","description":"Method of displaying part of an element, using a selected image as a mask","spec":"http://www.w3.org/TR/css-masking/","status":"cr","links":[{"url":"http://docs.webplatform.org/wiki/css/properties/mask","title":"WebPlatform Docs"},{"url":"http://www.html5rocks.com/en/tutorials/masking/adobe/","title":"HTML5 Rocks article"},{"url":"http://thenittygritty.co/css-masking","title":"Detailed blog post"}],"categories":["CSS"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"n","3.5":"a","3.6":"a","4":"a","5":"a","6":"a","7":"a","8":"a","9":"a","10":"a","11":"a","12":"a","13":"a","14":"a","15":"a","16":"a","17":"a","18":"a","19":"a","20":"a","21":"a","22":"a","23":"a","24":"a","25":"a","26":"a","27":"a","28":"a","29":"a","30":"a","31":"a","32":"a","33":"a","34":"a","35":"a","36":"a","37":"a","38":"a"},"chrome":{"4":"a x","5":"a x","6":"a x","7":"a x","8":"a x","9":"a x","10":"a x","11":"a x","12":"a x","13":"a x","14":"a x","15":"a x","16":"a x","17":"a x","18":"a x","19":"a x","20":"a x","21":"a x","22":"a x","23":"a x","24":"a x","25":"a x","26":"a x","27":"a x","28":"a x","29":"a x","30":"a x","31":"a x","32":"a x","33":"a x","34":"a x","35":"a x","36":"a x","37":"a x","38":"a x","39":"a x","40":"a x","41":"a x","42":"a x","43":"a x"},"safari":{"3.1":"n","3.2":"n","4":"a x","5":"a x","5.1":"a x","6":"a x","6.1":"a x","7":"a x","7.1":"a x","8":"a x"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"a x","16":"a x","17":"a x","18":"a x","19":"a x","20":"a x","21":"a x","22":"a x","23":"a x","24":"a x","25":"a x","26":"a x","27":"a x","28":"a x","29":"a x"},"ios_saf":{"3.2":"a x","4.0-4.1":"a x","4.2-4.3":"a x","5.0-5.1":"a x","6.0-6.1":"a x","7.0-7.1":"a x","8":"a x","8.1":"a x"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"a x","2.2":"a x","2.3":"a x","3":"a x","4":"a x","4.1":"a x","4.2-4.3":"a x","4.4":"a x","4.4.3-4.4.4":"a x","37":"a x"},"bb":{"7":"a x","10":"a x"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"a x"},"and_chr":{"40":"a x"},"and_ff":{"33":"a"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"a x"}},"notes":"Partial support in WebKit/Blink browsers refers to supporting the mask-image and mask-box-image properties, but lacks support for other parts of the spec. Partial support in Firefox refers to only support for inline SVG mask elements i.e. mask: url(#foo).","notes_by_num":{},"usage_perc_y":0,"usage_perc_a":76.49,"ucprefix":false,"parent":"","keywords":"","ie_id":"masks","chrome_id":"5381559662149632"},"svg":{"title":"SVG (basic support)","description":"Method of displaying basic Vector Graphics features using the embed or object elements. Refers to the SVG 1.1 spec.","spec":"http://www.w3.org/TR/SVG/","status":"rec","links":[{"url":"http://en.wikipedia.org/wiki/Scalable_Vector_Graphics","title":"Wikipedia"},{"url":"http://www.alistapart.com/articles/using-svg-for-flexible-scalable-and-fun-backgrounds-part-i","title":"A List Apart article"},{"url":"http://svg-wow.org/","title":"SVG showcase site"},{"url":"http://code.google.com/p/svgweb/","title":"SVG Web: Flash-based polyfill"},{"url":"http://svg-edit.googlecode.com","title":"Web-based SVG editor"},{"url":"https://raw.github.com/phiggins42/has.js/master/detect/graphics.js#svg","title":"has.js test"}],"categories":["SVG"],"stats":{"ie":{"5.5":"n","6":"p","7":"p","8":"p","9":"y #2","10":"y #2","11":"y #2","TP":"y #2"},"firefox":{"2":"a","3":"y","3.5":"y","3.6":"y","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"a","3.2":"y","4":"y","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"y","9.5-9.6":"y","10.0-10.1":"y","10.5":"y","10.6":"y","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"y","4.0-4.1":"y","4.2-4.3":"y","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"y"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"a #1","4":"a #1","4.1":"a #1","4.2-4.3":"a #1","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"y","11":"y","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y #2","11":"y #2"},"and_uc":{"9.9":"y"}},"notes":"","notes_by_num":{"1":"Partial support in Android 3 & 4 refers to not supporting masking.","2":"IE9-11 desktop & mobile don't properly scale SVG files.  [Adding height, width, viewport, and CSS rules](http://codepen.io/tomByrer/pen/qEBbzw?editors=110) seem to be the best workaround."},"usage_perc_y":89.88,"usage_perc_a":2.74,"ucprefix":false,"parent":"","keywords":"","ie_id":"","chrome_id":""},"svg-css":{"title":"SVG in CSS backgrounds","description":"Method of using SVG images as CSS backgrounds","spec":"http://www.w3.org/TR/css3-background/#background-image","status":"cr","links":[{"url":"http://designfestival.com/a-farewell-to-css3-gradients/","title":"Tutorial for advanced effects"}],"categories":["CSS3","SVG"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"y","10":"y","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"a","5":"a","6":"a","7":"a","8":"a","9":"a","10":"a","11":"a","12":"a","13":"a","14":"a","15":"a","16":"a","17":"a","18":"a","19":"a","20":"a","21":"a","22":"a","23":"a","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"a","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"a","4":"a","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"y","10.0-10.1":"y","10.5":"y","10.6":"y","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"a","4.0-4.1":"a","4.2-4.3":"y","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"a"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"y","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"a","11":"a","11.1":"a","11.5":"a","12":"a","12.1":"a","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y"}},"notes":"Partial support in older Firefox and Opera Mini/Mobile refers to SVG images being blurry when scaled. Partial support in iOS Safari and older Safari versions refers to failing to support tiling or the background-position property.","notes_by_num":{},"usage_perc_y":88.62,"usage_perc_a":3.85,"ucprefix":false,"parent":"","keywords":"svg-in-css,svgincss,css-svg","ie_id":"","chrome_id":""},"svg-smil":{"title":"SVG SMIL animation","description":"Method of using animation elements to animate SVG images","spec":"http://www.w3.org/TR/SVG/animate.html","status":"rec","links":[{"url":"http://svg-wow.org/blog/category/animation/","title":"Examples on SVG WOW"},{"url":"https://developer.mozilla.org/en/SVG/SVG_animation_with_SMIL","title":"MDN article"},{"url":"http://leunen.me/fakesmile/","title":"JS library to support SMIL in SVG"},{"url":"https://raw.github.com/phiggins42/has.js/master/detect/graphics.js#svg-smil","title":"has.js test"},{"url":"https://github.com/madsgraphics/SVGEventListener","title":"Polyfill for SMIL animate events on SVG"}],"categories":["SVG"],"stats":{"ie":{"5.5":"n","6":"p","7":"p","8":"p","9":"p","10":"p","11":"p","TP":"p"},"firefox":{"2":"p","3":"p","3.5":"p","3.6":"p","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"a","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"p","3.2":"p","4":"a","5":"a","5.1":"a","6":"a","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"y","9.5-9.6":"y","10.0-10.1":"y","10.5":"y","10.6":"y","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"a","4.0-4.1":"a","4.2-4.3":"a","5.0-5.1":"a","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"y","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"y","11":"y","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"p","11":"p"},"and_uc":{"9.9":"y"}},"notes":"Partial support in Safari refers to not working in HTML files.","notes_by_num":{},"usage_perc_y":75.8,"usage_perc_a":0.76,"ucprefix":false,"parent":"","keywords":"","ie_id":"","chrome_id":""},"svg-fonts":{"title":"SVG fonts","description":"Method of using fonts defined as SVG shapes. Considered among a number of browser vendors as a deprecated feature with support being removed.","spec":"http://www.w3.org/TR/SVG/fonts.html","status":"rec","links":[{"url":"http://jeremie.patonnier.net/post/2011/02/07/Why-are-SVG-Fonts-so-different","title":"Blog post"},{"url":"http://opentype.info/blog/2010/04/13/the-ipad-and-svg-fonts-in-mobile-safari/","title":"Blog post on usage for iPad"}],"categories":["SVG"],"stats":{"ie":{"5.5":"n","6":"p","7":"p","8":"p","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"n","34":"n","35":"n","36":"n","37":"n","38":"n"},"chrome":{"4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"n #1","39":"n #1","40":"n #1","41":"n #1","42":"n #1","43":"n #1"},"safari":{"3.1":"n","3.2":"y","4":"y","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"y","9.5-9.6":"y","10.0-10.1":"y","10.5":"y","10.6":"y","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"n #1","26":"n #1","27":"n #1","28":"n #1","29":"n #1"},"ios_saf":{"3.2":"y","4.0-4.1":"y","4.2-4.3":"y","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n #2"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"y","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"y","11":"y","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"n #1"},"and_ff":{"33":"n"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"y"}},"notes":"","notes_by_num":{"1":"Chrome 38 and newer support SVG fonts only on Windows Vista and XP.","2":"Supported in Opera Mini in SVG images only, not in HTML."},"usage_perc_y":26.51,"usage_perc_a":0,"ucprefix":false,"parent":"fontface","keywords":"","ie_id":"","chrome_id":"5930075908210688"},"svg-filters":{"title":"SVG filters","description":"Method of using photoshop-like effects on SVG objects including blurring and color manipulation.","spec":"http://www.w3.org/TR/SVG/filters.html","status":"rec","links":[{"url":"http://electricbeach.org/?p=950","title":"Experiments with filter effects"},{"url":"http://svg-wow.org/blog/category/filters/","title":"SVG filter demos"},{"url":"http://docs.webplatform.org/wiki/svg/elements/filter","title":"WebPlatform Docs"}],"categories":["SVG"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"y","11":"y","TP":"y"},"firefox":{"2":"n","3":"y","3.5":"y","3.6":"y","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"a","6":"a","7":"a","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"y","9.5-9.6":"y","10.0-10.1":"y","10.5":"y","10.6":"y","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"y"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"n","10":"y"},"op_mob":{"10":"y","11":"y","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y"}},"notes":"","notes_by_num":{},"usage_perc_y":86.93,"usage_perc_a":0.05,"ucprefix":false,"parent":"","keywords":"","ie_id":"","chrome_id":""},"svg-html":{"title":"SVG effects for HTML","description":"Method of using SVG transforms, filters, etc on HTML elements using either CSS or the foreignObject element","spec":"http://www.w3.org/TR/SVG11/extend.html#ForeignObjectElement","status":"wd","links":[{"url":"https://developer.mozilla.org/en/SVG/Tutorial/Other_content_in_SVG","title":"MDN Tutorial"},{"url":"https://developer.mozilla.org/En/Applying_SVG_effects_to_HTML_content","title":"MDN Reference page"},{"url":"http://www.w3.org/TR/filter-effects/","title":"Filter Effects draft"}],"categories":["SVG"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"a","10":"a","11":"a","TP":"a"},"firefox":{"2":"n","3":"a","3.5":"y","3.6":"y","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"a","5":"a","6":"a","7":"a","8":"a","9":"a","10":"a","11":"a","12":"a","13":"a","14":"a","15":"a","16":"a","17":"a","18":"a","19":"a","20":"a","21":"a","22":"a","23":"a","24":"a","25":"a","26":"a","27":"a","28":"a","29":"a","30":"a","31":"a","32":"a","33":"a","34":"a","35":"a","36":"a","37":"a","38":"a","39":"a","40":"a","41":"a","42":"a","43":"a"},"safari":{"3.1":"n","3.2":"n","4":"a","5":"a","5.1":"a","6":"a","6.1":"a","7":"a","7.1":"a","8":"a"},"opera":{"9":"a","9.5-9.6":"a","10.0-10.1":"a","10.5":"a","10.6":"a","11":"a","11.1":"a","11.5":"a","11.6":"a","12":"a","12.1":"a","15":"a","16":"a","17":"a","18":"a","19":"a","20":"a","21":"a","22":"a","23":"a","24":"a","25":"a","26":"a","27":"a","28":"a","29":"a"},"ios_saf":{"3.2":"a","4.0-4.1":"a","4.2-4.3":"a","5.0-5.1":"a","6.0-6.1":"a","7.0-7.1":"a","8":"a","8.1":"a"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"a","4.4.3-4.4.4":"a","37":"a"},"bb":{"7":"n","10":"y"},"op_mob":{"10":"a","11":"a","11.1":"a","11.5":"a","12":"a","12.1":"a","24":"a"},"and_chr":{"40":"a"},"and_ff":{"33":"y"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"n"}},"notes":"Partial support refers to lack of filter support or buggy result from effects. A [CSS Filter Effects](http://www.w3.org/TR/filter-effects/) specification is in the works that would replace this method.","notes_by_num":{},"usage_perc_y":11.97,"usage_perc_a":70.22,"ucprefix":false,"parent":"","keywords":"","ie_id":"","chrome_id":""},"svg-html5":{"title":"Inline SVG in HTML5","description":"Method of using SVG tags directly in HTML documents. Requires HTML5 parser.","spec":"https://html.spec.whatwg.org/multipage/embedded-content.html#svg-0","status":"ls","links":[{"url":"http://hacks.mozilla.org/2010/05/firefox-4-the-html5-parser-inline-svg-speed-and-more/","title":"Mozilla Hacks blog post"},{"url":"http://samples.msdn.microsoft.com/ietestcenter/html5/svghtml_harness.htm?url=SVG_HTML_Elements_001","title":"Test suite"}],"categories":["HTML5","SVG"],"stats":{"ie":{"5.5":"n","6":"p","7":"p","8":"p","9":"y","10":"y","11":"y","TP":"y"},"firefox":{"2":"p","3":"p","3.5":"p","3.6":"p","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"p","5":"p","6":"p","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"p","3.2":"p","4":"p","5":"p","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"p","9.5-9.6":"p","10.0-10.1":"p","10.5":"p","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"p","4.0-4.1":"p","4.2-4.3":"p","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"y","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"p","11":"p","11.1":"p","11.5":"p","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y"}},"notes":"","notes_by_num":{},"usage_perc_y":89.09,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"","ie_id":"","chrome_id":""},"canvas":{"title":"Canvas (basic support)","description":"Method of generating fast, dynamic graphics using JavaScript.","spec":"https://html.spec.whatwg.org/multipage/scripting.html#the-canvas-element","status":"ls","links":[{"url":"https://developer.mozilla.org/en/Canvas_tutorial","title":"Tutorial by Mozilla"},{"url":"http://www.canvasdemos.com/","title":"Showcase site"},{"url":"http://glimr.rubyforge.org/cake/canvas.html","title":"Animation kit "},{"url":"http://diveintohtml5.info/canvas.html","title":"Another tutorial"},{"url":"http://explorercanvas.googlecode.com/","title":"Implementation for Internet Explorer"},{"url":"https://raw.github.com/phiggins42/has.js/master/detect/graphics.js#canvas","title":"has.js test"}],"categories":["Canvas","HTML5"],"stats":{"ie":{"5.5":"n","6":"p","7":"p","8":"p","9":"y","10":"y","11":"y","TP":"y"},"firefox":{"2":"y","3":"y","3.5":"y","3.6":"y","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"y","3.2":"y","4":"y","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"y","9.5-9.6":"y","10.0-10.1":"y","10.5":"y","10.6":"y","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"y","4.0-4.1":"y","4.2-4.3":"y","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"a"},"android":{"2.1":"a","2.2":"a","2.3":"a","3":"y","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"y","11":"y","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y"}},"notes":"Opera Mini supports the canvas element, but is unable to play animations or run other more complex applications. Android 2.x supports canvas except the toDataURL() function. See http://code.google.com/p/android/issues/detail?id=7901 Some (slow) workarounds are described here: http://stackoverflow.com/q/10488033/841830","notes_by_num":{},"usage_perc_y":89.55,"usage_perc_a":3.23,"ucprefix":false,"parent":"","keywords":"","ie_id":"canvas","chrome_id":"5100084685438976"},"canvas-text":{"title":"Text API for Canvas","description":"Method of displaying text on Canvas elements","spec":"https://html.spec.whatwg.org/multipage/scripting.html#drawing-text-to-the-bitmap","status":"ls","links":[{"url":"https://developer.mozilla.org/en/Drawing_text_using_a_canvas#Additional_examples","title":"Examples by Mozilla"},{"url":"http://code.google.com/p/canvas-text/","title":"Support library"},{"url":"https://raw.github.com/phiggins42/has.js/master/detect/graphics.js#canvas-text","title":"has.js test"},{"url":"http://docs.webplatform.org/wiki/apis/canvas/CanvasRenderingContext2D/fillText","title":"WebPlatform Docs"}],"categories":["Canvas","HTML5"],"stats":{"ie":{"5.5":"n","6":"p","7":"p","8":"p","9":"y","10":"y","11":"y","TP":"y"},"firefox":{"2":"p","3":"p","3.5":"y","3.6":"y","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"p","3.2":"p","4":"y","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"p","9.5-9.6":"p","10.0-10.1":"p","10.5":"y","10.6":"y","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"y","4.0-4.1":"y","4.2-4.3":"y","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"y","2.2":"y","2.3":"y","3":"y","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"p","11":"y","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y"}},"notes":"","notes_by_num":{},"usage_perc_y":89.63,"usage_perc_a":0,"ucprefix":false,"parent":"canvas","keywords":"","ie_id":"","chrome_id":""},"namevalue-storage":{"title":"Web Storage - name/value pairs","description":"Method of storing data locally like cookies, but for larger amounts of data (sessionStorage and localStorage, used to fall under HTML5).","spec":"http://www.w3.org/TR/webstorage/#storage","status":"rec","links":[{"url":"https://developer.mozilla.org/en-US/docs/Web/API/Web_Storage_API","title":"MDN article"},{"url":"http://code.google.com/p/sessionstorage/","title":"Support library"},{"url":"http://html5demos.com/storage","title":"Simple demo"},{"url":"https://raw.github.com/phiggins42/has.js/master/detect/features.js#native-localstorage;native-sessionstorage","title":"has.js test"},{"url":"http://docs.webplatform.org/wiki/apis/web-storage/Storage/localStorage","title":"WebPlatform Docs"}],"categories":["JS API"],"stats":{"ie":{"5.5":"n","6":"p","7":"p","8":"y","9":"y","10":"y","11":"y","TP":"y"},"firefox":{"2":"a","3":"a","3.5":"y","3.6":"y","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"y","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"y","10.6":"y","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"y","4.0-4.1":"y","4.2-4.3":"y","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"y","2.2":"y","2.3":"y","3":"y","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"n","11":"y","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y"}},"notes":"","notes_by_num":{},"usage_perc_y":93.71,"usage_perc_a":0.03,"ucprefix":false,"parent":"","keywords":"webstorage,local storage","ie_id":"webstorage","chrome_id":"5345825534246912"},"sql-storage":{"title":"Web SQL Database","description":"Method of storing data client-side, allows Sqlite database queries for access and manipulation","spec":"http://www.w3.org/TR/webdatabase/","status":"unoff","links":[{"url":"http://html5doctor.com/introducing-web-sql-databases/","title":"HTML5 Doctor article"},{"url":"https://raw.github.com/phiggins42/has.js/master/detect/features.js#native-sql-db","title":"has.js test"}],"categories":["JS API"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"n","34":"n","35":"n","36":"n","37":"n","38":"n"},"chrome":{"4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"y","3.2":"y","4":"y","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"y","10.6":"y","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"y","4.0-4.1":"y","4.2-4.3":"y","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"y","2.2":"y","2.3":"y","3":"y","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"n","11":"y","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"n"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"y"}},"notes":"The Web SQL Database specification is no longer being maintained and support may be dropped in future versions.","notes_by_num":{},"usage_perc_y":64.83,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"db-storage,websql","ie_id":"websqldatabase","chrome_id":"6330987952734208"},"indexeddb":{"title":"IndexedDB","description":"Method of storing data client-side, allows indexed database queries.","spec":"http://www.w3.org/TR/IndexedDB/","status":"cr","links":[{"url":"http://hacks.mozilla.org/2010/06/comparing-indexeddb-and-webdatabase/","title":"Mozilla Hacks article"},{"url":"https://github.com/axemclion/IndexedDBShim","title":"Polyfill for browsers supporting WebSQL"},{"url":"https://raw.github.com/phiggins42/has.js/master/detect/features.js#native-indexeddb","title":"has.js test"},{"url":"http://docs.webplatform.org/wiki/apis/indexedDB","title":"WebPlatform Docs"}],"categories":["JS API"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"a #1","11":"a #1","TP":"a #1"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"a x","5":"a x","6":"a x","7":"a x","8":"a x","9":"a x","10":"y x","11":"y x","12":"y x","13":"y x","14":"y x","15":"y x","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"p","5":"p","6":"p","7":"p","8":"p","9":"p","10":"n","11":"a x","12":"a x","13":"a x","14":"a x","15":"a x","16":"a x","17":"a x","18":"a x","19":"a x","20":"a x","21":"a x","22":"a x","23":"y x","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"p","3.2":"p","4":"p","5":"p","5.1":"p","6":"p","6.1":"p","7":"p","7.1":"a #2","8":"a #2"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"p","10.6":"p","11":"p","11.1":"p","11.5":"p","11.6":"p","12":"p","12.1":"p","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"p","4.0-4.1":"p","4.2-4.3":"p","5.0-5.1":"p","6.0-6.1":"p","7.0-7.1":"p","8":"a #2","8.1":"a #2"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"p","2.2":"p","2.3":"p","3":"p","4":"p","4.1":"p","4.2-4.3":"p","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"p","10":"y"},"op_mob":{"10":"n","11":"p","11.1":"p","11.5":"p","12":"p","12.1":"p","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"a #1","11":"a #1"},"and_uc":{"9.9":"p"}},"notes":"","notes_by_num":{"1":"Partial support in IE 10 & 11 refers to a number of subfeatures [not being supported](http://codepen.io/cemerick/pen/Itymi).","2":"Partial support in iOS 8 refers to [seriously buggy behavior](http://www.raymondcamden.com/2014/9/25/IndexedDB-on-iOS-8--Broken-Bad)."},"usage_perc_y":58.27,"usage_perc_a":18.08,"ucprefix":false,"parent":"","keywords":"indexdb","ie_id":"indexeddb","chrome_id":"6507459568992256"},"online-status":{"title":"Online/offline status","description":"Events to indicate when the user's connected (`online` and `offline` events) and the `navigator.onLine` property to see current status.","spec":"https://html.spec.whatwg.org/multipage/browsers.html#browser-state","status":"ls","links":[{"url":"https://developer.mozilla.org/en-US/docs/Web/API/NavigatorOnLine.onLine#Specification","title":"MDN article"}],"categories":["JS API"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"a #2","9":"y","10":"y","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"y","3.6":"y","4":"a #3","5":"a #3","6":"a #3","7":"a #3","8":"a #3","9":"a #3","10":"a #3","11":"a #3","12":"a #3","13":"a #3","14":"a #3","15":"a #3","16":"a #3","17":"a #3","18":"a #3","19":"a #3","20":"a #3","21":"a #3","22":"a #3","23":"a #3","24":"a #3","25":"a #3","26":"a #3","27":"a #3","28":"a #3","29":"a #3","30":"a #3","31":"a #3","32":"a #3","33":"a #3","34":"a #3","35":"a #3","36":"a #3","37":"a #3","38":"a #3"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"a","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"u","4.0-4.1":"u","4.2-4.3":"y","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"u","2.2":"u","2.3":"y","3":"y","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"a #1","10":"y"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"a #1"}},"notes":"\"online\" does not always mean connection to the internet, it can also just mean connection to some network.\r\n\r\nEarly versions of Chrome and Safari always reported \"true\" for `navigator.onLine`","notes_by_num":{"1":"Seems to support `navigator.onLine` but not `online`/`offline` events.","2":"IE8 only supports the `online`/`offline` events on `document.body`, rather than `window`.","3":"Desktop Firefox responds to the status of its \"Work Offline\" mode. If not in that mode, `navigator.onLine` in always `true`, regardless of the actual network connectivity status."},"usage_perc_y":73.38,"usage_perc_a":19.88,"ucprefix":false,"parent":"","keywords":"","ie_id":"","chrome_id":""},"eventsource":{"title":"Server-sent events","description":"Method of continuously sending data from a server to the browser, rather than repeatedly requesting it (EventSource interface, used to fall under HTML5)","spec":"http://www.w3.org/TR/eventsource/","status":"pr","links":[{"url":"http://www.html5rocks.com/tutorials/eventsource/basics/","title":"HTML5 Rocks tutorial"},{"url":"http://samshull.blogspot.com/2010/10/ajax-push-in-ios-safari-and-chrome-with.html","title":"Blog post with demo"},{"url":"https://raw.github.com/phiggins42/has.js/master/detect/features.js#native-eventsource","title":"has.js test"}],"categories":["JS API"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"a","9.5-9.6":"a","10.0-10.1":"a","10.5":"a","10.6":"a","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"y","4.2-4.3":"y","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"a","11":"a","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"y"}},"notes":"","notes_by_num":{},"usage_perc_y":73.65,"usage_perc_a":0.04,"ucprefix":false,"parent":"","keywords":"serversent,s-sent-events","ie_id":"serversenteventseventsource","chrome_id":"5311740673785856"},"x-doc-messaging":{"title":"Cross-document messaging","description":"Method of sending information from a page on one domain to a page on a different one (using postMessage)","spec":"https://html.spec.whatwg.org/multipage/comms.html#crossDocumentMessages","status":"ls","links":[{"url":"https://developer.mozilla.org/en/DOM/window.postMessage","title":"MDN article"},{"url":"http://html5demos.com/postmessage2","title":"Simple demo"},{"url":"https://raw.github.com/phiggins42/has.js/master/detect/features.js#native-crosswindowmessaging","title":"has.js test"},{"url":"http://docs.webplatform.org/wiki/apis/web-messaging/MessagePort/postMessage","title":"WebPlatform Docs"}],"categories":["JS API"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"a","9":"a","10":"a","11":"a","TP":"a"},"firefox":{"2":"n","3":"y","3.5":"y","3.6":"y","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"y","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"y","10.0-10.1":"y","10.5":"y","10.6":"y","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"y","4.0-4.1":"y","4.2-4.3":"y","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"y"},"android":{"2.1":"y","2.2":"y","2.3":"y","3":"y","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"y","11":"y","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"a","11":"a"},"and_uc":{"9.9":"y"}},"notes":"Partial support in IE8-9 refers to only working in frames/iframes (not other tabs/windows). Also in IE 9 and below an object cannot be sent using postMessage. Partial support in IE10 refers to [limitations in certain conditions](http://stackoverflow.com/questions/16226924/is-cross-origin-postmessage-broken-in-ie10)","notes_by_num":{},"usage_perc_y":79.91,"usage_perc_a":16.92,"ucprefix":false,"parent":"","keywords":"","ie_id":"postmessage","chrome_id":"4786174115708928"},"datauri":{"title":"Data URIs","description":"Method of embedding images and other files in webpages as a string of text","spec":"http://www.ietf.org/rfc/rfc2397.txt","status":"other","links":[{"url":"http://css-tricks.com/5970-data-uris/","title":"Information page"},{"url":"http://en.wikipedia.org/wiki/data_URI_scheme","title":"Wikipedia"},{"url":"http://www.websiteoptimization.com/speed/tweak/inline-images/","title":"Data URL converter"},{"url":"http://klevjers.com/papers/phishing.pdf","title":"Information on security issues"}],"categories":["Other"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"a","9":"a","10":"a","11":"a","TP":"a"},"firefox":{"2":"y","3":"y","3.5":"y","3.6":"y","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"y","3.2":"y","4":"y","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"y","9.5-9.6":"y","10.0-10.1":"y","10.5":"y","10.6":"y","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"y","4.0-4.1":"y","4.2-4.3":"y","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"y"},"android":{"2.1":"y","2.2":"y","2.3":"y","3":"y","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"y","11":"y","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"a","11":"a"},"and_uc":{"9.9":"y"}},"notes":"Support in Internet Explorer 8 is limited to images and linked resources like CSS files, not HTML files. Max URI length in IE8 is 32KB. In IE9+ JavaScript files are supported too and the maximum size limit set to 4GB.","notes_by_num":{},"usage_perc_y":79.93,"usage_perc_a":16.92,"ucprefix":false,"parent":"","keywords":"data url,datauris,data uri,dataurl,dataurls,base64","ie_id":"","chrome_id":""},"mathml":{"title":"MathML","description":"Special tags that allow mathematical formulas and notations to be written on web pages.","spec":"http://www.w3.org/TR/MathML/","status":"rec","links":[{"url":"http://en.wikipedia.org/wiki/MathML","title":"Wikipedia"},{"url":"http://www.mozilla.org/projects/mathml/demo/","title":"MathML demos"},{"url":"http://www.mathjax.org","title":"Cross-browser support script"},{"url":"https://developer.mozilla.org/en/MathML/Element","title":"MDN element reference"}],"categories":["Other"],"stats":{"ie":{"5.5":"n","6":"p","7":"p","8":"p","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"y","3":"y","3.5":"y","3.6":"y","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"p","5":"p","6":"p","7":"p","8":"p","9":"p","10":"p","11":"p","12":"p","13":"p","14":"p","15":"p","16":"p","17":"p","18":"p","19":"p","20":"p","21":"p","22":"p","23":"p","24":"y","25":"p","26":"p","27":"p","28":"p","29":"p","30":"p","31":"p","32":"p","33":"p","34":"p","35":"p","36":"p","37":"p","38":"p","39":"p","40":"p","41":"p","42":"p","43":"p"},"safari":{"3.1":"p","3.2":"p","4":"p","5":"p","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"a","10.0-10.1":"a","10.5":"a","10.6":"a","11":"a","11.1":"a","11.5":"a","11.6":"a","12":"a","12.1":"a","15":"p","16":"p","17":"p","18":"p","19":"p","20":"p","21":"p","22":"p","23":"p","24":"p","25":"p","26":"p","27":"p","28":"p","29":"p"},"ios_saf":{"3.2":"p","4.0-4.1":"p","4.2-4.3":"p","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"p"},"android":{"2.1":"p","2.2":"p","2.3":"p","3":"p","4":"p","4.1":"p","4.2-4.3":"p","4.4":"p","4.4.3-4.4.4":"p","37":"p"},"bb":{"7":"p","10":"y"},"op_mob":{"10":"p","11":"p","11.1":"p","11.5":"p","12":"p","12.1":"p","24":"p"},"and_chr":{"40":"p"},"and_ff":{"33":"y"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"a"}},"notes":"Opera's support is limited to a CSS profile of MathML. Support was added in Chrome 24, but removed afterwards due to instability.","notes_by_num":{},"usage_perc_y":22.53,"usage_perc_a":4.07,"ucprefix":false,"parent":"","keywords":"","ie_id":"mathml","chrome_id":"5240822173794304"},"css-featurequeries":{"title":"CSS Feature Queries","description":"CSS Feature Queries allow authors to condition rules based on whether particular property declarations are supported in CSS using the @supports at rule.","spec":"http://www.w3.org/TR/css3-conditional/#at-supports","status":"cr","links":[{"url":"https://developer.mozilla.org/en-US/docs/Web/CSS/@supports","title":"MDN Article"},{"url":"http://mcc.id.au/blog/2012/08/supports","title":"@supports in Firefox"},{"url":"http://dabblet.com/gist/3895764","title":"Test case"},{"url":"http://docs.webplatform.org/wiki/css/atrules/@supports","title":"WebPlatform Docs"}],"categories":["CSS3"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"n","7":"n","7.1":"n","8":"n"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"n","8.1":"n"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"n"}},"notes":"See also the [CSS.supports() DOM API](#feat=css-supports-api)","notes_by_num":{},"usage_perc_y":57.79,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"supports,conditional","ie_id":"conditionalrules","chrome_id":"4993981813358592"},"xhtml":{"title":"XHTML served as application/xhtml+xml","description":"A strict form of HTML, and allows embedding of other XML languages","spec":"http://www.w3.org/TR/xhtml1/","status":"rec","links":[{"url":"http://en.wikipedia.org/wiki/XHTML","title":"Wikipedia"},{"url":"http://www.xmlplease.com/xhtml/xhtml5polyglot/","title":"Information on XHTML5"},{"url":"http://docs.webplatform.org/wiki/concepts/internet_and_web/the_web_standards_model#What_is_XHTML.3F","title":"WebPlatform Docs"}],"categories":["Other"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"y","10":"y","11":"y","TP":"y"},"firefox":{"2":"y","3":"y","3.5":"y","3.6":"y","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"y","3.2":"y","4":"y","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"y","9.5-9.6":"y","10.0-10.1":"y","10.5":"y","10.6":"y","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"y","4.0-4.1":"y","4.2-4.3":"y","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"y"},"android":{"2.1":"y","2.2":"y","2.3":"y","3":"y","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"y","11":"y","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y"}},"notes":"The XHTML syntax is very close to HTML, and thus is almost always ([incorrectly](https://developer.mozilla.org/en-US/docs/XHTML#MIME_type_versus_DOCTYPE)) served as text/html on the web.","notes_by_num":{},"usage_perc_y":92.77,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"xhtml+xml","ie_id":"","chrome_id":""},"xhtmlsmil":{"title":"XHTML+SMIL animation","description":"Method of using SMIL animation in web pages","spec":"http://www.w3.org/TR/XHTMLplusSMIL/","status":"unoff","links":[{"url":"http://en.wikipedia.org/wiki/XHTML%2BSMIL","title":"Wikipedia"},{"url":"http://leunen.me/fakesmile/","title":"JS library to support XHTML+SMIL"}],"categories":["Other"],"stats":{"ie":{"5.5":"n","6":"a","7":"a","8":"a","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"p","3":"p","3.5":"p","3.6":"p","4":"p","5":"p","6":"p","7":"p","8":"p","9":"p","10":"p","11":"p","12":"p","13":"p","14":"p","15":"p","16":"p","17":"p","18":"p","19":"p","20":"p","21":"p","22":"p","23":"p","24":"p","25":"p","26":"p","27":"p","28":"p","29":"p","30":"p","31":"p","32":"p","33":"p","34":"p","35":"p","36":"p","37":"p","38":"p"},"chrome":{"4":"p","5":"p","6":"p","7":"p","8":"p","9":"p","10":"p","11":"p","12":"p","13":"p","14":"p","15":"p","16":"p","17":"p","18":"p","19":"p","20":"p","21":"p","22":"p","23":"p","24":"p","25":"p","26":"p","27":"p","28":"p","29":"p","30":"p","31":"p","32":"p","33":"p","34":"p","35":"p","36":"p","37":"p","38":"p","39":"p","40":"p","41":"p","42":"p","43":"p"},"safari":{"3.1":"p","3.2":"p","4":"p","5":"p","5.1":"p","6":"p","6.1":"p","7":"p","7.1":"p","8":"p"},"opera":{"9":"p","9.5-9.6":"p","10.0-10.1":"p","10.5":"p","10.6":"p","11":"p","11.1":"p","11.5":"p","11.6":"p","12":"p","12.1":"p","15":"p","16":"p","17":"p","18":"p","19":"p","20":"p","21":"p","22":"p","23":"p","24":"p","25":"p","26":"p","27":"p","28":"p","29":"p"},"ios_saf":{"3.2":"p","4.0-4.1":"p","4.2-4.3":"p","5.0-5.1":"p","6.0-6.1":"p","7.0-7.1":"p","8":"p","8.1":"p"},"op_mini":{"5.0-8.0":"p"},"android":{"2.1":"p","2.2":"p","2.3":"p","3":"p","4":"p","4.1":"p","4.2-4.3":"p","4.4":"p","4.4.3-4.4.4":"p","37":"p"},"bb":{"7":"p","10":"p"},"op_mob":{"10":"p","11":"p","11.1":"p","11.5":"p","12":"p","12.1":"p","24":"p"},"and_chr":{"40":"p"},"and_ff":{"33":"p"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"p"}},"notes":"Internet Explorer supports the W3C proposal HTML+TIME, which is largely the same as XHTML+SMIL","notes_by_num":{},"usage_perc_y":0,"usage_perc_a":4.34,"ucprefix":false,"parent":"xhtml","keywords":"","ie_id":"","chrome_id":""},"wai-aria":{"title":"WAI-ARIA Accessibility features","description":"Method of providing ways for people with disabilities to use dynamic web content and web applications.","spec":"http://www.w3.org/TR/wai-aria/","status":"rec","links":[{"url":"http://www.w3.org/WAI/intro/aria","title":"Information page"},{"url":"http://www.paciellogroup.com/blog/2011/10/browser-assistive-technology-tests-redux/","title":"Links to various test results"},{"url":"http://en.wikipedia.org/wiki/WAI-ARIA","title":"Wikipedia"},{"url":"http://www.alistapart.com/articles/the-accessibility-of-wai-aria/","title":"ALA Article"},{"url":"http://zufelt.ca/blog/are-you-confused-html5-and-wai-aria-yet","title":"HTML5/WAI-ARIA information"}],"categories":["Other"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"y","9":"y","10":"y","11":"y","TP":"y"},"firefox":{"2":"a","3":"y","3.5":"y","3.6":"y","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"a","5":"a","6":"a","7":"a","8":"a","9":"a","10":"a","11":"a","12":"a","13":"a","14":"a","15":"a","16":"a","17":"a","18":"a","19":"a","20":"a","21":"a","22":"a","23":"a","24":"a","25":"a","26":"a","27":"a","28":"a","29":"a","30":"a","31":"a","32":"a","33":"a","34":"a","35":"a","36":"a","37":"a","38":"a","39":"a","40":"a","41":"a","42":"a","43":"a"},"safari":{"3.1":"n","3.2":"n","4":"a","5":"a","5.1":"a","6":"a","6.1":"a","7":"a","7.1":"a","8":"a"},"opera":{"9":"n","9.5-9.6":"a","10.0-10.1":"a","10.5":"a","10.6":"a","11":"a","11.1":"a","11.5":"a","11.6":"a","12":"a","12.1":"a","15":"a","16":"a","17":"a","18":"a","19":"a","20":"a","21":"a","22":"a","23":"a","24":"a","25":"a","26":"a","27":"a","28":"a","29":"a"},"ios_saf":{"3.2":"a","4.0-4.1":"a","4.2-4.3":"a","5.0-5.1":"a","6.0-6.1":"a","7.0-7.1":"a","8":"a","8.1":"a"},"op_mini":{"5.0-8.0":"a"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"a","4.4.3-4.4.4":"a","37":"a"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"a","11":"a","11.1":"a","11.5":"a","12":"a","12.1":"a","24":"a"},"and_chr":{"40":"a"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"n"}},"notes":"","notes_by_num":{},"usage_perc_y":28.91,"usage_perc_a":61.16,"ucprefix":false,"parent":"","keywords":"wai,aria","ie_id":"","chrome_id":""},"geolocation":{"title":"Geolocation","description":"Method of informing a website of the user's geographical location","spec":"http://www.w3.org/TR/geolocation-API/","status":"cr","links":[{"url":"http://html5demos.com/geo","title":"Simple demo"},{"url":"https://raw.github.com/phiggins42/has.js/master/detect/features.js#native-geolocation","title":"has.js test"},{"url":"http://docs.webplatform.org/wiki/apis/geolocation","title":"WebPlatform Docs"}],"categories":["JS API"],"stats":{"ie":{"5.5":"n","6":"p","7":"p","8":"p","9":"y","10":"y","11":"y","TP":"y"},"firefox":{"2":"p","3":"p","3.5":"y","3.6":"y","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"a","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"p","3.2":"p","4":"p","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"p","10.5":"p","10.6":"y","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"n","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"y","4.0-4.1":"y","4.2-4.3":"y","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"y","2.2":"y","2.3":"y","3":"y","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"p","11":"y","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y"}},"notes":"","notes_by_num":{},"usage_perc_y":89.53,"usage_perc_a":0.03,"ucprefix":false,"parent":"","keywords":"","ie_id":"geolocation","chrome_id":"6348855016685568"},"flexbox":{"title":"Flexible Box Layout Module","description":"Method of positioning elements in horizontal or vertical stacks.","spec":"http://www.w3.org/TR/css3-flexbox/","status":"wd","links":[{"url":"http://bennettfeely.com/flexplorer/","title":"Flexbox CSS generator"},{"url":"http://www.adobe.com/devnet/html5/articles/working-with-flexbox-the-new-spec.html","title":"Article on using the latest spec"},{"url":"https://dev.opera.com/articles/view/advanced-cross-browser-flexbox/","title":"Tutorial on cross-browser support"},{"url":"http://philipwalton.github.io/solved-by-flexbox/","title":"Examples on how to solve common layout problems with flexbox"},{"url":"http://css-tricks.com/snippets/css/a-guide-to-flexbox/","title":"A Complete Guide to Flexbox"},{"url":"http://the-echoplex.net/flexyboxes/","title":"Flexbox playground and code generator"}],"categories":["CSS3"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"a x #2","11":"y","TP":"y"},"firefox":{"2":"a x #1","3":"a x #1","3.5":"a x #1","3.6":"a x #1","4":"a x #1","5":"a x #1","6":"a x #1","7":"a x #1","8":"a x #1","9":"a x #1","10":"a x #1","11":"a x #1","12":"a x #1","13":"a x #1","14":"a x #1","15":"a x #1","16":"a x #1","17":"a x #1","18":"a x #1","19":"a x #1","20":"a x #1","21":"a x #1","22":"a #3","23":"a #3","24":"a #3","25":"a #3","26":"a #3","27":"a #3","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"a x #1","5":"a x #1","6":"a x #1","7":"a x #1","8":"a x #1","9":"a x #1","10":"a x #1","11":"a x #1","12":"a x #1","13":"a x #1","14":"a x #1","15":"a x #1","16":"a x #1","17":"a x #1","18":"a x #1","19":"a x #1","20":"a x #1","21":"y x","22":"y x","23":"y x","24":"y x","25":"y x","26":"y x","27":"y x","28":"y x","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"a x #1","3.2":"a x #1","4":"a x #1","5":"a x #1","5.1":"a x #1","6":"a x #1","6.1":"y x","7":"y x","7.1":"y x","8":"y x"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"y","15":"y x","16":"y x","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"a x #1","4.0-4.1":"a x #1","4.2-4.3":"a x #1","5.0-5.1":"a x #1","6.0-6.1":"a x #1","7.0-7.1":"y x","8":"y x","8.1":"y x"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"a x #1","2.2":"a x #1","2.3":"a x #1","3":"a x #1","4":"a x #1","4.1":"a x #1","4.2-4.3":"a x #1","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"a x #1","10":"y x"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"a x #2","11":"y"},"and_uc":{"9.9":"a x #1"}},"notes":"Most partial support refers to supporting an [older version](http://www.w3.org/TR/2009/WD-css3-flexbox-20090723/) of the specification or an [older syntax](http://www.w3.org/TR/2012/WD-css3-flexbox-20120322/).","notes_by_num":{"1":"Only supports the [old flexbox](http://www.w3.org/TR/2009/WD-css3-flexbox-20090723) specification and does not support wrapping.","2":"Only supports the [2012 syntax](http://www.w3.org/TR/2012/WD-css3-flexbox-20120322/)","3":"Does not support flex-wrap or flex-flow properties"},"usage_perc_y":76.29,"usage_perc_a":11.17,"ucprefix":false,"parent":"","keywords":"flex-box,flex-direction,flex-wrap,flex-flow,flex-grow,flex-basis","ie_id":"flexbox","chrome_id":"4837301406400512"},"webgl":{"title":"WebGL - 3D Canvas graphics","description":"Method of generating dynamic 3D graphics using JavaScript, accelerated through hardware","spec":"https://www.khronos.org/registry/webgl/specs/1.0/","status":"other","links":[{"url":"http://khronos.org/webgl/wiki/Getting_a_WebGL_Implementation","title":"Instructions on enabling WebGL"},{"url":"http://www.khronos.org/webgl/wiki/Tutorial","title":"Tutorial"},{"url":"http://hacks.mozilla.org/2009/12/webgl-draft-released-today/","title":"Firefox blog post"},{"url":"http://webkit.org/blog/603/webgl-now-available-in-webkit-nightlies/","title":"Webkit blog post"},{"url":"https://github.com/iewebgl/iewebgl","title":"Polyfill for IE"}],"categories":["Canvas"],"stats":{"ie":{"5.5":"n","6":"p","7":"p","8":"p","9":"p","10":"p","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"a","5":"a","6":"a","7":"a","8":"a","9":"a","10":"a","11":"a","12":"a","13":"a","14":"a","15":"a","16":"a","17":"a","18":"a","19":"a","20":"a","21":"a","22":"a","23":"a","24":"a","25":"a","26":"a","27":"a","28":"a","29":"a","30":"a","31":"a","32":"a","33":"a","34":"a","35":"a","36":"a","37":"a","38":"a"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"a","9":"a","10":"a","11":"a","12":"a","13":"a","14":"a","15":"a","16":"a","17":"a","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"a","6":"a","6.1":"a","7":"a","7.1":"a","8":"a"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"a","12.1":"a","15":"a","16":"a","17":"a","18":"a","19":"a","20":"a","21":"a","22":"a","23":"a","24":"a","25":"a","26":"a","27":"a","28":"a","29":"a"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"n","4.4.3-4.4.4":"n","37":"a"},"bb":{"7":"n","10":"y"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"a","12.1":"a","24":"y"},"and_chr":{"40":"a"},"and_ff":{"33":"a"},"ie_mob":{"10":"p","11":"y"},"and_uc":{"9.9":"y"}},"notes":"Support listed as \"partial\" refers to the fact that not all users with these browsers have WebGL access. This is due to the additional requirement for users to have [up to date video drivers](http://www.khronos.org/webgl/wiki/BlacklistsAndWhitelists). This problem was [solved in Chrome on Windows](http://blog.chromium.org/2012/02/gpu-accelerating-2d-canvas-and-enabling.html) as of version 18.\r\n\r\nNote that WebGL is part of the [Khronos Group](http://www.khronos.org/webgl/), not the W3C.","notes_by_num":{},"usage_perc_y":49.68,"usage_perc_a":26.46,"ucprefix":false,"parent":"canvas","keywords":"web gl","ie_id":"webglcanvas3d,webglinstancingextension","chrome_id":"6049512976023552"},"fileapi":{"title":"File API","description":"Method of manipulating file objects in web applications client-side, as well as programmatically selecting them and accessing their data.","spec":"http://www.w3.org/TR/FileAPI/","status":"wd","links":[{"url":"https://developer.mozilla.org/en/Using_files_from_web_applications","title":"MDN article"},{"url":"http://docs.webplatform.org/wiki/apis/file","title":"WebPlatform Docs"}],"categories":["JS API"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"y","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"y","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"a","7":"a","8":"a","9":"a","10":"a","11":"a","12":"a","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"a","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"a","4":"a","4.1":"a","4.2-4.3":"a","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"a","10":"y"},"op_mob":{"10":"n","11":"n","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"n","11":"y"},"and_uc":{"9.9":"y"}},"notes":"Partial support in older Safari and other WebKit browsers refers to lacking FileReader support. ","notes_by_num":{},"usage_perc_y":83.25,"usage_perc_a":3.46,"ucprefix":false,"parent":"","keywords":"FileReader","ie_id":"","chrome_id":""},"shadowdom":{"title":"Shadow DOM","description":"Method of establishing and maintaining functional boundaries between DOM trees and how these trees interact with each other within a document, thus enabling better functional encapsulation within the DOM.","spec":"http://www.w3.org/TR/shadow-dom/","status":"wd","links":[{"url":"http://html5-demos.appspot.com/static/shadowdom-visualizer/index.html","title":"Shadow DOM Visualizer"},{"url":"http://www.html5rocks.com/tutorials/webcomponents/shadowdom/","title":"HTML5Rocks - Shadow DOM 101 article"}],"categories":["DOM"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n d #1","30":"n d #1","31":"n d #1","32":"n d #1","33":"n d #1","34":"n d #1","35":"n d #1","36":"n d #1","37":"n d #1","38":"n d #1"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"y x","26":"y x","27":"y x","28":"y x","29":"y x","30":"y x","31":"y x","32":"y x","33":"y x","34":"y x","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"n","7":"n","7.1":"n","8":"n"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"y x","16":"y x","17":"y x","18":"y x","19":"y x","20":"y x","21":"y x","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"n","8.1":"n"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"y x","4.4.3-4.4.4":"y x","37":"y"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"n"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"n"}},"notes":"","notes_by_num":{"1":"Supported in Firefox behind the `dom.webcomponents.enabled` flag."},"usage_perc_y":46.47,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"web components","ie_id":"shadowdomunprefixed","chrome_id":"4507242028072960"},"websockets":{"title":"Web Sockets","description":"Bidirectional communication technology for web apps","spec":"http://www.w3.org/TR/websockets/","status":"cr","links":[{"url":"http://websocket.org/aboutwebsocket.html","title":"WebSockets information"},{"url":"http://updates.html5rocks.com/2011/08/What-s-different-in-the-new-WebSocket-protocol","title":"Details on newer protocol"},{"url":"http://en.wikipedia.org/wiki/WebSocket","title":"Wikipedia"},{"url":"https://raw.github.com/phiggins42/has.js/master/detect/features.js#native-websockets","title":"has.js test"},{"url":"http://docs.webplatform.org/wiki/apis/websocket","title":"WebPlatform Docs"}],"categories":["JS API"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"y","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"a #1","5":"a #1","6":"a x #2","7":"a x #2","8":"a x #2","9":"a x #2","10":"a x #2","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"a #1","5":"a #1","6":"a #1","7":"a #1","8":"a #1","9":"a #1","10":"a #1","11":"a #1","12":"a #1","13":"a #1","14":"a #1","15":"a #2","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"a #1","5.1":"a #1","6":"a #2","6.1":"a #2","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"a #1","11.1":"a #1","11.5":"a #1","11.6":"a #1","12":"a #1","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"a #1","5.0-5.1":"a #1","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y #1","10":"y"},"op_mob":{"10":"n","11":"a #1","11.1":"a #1","11.5":"a #1","12":"a #1","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y"}},"notes":"","notes_by_num":{"1":"Partial support refers to the websockets implementation using an older version of the protocol and/or the implementation being disabled by default (due to security issues with the older protocol).","2":"Partial support refers to lacking support for binary data. "},"usage_perc_y":82.91,"usage_perc_a":1.52,"ucprefix":true,"parent":"","keywords":"","ie_id":"websocket","chrome_id":"6555138000945152"},"hidden":{"title":"hidden attribute","description":"The `hidden` attribute may be applied to any element, and effectively hides elements similar to `display: none` in CSS.","spec":"https://html.spec.whatwg.org/multipage/interaction.html#the-hidden-attribute","status":"ls","links":[{"url":"http://davidwalsh.name/html5-hidden","title":"Article on hidden attribute"}],"categories":["HTML5"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"y"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"n","10":"y"},"op_mob":{"10":"n","11":"n","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"n","11":"y"},"and_uc":{"9.9":"y"}},"notes":"The hidden state can be easily overridden with a CSS `display` property set to anything other than `none`.","notes_by_num":{},"usage_perc_y":88,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"","ie_id":"","chrome_id":""},"script-async":{"title":"async attribute for external scripts","description":"The boolean async attribute on script elements allows the external JavaScript file to run when it's available, without delaying page load first.","spec":"https://html.spec.whatwg.org/multipage/scripting.html#attr-script-async","status":"ls","links":[{"url":"https://developer.mozilla.org/en/HTML/Element/script#Attributes","title":"MDN article"},{"url":"http://ie.microsoft.com/testdrive/Performance/AsyncScripts/Default.html","title":"Demo"},{"url":"https://raw.github.com/phiggins42/has.js/master/detect/script.js#script-async","title":"has.js test"}],"categories":["DOM","HTML5"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"y","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"y","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"a","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"y","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y"}},"notes":"Using script.async = false; to maintain execution order for dynamically-added scripts isn't supported in Safari 5.0","notes_by_num":{},"usage_perc_y":86.78,"usage_perc_a":0.13,"ucprefix":false,"parent":"","keywords":"","ie_id":"","chrome_id":""},"cors":{"title":"Cross-Origin Resource Sharing","description":"Method of performing XMLHttpRequests across domains","spec":"http://www.w3.org/TR/cors/","status":"rec","links":[{"url":"http://hacks.mozilla.org/2009/07/cross-site-xmlhttprequest-with-cors/","title":"Mozilla Hacks blog post"},{"url":"http://msdn.microsoft.com/en-us/library/cc288060(VS.85).aspx","title":"Alternative implementation by IE8"},{"url":"https://dev.opera.com/articles/view/dom-access-control-using-cross-origin-resource-sharing/","title":"DOM access using CORS"},{"url":"https://raw.github.com/phiggins42/has.js/master/detect/features.js#native-cors-xhr","title":"has.js test"}],"categories":["JS API"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"a","9":"a","10":"y","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"y","3.6":"y","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"y","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"y","4.0-4.1":"y","4.2-4.3":"y","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"y","2.2":"y","2.3":"y","3":"y","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y"}},"notes":"Supported somewhat in IE8 and IE9 using the XDomainRequest object (but has [limitations]( http://blogs.msdn.com/b/ieinternals/archive/2010/05/13/xdomainrequest-restrictions-limitations-and-workarounds.aspx))","notes_by_num":{},"usage_perc_y":87.44,"usage_perc_a":6.21,"ucprefix":false,"parent":"","keywords":"","ie_id":"","chrome_id":""},"calc":{"title":"calc() as CSS unit value","description":"Method of allowing calculated values for length units, i.e. `width: calc(100% - 3em)`","spec":"http://www.w3.org/TR/css3-values/#calc","status":"cr","links":[{"url":"http://hacks.mozilla.org/2010/06/css3-calc/","title":"Mozilla Hacks article"},{"url":"https://developer.mozilla.org/en/CSS/-moz-calc","title":"MDN article"},{"url":"http://docs.webplatform.org/wiki/css/functions/calc","title":"WebPlatform Docs"}],"categories":["CSS3"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"a","10":"y","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"y x","5":"y x","6":"y x","7":"y x","8":"y x","9":"y x","10":"y x","11":"y x","12":"y x","13":"y x","14":"y x","15":"y x","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"y x","20":"y x","21":"y x","22":"y x","23":"y x","24":"y x","25":"y x","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"y x","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"y x","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"a","4.4.3-4.4.4":"a","37":"y"},"bb":{"7":"n","10":"y x"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"n"}},"notes":"Support can be somewhat emulated in older versions of IE using the non-standard `expression()` syntax. Partial support in IE9 refers to the browser crashing when used as a `background-position` value. Partial support in Android Browser 4.4 refers to the browser lacking the ability to multiply and divide values.","notes_by_num":{},"usage_perc_y":75.77,"usage_perc_a":5.66,"ucprefix":false,"parent":"","keywords":"","ie_id":"csscalc","chrome_id":"5765241438732288"},"ruby":{"title":"Ruby annotation","description":"Method of adding pronunciation or other annotations using ruby elements (primarily used in East Asian typography).","spec":"https://html.spec.whatwg.org/multipage/semantics.html#the-ruby-element","status":"ls","links":[{"url":"http://html5doctor.com/ruby-rt-rp-element/","title":"HTML5 Doctor article"},{"url":"http://docs.webplatform.org/wiki/html/elements/ruby","title":"WebPlatform Docs"},{"url":"https://addons.mozilla.org/firefox/addon/1935/","title":"Add-on \"XHTML Ruby Support\" for Firefox"},{"url":"https://addons.mozilla.org/firefox/addon/6812/","title":"Addon \"HTML Ruby\" for Firefox support"}],"categories":["HTML5"],"stats":{"ie":{"5.5":"a","6":"a","7":"a","8":"a","9":"a","10":"a","11":"a","TP":"a"},"firefox":{"2":"p","3":"p","3.5":"p","3.6":"p","4":"p","5":"p","6":"p","7":"p","8":"p","9":"p","10":"p","11":"p","12":"p","13":"p","14":"p","15":"p","16":"p","17":"p","18":"p","19":"p","20":"p","21":"p","22":"p","23":"p","24":"p","25":"p","26":"p","27":"p","28":"p","29":"p","30":"p","31":"p","32":"p","33":"p","34":"p","35":"p","36":"p","37":"p","38":"p"},"chrome":{"4":"p","5":"a","6":"a","7":"a","8":"a","9":"a","10":"a","11":"a","12":"a","13":"a","14":"a","15":"a","16":"a","17":"a","18":"a","19":"a","20":"a","21":"a","22":"a","23":"a","24":"a","25":"a","26":"a","27":"a","28":"a","29":"a","30":"a","31":"a","32":"a","33":"a","34":"a","35":"a","36":"a","37":"a","38":"a","39":"a","40":"a","41":"a","42":"a","43":"a"},"safari":{"3.1":"p","3.2":"p","4":"p","5":"a","5.1":"a","6":"a","6.1":"a","7":"a","7.1":"a","8":"a"},"opera":{"9":"p","9.5-9.6":"p","10.0-10.1":"p","10.5":"p","10.6":"p","11":"p","11.1":"p","11.5":"p","11.6":"p","12":"p","12.1":"p","15":"a","16":"a","17":"a","18":"a","19":"a","20":"a","21":"a","22":"a","23":"a","24":"a","25":"a","26":"a","27":"a","28":"a","29":"a"},"ios_saf":{"3.2":"p","4.0-4.1":"p","4.2-4.3":"p","5.0-5.1":"a","6.0-6.1":"a","7.0-7.1":"a","8":"a","8.1":"a"},"op_mini":{"5.0-8.0":"p"},"android":{"2.1":"p","2.2":"p","2.3":"p","3":"a","4":"a","4.1":"a","4.2-4.3":"a","4.4":"a","4.4.3-4.4.4":"a","37":"a"},"bb":{"7":"p","10":"a"},"op_mob":{"10":"p","11":"p","11.1":"p","11.5":"p","12":"p","12.1":"p","24":"a"},"and_chr":{"40":"a"},"and_ff":{"33":"p"},"ie_mob":{"10":"a","11":"a"},"and_uc":{"9.9":"a"}},"notes":"Browsers without native support can still simulate support using CSS. Partial support refers to only supporting basic ruby, may still be missing writing-mode, Complex ruby and CSS3 Ruby.","notes_by_num":{},"usage_perc_y":0,"usage_perc_a":81.38,"ucprefix":false,"parent":"","keywords":"","ie_id":"","chrome_id":""},"css-opacity":{"title":"CSS3 Opacity","description":"Method of setting the transparency level of an element","spec":"http://www.w3.org/TR/css3-color/","status":"rec","links":[{"url":"http://www.css3files.com/color/#opacity","title":"Information page"},{"url":"http://docs.webplatform.org/wiki/css/properties/opacity","title":"WebPlatform Docs"}],"categories":["CSS3"],"stats":{"ie":{"5.5":"a","6":"a","7":"a","8":"a","9":"y","10":"y","11":"y","TP":"y"},"firefox":{"2":"y","3":"y","3.5":"y","3.6":"y","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"y","3.2":"y","4":"y","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"y","9.5-9.6":"y","10.0-10.1":"y","10.5":"y","10.6":"y","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"y","4.0-4.1":"y","4.2-4.3":"y","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"y"},"android":{"2.1":"y","2.2":"y","2.3":"y","3":"y","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"y","11":"y","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y"}},"notes":"Transparency for elements in IE8 and older can be achieved using the proprietary \"filter\" property and does not work well with PNG images using alpha transparency.","notes_by_num":{},"usage_perc_y":92.77,"usage_perc_a":4.35,"ucprefix":false,"parent":"","keywords":"transparent,transparency,alpha","ie_id":"","chrome_id":""},"form-validation":{"title":"Form validation","description":"Method of setting required fields and field types without requiring JavaScript.","spec":"https://html.spec.whatwg.org/multipage/forms.html#client-side-form-validation","status":"ls","links":[{"url":"http://docs.webplatform.org/wiki/html/attributes/required","title":"WebPlatform Docs"}],"categories":["HTML5"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"y","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"a","5.1":"a","6":"a","6.1":"a","7":"a","7.1":"a","8":"a"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"y","10.5":"y","10.6":"y","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"n","8.1":"n"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"n","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"n","10":"y"},"op_mob":{"10":"y","11":"y","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"a","11":"a"},"and_uc":{"9.9":"y"}},"notes":"Partial support in Safari refers to lack of notice when form with required fields is attempted to be submitted. Partial support in IE10 mobile refers to lack of warning when blocking submission.","notes_by_num":{},"usage_perc_y":70.42,"usage_perc_a":3.66,"ucprefix":false,"parent":"forms","keywords":"","ie_id":"","chrome_id":"6091813840486400"},"history":{"title":"Session history management","description":"Method of manipulating the user's browser's session history in JavaScript using history.pushState, history.replaceState and the popstate event.","spec":"https://html.spec.whatwg.org/multipage/browsers.html#dom-history-pushstate","status":"ls","links":[{"url":"http://www.adequatelygood.com/2010/7/Saner-HTML5-History-Management","title":"Introduction to history management"},{"url":"https://developer.mozilla.org/en/DOM/Manipulating_the_browser_history","title":"MDN article"},{"url":"http://html5demos.com/history","title":"Demo page"},{"url":"https://github.com/browserstate/history.js","title":"History.js polyfill "},{"url":"https://raw.github.com/phiggins42/has.js/master/detect/features.js#native-history-state","title":"has.js test"},{"url":"http://docs.webplatform.org/wiki/dom/History","title":"WebPlatform Docs"}],"categories":["HTML5"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"y","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"a","5.1":"a","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"a","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"y","2.3":"y","3":"n","4":"n","4.1":"n","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"n","11":"n","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"a"}},"notes":"Older iOS versions and Android 4.0.4 claim support, but implementation is too buggy to be useful.","notes_by_num":{},"usage_perc_y":81.72,"usage_perc_a":4.31,"ucprefix":false,"parent":"","keywords":"onpushstate,onreplacestate","ie_id":"","chrome_id":""},"json":{"title":"JSON parsing","description":"Method of converting JavaScript objects to JSON strings and JSON back to objects using JSON.stringify() and JSON.parse()","spec":"http://es5.github.com/#x15.12","status":"other","links":[{"url":"https://developer.mozilla.org/En/Using_native_JSON","title":"MDN article"},{"url":"http://www.json.org/js.html","title":"JSON in JS (includes script w/support)"},{"url":"https://raw.github.com/phiggins42/has.js/master/detect/json.js#json","title":"has.js test"},{"url":"http://docs.webplatform.org/wiki/apis/json","title":"WebPlatform Docs"}],"categories":["JS API"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"y","9":"y","10":"y","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"y","3.6":"y","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"y","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"y","10.6":"y","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"y","4.2-4.3":"y","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"y"},"android":{"2.1":"y","2.2":"y","2.3":"y","3":"y","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"y","11":"y","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y"}},"notes":"Requires document to be in IE8+ [standards mode](http://msdn.microsoft.com/en-us/library/cc288325%28VS.85%29.aspx) to work in IE8.","notes_by_num":{},"usage_perc_y":96.78,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"","ie_id":"","chrome_id":""},"classlist":{"title":"classList (DOMTokenList )","description":"Method of easily manipulating classes on elements, using the DOMTokenList object.","spec":"http://www.w3.org/TR/dom/#dom-element-classlist","status":"wd","links":[{"url":"http://hacks.mozilla.org/2010/01/classlist-in-firefox-3-6/","title":"Mozilla Hacks article"},{"url":"https://github.com/eligrey/classList.js","title":"Polyfill script"},{"url":"http://docs.webplatform.org/wiki/dom/Element/classList","title":"WebPlatform Docs"},{"url":"http://www.sitepoint.com/exploring-classlist-api/","title":"SitePoint article"},{"url":"http://aurelio.audero.it/demo/classlist-api-demo.html","title":"Demo using classList"}],"categories":["DOM","HTML5"],"stats":{"ie":{"5.5":"p","6":"p","7":"p","8":"p","9":"p","10":"y","11":"y","TP":"y"},"firefox":{"2":"p","3":"p","3.5":"p","3.6":"y","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"p","5":"p","6":"p","7":"p","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"p","3.2":"p","4":"p","5":"p","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"p","9.5-9.6":"p","10.0-10.1":"p","10.5":"p","10.6":"p","11":"p","11.1":"p","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"p","4.0-4.1":"p","4.2-4.3":"p","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"p"},"android":{"2.1":"p","2.2":"p","2.3":"p","3":"y","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"p","11":"p","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y"}},"notes":"","notes_by_num":{},"usage_perc_y":87.04,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"","ie_id":"","chrome_id":""},"text-overflow":{"title":"CSS3 Text-overflow","description":"Append ellipsis when text overflows its containing element","spec":"http://www.w3.org/TR/css3-ui/#text-overflow0","status":"wd","links":[{"url":"https://github.com/rmorse/AutoEllipsis","title":"jQuery polyfill for Firefox"},{"url":"https://developer.mozilla.org/En/CSS/Text-overflow","title":"MDN article"},{"url":"http://www.css3files.com/text/","title":"Information page"},{"url":"https://raw.github.com/phiggins42/has.js/master/detect/css.js#css-text-overflow","title":"has.js test"},{"url":"http://docs.webplatform.org/wiki/css/properties/text-overflow","title":"WebPlatform Docs"}],"categories":["CSS3"],"stats":{"ie":{"5.5":"n","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","TP":"y"},"firefox":{"2":"p","3":"p","3.5":"p","3.6":"p","4":"p","5":"p","6":"p","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"y","3.2":"y","4":"y","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"y x","9.5-9.6":"y x","10.0-10.1":"y x","10.5":"y x","10.6":"y x","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"y","4.0-4.1":"y","4.2-4.3":"y","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"y"},"android":{"2.1":"y","2.2":"y","2.3":"y","3":"y","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"y x","11":"y x","11.1":"y x","11.5":"y x","12":"y x","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y"}},"notes":"","notes_by_num":{},"usage_perc_y":96.91,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"textoverflow,ellipsis","ie_id":"","chrome_id":""},"webm":{"title":"WebM video format","description":"Multimedia format designed to provide a royalty-free, high-quality open video compression format for use with HTML5 video. WebM supports the video codec VP8 and VP9.","spec":"http://www.webmproject.org/","status":"other","links":[{"url":"https://tools.google.com/dlpage/webmmf","title":"Codec for IE9 support"},{"url":"http://www.broken-links.com/2010/09/01/playing-webm-in-safari-with-plugins/","title":"Info on supporting WebM in Safari"},{"url":"http://webmproject.org","title":"Official website"},{"url":"https://raw.github.com/phiggins42/has.js/master/detect/video.js#video-webm","title":"has.js test"},{"url":"http://perian.org/","title":"Perian :Mac OSX Webm Codec install"}],"categories":["Other"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"p","10":"p","11":"p","TP":"p"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"a","5":"a","6":"a","7":"a","8":"a","9":"a","10":"a","11":"a","12":"a","13":"a","14":"a","15":"a","16":"a","17":"a","18":"a","19":"a","20":"a","21":"a","22":"a","23":"a","24":"a","25":"a","26":"a","27":"a","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"a","7":"a","8":"a","9":"a","10":"a","11":"a","12":"a","13":"a","14":"a","15":"a","16":"a","17":"a","18":"a","19":"a","20":"a","21":"a","22":"a","23":"a","24":"a","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"p","4":"p","5":"p","5.1":"p","6":"p","6.1":"p","7":"p","7.1":"p","8":"p"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"a","11":"a","11.1":"a","11.5":"a","11.6":"a","12":"a","12.1":"a","15":"a","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"n","8.1":"n"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"a","3":"a","4":"a","4.1":"a","4.2-4.3":"a","4.4":"a","4.4.3-4.4.4":"a","37":"a"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"a"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"p","11":"p"},"and_uc":{"9.9":"y"}},"notes":"Will work in IE9+ and Safari/MacOSX provided the user has the WebM codecs installed. Partial support indicates that at least one codec is supported but not all.","notes_by_num":{},"usage_perc_y":57.62,"usage_perc_a":8.23,"ucprefix":false,"parent":"video","keywords":"matroska","ie_id":"","chrome_id":"6362186595172352"},"mpeg4":{"title":"MPEG-4/H.264 video format","description":"Commonly used video compression format (not royalty-free)","spec":"http://ip.hhi.de/imagecom_G1/assets/pdfs/csvt_overview_0305.pdf","status":"other","links":[{"url":"http://en.wikipedia.org/wiki/H.264/MPEG-4_AVC","title":"Wikipedia article"},{"url":"http://www.interoperabilitybridges.com/html5-extension-for-wmp-plugin","title":"Firefox extension allowing support in Win7"}],"categories":["Other"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"y","10":"y","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"a","22":"a","23":"a","24":"a","25":"a","26":"a","27":"a","28":"a","29":"a","30":"a","31":"a","32":"a","33":"a","34":"a","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"y","4":"y","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"y","4.0-4.1":"y","4.2-4.3":"y","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"a","2.2":"a","2.3":"a","3":"a","4":"a","4.1":"a","4.2-4.3":"a","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"n","11":"y","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"a"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"a"}},"notes":"The Android 2.3 browser currently requires [specific handling](http://www.broken-links.com/2010/07/08/making-html5-video-work-on-android-phones/) to play videos\r\n\r\nFirefox supports H.264 on Windows 7 and later since version 21. Firefox supports H.264 on Linux since version 26 if the appropriate gstreamer plug-ins are installed.\r\n\r\nPartial support for Firefox refers to the lack of support in OSX & some Linux platforms, for Android Firefox it refers to the inability of hardware acceleration.","notes_by_num":{},"usage_perc_y":70.89,"usage_perc_a":17.74,"ucprefix":false,"parent":"video","keywords":"avc,mp4,mpv,mov,aac,h264","ie_id":"","chrome_id":""},"ogv":{"title":"Ogg/Theora video format","description":"Free lossy video compression format.","spec":"http://theora.org/doc/","status":"other","links":[{"url":"http://en.wikipedia.org/wiki/Theora","title":"Wikipedia article"}],"categories":["Other"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"p","10":"p","11":"p","TP":"p"},"firefox":{"2":"n","3":"n","3.5":"y","3.6":"y","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"n","7":"n","7.1":"n","8":"n"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"y","10.6":"y","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"n","8.1":"n"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"n","4.4.3-4.4.4":"n","37":"n"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"n"},"and_chr":{"40":"n"},"and_ff":{"33":"y"},"ie_mob":{"10":"p","11":"p"},"and_uc":{"9.9":"y"}},"notes":"","notes_by_num":{},"usage_perc_y":49.06,"usage_perc_a":0,"ucprefix":false,"parent":"video","keywords":"xiph","ie_id":"","chrome_id":""},"wordwrap":{"title":"CSS3 Overflow-wrap","description":"Allows lines to be broken within words if an otherwise unbreakable string is too long to fit. Currently mostly supported using the `word-wrap` property.","spec":"http://www.w3.org/TR/css3-text/#overflow-wrap","status":"wd","links":[{"url":"https://developer.mozilla.org/En/CSS/Word-wrap","title":"MDN article"},{"url":"http://www.css3files.com/text/#wordwrap","title":"Information page"},{"url":"http://docs.webplatform.org/wiki/css/properties/word-wrap","title":"WebPlatform Docs"}],"categories":["CSS3"],"stats":{"ie":{"5.5":"a","6":"a","7":"a","8":"a","9":"a","10":"a","11":"a","TP":"a"},"firefox":{"2":"n","3":"n","3.5":"a","3.6":"a","4":"a","5":"a","6":"a","7":"a","8":"a","9":"a","10":"a","11":"a","12":"a","13":"a","14":"a","15":"a","16":"a","17":"a","18":"a","19":"a","20":"a","21":"a","22":"a","23":"a","24":"a","25":"a","26":"a","27":"a","28":"a","29":"a","30":"a","31":"a","32":"a","33":"a","34":"a","35":"a","36":"a","37":"a","38":"a"},"chrome":{"4":"a","5":"a","6":"a","7":"a","8":"a","9":"a","10":"a","11":"a","12":"a","13":"a","14":"a","15":"a","16":"a","17":"a","18":"a","19":"a","20":"a","21":"a","22":"a","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"a","3.2":"a","4":"a","5":"a","5.1":"a","6":"a","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"a","10.6":"a","11":"a","11.1":"a","11.5":"a","11.6":"a","12":"a","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"a","4.0-4.1":"a","4.2-4.3":"a","5.0-5.1":"a","6.0-6.1":"a","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"a"},"android":{"2.1":"a","2.2":"a","2.3":"a","3":"a","4":"a","4.1":"a","4.2-4.3":"a","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"a","10":"y"},"op_mob":{"10":"a","11":"a","11.1":"a","11.5":"a","12":"a","12.1":"a","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"a"},"ie_mob":{"10":"a","11":"a"},"and_uc":{"9.9":"a"}},"notes":"Partial support refers to requiring the legacy name \"word-wrap\" (rather than overflow-wrap) to work.","notes_by_num":{},"usage_perc_y":56.48,"usage_perc_a":40.58,"ucprefix":false,"parent":"","keywords":"wordwrap,word-wrap","ie_id":"","chrome_id":""},"progressmeter":{"title":"Progress & Meter","description":"Method of indicating a progress state (progress element) or the current level of a gauge (meter element).\r\n","spec":"https://html.spec.whatwg.org/multipage/forms.html#the-progress-element","status":"ls","links":[{"url":"https://dev.opera.com/articles/new-form-features-in-html5/#newoutput","title":"Dev.Opera article"},{"url":"http://html5doctor.com/measure-up-with-the-meter-tag/","title":"HTML5 Doctor on meter element"},{"url":"http://peter.sh/examples/?/html/meter-progress.html","title":"Examples of progress and meter elements"},{"url":"http://docs.webplatform.org/wiki/html/elements/progress","title":"WebPlatform Docs"}],"categories":["HTML5"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"a","11":"a","TP":"a"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"a","7":"a","8":"a","9":"a","10":"a","11":"a","12":"a","13":"a","14":"a","15":"a","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"a","8":"a","8.1":"a"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"n","11":"y","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"a","11":"a"},"and_uc":{"9.9":"y"}},"notes":"Partial support in Firefox 6-15, IE10 & iOS7 Safari refers to supporting the progress element, but not the meter element. iOS7 Safari also does not support \"indeterminate\" progress elements.\r\n\r\nFor styling progress bars, [see this article](http://css-tricks.com/html5-progress-element/)","notes_by_num":{},"usage_perc_y":65.08,"usage_perc_a":18.47,"ucprefix":false,"parent":"forms","keywords":"","ie_id":"","chrome_id":""},"object-fit":{"title":"CSS3 object-fit/object-position","description":"Method of specifying how an object (image or video) should fit inside its box. object-fit options include \"contain\" (fit according to aspect ratio), \"fill\" (stretches object to fill) and \"cover\" (overflows box but maintains ratio), where object-position allows the object to be repositioned like background-image does.","spec":"http://www.w3.org/TR/css3-images/","status":"cr","links":[{"url":"https://dev.opera.com/articles/view/css3-object-fit-object-position/","title":"Dev.Opera article"},{"url":"http://docs.webplatform.org/wiki/css/properties/object-fit","title":"WebPlatform Docs"},{"url":"https://github.com/anselmh/object-fit","title":"object-fit JavaScript-Polyfill"}],"categories":["CSS3"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"n","34":"n","35":"n","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"n","7":"n","7.1":"a #1","8":"a #1"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"y x","11":"y x","11.1":"y x","11.5":"y x","11.6":"y x","12":"y x","12.1":"y x","15":"n","16":"n","17":"n","18":"n","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"a #1","8.1":"a #1"},"op_mini":{"5.0-8.0":"y x"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"n","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"n","11":"y x","11.1":"y x","11.5":"y x","12":"y x","12.1":"y x","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"n"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"n"}},"notes":"","notes_by_num":{"1":"Partial support in Safari refers to support for `object-fit` but not `object-position`."},"usage_perc_y":46.87,"usage_perc_a":6.79,"ucprefix":false,"parent":"","keywords":"objectfit,objectposition","ie_id":"objectfitandobjectposition","chrome_id":"5302669702856704"},"xhr2":{"title":"XMLHttpRequest 2","description":"Adds more functionality to AJAX requests like file uploads, transfer progress information and the ability to send form data.","spec":"http://www.w3.org/TR/XMLHttpRequest2/","status":"wd","links":[{"url":"https://developer.mozilla.org/en/XMLHttpRequest/FormData","title":"MDN article on FormData"},{"url":"https://github.com/3nr1c/jUri.js","title":"Polyfill for FormData object"},{"url":"http://docs.webplatform.org/wiki/apis/xhr/XMLHttpRequest","title":"WebPlatform Docs"}],"categories":["DOM","JS API"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"y","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"a","3.6":"a","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"u","5":"u","6":"u","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"y","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y"}},"notes":"","notes_by_num":{},"usage_perc_y":87.07,"usage_perc_a":0.11,"ucprefix":false,"parent":"","keywords":"formdata","ie_id":"","chrome_id":""},"minmaxwh":{"title":"CSS min/max-width/height","description":"Method of setting a minimum or maximum width or height to an element. ","spec":"http://www.w3.org/TR/CSS21/visudet.html#min-max-widths","status":"rec","links":[{"url":"http://code.google.com/p/ie7-js/","title":"JS library with support"},{"url":"http://docs.webplatform.org/wiki/css/properties/min-width","title":"WebPlatform Docs"},{"url":"http://www.impressivewebs.com/min-max-width-height-css/","title":"CSS Basics post"}],"categories":["CSS2"],"stats":{"ie":{"5.5":"p","6":"p","7":"y","8":"y","9":"y","10":"y","11":"y","TP":"y"},"firefox":{"2":"y","3":"y","3.5":"y","3.6":"y","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"y","3.2":"y","4":"y","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"y","9.5-9.6":"y","10.0-10.1":"y","10.5":"y","10.6":"y","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"y","4.0-4.1":"y","4.2-4.3":"y","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"y"},"android":{"2.1":"y","2.2":"y","2.3":"y","3":"y","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"y","11":"y","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y"}},"notes":"IE7 does not support \"inherit\" as a value on any of these properties. IE8 has some bugs with max-width/height combined with overflow: auto/scroll.","notes_by_num":{},"usage_perc_y":97.04,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"min-width,min-height,max-width,max-height","ie_id":"","chrome_id":""},"details":{"title":"Details & Summary elements","description":"The <details> element generates a simple no-JavaScript widget to show/hide element contents, optionally by clicking on its child <summary> element.","spec":"https://html.spec.whatwg.org/multipage/forms.html#the-details-element","status":"ls","links":[{"url":"https://mathiasbynens.be/notes/html5-details-jquery","title":"jQuery fallback script"},{"url":"https://gist.github.com/370590","title":"Fallback script"},{"url":"http://html5doctor.com/summary-figcaption-element/","title":"HTML5 Doctor article"},{"url":"https://raw.github.com/phiggins42/has.js/master/detect/features.js#native-details","title":"has.js test"},{"url":"http://docs.webplatform.org/wiki/html/elements/details","title":"WebPlatform Docs"}],"categories":["HTML5"],"stats":{"ie":{"5.5":"n","6":"p","7":"p","8":"p","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"p","3.5":"p","3.6":"p","4":"p","5":"p","6":"p","7":"p","8":"p","9":"p","10":"p","11":"p","12":"p","13":"p","14":"p","15":"p","16":"p","17":"p","18":"p","19":"p","20":"p","21":"p","22":"p","23":"p","24":"p","25":"p","26":"p","27":"p","28":"p","29":"p","30":"p","31":"p","32":"p","33":"p","34":"p","35":"p","36":"p","37":"p","38":"p"},"chrome":{"4":"p","5":"p","6":"p","7":"p","8":"p","9":"p","10":"p","11":"p","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"p","3.2":"p","4":"p","5":"p","5.1":"p","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"p","9.5-9.6":"p","10.0-10.1":"p","10.5":"p","10.6":"p","11":"p","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"p","4.0-4.1":"p","4.2-4.3":"p","5.0-5.1":"p","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"p"},"android":{"2.1":"p","2.2":"p","2.3":"p","3":"p","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"p","10":"y"},"op_mob":{"10":"p","11":"p","11.1":"p","11.5":"p","12":"p","12.1":"p","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"p"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"y"}},"notes":"","notes_by_num":{},"usage_perc_y":63.43,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"","ie_id":"detailssummary","chrome_id":"5348024557502464"},"text-stroke":{"title":"CSS text-stroke","description":"Method of declaring the outline (stroke) width and color for text.","spec":"http://developer.apple.com/library/safari/documentation/appleapplications/reference/SafariCSSRef/Articles/StandardCSSProperties.html#//apple_ref/doc/uid/TP30001266-_webkit_text_stroke","status":"unoff","links":[{"url":"http://css-tricks.com/7405-adding-stroke-to-web-text/","title":"Information & workarounds"},{"url":"http://www.westciv.com/tools/textStroke/","title":"Live editor"}],"categories":["CSS"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"n","34":"n","35":"n","36":"u","37":"u","38":"u"},"chrome":{"4":"y x","5":"y x","6":"y x","7":"y x","8":"y x","9":"y x","10":"y x","11":"y x","12":"y x","13":"y x","14":"y x","15":"y x","16":"y x","17":"y x","18":"y x","19":"y x","20":"y x","21":"y x","22":"y x","23":"y x","24":"y x","25":"y x","26":"y x","27":"y x","28":"y x","29":"y x","30":"y x","31":"y x","32":"y x","33":"y x","34":"y x","35":"y x","36":"y x","37":"y x","38":"y x","39":"y x","40":"y x","41":"y x","42":"y x","43":"y x"},"safari":{"3.1":"y x","3.2":"y x","4":"y x","5":"y x","5.1":"y x","6":"y x","6.1":"y x","7":"y x","7.1":"y x","8":"y x"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"y x","16":"y x","17":"y x","18":"y x","19":"y x","20":"y x","21":"y x","22":"y x","23":"y x","24":"y x","25":"y x","26":"y x","27":"y x","28":"y x","29":"y x"},"ios_saf":{"3.2":"a x","4.0-4.1":"y x","4.2-4.3":"y x","5.0-5.1":"y x","6.0-6.1":"y x","7.0-7.1":"y x","8":"y x","8.1":"y x"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"y x","2.2":"y x","2.3":"y x","3":"n","4":"y x","4.1":"y x","4.2-4.3":"y x","4.4":"y x","4.4.3-4.4.4":"y x","37":"y x"},"bb":{"7":"y x","10":"y x"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"y x"},"and_chr":{"40":"y x"},"and_ff":{"33":"n"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"n"}},"notes":"Does not yet appear in any W3C specification. Was briefly included in a spec as the \"text-outline\" property, but this was removed.","notes_by_num":{},"usage_perc_y":60.75,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"textstroke,stroke-color,stroke-width,fill-color","ie_id":"","chrome_id":""},"inline-block":{"title":"CSS inline-block","description":"Method of displaying an element as a block while flowing it with text. ","spec":"http://www.w3.org/TR/CSS21/visuren.html#fixed-positioning","status":"rec","links":[{"url":"http://robertnyman.com/2010/02/24/css-display-inline-block-why-it-rocks-and-why-it-sucks/","title":"Blog post w/info"},{"url":"http://blog.mozilla.com/webdev/2009/02/20/cross-browser-inline-block/","title":"Info on cross browser support"},{"url":"http://docs.webplatform.org/wiki/css/properties/display","title":"WebPlatform Docs"}],"categories":["CSS2"],"stats":{"ie":{"5.5":"a","6":"a","7":"a","8":"y","9":"y","10":"y","11":"y","TP":"y"},"firefox":{"2":"a x","3":"y","3.5":"y","3.6":"y","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"y","3.2":"y","4":"y","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"y","9.5-9.6":"y","10.0-10.1":"y","10.5":"y","10.6":"y","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"y","4.0-4.1":"y","4.2-4.3":"y","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"y"},"android":{"2.1":"y","2.2":"y","2.3":"y","3":"y","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"y","11":"y","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y"}},"notes":"Only supported in IE6 and IE7 on elements with a display of \"inline\" by default. [Alternative properties](http://blog.mozilla.com/webdev/2009/02/20/cross-browser-inline-block/) are available to provide complete cross-browser support.","notes_by_num":{},"usage_perc_y":96.84,"usage_perc_a":0.28,"ucprefix":false,"parent":"","keywords":"inlineblock","ie_id":"","chrome_id":""},"notifications":{"title":"Web Notifications","description":"Method of alerting the user outside of a web page by displaying notifications (that do not require interaction by the user).","spec":"http://www.w3.org/TR/notifications/","status":"wd","links":[{"url":"http://www.html5rocks.com/tutorials/notifications/quick/","title":"HTML5 Rocks tutorial"},{"url":"http://www.chromium.org/developers/design-documents/desktop-notifications/api-specification","title":"Chromium API"},{"url":"https://addons.mozilla.org/en-us/firefox/addon/221523/","title":"Add-on "},{"url":"https://developer.mozilla.org/en-US/docs/Web/API/notification","title":"MDN Notifications"},{"url":"http://www.sitepoint.com/introduction-web-notifications-api/","title":"SitePoint article"},{"url":"http://aurelio.audero.it/demo/web-notifications-api-demo.html","title":"Demo"}],"categories":["JS API"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"a x","6":"a x","7":"a x","8":"a x","9":"a x","10":"a x","11":"a x","12":"a x","13":"a x","14":"a x","15":"a x","16":"a x","17":"a x","18":"a x","19":"a x","20":"a x","21":"a x","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"n","8.1":"n"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"a x","4.4.3-4.4.4":"a x","37":"a x"},"bb":{"7":"n","10":"y"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"a x"},"and_chr":{"40":"n"},"and_ff":{"33":"y"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"n"}},"notes":"","notes_by_num":{},"usage_perc_y":46.13,"usage_perc_a":4.01,"ucprefix":false,"parent":"","keywords":"","ie_id":"webnotifications","chrome_id":"5064350557536256"},"stream":{"title":"getUserMedia/Stream API","description":"Method of accessing external device data (such as a webcam video stream). Formerly this was envisioned as the <device> element.","spec":"http://www.w3.org/TR/mediacapture-streams/","status":"wd","links":[{"url":"https://dev.opera.com/blog/webcam-orientation-preview/","title":"Technology preview from Opera"},{"url":"http://docs.webplatform.org/wiki/dom/Navigator/getUserMedia","title":"WebPlatform Docs"}],"categories":["JS API"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"y x","18":"y x","19":"y x","20":"y x","21":"y x","22":"y x","23":"y x","24":"y x","25":"y x","26":"y x","27":"y x","28":"y x","29":"y x","30":"y x","31":"y x","32":"y x","33":"y x","34":"y x","35":"y x","36":"y x","37":"y x","38":"y x"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"y x","22":"y x","23":"y x","24":"y x","25":"y x","26":"y x","27":"y x","28":"y x","29":"y x","30":"y x","31":"y x","32":"y x","33":"y x","34":"y x","35":"y x","36":"y x","37":"y x","38":"y x","39":"y x","40":"y x","41":"y x","42":"y x","43":"y x"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"n","7":"n","7.1":"n","8":"n"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"y","12.1":"y","15":"n","16":"n","17":"n","18":"y x","19":"y x","20":"y x","21":"y x","22":"y x","23":"y x","24":"y x","25":"y x","26":"y x","27":"y x","28":"y x","29":"y x"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"n","8.1":"n"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"n","4.4.3-4.4.4":"n","37":"y x"},"bb":{"7":"n","10":"y x"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"y","12.1":"y","24":"y x"},"and_chr":{"40":"y x"},"and_ff":{"33":"y x"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"y x"}},"notes":"","notes_by_num":{},"usage_perc_y":58.59,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"camera,device,getUserMedia,media stream,Media Capture API","ie_id":"mediacaptureandstreams","chrome_id":"6067380039974912,6605041225957376"},"svg-img":{"title":"SVG in HTML img element","description":"Method of displaying SVG images in HTML using <img>.","spec":"https://html.spec.whatwg.org/multipage/embedded-content.html","status":"ls","links":[{"url":"http://blog.dholbert.org/2010/10/svg-as-image.html","title":"Blog post with examples"},{"url":"http://www.codedread.com/blog/","title":"Blog with SVGs an images"}],"categories":["SVG"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"y","10":"y","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"a","4":"y","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"y","9.5-9.6":"y","10.0-10.1":"y","10.5":"y","10.6":"y","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"a","4.0-4.1":"y","4.2-4.3":"y","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"y"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"y","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"y","11":"y","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y"}},"notes":"","notes_by_num":{},"usage_perc_y":92.47,"usage_perc_a":0.01,"ucprefix":false,"parent":"","keywords":"svg-as-img,svg-in-img","ie_id":"","chrome_id":""},"datalist":{"title":"Datalist element","description":"Method of setting a list of options for a user to select in a text field, while leaving the ability to enter a custom value.","spec":"https://html.spec.whatwg.org/multipage/forms.html#the-datalist-element","status":"ls","links":[{"url":"http://hacks.mozilla.org/2010/11/firefox-4-html5-forms/","title":"Mozilla Hacks article"},{"url":"http://afarkas.github.com/webshim/demos/","title":"HTML5 Library including datalist support"},{"url":"https://developer.mozilla.org/en/HTML/Element/datalist","title":"MDN reference"},{"url":"http://docs.webplatform.org/wiki/html/elements/datalist","title":"WebPlatform Docs"},{"url":"http://demo.agektmr.com/datalist/","title":"Eiji Kitamura's options demos & tests"},{"url":"http://github.com/thgreasi/datalist-polyfill","title":"Minimal Datalist polyfill w/tutorial"}],"categories":["HTML5"],"stats":{"ie":{"5.5":"n","6":"p","7":"p","8":"p","9":"p","10":"a","11":"a","TP":"a"},"firefox":{"2":"p","3":"p","3.5":"p","3.6":"p","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"p","5":"p","6":"p","7":"p","8":"p","9":"p","10":"p","11":"p","12":"p","13":"p","14":"p","15":"p","16":"p","17":"p","18":"p","19":"n","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"p","3.2":"p","4":"p","5":"p","5.1":"p","6":"n","6.1":"n","7":"n","7.1":"n","8":"n"},"opera":{"9":"y","9.5-9.6":"y","10.0-10.1":"y","10.5":"y","10.6":"y","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"p","4.0-4.1":"p","4.2-4.3":"p","5.0-5.1":"p","6.0-6.1":"p","7.0-7.1":"p","8":"p","8.1":"p"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"p","2.2":"p","2.3":"p","3":"p","4":"p","4.1":"p","4.2-4.3":"p","4.4":"p","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"p","10":"y"},"op_mob":{"10":"y","11":"y","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"p"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"p","11":"p"},"and_uc":{"9.9":"y"}},"notes":"Partial support in IE10 refers to [significantly buggy behavior](http://playground.onereason.eu/2013/04/ie10s-lousy-support-for-datalists/).","notes_by_num":{},"usage_perc_y":60.14,"usage_perc_a":9.97,"ucprefix":false,"parent":"forms","keywords":"list attribute","ie_id":"datalistelement","chrome_id":"6090950820495360"},"dataset":{"title":"dataset & data-* attributes","description":"Method of applying and accessing custom data to elements.","spec":"https://html.spec.whatwg.org/multipage/dom.html#embedding-custom-non-visible-data-with-the-data-*-attributes","status":"ls","links":[{"url":"http://html5doctor.com/html5-custom-data-attributes/","title":"HTML5 Doctor article"},{"url":"http://html5demos.com/dataset","title":"Demo using dataset"},{"url":"https://raw.github.com/phiggins42/has.js/master/detect/dom.js#dom-dataset","title":"has.js test"},{"url":"http://docs.webplatform.org/wiki/html/attributes/data-*","title":"WebPlatform Docs"},{"url":"https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement.dataset","title":"MDN Reference - dataset"},{"url":"https://developer.mozilla.org/en-US/docs/Web/Guide/HTML/Using_data_attributes","title":"MDN Guide - Using data-* attributes"}],"categories":["HTML5"],"stats":{"ie":{"5.5":"a","6":"a","7":"a","8":"a","9":"a","10":"a","11":"y","TP":"y"},"firefox":{"2":"a","3":"a","3.5":"a","3.6":"a","4":"a","5":"a","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"a","5":"a","6":"a","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"a","3.2":"a","4":"a","5":"a","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"a","9.5-9.6":"a","10.0-10.1":"a","10.5":"a","10.6":"a","11":"a","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"a","4.0-4.1":"a","4.2-4.3":"a","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"a"},"android":{"2.1":"a","2.2":"a","2.3":"a","3":"y","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"a","11":"a","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"a","11":"y"},"and_uc":{"9.9":"y"}},"notes":"Partial support refers to being able to use `data-*` attributes and access them using `getAttribute`. \r\n\r\n\"Supported\" refers to accessing the values using the `dataset` property. Current spec only refers to support on HTML elements, only some browsers also have support for SVG/MathML elements.","notes_by_num":{},"usage_perc_y":84.96,"usage_perc_a":12.16,"ucprefix":false,"parent":"","keywords":"DOMStringMap","ie_id":"","chrome_id":""},"css-grid":{"title":"CSS Grid Layout","description":"Method of using a grid concept to lay out content, providing a mechanism for authors to divide available space for lay out into columns and rows using a set of predictable sizing behaviors","spec":"http://www.w3.org/TR/css3-grid-layout/","status":"wd","links":[{"url":"http://blogs.msdn.com/b/ie/archive/2011/04/14/ie10-platform-preview-and-css-features-for-adaptive-layouts.aspx","title":"IE Blog post"},{"url":"https://bugs.webkit.org/show_bug.cgi?id=60731","title":"Webkit (Chrome, Safari, etc.) feature request"},{"url":"https://bugzilla.mozilla.org/show_bug.cgi?id=616605","title":"Mozilla (Firefox) feature request"},{"url":"https://github.com/codler/Grid-Layout-Polyfill","title":"Polyfill based on old spec"},{"url":"https://github.com/FremyCompany/css-grid-polyfill/","title":"Polyfill based on new spec"}],"categories":["CSS"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"p","10":"a x #2","11":"a x #2","TP":"a x #2"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"p","20":"p","21":"p","22":"p","23":"p","24":"p","25":"p","26":"p","27":"p","28":"p","29":"p","30":"p","31":"p","32":"p","33":"p","34":"p","35":"p","36":"u","37":"u","38":"u"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"p","26":"p","27":"p","28":"p","29":"p d #1","30":"p d #1","31":"p d #1","32":"p d #1","33":"p d #1","34":"p d #1","35":"p d #1","36":"p d #1","37":"p d #1","38":"p d #1","39":"p d #1","40":"p d #1","41":"p d #1","42":"p d #1","43":"p d #1"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"p","6.1":"p","7":"p","7.1":"p","8":"p"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"p d #1","29":"p d #1"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"p","7.0-7.1":"p","8":"p","8.1":"p"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"p","4.4":"p","4.4.3-4.4.4":"p","37":"p"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"p"},"and_chr":{"40":"p"},"and_ff":{"33":"p"},"ie_mob":{"10":"a x #2","11":"a x #2"},"and_uc":{"9.9":"n"}},"notes":"","notes_by_num":{"1":"Enabled in Chrome through the \"experimental Web Platform features\" flag in chrome://flags","2":"Partial support in IE refers to supporting an [older version](http://www.w3.org/TR/2011/WD-css3-grid-layout-20110407/) of the specification."},"usage_perc_y":0,"usage_perc_a":10.71,"ucprefix":false,"parent":"","keywords":"grids,grid-row,grid-column","ie_id":"grid","chrome_id":"4589636412243968"},"menu":{"title":"Toolbar/context menu","description":"Method of defining a toolbar menu, a context menu or a list of (interactive) options using the <menu> element.","spec":"https://html.spec.whatwg.org/multipage/forms.html#the-menu-element","status":"ls","links":[{"url":"https://bug617528.bugzilla.mozilla.org/attachment.cgi?id=554309","title":"Demo"},{"url":"http://addyosmani.github.com/jQuery-contextMenu/","title":"jQuery polyfill"},{"url":"https://raw.github.com/phiggins42/has.js/master/detect/events.js#event-contextmenu","title":"has.js test"}],"categories":["HTML5"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"a","9":"a","10":"a","11":"a","12":"a","13":"a","14":"a","15":"a","16":"a","17":"a","18":"a","19":"a","20":"a","21":"a","22":"a","23":"a","24":"a","25":"a","26":"a","27":"a","28":"a","29":"a","30":"a","31":"a","32":"a","33":"a","34":"a","35":"a","36":"a","37":"a","38":"a"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"n","34":"n","35":"n","36":"n","37":"n","38":"n","39":"n","40":"n","41":"n","42":"n","43":"n"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"n","7":"n","7.1":"n","8":"n"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"n","8.1":"n"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"n","4.4.3-4.4.4":"n","37":"n"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"n"},"and_chr":{"40":"n"},"and_ff":{"33":"n"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"n"}},"notes":"Partial support in Firefox refers to being limited to context menus, not toolbar menus.","notes_by_num":{},"usage_perc_y":0,"usage_perc_a":11.66,"ucprefix":false,"parent":"","keywords":"contextmenu,menuitem,command","ie_id":"","chrome_id":""},"rem":{"title":"rem (root em) units","description":"Type of unit similar to \"em\", but relative only to the root element, not any parent element. Thus compounding does not occur as it does with \"em\" units.","spec":"http://www.w3.org/TR/css3-values/#font-relative-lengths","status":"cr","links":[{"url":"http://snook.ca/archives/html_and_css/font-size-with-rem","title":"Article on usage"},{"url":"https://github.com/chuckcarpenter/REM-unit-polyfill","title":"REM Polyfill"}],"categories":["CSS3"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"y","10":"y","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"y","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"u","5":"u","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"y","4.2-4.3":"y","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"y","2.2":"y","2.3":"y","3":"y","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y"}},"notes":"","notes_by_num":{},"usage_perc_y":89.48,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"rems","ie_id":"","chrome_id":""},"ttf":{"title":"TTF/OTF - TrueType and OpenType font support","description":"Support for the TrueType (.ttf)and OpenType (.otf) outline font formats in @font-face. ","spec":"http://developer.apple.com/fonts/TTRefMan/index.html","status":"other","links":[{"url":"http://stackoverflow.com/questions/17694143/what-is-the-status-of-ttf-support-in-internet-explorer","title":"What is the status of TTF support in Internet Explorer?"}],"categories":["CSS3"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"a","10":"a","11":"a","TP":"a"},"firefox":{"2":"n","3":"n","3.5":"y","3.6":"y","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"y","3.2":"y","4":"y","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"y","10.5":"y","10.6":"y","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"y","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"y","2.3":"y","3":"y","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"y","11":"y","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"u","11":"u"},"and_uc":{"9.9":"y"}},"notes":"Partial support in IE9 refers to the fonts only working [when set to be \"installable\"](http://blogs.msdn.com/b/ie/archive/2010/07/15/the-css-corner-better-web-typography-for-better-design.aspx).","notes_by_num":{},"usage_perc_y":76.81,"usage_perc_a":12.11,"ucprefix":false,"parent":"fontface","keywords":"","ie_id":"","chrome_id":""},"touch":{"title":"Touch events","description":"Method of registering when, where and how the interface is touched, for devices with a touch screen. These DOM events are similar to mousedown, mousemove, etc.","spec":"http://www.w3.org/TR/touch-events/","status":"rec","links":[{"url":"http://www.quirksmode.org/mobile/tableTouch.html","title":"Detailed support tables"},{"url":"http://www.quirksmode.org/m/tests/drag2.html","title":"Multi-touch demo"},{"url":"http://schepers.cc/getintouch","title":"Information on the spec development"},{"url":"http://msdn.microsoft.com/en-us/library/ie/hh673557(v=vs.85).aspx","title":"Internet Explorer's gesture and touch implementation."},{"url":"http://github.com/CamHenlin/TouchPolyfill","title":"Touch polyfill for supporting touch events on Internet Explorer"}],"categories":["DOM","JS API"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"p","11":"p","TP":"p"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"a","5":"a","6":"a","7":"a","8":"a","9":"a","10":"a","11":"a","12":"a","13":"a","14":"a","15":"a","16":"a","17":"a","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"n d #1","26":"n d #1","27":"n d #1","28":"n d #1","29":"n d #1","30":"n d #1","31":"n d #1","32":"n d #1","33":"n d #1","34":"n d #1","35":"n d #1","36":"n d #1","37":"n d #1","38":"n d #1"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"n","7":"n","7.1":"n","8":"n"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"y","4.0-4.1":"y","4.2-4.3":"y","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"y","2.2":"y","2.3":"y","3":"y","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"n","11":"y","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"p","11":"a #2"},"and_uc":{"9.9":"y"}},"notes":"Internet Explorer implements Pointer Events specification which supports more input devices than Touch Events one.\r\n\r\nThere is a library on GitHub that is working toward bringing W3C touch events to IE 10 and 11: https://github.com/CamHenlin/TouchPolyfill \r\n\r\nRemoved support in Firefox refers to desktop Firefox only.","notes_by_num":{"1":"Can be enabled in Firefox using the dom.w3c_touch_events.enabled flag (disabled by default for site compatibility reasons)","2":"Supported on IE11 Mobile for phones with \"[Windows Phone 8.1 Update](http://blogs.msdn.com/b/ie/archive/2014/07/31/the-mobile-web-should-just-work-for-everyone.aspx)\""},"usage_perc_y":61.49,"usage_perc_a":0.85,"ucprefix":false,"parent":"","keywords":"touchstart,touchend,touchmove,touchenter,touchleave,touchcancel","ie_id":"touchevents","chrome_id":"6296903092273152"},"matchesselector":{"title":"matches() DOM method","description":"Method of testing whether or not a DOM element matches a given selector. Formerly known (and largely supported with prefix) as matchesSelector.","spec":"https://dom.spec.whatwg.org/#dom-element-matches","status":"ls","links":[{"url":"https://developer.mozilla.org/en/DOM/Element.mozMatchesSelector","title":"MDN article"},{"url":"http://docs.webplatform.org/wiki/dom/HTMLElement/matchesSelector","title":"WebPlatform Docs"}],"categories":["DOM","JS API"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"a x","10":"a x","11":"a x","TP":"a x"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"a x","4":"a x","5":"a x","6":"a x","7":"a x","8":"a x","9":"a x","10":"a x","11":"a x","12":"a x","13":"a x","14":"a x","15":"a x","16":"a x","17":"a x","18":"a x","19":"a x","20":"a x","21":"a x","22":"a x","23":"a x","24":"a x","25":"a x","26":"a x","27":"a x","28":"a x","29":"a x","30":"a x","31":"a x","32":"a x","33":"a x","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"a x","5":"a x","6":"a x","7":"a x","8":"a x","9":"a x","10":"a x","11":"a x","12":"a x","13":"a x","14":"a x","15":"a x","16":"a x","17":"a x","18":"a x","19":"a x","20":"a x","21":"a x","22":"a x","23":"a x","24":"a x","25":"a x","26":"a x","27":"a x","28":"a x","29":"a x","30":"a x","31":"a x","32":"a x","33":"a x","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"a x","5.1":"a x","6":"a x","6.1":"a x","7":"a x","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"a x","11.6":"a x","12":"a x","12.1":"a x","15":"a x","16":"a x","17":"a x","18":"a x","19":"a x","20":"a x","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"a x","4.2-4.3":"a x","5.0-5.1":"a x","6.0-6.1":"a x","7.0-7.1":"a x","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"a x","2.3":"a x","3":"a x","4":"a x","4.1":"a x","4.2-4.3":"a x","4.4":"a x","4.4.3-4.4.4":"a x","37":"y"},"bb":{"7":"a x","10":"a x"},"op_mob":{"10":"n","11":"n","11.1":"a x","11.5":"a x","12":"a x","12.1":"a x","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"a x"},"ie_mob":{"10":"a x","11":"a x"},"and_uc":{"9.9":"a x"}},"notes":"Partial support refers to supporting the older specification's \"matchesSelector\" name rather than just \"matches\".","notes_by_num":{},"usage_perc_y":54.63,"usage_perc_a":34.89,"ucprefix":false,"parent":"","keywords":" matchesSelector","ie_id":"","chrome_id":""},"pointer-events":{"title":"CSS pointer-events (for HTML)","description":"This CSS property, when set to \"none\" allows elements to not receive hover/click events, instead the event will occur on anything behind it. ","spec":"http://wiki.csswg.org/spec/css4-ui#pointer-events","status":"unoff","links":[{"url":"http://robertnyman.com/2010/03/22/css-pointer-events-to-allow-clicks-on-underlying-elements/","title":"Article & tutorial"},{"url":"https://raw.github.com/phiggins42/has.js/master/detect/css.js#css-pointerevents","title":"has.js test"}],"categories":["CSS3"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"y","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"y","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"y","4.0-4.1":"y","4.2-4.3":"y","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"y","2.2":"y","2.3":"y","3":"y","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"n","11":"y"},"and_uc":{"9.9":"y"}},"notes":"Already part of the SVG specification, and all SVG-supporting browsers appear to support the property on SVG elements.","notes_by_num":{},"usage_perc_y":85.22,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"pointerevents","ie_id":"csspointerevents","chrome_id":""},"blobbuilder":{"title":"Blob constructing","description":"Construct Blobs (binary large objects) either using the BlobBuilder API (deprecated) or the Blob constructor.","spec":"http://www.w3.org/TR/file-writer-api/#the-blobbuilder-interface","status":"wd","links":[{"url":"https://developer.mozilla.org/en/DOM/BlobBuilder","title":"MDN article on BlobBuilder"},{"url":"https://developer.mozilla.org/en-US/docs/DOM/Blob","title":"MDN article on Blobs"}],"categories":["JS API"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"y","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"a x","7":"a x","8":"a x","9":"a x","10":"a x","11":"a x","12":"a x","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"a x","9":"a x","10":"a x","11":"a x","12":"a x","13":"a x","14":"a x","15":"a x","16":"a x","17":"a x","18":"a x","19":"a x","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"a x","4":"a x","4.1":"a x","4.2-4.3":"a x","4.4":"a x","4.4.3-4.4.4":"a x","37":"y"},"bb":{"7":"n","10":"y"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"a x"}},"notes":"Partial support refers to only supporting the now deprecated BlobBuilder to create blobs.","notes_by_num":{},"usage_perc_y":75.7,"usage_perc_a":10.62,"ucprefix":true,"parent":"fileapi","keywords":"","ie_id":"blob","chrome_id":"5328783104016384"},"filereader":{"title":"FileReader API","description":"Method of reading the contents of a File or Blob object into memory","spec":"http://www.w3.org/TR/FileAPI/#dfn-filereader","status":"wd","links":[{"url":"https://developer.mozilla.org/en/DOM/FileReader","title":"FileReader API"},{"url":"http://docs.webplatform.org/wiki/apis/file/FileReader","title":"WebPlatform Docs"}],"categories":["JS API"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"y","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"y","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"y","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"n","10":"y"},"op_mob":{"10":"n","11":"n","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y"}},"notes":"","notes_by_num":{},"usage_perc_y":86.53,"usage_perc_a":0,"ucprefix":false,"parent":"fileapi","keywords":"","ie_id":"filereader","chrome_id":"5171003185430528"},"filesystem":{"title":"Filesystem & FileWriter API","description":"Method of reading and writing files to a sandboxed file system.","spec":"http://www.w3.org/TR/file-system-api/","status":"unoff","links":[{"url":"http://www.html5rocks.com/en/tutorials/file/filesystem/","title":"HTML5 Rocks tutorial"},{"url":"http://docs.webplatform.org/wiki/apis/filesystem","title":"WebPlatform Docs"}],"categories":["JS API"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"n","34":"n","35":"n","36":"n","37":"n","38":"n"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"a x","9":"a x","10":"a x","11":"a x","12":"a x","13":"y x","14":"y x","15":"y x","16":"y x","17":"y x","18":"y x","19":"y x","20":"y x","21":"y x","22":"y x","23":"y x","24":"y x","25":"y x","26":"y x","27":"y x","28":"y x","29":"y x","30":"y x","31":"y x","32":"y x","33":"y x","34":"y x","35":"y x","36":"y x","37":"y x","38":"y x","39":"y x","40":"y x","41":"y x","42":"y x","43":"y x"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"n","7":"n","7.1":"n","8":"n"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"y x","16":"y x","17":"y x","18":"y x","19":"y x","20":"y x","21":"y x","22":"y x","23":"y x","24":"y x","25":"y x","26":"y x","27":"y x","28":"y x","29":"y x"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"n","8.1":"n"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"n","4.4.3-4.4.4":"n","37":"n"},"bb":{"7":"n","10":"y x"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"y x"},"and_chr":{"40":"y x"},"and_ff":{"33":"n"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"n"}},"notes":"The File API: Directories and System specification is no longer being maintained and support may be dropped in future versions.","notes_by_num":{},"usage_perc_y":43.31,"usage_perc_a":0.18,"ucprefix":false,"parent":"","keywords":"filewriter","ie_id":"filewriter","chrome_id":"5452478162141184"},"bloburls":{"title":"Blob URLs","description":"Method of creating URL handles to the specified File or Blob object.","spec":"http://www.w3.org/TR/FileAPI/#url","status":"wd","links":[{"url":"https://developer.mozilla.org/en/DOM/window.URL.createObjectURL","title":"MDN article"}],"categories":["JS API"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"y","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"y x","9":"y x","10":"y x","11":"y x","12":"y x","13":"y x","14":"y x","15":"y x","16":"y x","17":"y x","18":"y x","19":"y x","20":"y x","21":"y x","22":"y x","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"y x","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"y x","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"y x","4.1":"y x","4.2-4.3":"y x","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"n","10":"y x"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"n","11":"y"},"and_uc":{"9.9":"y x"}},"notes":"","notes_by_num":{},"usage_perc_y":85.81,"usage_perc_a":0,"ucprefix":false,"parent":"fileapi","keywords":"createobjecturl","ie_id":"","chrome_id":""},"rellist":{"title":"relList (DOMTokenList)","description":"Method of easily manipulating rel attribute values on elements, using the DOMTokenList object (similar to classList).","spec":"https://html.spec.whatwg.org/multipage/semantics.html#dom-a-rellist","status":"ls","links":[{"url":"https://developer.mozilla.org/en-US/docs/DOM/DOMTokenList","title":"MDN - DOMTokenList"}],"categories":["DOM","HTML5"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"n","34":"n","35":"n","36":"n","37":"n","38":"n","39":"n","40":"n","41":"n","42":"n","43":"n"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"n","7":"n","7.1":"n","8":"n"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"n","8.1":"n"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"n","4.4.3-4.4.4":"n","37":"n"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"n"},"and_chr":{"40":"n"},"and_ff":{"33":"y"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"n"}},"notes":"","notes_by_num":{},"usage_perc_y":10.76,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"","ie_id":"","chrome_id":""},"typedarrays":{"title":"Typed Arrays","description":"JavaScript typed arrays provide a mechanism for accessing raw binary data much more efficiently.\r\n","spec":"http://www.khronos.org/registry/typedarray/specs/latest/","status":"other","links":[{"url":"https://developer.mozilla.org/en/javascript_typed_arrays","title":"MDN article"}],"categories":["JS API"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"a #1","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"n","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"a #2","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"a #2","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"n","10":"y"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"a #1","11":"a #1"},"and_uc":{"9.9":"y"}},"notes":"","notes_by_num":{"1":"IE10 (and IE 10&11 mobile) does not support `Uint8ClampedArray`"},"usage_perc_y":84.08,"usage_perc_a":2.78,"ucprefix":false,"parent":"","keywords":"float64array,dataview,uint8array","ie_id":"typedarrays","chrome_id":"5135818813341696"},"deviceorientation":{"title":"DeviceOrientation events","description":"API for detecting orientation and motion events from the device running the browser.","spec":"http://www.w3.org/TR/orientation-event/","status":"wd","links":[{"url":"http://www.html5rocks.com/en/tutorials/device/orientation/","title":"HTML5 Rocks tutorial"},{"url":"https://raw.github.com/phiggins42/has.js/master/detect/features.js#native-orientation","title":"has.js test"},{"url":"http://html5labs.interoperabilitybridges.com/prototypes/device-orientation-events/device-orientation-events/info","title":"DeviceOrientation implementation prototype for IE10"},{"url":"http://aurelio.audero.it/demo/device-orientation-api-demo.html","title":"Demo"}],"categories":["JS API"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"a #1","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"p","4":"p","5":"p","6":"a","7":"a","8":"a","9":"a","10":"a","11":"a","12":"a","13":"a","14":"a","15":"a","16":"a","17":"a","18":"a","19":"a","20":"a","21":"a","22":"a","23":"a","24":"a","25":"a","26":"a","27":"a","28":"a","29":"a","30":"a","31":"a","32":"a","33":"a","34":"a","35":"a","36":"a","37":"a","38":"a"},"chrome":{"4":"n","5":"n","6":"n","7":"a","8":"a","9":"a","10":"a","11":"a","12":"a","13":"a","14":"a","15":"a","16":"a","17":"a","18":"a","19":"a","20":"a","21":"a","22":"a","23":"a","24":"a","25":"a","26":"a","27":"a","28":"a","29":"a","30":"a","31":"a","32":"a","33":"a","34":"a","35":"a","36":"a","37":"a","38":"a","39":"a","40":"a","41":"a","42":"a","43":"a"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"n","7":"n","7.1":"n","8":"n"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"a","16":"a","17":"a","18":"a","19":"a","20":"a","21":"a","22":"a","23":"a","24":"a","25":"a","26":"a","27":"a","28":"a","29":"a"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"a","5.0-5.1":"a","6.0-6.1":"a","7.0-7.1":"a","8":"a","8.1":"a"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"a","4":"a","4.1":"a","4.2-4.3":"a","4.4":"a","4.4.3-4.4.4":"a","37":"a"},"bb":{"7":"n","10":"a"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"y","12.1":"y","24":"a"},"and_chr":{"40":"a"},"and_ff":{"33":"a"},"ie_mob":{"10":"n","11":"y"},"and_uc":{"9.9":"a"}},"notes":"Partial support refers to the lack of compassneedscalibration event. Partial support also refers to the lack of devicemotion event support for Chrome 30- and Opera. Opera Mobile 14 lost the ondevicemotion event support. Firefox 3.6, 4 and 5 support the non-standard [MozOrientation](https://developer.mozilla.org/en/DOM/MozOrientation) event.","notes_by_num":{"1":"`compassneedscalibration` supported in IE11 only for compatible devices with Windows 8.1+."},"usage_perc_y":0.43,"usage_perc_a":81.4,"ucprefix":false,"parent":"","keywords":"","ie_id":"deviceorientation,devicemotion","chrome_id":"5874690627207168,5556931766779904"},"script-defer":{"title":"defer attribute for external scripts","description":"The boolean defer attribute on script elements allows the external JavaScript file to run when the DOM is loaded, without delaying page load first.","spec":"https://html.spec.whatwg.org/multipage/scripting.html#attr-script-defer","status":"ls","links":[{"url":"https://developer.mozilla.org/en/HTML/Element/script#Attributes","title":"MDN article"},{"url":"https://raw.github.com/phiggins42/has.js/master/detect/script.js#script-defer","title":"has.js test"},{"url":"http://docs.webplatform.org/wiki/html/attributes/defer","title":"WebPlatform Docs"}],"categories":["DOM","HTML5"],"stats":{"ie":{"5.5":"a","6":"a","7":"a","8":"a","9":"a","10":"y","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"y","3.6":"y","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"y","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y"}},"notes":"Partial support in older IE refers to a buggy implementation (see issue).","notes_by_num":{},"usage_perc_y":86.92,"usage_perc_a":6.48,"ucprefix":false,"parent":"","keywords":"","ie_id":"","chrome_id":""},"nav-timing":{"title":"Navigation Timing API","description":"API for accessing timing information related to navigation and elements.","spec":"http://www.w3.org/TR/navigation-timing/","status":"rec","links":[{"url":"https://developer.mozilla.org/en/API/navigationTiming","title":"MDN article"},{"url":"http://www.html5rocks.com/en/tutorials/webperformance/basics/","title":"HTML5 Rocks tutorial"},{"url":"http://docs.webplatform.org/wiki/apis/navigation_timing","title":"WebPlatform Docs"}],"categories":["DOM","JS API"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"y","10":"y","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"y x","7":"y x","8":"y x","9":"y x","10":"y x","11":"y x","12":"y x","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"n","7":"n","7.1":"n","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"y","8.1":"n"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"n","10":"y"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y"}},"notes":"Removed in iOS 8.1 due to poor performance.","notes_by_num":{},"usage_perc_y":79.85,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"performance,performance.timing","ie_id":"navigationtimingapi","chrome_id":"5584144679567360"},"audio-api":{"title":"Web Audio API","description":"High-level JavaScript API for processing and synthesizing audio","spec":"http://www.w3.org/TR/webaudio/","status":"wd","links":[{"url":"https://github.com/corbanbrook/audionode.js","title":"Polyfill to support Web Audio API in Firefox"},{"url":"http://docs.webplatform.org/wiki/apis/webaudio","title":"WebPlatform Docs"},{"url":"http://www.doboism.com/projects/webaudio-compatibility/","title":"Additional browser compatibility tests for specific features"},{"url":"https://github.com/g200kg/WAAPISim","title":"Polyfill to enable Web Audio API through Firefox Audio Data api or flash"}],"categories":["JS API"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"y x","11":"y x","12":"y x","13":"y x","14":"y x","15":"y x","16":"y x","17":"y x","18":"y x","19":"y x","20":"y x","21":"y x","22":"y x","23":"y x","24":"y x","25":"y x","26":"y x","27":"y x","28":"y x","29":"y x","30":"y x","31":"y x","32":"y x","33":"y x","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"y x","6.1":"y x","7":"y x","7.1":"y x","8":"y x"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"y x","16":"y x","17":"y x","18":"y x","19":"y x","20":"y x","21":"y x","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"y x","7.0-7.1":"y x","8":"y x","8.1":"y x"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"n","4.4.3-4.4.4":"n","37":"n"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"n"}},"notes":"Firefox versions < 25 support an alternative, deprecated audio API.\r\n\r\nChrome support [went through some changes](http://updates.html5rocks.com/2014/07/Web-Audio-Changes-in-m36) as of version 36.","notes_by_num":{},"usage_perc_y":64.63,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"web-audio","ie_id":"webaudioapi","chrome_id":"6261718720184320"},"css-regions":{"title":"CSS Regions","description":"Method of flowing content into multiple elements.","spec":"http://www.w3.org/TR/css3-regions/","status":"wd","links":[{"url":"http://html.adobe.com/webstandards/cssregions/","title":"Adobe demos and samples"},{"url":"http://msdn.microsoft.com/en-us/ie/hh272902#_CSSConnected","title":"IE10 developer guide info"},{"url":"http://docs.webplatform.org/wiki/css/atrules/@region","title":"WebPlatform Docs"}],"categories":["CSS3"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"a x","11":"a x","TP":"a x"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"n","34":"n","35":"n","36":"n","37":"n","38":"n"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"a x","16":"a x","17":"a x","18":"a x","19":"n d","20":"n d","21":"n d","22":"n d","23":"n d","24":"n d","25":"n d","26":"n d","27":"n d","28":"n d","29":"n d","30":"n d","31":"n d","32":"n d","33":"n d","34":"n d","35":"n","36":"n","37":"n","38":"n","39":"n","40":"n","41":"n","42":"n","43":"n"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"y x","7":"y x","7.1":"y x","8":"y x"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"y x","8":"y x","8.1":"y x"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"n","4.4.3-4.4.4":"n","37":"n"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"n"},"and_chr":{"40":"n"},"and_ff":{"33":"n"},"ie_mob":{"10":"a x","11":"a x"},"and_uc":{"9.9":"y x"}},"notes":"Support in IE10 and IE11 is limited to using an iframe as a content source with the `-ms-flow-into: flow_name;` and `-ms-flow-from: flow_name;` syntax. ","notes_by_num":{},"usage_perc_y":13.52,"usage_perc_a":10.8,"ucprefix":false,"parent":"","keywords":"","ie_id":"regions","chrome_id":"5655612935372800"},"spellcheck-attribute":{"title":"Spellcheck attribute","description":"Attribute for `input`/`textarea` fields to enable/disable the browser's spellchecker.","spec":"https://html.spec.whatwg.org/multipage/interaction.html#spelling-and-grammar-checking","status":"ls","links":[{"url":"https://developer.mozilla.org/en-US/docs/Web/HTML/Controlling_spell_checking_in_HTML_formsControlling_spell_checking_in_HTML_forms","title":"MDN article"}],"categories":["HTML5"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"y","11":"y","TP":"y"},"firefox":{"2":"y","3":"y","3.5":"y","3.6":"y","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"y","10.6":"y","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"a","4.0-4.1":"a","4.2-4.3":"a","5.0-5.1":"a","6.0-6.1":"a","7.0-7.1":"a","8":"a","8.1":"a"},"op_mini":{"5.0-8.0":"a"},"android":{"2.1":"a","2.2":"a","2.3":"a","3":"a","4":"a","4.1":"a","4.2-4.3":"a","4.4":"a","4.4.3-4.4.4":"a","37":"a"},"bb":{"7":"a","10":"a"},"op_mob":{"10":"a","11":"a","11.1":"a","11.5":"a","12":"a","12.1":"a","24":"a"},"and_chr":{"40":"a"},"and_ff":{"33":"a"},"ie_mob":{"10":"a","11":"a"},"and_uc":{"9.9":"a"}},"notes":"The partial support in mobile browsers results from their OS generally having built-in spell checking instead of using the wavy underline to indicate misspelled words. `spellcheck=\"false\"` does not seem to have any effect in these browsers.","notes_by_num":{},"usage_perc_y":57.88,"usage_perc_a":32.46,"ucprefix":false,"parent":"","keywords":"spelling","ie_id":"","chrome_id":""},"fullscreen":{"title":"Full Screen API","description":"API for allowing content (like a video or canvas element) to take up the entire screen.","spec":"http://www.w3.org/TR/fullscreen/","status":"wd","links":[{"url":"https://developer.mozilla.org/en/DOM/Using_full-screen_mode","title":"MDN article"},{"url":"http://jlongster.com/2011/11/21/canvas.html","title":"Blog post"},{"url":"http://hacks.mozilla.org/2012/01/using-the-fullscreen-api-in-web-browsers/","title":"Mozilla hacks article"},{"url":"http://docs.webplatform.org/wiki/dom/Element/requestFullscreen","title":"WebPlatform Docs"}],"categories":["JS API"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"y x","TP":"y x"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"a x","11":"a x","12":"a x","13":"a x","14":"a x","15":"a x","16":"a x","17":"a x","18":"a x","19":"a x","20":"a x","21":"a x","22":"a x","23":"a x","24":"a x","25":"a x","26":"a x","27":"a x","28":"a x","29":"a x","30":"a x","31":"a x","32":"a x","33":"a x","34":"a x","35":"a x","36":"a x","37":"a x","38":"a x"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"a x","16":"a x","17":"a x","18":"a x","19":"a x","20":"y x","21":"y x","22":"y x","23":"y x","24":"y x","25":"y x","26":"y x","27":"y x","28":"y x","29":"y x","30":"y x","31":"y x","32":"y x","33":"y x","34":"y x","35":"y x","36":"y x","37":"y x","38":"y x","39":"y x","40":"y x","41":"y x","42":"y x","43":"y x"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"a x","6":"y x","6.1":"y x","7":"y x","7.1":"y x","8":"y x"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"y","15":"y x","16":"y x","17":"y x","18":"y x","19":"y x","20":"y x","21":"y x","22":"y x","23":"y x","24":"y x","25":"y x","26":"y x","27":"y x","28":"y x","29":"y x"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"n","8.1":"n"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"n","4.4.3-4.4.4":"n","37":"n"},"bb":{"7":"n","10":"a"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"y x"},"and_chr":{"40":"y x"},"and_ff":{"33":"a x"},"ie_mob":{"10":"n","11":"y x"},"and_uc":{"9.9":"n"}},"notes":"Partial support refers to supporting an earlier draft of the spec.","notes_by_num":{},"usage_perc_y":54.48,"usage_perc_a":12.24,"ucprefix":false,"parent":"","keywords":"full-screen","ie_id":"fullscreenapi","chrome_id":"5259513871466496"},"requestanimationframe":{"title":"requestAnimationFrame","description":"API allowing a more efficient way of running script-based animation, compared to traditional methods using timeouts.","spec":"http://www.w3.org/TR/animation-timing/#requestAnimationFrame","status":"cr","links":[{"url":"http://paulirish.com/2011/requestanimationframe-for-smart-animating/","title":"Blog post"},{"url":"http://hacks.mozilla.org/2011/08/animating-with-javascript-from-setinterval-to-requestanimationframe/","title":"Mozilla Hacks article"},{"url":"http://docs.webplatform.org/wiki/dom/Window/requestAnimationFrame","title":"WebPlatform Docs"}],"categories":["JS API"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"y","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"y x","5":"y x","6":"y x","7":"y x","8":"y x","9":"y x","10":"y x","11":"y x","12":"y x","13":"y x","14":"y x","15":"y x","16":"y x","17":"y x","18":"y x","19":"y x","20":"y x","21":"y x","22":"y x","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"y x","11":"y x","12":"y x","13":"y x","14":"y x","15":"y x","16":"y x","17":"y x","18":"y x","19":"y x","20":"y x","21":"y x","22":"y x","23":"y x","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"y x","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"y x","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"n","10":"y x"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y"}},"notes":"","notes_by_num":{},"usage_perc_y":83.38,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"","ie_id":"requestanimationframe","chrome_id":"5233400470306816"},"input-range":{"title":"Range input type","description":"Form field type that allows the user to select a value using a slider widget.","spec":"https://html.spec.whatwg.org/multipage/forms.html#range-state-(type=range)","status":"ls","links":[{"url":"https://github.com/fryn/html5slider","title":"Polyfill for Firefox"},{"url":"https://github.com/freqdec/fd-slider","title":"Cross-browser polyfill"},{"url":"http://tutorialzine.com/2011/12/what-you-need-to-know-html5-range-input/","title":"Tutorial"},{"url":"https://raw.github.com/phiggins42/has.js/master/detect/form.js#input-type-range","title":"has.js test"},{"url":"http://docs.webplatform.org/wiki/html/elements/input/type/range","title":"WebPlatform Docs"},{"url":"https://github.com/andreruffert/rangeslider.js","title":"rangeslider.js polyfill"}],"categories":["HTML5"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"y","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"u","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"y","3.2":"y","4":"y","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"y","9.5-9.6":"y","10.0-10.1":"y","10.5":"y","10.6":"y","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"a","2.2":"a","2.3":"a","3":"a","4":"a","4.1":"a","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"y","11":"y","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y"}},"notes":"Currently all Android browsers with partial support hide the slider input field by default. However, the element [can be styled](http://tiffanybbrown.com/2012/02/07/input-typerange-and-androids-stock-browser/) to be made visible and usable.","notes_by_num":{},"usage_perc_y":85.39,"usage_perc_a":1.4,"ucprefix":false,"parent":"forms","keywords":"input type=\"range\"","ie_id":"","chrome_id":""},"matchmedia":{"title":"matchMedia","description":"API for finding out whether or not a media query applies to the document.","spec":"http://www.w3.org/TR/cssom-view/#dom-window-matchmedia","status":"wd","links":[{"url":"https://github.com/paulirish/matchMedia.js/","title":"matchMedia.js polyfill"},{"url":"https://developer.mozilla.org/en/DOM/window.matchMedia","title":"MDN article"},{"url":"https://developer.mozilla.org/en/CSS/Using_media_queries_from_code","title":"MDN tutorial"},{"url":"http://docs.webplatform.org/wiki/css/media_queries/apis/matchMedia","title":"WebPlatform Docs"}],"categories":["DOM","JS API"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"y","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"y","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"n","10":"y"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y"}},"notes":"","notes_by_num":{},"usage_perc_y":86.76,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"mediaquerylist","ie_id":"matchmedia","chrome_id":"4677872220372992"},"input-datetime":{"title":"Date and time input types","description":"Form field widget to easily allow users to enter a date or a time, generally by using a calendar/time input widget. Previously there was also a single field for both date & time, but this has been deprecated.","spec":"https://html.spec.whatwg.org/multipage/forms.html#date-state-(type=date)","status":"ls","links":[{"url":"http://net.tutsplus.com/tutorials/javascript-ajax/quick-tip-cross-browser-datepickers-within-minutes/","title":"Datepicker tutorial w/polyfill"},{"url":"https://github.com/zoltan-dulac/html5Forms.js","title":"Polyfill for HTML5 forms"},{"url":"https://raw.github.com/phiggins42/has.js/master/detect/form.js#input-type-datetime;input-type-datetime-local","title":"has.js test"},{"url":"http://docs.webplatform.org/wiki/html/elements/input/type/date","title":"WebPlatform Docs"}],"categories":["HTML5"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"n","34":"n","35":"n","36":"n","37":"n","38":"n"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"n","7":"n","7.1":"n","8":"n"},"opera":{"9":"y","9.5-9.6":"y","10.0-10.1":"y","10.5":"y","10.6":"y","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"n","10":"y"},"op_mob":{"10":"y","11":"y","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"n"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"y"}},"notes":"Partial support in iOS refers to a lack of support for attributes like step, min, or max.\r\n\r\nOlder versions of Safari provide date-formatted text fields, but no real calendar widget.\r\n\r\nSome modified versions of the Android 4.x browser do have support for date/time fields.","notes_by_num":{},"usage_perc_y":58.47,"usage_perc_a":0,"ucprefix":false,"parent":"forms","keywords":"datepicker,timepicker,input type=\"date\",input type=\"time\"","ie_id":"","chrome_id":"6640933999214592"},"input-color":{"title":"Color input type","description":"Form field allowing the user to select a color.","spec":"https://html.spec.whatwg.org/multipage/forms.html#color-state-(type=color)","status":"ls","links":[{"url":"http://www.html5tutorial.info/html5-color.php","title":"Tutorial"},{"url":"https://github.com/jonstipe/color-polyfill","title":"Polyfill"},{"url":"http://docs.webplatform.org/wiki/html/elements/input/type/color","title":"WebPlatform Docs"}],"categories":["HTML5"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"n","7":"n","7.1":"n","8":"n"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"n","16":"n","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"n","8.1":"n"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"y","11":"y","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"a"}},"notes":"","notes_by_num":{},"usage_perc_y":57.9,"usage_perc_a":3.78,"ucprefix":false,"parent":"forms","keywords":"colour,input type=\"color\"","ie_id":"","chrome_id":""},"input-number":{"title":"Number input type","description":"Form field type for numbers.","spec":"https://html.spec.whatwg.org/multipage/forms.html#number-state-(type=number)","status":"ls","links":[{"url":"http://www.html5tutorial.info/html5-number.php","title":"Tutorial"},{"url":"https://github.com/jonstipe/number-polyfill","title":"Polyfill"},{"url":"https://raw.github.com/phiggins42/has.js/master/detect/form.js#input-type-number","title":"has.js test"},{"url":"http://docs.webplatform.org/wiki/html/elements/input/type/number","title":"WebPlatform Docs"}],"categories":["HTML5"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"a","11":"a","TP":"a"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"y","9.5-9.6":"y","10.0-10.1":"y","10.5":"y","10.6":"y","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"a","4.0-4.1":"a","4.2-4.3":"a","5.0-5.1":"a","6.0-6.1":"a","7.0-7.1":"a","8":"a","8.1":"a"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"a","4.1":"a","4.2-4.3":"a","4.4":"a","4.4.3-4.4.4":"a","37":"a"},"bb":{"7":"n","10":"a"},"op_mob":{"10":"y","11":"y","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"a"},"and_chr":{"40":"a"},"and_ff":{"33":"a"},"ie_mob":{"10":"a","11":"a"},"and_uc":{"9.9":"a"}},"notes":"iOS Safari, Android 4, Chrome for Android show number input, but do not use \"step\", \"min\" or \"max\" attributes or show increment/decrement buttons. Internet Explorer 10 and 11 do not show increment/decrement buttons.","notes_by_num":{},"usage_perc_y":46.99,"usage_perc_a":39.08,"ucprefix":false,"parent":"forms","keywords":"spinner,input type=\"number\"","ie_id":"","chrome_id":""},"iframe-sandbox":{"title":"sandbox attribute for iframes","description":"Method of running external site pages with reduced privileges (e.g. no JavaScript) in iframes.","spec":"https://html.spec.whatwg.org/multipage/embedded-content.html#attr-iframe-sandbox","status":"ls","links":[{"url":"http://blog.chromium.org/2010/05/security-in-depth-html5s-sandbox.html","title":"Chromium blog article"},{"url":"http://msdn.microsoft.com/en-us/hh563496","title":"MSDN article"},{"url":"http://docs.webplatform.org/wiki/html/attributes/sandbox","title":"WebPlatform Docs"}],"categories":["HTML5"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"y","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"a","18":"a","19":"a","20":"a","21":"a","22":"a","23":"a","24":"a","25":"a","26":"a","27":"a","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"y","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"y","2.3":"y","3":"y","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y"}},"notes":"","notes_by_num":{},"usage_perc_y":86.09,"usage_perc_a":0.54,"ucprefix":false,"parent":"","keywords":"","ie_id":"iframesandboxattribute","chrome_id":"5715536319086592"},"css-counters":{"title":"CSS Counters","description":"Method of controlling number values in generated content, using the counter-reset and counter-increment properties.","spec":"http://www.w3.org/TR/CSS21/generate.html#counters","status":"wd","links":[{"url":"http://onwebdev.blogspot.com/2012/02/css-counters-tutorial.html","title":"Tutorial and information"},{"url":"https://developer.mozilla.org/en/CSS_Counters","title":"MDN article"},{"url":"http://docs.webplatform.org/wiki/css/properties/counter-reset","title":"WebPlatform Docs"}],"categories":["CSS2"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"y","9":"y","10":"y","11":"y","TP":"y"},"firefox":{"2":"y","3":"y","3.5":"y","3.6":"y","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"y","3.2":"y","4":"y","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"y","9.5-9.6":"y","10.0-10.1":"y","10.5":"y","10.6":"y","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"y","4.0-4.1":"y","4.2-4.3":"y","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"y"},"android":{"2.1":"y","2.2":"y","2.3":"y","3":"y","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"y","11":"y","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y"}},"notes":"","notes_by_num":{},"usage_perc_y":96.85,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"","ie_id":"","chrome_id":""},"css-resize":{"title":"CSS resize property","description":"Method of allowing an element to be resized by the user, with options to limit to a given direction. ","spec":"http://www.w3.org/TR/css3-ui/#resize","status":"wd","links":[{"url":"http://css-tricks.com/almanac/properties/r/resize/","title":"CSS Tricks info"},{"url":"http://davidwalsh.name/textarea-resize","title":"On textarea resizing"}],"categories":["CSS3"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"y x","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"y","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"a","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"n","8.1":"n"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"n","4.4.3-4.4.4":"n","37":"n"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"n"}},"notes":"Opera 12.10+ currently only supports the resize property for textarea elements.","notes_by_num":{},"usage_perc_y":58.42,"usage_perc_a":0.2,"ucprefix":false,"parent":"","keywords":"horizontal,vertical","ie_id":"","chrome_id":""},"input-placeholder":{"title":"input placeholder attribute","description":"Method of setting placeholder text for text-like input fields, to suggest the expected inserted information.","spec":"https://html.spec.whatwg.org/multipage/forms.html#attr-input-placeholder","status":"ls","links":[{"url":"http://www.zachleat.com/web/placeholder/","title":"Article on usage"},{"url":"https://github.com/mathiasbynens/jquery-placeholder","title":"Polyfill"},{"url":"https://raw.github.com/phiggins42/has.js/master/detect/form.js#input-attr-placeholder","title":"has.js test"},{"url":"http://docs.webplatform.org/wiki/html/attributes/placeholder","title":"WebPlatform Docs"},{"url":"https://code.google.com/p/android/issues/detail?id=24626","title":"Issue 24626: Placeholder text for an input type="}],"categories":["HTML5"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"y","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"a","3.2":"a","4":"a","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"a","11.1":"a","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"y","4.0-4.1":"y","4.2-4.3":"y","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"y","2.2":"y","2.3":"y","3":"y","4":"a","4.1":"a","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"n","11":"y","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y"}},"notes":"Partial support in older Safari and Opera versions refers to lacking placeholder support on textarea elements. ","notes_by_num":{},"usage_perc_y":86.06,"usage_perc_a":1.33,"ucprefix":false,"parent":"forms","keywords":"","ie_id":"","chrome_id":""},"spdy":{"title":"HTTP/2 protocol / SPDY","description":"Networking protocol for low-latency transport of content over the web. Originally started out from the SPDY protocol, now standardized as HTTP version 2.","spec":"http://http2.github.io/http2-spec/index.html","status":"other","links":[{"url":"http://en.wikipedia.org/wiki/HTTP/2","title":"Wikipedia"},{"url":"http://dev.chromium.org/spdy/spdy-whitepaper","title":"SPDY whitepaper"}],"categories":["Other"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"a","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"n","7":"n","7.1":"n","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"y","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"n","11":"y"},"and_uc":{"9.9":"u"}},"notes":"","notes_by_num":{},"usage_perc_y":68.27,"usage_perc_a":8.34,"ucprefix":false,"parent":"","keywords":"http2","ie_id":"http2","chrome_id":"5152586365665280"},"css-repeating-gradients":{"title":"CSS Repeating Gradients","description":"Method of defining a repeating linear or radial color gradient as a CSS image.","spec":"http://www.w3.org/TR/css3-images/#repeating-gradients","status":"cr","links":[{"url":"https://developer.mozilla.org/en/CSS/repeating-linear-gradient","title":"MDN article"},{"url":"http://www.css3files.com/gradient/#repeatinglineargradient","title":"Information page"},{"url":"http://docs.webplatform.org/wiki/css/repeating-linear-gradient","title":"WebPlatform Docs"}],"categories":["CSS3"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"y","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"y x","4":"y x","5":"y x","6":"y x","7":"y x","8":"y x","9":"y x","10":"y x","11":"y x","12":"y x","13":"y x","14":"y x","15":"y x","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"y x","11":"y x","12":"y x","13":"y x","14":"y x","15":"y x","16":"y x","17":"y x","18":"y x","19":"y x","20":"y x","21":"y x","22":"y x","23":"y x","24":"y x","25":"y x","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"y x","6":"y x","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"a x","11.5":"a x","11.6":"y x","12":"y x","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"y x","6.0-6.1":"y x","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"y x","4.1":"y x","4.2-4.3":"y x","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"n","10":"y x"},"op_mob":{"10":"n","11":"n","11.1":"a x","11.5":"a x","12":"y x","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y x"}},"notes":"Firefox 10+, Chrome 26+ and Opera 11.6+ also support the new \"to (side)\" syntax.","notes_by_num":{},"usage_perc_y":86.91,"usage_perc_a":0.02,"ucprefix":false,"parent":"css-gradients","keywords":"","ie_id":"","chrome_id":""},"css-filters":{"title":"CSS Filter Effects","description":"Method of applying filter effects (like blur, grayscale, brightness, contrast and hue) to elements, previously only possible by using SVG.","spec":"http://www.w3.org/TR/filter-effects/","status":"wd","links":[{"url":"http://html5-demos.appspot.com/static/css/filters/index.html","title":"Demo file for WebKit browsers"},{"url":"http://www.html5rocks.com/en/tutorials/filters/understanding-css/","title":"HTML5Rocks article"},{"url":"http://dl.dropbox.com/u/3260327/angular/CSS3ImageManipulation.html","title":"Filter editor"},{"url":"http://bennettfeely.com/filters/","title":"Filter Playground"}],"categories":["CSS","CSS3"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"a","4":"a","5":"a","6":"a","7":"a","8":"a","9":"a","10":"a","11":"a","12":"a","13":"a","14":"a","15":"a","16":"a","17":"a","18":"a","19":"a","20":"a","21":"a","22":"a","23":"a","24":"a","25":"a","26":"a","27":"a","28":"a","29":"a","30":"a","31":"a","32":"a","33":"a","34":"a d #1","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"y x","19":"y x","20":"y x","21":"y x","22":"y x","23":"y x","24":"y x","25":"y x","26":"y x","27":"y x","28":"y x","29":"y x","30":"y x","31":"y x","32":"y x","33":"y x","34":"y x","35":"y x","36":"y x","37":"y x","38":"y x","39":"y x","40":"y x","41":"y x","42":"y x","43":"y x"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"y x","6.1":"y x","7":"y x","7.1":"y x","8":"y x"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"y x","16":"y x","17":"y x","18":"y x","19":"y x","20":"y x","21":"y x","22":"y x","23":"y x","24":"y x","25":"y x","26":"y x","27":"y x","28":"y x","29":"y x"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"y x","7.0-7.1":"y x","8":"y x","8.1":"y x"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"y x","4.4.3-4.4.4":"y x","37":"y x"},"bb":{"7":"n","10":"y x"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"y x"},"and_chr":{"40":"y x"},"and_ff":{"33":"a"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"y x"}},"notes":"Note that this property is significantly different from and incompatible with Microsoft's [older \"filter\" property](http://msdn.microsoft.com/en-us/library/ie/ms530752%28v=vs.85%29.aspx).\r\n\r\nPartial support in Firefox before version 34 [only implemented the url() function of the filter property](https://developer.mozilla.org/en-US/docs/Web/CSS/filter#Browser_compatibility)","notes_by_num":{"1":"Supported in Firefox under the `layout.css.filters.enabled` flag."},"usage_perc_y":60.79,"usage_perc_a":11.71,"ucprefix":false,"parent":"","keywords":"sepia,hue-rotate,invert,saturate","ie_id":"filters","chrome_id":""},"getcomputedstyle":{"title":"getComputedStyle","description":"API to get the current computed CSS styles applied to an element. This may be the current value applied by an animation or as set by a stylesheet.","spec":"http://www.w3.org/TR/cssom/#dom-window-getcomputedstyle","status":"rec","links":[{"url":"https://developer.mozilla.org/en/DOM/window.getComputedStyle","title":"MDN article"},{"url":"http://ie.microsoft.com/testdrive/HTML5/getComputedStyle/","title":"Demo"},{"url":"http://snipplr.com/view/13523/","title":"Polyfill for IE"},{"url":"http://docs.webplatform.org/wiki/css/cssom/methods/getComputedStyle","title":"WebPlatform Docs"}],"categories":["CSS3","DOM","JS API"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"y","10":"y","11":"y","TP":"y"},"firefox":{"2":"n","3":"a","3.5":"a","3.6":"a","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"a","5":"a","6":"a","7":"a","8":"a","9":"a","10":"a","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"a","3.2":"a","4":"a","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"a","9.5-9.6":"a","10.0-10.1":"a","10.5":"a","10.6":"y","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"a","4.0-4.1":"a","4.2-4.3":"a","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"a"},"android":{"2.1":"a","2.2":"a","2.3":"a","3":"a","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"a","10":"y"},"op_mob":{"10":"a","11":"y","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y"}},"notes":"Partial support in older Firefox versions refers to requiring the second parameter to be included.\r\n\r\nPartial support in all other browsers refers to not supporting getComputedStyle on pseudo-elements.","notes_by_num":{},"usage_perc_y":89.1,"usage_perc_a":3.67,"ucprefix":false,"parent":"","keywords":"","ie_id":"","chrome_id":""},"word-break":{"title":"CSS3 word-break","description":"Property to prevent or allow words to be broken over multiple lines between letters.","spec":"http://www.w3.org/TR/css3-text/#word-break","status":"wd","links":[{"url":"https://developer.mozilla.org/en/CSS/word-break","title":"MDN article"},{"url":"http://docs.webplatform.org/wiki/css/properties/word-break","title":"WebPlatform Docs"}],"categories":["CSS3"],"stats":{"ie":{"5.5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"a","5":"a","6":"a","7":"a","8":"a","9":"a","10":"a","11":"a","12":"a","13":"a","14":"a","15":"a","16":"a","17":"a","18":"a","19":"a","20":"a","21":"a","22":"a","23":"a","24":"a","25":"a","26":"a","27":"a","28":"a","29":"a","30":"a","31":"a","32":"a","33":"a","34":"a","35":"a","36":"a","37":"a","38":"a","39":"a","40":"a","41":"a","42":"a","43":"a"},"safari":{"3.1":"a","3.2":"a","4":"a","5":"a","5.1":"a","6":"a","6.1":"a","7":"a","7.1":"a","8":"a"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"a","16":"a","17":"a","18":"a","19":"a","20":"a","21":"a","22":"a","23":"a","24":"a","25":"a","26":"a","27":"a","28":"a","29":"a"},"ios_saf":{"3.2":"a","4.0-4.1":"a","4.2-4.3":"a","5.0-5.1":"a","6.0-6.1":"a","7.0-7.1":"a","8":"a","8.1":"a"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"a","2.2":"a","2.3":"a","3":"a","4":"a","4.1":"a","4.2-4.3":"a","4.4":"a","4.4.3-4.4.4":"a","37":"a"},"bb":{"7":"a","10":"a"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"a"},"and_chr":{"40":"a"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"a"}},"notes":"Partial support refers to supporting the \"break-all\" value, but not the \"keep-all\" value.","notes_by_num":{},"usage_perc_y":28.73,"usage_perc_a":64.53,"ucprefix":false,"parent":"","keywords":"break-all,keep-all","ie_id":"","chrome_id":""},"viewport-units":{"title":"Viewport units: vw, vh, vmin, vmax","description":"Length units representing 1% of the viewport size for viewport width (vw), height (vh), the smaller of the two (vmin), or the larger of the two (vmax).","spec":"http://www.w3.org/TR/css3-values/#viewport-relative-lengths","status":"cr","links":[{"url":"http://css-tricks.com/viewport-sized-typography/","title":"Blog post"},{"url":"https://github.com/saabi/vminpoly","title":"Polyfill"},{"url":"https://github.com/rodneyrehm/viewport-units-buggyfill","title":"Buggyfill - Polyfill that fixes buggy support"},{"url":"http://blog.rodneyrehm.de/archives/34-iOS7-Mobile-Safari-And-Viewport-Units.html","title":"Back-Forward issue blog post"}],"categories":["CSS3"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"a","10":"a","11":"a","TP":"a"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"a","21":"a","22":"a","23":"a","24":"a","25":"a","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"a","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"a","7.0-7.1":"a","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"n","10":"a"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"a #1","11":"a #1"},"and_uc":{"9.9":"n"}},"notes":"Partial support in IE9 refers to supporting \"vm\" instead of \"vmin\".\r\n\r\nPartial support in iOS7 is due to buggy behavior of the \"vh\" unit (see [workaround](https://gist.github.com/pburtchaell/e702f441ba9b3f76f587)).\r\n\r\nAll other partial support refers to not supporting the \"vmax\" unit. ","notes_by_num":{},"usage_perc_y":65.33,"usage_perc_a":15.6,"ucprefix":false,"parent":"","keywords":"vm,viewport-percentage","ie_id":"","chrome_id":""},"contentsecuritypolicy":{"title":"Content Security Policy 1.0","description":"Mitigate cross-site scripting attacks by whitelisting allowed sources of script, style, and other resources.","spec":"http://www.w3.org/TR/CSP/","status":"cr","links":[{"url":"http://html5rocks.com/en/tutorials/security/content-security-policy/","title":"HTML5Rocks article"},{"url":"http://content-security-policy.com/","title":"CSP Examples & Quick Reference"}],"categories":["Other"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"a #1","11":"a #1","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"y #1","5":"y #1","6":"y #1","7":"y #1","8":"y #1","9":"y #1","10":"y #1","11":"y #1","12":"y #1","13":"y #1","14":"y #1","15":"y #1","16":"y #1","17":"y #1","18":"y #1","19":"y #1","20":"y #1","21":"y #1","22":"y #1","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"y #2","15":"y #2","16":"y #2","17":"y #2","18":"y #2","19":"y #2","20":"y #2","21":"y #2","22":"y #2","23":"y #2","24":"y #2","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"a #2","6":"y #2","6.1":"y #2","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"a #2","6.0-6.1":"y #2","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"n","10":"y #2"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"a #1","11":"a #1"},"and_uc":{"9.9":"y x"}},"notes":"The standard HTTP header is `Content-Security-Policy` which is used unless otherwise noted.","notes_by_num":{"1":"Supported through the `X-Content-Security-Policy` header","2":"Supported through the `X-Webkit-CSP` header"},"usage_perc_y":72.49,"usage_perc_a":11.16,"ucprefix":false,"parent":"","keywords":"csp,security,header","ie_id":"contentsecuritypolicy","chrome_id":"5205088045891584"},"pagevisibility":{"title":"Page Visibility","description":"JavaScript API for determining whether a document is visible on the display","spec":"http://www.w3.org/TR/page-visibility/","status":"rec","links":[{"url":"https://developer.mozilla.org/en-US/docs/DOM/Using_the_Page_Visibility_API","title":"MDN article"},{"url":"http://docs.webplatform.org/wiki/apis/timing/properties/visibilityState","title":"WebPlatform Docs"},{"url":"http://www.sitepoint.com/introduction-to-page-visibility-api/","title":"SitePoint article"},{"url":"http://aurelio.audero.it/demo/page-visibility-api-demo.html","title":"Demo"}],"categories":["JS API"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"y","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"y x","11":"y x","12":"y x","13":"y x","14":"y x","15":"y x","16":"y x","17":"y x","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"y x","15":"y x","16":"y x","17":"y x","18":"y x","19":"y x","20":"y x","21":"y x","22":"y x","23":"y x","24":"y x","25":"y x","26":"y x","27":"y x","28":"y x","29":"y x","30":"y x","31":"y x","32":"y x","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y #1","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"y","15":"y x","16":"y x","17":"y x","18":"y x","19":"y x","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"y x","4.4.3-4.4.4":"y x","37":"y"},"bb":{"7":"n","10":"y x"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y x"}},"notes":"","notes_by_num":{},"usage_perc_y":82.99,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"visibilitystate","ie_id":"pagevisibilityapi","chrome_id":"5689697795833856"},"stricttransportsecurity":{"title":"Strict Transport Security","description":"Declare that a website is only accessible over a secure connection (HTTPS).","spec":"http://tools.ietf.org/html/rfc6797","status":"other","links":[{"url":"http://dev.chromium.org/sts","title":"Chromium article"},{"url":"https://developer.mozilla.org/en-US/docs/Security/HTTP_Strict_Transport_Security","title":"MDN article"},{"url":"https://www.owasp.org/index.php/HTTP_Strict_Transport_Security","title":"OWASP article"}],"categories":["Other"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"n","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"u","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"u"}},"notes":"The HTTP header is 'Strict-Transport-Security'.","notes_by_num":{},"usage_perc_y":66.41,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"sts,hsts,security,header","ie_id":"httpstricttransportsecurityhsts","chrome_id":"4941480133132288"},"style-scoped":{"title":"Scoped CSS","description":"Allows CSS rules to be scoped to part of the document, based on the position of the style element.","spec":"https://html.spec.whatwg.org/multipage/semantics.html#attr-style-scoped","status":"ls","links":[{"url":"https://github.com/PM5544/scoped-polyfill","title":"Polyfill"},{"url":"http://html5doctor.com/the-scoped-attribute/","title":"HTML5 Doctor article"},{"url":"http://updates.html5rocks.com/2012/03/A-New-Experimental-Feature-style-scoped","title":"HTML5Rocks article"}],"categories":["CSS","HTML5"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n d #1","21":"n d #1","22":"n d #1","23":"n d #1","24":"n d #1","25":"n d #1","26":"n d #1","27":"n d #1","28":"n d #1","29":"n d #1","30":"n d #1","31":"n d #1","32":"n d #1","33":"n d #1","34":"n d #1","35":"n d #1","36":"n d #1","37":"n","38":"n","39":"n","40":"n","41":"n","42":"n","43":"n"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"n","7":"n","7.1":"n","8":"n"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"n","8.1":"n"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"n","4.4.3-4.4.4":"n","37":"n"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"u","24":"n"},"and_chr":{"40":"n"},"and_ff":{"33":"y"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"y"}},"notes":"","notes_by_num":{"1":"Enabled in Chrome through the \"experimental Web Platform features\" flag in chrome://flags"},"usage_perc_y":15.1,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"scope","ie_id":"scopedstyles","chrome_id":"5374137958662144"},"svg-fragment":{"title":"SVG fragment identifiers","description":"Method of displaying only a part of an SVG image by defining a view ID or view box dimensions as the file's fragment identifier.","spec":"http://www.w3.org/TR/SVG/linking.html#SVGFragmentIdentifiers","status":"rec","links":[{"url":"http://www.broken-links.com/2012/08/14/better-svg-sprites-with-fragment-identifiers/","title":"Blog post"}],"categories":["SVG"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"y","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"n","34":"n","35":"n","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"n","7":"n","7.1":"y","8":"y"},"opera":{"9":"u","9.5-9.6":"u","10.0-10.1":"u","10.5":"u","10.6":"u","11":"u","11.1":"u","11.5":"u","11.6":"u","12":"u","12.1":"y","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"y"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"n","4.4.3-4.4.4":"n","37":"y"},"bb":{"7":"n","10":"y"},"op_mob":{"10":"u","11":"u","11.1":"u","11.5":"u","12":"u","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"n"}},"notes":"","notes_by_num":{},"usage_perc_y":72.46,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"fragments,sprite","ie_id":"","chrome_id":""},"outline":{"title":"CSS outline","description":"The CSS outline property is a shorthand property for setting one or more of the individual outline properties outline-style, outline-width and outline-color in a single rule. In most cases the use of this shortcut is preferable and more convenient.","spec":"http://www.w3.org/TR/CSS2/ui.html#propdef-outline","status":"rec","links":[{"url":"http://dev.w3.org/csswg/css3-ui/#outline","title":"CSS Basic User Interface Module Level 3"},{"url":"https://developer.mozilla.org/en-US/docs/CSS/outline","title":"Mozilla Developer Network: outline"}],"categories":["CSS2"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"y","9":"y #1","10":"y #1","11":"y #1","TP":"y #1"},"firefox":{"2":"y","3":"y","3.5":"y","3.6":"y","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"y","3.2":"y","4":"y","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"y","9.5-9.6":"y","10.0-10.1":"y","10.5":"y","10.6":"y","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y #1","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"y","4.0-4.1":"y","4.2-4.3":"y","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"y","2.2":"y","2.3":"y","3":"y","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"y","11":"y","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y #1","11":"y #1"},"and_uc":{"9.9":"y"}},"notes":"","notes_by_num":{"1":"Also supports the value of `invert` for `outline-color`. (support of this value is optional for browsers)"},"usage_perc_y":93.78,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"-moz-outline,outline-width,outline-style,outline-color","ie_id":"","chrome_id":""},"download":{"title":"Download attribute","description":"When used on an anchor, this attribute signifies that the browser should download the resource the anchor points to rather than navigate to it.","spec":"https://html.spec.whatwg.org/multipage/semantics.html#downloading-resources","status":"ls","links":[{"url":"http://updates.html5rocks.com/2011/08/Downloading-resources-in-HTML5-a-download","title":"HTML5Rocks post"},{"url":"http://html5-demos.appspot.com/static/a.download.html","title":"Demo: creating a text file and downloading it."}],"categories":["HTML5"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"n","7":"n","7.1":"n","8":"n"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"n","8.1":"n"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"n","10":"y"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"n"}},"notes":"","notes_by_num":{},"usage_perc_y":58.17,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"download,a.download,a[download],download attribute","ie_id":"adownloadattribute","chrome_id":"6473924464345088"},"pointer":{"title":"Pointer events","description":"This specification integrates various inputs from mice, touchscreens, and pens, making separate implementations no longer necessary and authoring for cross-device pointers easier. Not to be mistaken with the unrelated \"pointer-events\" CSS property.","spec":"http://www.w3.org/TR/pointerevents/","status":"cr","links":[{"url":"http://blogs.msdn.com/b/ie/archive/2011/09/20/touch-input-for-ie10-and-metro-style-apps.aspx","title":"Implementation of Pointer Events in IE10"},{"url":"http://blogs.msdn.com/b/eternalcoding/archive/2013/01/16/hand-js-a-polyfill-for-supporting-pointer-events-on-every-browser.aspx","title":"Hand.js, the polyfill for browsers only supporting Touch Events"},{"url":"http://blogs.msdn.com/b/davrous/archive/2013/02/20/handling-touch-in-your-html5-apps-thanks-to-the-pointer-events-of-ie10-and-windows-8.aspx","title":"Article & tutorial"}],"categories":["DOM","JS API"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"a x","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"p","7":"p","8":"p","9":"p","10":"p","11":"p","12":"p","13":"p","14":"p","15":"p","16":"p","17":"p","18":"p","19":"p","20":"p","21":"p","22":"p","23":"p","24":"p","25":"p","26":"p","27":"p","28":"p","29":"p","30":"p","31":"p","32":"p","33":"p","34":"p","35":"p","36":"p","37":"p","38":"p"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"p","23":"p","24":"p","25":"p","26":"p","27":"p","28":"p","29":"p","30":"p","31":"p","32":"p","33":"p","34":"p","35":"p","36":"p","37":"p","38":"p","39":"p","40":"p","41":"p","42":"p","43":"p"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"u","7":"u","7.1":"u","8":"u"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"p","16":"p","17":"p","18":"p","19":"p","20":"p","21":"p","22":"p","23":"p","24":"p","25":"p","26":"p","27":"p","28":"p","29":"p"},"ios_saf":{"3.2":"p","4.0-4.1":"p","4.2-4.3":"p","5.0-5.1":"p","6.0-6.1":"p","7.0-7.1":"p","8":"p","8.1":"p"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"p","2.2":"p","2.3":"p","3":"p","4":"p","4.1":"p","4.2-4.3":"p","4.4":"p","4.4.3-4.4.4":"p","37":"p"},"bb":{"7":"p","10":"p"},"op_mob":{"10":"n","11":"p","11.1":"p","11.5":"p","12":"p","12.1":"p","24":"p"},"and_chr":{"40":"p"},"and_ff":{"33":"p"},"ie_mob":{"10":"a x","11":"y"},"and_uc":{"9.9":"p"}},"notes":"Partial support in IE10 refers the lack of pointerenter and pointerleave events. Firefox Nightly provides 'dom.w3c_pointer_events.enabled' option to support this specification starting with version 28.","notes_by_num":{},"usage_perc_y":8.74,"usage_perc_a":1.97,"ucprefix":false,"parent":"","keywords":"pointerdown,pointermove,pointerup,pointercancel,pointerover,pointerout,pointerenter,pointerleave","ie_id":"pointerevents","chrome_id":"4504699138998272"},"user-select-none":{"title":"CSS user-select: none","description":"Method of preventing text/element selection using CSS. ","spec":"https://developer.mozilla.org/en-US/docs/CSS/user-select","status":"unoff","links":[{"url":"https://developer.mozilla.org/en-US/docs/CSS/user-select","title":"MDN article"},{"url":"http://css-tricks.com/almanac/properties/u/user-select/","title":"CSS Tricks article"},{"url":"http://msdn.microsoft.com/en-us/library/ie/hh781492(v=vs.85).aspx","title":"MSDN Documentation"}],"categories":["CSS"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"y x","11":"y x","TP":"y x"},"firefox":{"2":"y x","3":"y x","3.5":"y x","3.6":"y x","4":"y x","5":"y x","6":"y x","7":"y x","8":"y x","9":"y x","10":"y x","11":"y x","12":"y x","13":"y x","14":"y x","15":"y x","16":"y x","17":"y x","18":"y x","19":"y x","20":"y x","21":"y x","22":"y x","23":"y x","24":"y x","25":"y x","26":"y x","27":"y x","28":"y x","29":"y x","30":"y x","31":"y x","32":"y x","33":"y x","34":"y x","35":"y x","36":"y x","37":"y x","38":"y x"},"chrome":{"4":"u","5":"u","6":"y x","7":"y x","8":"y x","9":"y x","10":"y x","11":"y x","12":"y x","13":"y x","14":"y x","15":"y x","16":"y x","17":"y x","18":"y x","19":"y x","20":"y x","21":"y x","22":"y x","23":"y x","24":"y x","25":"y x","26":"y x","27":"y x","28":"y x","29":"y x","30":"y x","31":"y x","32":"y x","33":"y x","34":"y x","35":"y x","36":"y x","37":"y x","38":"y x","39":"y x","40":"y x","41":"y x","42":"y x","43":"y x"},"safari":{"3.1":"y x","3.2":"y x","4":"y x","5":"y x","5.1":"y x","6":"y x","6.1":"y x","7":"y x","7.1":"y x","8":"y x"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"y x","16":"y x","17":"y x","18":"y x","19":"y x","20":"y x","21":"y x","22":"y x","23":"y x","24":"y x","25":"y x","26":"y x","27":"y x","28":"y x","29":"y x"},"ios_saf":{"3.2":"y x","4.0-4.1":"y x","4.2-4.3":"y x","5.0-5.1":"y x","6.0-6.1":"y x","7.0-7.1":"y x","8":"y x","8.1":"y x"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"y x","2.2":"y x","2.3":"y x","3":"y x","4":"y x","4.1":"y x","4.2-4.3":"y x","4.4":"y x","4.4.3-4.4.4":"y x","37":"y x"},"bb":{"7":"y x","10":"y x"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"y x"},"and_chr":{"40":"y x"},"and_ff":{"33":"y x"},"ie_mob":{"10":"y x","11":"y x"},"and_uc":{"9.9":"y x"}},"notes":"Currently the user-select property does not appear in any W3C specification. Support information here is only for \"none\" value, not others.","notes_by_num":{},"usage_perc_y":87.2,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"","ie_id":"","chrome_id":""},"webp":{"title":"WebP image format","description":"Image format that supports lossy and lossless compression, as well as animation and alpha transparency.","spec":"https://developers.google.com/speed/webp/","status":"other","links":[{"url":"https://developers.google.com/speed/webp/","title":"Official website"},{"url":"http://antimatter15.github.io/weppy/demo.html","title":"Polyfill for browsers with WebM support"},{"url":"http://libwebpjs.appspot.com/","title":"Decoder in JS"},{"url":"http://webpjs.appspot.com/","title":"Polyfill for browsers with or without WebM support (i.e. IE6-IE9, Safari/iOS version 6.1 and below; Firefox versions 24 and bel"},{"url":"https://developers.google.com/speed/webp/faq#which_web_browsers_natively_support_webp","title":"Official website FAQ - Which web browsers natively support WebP?"}],"categories":["Other"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"p","5":"p","6":"p","7":"p","8":"p","9":"p","10":"p","11":"p","12":"p","13":"p","14":"p","15":"p","16":"p","17":"p","18":"p","19":"p","20":"p","21":"p","22":"p","23":"p","24":"p","25":"p","26":"p","27":"p","28":"p","29":"p","30":"p","31":"p","32":"p","33":"p","34":"p","35":"p","36":"p","37":"p","38":"p"},"chrome":{"4":"n","5":"n","6":"p","7":"p","8":"p","9":"a","10":"a","11":"a","12":"a","13":"a","14":"a","15":"a","16":"a","17":"a","18":"a","19":"a","20":"a","21":"a","22":"a","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"n","7":"n","7.1":"n","8":"n"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"p","11":"p","11.1":"a","11.5":"a","11.6":"a","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"n","8.1":"n"},"op_mini":{"5.0-8.0":"y"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"a","4.1":"a","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"n","11":"a","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"p"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"y"}},"notes":"Partial support in older Chrome, Opera and Android refers to browser not supporting lossless and alpha versions of WebP. Animated webp images are supported in Chrome 32+ and Opera 19+.","notes_by_num":{},"usage_perc_y":55.12,"usage_perc_a":1.75,"ucprefix":false,"parent":"","keywords":"","ie_id":"webpimageformatsupport","chrome_id":"6471725441089536,4785074604081152"},"intrinsic-width":{"title":"Intrinsic & Extrinsic Sizing","description":"Allows for the heights and widths to be specified in intrinsic values using the fill-available, max-content, min-content, and fit-content properties.","spec":"http://www.w3.org/TR/css3-sizing/","status":"wd","links":[{"url":"http://demosthenes.info/blog/662/Design-From-the-Inside-Out-With-CSS-MinContent","title":"Min-Content tutorial"}],"categories":["CSS3"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"y x","5":"y x","6":"y x","7":"y x","8":"y x","9":"y x","10":"y x","11":"y x","12":"y x","13":"y x","14":"y x","15":"y x","16":"y x","17":"y x","18":"y x","19":"y x","20":"y x","21":"y x","22":"y x","23":"y x","24":"y x","25":"y x","26":"y x","27":"y x","28":"y x","29":"y x","30":"y x","31":"y x","32":"y x","33":"y x","34":"y x","35":"y x","36":"y x","37":"y x","38":"y x"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"y x","23":"y x","24":"y x","25":"y x","26":"y x","27":"y x","28":"y x","29":"y x","30":"y x","31":"y x","32":"y x","33":"y x","34":"y x","35":"y x","36":"y x","37":"y x","38":"y x","39":"y x","40":"y x","41":"y x","42":"y x","43":"y x"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"y x","7":"y x","7.1":"y x","8":"y x"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"y x","16":"y x","17":"y x","18":"y x","19":"y x","20":"y x","21":"y x","22":"y x","23":"y x","24":"y x","25":"y x","26":"y x","27":"y x","28":"y x","29":"y x"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"y x","8":"y x","8.1":"y x"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"y x","4.4.3-4.4.4":"y x","37":"y x"},"bb":{"7":"n","10":"y x"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"y x"},"and_chr":{"40":"y x"},"and_ff":{"33":"y x"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"n"}},"notes":"Prefixes are on the values, not the property names (e.g. -webkit-min-content) Firefox currently supports the \"-moz-available\" property rather than \"-moz-fill-available\".","notes_by_num":{},"usage_perc_y":68.21,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"fill-available,max-content,min-content,fit-content,contain-floats","ie_id":"cssintrinsicsizing","chrome_id":"5901353784180736"},"cryptography":{"title":"Web Cryptography","description":"JavaScript API for performing basic cryptographic operations in web applications","spec":"http://www.w3.org/TR/WebCryptoAPI/","status":"wd","links":[{"url":"http://www.slideshare.net/Channy/the-history-and-status-of-web-crypto-api","title":"The History and Status of Web Crypto API"},{"url":"http://research.microsoft.com/en-us/projects/msrjscrypto/","title":"Microsoft Research JavaScript Cryptography Library"},{"url":"http://bitwiseshiftleft.github.io/sjcl/","title":"Cross-browser cryptography library"}],"categories":["JS API"],"stats":{"ie":{"5.5":"n","6":"p","7":"p","8":"p","9":"p","10":"p","11":"a x #1","TP":"y"},"firefox":{"2":"p","3":"p","3.5":"p","3.6":"p","4":"p","5":"p","6":"p","7":"p","8":"p","9":"p","10":"p","11":"p","12":"p","13":"p","14":"p","15":"p","16":"p","17":"p","18":"p","19":"p","20":"p","21":"p","22":"p","23":"p","24":"p","25":"p","26":"p","27":"p","28":"p","29":"p","30":"p","31":"p","32":"n d #2","33":"n d #2","34":"a #4","35":"a #4","36":"a #4","37":"a #4","38":"a #4"},"chrome":{"4":"p","5":"p","6":"p","7":"p","8":"p","9":"p","10":"p","11":"p","12":"p","13":"p","14":"p","15":"p","16":"p","17":"p","18":"p","19":"p","20":"p","21":"p","22":"p","23":"p","24":"p","25":"p","26":"p","27":"p","28":"p","29":"p","30":"p","31":"p","32":"p","33":"p","34":"p","35":"p","36":"p","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"p","3.2":"p","4":"p","5":"p","5.1":"p","6":"p","6.1":"p","7":"p","7.1":"y x #3","8":"y x #3"},"opera":{"9":"p","9.5-9.6":"p","10.0-10.1":"p","10.5":"p","10.6":"p","11":"p","11.1":"p","11.5":"p","11.6":"p","12":"p","12.1":"p","15":"p","16":"p","17":"p","18":"p","19":"p","20":"p","21":"p","22":"p","23":"p","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"p","4.0-4.1":"p","4.2-4.3":"p","5.0-5.1":"p","6.0-6.1":"p","7.0-7.1":"p","8":"y x #3","8.1":"y x #3"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"p","2.2":"p","2.3":"p","3":"p","4":"p","4.1":"p","4.2-4.3":"p","4.4":"p","4.4.3-4.4.4":"p","37":"y"},"bb":{"7":"p","10":"p"},"op_mob":{"10":"p","11":"p","11.1":"p","11.5":"p","12":"p","12.1":"p","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"p"},"ie_mob":{"10":"p","11":"a x #1"},"and_uc":{"9.9":"p"}},"notes":"Many browsers support the `[crypto.getRandomValues()](#feat=getrandomvalues)` method, but not actual cryptography functionality under `crypto.subtle`. \r\n\r\nFirefox also has support for [unofficial features](https://developer.mozilla.org/en-US/docs/JavaScript_crypto). \r\n\r\nIn Chrome the API is only usable over secure connections. ([corresponding bug](https://code.google.com/p/chromium/issues/detail?id=373032))","notes_by_num":{"1":"Support in IE11 is based an older version of the specification. ","2":"Supported in Firefox behind the `dom.webcrypto.enabled` flag. ","3":"Supported in Safari using the `crypto.webkitSubtle` prefix","4":"Partial support in Firefox is [described here](https://docs.google.com/spreadsheet/ccc?key=0AiAcidBZRLxndE9LWEs2R1oxZ0xidUVoU3FQbFFobkE#gid=1)"},"usage_perc_y":46.02,"usage_perc_a":15.49,"ucprefix":false,"parent":"","keywords":"subtle,subtlecrypto","ie_id":"webcryptoapi","chrome_id":"5030265697075200"},"template":{"title":"HTML templates","description":"Method of declaring a portion of reusable markup that is parsed but not rendered until cloned.","spec":"https://html.spec.whatwg.org/multipage/scripting.html#the-template-element","status":"ls","links":[{"url":"http://www.html5rocks.com/en/tutorials/webcomponents/template/","title":"HTML5Rocks - HTML's New template Tag"},{"url":"http://polymer-project.org","title":"Polymer project (polyfill & web components framework)"}],"categories":["DOM","HTML5"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"n","7":"n","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"n"}},"notes":"","notes_by_num":{},"usage_perc_y":64.51,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"web components, template","ie_id":"templateelement","chrome_id":"5207287069147136"},"opus":{"title":"Opus","description":"Royalty-free open audio codec by IETF, which incorporated SILK from Skype and CELT from Xiph.org, to serve higher sound quality and lower latency at the same bitrate.","spec":"http://tools.ietf.org/html/rfc6716","status":"other","links":[{"url":"https://hacks.mozilla.org/2012/07/firefox-beta-15-supports-the-new-opus-audio-format/","title":"Introduction of Opus by Mozilla"},{"url":"http://www.ietf.org/mail-archive/web/rtcweb/current/msg04953.html","title":"Google's statement about the use of VP8 and Opus codec for WebRTC standard"}],"categories":["Other"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"n","7":"n","7.1":"n","8":"n"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"n","8.1":"n"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"n","4.4.3-4.4.4":"n","37":"n"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"n"},"and_chr":{"40":"n"},"and_ff":{"33":"y"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"n"}},"notes":"For Opera the Linux version may be able to play it when the GStreamer module is up to date and the served mime-type is 'audio/ogg'.","notes_by_num":{},"usage_perc_y":42.58,"usage_perc_a":0,"ucprefix":false,"parent":"audio","keywords":"","ie_id":"","chrome_id":"4891189287321600"},"jpegxr":{"title":"JPEG XR image format","description":"The latest JPEG image format of Joint Photographic Experts Group which boasts better compression and supports lossless compression, alpha channel, and 48-bit deep color over normal jpg format.","spec":"http://www.itu.int/rec/T-REC-T.832","status":"other","links":[{"url":"http://msdn.microsoft.com/en-us/library/windows/desktop/hh707223(v=vs.85).aspx","title":"Microsoft JPEG XR Codec Overview"}],"categories":["Other"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"y","10":"y","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"n","34":"n","35":"n","36":"n","37":"n","38":"n"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"n","34":"n","35":"n","36":"n","37":"n","38":"n","39":"n","40":"n","41":"n","42":"n","43":"n"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"n","7":"n","7.1":"n","8":"n"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"n","8.1":"n"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"n","4.4.3-4.4.4":"n","37":"n"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"n"},"and_chr":{"40":"n"},"and_ff":{"33":"n"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"n"}},"notes":"","notes_by_num":{},"usage_perc_y":12.84,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"","ie_id":"","chrome_id":""},"channel-messaging":{"title":"Channel messaging","description":"Method for having two-way communication between browsing contexts (using MessageChannel)","spec":"http://www.w3.org/TR/webmessaging/#channel-messaging","status":"cr","links":[{"url":"https://dev.opera.com/articles/view/window-postmessage-messagechannel/#channel","title":"An Introduction to HTML5 web messaging"}],"categories":["JS API"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"y","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n d #1","27":"n d #1","28":"n d #1","29":"n d #1","30":"n d #1","31":"n d #1","32":"n d #1","33":"n d #1","34":"n d #1","35":"n d #1","36":"n d #1","37":"n d #1","38":"n d #1"},"chrome":{"4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"u","10.0-10.1":"u","10.5":"u","10.6":"y","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"u","11":"y","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"n"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y"}},"notes":"","notes_by_num":{"1":"Supported in Firefox behind the `dom.messageChannel.enabled` flag. Reported to not work in web workers."},"usage_perc_y":72.57,"usage_perc_a":0,"ucprefix":false,"parent":"x-doc-messaging","keywords":"","ie_id":"messagechannels","chrome_id":"6710044586409984"},"css3-tabsize":{"title":"CSS3 tab-size","description":"Method of customizing the width of the tab character. Only effective using 'white-space: pre' or 'white-space: pre-wrap'.","spec":"http://www.w3.org/TR/css3-text/#tab-size1","status":"wd","links":[{"url":"https://developer.mozilla.org/en-US/docs/Web/CSS/tab-size","title":"MDN article"}],"categories":["CSS3"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"y x","5":"y x","6":"y x","7":"y x","8":"y x","9":"y x","10":"y x","11":"y x","12":"y x","13":"y x","14":"y x","15":"y x","16":"y x","17":"y x","18":"y x","19":"y x","20":"y x","21":"y x","22":"y x","23":"y x","24":"y x","25":"y x","26":"y x","27":"y x","28":"y x","29":"y x","30":"y x","31":"y x","32":"y x","33":"y x","34":"y x","35":"y x","36":"y x","37":"y x","38":"y x"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"y x","11":"y x","11.1":"y x","11.5":"y x","11.6":"y x","12":"y x","12.1":"y x","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"y x"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"n","11":"y x","11.1":"y x","11.5":"y x","12":"y x","12.1":"y x","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y x"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"n"}},"notes":"","notes_by_num":{},"usage_perc_y":71.73,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"tab-size,tab-width","ie_id":"","chrome_id":""},"mutationobserver":{"title":"Mutation Observer","description":"Method for observing and reacting to changes to the DOM. Replaces MutationEvents, which is deprecated.","spec":"http://www.w3.org/TR/dom/","status":"wd","links":[{"url":"https://developer.mozilla.org/en-US/docs/Web/API/MutationObserver","title":"MutationObserver from MDN"},{"url":"https://github.com/webcomponents/webcomponentsjs","title":"Polyfill"}],"categories":["DOM","JS API"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"p","10":"p","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"y x","19":"y x","20":"y x","21":"y x","22":"y x","23":"y x","24":"y x","25":"y x","26":"y x","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"y x","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"y x","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"p","4.1":"p","4.2-4.3":"p","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"n","10":"y x"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"p","11":"y"},"and_uc":{"9.9":"y x"}},"notes":"When the content of a node with a single CharacterData child node is changed by innerHTML attribute and the node have a single different one as a result, WebKit browsers consider it as a characterData mutation of the child CharacterData node, while other browsers think it as a childList mutation of the parent node.","notes_by_num":{},"usage_perc_y":80.84,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"MutationObserver","ie_id":"mutationobservers","chrome_id":"5021194726146048"},"css-selection":{"title":"::selection CSS pseudo-element","description":"The ::selection CSS pseudo-element applies rules to the portion of a document that has been highlighted (e.g., selected with the mouse or another pointing device) by the user.","spec":"https://developer.mozilla.org/en-US/docs/Web/CSS/::selection","status":"unoff","links":[{"url":"http://quirksmode.org/css/selectors/selection.html","title":"::selection test"},{"url":"http://docs.webplatform.org/wiki/css/selectors/pseudo-elements/::selection","title":"WebPlatform Docs"}],"categories":["CSS"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"y","10":"y","11":"y","TP":"y"},"firefox":{"2":"y x","3":"y x","3.5":"y x","3.6":"y x","4":"y x","5":"y x","6":"y x","7":"y x","8":"y x","9":"y x","10":"y x","11":"y x","12":"y x","13":"y x","14":"y x","15":"y x","16":"y x","17":"y x","18":"y x","19":"y x","20":"y x","21":"y x","22":"y x","23":"y x","24":"y x","25":"y x","26":"y x","27":"y x","28":"y x","29":"y x","30":"y x","31":"y x","32":"y x","33":"y x","34":"y x","35":"y x","36":"y x","37":"y x","38":"y x"},"chrome":{"4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"y","3.2":"y","4":"y","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"y","10.0-10.1":"y","10.5":"y","10.6":"y","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"n","8.1":"n"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"u","11":"u","11.1":"u","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y x"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"n"}},"notes":"","notes_by_num":{},"usage_perc_y":75.25,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"::selection,selection","ie_id":"","chrome_id":""},"css-placeholder":{"title":":placeholder-shown CSS pseudo-class","description":"The :placeholder-shown pseudo-class represents the placeholder contents of a form field with placeholder text.","spec":"http://dev.w3.org/csswg/selectors/#placeholder","status":"unoff","links":[{"url":"http://msdn.microsoft.com/en-us/library/ie/hh772745(v=vs.85).aspx","title":"MSDN article"},{"url":"http://css-tricks.com/snippets/css/style-placeholder-text/","title":"CSS-Tricks article with all prefixes"},{"url":"http://wiki.csswg.org/ideas/placeholder-styling","title":"CSSWG discussion"}],"categories":["CSS"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"a x","11":"a x","TP":"a x"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"a x","5":"a x","6":"a x","7":"a x","8":"a x","9":"a x","10":"a x","11":"a x","12":"a x","13":"a x","14":"a x","15":"a x","16":"a x","17":"a x","18":"a x","19":"a x","20":"a x","21":"a x","22":"a x","23":"a x","24":"a x","25":"a x","26":"a x","27":"a x","28":"a x","29":"a x","30":"a x","31":"a x","32":"a x","33":"a x","34":"a x","35":"a x","36":"a x","37":"a x","38":"a x"},"chrome":{"4":"a x","5":"a x","6":"a x","7":"a x","8":"a x","9":"a x","10":"a x","11":"a x","12":"a x","13":"a x","14":"a x","15":"a x","16":"a x","17":"a x","18":"a x","19":"a x","20":"a x","21":"a x","22":"a x","23":"a x","24":"a x","25":"a x","26":"a x","27":"a x","28":"a x","29":"a x","30":"a x","31":"a x","32":"a x","33":"a x","34":"a x","35":"a x","36":"a x","37":"a x","38":"a x","39":"a x","40":"a x","41":"a x","42":"a x","43":"a x"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"a x","5.1":"a x","6":"a x","6.1":"a x","7":"a x","7.1":"a x","8":"a x"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"a x","16":"a x","17":"a x","18":"a x","19":"a x","20":"a x","21":"a x","22":"a x","23":"a x","24":"a x","25":"a x","26":"a x","27":"a x","28":"a x","29":"a x"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"a x","5.0-5.1":"a x","6.0-6.1":"a x","7.0-7.1":"a x","8":"a x","8.1":"a x"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"a x","2.2":"a x","2.3":"a x","3":"a x","4":"a x","4.1":"a x","4.2-4.3":"a x","4.4":"a x","4.4.3-4.4.4":"a x","37":"a x"},"bb":{"7":"u","10":"a x"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"a x"},"and_chr":{"40":"a x"},"and_ff":{"33":"a x"},"ie_mob":{"10":"a x","11":"a x"},"and_uc":{"9.9":"a x"}},"notes":"Partial support refers to support for alternative syntax: ::-webkit-input-placeholder (Chrome/Safari/Opera),\r\n::-moz-placeholder (Firefox) and \r\n:-ms-input-placeholder (IE). ","notes_by_num":{},"usage_perc_y":0,"usage_perc_a":86.95,"ucprefix":false,"parent":"","keywords":"::placeholder,placeholder","ie_id":"","chrome_id":""},"css-deviceadaptation":{"title":"CSS Device Adaptation","description":"A standard way to override the size of viewport in web page, standardizing and replacing Apple's own popular <meta> viewport implementation.","spec":"http://www.w3.org/TR/css-device-adapt/","status":"wd","links":[{"url":"https://dev.opera.com/articles/view/an-introduction-to-meta-viewport-and-viewport/","title":"Introduction to meta viewport and @viewport in Opera Mobile"},{"url":"http://msdn.microsoft.com/en-us/library/ie/hh708740(v=vs.85).aspx","title":"Device adaptation in Internet Explorer 10"}],"categories":["CSS"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"a x #1","11":"a x #1","TP":"a x #1"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"n","34":"n","35":"n","36":"n","37":"n","38":"n"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"n","34":"n","35":"n","36":"n","37":"n","38":"n","39":"n","40":"n","41":"n","42":"n","43":"n"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"u","7":"u","7.1":"u","8":"u"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"n","8.1":"n"},"op_mini":{"5.0-8.0":"a x #2"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"n","4.4.3-4.4.4":"n","37":"n"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"n","11":"a x #2","11.1":"a x #2","11.5":"a x #2","12":"a x #2","12.1":"a x #2","24":"n"},"and_chr":{"40":"n"},"and_ff":{"33":"n"},"ie_mob":{"10":"a x #1","11":"a x #1"},"and_uc":{"9.9":"n"}},"notes":"","notes_by_num":{"1":"IE only supports the 'width' and 'height' properties.","2":"Opera Mobile and Opera Mini only support the 'orientation' property."},"usage_perc_y":0,"usage_perc_a":13.81,"ucprefix":false,"parent":"","keywords":"viewport","ie_id":"","chrome_id":""},"text-emphasis":{"title":"text-emphasis styling","description":"Method of using small symbols next to each glyph to emphasize a run of text, commonly used in East Asian languages. The `text-emphasis` shorthand, and its `text-emphasis-style` and `text-emphasis-color` longhands, can be used to apply marks to the text. The `text-emphasis-position` property, which inherits separately, allows setting the emphasis marks' position with respect to the text.","spec":"http://www.w3.org/TR/css-text-decor-3/#text-emphasis","status":"cr","links":[{"url":"https://github.com/zmmbreeze/jquery.emphasis/","title":"A javascript fallback for CSS3 emphasis mark."}],"categories":["CSS3"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"n","34":"n","35":"n","36":"n","37":"n","38":"n"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"a x #1","26":"a x #1","27":"a x #1","28":"a x #1","29":"a x #1","30":"a x #1","31":"a x #1","32":"a x #1","33":"a x #1","34":"a x #1","35":"a x #1","36":"a x #1","37":"a x #1","38":"a x #1","39":"a x #1","40":"a x #1","41":"a x #1","42":"a x #1","43":"a x #1"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"a x #1","7":"a x #1","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"a x #1","16":"a x #1","17":"a x #1","18":"a x #1","19":"a x #1","20":"a x #1","21":"a x #1","22":"a x #1","23":"a x #1","24":"a x #1","25":"a x #1","26":"a x #1","27":"a x #1","28":"a x #1","29":"a x #1"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"a x #1","4.4.3-4.4.4":"a x #1","37":"a x #1"},"bb":{"7":"u","10":"u"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"a x #1"},"and_chr":{"40":"a x #1"},"and_ff":{"33":"n"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"a x #1"}},"notes":"Some old webkit browsers (like Chrome 24) support `-webkit-text-emphasis`, but does not support CJK languages and is therefore considered unsupported.","notes_by_num":{"1":"Partial support refers to incorrect support for `-webkit-text-emphasis-position`. These browsers support `over` and `under` as values, but not the added `left` and `right` values required by the spec."},"usage_perc_y":9.02,"usage_perc_a":50.97,"ucprefix":false,"parent":"","keywords":"text-emphasis,text-emphasis-position,text-emphasis-style,text-emphasis-color","ie_id":"","chrome_id":""},"canvas-blending":{"title":"Canvas blend modes","description":"Method of defining the effect resulting from overlaying two layers on a Canvas element. ","spec":"http://www.w3.org/TR/compositing-1/#blending","status":"cr","links":[{"url":"http://blogs.adobe.com/webplatform/2013/01/28/blending-features-in-canvas/","title":"Blog post"}],"categories":["Canvas"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"n","16":"n","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"n"}},"notes":"","notes_by_num":{},"usage_perc_y":67.25,"usage_perc_a":0,"ucprefix":false,"parent":"canvas","keywords":"","ie_id":"compositingandblendingincanvas2d","chrome_id":""},"clipboard":{"title":"Clipboard API","description":"API to provide copy, cut and paste functionality using the OS clipboard.","spec":"http://www.w3.org/TR/clipboard-apis/","status":"wd","links":[{"url":"https://developer.mozilla.org/en-US/docs/Web/API/ClipboardEvent","title":"MDN page on ClipboardEvent"},{"url":"http://www.deluxeblogtips.com/2010/06/javascript-copy-to-clipboard.html","title":"Blog post on cross-browser usage"}],"categories":["JS API"],"stats":{"ie":{"5.5":"a #1","6":"a #1","7":"a #1","8":"a #1","9":"a #1","10":"a #1","11":"a #1","TP":"a #1"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"a","14":"a","15":"a","16":"a","17":"a","18":"a","19":"a","20":"a","21":"a","22":"a","23":"a","24":"a","25":"a","26":"a","27":"a","28":"a","29":"a","30":"a","31":"a","32":"a","33":"a","34":"a","35":"a","36":"a","37":"a","38":"a","39":"a","40":"a","41":"a","42":"a","43":"a"},"safari":{"3.1":"u","3.2":"u","4":"a","5":"a","5.1":"a","6":"a","6.1":"a","7":"a","7.1":"a","8":"a"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"n","16":"a","17":"a","18":"a","19":"a","20":"a","21":"a","22":"a","23":"a","24":"a","25":"a","26":"a","27":"a","28":"a","29":"a"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"a","6.0-6.1":"a","7.0-7.1":"a","8":"a","8.1":"a"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"a","4.4.3-4.4.4":"a","37":"a"},"bb":{"7":"n","10":"a"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"a"},"and_chr":{"40":"a"},"and_ff":{"33":"y"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"n"}},"notes":"Partial support in IE refers using [a non-standard method](http://msdn.microsoft.com/en-us/library/ie/ms535220%28v=vs.85%29.aspx) of interacting with the clipboard. For other browsers it refers to not supporting the ClipboardEvent constructor.","notes_by_num":{},"usage_perc_y":11.28,"usage_perc_a":73.95,"ucprefix":false,"parent":"","keywords":"cut,copy,paste,clipboarddata","ie_id":"","chrome_id":""},"rtcpeerconnection":{"title":"WebRTC Peer-to-peer connections","description":"Method of allowing two users to communicate directly, browser to browser using the RTCPeerConnection API.","spec":"http://www.w3.org/TR/webrtc/#peer-to-peer-connections","status":"wd","links":[{"url":"http://www.webrtc.org/","title":"WebRTC Project site"}],"categories":["JS API"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"y x","23":"y x","24":"y x","25":"y x","26":"y x","27":"y x","28":"y x","29":"y x","30":"y x","31":"y x","32":"y x","33":"y x","34":"y x","35":"y x","36":"y x","37":"y x","38":"y x"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"y x","24":"y x","25":"y x","26":"y x","27":"y x","28":"y x","29":"y x","30":"y x","31":"y x","32":"y x","33":"y x","34":"y x","35":"y x","36":"y x","37":"y x","38":"y x","39":"y x","40":"y x","41":"y x","42":"y x","43":"y x"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"n","7":"n","7.1":"n","8":"n"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"n","16":"n","17":"n","18":"y x","19":"y x","20":"y x","21":"y x","22":"y x","23":"y x","24":"y x","25":"y x","26":"y x","27":"y x","28":"y x","29":"y x"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"n","8.1":"n"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"n","4.4.3-4.4.4":"n","37":"y x"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"y x"},"and_chr":{"40":"y x"},"and_ff":{"33":"y x"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"n"}},"notes":"BlackBerry 10 recognizes RTCPeerConnection but real support is unconfirmed.","notes_by_num":{},"usage_perc_y":54.27,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"","ie_id":"webrtcwebrtcv10api","chrome_id":"6612462929444864"},"css3-cursors":{"title":"CSS3 Cursors (original values)","description":"CSS3 cursor values added in the 2004 spec, including none, context-menu, cell, vertical-text, alias, copy, no-drop, not-allowed, nesw-resize, nwse-resize, col-resize, row-resize and all-scroll. ","spec":"http://www.w3.org/TR/css3-ui/#cursor","status":"wd","links":[{"url":"https://developer.mozilla.org/en-US/docs/Web/CSS/cursor","title":"MDN Documentation"}],"categories":["CSS3"],"stats":{"ie":{"5.5":"a","6":"a","7":"a","8":"a","9":"y","10":"y","11":"y","TP":"y"},"firefox":{"2":"a","3":"a","3.5":"a","3.6":"a","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"a","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"a","3.2":"a","4":"a","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"a","9.5-9.6":"a","10.0-10.1":"a","10.5":"a","10.6":"a","11":"a","11.1":"a","11.5":"a","11.6":"a","12":"a","12.1":"a","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"n","8.1":"n"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"n","4.4.3-4.4.4":"n","37":"n"},"bb":{"7":"n","10":"u"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"n"},"and_chr":{"40":"n"},"and_ff":{"33":"n"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"n"}},"notes":"Partial support in IE refers to no support for the alias, cell, copy, ew-resize, ns-resize, nesw-resize, nwse-resize or context-menu cursors. Opera 12.10- does not support 'none' or a URI.","notes_by_num":{},"usage_perc_y":59.79,"usage_perc_a":4.87,"ucprefix":false,"parent":"","keywords":"cursors, pointers","ie_id":"","chrome_id":""},"css3-cursors-newer":{"title":"CSS3 Cursors (new values)","description":"Support for `zoom-in` and `zoom-out` values for the CSS3 `cursor` property.","spec":"http://www.w3.org/TR/css3-ui/#cursor","status":"wd","links":[{"url":"https://developer.mozilla.org/en-US/docs/Web/CSS/cursor","title":"MDN Documentation"}],"categories":["CSS3"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"y x","3":"y x","3.5":"y x","3.6":"y x","4":"y x","5":"y x","6":"y x","7":"y x","8":"y x","9":"y x","10":"y x","11":"y x","12":"y x","13":"y x","14":"y x","15":"y x","16":"y x","17":"y x","18":"y x","19":"y x","20":"y x","21":"y x","22":"y x","23":"y x","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"y x","5":"y x","6":"y x","7":"y x","8":"y x","9":"y x","10":"y x","11":"y x","12":"y x","13":"y x","14":"y x","15":"y x","16":"y x","17":"y x","18":"y x","19":"y x","20":"y x","21":"y x","22":"y x","23":"y x","24":"y x","25":"y x","26":"y x","27":"y x","28":"y x","29":"y x","30":"y x","31":"y x","32":"y x","33":"y x","34":"y x","35":"y x","36":"y x","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"y x","3.2":"y x","4":"y x","5":"y x","5.1":"y x","6":"y x","6.1":"y x","7":"y x","7.1":"y x","8":"y x"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"y","12":"y","12.1":"y","15":"y x","16":"y x","17":"y x","18":"y x","19":"y x","20":"y x","21":"y x","22":"y x","23":"y x","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"n","8.1":"n"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"n","4.4.3-4.4.4":"n","37":"n"},"bb":{"7":"y x","10":"y x"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"n"},"and_chr":{"40":"n"},"and_ff":{"33":"n"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"n"}},"notes":"Chrome, Safari and Firefox also support the unofficial `grab` and `grabbing` values (with prefix)","notes_by_num":{},"usage_perc_y":48.23,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"cursors, pointers","ie_id":"","chrome_id":""},"webvtt":{"title":"WebVTT - Web Video Text Tracks","description":"Format for marking up text captions for multimedia resources.","spec":"http://dev.w3.org/html5/webvtt/","status":"unoff","links":[{"url":"http://www.html5rocks.com/en/tutorials/track/basics/","title":"Getting Started With the Track Element"},{"url":"https://dev.opera.com/articles/view/an-introduction-to-webvtt-and-track/","title":"An Introduction to WebVTT and track"}],"categories":["Other"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"y","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n d","25":"n d","26":"n d","27":"n d","28":"n d","29":"n d","30":"n d","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"n","10":"y"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"n","11":"y"},"and_uc":{"9.9":"n"}},"notes":"WebVTT must be used with the <track> element.\r\n\r\nFirefox currently lacks support for the ::cue pseudo-element.","notes_by_num":{},"usage_perc_y":77.56,"usage_perc_a":0,"ucprefix":false,"parent":"video","keywords":"captions,track","ie_id":"","chrome_id":"6719115557339136"},"promises":{"title":"Promises","description":"A promise represents the eventual result of an asynchronous operation.","spec":"https://people.mozilla.org/~jorendorff/es6-draft.html#sec-promise-objects","status":"other","links":[{"url":"http://promises-aplus.github.io/promises-spec/","title":"Promises/A+ spec"},{"url":"http://www.chromestatus.com/features/5681726336532480","title":"Chromium dashboard - ES6 Promises"},{"url":"http://www.html5rocks.com/en/tutorials/es6/promises/","title":"JavaScript Promises: There and back again - HTML5 Rocks"},{"url":"https://github.com/jakearchibald/ES6-Promises","title":"A polyfill for ES6-style Promises"}],"categories":["JS API"],"stats":{"ie":{"5.5":"p","6":"p","7":"p","8":"p","9":"p","10":"p","11":"p","TP":"y"},"firefox":{"2":"p","3":"p","3.5":"p","3.6":"p","4":"p","5":"p","6":"p","7":"p","8":"p","9":"p","10":"p","11":"p","12":"p","13":"p","14":"p","15":"p","16":"p","17":"p","18":"p","19":"p","20":"p","21":"p","22":"p","23":"p","24":"p","25":"p","26":"p","27":"a","28":"a","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"p","5":"p","6":"p","7":"p","8":"p","9":"p","10":"p","11":"p","12":"p","13":"p","14":"p","15":"p","16":"p","17":"p","18":"p","19":"p","20":"p","21":"p","22":"p","23":"p","24":"p","25":"p","26":"p","27":"p","28":"p","29":"p","30":"p","31":"p","32":"a","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"p","3.2":"p","4":"p","5":"p","5.1":"p","6":"p","6.1":"p","7":"p","7.1":"y","8":"y"},"opera":{"9":"p","9.5-9.6":"p","10.0-10.1":"p","10.5":"p","10.6":"p","11":"p","11.1":"p","11.5":"p","11.6":"p","12":"p","12.1":"p","15":"p","16":"p","17":"p","18":"p","19":"a","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"p","4.0-4.1":"p","4.2-4.3":"p","5.0-5.1":"p","6.0-6.1":"p","7.0-7.1":"p","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"p"},"android":{"2.1":"p","2.2":"p","2.3":"p","3":"p","4":"p","4.1":"p","4.2-4.3":"p","4.4":"p","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"p","10":"p"},"op_mob":{"10":"p","11":"p","11.1":"p","11.5":"p","12":"p","12.1":"p","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"p","11":"p"},"and_uc":{"9.9":"p"}},"notes":"","notes_by_num":{},"usage_perc_y":60.23,"usage_perc_a":0.31,"ucprefix":false,"parent":"","keywords":"futures","ie_id":"","chrome_id":"5681726336532480"},"css-sticky":{"title":"CSS position:sticky","description":"Keeps elements positioned as \"fixed\" or \"relative\" depending on how it appears in the viewport. As a result the element is \"stuck\" when necessary while scrolling.","spec":"http://dev.w3.org/csswg/css-position/#sticky-positioning","status":"unoff","links":[{"url":"http://updates.html5rocks.com/2012/08/Stick-your-landings-position-sticky-lands-in-WebKit","title":"HTML5Rocks"},{"url":"https://developer.mozilla.org/en-US/docs/Web/CSS/position","title":"MDN article"},{"url":"http://docs.webplatform.org/wiki/css/properties/position","title":"WebPlatform Docs"},{"url":"https://github.com/filamentgroup/fixed-sticky","title":"Polyfill"},{"url":"https://github.com/wilddeer/stickyfill","title":"Another polyfill"}],"categories":["CSS"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n d #1","27":"n d #1","28":"n d #1","29":"n d #1","30":"n d #1","31":"n d #1","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n d #2","24":"n d #2","25":"n d #2","26":"n d #2","27":"n d #2","28":"n d #2","29":"n d #2","30":"n d #2","31":"n d #2","32":"n d #2","33":"n d #2","34":"n d #2","35":"n d #2","36":"n d #2","37":"n","38":"n","39":"n","40":"n","41":"n","42":"n","43":"n"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"y x","7":"y x","7.1":"y x","8":"y x"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"y x","7.0-7.1":"y x","8":"y x","8.1":"y x"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"n","4.4.3-4.4.4":"n","37":"n"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"n"},"and_chr":{"40":"n"},"and_ff":{"33":"y"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"n"}},"notes":"","notes_by_num":{"1":"Can be enabled in Firefox by setting the about:config preference layout.css.sticky.enabled to true","2":"Enabled in Chrome through the \"experimental Web Platform features\" flag in chrome://flags"},"usage_perc_y":20.09,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"","ie_id":"positionsticky","chrome_id":"6190250464378880"},"dialog":{"title":"Dialog element","description":"Method of easily creating custom dialog boxes to display to the user with modal or non-modal options. Also includes a `::backdrop` pseudo-element for behind the element.","spec":"https://html.spec.whatwg.org/multipage/forms.html#the-dialog-element","status":"ls","links":[{"url":"https://github.com/GoogleChrome/dialog-polyfill","title":"Polyfill"}],"categories":["DOM","HTML5"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"n","34":"n","35":"n","36":"u","37":"u","38":"u"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n d #1","33":"n d #1","34":"n d #1","35":"n d #1","36":"n d #1","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"n","7":"n","7.1":"n","8":"n"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"n","16":"n","17":"n","18":"n","19":"n d #2","20":"n d #2","21":"n d #2","22":"n d #2","23":"n d #2","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"n","8.1":"n"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"n","4.4.3-4.4.4":"n","37":"y"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"n"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"n"}},"notes":"","notes_by_num":{"1":"Enabled through the \"Experimental Web Platform features\" flag in `chrome://flags`","2":"Enabled through the \"Experimental Web Platform features\" flag in `opera://flags`"},"usage_perc_y":39.23,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"HTMLDialogElement,showModal,backdrop","ie_id":"","chrome_id":"5770237022568448"},"css-variables":{"title":"CSS Variables","description":"Permits the declaration and usage of cascading variables in stylesheets.","spec":"http://www.w3.org/TR/css-variables/","status":"wd","links":[{"url":"https://hacks.mozilla.org/2013/12/css-variables-in-firefox-nightly/","title":"Mozilla hacks article (older syntax)"},{"url":"https://developer.mozilla.org/en-US/docs/Web/CSS/Using_CSS_variables","title":"MDN article"}],"categories":["CSS3"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"n","34":"n","35":"n","36":"n","37":"n","38":"n","39":"n","40":"n","41":"u","42":"u","43":"u"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"n","7":"n","7.1":"n","8":"n"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"u","29":"u"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"n","8.1":"n"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"n","4.4.3-4.4.4":"n","37":"n"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"n"},"and_chr":{"40":"n"},"and_ff":{"33":"y"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"n"}},"notes":"","notes_by_num":{},"usage_perc_y":10.61,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"css variables","ie_id":"cssvariables","chrome_id":"6401356696911872"},"vibration":{"title":"Vibration API","description":"Method to access the vibration mechanism of the hosting device.","spec":"http://www.w3.org/TR/vibration/","status":"pr","links":[{"url":"https://developer.mozilla.org/en-US/docs/Web/Guide/API/Vibration","title":"MDN article"},{"url":"http://davidwalsh.name/vibration-api","title":"Vibration API sample code & demo"},{"url":"http://code.tutsplus.com/tutorials/html5-vibration-api--mobile-22585","title":"Tuts+ article"},{"url":"http://aurelio.audero.it/demo/vibration-api-demo.html","title":"Demo"},{"url":"http://www.illyism.com/journal/vibration-api","title":"Article and Usage Examples"}],"categories":["JS API"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"y x","12":"y x","13":"y x","14":"y x","15":"y x","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"n","7":"n","7.1":"n","8":"n"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"n","16":"n","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"n","8.1":"n"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"n","10":"y"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"y"}},"notes":"","notes_by_num":{},"usage_perc_y":61.63,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"vibration,mobile,device","ie_id":"vibrationapi","chrome_id":"5698768766763008"},"css-backgroundblendmode":{"title":"CSS background-blend-mode","description":"Allows blending between CSS background images, gradients, and colors.","spec":"http://www.w3.org/TR/compositing-1/#background-blend-mode","status":"cr","links":[{"url":"http://codepen.io/bennettfeely/pen/rxoAc","title":"codepen example"},{"url":"https://medium.com/web-design-technique/6b51bf53743a","title":"Blog post"},{"url":"http://bennettfeely.com/gradients","title":"Demo"}],"categories":["CSS"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"n","34":"n","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"n","7":"n","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"n","4.4.3-4.4.4":"n","37":"y"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"n"}},"notes":"","notes_by_num":{},"usage_perc_y":58.3,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"css blend modes,css blending modes,blending,multiply,screen,background","ie_id":"","chrome_id":"5768037999312896"},"css-mixblendmode":{"title":"Blending of HTML/SVG elements","description":"Allows blending between arbitrary SVG and HTML elements","spec":"http://www.w3.org/TR/compositing-1/#mix-blend-mode","status":"cr","links":[{"url":"http://codepen.io/bennettfeely/pen/csjzd","title":"codepen example"},{"url":"http://css-tricks.com/basics-css-blend-modes/","title":"Blog post"}],"categories":["CSS"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n d #1","30":"n d #1","31":"n d #1","32":"n d #1","33":"n d #1","34":"n d #1","35":"n d #1","36":"n d #1","37":"n d #1","38":"n d #1","39":"n d #1","40":"n d #1","41":"n d #1","42":"n d #1","43":"n d #1"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"n","7":"n","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"n","4.4.3-4.4.4":"n","37":"n"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"n"},"and_chr":{"40":"n"},"and_ff":{"33":"y"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"n"}},"notes":"","notes_by_num":{"1":"Enabled in Chrome through the \"experimental Web Platform features\" flag in chrome://flags"},"usage_perc_y":16.95,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"mix-blend-mode,css blend modes,css blending modes","ie_id":"mixblendmode","chrome_id":"6362616360337408"},"web-speech":{"title":"Web Speech API","description":"Method to provide speech input and text-to-speech output features in a web browser.","spec":"https://dvcs.w3.org/hg/speech-api/raw-file/tip/speechapi.html","status":"unoff","links":[{"url":"http://updates.html5rocks.com/2013/01/Voice-Driven-Web-Apps-Introduction-to-the-Web-Speech-API","title":"HTML5Rocks article"},{"url":"http://www.sitepoint.com/introducing-web-speech-api/","title":"SitePoint article"},{"url":"http://aurelio.audero.it/demo/web-speech-api-demo.html","title":"Demo"},{"url":"http://zenorocha.github.io/voice-elements/","title":"Advanced demo and resource"}],"categories":["JS API"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"n","34":"n","35":"n","36":"n","37":"n","38":"n"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"a x","26":"a x","27":"a x","28":"a x","29":"a x","30":"a x","31":"a x","32":"a x","33":"a x","34":"a x","35":"a x","36":"a x","37":"a x","38":"a x","39":"a x","40":"a x","41":"a x","42":"a x","43":"a x"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"a x","7":"a x","7.1":"a","8":"a"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"a x","8":"a x","8.1":"a x"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"n","4.4.3-4.4.4":"n","37":"n"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"n"},"and_chr":{"40":"a x"},"and_ff":{"33":"n"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"n"}},"notes":"Partial support in Chrome refers to some attributes missing. Partial support in Safari refers to only Speech Synthesis supported.","notes_by_num":{},"usage_perc_y":0,"usage_perc_a":51.94,"ucprefix":false,"parent":"","keywords":"speech,recognition,ASR","ie_id":"webspeechapiinput","chrome_id":"5908775487668224"},"high-resolution-time":{"title":"High Resolution Time API","description":"Method to provide the current time in sub-millisecond resolution and such that it is not subject to system clock skew or adjustments. Called using `performance.now()`","spec":"http://www.w3.org/TR/hr-time/","status":"rec","links":[{"url":"https://developer.mozilla.org/en-US/docs/Web/API/Performance.now()","title":"MDN article"},{"url":"http://updates.html5rocks.com/2012/08/When-milliseconds-are-not-enough-performance-now","title":"HTML5Rocks article"},{"url":"http://www.sitepoint.com/discovering-the-high-resolution-time-api/","title":"SitePoint article"},{"url":"http://aurelio.audero.it/demo/high-resolution-time-api-demo.html","title":"Demo"}],"categories":["JS API"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"y","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"y x","21":"y x","22":"y x","23":"y x","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"n","7":"n","7.1":"n","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"y","8.1":"n"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"n","10":"y"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y"}},"notes":"","notes_by_num":{},"usage_perc_y":74.34,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"performance,now,testing","ie_id":"highresolutiontime","chrome_id":"5349124069130240"},"battery-status":{"title":"Battery Status API","description":"Method to provide information about the battery status of the hosting device.","spec":"http://www.w3.org/TR/battery-status/","status":"cr","links":[{"url":"https://developer.mozilla.org/en-US/docs/WebAPI/Battery_Status","title":"MDN Docs"},{"url":"http://www.smartjava.org/examples/webapi-battery/","title":"Simple demo"}],"categories":["JS API"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"a x #1","11":"a x #1","12":"a x #1","13":"a x #1","14":"a x #1","15":"a x #1","16":"a #1","17":"a #1","18":"a #1","19":"a #1","20":"a #1","21":"a #1","22":"a #1","23":"a #1","24":"a #1","25":"a #1","26":"a #1","27":"a #1","28":"a #1","29":"a #1","30":"a #1","31":"a #1","32":"a #1","33":"a #1","34":"a #1","35":"a #1","36":"a #1","37":"a #1","38":"a #1"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"n","34":"n","35":"n","36":"n","37":"n d","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"n","7":"n","7.1":"n","8":"n"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"n","8.1":"n"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"n","4.4.3-4.4.4":"n","37":"n"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"n"},"and_chr":{"40":"y"},"and_ff":{"33":"a #1"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"a #1"}},"notes":"","notes_by_num":{"1":"Partial support refers to support for the older specification's `navigator.battery` rather than `navigator.getBattery()` to access the `BatteryManager`."},"usage_perc_y":38.19,"usage_perc_a":15.5,"ucprefix":false,"parent":"","keywords":"navigator.battery,navigator.getbattery,batterymanager","ie_id":"batterystatusapi","chrome_id":"4537134732017664"},"serviceworkers":{"title":"Service Workers","description":"Method that enables applications to take advantage of persistent background processing, including hooks to enable bootstrapping of web applications while offline.","spec":"http://www.w3.org/TR/service-workers/","status":"wd","links":[{"url":"http://www.html5rocks.com/en/tutorials/service-worker/introduction/","title":"HTML5Rocks article (introduction)"},{"url":"https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorker_API","title":"MDN article"},{"url":"https://jakearchibald.github.io/isserviceworkerready/resources.html","title":"List of various resources"}],"categories":["JS API"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"u"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"n d #1","34":"n d #1","35":"n d #1","36":"n d #1","37":"n d #1","38":"n d #1"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"n","34":"n","35":"n","36":"n","37":"n","38":"n","39":"n","40":"a","41":"a","42":"a","43":"a"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"n","7":"n","7.1":"n","8":"n"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"a","25":"a","26":"a","27":"a","28":"a","29":"a"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"n","8.1":"n"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"n","4.4.3-4.4.4":"n","37":"n"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"n"},"and_chr":{"40":"a"},"and_ff":{"33":"n"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"n"}},"notes":"Details on partial support can be found on [is ServiceWorker Ready?](https://jakearchibald.github.io/isserviceworkerready/)","notes_by_num":{"1":"Partial support can be enabled in Firefox with the `dom.serviceWorkers.enabled` flag."},"usage_perc_y":0,"usage_perc_a":11.49,"ucprefix":false,"parent":"","keywords":"","ie_id":"serviceworker","chrome_id":"6561526227927040"},"text-decoration":{"title":"text-decoration styling","description":"Method of defining the type, style and color of lines in the text-decoration property. These can be defined as shorthand (e.g. `text-decoration: line-through dashed blue`) or as single properties (e.g. `text-decoration-color: blue`)","spec":"http://www.w3.org/TR/css-text-decor-3/#line-decoration","status":"cr","links":[{"url":"https://developer.mozilla.org/en-US/docs/Web/CSS/text-decoration-style","title":"MDN Documentation for text-decoration-style"},{"url":"https://developer.mozilla.org/en-US/docs/Web/CSS/text-decoration-color","title":"MDN Documentation for text-decoration-color"},{"url":"https://developer.mozilla.org/en-US/docs/Web/CSS/text-decoration-line","title":"MDN Documentation for text-decoration-line"}],"categories":["CSS3"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"y x","7":"y x","8":"y x","9":"y x","10":"y x","11":"y x","12":"y x","13":"y x","14":"y x","15":"y x","16":"y x","17":"y x","18":"y x","19":"y x","20":"y x","21":"y x","22":"y x","23":"y x","24":"y x","25":"y x","26":"y x","27":"y x","28":"y x","29":"y x","30":"y x","31":"y x","32":"y x","33":"y x","34":"y x","35":"y x","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n x d #1","27":"n x d #1","28":"n x d #1","29":"n x d #1","30":"n x d #1","31":"n x d #1","32":"n x d #1","33":"n x d #1","34":"n x d #1","35":"n x d #1","36":"n x d #1","37":"n x d #1","38":"n x d #1","39":"n x d #1","40":"n x d #1","41":"n x d #1","42":"n x d #1","43":"n x d #1"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"n","7":"n","7.1":"a x #2","8":"a x #2"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"a x #2","8.1":"a x #2"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"n","4.4.3-4.4.4":"n","37":"n"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"n"},"and_chr":{"40":"n"},"and_ff":{"33":"y x"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"n"}},"notes":"All browsers support the CSS2 version of `text-decoration`, which matches only the `text-decoration-line` values (`underline`, etc.)","notes_by_num":{"1":"Enabled in Chrome through the \"experimental Web Platform features\" flag in chrome://flags","2":"Partial support in Safari refers to not supporting the text-decoration-style property."},"usage_perc_y":11.83,"usage_perc_a":6.79,"ucprefix":false,"parent":"","keywords":"text-decoration-line,text-decoration-style,text-decoration-color","ie_id":"","chrome_id":""},"speech-synthesis":{"title":"Speech Synthesis API","description":"A web API for controlling a text-to-speech output.","spec":"https://dvcs.w3.org/hg/speech-api/raw-file/tip/speechapi.html#tts-section","status":"unoff","links":[{"url":"http://updates.html5rocks.com/2014/01/Web-apps-that-talk---Introduction-to-the-Speech-Synthesis-API","title":"HTML5Rocks article"},{"url":"http://www.sitepoint.com/talking-web-pages-and-the-speech-synthesis-api/","title":"SitePoint article"},{"url":"http://aurelio.audero.it/demo/speech-synthesis-api-demo.html","title":"Demo"}],"categories":["JS API"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"n","34":"n","35":"n","36":"n","37":"n","38":"n"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"n","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"n","4.4.3-4.4.4":"n","37":"n"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"n"},"and_chr":{"40":"y"},"and_ff":{"33":"n"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"n"}},"notes":"","notes_by_num":{},"usage_perc_y":50.34,"usage_perc_a":0,"ucprefix":false,"parent":"web-speech","keywords":"speech,synthesis,speechSynthesis,TTS,SpeechSynthesisUtterance,","ie_id":"webspeechapisynthesis","chrome_id":"4782875580825600"},"user-timing":{"title":"User Timing API","description":"Method to help web developers measure the performance of their applications by giving them access to high precision timestamps.","spec":"http://www.w3.org/TR/user-timing/","status":"rec","links":[{"url":"http://www.sitepoint.com/discovering-user-timing-api/","title":"SitePoint article"},{"url":"http://www.html5rocks.com/en/tutorials/webperformance/usertiming/","title":"HTML5Rocks article"},{"url":"https://gist.github.com/pmeenan/5902672","title":"Polyfill"},{"url":"http://aurelio.audero.it/demo/user-timing-api-demo.html","title":"Demo"}],"categories":["JS API"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"y","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"n","34":"n","35":"n","36":"n","37":"n","38":"n"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"n","7":"n","7.1":"n","8":"n"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"n","8.1":"n"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"n"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"n"}},"notes":"","notes_by_num":{},"usage_perc_y":57.17,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"performance,testing,mark,measure","ie_id":"usertimingapi","chrome_id":"5066549580791808"},"srcset":{"title":"Srcset attribute","description":"Allows authors to specify alternate high-resolution sources on `img` elements","spec":"https://html.spec.whatwg.org/multipage/embedded-content.html#attr-img-srcset","status":"ls","links":[{"url":"https://www.webkit.org/blog/2910/improved-support-for-high-resolution-displays-with-the-srcset-image-attribute/","title":"Improved support for high-resolution displays with the srcset image attribute"}],"categories":["HTML5"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n d #1","33":"n d #1","34":"n d #1","35":"n d #1","36":"n d #1","37":"n d #1","38":"n d #1"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"n","34":"a #2","35":"a #2","36":"a #2","37":"a #2","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"n","7":"n","7.1":"a #2","8":"a #2"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"a #2","22":"a #2","23":"a #2","24":"a #2","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"a #2","8.1":"a #2"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"n","4.4.3-4.4.4":"n","37":"y"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"a #2"},"and_chr":{"40":"y"},"and_ff":{"33":"n"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"n"}},"notes":"","notes_by_num":{"1":"Can be enabled in Firefox by setting the about:config preference dom.image.srcset.enabled to true","2":"Supports the subset of the syntax for resolution switching (using the `x` descriptor), but not the full syntax that can be used with `sizes` (using the `w` descriptor)."},"usage_perc_y":38.19,"usage_perc_a":9.69,"ucprefix":false,"parent":"","keywords":"","ie_id":"imgsrcset","chrome_id":"4644337115725824"},"ambient-light":{"title":"Ambient Light API","description":"Defines events that provide information about the ambient light level, as measured by a device's light sensor.","spec":"http://www.w3.org/TR/ambient-light/","status":"cr","links":[{"url":"http://aurelio.audero.it/demo/ambient-light-api-demo.html","title":"Demo"},{"url":"http://modernweb.com/2014/05/27/introduction-to-the-ambient-light-api/","title":"Article"}],"categories":["JS API"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"n","34":"n","35":"n","36":"n","37":"n","38":"n","39":"n","40":"n","41":"n","42":"n","43":"n"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"n","7":"n","7.1":"n","8":"n"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"n","8.1":"n"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"n","4.4.3-4.4.4":"n","37":"n"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"n"},"and_chr":{"40":"n"},"and_ff":{"33":"y"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"n"}},"notes":"Firefox desktop supports this API only on Mac OS X. [Support for Windows 7 is in progress](https://bugzilla.mozilla.org/show_bug.cgi?id=754199)","notes_by_num":{},"usage_perc_y":11.28,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"","ie_id":"ambientlightevents","chrome_id":"5298357018820608"},"will-change":{"title":"CSS will-change property","description":"Method of optimizing animations by informing the browser which elements will change and what properties will change.","spec":"http://dev.w3.org/csswg/css-will-change/","status":"wd","links":[{"url":"https://dev.opera.com/articles/css-will-change-property/","title":"Detailed article"},{"url":"http://aerotwist.com/blog/bye-bye-layer-hacks/","title":"Blog post"}],"categories":["CSS"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n d #1","30":"n d #1","31":"n d #1","32":"n d #1","33":"n d #1","34":"n d #1","35":"n d #1","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"n","34":"n","35":"n","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"n","7":"n","7.1":"n","8":"n"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"n","8.1":"n"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"n","4.4.3-4.4.4":"n","37":"y"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"n"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"n"}},"notes":"","notes_by_num":{"1":"Supported in Firefox behind the `layout.css.will-change.enabled` flag"},"usage_perc_y":40.13,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"scroll-position","ie_id":"csswillchange","chrome_id":"5954199330226176"},"css-shapes":{"title":"CSS Shapes Level 1","description":"Allows geometric shapes to be set in CSS to define an area for text to flow around.","spec":"http://www.w3.org/TR/css-shapes/","status":"cr","links":[{"url":"http://html.adobe.com/webplatform/layout/shapes/","title":"Adobe demos and samples"},{"url":"http://html.adobe.com/webplatform/layout/shapes/browser-support/","title":"CSS shapes support test by Adobe"},{"url":"http://alistapart.com/article/css-shapes-101","title":"A List Apart article"}],"categories":["CSS3"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"n","34":"n","35":"n","36":"n","37":"n","38":"n"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"n","34":"n d #1","35":"n d #1","36":"n d #1","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"n","7":"n","7.1":"y x","8":"y x"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"y x","8.1":"y x"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"n","4.4.3-4.4.4":"n","37":"y"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"n"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"n"}},"notes":"","notes_by_num":{"1":"Enabled in Chrome through the \"experimental Web Platform features\" flag in chrome://flags"},"usage_perc_y":46.02,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"circle,ellipse,polygon,inset,shape-outside,shape-inside","ie_id":"shapes","chrome_id":"5163890719588352"},"domcontentloaded":{"title":"DOMContentLoaded","description":"JavaScript event that fires when the DOM is loaded, but before all page assets are loaded (CSS, images, etc.).","spec":"https://html.spec.whatwg.org/multipage/syntax.html#stop-parsing","status":"ls","links":[{"url":"https://developer.mozilla.org/en-US/docs/Web/Reference/Events/DOMContentLoaded","title":"MDN: DOMContentLoaded"}],"categories":["DOM"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"y","10":"y","11":"y","TP":"y"},"firefox":{"2":"y","3":"y","3.5":"y","3.6":"y","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"y","3.2":"y","4":"y","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"y","9.5-9.6":"y","10.0-10.1":"y","10.5":"y","10.6":"y","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"y","4.0-4.1":"y","4.2-4.3":"y","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"y"},"android":{"2.1":"y","2.2":"y","2.3":"y","3":"y","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"y","11":"y","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y"}},"notes":"","notes_by_num":{},"usage_perc_y":92.77,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"dom,domready,onload,contentloaded,document","ie_id":"","chrome_id":""},"proximity":{"title":"Proximity API","description":"Defines events that provide information about the distance between a device and an object, as measured by a proximity sensor.","spec":"http://www.w3.org/TR/proximity/","status":"cr","links":[{"url":"http://aurelio.audero.it/demo/proximity-api-demo.html","title":"Demo"},{"url":"http://www.sitepoint.com/introducing-proximity-api/","title":"SitePoint article"}],"categories":["JS API"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"n","34":"n","35":"n","36":"n","37":"n","38":"n","39":"n","40":"n","41":"n","42":"n","43":"n"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"n","7":"n","7.1":"n","8":"n"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"n","8.1":"n"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"n","4.4.3-4.4.4":"n","37":"n"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"n"},"and_chr":{"40":"n"},"and_ff":{"33":"y"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"n"}},"notes":"","notes_by_num":{},"usage_perc_y":11.54,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"","ie_id":"","chrome_id":""},"kerning-pairs-ligatures":{"title":"Improved kerning pairs & ligatures","description":"Currently non-standard method of improving kerning pairs & ligatures using text-rendering: optimizeLegibility.","spec":"http://www.w3.org/TR/SVG11/painting.html#TextRenderingProperty","status":"unoff","links":[{"url":"https://developer.mozilla.org/en-US/docs/Web/CSS/text-rendering","title":"MDN article"},{"url":"http://css-tricks.com/almanac/properties/t/text-rendering/","title":"CSS Tricks article"}],"categories":["CSS"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"y","3.5":"y","3.6":"y","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"u","4.0-4.1":"u","4.2-4.3":"y","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"y","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"n","10":"y"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"y"}},"notes":"","notes_by_num":{},"usage_perc_y":76.22,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"optimizeLegibility,optimizeSpeed,geometricPrecision","ie_id":"","chrome_id":""},"iframe-seamless":{"title":"seamless attribute for iframes","description":"The seamless attribute makes an iframe's contents actually part of a page, and adopts the styles from its hosting page. ","spec":"https://html.spec.whatwg.org/multipage/embedded-content.html#attr-iframe-seamless","status":"ls","links":[{"url":"https://github.com/ornj/seamless-polyfill","title":"Experimental polyfill"},{"url":"http://labs.ft.com/2013/01/seamless-iframes-not-quite-seamless/","title":"Article"}],"categories":["HTML5"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"n","34":"n","35":"n","36":"u","37":"u","38":"u"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n d","21":"n d","22":"n d","23":"n d","24":"n d","25":"n d","26":"n d","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"n","34":"n","35":"n","36":"n","37":"n","38":"n","39":"n","40":"n","41":"u","42":"u","43":"u"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"n","7":"n","7.1":"n","8":"n"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"u","29":"u"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"n","8.1":"n"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"n","4.4.3-4.4.4":"n","37":"n"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"n"},"and_chr":{"40":"n"},"and_ff":{"33":"n"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"y"}},"notes":"Chrome 20-26 had partial support behind a flag, though this was [later removed](http://crbug.com/229421). \r\n\r\nSafari 7 (& iOS 7 Safari) hides the border of seamless iframes and recognizes the 'seamless' DOM property, but does not provide actual support.","notes_by_num":{},"usage_perc_y":3.78,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"","ie_id":"iframeseamlessattribute","chrome_id":"6630329993396224"},"css-image-orientation":{"title":"CSS3 image-orientation","description":"CSS property used generally to fix the intended orientation of an image. This can be done using 90 degree increments or based on the image's EXIF data using the \"from-image\" value.","spec":"http://www.w3.org/TR/css3-images/#image-orientation","status":"cr","links":[{"url":"https://developer.mozilla.org/en-US/docs/Web/CSS/image-orientation","title":"MDN article"},{"url":"http://sethfowler.org/blog/2013/09/13/new-in-firefox-26-css-image-orientation/","title":"Blog post"},{"url":"http://jsbin.com/EXUTolo/4","title":"Demo (Chinese)"}],"categories":["CSS3"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"n","34":"n","35":"n","36":"n","37":"n","38":"n","39":"n","40":"n","41":"n","42":"n","43":"n"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"n","7":"n","7.1":"n","8":"n"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n"},"ios_saf":{"3.2":"a","4.0-4.1":"a","4.2-4.3":"a","5.0-5.1":"a","6.0-6.1":"a","7.0-7.1":"a","8":"a","8.1":"a"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"n","4.4.3-4.4.4":"n","37":"n"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"n"},"and_chr":{"40":"n"},"and_ff":{"33":"y"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"n"}},"notes":"Partial support in iOS refers to the browser using EXIF data by default, though it does not actually support the property. Opening the image in a new tab in Chrome results in the image shown in the orientation according to the EXIF data.","notes_by_num":{},"usage_perc_y":11.07,"usage_perc_a":7.68,"ucprefix":false,"parent":"","keywords":"image-orientation,from-image,flip","ie_id":"","chrome_id":""},"picture":{"title":"Picture element","description":"A responsive images method to control which image resource a user agent presents to a user, based on resolution, media query and/or support for a particular image format","spec":"https://html.spec.whatwg.org/multipage/embedded-content.html#the-picture-element","status":"ls","links":[{"url":"http://responsiveimages.org/demos/","title":"Demo"},{"url":"http://code.tutsplus.com/tutorials/better-responsive-images-with-the-picture-element--net-36583","title":"Tutorial"},{"url":"http://usecases.responsiveimages.org/","title":"Read about the use cases"},{"url":"http://responsiveimages.org/","title":"General information about Responsive Images"},{"url":"https://dev.opera.com/articles/responsive-images/","title":"Blog post on usage"},{"url":"http://www.html5rocks.com/tutorials/responsive/picture-element/","title":"HTML5 Rocks tutorial"}],"categories":["DOM","HTML5"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"n","34":"n d #3","35":"n d #3","36":"n d #3","37":"n d #3","38":"n d #3"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"n","34":"n","35":"n","36":"n","37":"n d #1","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"n","7":"n","7.1":"n","8":"n"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n d #2","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"n","8.1":"n"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"n","4.4.3-4.4.4":"n","37":"n"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"n"},"and_chr":{"40":"y"},"and_ff":{"33":"n"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"n"}},"notes":"","notes_by_num":{"1":"Enabled in Chrome through the \"experimental Web Platform features\" flag in chrome://flags","2":"Enabled in Opera through the \"experimental Web Platform features\" flag in opera://flags","3":"Enabled in Firefox by setting the about:config preference dom.image.picture.enable to true"},"usage_perc_y":38.19,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"<picture>","ie_id":"pictureelement","chrome_id":"5910974510923776"},"woff2":{"title":"WOFF 2.0 - Web Open Font Format","description":"TrueType/OpenType font that provides better compression than WOFF 1.0.","spec":"http://www.w3.org/TR/WOFF2/","status":"wd","links":[{"url":"https://gist.github.com/sergejmueller/cf6b4f2133bcb3e2f64a","title":"Basics about WOFF 2.0"},{"url":"http://everythingfonts.com/ttf-to-woff2","title":"WOFF 2.0 converter"}],"categories":["Other"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"n","34":"n","35":"n d #1","36":"n d #1","37":"n d #1","38":"n d #1"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"n","34":"n","35":"n","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"n","7":"n","7.1":"n","8":"n"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"n","8.1":"n"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"n","4.4.3-4.4.4":"n","37":"y"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"n"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"n"}},"notes":"","notes_by_num":{"1":"Default 'enabled' for Firefox Developer Edition and Nightly, but Beta and Release versions will need to set a flag to 'true' to [use WOFF2](https://developer.mozilla.org/en-US/docs/Web/CSS/@font-face#Browser_compatibility)."},"usage_perc_y":40.13,"usage_perc_a":0,"ucprefix":false,"parent":"fontface","keywords":"woff, fontface, webfonts","ie_id":"","chrome_id":"6718644721549312"},"text-size-adjust":{"title":"CSS text-size-adjust","description":"On mobile devices, the text-size-adjust CSS property allows Web authors to control if and how the text-inflating algorithm is applied to the textual content of the element it is applied to.","spec":"http://dev.w3.org/csswg/css-size-adjust/","status":"wd","links":[{"url":"https://developer.mozilla.org/en-US/docs/Web/CSS/text-size-adjust","title":"MDN Docs"}],"categories":["CSS3"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"n","34":"n","35":"n","36":"n","37":"n","38":"n"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"n","34":"n","35":"n","36":"n","37":"n","38":"n","39":"n","40":"n","41":"n","42":"n","43":"n"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"n","7":"n","7.1":"n","8":"n"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"y x","6.0-6.1":"y x","7.0-7.1":"y x","8":"y x","8.1":"y x"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"n","4.4.3-4.4.4":"n","37":"n"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"n"},"and_chr":{"40":"n"},"and_ff":{"33":"y x"},"ie_mob":{"10":"y x","11":"y x"},"and_uc":{"9.9":"y x"}},"notes":"","notes_by_num":{},"usage_perc_y":12.32,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"","ie_id":"","chrome_id":""},"web-animation":{"title":"Web Animations API","description":"This function lets you create an animation purely in JavaScript and have it run as efficiently as any CSS Animation or Transition.","spec":"http://w3c.github.io/web-animations/","status":"wd","links":[{"url":"http://updates.html5rocks.com/2014/05/Web-Animations---element-animate-is-now-in-Chrome-36","title":"HTML5 Rocks"},{"url":"http://updates.html5rocks.com/2013/12/New-Web-Animations-engine-in-Blink-drives-CSS-Animations-Transitions","title":"HTML5 Rocks"},{"url":"https://bugzilla.mozilla.org/show_bug.cgi?id=875219","title":"Current Firefox status"}],"categories":["DOM","JS API"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"n","34":"n","35":"n","36":"n","37":"n","38":"n"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"n","34":"n","35":"n","36":"a #1","37":"a #1","38":"a #1","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"n","7":"n","7.1":"n","8":"n"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"a #1","24":"a #1","25":"a #1","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"n","8.1":"n"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"n","4.4.3-4.4.4":"n","37":"a #1"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"a #1"},"and_chr":{"40":"a #1"},"and_ff":{"33":"n"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"n"}},"notes":"","notes_by_num":{"1":"Partial support refers to supporting `element.animate()` but not [playback control of AnimationPlayer](https://www.chromestatus.com/features/5633748733263872)"},"usage_perc_y":26.32,"usage_perc_a":13.82,"ucprefix":false,"parent":"","keywords":"animate,play,pause,reverse,finish,currentTime,startTime,playbackRate,playState","ie_id":"webanimationsjavascriptapi","chrome_id":"4854343836631040"},"resource-timing":{"title":"Resource Timing","description":"Method to help web developers to collect complete timing information related to resources on a document.","spec":"http://www.w3.org/TR/resource-timing/","status":"cr","links":[{"url":"http://aurelio.audero.it/demo/resource-timing-api-demo.html","title":"Demo"},{"url":"http://googledevelopers.blogspot.com/2013/12/measuring-network-performance-with.html","title":"Blog post"},{"url":"http://www.sitepoint.com/introduction-resource-timing-api/","title":"SitePoint article"}],"categories":["JS API"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"y","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n d #1","32":"n d #1","33":"n d #1","34":"n d #1","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"n","7":"n","7.1":"n","8":"n"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"n","8.1":"n"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"n"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"n"}},"notes":"","notes_by_num":{"1":"Can be enabled in Firefox using the dom.enable_resource_timing flag"},"usage_perc_y":57.42,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"performance,testing,resource","ie_id":"resourcetimingapi","chrome_id":"5796350423728128"},"custom-elements":{"title":"Custom Elements","description":"Method of defining and using new types of DOM elements in a document.","spec":"http://www.w3.org/TR/custom-elements/","status":"wd","links":[{"url":"http://w3c.github.io/webcomponents/spec/custom/","title":"W3C Editor's Draft spec (closer to current implementations)"},{"url":"http://www.polymer-project.org/platform/custom-elements.html","title":"Polymer project (polyfill & web components framework)"},{"url":"http://www.html5rocks.com/tutorials/webcomponents/customelements/","title":"HTML5Rocks - Custom Elements: defining new elements in HTML"},{"url":"https://code.google.com/p/chromium/issues/detail?id=234509","title":"Chromium tracking bug: Implement Custom Elements"},{"url":"https://bugzilla.mozilla.org/show_bug.cgi?id=889230","title":"Firefox tracking bug: Implement Custom Elements (from Web Components)"},{"url":"http://status.modern.ie/customelements","title":"IE Web Platform Status and Roadmap: Custom Elements"}],"categories":["DOM","HTML5"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"p","11":"p","TP":"p"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n d #1","24":"n d #1","25":"n d #1","26":"n d #1","27":"n d #1","28":"n d #1","29":"n d #1","30":"p d #1","31":"p d #1","32":"p d #1","33":"p d #1","34":"p d #1","35":"p d #1","36":"p d #1","37":"p d #1","38":"p d #1"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n d","28":"n d","29":"n d","30":"n d","31":"n d","32":"n d","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"p","6.1":"p","7":"p","7.1":"p","8":"p"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"n d","16":"n d","17":"n d","18":"n d","19":"n d","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"p","8":"p","8.1":"p"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"n","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"p d #1"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"n"}},"notes":"","notes_by_num":{"1":"Enabled through the \"dom.webcomponents.enabled\" preference in about:config"},"usage_perc_y":42.59,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"web components","ie_id":"customelements","chrome_id":"4642138092470272"},"imports":{"title":"HTML Imports","description":"Method of including and reusing HTML documents in other HTML documents.","spec":"http://www.w3.org/TR/html-imports/","status":"wd","links":[{"url":"http://www.polymer-project.org/platform/html-imports.html","title":"Polymer project (polyfill & web components framework)"},{"url":"http://www.html5rocks.com/tutorials/webcomponents/imports/","title":"HTML5Rocks - HTML Imports: #include for the web"},{"url":"https://code.google.com/p/chromium/issues/detail?id=240592","title":"Chromium tracking bug: Implement HTML Imports"},{"url":"https://bugzilla.mozilla.org/show_bug.cgi?id=877072","title":"Firefox tracking bug: Implement HTML Imports"},{"url":"http://status.modern.ie/htmlimports","title":"IE Web Platform Status and Roadmap: HTML Imports"}],"categories":["DOM","HTML5"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"p","11":"p","TP":"p"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"p","31":"p","32":"p d #1","33":"p d #1","34":"p d #1","35":"p d #1","36":"p d #1","37":"p d #1","38":"p d #1"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n d #2","31":"n d #2","32":"n d #2","33":"n d #2","34":"n d #2","35":"p d #3","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"p","6.1":"p","7":"p","7.1":"p","8":"p"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"n","16":"n","17":"n d #4","18":"n d #4","19":"n d #4","20":"n d #4","21":"n d #4","22":"p d #5","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"p","8":"p","8.1":"p"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"n","4.4.3-4.4.4":"n","37":"y"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"p"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"n"}},"notes":"","notes_by_num":{"1":"Firefox [has no plans to support HTML imports](https://hacks.mozilla.org/2014/12/mozilla-and-web-components/) though for now it can be enabled through the \"dom.webcomponents.enabled\" preference in about:config","2":"Enabled through the \"Enable HTML Imports\" flag in chrome://flags","3":"Enabled through the \"Experimental Web Platform features\" flag in chrome://flags","4":"Enabled through the \"Enable HTML Imports\" flag in opera://flags","5":"Enabled through the \"Experimental Web Platform features\" flag in opera://flags"},"usage_perc_y":40.13,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"web components","ie_id":"htmlimports","chrome_id":"5144752345317376"},"input-file-multiple":{"title":"Multiple file selection","description":"Allows users to select multiple files in the file picker.","spec":"https://html.spec.whatwg.org/multipage/forms.html#attr-input-multiple","status":"ls","links":[{"url":"https://code.google.com/p/chromium/issues/detail?id=348912","title":"Chrome bug (for Android)"},{"url":"http://www.raymondcamden.com/2012/2/28/Working-with-HTML5s-multiple-file-upload-support","title":"Article"}],"categories":["HTML5"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"y","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"y","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"y","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"y","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n #1"},"android":{"2.1":"n #1","2.2":"n #1","2.3":"n #1","3":"n #1","4":"n #1","4.1":"n #1","4.2-4.3":"n #1","4.4":"n #1","4.4.3-4.4.4":"n #1","37":"n #1"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"n #1","11":"n #1","11.1":"n #1","11.5":"n #1","12":"n #1","12.1":"n #1","24":"n #1"},"and_chr":{"40":"n #1"},"and_ff":{"33":"n #1"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"n #1"}},"notes":"","notes_by_num":{"1":"Not supported when tested on Android, presumably an OS limitation. "},"usage_perc_y":65.7,"usage_perc_a":0,"ucprefix":false,"parent":"forms","keywords":"","ie_id":"","chrome_id":""},"atob-btoa":{"title":"Base64 encoding and decoding","description":"Utility functions for of encoding and decoding strings to and from base 64: window.atob() and window.btoa().","spec":"https://html.spec.whatwg.org/multipage/webappapis.html#atob","status":"ls","links":[{"url":"https://developer.mozilla.org/en-US/docs/Web/API/Window.btoa","title":"MDN article on btoa()"},{"url":"https://developer.mozilla.org/en-US/docs/Web/API/Window.atob","title":"MDN article on atob()"},{"url":"https://github.com/davidchambers/Base64.js","title":"Polyfill"}],"categories":["JS API"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"y","11":"y","TP":"y"},"firefox":{"2":"y","3":"y","3.5":"y","3.6":"y","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"y","3.2":"y","4":"y","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"u","10.0-10.1":"u","10.5":"u","10.6":"y","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"y","4.0-4.1":"y","4.2-4.3":"y","5.0-5.1":"y","6.0-6.1":"y","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"y"},"android":{"2.1":"y","2.2":"y","2.3":"y","3":"y","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"y"},"op_mob":{"10":"u","11":"y","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"y"}},"notes":"","notes_by_num":{},"usage_perc_y":90.6,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"atob,btoa","ie_id":"","chrome_id":""},"css-appearance":{"title":"CSS Appearance","description":"The `appearance` property defines how elements (particularly form controls) appear by default. By setting the value to `none` the default appearance can be entirely redefined using other CSS properties.","spec":"http://wiki.csswg.org/spec/css4-ui#appearance","status":"unoff","links":[{"url":"http://css-tricks.com/almanac/properties/a/appearance/","title":"CSS Tricks article"}],"categories":["CSS"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"y x","3":"y x","3.5":"y x","3.6":"y x","4":"y x","5":"y x","6":"y x","7":"y x","8":"y x","9":"y x","10":"y x","11":"y x","12":"y x","13":"y x","14":"y x","15":"y x","16":"y x","17":"y x","18":"y x","19":"y x","20":"y x","21":"y x","22":"y x","23":"y x","24":"y x","25":"y x","26":"y x","27":"y x","28":"y x","29":"y x","30":"y x","31":"y x","32":"y x","33":"y x","34":"y x","35":"y x","36":"y x","37":"y x","38":"y x"},"chrome":{"4":"y x","5":"y x","6":"y x","7":"y x","8":"y x","9":"y x","10":"y x","11":"y x","12":"y x","13":"y x","14":"y x","15":"y x","16":"y x","17":"y x","18":"y x","19":"y x","20":"y x","21":"y x","22":"y x","23":"y x","24":"y x","25":"y x","26":"y x","27":"y x","28":"y x","29":"y x","30":"y x","31":"y x","32":"y x","33":"y x","34":"y x","35":"y x","36":"y x","37":"y x","38":"y x","39":"y x","40":"y x","41":"y x","42":"y x","43":"y x"},"safari":{"3.1":"y x","3.2":"y x","4":"y x","5":"y x","5.1":"y x","6":"y x","6.1":"y x","7":"y x","7.1":"y x","8":"y x"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"y x","16":"y x","17":"y x","18":"y x","19":"y x","20":"y x","21":"y x","22":"y x","23":"y x","24":"y x","25":"y x","26":"y x","27":"y x","28":"y x","29":"y x"},"ios_saf":{"3.2":"y x","4.0-4.1":"y x","4.2-4.3":"y x","5.0-5.1":"y x","6.0-6.1":"y x","7.0-7.1":"y x","8":"y x","8.1":"y x"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"y x","2.2":"y x","2.3":"y x","3":"y x","4":"y x","4.1":"y x","4.2-4.3":"y x","4.4":"y x","4.4.3-4.4.4":"y x","37":"y x"},"bb":{"7":"y x","10":"y x"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"y x"},"and_chr":{"40":"y x"},"and_ff":{"33":"y x"},"ie_mob":{"10":"n","11":"a #1"},"and_uc":{"9.9":"y x"}},"notes":"The `appearance` property currently does not appear in any CSS specification so there is no specifically correct usage.","notes_by_num":{"1":"`-webkit-appearance` with value `none` is supported on IE11 Mobile for phones with \"[Windows Phone 8.1 Update](http://blogs.msdn.com/b/ie/archive/2014/07/31/the-mobile-web-should-just-work-for-everyone.aspx)\""},"usage_perc_y":76.54,"usage_perc_a":0.4,"ucprefix":false,"parent":"","keywords":"","ie_id":"","chrome_id":""},"css-background-offsets":{"title":"CSS background-position edge offsets","description":"Allows CSS background images to be positioned relative to the specified edge using the 3 to 4 value syntax. For example: `background-position: right 5px bottom 5px;` for positioning 5px from the bottom-right corner.","spec":"http://www.w3.org/TR/css3-background/#background-position","status":"wd","links":[{"url":"https://developer.mozilla.org/en-US/docs/Web/CSS/background-position","title":"MDN article on background-position"},{"url":"http://briantree.se/quick-tip-06-use-four-value-syntax-properly-position-background-images/","title":"Basic information"}],"categories":["CSS3"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"y","10":"y","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"n","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"y","10.6":"y","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"y"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"n","10":"y"},"op_mob":{"10":"n","11":"y","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"n"}},"notes":"","notes_by_num":{},"usage_perc_y":83.74,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"4 value syntax","ie_id":"","chrome_id":""},"css-supports-api":{"title":"CSS.supports() API","description":"The CSS.supports() static methods returns a Boolean value indicating if the browser supports a given CSS feature, or not.","spec":"http://dev.w3.org/csswg/css-conditional/#the-css-interface","status":"cr","links":[{"url":"https://developer.mozilla.org/en-US/docs/Web/API/CSS.supports","title":"MDN Docs"},{"url":"http://jsbin.com/rimevilotari/1/edit","title":"Demo (Chinese)"},{"url":"https://dev.opera.com/articles/native-css-feature-detection/","title":"Native CSS Feature Detection via the @supports Rule"},{"url":"http://davidwalsh.name/css-supports","title":"CSS @supports"},{"url":"http://blog.csdn.net/hfahe/article/details/8619480","title":"Article (Chinese)"}],"categories":["DOM","JS API"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n d","21":"n d","22":"n d","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"n","7":"n","7.1":"n","8":"n"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"y #1","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"n","8.1":"n"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"n"}},"notes":"See also [@supports in CSS](#feat=css-featurequeries)\r\n\r\nSee the [WebKit Bug](http://trac.webkit.org/changeset/142739) for status in Safari","notes_by_num":{"1":"Opera 12 uses a different method name('window.supportsCSS')"},"usage_perc_y":57.78,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"conditional","ie_id":"conditionalrules","chrome_id":"4993981813358592"},"css-touch-action":{"title":"CSS touch-action property","description":"touch-action is a CSS property that controls filtering of gesture events, providing developers with a declarative mechanism to selectively disable touch scrolling (in one or both axes), pinch-zooming or double-tap-zooming.","spec":"http://www.w3.org/TR/pointerevents/#the-touch-action-css-property","status":"cr","links":[{"url":"http://docs.webplatform.org/wiki/css/properties/touch-action","title":"WebPlatform Docs"},{"url":"http://msdn.microsoft.com/en-us/library/windows/apps/hh767313.aspx","title":"MSDN Docs"},{"url":"http://updates.html5rocks.com/2013/12/300ms-tap-delay-gone-away","title":"300ms tap delay, gone away"},{"url":"http://blogs.telerik.com/appbuilder/posts/13-11-21/what-exactly-is.....-the-300ms-click-delay","title":"What Exactly Is..... The 300ms Click Delay"},{"url":"http://thx.github.io/mobile/300ms-click-delay/","title":"What Exactly Is..... The 300ms Click Delay(Chinese)"}],"categories":["CSS"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"y x #2","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n d #1","30":"n d #1","31":"n d #1","32":"n d #1","33":"n d #1","34":"n d #1","35":"n d #1","36":"n d #1","37":"n d #1","38":"n d #1"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"n","34":"n","35":"n","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"n","7":"n","7.1":"n","8":"n"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"n","8.1":"n"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"n","4.4.3-4.4.4":"n","37":"y"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"n"},"ie_mob":{"10":"y x #2","11":"y"},"and_uc":{"9.9":"n"}},"notes":"","notes_by_num":{"1":"Supported in Firefox behind the `layout.css.touch_action.enabled` flag, Firefox for Windows 8 Touch ('Metro') enabled by default.","2":"IE10+ has already supported these property which are not in standard at present such as'pinch-zoom','double-tap-zoom','cross-slide-x','cross-slide-y'."},"usage_perc_y":50.84,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"touch action","ie_id":"csstouchaction","chrome_id":"5912074022551552"},"autofocus":{"title":"Autofocus attribute","description":"Allows a form field to be immediately focused on page load.","spec":"https://html.spec.whatwg.org/multipage/forms.html#autofocusing-a-form-control:-the-autofocus-attribute","status":"ls","links":[{"url":"http://davidwalsh.name/autofocus","title":"Article on autofocus"}],"categories":["HTML5"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"y","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"y","5.1":"y","6":"y","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"y","10.0-10.1":"y","10.5":"y","10.6":"y","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"n","8.1":"n"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"y","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"y","10":"u"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"n"}},"notes":"While not supported in iOS Safari, it does work in iOS WebViews.","notes_by_num":{},"usage_perc_y":75.69,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"","ie_id":"","chrome_id":""},"css-clip-path":{"title":"CSS clip-path property","description":"Method of defining the visible region of an element using SVG or a shape definition.","spec":"http://www.w3.org/TR/css-masking-1/#the-clip-path","status":"wd","links":[{"url":"http://css-tricks.com/almanac/properties/c/clip/","title":"CSS Tricks article"}],"categories":["CSS3"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"n","3.5":"a #1","3.6":"a #1","4":"a #1","5":"a #1","6":"a #1","7":"a #1","8":"a #1","9":"a #1","10":"a #1","11":"a #1","12":"a #1","13":"a #1","14":"a #1","15":"a #1","16":"a #1","17":"a #1","18":"a #1","19":"a #1","20":"a #1","21":"a #1","22":"a #1","23":"a #1","24":"a #1","25":"a #1","26":"a #1","27":"a #1","28":"a #1","29":"a #1","30":"a #1","31":"a #1","32":"a #1","33":"a #1","34":"a #1","35":"a #1","36":"a #1","37":"a #1","38":"a #1"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"a x #2","25":"a x #2","26":"a x #2","27":"a x #2","28":"a x #2","29":"a x #2","30":"a x #2","31":"a x #2","32":"a x #2","33":"a x #2","34":"a x #2","35":"a x #2","36":"a x #2","37":"a x #2","38":"a x #2","39":"a x #2","40":"a x #2","41":"a x #2","42":"a x #2","43":"a x #2"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"n","7":"a x #2","7.1":"a x #2","8":"a x #2"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"a x #2","16":"a x #2","17":"a x #2","18":"a x #2","19":"a x #2","20":"a x #2","21":"a x #2","22":"a x #2","23":"a x #2","24":"a x #2","25":"a x #2","26":"a x #2","27":"a x #2","28":"a x #2","29":"a x #2"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"a x #2","8":"a x #2","8.1":"a x #2"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"a x #2","4.4.3-4.4.4":"a x #2","37":"a x #2"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"a x #2"},"and_chr":{"40":"a x #2"},"and_ff":{"33":"a #1"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"n"}},"notes":"","notes_by_num":{"1":"Partial support refers to only supporting the `url()` syntax.","2":"Partial support refers to supporting shapes and the `url(#foo)` syntax for inline SVG, but not shapes in external SVGs."},"usage_perc_y":0,"usage_perc_a":67.94,"ucprefix":false,"parent":"","keywords":"","ie_id":"","chrome_id":""},"getrandomvalues":{"title":"crypto.getRandomValues()","description":"Method of generating cryptographically random values.","spec":"http://www.w3.org/TR/WebCryptoAPI/#RandomSource-method-getRandomValues","status":"wd","links":[{"url":"https://developer.mozilla.org/en-US/docs/Web/API/window.crypto.getRandomValues","title":"MDN article"}],"categories":["JS API"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"y x","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"y","7":"y","7.1":"y","8":"y"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"y","8":"y","8.1":"y"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"n","11":"y x"},"and_uc":{"9.9":"n"}},"notes":"","notes_by_num":{},"usage_perc_y":76.79,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"","ie_id":"","chrome_id":""},"screen-orientation":{"title":"Screen Orientation","description":"Provides the ability to read the screen orientation state, to be informed when this state changes, and to be able to lock the screen orientation to a specific state.","spec":"http://www.w3.org/TR/screen-orientation/","status":"wd","links":[{"url":"http://aurelio.audero.it/demo/screen-orientation-api-demo.html","title":"Demo"},{"url":"https://developer.mozilla.org/en-US/docs/Web/API/Screen.orientation","title":"MDN article"},{"url":"http://www.sitepoint.com/introducing-screen-orientation-api/","title":"SitePoint article"}],"categories":["JS API"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"y x","TP":"y x"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"y x","19":"y x","20":"y x","21":"y x","22":"y x","23":"y x","24":"y x","25":"y x","26":"y x","27":"y x","28":"y x","29":"y x","30":"y x","31":"y x","32":"y x","33":"y x","34":"y x","35":"y x","36":"y x","37":"y x","38":"y x"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"n","34":"n","35":"n","36":"n","37":"n","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"n","7":"n","7.1":"n","8":"n"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"n","8.1":"n"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"n","4.4.3-4.4.4":"n","37":"n"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"n"},"and_chr":{"40":"y"},"and_ff":{"33":"y x"},"ie_mob":{"10":"n","11":"a x"},"and_uc":{"9.9":"y"}},"notes":"","notes_by_num":{},"usage_perc_y":61.72,"usage_perc_a":0.4,"ucprefix":false,"parent":"","keywords":"","ie_id":"screenorientationapi","chrome_id":"6191285283061760"},"font-loading":{"title":"CSS Font Loading","description":"This CSS module defines a scripting interface to font faces in CSS, allowing font faces to be easily created and loaded from script. It also provides methods to track the loading status of an individual font, or of all the fonts on an entire page.","spec":"http://dev.w3.org/csswg/css-font-loading/","status":"cr","links":[{"url":"https://www.igvita.com/2014/01/31/optimizing-web-font-rendering-performance/#font-load-events","title":"Optimizing with font load events"}],"categories":["CSS3","JS API"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"n","34":"n","35":"n d #1","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"n","34":"n","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"n","7":"n","7.1":"n","8":"n"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"n","8.1":"n"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"n","4.4.3-4.4.4":"n","37":"y"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"n"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"n"}},"notes":"","notes_by_num":{"1":"Can be enabled in Firefox using the `layout.css.font-loading-api.enabled` flag."},"usage_perc_y":40.76,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"","ie_id":"","chrome_id":"6244676289953792"},"font-unicode-range":{"title":"Font unicode-range subsetting","description":"This @font-face descriptor defines the set of Unicode codepoints that may be supported by the font face for which it is declared. The descriptor value is a comma-delimited list of Unicode range (<urange>) values. The union of these ranges defines the set of codepoints that serves as a hint for user agents when deciding whether or not to download a font resource for a given text run.","spec":"http://dev.w3.org/csswg/css-fonts/#descdef-unicode-range","status":"cr","links":[{"url":"https://developer.mozilla.org/en-US/docs/Web/CSS/unicode-range","title":"MDN: unicode-range"},{"url":"https://developer.apple.com/library/safari/documentation/AppleApplications/Reference/SafariCSSRef/Articles/StandardCSSProperties.html#//apple_ref/css/property/unicode-range","title":"Safari CSS Reference: unicode-range"},{"url":"http://docs.webplatform.org/wiki/css/properties/unicode-range","title":"Web Platform Docs: unicode-range"},{"url":"http://jsbin.com/jeqoguzeye/1/edit?html,output","title":"Demo"}],"categories":["CSS3"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"a","10":"a","11":"a","TP":"a"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"n","34":"n","35":"n","36":"y","37":"y","38":"y"},"chrome":{"4":"a","5":"a","6":"a","7":"a","8":"a","9":"a","10":"a","11":"a","12":"a","13":"a","14":"a","15":"a","16":"a","17":"a","18":"a","19":"a","20":"a","21":"a","22":"a","23":"a","24":"a","25":"a","26":"a","27":"a","28":"a","29":"a","30":"a","31":"a","32":"a","33":"a","34":"a","35":"a","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"a","3.2":"a","4":"a","5":"a","5.1":"a","6":"a","6.1":"a","7":"a","7.1":"a","8":"a"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"a","16":"a","17":"a","18":"a","19":"a","20":"a","21":"a","22":"a","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"a","4.0-4.1":"a","4.2-4.3":"a","5.0-5.1":"a","6.0-6.1":"a","7.0-7.1":"a","8":"a","8.1":"a"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"a","2.2":"a","2.3":"a","3":"a","4":"a","4.1":"a","4.2-4.3":"a","4.4":"a","4.4.3-4.4.4":"a","37":"y"},"bb":{"7":"u","10":"u"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"a"},"and_chr":{"40":"y"},"and_ff":{"33":"a"},"ie_mob":{"10":"a","11":"a"},"and_uc":{"9.9":"a"}},"notes":"Partial support indicates that unnecessary code-ranges are downloaded by the browser - see [browser test matrix](https://docs.google.com/a/chromium.org/spreadsheets/d/18h-1gaosu4-KYxH8JUNL6ZDuOsOKmWfauoai3CS3hPY/edit?pli=1#gid=0).","notes_by_num":{},"usage_perc_y":40.14,"usage_perc_a":37.28,"ucprefix":false,"parent":"","keywords":"font face,unicode,unicode-range","ie_id":"","chrome_id":""},"gamepad":{"title":"Gamepad API","description":"API to support input from USB gamepad controllers though JavaScript.","spec":"http://www.w3.org/TR/gamepad/","status":"wd","links":[{"url":"http://luser.github.io/gamepadtest/","title":"Controller demo"},{"url":"https://developer.mozilla.org/en-US/docs/Web/API/Gamepad_API","title":"MDN article"},{"url":"http://www.html5rocks.com/en/tutorials/doodles/gamepad/","title":"HTML5Rocks article"},{"url":"http://gamedevelopment.tutsplus.com/tutorials/using-the-html5-gamepad-api-to-add-controller-support-to-browser-games--cms-21345","title":"Detailed tutorial"}],"categories":["JS API"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"y x","22":"y x","23":"y x","24":"y x","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"n","7":"n","7.1":"n","8":"n"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"n","8.1":"n"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"n","4.4.3-4.4.4":"n","37":"n"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"n"},"and_chr":{"40":"n"},"and_ff":{"33":"n"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"n"}},"notes":"","notes_by_num":{},"usage_perc_y":43.26,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"","ie_id":"gamepadapi","chrome_id":"5118776383111168"},"css-font-stretch":{"title":"CSS font-stretch","description":"If a font has multiple types of variations based on the width of characters, the `font-stretch` property allows the appropriate one to be selected. The property in itself does not cause the browser to stretch to a font.","spec":"http://www.w3.org/TR/css-fonts-3/#font-stretch-prop","status":"cr","links":[{"url":"https://developer.mozilla.org/en-US/docs/Web/CSS/font-stretch","title":"MDN article"},{"url":"http://css-tricks.com/almanac/properties/f/font-stretch/","title":"CSS Tricks article"}],"categories":["CSS"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"y","10":"y","11":"y","TP":"y"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"n","34":"n","35":"n","36":"n","37":"n","38":"n","39":"n","40":"n","41":"u","42":"u","43":"u"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"n","7":"n","7.1":"n","8":"n"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"u","29":"u"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"n","8.1":"n"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"n","4.4.3-4.4.4":"n","37":"n"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"n"},"and_chr":{"40":"n"},"and_ff":{"33":"y"},"ie_mob":{"10":"y","11":"y"},"and_uc":{"9.9":"n"}},"notes":"","notes_by_num":{},"usage_perc_y":24.58,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"font stretch","ie_id":"cssfontstretch","chrome_id":"4598830058176512"},"font-size-adjust":{"title":"CSS font-size-adjust","description":"Method of adjusting the font size in a matter that relates to the height of lowercase vs. uppercase letters. This makes it easier to set the size of fallback fonts.","spec":"http://www.w3.org/TR/css-fonts-3/#font-size-adjust-prop","status":"cr","links":[{"url":"http://webdesignernotebook.com/css/the-little-known-font-size-adjust-css3-property/","title":"Article on font-size-adjust"},{"url":"https://developer.mozilla.org/en-US/docs/Web/CSS/font-size-adjust","title":"MDN article on font-size-adjust"}],"categories":["CSS"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"y","3.5":"y","3.6":"y","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"n","34":"n","35":"n","36":"n","37":"n","38":"n","39":"n","40":"n","41":"u","42":"u","43":"u"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"n","7":"n","7.1":"n","8":"n"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"u","29":"u"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"n","8.1":"n"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"n","4.4.3-4.4.4":"n","37":"n"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"n"},"and_chr":{"40":"n"},"and_ff":{"33":"n"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"n"}},"notes":"Does not appear to work on Firefox mobile, despite recognition of the property.","notes_by_num":{},"usage_perc_y":11.87,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"","ie_id":"","chrome_id":""},"link-icon-png":{"title":"PNG favicons","description":"Icon used by browsers to identify a webpage or site. While all browsers support the `.ico` format, the PNG format can be preferable.","spec":"https://html.spec.whatwg.org/multipage/semantics.html#rel-icon","status":"ls","links":[{"url":"http://css-tricks.com/favicon-quiz/","title":"Detailed info on favicons for various uses"}],"categories":["HTML5"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"y","TP":"y"},"firefox":{"2":"y","3":"y","3.5":"y","3.6":"y","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"y #1","5":"y #1","6":"y #1","7":"y #1","8":"y #1","9":"y #1","10":"y #1","11":"y #1","12":"y #1","13":"y #1","14":"y #1","15":"y #1","16":"y #1","17":"y #1","18":"y #1","19":"y #1","20":"y #1","21":"y #1","22":"y #1","23":"y #1","24":"y #1","25":"y #1","26":"y #1","27":"y #1","28":"y #1","29":"y #1","30":"y #1","31":"y #1","32":"y #1","33":"y #1","34":"y #1","35":"y #1","36":"y #1","37":"y #1","38":"y #1","39":"y #1","40":"y #1","41":"y #1","42":"y #1","43":"y #1"},"safari":{"3.1":"y #2","3.2":"y #2","4":"y #2","5":"y #2","5.1":"y #2","6":"y #2","6.1":"y #2","7":"y #2","7.1":"y #2","8":"y #2"},"opera":{"9":"y #3","9.5-9.6":"y #3","10.0-10.1":"y #3","10.5":"y #3","10.6":"y #3","11":"y #3","11.1":"y #3","11.5":"y #3","11.6":"y #3","12":"y #3","12.1":"y #3","15":"y #1","16":"y #1","17":"y #1","18":"y #1","19":"y #1","20":"y #1","21":"y #1","22":"y #1","23":"y #1","24":"y #1","25":"y #1","26":"y #1","27":"y #1","28":"y #1","29":"y #1"},"ios_saf":{"3.2":"n #4","4.0-4.1":"n #4","4.2-4.3":"n #4","5.0-5.1":"n #4","6.0-6.1":"n #4","7.0-7.1":"n #4","8":"n #4","8.1":"n #4"},"op_mini":{"5.0-8.0":"n #4"},"android":{"2.1":"y","2.2":"y","2.3":"y","3":"y","4":"y","4.1":"y","4.2-4.3":"y","4.4":"y #3","4.4.3-4.4.4":"y #3","37":"y #3"},"bb":{"7":"y","10":"n #4"},"op_mob":{"10":"n #4","11":"n #4","11.1":"n #4","11.5":"n #4","12":"n #4","12.1":"n #4","24":"n #4"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"n #4","11":"n #4"},"and_uc":{"9.9":"y #2"}},"notes":"Win8/IE10+ and iOS Safari support other types of icons for webpages too, using alternate tags.\r\n\r\nSee also [SVG favicons](#feat=link-icon-svg).","notes_by_num":{"1":"If both ICO and PNG are available, will use ICO over PNG if ICO has better matching sizes set.","2":"If both ICO and PNG are available, will ALWAYS use ICO file, regardless of sizes set.","3":"If multiple formats are available, will use the last one loaded, regardless of sizes (effectively picks at random).","4":"Does not use favicons at all (but may have alternative for bookmarks, etc.)."},"usage_perc_y":77.49,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"","ie_id":"","chrome_id":""},"link-icon-svg":{"title":"SVG favicons","description":"Icon used by browsers to identify a webpage or site. While all browsers support the `.ico` format, the SVG format can be preferable to more easily support higher resolutions or larger icons.","spec":"https://html.spec.whatwg.org/multipage/semantics.html#rel-icon","status":"ls","links":[{"url":"http://crbug.com/294179","title":"Chrome bug"}],"categories":["HTML5","SVG"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"y","5":"y","6":"y","7":"y","8":"y","9":"y","10":"y","11":"y","12":"y","13":"y","14":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"n","34":"n","35":"n","36":"n","37":"n","38":"n","39":"n","40":"n","41":"u","42":"u","43":"u"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"n","7":"n","7.1":"n","8":"n"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"u","29":"u"},"ios_saf":{"3.2":"n #1","4.0-4.1":"n #1","4.2-4.3":"n #1","5.0-5.1":"n #1","6.0-6.1":"n #1","7.0-7.1":"n #1","8":"n #1","8.1":"n #1"},"op_mini":{"5.0-8.0":"n #1"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"n","4.4.3-4.4.4":"n","37":"n"},"bb":{"7":"n","10":"n #1"},"op_mob":{"10":"n #1","11":"n #1","11.1":"n #1","11.5":"n #1","12":"n #1","12.1":"n #1","24":"n #1"},"and_chr":{"40":"n"},"and_ff":{"33":"n"},"ie_mob":{"10":"n #1","11":"n #1"},"and_uc":{"9.9":"n"}},"notes":"See also [PNG favicons](#feat=link-icon-png).","notes_by_num":{"1":"Does not use favicons at all"},"usage_perc_y":11.74,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"","ie_id":"","chrome_id":""},"css-media-resolution":{"title":"Media Queries: resolution feature","description":"Allows a media query to be set based on the device pixels used per CSS unit. While the standard uses `min`/`max-resolution` for this, some browsers support the older non-standard `device-pixel-ratio` media query.","spec":"http://www.w3.org/TR/css3-mediaqueries/#resolution","status":"rec","links":[{"url":"http://www.w3.org/blog/CSS/2012/06/14/unprefix-webkit-device-pixel-ratio/","title":"How to unprefix -webkit-device-pixel-ratio"}],"categories":["CSS","CSS3"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"a #1","10":"a #1","11":"a #1","TP":"a #2"},"firefox":{"2":"n","3":"n","3.5":"a #3","3.6":"a #3","4":"a #3","5":"a #3","6":"a #3","7":"a #3","8":"a #3","9":"a #3","10":"a #3","11":"a #3","12":"a #3","13":"a #3","14":"a #3","15":"a #3","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"a x #4","5":"a x #4","6":"a x #4","7":"a x #4","8":"a x #4","9":"a x #4","10":"a x #4","11":"a x #4","12":"a x #4","13":"a x #4","14":"a x #4","15":"a x #4","16":"a x #4","17":"a x #4","18":"a x #4","19":"a x #4","20":"a x #4","21":"a x #4","22":"a x #4","23":"a x #4","24":"a x #4","25":"a x #4","26":"a x #4","27":"a x #4","28":"a x #4","29":"y","30":"y","31":"y","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"a x #4","5":"a x #4","5.1":"a x #4","6":"a x #4","6.1":"a x #4","7":"a x #4","7.1":"a x #4","8":"a x #4"},"opera":{"9":"n","9.5-9.6":"a x #4","10.0-10.1":"a x #4","10.5":"a x #4","10.6":"a x #4","11":"a x #4","11.1":"a x #4","11.5":"a x #4","11.6":"a x #4","12":"a x #4","12.1":"y","15":"y","16":"y","17":"y","18":"y","19":"y","20":"y","21":"y","22":"y","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"u","4.0-4.1":"a x #4","4.2-4.3":"a x #4","5.0-5.1":"a x #4","6.0-6.1":"a x #4","7.0-7.1":"a x #4","8":"a x #4","8.1":"a x #4"},"op_mini":{"5.0-8.0":"a #1"},"android":{"2.1":"u","2.2":"u","2.3":"u","3":"u","4":"a x #4","4.1":"a x #4","4.2-4.3":"a x #4","4.4":"y","4.4.3-4.4.4":"y","37":"y"},"bb":{"7":"a x #4","10":"a x #4"},"op_mob":{"10":"u","11":"u","11.1":"u","11.5":"u","12":"u","12.1":"y","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"y"},"ie_mob":{"10":"a #1","11":"a #1"},"and_uc":{"9.9":"a x #4"}},"notes":"","notes_by_num":{"1":"Supports the `dpi` unit, but does not support `dppx` or `dpcm` units.","2":"Supports the `dpi` and `dppx` units, but does not support `dpcm` units.","3":"Firefox before 16 supports only `dpi` unit, but you can set `2dppx` per `min--moz-device-pixel-ratio: 2`","4":"Supporte the non-standard `min`/`max-device-pixel-ratio`"},"usage_perc_y":57.96,"usage_perc_a":34.61,"ucprefix":false,"parent":"css-mediaqueries","keywords":"@media,device-pixel-ratio,resolution","ie_id":"mediaqueriesresolutionfeature,dppxunitfortheresolutionmediaquery","chrome_id":"5944509615570944"},"css-image-set":{"title":"CSS image-set","description":"Method of letting the browser pick the most appropriate CSS background image from a given set, primarily for high PPI screens.","spec":"http://dev.w3.org/csswg/css-images-3/#image-set-notation","status":"unoff","links":[{"url":"http://cloudfour.com/examples/image-set/","title":"Demo"}],"categories":["CSS"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"n","34":"n","35":"n","36":"n","37":"n","38":"n"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"y x","22":"y x","23":"y x","24":"y x","25":"y x","26":"y x","27":"y x","28":"y x","29":"y x","30":"y x","31":"y x","32":"y x","33":"y x","34":"y x","35":"y x","36":"y x","37":"y x","38":"y x","39":"y x","40":"y x","41":"y x","42":"y x","43":"y x"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"y x","6.1":"y x","7":"y x","7.1":"y x","8":"y x"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"y x","16":"y x","17":"y x","18":"y x","19":"y x","20":"y x","21":"y x","22":"y x","23":"y x","24":"y x","25":"y x","26":"y x","27":"y x","28":"y x","29":"y x"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"y x","7.0-7.1":"y x","8":"y x","8.1":"y x"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"y x","4.4.3-4.4.4":"y x","37":"y x"},"bb":{"7":"u","10":"y x"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"y x"},"and_chr":{"40":"y x"},"and_ff":{"33":"n"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"n"}},"notes":"","notes_by_num":{},"usage_perc_y":56.7,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"","ie_id":"","chrome_id":""},"css-boxdecorationbreak":{"title":"CSS box-decoration-break","description":"Controls whether the box's margins, borders, padding, and other decorations wrap the broken edges of the box fragments (when the box is split by a break (page/column/region/line).","spec":"http://www.w3.org/TR/css3-break/#break-decoration","status":"wd","links":[{"url":"https://developer.mozilla.org/en-US/docs/Web/CSS/box-decoration-break","title":"MDN article"},{"url":"http://jsbin.com/xojoro/edit?css,output","title":"Demo of effect on box border"}],"categories":["CSS3"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"y","33":"y","34":"y","35":"y","36":"y","37":"y","38":"y"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"y x","23":"y x","24":"y x","25":"y x","26":"y x","27":"y x","28":"y x","29":"y x","30":"y x","31":"y x","32":"y x","33":"y x","34":"y x","35":"y x","36":"y x","37":"y x","38":"y x","39":"y x","40":"y x","41":"y x","42":"y x","43":"y x"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"y x","7":"y x","7.1":"y x","8":"y x"},"opera":{"9":"u","9.5-9.6":"u","10.0-10.1":"u","10.5":"u","10.6":"u","11":"y","11.1":"y","11.5":"y","11.6":"y","12":"y","12.1":"y","15":"y x","16":"y x","17":"y x","18":"y x","19":"y x","20":"y x","21":"y x","22":"y x","23":"y x","24":"y x","25":"y x","26":"y x","27":"y x","28":"y x","29":"y x"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"y x","8":"y x","8.1":"y x"},"op_mini":{"5.0-8.0":"y"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"y x","4.4.3-4.4.4":"y x","37":"y x"},"bb":{"7":"u","10":"y x"},"op_mob":{"10":"u","11":"y","11.1":"y","11.5":"y","12":"y","12.1":"y","24":"y x"},"and_chr":{"40":"y x"},"and_ff":{"33":"y"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"n"}},"notes":"","notes_by_num":{},"usage_perc_y":69.86,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"box-decoration,box decoration,break","ie_id":"","chrome_id":""},"object-observe":{"title":"Object.observe data binding","description":"Method for data binding, part of the ECMAScript 7 proposals","spec":"http://wiki.ecmascript.org/doku.php?id=harmony:observe","status":"other","links":[{"url":"http://www.html5rocks.com/en/tutorials/es7/observe/","title":"Data-binding Revolutions with Object.observe()"}],"categories":["JS API"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"n","34":"n","35":"n","36":"n","37":"n","38":"n"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"n","34":"n","35":"n","36":"y","37":"y","38":"y","39":"y","40":"y","41":"y","42":"y","43":"y"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"n","7":"n","7.1":"n","8":"n"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"y","24":"y","25":"y","26":"y","27":"y","28":"y","29":"y"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"n","8.1":"n"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"n","4.4.3-4.4.4":"n","37":"y"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"y"},"and_chr":{"40":"y"},"and_ff":{"33":"n"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"n"}},"notes":"","notes_by_num":{},"usage_perc_y":40.13,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"","ie_id":"objectobserve","chrome_id":"6147094632988672"},"broadcastchannel":{"title":"BroadcastChannel","description":"BroadcastChannel allows scripts from the same origin but other browsing contexts (windows, workers) to send each other messages.","spec":"https://html.spec.whatwg.org/multipage/comms.html#broadcasting-to-other-browsing-contexts","status":"ls","links":[{"url":"https://developer.mozilla.org/en-US/docs/Web/API/BroadcastChannel","title":"MDN article"}],"categories":["JS API"],"stats":{"ie":{"5.5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","TP":"n"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"n","34":"n","35":"n","36":"n","37":"n","38":"y"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"n","34":"n","35":"n","36":"n","37":"n","38":"n","39":"n","40":"n","41":"n","42":"n","43":"n"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"n","7":"n","7.1":"n","8":"n"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"n","8.1":"n"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"n","4.4.3-4.4.4":"n","37":"n"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"n"},"and_chr":{"40":"n"},"and_ff":{"33":"n"},"ie_mob":{"10":"n","11":"n"},"and_uc":{"9.9":"n"}},"notes":"","notes_by_num":{},"usage_perc_y":0,"usage_perc_a":0,"ucprefix":false,"parent":"","keywords":"broadcast,channel,messaging","ie_id":"","chrome_id":"4585496197988352"},"css-text-align-last":{"title":"CSS3 text-align-last","description":"CSS property to describe how the last line of a block or a line right before a forced line break when `text-align` is `justify`.","spec":"http://www.w3.org/TR/css3-text/#text-align-last-property","status":"wd","links":[{"url":"https://developer.mozilla.org/en-US/docs/Web/CSS/text-align-last","title":"MDN text-align-last"},{"url":"http://blogs.adobe.com/webplatform/2014/02/25/improving-your-sites-visual-details-css3-text-align-last/","title":"Adobe Web Platform Article"}],"categories":["CSS3"],"stats":{"ie":{"5.5":"a #1","6":"a #1","7":"a #1","8":"a #1","9":"a #1","10":"a #1","11":"a #1","TP":"a #1"},"firefox":{"2":"n","3":"n","3.5":"n","3.6":"n","4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"y x","13":"y x","14":"y x","15":"y x","16":"y x","17":"y x","18":"y x","19":"y x","20":"y x","21":"y x","22":"y x","23":"y x","24":"y x","25":"y x","26":"y x","27":"y x","28":"y x","29":"y x","30":"y x","31":"y x","32":"y x","33":"y x","34":"y x","35":"y x","36":"y x","37":"y x","38":"y x"},"chrome":{"4":"n","5":"n","6":"n","7":"n","8":"n","9":"n","10":"n","11":"n","12":"n","13":"n","14":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n","23":"n","24":"n","25":"n","26":"n","27":"n","28":"n","29":"n","30":"n","31":"n","32":"n","33":"n","34":"n","35":"n d #2","36":"n d #2","37":"n d #2","38":"n d #2","39":"n d #2","40":"n d #2","41":"n d #2","42":"n d #2","43":"n d #2"},"safari":{"3.1":"n","3.2":"n","4":"n","5":"n","5.1":"n","6":"n","6.1":"n","7":"n","7.1":"n","8":"n"},"opera":{"9":"n","9.5-9.6":"n","10.0-10.1":"n","10.5":"n","10.6":"n","11":"n","11.1":"n","11.5":"n","11.6":"n","12":"n","12.1":"n","15":"n","16":"n","17":"n","18":"n","19":"n","20":"n","21":"n","22":"n d #3","23":"n d #3","24":"n d #3","25":"n d #3","26":"n d #3","27":"n d #3","28":"n d #3","29":"n d #3"},"ios_saf":{"3.2":"n","4.0-4.1":"n","4.2-4.3":"n","5.0-5.1":"n","6.0-6.1":"n","7.0-7.1":"n","8":"n","8.1":"n"},"op_mini":{"5.0-8.0":"n"},"android":{"2.1":"n","2.2":"n","2.3":"n","3":"n","4":"n","4.1":"n","4.2-4.3":"n","4.4":"n","4.4.3-4.4.4":"n","37":"n"},"bb":{"7":"n","10":"n"},"op_mob":{"10":"n","11":"n","11.1":"n","11.5":"n","12":"n","12.1":"n","24":"n"},"and_chr":{"40":"n"},"and_ff":{"33":"y x"},"ie_mob":{"10":"a #1","11":"a #1"},"and_uc":{"9.9":"n"}},"notes":"","notes_by_num":{"1":"In Internet Explorer, the start and end values are not supported.","2":"Enabled through the \"Enable Experimental Web Platform Features\" flag in chrome://flags","3":"Enabled through the \"Enable Experimental Web Platform Features\" flag in opera://flags"},"usage_perc_y":11.65,"usage_perc_a":17.19,"ucprefix":false,"parent":"","keywords":"text align last","ie_id":"","chrome_id":""}}}
6018 },{}],57:[function(require,module,exports){
6019 module.exports={
6020   "title":"CSS3 Background-image options",
6021   "description":"New properties to affect background images, including background-clip, background-origin and background-size",
6022   "spec":"http://www.w3.org/TR/css3-background/#backgrounds",
6023   "status":"cr",
6024   "links":[
6025     {
6026       "url":"http://www.standardista.com/css3/css3-background-properties",
6027       "title":"Detailed compatibility tables and demos"
6028     },
6029     {
6030       "url":"http://www.css3files.com/background/",
6031       "title":"Information page"
6032     },
6033     {
6034       "url":"https://github.com/louisremi/background-size-polyfill",
6035       "title":"Polyfill for IE7-8"
6036     }
6037   ],
6038   "bugs":[
6039     {
6040       "description":"iOS Safari has buggy behavior with `background-size: cover;` on a page's body."
6041     },
6042     {
6043       "description":"iOS Safari has buggy behavior with `background-size: cover;` + `background-attachment: fixed;`"
6044     }
6045   ],
6046   "categories":[
6047     "CSS3"
6048   ],
6049   "stats":{
6050     "ie":{
6051       "5.5":"n",
6052       "6":"n",
6053       "7":"n",
6054       "8":"n",
6055       "9":"y",
6056       "10":"y",
6057       "11":"y",
6058       "TP":"y"
6059     },
6060     "firefox":{
6061       "2":"n",
6062       "3":"n",
6063       "3.5":"n",
6064       "3.6":"a x",
6065       "4":"y",
6066       "5":"y",
6067       "6":"y",
6068       "7":"y",
6069       "8":"y",
6070       "9":"y",
6071       "10":"y",
6072       "11":"y",
6073       "12":"y",
6074       "13":"y",
6075       "14":"y",
6076       "15":"y",
6077       "16":"y",
6078       "17":"y",
6079       "18":"y",
6080       "19":"y",
6081       "20":"y",
6082       "21":"y",
6083       "22":"y",
6084       "23":"y",
6085       "24":"y",
6086       "25":"y",
6087       "26":"y",
6088       "27":"y",
6089       "28":"y",
6090       "29":"y",
6091       "30":"y",
6092       "31":"y",
6093       "32":"y",
6094       "33":"y",
6095       "34":"y",
6096       "35":"y",
6097       "36":"y",
6098       "37":"y",
6099       "38":"y"
6100     },
6101     "chrome":{
6102       "4":"a #3",
6103       "5":"a #3",
6104       "6":"a #3",
6105       "7":"a #3",
6106       "8":"a #3",
6107       "9":"a #3",
6108       "10":"a #3",
6109       "11":"a #3",
6110       "12":"a #3",
6111       "13":"a #3",
6112       "14":"a #3",
6113       "15":"y",
6114       "16":"y",
6115       "17":"y",
6116       "18":"y",
6117       "19":"y",
6118       "20":"y",
6119       "21":"y",
6120       "22":"y",
6121       "23":"y",
6122       "24":"y",
6123       "25":"y",
6124       "26":"y",
6125       "27":"y",
6126       "28":"y",
6127       "29":"y",
6128       "30":"y",
6129       "31":"y",
6130       "32":"y",
6131       "33":"y",
6132       "34":"y",
6133       "35":"y",
6134       "36":"y",
6135       "37":"y",
6136       "38":"y",
6137       "39":"y",
6138       "40":"y",
6139       "41":"y",
6140       "42":"y",
6141       "43":"y"
6142     },
6143     "safari":{
6144       "3.1":"a #2 #3",
6145       "3.2":"a #2 #3",
6146       "4":"a #2 #3",
6147       "5":"a #2 #3",
6148       "5.1":"a #2 #3",
6149       "6":"a #2 #3",
6150       "6.1":"a #2 #3",
6151       "7":"y",
6152       "7.1":"y",
6153       "8":"y"
6154     },
6155     "opera":{
6156       "9":"n",
6157       "9.5-9.6":"n",
6158       "10.0-10.1":"a x",
6159       "10.5":"y",
6160       "10.6":"y",
6161       "11":"y",
6162       "11.1":"y",
6163       "11.5":"y",
6164       "11.6":"y",
6165       "12":"y",
6166       "12.1":"y",
6167       "15":"y",
6168       "16":"y",
6169       "17":"y",
6170       "18":"y",
6171       "19":"y",
6172       "20":"y",
6173       "21":"y",
6174       "22":"y",
6175       "23":"y",
6176       "24":"y",
6177       "25":"y",
6178       "26":"y",
6179       "27":"y",
6180       "28":"y",
6181       "29":"y"
6182     },
6183     "ios_saf":{
6184       "3.2":"a",
6185       "4.0-4.1":"a",
6186       "4.2-4.3":"a",
6187       "5.0-5.1":"a #3",
6188       "6.0-6.1":"a",
6189       "7.0-7.1":"y",
6190       "8":"y",
6191       "8.1":"y"
6192     },
6193     "op_mini":{
6194       "5.0-8.0":"a #1"
6195     },
6196     "android":{
6197       "2.1":"a x",
6198       "2.2":"a x #3",
6199       "2.3":"a x #3",
6200       "3":"a #3",
6201       "4":"a #3",
6202       "4.1":"a #3",
6203       "4.2-4.3":"a #3",
6204       "4.4":"y",
6205       "4.4.3-4.4.4":"y",
6206       "37":"y"
6207     },
6208     "bb":{
6209       "7":"y",
6210       "10":"y"
6211     },
6212     "op_mob":{
6213       "10":"y",
6214       "11":"y",
6215       "11.1":"y",
6216       "11.5":"y",
6217       "12":"y",
6218       "12.1":"y",
6219       "24":"y"
6220     },
6221     "and_chr":{
6222       "40":"y"
6223     },
6224     "and_ff":{
6225       "33":"y"
6226     },
6227     "ie_mob":{
6228       "10":"y",
6229       "11":"y"
6230     },
6231     "and_uc":{
6232       "9.9":"y"
6233     }
6234   },
6235   "notes":"",
6236   "notes_by_num":{
6237     "1":"Partial support in Opera Mini refers to not supporting background sizing or background attachments. However Opera Mini 7.5 supports background sizing (including cover and contain values).",
6238     "2":"Partial support in Safari 6 refers to not supporting background sizing offset from edges syntax.",
6239     "3":"Does not support `background-size` values in the `background` shorthand"
6240   },
6241   "usage_perc_y":85.13,
6242   "usage_perc_a":7.59,
6243   "ucprefix":false,
6244   "parent":"",
6245   "keywords":"",
6246   "ie_id":"",
6247   "chrome_id":"",
6248   "shown":true
6249 }
6250 },{}],58:[function(require,module,exports){
6251 module.exports={
6252   "title":"CSS3 Border images",
6253   "description":"Method of using images for borders",
6254   "spec":"http://www.w3.org/TR/css3-background/#the-border-image",
6255   "status":"cr",
6256   "links":[
6257     {
6258       "url":"http://www.css3files.com/border/",
6259       "title":"Information page"
6260     },
6261     {
6262       "url":"http://docs.webplatform.org/wiki/css/properties/border-image",
6263       "title":"WebPlatform Docs"
6264     }
6265   ],
6266   "bugs":[
6267
6268   ],
6269   "categories":[
6270     "CSS3"
6271   ],
6272   "stats":{
6273     "ie":{
6274       "5.5":"n",
6275       "6":"n",
6276       "7":"n",
6277       "8":"n",
6278       "9":"n",
6279       "10":"n",
6280       "11":"y",
6281       "TP":"y"
6282     },
6283     "firefox":{
6284       "2":"n",
6285       "3":"n",
6286       "3.5":"a x",
6287       "3.6":"a x",
6288       "4":"a x",
6289       "5":"a x",
6290       "6":"a x",
6291       "7":"a x",
6292       "8":"a x",
6293       "9":"a x",
6294       "10":"a x",
6295       "11":"a x",
6296       "12":"a x",
6297       "13":"a x",
6298       "14":"a x",
6299       "15":"y",
6300       "16":"y",
6301       "17":"y",
6302       "18":"y",
6303       "19":"y",
6304       "20":"y",
6305       "21":"y",
6306       "22":"y",
6307       "23":"y",
6308       "24":"y",
6309       "25":"y",
6310       "26":"y",
6311       "27":"y",
6312       "28":"y",
6313       "29":"y",
6314       "30":"y",
6315       "31":"y",
6316       "32":"y",
6317       "33":"y",
6318       "34":"y",
6319       "35":"y",
6320       "36":"y",
6321       "37":"y",
6322       "38":"y"
6323     },
6324     "chrome":{
6325       "4":"a x",
6326       "5":"a x",
6327       "6":"a x",
6328       "7":"a x",
6329       "8":"a x",
6330       "9":"a x",
6331       "10":"a x",
6332       "11":"a x",
6333       "12":"a x",
6334       "13":"a x",
6335       "14":"a x",
6336       "15":"y x",
6337       "16":"y",
6338       "17":"y",
6339       "18":"y",
6340       "19":"y",
6341       "20":"y",
6342       "21":"y",
6343       "22":"y",
6344       "23":"y",
6345       "24":"y",
6346       "25":"y",
6347       "26":"y",
6348       "27":"y",
6349       "28":"y",
6350       "29":"y",
6351       "30":"y",
6352       "31":"y",
6353       "32":"y",
6354       "33":"y",
6355       "34":"y",
6356       "35":"y",
6357       "36":"y",
6358       "37":"y",
6359       "38":"y",
6360       "39":"y",
6361       "40":"y",
6362       "41":"y",
6363       "42":"y",
6364       "43":"y"
6365     },
6366     "safari":{
6367       "3.1":"a x",
6368       "3.2":"a x",
6369       "4":"a x",
6370       "5":"a x",
6371       "5.1":"a x",
6372       "6":"y",
6373       "6.1":"y",
6374       "7":"y",
6375       "7.1":"y",
6376       "8":"y"
6377     },
6378     "opera":{
6379       "9":"n",
6380       "9.5-9.6":"n",
6381       "10.0-10.1":"n",
6382       "10.5":"a",
6383       "10.6":"a",
6384       "11":"a x",
6385       "11.1":"a x",
6386       "11.5":"a x",
6387       "11.6":"a x",
6388       "12":"a x",
6389       "12.1":"a x",
6390       "15":"y",
6391       "16":"y",
6392       "17":"y",
6393       "18":"y",
6394       "19":"y",
6395       "20":"y",
6396       "21":"y",
6397       "22":"y",
6398       "23":"y",
6399       "24":"y",
6400       "25":"y",
6401       "26":"y",
6402       "27":"y",
6403       "28":"y",
6404       "29":"y"
6405     },
6406     "ios_saf":{
6407       "3.2":"a x",
6408       "4.0-4.1":"a x",
6409       "4.2-4.3":"a x",
6410       "5.0-5.1":"a x",
6411       "6.0-6.1":"y",
6412       "7.0-7.1":"y",
6413       "8":"y",
6414       "8.1":"y"
6415     },
6416     "op_mini":{
6417       "5.0-8.0":"n"
6418     },
6419     "android":{
6420       "2.1":"a x",
6421       "2.2":"a x",
6422       "2.3":"a x",
6423       "3":"a x",
6424       "4":"a x",
6425       "4.1":"a x",
6426       "4.2-4.3":"a x",
6427       "4.4":"y",
6428       "4.4.3-4.4.4":"y",
6429       "37":"y"
6430     },
6431     "bb":{
6432       "7":"a x",
6433       "10":"y"
6434     },
6435     "op_mob":{
6436       "10":"n",
6437       "11":"a x",
6438       "11.1":"a x",
6439       "11.5":"a x",
6440       "12":"a x",
6441       "12.1":"a x",
6442       "24":"y"
6443     },
6444     "and_chr":{
6445       "40":"y"
6446     },
6447     "and_ff":{
6448       "33":"y"
6449     },
6450     "ie_mob":{
6451       "10":"n",
6452       "11":"y"
6453     },
6454     "and_uc":{
6455       "9.9":"y"
6456     }
6457   },
6458   "notes":"Note that both the border-style and border-width must be specified for border-images to work according to spec, though older implementations may not have this requirement. Partial support refers to supporting the shorthand syntax, but not the individual properties (border-image-source, border-image-slice, etc). ",
6459   "notes_by_num":{
6460
6461   },
6462   "usage_perc_y":80.88,
6463   "usage_perc_a":4.66,
6464   "ucprefix":false,
6465   "parent":"",
6466   "keywords":"",
6467   "ie_id":"",
6468   "chrome_id":"",
6469   "shown":true
6470 }
6471 },{}],59:[function(require,module,exports){
6472 module.exports={
6473   "title":"CSS3 Border-radius (rounded corners)",
6474   "description":"Method of making the border corners round",
6475   "spec":"http://www.w3.org/TR/css3-background/#the-border-radius",
6476   "status":"cr",
6477   "links":[
6478     {
6479       "url":"http://border-radius.com",
6480       "title":"Border-radius CSS Generator"
6481     },
6482     {
6483       "url":"http://muddledramblings.com/table-of-css3-border-radius-compliance",
6484       "title":"Detailed compliance table"
6485     },
6486     {
6487       "url":"http://www.css3files.com/border/#borderradius",
6488       "title":"Information page"
6489     },
6490     {
6491       "url":"http://css3pie.com/",
6492       "title":"Polyfill which includes border-radius"
6493     },
6494     {
6495       "url":"http://docs.webplatform.org/wiki/css/properties/border-radius",
6496       "title":"WebPlatform Docs"
6497     }
6498   ],
6499   "bugs":[
6500     {
6501       "description":"Safari does not apply `border-radius` correctly to image borders: http://stackoverflow.com/q/17202128"
6502     },
6503     {
6504       "description":"Android Browser 2.3 does not support % value for `border-radius`."
6505     },
6506     {
6507       "description":"Border-radius does not work on fieldset elements in IE9."
6508     },
6509     {
6510       "description":"The stock browser on the Samsung Galaxy S4 with Android 4.2 does not support the `border-radius` shorthand property but does support the long-hand properties for each corner like `border-top-left-radius`."
6511     }
6512   ],
6513   "categories":[
6514     "CSS3"
6515   ],
6516   "stats":{
6517     "ie":{
6518       "5.5":"n",
6519       "6":"n",
6520       "7":"n",
6521       "8":"n",
6522       "9":"y",
6523       "10":"y",
6524       "11":"y",
6525       "TP":"y"
6526     },
6527     "firefox":{
6528       "2":"a x",
6529       "3":"y x",
6530       "3.5":"y x",
6531       "3.6":"y x",
6532       "4":"y",
6533       "5":"y",
6534       "6":"y",
6535       "7":"y",
6536       "8":"y",
6537       "9":"y",
6538       "10":"y",
6539       "11":"y",
6540       "12":"y",
6541       "13":"y",
6542       "14":"y",
6543       "15":"y",
6544       "16":"y",
6545       "17":"y",
6546       "18":"y",
6547       "19":"y",
6548       "20":"y",
6549       "21":"y",
6550       "22":"y",
6551       "23":"y",
6552       "24":"y",
6553       "25":"y",
6554       "26":"y",
6555       "27":"y",
6556       "28":"y",
6557       "29":"y",
6558       "30":"y",
6559       "31":"y",
6560       "32":"y",
6561       "33":"y",
6562       "34":"y",
6563       "35":"y",
6564       "36":"y",
6565       "37":"y",
6566       "38":"y"
6567     },
6568     "chrome":{
6569       "4":"y x",
6570       "5":"y",
6571       "6":"y",
6572       "7":"y",
6573       "8":"y",
6574       "9":"y",
6575       "10":"y",
6576       "11":"y",
6577       "12":"y",
6578       "13":"y",
6579       "14":"y",
6580       "15":"y",
6581       "16":"y",
6582       "17":"y",
6583       "18":"y",
6584       "19":"y",
6585       "20":"y",
6586       "21":"y",
6587       "22":"y",
6588       "23":"y",
6589       "24":"y",
6590       "25":"y",
6591       "26":"y",
6592       "27":"y",
6593       "28":"y",
6594       "29":"y",
6595       "30":"y",
6596       "31":"y",
6597       "32":"y",
6598       "33":"y",
6599       "34":"y",
6600       "35":"y",
6601       "36":"y",
6602       "37":"y",
6603       "38":"y",
6604       "39":"y",
6605       "40":"y",
6606       "41":"y",
6607       "42":"y",
6608       "43":"y"
6609     },
6610     "safari":{
6611       "3.1":"y x",
6612       "3.2":"y x",
6613       "4":"y x",
6614       "5":"y",
6615       "5.1":"y",
6616       "6":"y",
6617       "6.1":"y",
6618       "7":"y",
6619       "7.1":"y",
6620       "8":"y"
6621     },
6622     "opera":{
6623       "9":"n",
6624       "9.5-9.6":"n",
6625       "10.0-10.1":"n",
6626       "10.5":"y",
6627       "10.6":"y",
6628       "11":"y",
6629       "11.1":"y",
6630       "11.5":"y",
6631       "11.6":"y",
6632       "12":"y",
6633       "12.1":"y",
6634       "15":"y",
6635       "16":"y",
6636       "17":"y",
6637       "18":"y",
6638       "19":"y",
6639       "20":"y",
6640       "21":"y",
6641       "22":"y",
6642       "23":"y",
6643       "24":"y",
6644       "25":"y",
6645       "26":"y",
6646       "27":"y",
6647       "28":"y",
6648       "29":"y"
6649     },
6650     "ios_saf":{
6651       "3.2":"y x",
6652       "4.0-4.1":"y",
6653       "4.2-4.3":"y",
6654       "5.0-5.1":"y",
6655       "6.0-6.1":"y",
6656       "7.0-7.1":"y",
6657       "8":"y",
6658       "8.1":"y"
6659     },
6660     "op_mini":{
6661       "5.0-8.0":"n"
6662     },
6663     "android":{
6664       "2.1":"y x",
6665       "2.2":"y",
6666       "2.3":"y",
6667       "3":"y",
6668       "4":"y",
6669       "4.1":"y",
6670       "4.2-4.3":"y",
6671       "4.4":"y",
6672       "4.4.3-4.4.4":"y",
6673       "37":"y"
6674     },
6675     "bb":{
6676       "7":"y",
6677       "10":"y"
6678     },
6679     "op_mob":{
6680       "10":"n",
6681       "11":"y",
6682       "11.1":"y",
6683       "11.5":"y",
6684       "12":"y",
6685       "12.1":"y",
6686       "24":"y"
6687     },
6688     "and_chr":{
6689       "40":"y"
6690     },
6691     "and_ff":{
6692       "33":"y"
6693     },
6694     "ie_mob":{
6695       "10":"y",
6696       "11":"y"
6697     },
6698     "and_uc":{
6699       "9.9":"y"
6700     }
6701   },
6702   "notes":"",
6703   "notes_by_num":{
6704
6705   },
6706   "usage_perc_y":89.66,
6707   "usage_perc_a":0.01,
6708   "ucprefix":false,
6709   "parent":"",
6710   "keywords":"roundedcorners, border radius,-moz-border-radius",
6711   "ie_id":"",
6712   "chrome_id":"",
6713   "shown":true
6714 }
6715 },{}],60:[function(require,module,exports){
6716 module.exports={
6717   "title":"calc() as CSS unit value",
6718   "description":"Method of allowing calculated values for length units, i.e. `width: calc(100% - 3em)`",
6719   "spec":"http://www.w3.org/TR/css3-values/#calc",
6720   "status":"cr",
6721   "links":[
6722     {
6723       "url":"http://hacks.mozilla.org/2010/06/css3-calc/",
6724       "title":"Mozilla Hacks article"
6725     },
6726     {
6727       "url":"https://developer.mozilla.org/en/CSS/-moz-calc",
6728       "title":"MDN article"
6729     },
6730     {
6731       "url":"http://docs.webplatform.org/wiki/css/functions/calc",
6732       "title":"WebPlatform Docs"
6733     }
6734   ],
6735   "bugs":[
6736     {
6737       "description":"Safari 7.0 and older and Chrome 26 and older don't support viewport units in `calc()` expressions (fixed since then)."
6738     },
6739     {
6740       "description":"`calc()` doesn't work [inside a transform in IE](http://connect.microsoft.com/IE/feedback/details/814380/css3-using-calc-inside-a-transform-is-invalid)"
6741     },
6742     {
6743       "description":"IE9 appears to ignore `calc()` expressions when `display:table` is used."
6744     },
6745     {
6746       "description":"Safari 6 has a bug where an element with a width defined using `calc()` has its width reset when changing the height using JS (fixed in Safari 7)."
6747     },
6748     {
6749       "description":"IE11 and other browsers to a lesser extent have trouble supporting `calc()` inside [color or transform values](http://codepen.io/thebabydino/pen/wfraH)."
6750     },
6751     {
6752       "description":"IE10 crashes when a div with a property using `calc()` has a child with [same property with `inherit`](http://stackoverflow.com/questions/19423384/css-less-calc-method-is-crashing-my-ie10)."
6753     },
6754     {
6755       "description":"IE 9 - 11 don't render `box-shadow` when `calc()` is used for any of the values."
6756     }
6757   ],
6758   "categories":[
6759     "CSS3"
6760   ],
6761   "stats":{
6762     "ie":{
6763       "5.5":"n",
6764       "6":"n",
6765       "7":"n",
6766       "8":"n",
6767       "9":"a",
6768       "10":"y",
6769       "11":"y",
6770       "TP":"y"
6771     },
6772     "firefox":{
6773       "2":"n",
6774       "3":"n",
6775       "3.5":"n",
6776       "3.6":"n",
6777       "4":"y x",
6778       "5":"y x",
6779       "6":"y x",
6780       "7":"y x",
6781       "8":"y x",
6782       "9":"y x",
6783       "10":"y x",
6784       "11":"y x",
6785       "12":"y x",
6786       "13":"y x",
6787       "14":"y x",
6788       "15":"y x",
6789       "16":"y",
6790       "17":"y",
6791       "18":"y",
6792       "19":"y",
6793       "20":"y",
6794       "21":"y",
6795       "22":"y",
6796       "23":"y",
6797       "24":"y",
6798       "25":"y",
6799       "26":"y",
6800       "27":"y",
6801       "28":"y",
6802       "29":"y",
6803       "30":"y",
6804       "31":"y",
6805       "32":"y",
6806       "33":"y",
6807       "34":"y",
6808       "35":"y",
6809       "36":"y",
6810       "37":"y",
6811       "38":"y"
6812     },
6813     "chrome":{
6814       "4":"n",
6815       "5":"n",
6816       "6":"n",
6817       "7":"n",
6818       "8":"n",
6819       "9":"n",
6820       "10":"n",
6821       "11":"n",
6822       "12":"n",
6823       "13":"n",
6824       "14":"n",
6825       "15":"n",
6826       "16":"n",
6827       "17":"n",
6828       "18":"n",
6829       "19":"y x",
6830       "20":"y x",
6831       "21":"y x",
6832       "22":"y x",
6833       "23":"y x",
6834       "24":"y x",
6835       "25":"y x",
6836       "26":"y",
6837       "27":"y",
6838       "28":"y",
6839       "29":"y",
6840       "30":"y",
6841       "31":"y",
6842       "32":"y",
6843       "33":"y",
6844       "34":"y",
6845       "35":"y",
6846       "36":"y",
6847       "37":"y",
6848       "38":"y",
6849       "39":"y",
6850       "40":"y",
6851       "41":"y",
6852       "42":"y",
6853       "43":"y"
6854     },
6855     "safari":{
6856       "3.1":"n",
6857       "3.2":"n",
6858       "4":"n",
6859       "5":"n",
6860       "5.1":"n",
6861       "6":"y x",
6862       "6.1":"y",
6863       "7":"y",
6864       "7.1":"y",
6865       "8":"y"
6866     },
6867     "opera":{
6868       "9":"n",
6869       "9.5-9.6":"n",
6870       "10.0-10.1":"n",
6871       "10.5":"n",
6872       "10.6":"n",
6873       "11":"n",
6874       "11.1":"n",
6875       "11.5":"n",
6876       "11.6":"n",
6877       "12":"n",
6878       "12.1":"n",
6879       "15":"y",
6880       "16":"y",
6881       "17":"y",
6882       "18":"y",
6883       "19":"y",
6884       "20":"y",
6885       "21":"y",
6886       "22":"y",
6887       "23":"y",
6888       "24":"y",
6889       "25":"y",
6890       "26":"y",
6891       "27":"y",
6892       "28":"y",
6893       "29":"y"
6894     },
6895     "ios_saf":{
6896       "3.2":"n",
6897       "4.0-4.1":"n",
6898       "4.2-4.3":"n",
6899       "5.0-5.1":"n",
6900       "6.0-6.1":"y x",
6901       "7.0-7.1":"y",
6902       "8":"y",
6903       "8.1":"y"
6904     },
6905     "op_mini":{
6906       "5.0-8.0":"n"
6907     },
6908     "android":{
6909       "2.1":"n",
6910       "2.2":"n",
6911       "2.3":"n",
6912       "3":"n",
6913       "4":"n",
6914       "4.1":"n",
6915       "4.2-4.3":"n",
6916       "4.4":"a",
6917       "4.4.3-4.4.4":"a",
6918       "37":"y"
6919     },
6920     "bb":{
6921       "7":"n",
6922       "10":"y x"
6923     },
6924     "op_mob":{
6925       "10":"n",
6926       "11":"n",
6927       "11.1":"n",
6928       "11.5":"n",
6929       "12":"n",
6930       "12.1":"n",
6931       "24":"y"
6932     },
6933     "and_chr":{
6934       "40":"y"
6935     },
6936     "and_ff":{
6937       "33":"y"
6938     },
6939     "ie_mob":{
6940       "10":"y",
6941       "11":"y"
6942     },
6943     "and_uc":{
6944       "9.9":"n"
6945     }
6946   },
6947   "notes":"Support can be somewhat emulated in older versions of IE using the non-standard `expression()` syntax. Partial support in IE9 refers to the browser crashing when used as a `background-position` value. Partial support in Android Browser 4.4 refers to the browser lacking the ability to multiply and divide values.",
6948   "notes_by_num":{
6949
6950   },
6951   "usage_perc_y":75.77,
6952   "usage_perc_a":5.66,
6953   "ucprefix":false,
6954   "parent":"",
6955   "keywords":"",
6956   "ie_id":"csscalc",
6957   "chrome_id":"5765241438732288",
6958   "shown":true
6959 }
6960 },{}],61:[function(require,module,exports){
6961 module.exports={
6962   "title":"CSS3 Animation",
6963   "description":"Complex method of animating certain properties of an element",
6964   "spec":"http://www.w3.org/TR/css3-animations/",
6965   "status":"wd",
6966   "links":[
6967     {
6968       "url":"http://robertnyman.com/2010/05/06/css3-animations/",
6969       "title":"Blog post on usage"
6970     },
6971     {
6972       "url":"http://www.css3files.com/animation/",
6973       "title":"Information page"
6974     },
6975     {
6976       "url":"http://docs.webplatform.org/wiki/css/properties/animations",
6977       "title":"WebPlatform Docs"
6978     }
6979   ],
6980   "bugs":[
6981     {
6982       "description":"'animation-fill-mode' property is not supported in Android browser below 2.3."
6983     },
6984     {
6985       "description":"iOS 6.1 and below do not support animation on pseudo-elements."
6986     },
6987     {
6988       "description":"@keyframes not supported in an inline or scoped stylesheet in Firefox (bug 830056)"
6989     }
6990   ],
6991   "categories":[
6992     "CSS3"
6993   ],
6994   "stats":{
6995     "ie":{
6996       "5.5":"n",
6997       "6":"n",
6998       "7":"n",
6999       "8":"n",
7000       "9":"n",
7001       "10":"y",
7002       "11":"y",
7003       "TP":"y"
7004     },
7005     "firefox":{
7006       "2":"n",
7007       "3":"n",
7008       "3.5":"n",
7009       "3.6":"n",
7010       "4":"n",
7011       "5":"y x",
7012       "6":"y x",
7013       "7":"y x",
7014       "8":"y x",
7015       "9":"y x",
7016       "10":"y x",
7017       "11":"y x",
7018       "12":"y x",
7019       "13":"y x",
7020       "14":"y x",
7021       "15":"y x",
7022       "16":"y",
7023       "17":"y",
7024       "18":"y",
7025       "19":"y",
7026       "20":"y",
7027       "21":"y",
7028       "22":"y",
7029       "23":"y",
7030       "24":"y",
7031       "25":"y",
7032       "26":"y",
7033       "27":"y",
7034       "28":"y",
7035       "29":"y",
7036       "30":"y",
7037       "31":"y",
7038       "32":"y",
7039       "33":"y",
7040       "34":"y",
7041       "35":"y",
7042       "36":"y",
7043       "37":"y",
7044       "38":"y"
7045     },
7046     "chrome":{
7047       "4":"y x",
7048       "5":"y x",
7049       "6":"y x",
7050       "7":"y x",
7051       "8":"y x",
7052       "9":"y x",
7053       "10":"y x",
7054       "11":"y x",
7055       "12":"y x",
7056       "13":"y x",
7057       "14":"y x",
7058       "15":"y x",
7059       "16":"y x",
7060       "17":"y x",
7061       "18":"y x",
7062       "19":"y x",
7063       "20":"y x",
7064       "21":"y x",
7065       "22":"y x",
7066       "23":"y x",
7067       "24":"y x",
7068       "25":"y x",
7069       "26":"y x",
7070       "27":"y x",
7071       "28":"y x",
7072       "29":"y x",
7073       "30":"y x",
7074       "31":"y x",
7075       "32":"y x",
7076       "33":"y x",
7077       "34":"y x",
7078       "35":"y x",
7079       "36":"y x",
7080       "37":"y x",
7081       "38":"y x",
7082       "39":"y x",
7083       "40":"y x",
7084       "41":"y x",
7085       "42":"y x",
7086       "43":"y x"
7087     },
7088     "safari":{
7089       "3.1":"n",
7090       "3.2":"n",
7091       "4":"y x",
7092       "5":"y x",
7093       "5.1":"y x",
7094       "6":"y x",
7095       "6.1":"y x",
7096       "7":"y x",
7097       "7.1":"y x",
7098       "8":"y x"
7099     },
7100     "opera":{
7101       "9":"n",
7102       "9.5-9.6":"n",
7103       "10.0-10.1":"n",
7104       "10.5":"n",
7105       "10.6":"n",
7106       "11":"n",
7107       "11.1":"n",
7108       "11.5":"n",
7109       "11.6":"n",
7110       "12":"y x",
7111       "12.1":"y",
7112       "15":"y x",
7113       "16":"y x",
7114       "17":"y x",
7115       "18":"y x",
7116       "19":"y x",
7117       "20":"y x",
7118       "21":"y x",
7119       "22":"y x",
7120       "23":"y x",
7121       "24":"y x",
7122       "25":"y x",
7123       "26":"y x",
7124       "27":"y x",
7125       "28":"y x",
7126       "29":"y x"
7127     },
7128     "ios_saf":{
7129       "3.2":"y x",
7130       "4.0-4.1":"y x",
7131       "4.2-4.3":"y x",
7132       "5.0-5.1":"y x",
7133       "6.0-6.1":"y x",
7134       "7.0-7.1":"y x",
7135       "8":"y x",
7136       "8.1":"y x"
7137     },
7138     "op_mini":{
7139       "5.0-8.0":"n"
7140     },
7141     "android":{
7142       "2.1":"a x",
7143       "2.2":"a x",
7144       "2.3":"a x",
7145       "3":"a x",
7146       "4":"y x",
7147       "4.1":"y x",
7148       "4.2-4.3":"y x",
7149       "4.4":"y x",
7150       "4.4.3-4.4.4":"y x",
7151       "37":"y x"
7152     },
7153     "bb":{
7154       "7":"y x",
7155       "10":"y x"
7156     },
7157     "op_mob":{
7158       "10":"n",
7159       "11":"n",
7160       "11.1":"n",
7161       "11.5":"n",
7162       "12":"n",
7163       "12.1":"y",
7164       "24":"y x"
7165     },
7166     "and_chr":{
7167       "40":"y x"
7168     },
7169     "and_ff":{
7170       "33":"y"
7171     },
7172     "ie_mob":{
7173       "10":"y",
7174       "11":"y"
7175     },
7176     "and_uc":{
7177       "9.9":"y x"
7178     }
7179   },
7180   "notes":"Partial support in Android browser refers to buggy behavior in different scenarios.",
7181   "notes_by_num":{
7182
7183   },
7184   "usage_perc_y":87.15,
7185   "usage_perc_a":0.15,
7186   "ucprefix":false,
7187   "parent":"",
7188   "keywords":"animations,css-animations,keyframe,keyframes",
7189   "ie_id":"",
7190   "chrome_id":"",
7191   "shown":true
7192 }
7193 },{}],62:[function(require,module,exports){
7194 module.exports={
7195   "title":"CSS box-decoration-break",
7196   "description":"Controls whether the box's margins, borders, padding, and other decorations wrap the broken edges of the box fragments (when the box is split by a break (page/column/region/line).",
7197   "spec":"http://www.w3.org/TR/css3-break/#break-decoration",
7198   "status":"wd",
7199   "links":[
7200     {
7201       "url":"https://developer.mozilla.org/en-US/docs/Web/CSS/box-decoration-break",
7202       "title":"MDN article"
7203     },
7204     {
7205       "url":"http://jsbin.com/xojoro/edit?css,output",
7206       "title":"Demo of effect on box border"
7207     }
7208   ],
7209   "bugs":[
7210
7211   ],
7212   "categories":[
7213     "CSS3"
7214   ],
7215   "stats":{
7216     "ie":{
7217       "5.5":"n",
7218       "6":"n",
7219       "7":"n",
7220       "8":"n",
7221       "9":"n",
7222       "10":"n",
7223       "11":"n",
7224       "TP":"n"
7225     },
7226     "firefox":{
7227       "2":"n",
7228       "3":"n",
7229       "3.5":"n",
7230       "3.6":"n",
7231       "4":"n",
7232       "5":"n",
7233       "6":"n",
7234       "7":"n",
7235       "8":"n",
7236       "9":"n",
7237       "10":"n",
7238       "11":"n",
7239       "12":"n",
7240       "13":"n",
7241       "14":"n",
7242       "15":"n",
7243       "16":"n",
7244       "17":"n",
7245       "18":"n",
7246       "19":"n",
7247       "20":"n",
7248       "21":"n",
7249       "22":"n",
7250       "23":"n",
7251       "24":"n",
7252       "25":"n",
7253       "26":"n",
7254       "27":"n",
7255       "28":"n",
7256       "29":"n",
7257       "30":"n",
7258       "31":"n",
7259       "32":"y",
7260       "33":"y",
7261       "34":"y",
7262       "35":"y",
7263       "36":"y",
7264       "37":"y",
7265       "38":"y"
7266     },
7267     "chrome":{
7268       "4":"n",
7269       "5":"n",
7270       "6":"n",
7271       "7":"n",
7272       "8":"n",
7273       "9":"n",
7274       "10":"n",
7275       "11":"n",
7276       "12":"n",
7277       "13":"n",
7278       "14":"n",
7279       "15":"n",
7280       "16":"n",
7281       "17":"n",
7282       "18":"n",
7283       "19":"n",
7284       "20":"n",
7285       "21":"n",
7286       "22":"y x",
7287       "23":"y x",
7288       "24":"y x",
7289       "25":"y x",
7290       "26":"y x",
7291       "27":"y x",
7292       "28":"y x",
7293       "29":"y x",
7294       "30":"y x",
7295       "31":"y x",
7296       "32":"y x",
7297       "33":"y x",
7298       "34":"y x",
7299       "35":"y x",
7300       "36":"y x",
7301       "37":"y x",
7302       "38":"y x",
7303       "39":"y x",
7304       "40":"y x",
7305       "41":"y x",
7306       "42":"y x",
7307       "43":"y x"
7308     },
7309     "safari":{
7310       "3.1":"n",
7311       "3.2":"n",
7312       "4":"n",
7313       "5":"n",
7314       "5.1":"n",
7315       "6":"n",
7316       "6.1":"y x",
7317       "7":"y x",
7318       "7.1":"y x",
7319       "8":"y x"
7320     },
7321     "opera":{
7322       "9":"u",
7323       "9.5-9.6":"u",
7324       "10.0-10.1":"u",
7325       "10.5":"u",
7326       "10.6":"u",
7327       "11":"y",
7328       "11.1":"y",
7329       "11.5":"y",
7330       "11.6":"y",
7331       "12":"y",
7332       "12.1":"y",
7333       "15":"y x",
7334       "16":"y x",
7335       "17":"y x",
7336       "18":"y x",
7337       "19":"y x",
7338       "20":"y x",
7339       "21":"y x",
7340       "22":"y x",
7341       "23":"y x",
7342       "24":"y x",
7343       "25":"y x",
7344       "26":"y x",
7345       "27":"y x",
7346       "28":"y x",
7347       "29":"y x"
7348     },
7349     "ios_saf":{
7350       "3.2":"n",
7351       "4.0-4.1":"n",
7352       "4.2-4.3":"n",
7353       "5.0-5.1":"n",
7354       "6.0-6.1":"n",
7355       "7.0-7.1":"y x",
7356       "8":"y x",
7357       "8.1":"y x"
7358     },
7359     "op_mini":{
7360       "5.0-8.0":"y"
7361     },
7362     "android":{
7363       "2.1":"n",
7364       "2.2":"n",
7365       "2.3":"n",
7366       "3":"n",
7367       "4":"n",
7368       "4.1":"n",
7369       "4.2-4.3":"n",
7370       "4.4":"y x",
7371       "4.4.3-4.4.4":"y x",
7372       "37":"y x"
7373     },
7374     "bb":{
7375       "7":"u",
7376       "10":"y x"
7377     },
7378     "op_mob":{
7379       "10":"u",
7380       "11":"y",
7381       "11.1":"y",
7382       "11.5":"y",
7383       "12":"y",
7384       "12.1":"y",
7385       "24":"y x"
7386     },
7387     "and_chr":{
7388       "40":"y x"
7389     },
7390     "and_ff":{
7391       "33":"y"
7392     },
7393     "ie_mob":{
7394       "10":"n",
7395       "11":"n"
7396     },
7397     "and_uc":{
7398       "9.9":"n"
7399     }
7400   },
7401   "notes":"",
7402   "notes_by_num":{
7403
7404   },
7405   "usage_perc_y":69.86,
7406   "usage_perc_a":0,
7407   "ucprefix":false,
7408   "parent":"",
7409   "keywords":"box-decoration,box decoration,break",
7410   "ie_id":"",
7411   "chrome_id":"",
7412   "shown":true
7413 }
7414 },{}],63:[function(require,module,exports){
7415 module.exports={
7416   "title":"CSS3 Box-shadow",
7417   "description":"Method of displaying an inner or outer shadow effect to elements",
7418   "spec":"http://www.w3.org/TR/css3-background/#box-shadow",
7419   "status":"cr",
7420   "links":[
7421     {
7422       "url":"https://developer.mozilla.org/En/CSS/-moz-box-shadow",
7423       "title":"MDN article"
7424     },
7425     {
7426       "url":"http://westciv.com/tools/boxshadows/index.html",
7427       "title":"Live editor"
7428     },
7429     {
7430       "url":"http://tests.themasta.com/blogstuff/boxshadowdemo.html",
7431       "title":"Demo of various effects"
7432     },
7433     {
7434       "url":"http://www.css3files.com/shadow/",
7435       "title":"Information page"
7436     },
7437     {
7438       "url":"http://docs.webplatform.org/wiki/css/properties/box-shadow",
7439       "title":"WebPlatform Docs"
7440     }
7441   ],
7442   "bugs":[
7443     {
7444       "description":"Safari 6, iOS 6 and Android 2.3 default browser don't work with a 0px value for \"blur-radius\".\r\ne.g. `-webkit-box-shadow: 5px 1px 0px 1px #f04e29;`\r\ndoesn't work, but\r\n`-webkit-box-shadow: 5px 1px 1px 1px #f04e29`\r\ndoes."
7445     }
7446   ],
7447   "categories":[
7448     "CSS3"
7449   ],
7450   "stats":{
7451     "ie":{
7452       "5.5":"n",
7453       "6":"n",
7454       "7":"n",
7455       "8":"n",
7456       "9":"y",
7457       "10":"y",
7458       "11":"y",
7459       "TP":"y"
7460     },
7461     "firefox":{
7462       "2":"n",
7463       "3":"n",
7464       "3.5":"y x",
7465       "3.6":"y x",
7466       "4":"y",
7467       "5":"y",
7468       "6":"y",
7469       "7":"y",
7470       "8":"y",
7471       "9":"y",
7472       "10":"y",
7473       "11":"y",
7474       "12":"y",
7475       "13":"y",
7476       "14":"y",
7477       "15":"y",
7478       "16":"y",
7479       "17":"y",
7480       "18":"y",
7481       "19":"y",
7482       "20":"y",
7483       "21":"y",
7484       "22":"y",
7485       "23":"y",
7486       "24":"y",
7487       "25":"y",
7488       "26":"y",
7489       "27":"y",
7490       "28":"y",
7491       "29":"y",
7492       "30":"y",
7493       "31":"y",
7494       "32":"y",
7495       "33":"y",
7496       "34":"y",
7497       "35":"y",
7498       "36":"y",
7499       "37":"y",
7500       "38":"y"
7501     },
7502     "chrome":{
7503       "4":"y x",
7504       "5":"y x",
7505       "6":"y x",
7506       "7":"y x",
7507       "8":"y x",
7508       "9":"y x",
7509       "10":"y",
7510       "11":"y",
7511       "12":"y",
7512       "13":"y",
7513       "14":"y",
7514       "15":"y",
7515       "16":"y",
7516       "17":"y",
7517       "18":"y",
7518       "19":"y",
7519       "20":"y",
7520       "21":"y",
7521       "22":"y",
7522       "23":"y",
7523       "24":"y",
7524       "25":"y",
7525       "26":"y",
7526       "27":"y",
7527       "28":"y",
7528       "29":"y",
7529       "30":"y",
7530       "31":"y",
7531       "32":"y",
7532       "33":"y",
7533       "34":"y",
7534       "35":"y",
7535       "36":"y",
7536       "37":"y",
7537       "38":"y",
7538       "39":"y",
7539       "40":"y",
7540       "41":"y",
7541       "42":"y",
7542       "43":"y"
7543     },
7544     "safari":{
7545       "3.1":"a x",
7546       "3.2":"a x",
7547       "4":"a x",
7548       "5":"y x",
7549       "5.1":"y",
7550       "6":"y",
7551       "6.1":"y",
7552       "7":"y",
7553       "7.1":"y",
7554       "8":"y"
7555     },
7556     "opera":{
7557       "9":"n",
7558       "9.5-9.6":"n",
7559       "10.0-10.1":"n",
7560       "10.5":"y",
7561       "10.6":"y",
7562       "11":"y",
7563       "11.1":"y",
7564       "11.5":"y",
7565       "11.6":"y",
7566       "12":"y",
7567       "12.1":"y",
7568       "15":"y",
7569       "16":"y",
7570       "17":"y",
7571       "18":"y",
7572       "19":"y",
7573       "20":"y",
7574       "21":"y",
7575       "22":"y",
7576       "23":"y",
7577       "24":"y",
7578       "25":"y",
7579       "26":"y",
7580       "27":"y",
7581       "28":"y",
7582       "29":"y"
7583     },
7584     "ios_saf":{
7585       "3.2":"a x",
7586       "4.0-4.1":"y x",
7587       "4.2-4.3":"y x",
7588       "5.0-5.1":"y",
7589       "6.0-6.1":"y",
7590       "7.0-7.1":"y",
7591       "8":"y",
7592       "8.1":"y"
7593     },
7594     "op_mini":{
7595       "5.0-8.0":"n"
7596     },
7597     "android":{
7598       "2.1":"a x",
7599       "2.2":"a x",
7600       "2.3":"a x",
7601       "3":"a x",
7602       "4":"y",
7603       "4.1":"y",
7604       "4.2-4.3":"y",
7605       "4.4":"y",
7606       "4.4.3-4.4.4":"y",
7607       "37":"y"
7608     },
7609     "bb":{
7610       "7":"y x",
7611       "10":"y"
7612     },
7613     "op_mob":{
7614       "10":"n",
7615       "11":"y",
7616       "11.1":"y",
7617       "11.5":"y",
7618       "12":"y",
7619       "12.1":"y",
7620       "24":"y"
7621     },
7622     "and_chr":{
7623       "40":"y"
7624     },
7625     "and_ff":{
7626       "33":"y"
7627     },
7628     "ie_mob":{
7629       "10":"y",
7630       "11":"y"
7631     },
7632     "and_uc":{
7633       "9.9":"y"
7634     }
7635   },
7636   "notes":"Can be partially emulated in older IE versions using the non-standard \"shadow\" filter. Partial support in Safari, iOS Safari and Android Browser refers to missing \"inset\" and blur radius value support.",
7637   "notes_by_num":{
7638
7639   },
7640   "usage_perc_y":89.42,
7641   "usage_perc_a":0.22,
7642   "ucprefix":false,
7643   "parent":"",
7644   "keywords":"box-shadows,boxshadows,box shadow,shaow",
7645   "ie_id":"",
7646   "chrome_id":"",
7647   "shown":true
7648 }
7649 },{}],64:[function(require,module,exports){
7650 module.exports={
7651   "title":"Crisp Edges Image Rendering Algorithm",
7652   "description":"Forces images to be scaled with an algorithm that preserves contrast and edges in the image, and which does not smooth colors or introduce blur to the image in the process. This is intended for images such as pixel art.",
7653   "spec":"http://dev.w3.org/csswg/css-images-3/#valdef-image-rendering-crisp-edges",
7654   "status":"unoff",
7655   "links":[
7656     {
7657       "url":"https://developer.mozilla.org/en-US/docs/Web/CSS/image-rendering",
7658       "title":"MDN article"
7659     }
7660   ],
7661   "bugs":[
7662
7663   ],
7664   "categories":[
7665     "CSS",
7666     "CSS3"
7667   ],
7668   "stats":{
7669     "ie":{
7670       "5.5":"n",
7671       "6":"n",
7672       "7":"n",
7673       "8":"n",
7674       "9":"n",
7675       "10":"n",
7676       "11":"n",
7677       "TP":"n"
7678     },
7679     "firefox":{
7680       "2":"n",
7681       "3":"n",
7682       "3.5":"n",
7683       "3.6":"y x",
7684       "4":"y x",
7685       "5":"y x",
7686       "6":"y x",
7687       "7":"y x",
7688       "8":"y x",
7689       "9":"y x",
7690       "10":"y x",
7691       "11":"y x",
7692       "12":"y x",
7693       "13":"y x",
7694       "14":"y x",
7695       "15":"y x",
7696       "16":"y x",
7697       "17":"y x",
7698       "18":"y x",
7699       "19":"y x",
7700       "20":"y x",
7701       "21":"y x",
7702       "22":"y x",
7703       "23":"y x",
7704       "24":"y x",
7705       "25":"y x",
7706       "26":"y x",
7707       "27":"y x",
7708       "28":"y x",
7709       "29":"y x",
7710       "30":"y x",
7711       "31":"y x",
7712       "32":"y x",
7713       "33":"y x",
7714       "34":"y x",
7715       "35":"y x",
7716       "36":"y x",
7717       "37":"y x",
7718       "38":"y x"
7719     },
7720     "chrome":{
7721       "4":"n",
7722       "5":"n",
7723       "6":"n",
7724       "7":"n",
7725       "8":"n",
7726       "9":"n",
7727       "10":"a x #1",
7728       "11":"a x #1",
7729       "12":"a x #1",
7730       "13":"a x #1",
7731       "14":"a x #1",
7732       "15":"a x #1",
7733       "16":"a x #1",
7734       "17":"a x #1",
7735       "18":"a x #1",
7736       "19":"a x #1",
7737       "20":"a x #1",
7738       "21":"a x #1",
7739       "22":"a x #1",
7740       "23":"a x #1",
7741       "24":"a x #1",
7742       "25":"a x #1",
7743       "26":"a x #1",
7744       "27":"a x #1",
7745       "28":"a x #1",
7746       "29":"a x #1",
7747       "30":"a x #1",
7748       "31":"a x #1",
7749       "32":"a x #1",
7750       "33":"a x #1",
7751       "34":"a x #1",
7752       "35":"a x #1",
7753       "36":"a x #1",
7754       "37":"a x #1",
7755       "38":"a x #1",
7756       "39":"a x #1",
7757       "40":"a x #1",
7758       "41":"a x #1",
7759       "42":"a x #1",
7760       "43":"a x #1"
7761     },
7762     "safari":{
7763       "3.1":"n",
7764       "3.2":"n",
7765       "4":"n",
7766       "5":"n",
7767       "5.1":"a x #1",
7768       "6":"a x #1",
7769       "6.1":"a x #1",
7770       "7":"a x #1",
7771       "7.1":"a x #1",
7772       "8":"a x #1"
7773     },
7774     "opera":{
7775       "9":"n",
7776       "9.5-9.6":"n",
7777       "10.0-10.1":"n",
7778       "10.5":"n",
7779       "10.6":"n",
7780       "11":"n",
7781       "11.1":"n",
7782       "11.5":"n",
7783       "11.6":"y x",
7784       "12":"y x",
7785       "12.1":"y x",
7786       "15":"a x #1",
7787       "16":"a x #1",
7788       "17":"a x #1",
7789       "18":"a x #1",
7790       "19":"a x #1",
7791       "20":"a x #1",
7792       "21":"a x #1",
7793       "22":"a x #1",
7794       "23":"a x #1",
7795       "24":"a x #1",
7796       "25":"a x #1",
7797       "26":"a x #1",
7798       "27":"a x #1",
7799       "28":"a x #1",
7800       "29":"a x #1"
7801     },
7802     "ios_saf":{
7803       "3.2":"n",
7804       "4.0-4.1":"n",
7805       "4.2-4.3":"n",
7806       "5.0-5.1":"a x #1",
7807       "6.0-6.1":"a x #1",
7808       "7.0-7.1":"a x #1",
7809       "8":"a x #1",
7810       "8.1":"a x #1"
7811     },
7812     "op_mini":{
7813       "5.0-8.0":"n"
7814     },
7815     "android":{
7816       "2.1":"n",
7817       "2.2":"n",
7818       "2.3":"n",
7819       "3":"n",
7820       "4":"n",
7821       "4.1":"u",
7822       "4.2-4.3":"u",
7823       "4.4":"u",
7824       "4.4.3-4.4.4":"u",
7825       "37":"a x #1"
7826     },
7827     "bb":{
7828       "7":"n",
7829       "10":"n"
7830     },
7831     "op_mob":{
7832       "10":"n",
7833       "11":"n",
7834       "11.1":"n",
7835       "11.5":"n",
7836       "12":"y x",
7837       "12.1":"y x",
7838       "24":"a x #1"
7839     },
7840     "and_chr":{
7841       "40":"a x #1"
7842     },
7843     "and_ff":{
7844       "33":"y x"
7845     },
7846     "ie_mob":{
7847       "10":"n",
7848       "11":"n"
7849     },
7850     "and_uc":{
7851       "9.9":"u"
7852     }
7853   },
7854   "notes":"",
7855   "notes_by_num":{
7856     "1":"Chrome, Safari and Opera use non-standard value `-webkit-optimize-contrasts` instead of `crisp-edges`"
7857   },
7858   "usage_perc_y":12.21,
7859   "usage_perc_a":53.95,
7860   "ucprefix":false,
7861   "parent":"",
7862   "keywords":"image-rendering,crisp-edges",
7863   "ie_id":"",
7864   "chrome_id":"",
7865   "shown":false
7866 }
7867 },{}],65:[function(require,module,exports){
7868 module.exports={
7869   "title":"CSS Device Adaptation",
7870   "description":"A standard way to override the size of viewport in web page, standardizing and replacing Apple's own popular <meta> viewport implementation.",
7871   "spec":"http://www.w3.org/TR/css-device-adapt/",
7872   "status":"wd",
7873   "links":[
7874     {
7875       "url":"https://dev.opera.com/articles/view/an-introduction-to-meta-viewport-and-viewport/",
7876       "title":"Introduction to meta viewport and @viewport in Opera Mobile"
7877     },
7878     {
7879       "url":"http://msdn.microsoft.com/en-us/library/ie/hh708740(v=vs.85).aspx",
7880       "title":"Device adaptation in Internet Explorer 10"
7881     }
7882   ],
7883   "bugs":[
7884
7885   ],
7886   "categories":[
7887     "CSS"
7888   ],
7889   "stats":{
7890     "ie":{
7891       "5.5":"n",
7892       "6":"n",
7893       "7":"n",
7894       "8":"n",
7895       "9":"n",
7896       "10":"a x #1",
7897       "11":"a x #1",
7898       "TP":"a x #1"
7899     },
7900     "firefox":{
7901       "2":"n",
7902       "3":"n",
7903       "3.5":"n",
7904       "3.6":"n",
7905       "4":"n",
7906       "5":"n",
7907       "6":"n",
7908       "7":"n",
7909       "8":"n",
7910       "9":"n",
7911       "10":"n",
7912       "11":"n",
7913       "12":"n",
7914       "13":"n",
7915       "14":"n",
7916       "15":"n",
7917       "16":"n",
7918       "17":"n",
7919       "18":"n",
7920       "19":"n",
7921       "20":"n",
7922       "21":"n",
7923       "22":"n",
7924       "23":"n",
7925       "24":"n",
7926       "25":"n",
7927       "26":"n",
7928       "27":"n",
7929       "28":"n",
7930       "29":"n",
7931       "30":"n",
7932       "31":"n",
7933       "32":"n",
7934       "33":"n",
7935       "34":"n",
7936       "35":"n",
7937       "36":"n",
7938       "37":"n",
7939       "38":"n"
7940     },
7941     "chrome":{
7942       "4":"n",
7943       "5":"n",
7944       "6":"n",
7945       "7":"n",
7946       "8":"n",
7947       "9":"n",
7948       "10":"n",
7949       "11":"n",
7950       "12":"n",
7951       "13":"n",
7952       "14":"n",
7953       "15":"n",
7954       "16":"n",
7955       "17":"n",
7956       "18":"n",
7957       "19":"n",
7958       "20":"n",
7959       "21":"n",
7960       "22":"n",
7961       "23":"n",
7962       "24":"n",
7963       "25":"n",
7964       "26":"n",
7965       "27":"n",
7966       "28":"n",
7967       "29":"n",
7968       "30":"n",
7969       "31":"n",
7970       "32":"n",
7971       "33":"n",
7972       "34":"n",
7973       "35":"n",
7974       "36":"n",
7975       "37":"n",
7976       "38":"n",
7977       "39":"n",
7978       "40":"n",
7979       "41":"n",
7980       "42":"n",
7981       "43":"n"
7982     },
7983     "safari":{
7984       "3.1":"n",
7985       "3.2":"n",
7986       "4":"n",
7987       "5":"n",
7988       "5.1":"n",
7989       "6":"n",
7990       "6.1":"u",
7991       "7":"u",
7992       "7.1":"u",
7993       "8":"u"
7994     },
7995     "opera":{
7996       "9":"n",
7997       "9.5-9.6":"n",
7998       "10.0-10.1":"n",
7999       "10.5":"n",
8000       "10.6":"n",
8001       "11":"n",
8002       "11.1":"n",
8003       "11.5":"n",
8004       "11.6":"n",
8005       "12":"n",
8006       "12.1":"n",
8007       "15":"n",
8008       "16":"n",
8009       "17":"n",
8010       "18":"n",
8011       "19":"n",
8012       "20":"n",
8013       "21":"n",
8014       "22":"n",
8015       "23":"n",
8016       "24":"n",
8017       "25":"n",
8018       "26":"n",
8019       "27":"n",
8020       "28":"n",
8021       "29":"n"
8022     },
8023     "ios_saf":{
8024       "3.2":"n",
8025       "4.0-4.1":"n",
8026       "4.2-4.3":"n",
8027       "5.0-5.1":"n",
8028       "6.0-6.1":"n",
8029       "7.0-7.1":"n",
8030       "8":"n",
8031       "8.1":"n"
8032     },
8033     "op_mini":{
8034       "5.0-8.0":"a x #2"
8035     },
8036     "android":{
8037       "2.1":"n",
8038       "2.2":"n",
8039       "2.3":"n",
8040       "3":"n",
8041       "4":"n",
8042       "4.1":"n",
8043       "4.2-4.3":"n",
8044       "4.4":"n",
8045       "4.4.3-4.4.4":"n",
8046       "37":"n"
8047     },
8048     "bb":{
8049       "7":"n",
8050       "10":"n"
8051     },
8052     "op_mob":{
8053       "10":"n",
8054       "11":"a x #2",
8055       "11.1":"a x #2",
8056       "11.5":"a x #2",
8057       "12":"a x #2",
8058       "12.1":"a x #2",
8059       "24":"n"
8060     },
8061     "and_chr":{
8062       "40":"n"
8063     },
8064     "and_ff":{
8065       "33":"n"
8066     },
8067     "ie_mob":{
8068       "10":"a x #1",
8069       "11":"a x #1"
8070     },
8071     "and_uc":{
8072       "9.9":"n"
8073     }
8074   },
8075   "notes":"",
8076   "notes_by_num":{
8077     "1":"IE only supports the 'width' and 'height' properties.",
8078     "2":"Opera Mobile and Opera Mini only support the 'orientation' property."
8079   },
8080   "usage_perc_y":0,
8081   "usage_perc_a":13.81,
8082   "ucprefix":false,
8083   "parent":"",
8084   "keywords":"viewport",
8085   "ie_id":"",
8086   "chrome_id":"",
8087   "shown":true
8088 }
8089 },{}],66:[function(require,module,exports){
8090 module.exports={
8091   "title":"CSS Filter Effects",
8092   "description":"Method of applying filter effects (like blur, grayscale, brightness, contrast and hue) to elements, previously only possible by using SVG.",
8093   "spec":"http://www.w3.org/TR/filter-effects/",
8094   "status":"wd",
8095   "links":[
8096     {
8097       "url":"http://html5-demos.appspot.com/static/css/filters/index.html",
8098       "title":"Demo file for WebKit browsers"
8099     },
8100     {
8101       "url":"http://www.html5rocks.com/en/tutorials/filters/understanding-css/",
8102       "title":"HTML5Rocks article"
8103     },
8104     {
8105       "url":"http://dl.dropbox.com/u/3260327/angular/CSS3ImageManipulation.html",
8106       "title":"Filter editor"
8107     },
8108     {
8109       "url":"http://bennettfeely.com/filters/",
8110       "title":"Filter Playground"
8111     }
8112   ],
8113   "bugs":[
8114
8115   ],
8116   "categories":[
8117     "CSS",
8118     "CSS3"
8119   ],
8120   "stats":{
8121     "ie":{
8122       "5.5":"n",
8123       "6":"n",
8124       "7":"n",
8125       "8":"n",
8126       "9":"n",
8127       "10":"n",
8128       "11":"n",
8129       "TP":"n"
8130     },
8131     "firefox":{
8132       "2":"n",
8133       "3":"n",
8134       "3.5":"n",
8135       "3.6":"a",
8136       "4":"a",
8137       "5":"a",
8138       "6":"a",
8139       "7":"a",
8140       "8":"a",
8141       "9":"a",
8142       "10":"a",
8143       "11":"a",
8144       "12":"a",
8145       "13":"a",
8146       "14":"a",
8147       "15":"a",
8148       "16":"a",
8149       "17":"a",
8150       "18":"a",
8151       "19":"a",
8152       "20":"a",
8153       "21":"a",
8154       "22":"a",
8155       "23":"a",
8156       "24":"a",
8157       "25":"a",
8158       "26":"a",
8159       "27":"a",
8160       "28":"a",
8161       "29":"a",
8162       "30":"a",
8163       "31":"a",
8164       "32":"a",
8165       "33":"a",
8166       "34":"a d #1",
8167       "35":"y",
8168       "36":"y",
8169       "37":"y",
8170       "38":"y"
8171     },
8172     "chrome":{
8173       "4":"n",
8174       "5":"n",
8175       "6":"n",
8176       "7":"n",
8177       "8":"n",
8178       "9":"n",
8179       "10":"n",
8180       "11":"n",
8181       "12":"n",
8182       "13":"n",
8183       "14":"n",
8184       "15":"n",
8185       "16":"n",
8186       "17":"n",
8187       "18":"y x",
8188       "19":"y x",
8189       "20":"y x",
8190       "21":"y x",
8191       "22":"y x",
8192       "23":"y x",
8193       "24":"y x",
8194       "25":"y x",
8195       "26":"y x",
8196       "27":"y x",
8197       "28":"y x",
8198       "29":"y x",
8199       "30":"y x",
8200       "31":"y x",
8201       "32":"y x",
8202       "33":"y x",
8203       "34":"y x",
8204       "35":"y x",
8205       "36":"y x",
8206       "37":"y x",
8207       "38":"y x",
8208       "39":"y x",
8209       "40":"y x",
8210       "41":"y x",
8211       "42":"y x",
8212       "43":"y x"
8213     },
8214     "safari":{
8215       "3.1":"n",
8216       "3.2":"n",
8217       "4":"n",
8218       "5":"n",
8219       "5.1":"n",
8220       "6":"y x",
8221       "6.1":"y x",
8222       "7":"y x",
8223       "7.1":"y x",
8224       "8":"y x"
8225     },
8226     "opera":{
8227       "9":"n",
8228       "9.5-9.6":"n",
8229       "10.0-10.1":"n",
8230       "10.5":"n",
8231       "10.6":"n",
8232       "11":"n",
8233       "11.1":"n",
8234       "11.5":"n",
8235       "11.6":"n",
8236       "12":"n",
8237       "12.1":"n",
8238       "15":"y x",
8239       "16":"y x",
8240       "17":"y x",
8241       "18":"y x",
8242       "19":"y x",
8243       "20":"y x",
8244       "21":"y x",
8245       "22":"y x",
8246       "23":"y x",
8247       "24":"y x",
8248       "25":"y x",
8249       "26":"y x",
8250       "27":"y x",
8251       "28":"y x",
8252       "29":"y x"
8253     },
8254     "ios_saf":{
8255       "3.2":"n",
8256       "4.0-4.1":"n",
8257       "4.2-4.3":"n",
8258       "5.0-5.1":"n",
8259       "6.0-6.1":"y x",
8260       "7.0-7.1":"y x",
8261       "8":"y x",
8262       "8.1":"y x"
8263     },
8264     "op_mini":{
8265       "5.0-8.0":"n"
8266     },
8267     "android":{
8268       "2.1":"n",
8269       "2.2":"n",
8270       "2.3":"n",
8271       "3":"n",
8272       "4":"n",
8273       "4.1":"n",
8274       "4.2-4.3":"n",
8275       "4.4":"y x",
8276       "4.4.3-4.4.4":"y x",
8277       "37":"y x"
8278     },
8279     "bb":{
8280       "7":"n",
8281       "10":"y x"
8282     },
8283     "op_mob":{
8284       "10":"n",
8285       "11":"n",
8286       "11.1":"n",
8287       "11.5":"n",
8288       "12":"n",
8289       "12.1":"n",
8290       "24":"y x"
8291     },
8292     "and_chr":{
8293       "40":"y x"
8294     },
8295     "and_ff":{
8296       "33":"a"
8297     },
8298     "ie_mob":{
8299       "10":"n",
8300       "11":"n"
8301     },
8302     "and_uc":{
8303       "9.9":"y x"
8304     }
8305   },
8306   "notes":"Note that this property is significantly different from and incompatible with Microsoft's [older \"filter\" property](http://msdn.microsoft.com/en-us/library/ie/ms530752%28v=vs.85%29.aspx).\r\n\r\nPartial support in Firefox before version 34 [only implemented the url() function of the filter property](https://developer.mozilla.org/en-US/docs/Web/CSS/filter#Browser_compatibility)",
8307   "notes_by_num":{
8308     "1":"Supported in Firefox under the `layout.css.filters.enabled` flag."
8309   },
8310   "usage_perc_y":60.79,
8311   "usage_perc_a":11.71,
8312   "ucprefix":false,
8313   "parent":"",
8314   "keywords":"sepia,hue-rotate,invert,saturate",
8315   "ie_id":"filters",
8316   "chrome_id":"",
8317   "shown":true
8318 }
8319 },{}],67:[function(require,module,exports){
8320 module.exports={
8321   "title":"CSS Gradients",
8322   "description":"Method of defining a linear or radial color gradient as a CSS image.",
8323   "spec":"http://www.w3.org/TR/css3-images/",
8324   "status":"cr",
8325   "links":[
8326     {
8327       "url":"http://www.colorzilla.com/gradient-editor/",
8328       "title":"Cross-browser editor"
8329     },
8330     {
8331       "url":"http://www.css3files.com/gradient/",
8332       "title":"Information page"
8333     },
8334     {
8335       "url":"http://css3pie.com/",
8336       "title":"Tool to emulate support in IE"
8337     },
8338     {
8339       "url":"http://docs.webplatform.org/wiki/css/functions/linear-gradient",
8340       "title":"WebPlatform Docs"
8341     }
8342   ],
8343   "bugs":[
8344
8345   ],
8346   "categories":[
8347     "CSS3"
8348   ],
8349   "stats":{
8350     "ie":{
8351       "5.5":"n",
8352       "6":"n",
8353       "7":"n",
8354       "8":"n",
8355       "9":"n",
8356       "10":"y",
8357       "11":"y",
8358       "TP":"y"
8359     },
8360     "firefox":{
8361       "2":"n",
8362       "3":"n",
8363       "3.5":"n",
8364       "3.6":"y x",
8365       "4":"y x",
8366       "5":"y x",
8367       "6":"y x",
8368       "7":"y x",
8369       "8":"y x",
8370       "9":"y x",
8371       "10":"y x",
8372       "11":"y x",
8373       "12":"y x",
8374       "13":"y x",
8375       "14":"y x",
8376       "15":"y x",
8377       "16":"y",
8378       "17":"y",
8379       "18":"y",
8380       "19":"y",
8381       "20":"y",
8382       "21":"y",
8383       "22":"y",
8384       "23":"y",
8385       "24":"y",
8386       "25":"y",
8387       "26":"y",
8388       "27":"y",
8389       "28":"y",
8390       "29":"y",
8391       "30":"y",
8392       "31":"y",
8393       "32":"y",
8394       "33":"y",
8395       "34":"y",
8396       "35":"y",
8397       "36":"y",
8398       "37":"y",
8399       "38":"y"
8400     },
8401     "chrome":{
8402       "4":"a x",
8403       "5":"a x",
8404       "6":"a x",
8405       "7":"a x",
8406       "8":"a x",
8407       "9":"a x",
8408       "10":"y x",
8409       "11":"y x",
8410       "12":"y x",
8411       "13":"y x",
8412       "14":"y x",
8413       "15":"y x",
8414       "16":"y x",
8415       "17":"y x",
8416       "18":"y x",
8417       "19":"y x",
8418       "20":"y x",
8419       "21":"y x",
8420       "22":"y x",
8421       "23":"y x",
8422       "24":"y x",
8423       "25":"y x",
8424       "26":"y",
8425       "27":"y",
8426       "28":"y",
8427       "29":"y",
8428       "30":"y",
8429       "31":"y",
8430       "32":"y",
8431       "33":"y",
8432       "34":"y",
8433       "35":"y",
8434       "36":"y",
8435       "37":"y",
8436       "38":"y",
8437       "39":"y",
8438       "40":"y",
8439       "41":"y",
8440       "42":"y",
8441       "43":"y"
8442     },
8443     "safari":{
8444       "3.1":"n",
8445       "3.2":"n",
8446       "4":"a x",
8447       "5":"a x",
8448       "5.1":"y x",
8449       "6":"y x",
8450       "6.1":"y",
8451       "7":"y",
8452       "7.1":"y",
8453       "8":"y"
8454     },
8455     "opera":{
8456       "9":"n",
8457       "9.5-9.6":"n",
8458       "10.0-10.1":"n",
8459       "10.5":"n",
8460       "10.6":"n",
8461       "11":"n",
8462       "11.1":"a x",
8463       "11.5":"a x",
8464       "11.6":"y x",
8465       "12":"y x",
8466       "12.1":"y",
8467       "15":"y",
8468       "16":"y",
8469       "17":"y",
8470       "18":"y",
8471       "19":"y",
8472       "20":"y",
8473       "21":"y",
8474       "22":"y",
8475       "23":"y",
8476       "24":"y",
8477       "25":"y",
8478       "26":"y",
8479       "27":"y",
8480       "28":"y",
8481       "29":"y"
8482     },
8483     "ios_saf":{
8484       "3.2":"a x",
8485       "4.0-4.1":"a x",
8486       "4.2-4.3":"a x",
8487       "5.0-5.1":"y x",
8488       "6.0-6.1":"y x",
8489       "7.0-7.1":"y",
8490       "8":"y",
8491       "8.1":"y"
8492     },
8493     "op_mini":{
8494       "5.0-8.0":"n"
8495     },
8496     "android":{
8497       "2.1":"a x",
8498       "2.2":"a x",
8499       "2.3":"a x",
8500       "3":"a x",
8501       "4":"y x",
8502       "4.1":"y x",
8503       "4.2-4.3":"y x",
8504       "4.4":"y",
8505       "4.4.3-4.4.4":"y",
8506       "37":"y"
8507     },
8508     "bb":{
8509       "7":"a x",
8510       "10":"y x"
8511     },
8512     "op_mob":{
8513       "10":"n",
8514       "11":"n",
8515       "11.1":"a x",
8516       "11.5":"a x",
8517       "12":"y x",
8518       "12.1":"y",
8519       "24":"y"
8520     },
8521     "and_chr":{
8522       "40":"y"
8523     },
8524     "and_ff":{
8525       "33":"y"
8526     },
8527     "ie_mob":{
8528       "10":"y",
8529       "11":"y"
8530     },
8531     "and_uc":{
8532       "9.9":"y x"
8533     }
8534   },
8535   "notes":"Syntax used by browsers with prefixed support may be incompatible with that for proper support. \r\n\r\nPartial support in Opera 11.10 and 11.50 also refers to only having support for linear gradients.\r\n\r\nSupport can be somewhat emulated in older IE versions using the non-standard \"gradient\" filter. \r\n\r\nFirefox 10+, Opera 11.6+, Chrome 26+ and IE10+ also support the new \"to (side)\" syntax.",
8536   "notes_by_num":{
8537
8538   },
8539   "usage_perc_y":86.91,
8540   "usage_perc_a":0.54,
8541   "ucprefix":false,
8542   "parent":"",
8543   "keywords":"linear,linear-gradient,gradiant",
8544   "ie_id":"gradients",
8545   "chrome_id":"5785905063264256",
8546   "shown":true
8547 }
8548 },{}],68:[function(require,module,exports){
8549 module.exports={
8550   "title":"CSS Hyphenation",
8551   "description":"Method of controlling when words at the end of lines should be hyphenated using the \"hyphens\" property.",
8552   "spec":"http://www.w3.org/TR/css3-text/#hyphenation",
8553   "status":"wd",
8554   "links":[
8555     {
8556       "url":"https://developer.mozilla.org/en/CSS/hyphens",
8557       "title":"MDN article"
8558     },
8559     {
8560       "url":"http://blog.fontdeck.com/post/9037028497/hyphens",
8561       "title":"Blog post"
8562     },
8563     {
8564       "url":"http://docs.webplatform.org/wiki/css/properties/hyphens",
8565       "title":"WebPlatform Docs"
8566     }
8567   ],
8568   "bugs":[
8569
8570   ],
8571   "categories":[
8572     "CSS3"
8573   ],
8574   "stats":{
8575     "ie":{
8576       "5.5":"n",
8577       "6":"n",
8578       "7":"n",
8579       "8":"n",
8580       "9":"n",
8581       "10":"y x",
8582       "11":"y x",
8583       "TP":"y x"
8584     },
8585     "firefox":{
8586       "2":"n",
8587       "3":"n",
8588       "3.5":"n",
8589       "3.6":"n",
8590       "4":"n",
8591       "5":"n",
8592       "6":"y x",
8593       "7":"y x",
8594       "8":"y x",
8595       "9":"y x",
8596       "10":"y x",
8597       "11":"y x",
8598       "12":"y x",
8599       "13":"y x",
8600       "14":"y x",
8601       "15":"y x",
8602       "16":"y x",
8603       "17":"y x",
8604       "18":"y x",
8605       "19":"y x",
8606       "20":"y x",
8607       "21":"y x",
8608       "22":"y x",
8609       "23":"y x",
8610       "24":"y x",
8611       "25":"y x",
8612       "26":"y x",
8613       "27":"y x",
8614       "28":"y x",
8615       "29":"y x",
8616       "30":"y x",
8617       "31":"y x",
8618       "32":"y x",
8619       "33":"y x",
8620       "34":"y x",
8621       "35":"y x",
8622       "36":"y x",
8623       "37":"y x",
8624       "38":"y x"
8625     },
8626     "chrome":{
8627       "4":"n",
8628       "5":"n",
8629       "6":"n",
8630       "7":"n",
8631       "8":"n",
8632       "9":"n",
8633       "10":"n",
8634       "11":"n",
8635       "12":"n",
8636       "13":"n",
8637       "14":"n",
8638       "15":"n",
8639       "16":"n",
8640       "17":"n",
8641       "18":"n",
8642       "19":"n",
8643       "20":"n",
8644       "21":"n",
8645       "22":"n",
8646       "23":"n",
8647       "24":"n",
8648       "25":"n",
8649       "26":"n",
8650       "27":"n",
8651       "28":"n",
8652       "29":"n",
8653       "30":"n",
8654       "31":"n",
8655       "32":"n",
8656       "33":"n",
8657       "34":"n",
8658       "35":"n",
8659       "36":"n",
8660       "37":"n",
8661       "38":"n",
8662       "39":"n",
8663       "40":"n",
8664       "41":"n",
8665       "42":"n",
8666       "43":"n"
8667     },
8668     "safari":{
8669       "3.1":"n",
8670       "3.2":"n",
8671       "4":"n",
8672       "5":"n",
8673       "5.1":"y x",
8674       "6":"y x",
8675       "6.1":"y x",
8676       "7":"y x",
8677       "7.1":"y x",
8678       "8":"y x"
8679     },
8680     "opera":{
8681       "9":"n",
8682       "9.5-9.6":"n",
8683       "10.0-10.1":"n",
8684       "10.5":"n",
8685       "10.6":"n",
8686       "11":"n",
8687       "11.1":"n",
8688       "11.5":"n",
8689       "11.6":"n",
8690       "12":"n",
8691       "12.1":"n",
8692       "15":"n",
8693       "16":"n",
8694       "17":"n",
8695       "18":"n",
8696       "19":"n",
8697       "20":"n",
8698       "21":"n",
8699       "22":"n",
8700       "23":"n",
8701       "24":"n",
8702       "25":"n",
8703       "26":"n",
8704       "27":"n",
8705       "28":"n",
8706       "29":"n"
8707     },
8708     "ios_saf":{
8709       "3.2":"n",
8710       "4.0-4.1":"n",
8711       "4.2-4.3":"y x",
8712       "5.0-5.1":"y x",
8713       "6.0-6.1":"y x",
8714       "7.0-7.1":"y x",
8715       "8":"y x",
8716       "8.1":"y x"
8717     },
8718     "op_mini":{
8719       "5.0-8.0":"n"
8720     },
8721     "android":{
8722       "2.1":"n",
8723       "2.2":"n",
8724       "2.3":"n",
8725       "3":"n",
8726       "4":"n",
8727       "4.1":"n",
8728       "4.2-4.3":"n",
8729       "4.4":"n",
8730       "4.4.3-4.4.4":"n",
8731       "37":"n"
8732     },
8733     "bb":{
8734       "7":"n",
8735       "10":"n"
8736     },
8737     "op_mob":{
8738       "10":"n",
8739       "11":"n",
8740       "11.1":"n",
8741       "11.5":"n",
8742       "12":"n",
8743       "12.1":"n",
8744       "24":"n"
8745     },
8746     "and_chr":{
8747       "40":"n"
8748     },
8749     "and_ff":{
8750       "33":"y x"
8751     },
8752     "ie_mob":{
8753       "10":"n",
8754       "11":"n"
8755     },
8756     "and_uc":{
8757       "9.9":"a x"
8758     }
8759   },
8760   "notes":"Chrome 29- and Android 4.0 Browser support \"-webkit-hyphens: none\", but not the \"auto\" property. Chrome 30+ doesn't support it either.",
8761   "notes_by_num":{
8762
8763   },
8764   "usage_perc_y":32.28,
8765   "usage_perc_a":3.78,
8766   "ucprefix":false,
8767   "parent":"",
8768   "keywords":"hyphen,shy",
8769   "ie_id":"",
8770   "chrome_id":"",
8771   "shown":true
8772 }
8773 },{}],69:[function(require,module,exports){
8774 module.exports={
8775   "title":"CSS Logical Properties",
8776   "description":"Use start/end properties that depend on LTR or RTL writing direction instead of left/right",
8777   "spec":"http://dev.w3.org/csswg/css-logical-props/",
8778   "status":"wd",
8779   "links":[
8780     {
8781       "url":"https://developer.mozilla.org/en-US/docs/Web/CSS/-moz-margin-start",
8782       "title":"MDN -moz-margin-start"
8783     },
8784     {
8785       "url":"https://developer.mozilla.org/en-US/docs/Web/CSS/-moz-padding-start",
8786       "title":"MDN -moz-padding-start"
8787     }
8788   ],
8789   "bugs":[
8790
8791   ],
8792   "categories":[
8793     "CSS",
8794     "CSS3"
8795   ],
8796   "stats":{
8797     "ie":{
8798       "5.5":"n",
8799       "6":"n",
8800       "7":"n",
8801       "8":"n",
8802       "9":"n",
8803       "10":"n",
8804       "11":"n",
8805       "TP":"n"
8806     },
8807     "firefox":{
8808       "2":"n",
8809       "3":"a x #1",
8810       "3.5":"a x #1",
8811       "3.6":"a x #1",
8812       "4":"a x #1",
8813       "5":"a x #1",
8814       "6":"a x #1",
8815       "7":"a x #1",
8816       "8":"a x #1",
8817       "9":"a x #1",
8818       "10":"a x #1",
8819       "11":"a x #1",
8820       "12":"a x #1",
8821       "13":"a x #1",
8822       "14":"a x #1",
8823       "15":"a x #1",
8824       "16":"a x #1",
8825       "17":"a x #1",
8826       "18":"a x #1",
8827       "19":"a x #1",
8828       "20":"a x #1",
8829       "21":"a x #1",
8830       "22":"a x #1",
8831       "23":"a x #1",
8832       "24":"a x #1",
8833       "25":"a x #1",
8834       "26":"a x #1",
8835       "27":"a x #1",
8836       "28":"a x #1",
8837       "29":"a x #1",
8838       "30":"a x #1",
8839       "31":"a x #1",
8840       "32":"a x #1",
8841       "33":"a x #1",
8842       "34":"a x #1",
8843       "35":"a x #1",
8844       "36":"a x #1",
8845       "37":"a x #1",
8846       "38":"a x #1"
8847     },
8848     "chrome":{
8849       "4":"a x #1",
8850       "5":"a x #1",
8851       "6":"a x #1",
8852       "7":"a x #1",
8853       "8":"a x #1",
8854       "9":"a x #1",
8855       "10":"a x #1",
8856       "11":"a x #1",
8857       "12":"a x #1",
8858       "13":"a x #1",
8859       "14":"a x #1",
8860       "15":"a x #1",
8861       "16":"a x #1",
8862       "17":"a x #1",
8863       "18":"a x #1",
8864       "19":"a x #1",
8865       "20":"a x #1",
8866       "21":"a x #1",
8867       "22":"a x #1",
8868       "23":"a x #1",
8869       "24":"a x #1",
8870       "25":"a x #1",
8871       "26":"a x #1",
8872       "27":"a x #1",
8873       "28":"a x #1",
8874       "29":"a x #1",
8875       "30":"a x #1",
8876       "31":"a x #1",
8877       "32":"a x #1",
8878       "33":"a x #1",
8879       "34":"a x #1",
8880       "35":"a x #1",
8881       "36":"a x #1",
8882       "37":"a x #1",
8883       "38":"a x #1",
8884       "39":"a x #1",
8885       "40":"a x #1",
8886       "41":"a x #1",
8887       "42":"a x #1",
8888       "43":"a x #1"
8889     },
8890     "safari":{
8891       "3.1":"a x #1",
8892       "3.2":"a x #1",
8893       "4":"a x #1",
8894       "5":"a x #1",
8895       "5.1":"a x #1",
8896       "6":"a x #1",
8897       "6.1":"a x #1",
8898       "7":"a x #1",
8899       "7.1":"a x #1",
8900       "8":"a x #1"
8901     },
8902     "opera":{
8903       "9":"n",
8904       "9.5-9.6":"n",
8905       "10.0-10.1":"n",
8906       "10.5":"n",
8907       "10.6":"n",
8908       "11":"n",
8909       "11.1":"n",
8910       "11.5":"n",
8911       "11.6":"n",
8912       "12":"n",
8913       "12.1":"n",
8914       "15":"a x #1",
8915       "16":"a x #1",
8916       "17":"a x #1",
8917       "18":"a x #1",
8918       "19":"a x #1",
8919       "20":"a x #1",
8920       "21":"a x #1",
8921       "22":"a x #1",
8922       "23":"a x #1",
8923       "24":"a x #1",
8924       "25":"a x #1",
8925       "26":"a x #1",
8926       "27":"a x #1",
8927       "28":"a x #1",
8928       "29":"a x #1"
8929     },
8930     "ios_saf":{
8931       "3.2":"a x #1",
8932       "4.0-4.1":"a x #1",
8933       "4.2-4.3":"a x #1",
8934       "5.0-5.1":"a x #1",
8935       "6.0-6.1":"a x #1",
8936       "7.0-7.1":"a x #1",
8937       "8":"a x #1",
8938       "8.1":"a x #1"
8939     },
8940     "op_mini":{
8941       "5.0-8.0":"n"
8942     },
8943     "android":{
8944       "2.1":"u",
8945       "2.2":"u",
8946       "2.3":"u",
8947       "3":"u",
8948       "4":"u",
8949       "4.1":"u",
8950       "4.2-4.3":"u",
8951       "4.4":"u",
8952       "4.4.3-4.4.4":"u",
8953       "37":"a x #1"
8954     },
8955     "bb":{
8956       "7":"u",
8957       "10":"u"
8958     },
8959     "op_mob":{
8960       "10":"n",
8961       "11":"n",
8962       "11.1":"n",
8963       "11.5":"n",
8964       "12":"n",
8965       "12.1":"n",
8966       "24":"a x #1"
8967     },
8968     "and_chr":{
8969       "40":"a x #1"
8970     },
8971     "and_ff":{
8972       "33":"a x #1"
8973     },
8974     "ie_mob":{
8975       "10":"n",
8976       "11":"n"
8977     },
8978     "and_uc":{
8979       "9.9":"u"
8980     }
8981   },
8982   "notes":"",
8983   "notes_by_num":{
8984     "1":"Supports only margin-start, margin-end, padding-start and padding-end"
8985   },
8986   "usage_perc_y":0,
8987   "usage_perc_a":66.24,
8988   "ucprefix":false,
8989   "parent":"",
8990   "keywords":"margin,padding,start,end,left,,right",
8991   "ie_id":"",
8992   "chrome_id":"",
8993   "shown":false
8994 }
8995 },{}],70:[function(require,module,exports){
8996 module.exports={
8997   "title":"CSS Masks",
8998   "description":"Method of displaying part of an element, using a selected image as a mask",
8999   "spec":"http://www.w3.org/TR/css-masking/",
9000   "status":"cr",
9001   "links":[
9002     {
9003       "url":"http://docs.webplatform.org/wiki/css/properties/mask",
9004       "title":"WebPlatform Docs"
9005     },
9006     {
9007       "url":"http://www.html5rocks.com/en/tutorials/masking/adobe/",
9008       "title":"HTML5 Rocks article"
9009     },
9010     {
9011       "url":"http://thenittygritty.co/css-masking",
9012       "title":"Detailed blog post"
9013     }
9014   ],
9015   "bugs":[
9016
9017   ],
9018   "categories":[
9019     "CSS"
9020   ],
9021   "stats":{
9022     "ie":{
9023       "5.5":"n",
9024       "6":"n",
9025       "7":"n",
9026       "8":"n",
9027       "9":"n",
9028       "10":"n",
9029       "11":"n",
9030       "TP":"n"
9031     },
9032     "firefox":{
9033       "2":"n",
9034       "3":"n",
9035       "3.5":"a",
9036       "3.6":"a",
9037       "4":"a",
9038       "5":"a",
9039       "6":"a",
9040       "7":"a",
9041       "8":"a",
9042       "9":"a",
9043       "10":"a",
9044       "11":"a",
9045       "12":"a",
9046       "13":"a",
9047       "14":"a",
9048       "15":"a",
9049       "16":"a",
9050       "17":"a",
9051       "18":"a",
9052       "19":"a",
9053       "20":"a",
9054       "21":"a",
9055       "22":"a",
9056       "23":"a",
9057       "24":"a",
9058       "25":"a",
9059       "26":"a",
9060       "27":"a",
9061       "28":"a",
9062       "29":"a",
9063       "30":"a",
9064       "31":"a",
9065       "32":"a",
9066       "33":"a",
9067       "34":"a",
9068       "35":"a",
9069       "36":"a",
9070       "37":"a",
9071       "38":"a"
9072     },
9073     "chrome":{
9074       "4":"a x",
9075       "5":"a x",
9076       "6":"a x",
9077       "7":"a x",
9078       "8":"a x",
9079       "9":"a x",
9080       "10":"a x",
9081       "11":"a x",
9082       "12":"a x",
9083       "13":"a x",
9084       "14":"a x",
9085       "15":"a x",
9086       "16":"a x",
9087       "17":"a x",
9088       "18":"a x",
9089       "19":"a x",
9090       "20":"a x",
9091       "21":"a x",
9092       "22":"a x",
9093       "23":"a x",
9094       "24":"a x",
9095       "25":"a x",
9096       "26":"a x",
9097       "27":"a x",
9098       "28":"a x",
9099       "29":"a x",
9100       "30":"a x",
9101       "31":"a x",
9102       "32":"a x",
9103       "33":"a x",
9104       "34":"a x",
9105       "35":"a x",
9106       "36":"a x",
9107       "37":"a x",
9108       "38":"a x",
9109       "39":"a x",
9110       "40":"a x",
9111       "41":"a x",
9112       "42":"a x",
9113       "43":"a x"
9114     },
9115     "safari":{
9116       "3.1":"n",
9117       "3.2":"n",
9118       "4":"a x",
9119       "5":"a x",
9120       "5.1":"a x",
9121       "6":"a x",
9122       "6.1":"a x",
9123       "7":"a x",
9124       "7.1":"a x",
9125       "8":"a x"
9126     },
9127     "opera":{
9128       "9":"n",
9129       "9.5-9.6":"n",
9130       "10.0-10.1":"n",
9131       "10.5":"n",
9132       "10.6":"n",
9133       "11":"n",
9134       "11.1":"n",
9135       "11.5":"n",
9136       "11.6":"n",
9137       "12":"n",
9138       "12.1":"n",
9139       "15":"a x",
9140       "16":"a x",
9141       "17":"a x",
9142       "18":"a x",
9143       "19":"a x",
9144       "20":"a x",
9145       "21":"a x",
9146       "22":"a x",
9147       "23":"a x",
9148       "24":"a x",
9149       "25":"a x",
9150       "26":"a x",
9151       "27":"a x",
9152       "28":"a x",
9153       "29":"a x"
9154     },
9155     "ios_saf":{
9156       "3.2":"a x",
9157       "4.0-4.1":"a x",
9158       "4.2-4.3":"a x",
9159       "5.0-5.1":"a x",
9160       "6.0-6.1":"a x",
9161       "7.0-7.1":"a x",
9162       "8":"a x",
9163       "8.1":"a x"
9164     },
9165     "op_mini":{
9166       "5.0-8.0":"n"
9167     },
9168     "android":{
9169       "2.1":"a x",
9170       "2.2":"a x",
9171       "2.3":"a x",
9172       "3":"a x",
9173       "4":"a x",
9174       "4.1":"a x",
9175       "4.2-4.3":"a x",
9176       "4.4":"a x",
9177       "4.4.3-4.4.4":"a x",
9178       "37":"a x"
9179     },
9180     "bb":{
9181       "7":"a x",
9182       "10":"a x"
9183     },
9184     "op_mob":{
9185       "10":"n",
9186       "11":"n",
9187       "11.1":"n",
9188       "11.5":"n",
9189       "12":"n",
9190       "12.1":"n",
9191       "24":"a x"
9192     },
9193     "and_chr":{
9194       "40":"a x"
9195     },
9196     "and_ff":{
9197       "33":"a"
9198     },
9199     "ie_mob":{
9200       "10":"n",
9201       "11":"n"
9202     },
9203     "and_uc":{
9204       "9.9":"a x"
9205     }
9206   },
9207   "notes":"Partial support in WebKit/Blink browsers refers to supporting the mask-image and mask-box-image properties, but lacks support for other parts of the spec. Partial support in Firefox refers to only support for inline SVG mask elements i.e. mask: url(#foo).",
9208   "notes_by_num":{
9209
9210   },
9211   "usage_perc_y":0,
9212   "usage_perc_a":76.49,
9213   "ucprefix":false,
9214   "parent":"",
9215   "keywords":"",
9216   "ie_id":"masks",
9217   "chrome_id":"5381559662149632",
9218   "shown":true
9219 }
9220 },{}],71:[function(require,module,exports){
9221 module.exports={
9222   "title":"Media Queries: resolution feature",
9223   "description":"Allows a media query to be set based on the device pixels used per CSS unit. While the standard uses `min`/`max-resolution` for this, some browsers support the older non-standard `device-pixel-ratio` media query.",
9224   "spec":"http://www.w3.org/TR/css3-mediaqueries/#resolution",
9225   "status":"rec",
9226   "links":[
9227     {
9228       "url":"http://www.w3.org/blog/CSS/2012/06/14/unprefix-webkit-device-pixel-ratio/",
9229       "title":"How to unprefix -webkit-device-pixel-ratio"
9230     }
9231   ],
9232   "bugs":[
9233
9234   ],
9235   "categories":[
9236     "CSS",
9237     "CSS3"
9238   ],
9239   "stats":{
9240     "ie":{
9241       "5.5":"n",
9242       "6":"n",
9243       "7":"n",
9244       "8":"n",
9245       "9":"a #1",
9246       "10":"a #1",
9247       "11":"a #1",
9248       "TP":"a #2"
9249     },
9250     "firefox":{
9251       "2":"n",
9252       "3":"n",
9253       "3.5":"a #3",
9254       "3.6":"a #3",
9255       "4":"a #3",
9256       "5":"a #3",
9257       "6":"a #3",
9258       "7":"a #3",
9259       "8":"a #3",
9260       "9":"a #3",
9261       "10":"a #3",
9262       "11":"a #3",
9263       "12":"a #3",
9264       "13":"a #3",
9265       "14":"a #3",
9266       "15":"a #3",
9267       "16":"y",
9268       "17":"y",
9269       "18":"y",
9270       "19":"y",
9271       "20":"y",
9272       "21":"y",
9273       "22":"y",
9274       "23":"y",
9275       "24":"y",
9276       "25":"y",
9277       "26":"y",
9278       "27":"y",
9279       "28":"y",
9280       "29":"y",
9281       "30":"y",
9282       "31":"y",
9283       "32":"y",
9284       "33":"y",
9285       "34":"y",
9286       "35":"y",
9287       "36":"y",
9288       "37":"y",
9289       "38":"y"
9290     },
9291     "chrome":{
9292       "4":"a x #4",
9293       "5":"a x #4",
9294       "6":"a x #4",
9295       "7":"a x #4",
9296       "8":"a x #4",
9297       "9":"a x #4",
9298       "10":"a x #4",
9299       "11":"a x #4",
9300       "12":"a x #4",
9301       "13":"a x #4",
9302       "14":"a x #4",
9303       "15":"a x #4",
9304       "16":"a x #4",
9305       "17":"a x #4",
9306       "18":"a x #4",
9307       "19":"a x #4",
9308       "20":"a x #4",
9309       "21":"a x #4",
9310       "22":"a x #4",
9311       "23":"a x #4",
9312       "24":"a x #4",
9313       "25":"a x #4",
9314       "26":"a x #4",
9315       "27":"a x #4",
9316       "28":"a x #4",
9317       "29":"y",
9318       "30":"y",
9319       "31":"y",
9320       "32":"y",
9321       "33":"y",
9322       "34":"y",
9323       "35":"y",
9324       "36":"y",
9325       "37":"y",
9326       "38":"y",
9327       "39":"y",
9328       "40":"y",
9329       "41":"y",
9330       "42":"y",
9331       "43":"y"
9332     },
9333     "safari":{
9334       "3.1":"n",
9335       "3.2":"n",
9336       "4":"a x #4",
9337       "5":"a x #4",
9338       "5.1":"a x #4",
9339       "6":"a x #4",
9340       "6.1":"a x #4",
9341       "7":"a x #4",
9342       "7.1":"a x #4",
9343       "8":"a x #4"
9344     },
9345     "opera":{
9346       "9":"n",
9347       "9.5-9.6":"a x #4",
9348       "10.0-10.1":"a x #4",
9349       "10.5":"a x #4",
9350       "10.6":"a x #4",
9351       "11":"a x #4",
9352       "11.1":"a x #4",
9353       "11.5":"a x #4",
9354       "11.6":"a x #4",
9355       "12":"a x #4",
9356       "12.1":"y",
9357       "15":"y",
9358       "16":"y",
9359       "17":"y",
9360       "18":"y",
9361       "19":"y",
9362       "20":"y",
9363       "21":"y",
9364       "22":"y",
9365       "23":"y",
9366       "24":"y",
9367       "25":"y",
9368       "26":"y",
9369       "27":"y",
9370       "28":"y",
9371       "29":"y"
9372     },
9373     "ios_saf":{
9374       "3.2":"u",
9375       "4.0-4.1":"a x #4",
9376       "4.2-4.3":"a x #4",
9377       "5.0-5.1":"a x #4",
9378       "6.0-6.1":"a x #4",
9379       "7.0-7.1":"a x #4",
9380       "8":"a x #4",
9381       "8.1":"a x #4"
9382     },
9383     "op_mini":{
9384       "5.0-8.0":"a #1"
9385     },
9386     "android":{
9387       "2.1":"u",
9388       "2.2":"u",
9389       "2.3":"u",
9390       "3":"u",
9391       "4":"a x #4",
9392       "4.1":"a x #4",
9393       "4.2-4.3":"a x #4",
9394       "4.4":"y",
9395       "4.4.3-4.4.4":"y",
9396       "37":"y"
9397     },
9398     "bb":{
9399       "7":"a x #4",
9400       "10":"a x #4"
9401     },
9402     "op_mob":{
9403       "10":"u",
9404       "11":"u",
9405       "11.1":"u",
9406       "11.5":"u",
9407       "12":"u",
9408       "12.1":"y",
9409       "24":"y"
9410     },
9411     "and_chr":{
9412       "40":"y"
9413     },
9414     "and_ff":{
9415       "33":"y"
9416     },
9417     "ie_mob":{
9418       "10":"a #1",
9419       "11":"a #1"
9420     },
9421     "and_uc":{
9422       "9.9":"a x #4"
9423     }
9424   },
9425   "notes":"",
9426   "notes_by_num":{
9427     "1":"Supports the `dpi` unit, but does not support `dppx` or `dpcm` units.",
9428     "2":"Supports the `dpi` and `dppx` units, but does not support `dpcm` units.",
9429     "3":"Firefox before 16 supports only `dpi` unit, but you can set `2dppx` per `min--moz-device-pixel-ratio: 2`",
9430     "4":"Supporte the non-standard `min`/`max-device-pixel-ratio`"
9431   },
9432   "usage_perc_y":57.96,
9433   "usage_perc_a":34.61,
9434   "ucprefix":false,
9435   "parent":"css-mediaqueries",
9436   "keywords":"@media,device-pixel-ratio,resolution",
9437   "ie_id":"mediaqueriesresolutionfeature,dppxunitfortheresolutionmediaquery",
9438   "chrome_id":"5944509615570944",
9439   "shown":true
9440 }
9441 },{}],72:[function(require,module,exports){
9442 module.exports={
9443   "title":":placeholder-shown CSS pseudo-class",
9444   "description":"The :placeholder-shown pseudo-class represents the placeholder contents of a form field with placeholder text.",
9445   "spec":"http://dev.w3.org/csswg/selectors/#placeholder",
9446   "status":"unoff",
9447   "links":[
9448     {
9449       "url":"http://msdn.microsoft.com/en-us/library/ie/hh772745(v=vs.85).aspx",
9450       "title":"MSDN article"
9451     },
9452     {
9453       "url":"http://css-tricks.com/snippets/css/style-placeholder-text/",
9454       "title":"CSS-Tricks article with all prefixes"
9455     },
9456     {
9457       "url":"http://wiki.csswg.org/ideas/placeholder-styling",
9458       "title":"CSSWG discussion"
9459     }
9460   ],
9461   "bugs":[
9462
9463   ],
9464   "categories":[
9465     "CSS"
9466   ],
9467   "stats":{
9468     "ie":{
9469       "5.5":"n",
9470       "6":"n",
9471       "7":"n",
9472       "8":"n",
9473       "9":"n",
9474       "10":"a x",
9475       "11":"a x",
9476       "TP":"a x"
9477     },
9478     "firefox":{
9479       "2":"n",
9480       "3":"n",
9481       "3.5":"n",
9482       "3.6":"n",
9483       "4":"a x",
9484       "5":"a x",
9485       "6":"a x",
9486       "7":"a x",
9487       "8":"a x",
9488       "9":"a x",
9489       "10":"a x",
9490       "11":"a x",
9491       "12":"a x",
9492       "13":"a x",
9493       "14":"a x",
9494       "15":"a x",
9495       "16":"a x",
9496       "17":"a x",
9497       "18":"a x",
9498       "19":"a x",
9499       "20":"a x",
9500       "21":"a x",
9501       "22":"a x",
9502       "23":"a x",
9503       "24":"a x",
9504       "25":"a x",
9505       "26":"a x",
9506       "27":"a x",
9507       "28":"a x",
9508       "29":"a x",
9509       "30":"a x",
9510       "31":"a x",
9511       "32":"a x",
9512       "33":"a x",
9513       "34":"a x",
9514       "35":"a x",
9515       "36":"a x",
9516       "37":"a x",
9517       "38":"a x"
9518     },
9519     "chrome":{
9520       "4":"a x",
9521       "5":"a x",
9522       "6":"a x",
9523       "7":"a x",
9524       "8":"a x",
9525       "9":"a x",
9526       "10":"a x",
9527       "11":"a x",
9528       "12":"a x",
9529       "13":"a x",
9530       "14":"a x",
9531       "15":"a x",
9532       "16":"a x",
9533       "17":"a x",
9534       "18":"a x",
9535       "19":"a x",
9536       "20":"a x",
9537       "21":"a x",
9538       "22":"a x",
9539       "23":"a x",
9540       "24":"a x",
9541       "25":"a x",
9542       "26":"a x",
9543       "27":"a x",
9544       "28":"a x",
9545       "29":"a x",
9546       "30":"a x",
9547       "31":"a x",
9548       "32":"a x",
9549       "33":"a x",
9550       "34":"a x",
9551       "35":"a x",
9552       "36":"a x",
9553       "37":"a x",
9554       "38":"a x",
9555       "39":"a x",
9556       "40":"a x",
9557       "41":"a x",
9558       "42":"a x",
9559       "43":"a x"
9560     },
9561     "safari":{
9562       "3.1":"n",
9563       "3.2":"n",
9564       "4":"n",
9565       "5":"a x",
9566       "5.1":"a x",
9567       "6":"a x",
9568       "6.1":"a x",
9569       "7":"a x",
9570       "7.1":"a x",
9571       "8":"a x"
9572     },
9573     "opera":{
9574       "9":"n",
9575       "9.5-9.6":"n",
9576       "10.0-10.1":"n",
9577       "10.5":"n",
9578       "10.6":"n",
9579       "11":"n",
9580       "11.1":"n",
9581       "11.5":"n",
9582       "11.6":"n",
9583       "12":"n",
9584       "12.1":"n",
9585       "15":"a x",
9586       "16":"a x",
9587       "17":"a x",
9588       "18":"a x",
9589       "19":"a x",
9590       "20":"a x",
9591       "21":"a x",
9592       "22":"a x",
9593       "23":"a x",
9594       "24":"a x",
9595       "25":"a x",
9596       "26":"a x",
9597       "27":"a x",
9598       "28":"a x",
9599       "29":"a x"
9600     },
9601     "ios_saf":{
9602       "3.2":"n",
9603       "4.0-4.1":"n",
9604       "4.2-4.3":"a x",
9605       "5.0-5.1":"a x",
9606       "6.0-6.1":"a x",
9607       "7.0-7.1":"a x",
9608       "8":"a x",
9609       "8.1":"a x"
9610     },
9611     "op_mini":{
9612       "5.0-8.0":"n"
9613     },
9614     "android":{
9615       "2.1":"a x",
9616       "2.2":"a x",
9617       "2.3":"a x",
9618       "3":"a x",
9619       "4":"a x",
9620       "4.1":"a x",
9621       "4.2-4.3":"a x",
9622       "4.4":"a x",
9623       "4.4.3-4.4.4":"a x",
9624       "37":"a x"
9625     },
9626     "bb":{
9627       "7":"u",
9628       "10":"a x"
9629     },
9630     "op_mob":{
9631       "10":"n",
9632       "11":"n",
9633       "11.1":"n",
9634       "11.5":"n",
9635       "12":"n",
9636       "12.1":"n",
9637       "24":"a x"
9638     },
9639     "and_chr":{
9640       "40":"a x"
9641     },
9642     "and_ff":{
9643       "33":"a x"
9644     },
9645     "ie_mob":{
9646       "10":"a x",
9647       "11":"a x"
9648     },
9649     "and_uc":{
9650       "9.9":"a x"
9651     }
9652   },
9653   "notes":"Partial support refers to support for alternative syntax: ::-webkit-input-placeholder (Chrome/Safari/Opera),\r\n::-moz-placeholder (Firefox) and \r\n:-ms-input-placeholder (IE). ",
9654   "notes_by_num":{
9655
9656   },
9657   "usage_perc_y":0,
9658   "usage_perc_a":86.95,
9659   "ucprefix":false,
9660   "parent":"",
9661   "keywords":"::placeholder,placeholder",
9662   "ie_id":"",
9663   "chrome_id":"",
9664   "shown":true
9665 }
9666 },{}],73:[function(require,module,exports){
9667 module.exports={
9668   "title":"::selection CSS pseudo-element",
9669   "description":"The ::selection CSS pseudo-element applies rules to the portion of a document that has been highlighted (e.g., selected with the mouse or another pointing device) by the user.",
9670   "spec":"https://developer.mozilla.org/en-US/docs/Web/CSS/::selection",
9671   "status":"unoff",
9672   "links":[
9673     {
9674       "url":"http://quirksmode.org/css/selectors/selection.html",
9675       "title":"::selection test"
9676     },
9677     {
9678       "url":"http://docs.webplatform.org/wiki/css/selectors/pseudo-elements/::selection",
9679       "title":"WebPlatform Docs"
9680     }
9681   ],
9682   "bugs":[
9683
9684   ],
9685   "categories":[
9686     "CSS"
9687   ],
9688   "stats":{
9689     "ie":{
9690       "5.5":"n",
9691       "6":"n",
9692       "7":"n",
9693       "8":"n",
9694       "9":"y",
9695       "10":"y",
9696       "11":"y",
9697       "TP":"y"
9698     },
9699     "firefox":{
9700       "2":"y x",
9701       "3":"y x",
9702       "3.5":"y x",
9703       "3.6":"y x",
9704       "4":"y x",
9705       "5":"y x",
9706       "6":"y x",
9707       "7":"y x",
9708       "8":"y x",
9709       "9":"y x",
9710       "10":"y x",
9711       "11":"y x",
9712       "12":"y x",
9713       "13":"y x",
9714       "14":"y x",
9715       "15":"y x",
9716       "16":"y x",
9717       "17":"y x",
9718       "18":"y x",
9719       "19":"y x",
9720       "20":"y x",
9721       "21":"y x",
9722       "22":"y x",
9723       "23":"y x",
9724       "24":"y x",
9725       "25":"y x",
9726       "26":"y x",
9727       "27":"y x",
9728       "28":"y x",
9729       "29":"y x",
9730       "30":"y x",
9731       "31":"y x",
9732       "32":"y x",
9733       "33":"y x",
9734       "34":"y x",
9735       "35":"y x",
9736       "36":"y x",
9737       "37":"y x",
9738       "38":"y x"
9739     },
9740     "chrome":{
9741       "4":"y",
9742       "5":"y",
9743       "6":"y",
9744       "7":"y",
9745       "8":"y",
9746       "9":"y",
9747       "10":"y",
9748       "11":"y",
9749       "12":"y",
9750       "13":"y",
9751       "14":"y",
9752       "15":"y",
9753       "16":"y",
9754       "17":"y",
9755       "18":"y",
9756       "19":"y",
9757       "20":"y",
9758       "21":"y",
9759       "22":"y",
9760       "23":"y",
9761       "24":"y",
9762       "25":"y",
9763       "26":"y",
9764       "27":"y",
9765       "28":"y",
9766       "29":"y",
9767       "30":"y",
9768       "31":"y",
9769       "32":"y",
9770       "33":"y",
9771       "34":"y",
9772       "35":"y",
9773       "36":"y",
9774       "37":"y",
9775       "38":"y",
9776       "39":"y",
9777       "40":"y",
9778       "41":"y",
9779       "42":"y",
9780       "43":"y"
9781     },
9782     "safari":{
9783       "3.1":"y",
9784       "3.2":"y",
9785       "4":"y",
9786       "5":"y",
9787       "5.1":"y",
9788       "6":"y",
9789       "6.1":"y",
9790       "7":"y",
9791       "7.1":"y",
9792       "8":"y"
9793     },
9794     "opera":{
9795       "9":"n",
9796       "9.5-9.6":"y",
9797       "10.0-10.1":"y",
9798       "10.5":"y",
9799       "10.6":"y",
9800       "11":"y",
9801       "11.1":"y",
9802       "11.5":"y",
9803       "11.6":"y",
9804       "12":"y",
9805       "12.1":"y",
9806       "15":"y",
9807       "16":"y",
9808       "17":"y",
9809       "18":"y",
9810       "19":"y",
9811       "20":"y",
9812       "21":"y",
9813       "22":"y",
9814       "23":"y",
9815       "24":"y",
9816       "25":"y",
9817       "26":"y",
9818       "27":"y",
9819       "28":"y",
9820       "29":"y"
9821     },
9822     "ios_saf":{
9823       "3.2":"n",
9824       "4.0-4.1":"n",
9825       "4.2-4.3":"n",
9826       "5.0-5.1":"n",
9827       "6.0-6.1":"n",
9828       "7.0-7.1":"n",
9829       "8":"n",
9830       "8.1":"n"
9831     },
9832     "op_mini":{
9833       "5.0-8.0":"n"
9834     },
9835     "android":{
9836       "2.1":"n",
9837       "2.2":"n",
9838       "2.3":"n",
9839       "3":"n",
9840       "4":"n",
9841       "4.1":"n",
9842       "4.2-4.3":"n",
9843       "4.4":"y",
9844       "4.4.3-4.4.4":"y",
9845       "37":"y"
9846     },
9847     "bb":{
9848       "7":"n",
9849       "10":"n"
9850     },
9851     "op_mob":{
9852       "10":"u",
9853       "11":"u",
9854       "11.1":"u",
9855       "11.5":"y",
9856       "12":"y",
9857       "12.1":"y",
9858       "24":"y"
9859     },
9860     "and_chr":{
9861       "40":"y"
9862     },
9863     "and_ff":{
9864       "33":"y x"
9865     },
9866     "ie_mob":{
9867       "10":"y",
9868       "11":"y"
9869     },
9870     "and_uc":{
9871       "9.9":"n"
9872     }
9873   },
9874   "notes":"",
9875   "notes_by_num":{
9876
9877   },
9878   "usage_perc_y":75.25,
9879   "usage_perc_a":0,
9880   "ucprefix":false,
9881   "parent":"",
9882   "keywords":"::selection,selection",
9883   "ie_id":"",
9884   "chrome_id":"",
9885   "shown":true
9886 }
9887 },{}],74:[function(require,module,exports){
9888 module.exports={
9889   "title":"CSS Shapes Level 1",
9890   "description":"Allows geometric shapes to be set in CSS to define an area for text to flow around.",
9891   "spec":"http://www.w3.org/TR/css-shapes/",
9892   "status":"cr",
9893   "links":[
9894     {
9895       "url":"http://html.adobe.com/webplatform/layout/shapes/",
9896       "title":"Adobe demos and samples"
9897     },
9898     {
9899       "url":"http://html.adobe.com/webplatform/layout/shapes/browser-support/",
9900       "title":"CSS shapes support test by Adobe"
9901     },
9902     {
9903       "url":"http://alistapart.com/article/css-shapes-101",
9904       "title":"A List Apart article"
9905     }
9906   ],
9907   "bugs":[
9908
9909   ],
9910   "categories":[
9911     "CSS3"
9912   ],
9913   "stats":{
9914     "ie":{
9915       "5.5":"n",
9916       "6":"n",
9917       "7":"n",
9918       "8":"n",
9919       "9":"n",
9920       "10":"n",
9921       "11":"n",
9922       "TP":"n"
9923     },
9924     "firefox":{
9925       "2":"n",
9926       "3":"n",
9927       "3.5":"n",
9928       "3.6":"n",
9929       "4":"n",
9930       "5":"n",
9931       "6":"n",
9932       "7":"n",
9933       "8":"n",
9934       "9":"n",
9935       "10":"n",
9936       "11":"n",
9937       "12":"n",
9938       "13":"n",
9939       "14":"n",
9940       "15":"n",
9941       "16":"n",
9942       "17":"n",
9943       "18":"n",
9944       "19":"n",
9945       "20":"n",
9946       "21":"n",
9947       "22":"n",
9948       "23":"n",
9949       "24":"n",
9950       "25":"n",
9951       "26":"n",
9952       "27":"n",
9953       "28":"n",
9954       "29":"n",
9955       "30":"n",
9956       "31":"n",
9957       "32":"n",
9958       "33":"n",
9959       "34":"n",
9960       "35":"n",
9961       "36":"n",
9962       "37":"n",
9963       "38":"n"
9964     },
9965     "chrome":{
9966       "4":"n",
9967       "5":"n",
9968       "6":"n",
9969       "7":"n",
9970       "8":"n",
9971       "9":"n",
9972       "10":"n",
9973       "11":"n",
9974       "12":"n",
9975       "13":"n",
9976       "14":"n",
9977       "15":"n",
9978       "16":"n",
9979       "17":"n",
9980       "18":"n",
9981       "19":"n",
9982       "20":"n",
9983       "21":"n",
9984       "22":"n",
9985       "23":"n",
9986       "24":"n",
9987       "25":"n",
9988       "26":"n",
9989       "27":"n",
9990       "28":"n",
9991       "29":"n",
9992       "30":"n",
9993       "31":"n",
9994       "32":"n",
9995       "33":"n",
9996       "34":"n d #1",
9997       "35":"n d #1",
9998       "36":"n d #1",
9999       "37":"y",
10000       "38":"y",
10001       "39":"y",
10002       "40":"y",
10003       "41":"y",
10004       "42":"y",
10005       "43":"y"
10006     },
10007     "safari":{
10008       "3.1":"n",
10009       "3.2":"n",
10010       "4":"n",
10011       "5":"n",
10012       "5.1":"n",
10013       "6":"n",
10014       "6.1":"n",
10015       "7":"n",
10016       "7.1":"y x",
10017       "8":"y x"
10018     },
10019     "opera":{
10020       "9":"n",
10021       "9.5-9.6":"n",
10022       "10.0-10.1":"n",
10023       "10.5":"n",
10024       "10.6":"n",
10025       "11":"n",
10026       "11.1":"n",
10027       "11.5":"n",
10028       "11.6":"n",
10029       "12":"n",
10030       "12.1":"n",
10031       "15":"n",
10032       "16":"n",
10033       "17":"n",
10034       "18":"n",
10035       "19":"n",
10036       "20":"n",
10037       "21":"n",
10038       "22":"n",
10039       "23":"n",
10040       "24":"y",
10041       "25":"y",
10042       "26":"y",
10043       "27":"y",
10044       "28":"y",
10045       "29":"y"
10046     },
10047     "ios_saf":{
10048       "3.2":"n",
10049       "4.0-4.1":"n",
10050       "4.2-4.3":"n",
10051       "5.0-5.1":"n",
10052       "6.0-6.1":"n",
10053       "7.0-7.1":"n",
10054       "8":"y x",
10055       "8.1":"y x"
10056     },
10057     "op_mini":{
10058       "5.0-8.0":"n"
10059     },
10060     "android":{
10061       "2.1":"n",
10062       "2.2":"n",
10063       "2.3":"n",
10064       "3":"n",
10065       "4":"n",
10066       "4.1":"n",
10067       "4.2-4.3":"n",
10068       "4.4":"n",
10069       "4.4.3-4.4.4":"n",
10070       "37":"y"
10071     },
10072     "bb":{
10073       "7":"n",
10074       "10":"n"
10075     },
10076     "op_mob":{
10077       "10":"n",
10078       "11":"n",
10079       "11.1":"n",
10080       "11.5":"n",
10081       "12":"n",
10082       "12.1":"n",
10083       "24":"y"
10084     },
10085     "and_chr":{
10086       "40":"y"
10087     },
10088     "and_ff":{
10089       "33":"n"
10090     },
10091     "ie_mob":{
10092       "10":"n",
10093       "11":"n"
10094     },
10095     "and_uc":{
10096       "9.9":"n"
10097     }
10098   },
10099   "notes":"",
10100   "notes_by_num":{
10101     "1":"Enabled in Chrome through the \"experimental Web Platform features\" flag in chrome://flags"
10102   },
10103   "usage_perc_y":46.02,
10104   "usage_perc_a":0,
10105   "ucprefix":false,
10106   "parent":"",
10107   "keywords":"circle,ellipse,polygon,inset,shape-outside,shape-inside",
10108   "ie_id":"shapes",
10109   "chrome_id":"5163890719588352",
10110   "shown":true
10111 }
10112 },{}],75:[function(require,module,exports){
10113 module.exports={
10114   "title":"CSS position:sticky",
10115   "description":"Keeps elements positioned as \"fixed\" or \"relative\" depending on how it appears in the viewport. As a result the element is \"stuck\" when necessary while scrolling.",
10116   "spec":"http://dev.w3.org/csswg/css-position/#sticky-positioning",
10117   "status":"unoff",
10118   "links":[
10119     {
10120       "url":"http://updates.html5rocks.com/2012/08/Stick-your-landings-position-sticky-lands-in-WebKit",
10121       "title":"HTML5Rocks"
10122     },
10123     {
10124       "url":"https://developer.mozilla.org/en-US/docs/Web/CSS/position",
10125       "title":"MDN article"
10126     },
10127     {
10128       "url":"http://docs.webplatform.org/wiki/css/properties/position",
10129       "title":"WebPlatform Docs"
10130     },
10131     {
10132       "url":"https://github.com/filamentgroup/fixed-sticky",
10133       "title":"Polyfill"
10134     },
10135     {
10136       "url":"https://github.com/wilddeer/stickyfill",
10137       "title":"Another polyfill"
10138     }
10139   ],
10140   "bugs":[
10141     {
10142       "description":"Firefox and Safari do not appear to support [sticky table headers](http://jsfiddle.net/Mf4YT/2/). (see also [Firefox bug](https://bugzilla.mozilla.org/show_bug.cgi?id=975644))"
10143     }
10144   ],
10145   "categories":[
10146     "CSS"
10147   ],
10148   "stats":{
10149     "ie":{
10150       "5.5":"n",
10151       "6":"n",
10152       "7":"n",
10153       "8":"n",
10154       "9":"n",
10155       "10":"n",
10156       "11":"n",
10157       "TP":"n"
10158     },
10159     "firefox":{
10160       "2":"n",
10161       "3":"n",
10162       "3.5":"n",
10163       "3.6":"n",
10164       "4":"n",
10165       "5":"n",
10166       "6":"n",
10167       "7":"n",
10168       "8":"n",
10169       "9":"n",
10170       "10":"n",
10171       "11":"n",
10172       "12":"n",
10173       "13":"n",
10174       "14":"n",
10175       "15":"n",
10176       "16":"n",
10177       "17":"n",
10178       "18":"n",
10179       "19":"n",
10180       "20":"n",
10181       "21":"n",
10182       "22":"n",
10183       "23":"n",
10184       "24":"n",
10185       "25":"n",
10186       "26":"n d #1",
10187       "27":"n d #1",
10188       "28":"n d #1",
10189       "29":"n d #1",
10190       "30":"n d #1",
10191       "31":"n d #1",
10192       "32":"y",
10193       "33":"y",
10194       "34":"y",
10195       "35":"y",
10196       "36":"y",
10197       "37":"y",
10198       "38":"y"
10199     },
10200     "chrome":{
10201       "4":"n",
10202       "5":"n",
10203       "6":"n",
10204       "7":"n",
10205       "8":"n",
10206       "9":"n",
10207       "10":"n",
10208       "11":"n",
10209       "12":"n",
10210       "13":"n",
10211       "14":"n",
10212       "15":"n",
10213       "16":"n",
10214       "17":"n",
10215       "18":"n",
10216       "19":"n",
10217       "20":"n",
10218       "21":"n",
10219       "22":"n",
10220       "23":"n d #2",
10221       "24":"n d #2",
10222       "25":"n d #2",
10223       "26":"n d #2",
10224       "27":"n d #2",
10225       "28":"n d #2",
10226       "29":"n d #2",
10227       "30":"n d #2",
10228       "31":"n d #2",
10229       "32":"n d #2",
10230       "33":"n d #2",
10231       "34":"n d #2",
10232       "35":"n d #2",
10233       "36":"n d #2",
10234       "37":"n",
10235       "38":"n",
10236       "39":"n",
10237       "40":"n",
10238       "41":"n",
10239       "42":"n",
10240       "43":"n"
10241     },
10242     "safari":{
10243       "3.1":"n",
10244       "3.2":"n",
10245       "4":"n",
10246       "5":"n",
10247       "5.1":"n",
10248       "6":"n",
10249       "6.1":"y x",
10250       "7":"y x",
10251       "7.1":"y x",
10252       "8":"y x"
10253     },
10254     "opera":{
10255       "9":"n",
10256       "9.5-9.6":"n",
10257       "10.0-10.1":"n",
10258       "10.5":"n",
10259       "10.6":"n",
10260       "11":"n",
10261       "11.1":"n",
10262       "11.5":"n",
10263       "11.6":"n",
10264       "12":"n",
10265       "12.1":"n",
10266       "15":"n",
10267       "16":"n",
10268       "17":"n",
10269       "18":"n",
10270       "19":"n",
10271       "20":"n",
10272       "21":"n",
10273       "22":"n",
10274       "23":"n",
10275       "24":"n",
10276       "25":"n",
10277       "26":"n",
10278       "27":"n",
10279       "28":"n",
10280       "29":"n"
10281     },
10282     "ios_saf":{
10283       "3.2":"n",
10284       "4.0-4.1":"n",
10285       "4.2-4.3":"n",
10286       "5.0-5.1":"n",
10287       "6.0-6.1":"y x",
10288       "7.0-7.1":"y x",
10289       "8":"y x",
10290       "8.1":"y x"
10291     },
10292     "op_mini":{
10293       "5.0-8.0":"n"
10294     },
10295     "android":{
10296       "2.1":"n",
10297       "2.2":"n",
10298       "2.3":"n",
10299       "3":"n",
10300       "4":"n",
10301       "4.1":"n",
10302       "4.2-4.3":"n",
10303       "4.4":"n",
10304       "4.4.3-4.4.4":"n",
10305       "37":"n"
10306     },
10307     "bb":{
10308       "7":"n",
10309       "10":"n"
10310     },
10311     "op_mob":{
10312       "10":"n",
10313       "11":"n",
10314       "11.1":"n",
10315       "11.5":"n",
10316       "12":"n",
10317       "12.1":"n",
10318       "24":"n"
10319     },
10320     "and_chr":{
10321       "40":"n"
10322     },
10323     "and_ff":{
10324       "33":"y"
10325     },
10326     "ie_mob":{
10327       "10":"n",
10328       "11":"n"
10329     },
10330     "and_uc":{
10331       "9.9":"n"
10332     }
10333   },
10334   "notes":"",
10335   "notes_by_num":{
10336     "1":"Can be enabled in Firefox by setting the about:config preference layout.css.sticky.enabled to true",
10337     "2":"Enabled in Chrome through the \"experimental Web Platform features\" flag in chrome://flags"
10338   },
10339   "usage_perc_y":20.09,
10340   "usage_perc_a":0,
10341   "ucprefix":false,
10342   "parent":"",
10343   "keywords":"",
10344   "ie_id":"positionsticky",
10345   "chrome_id":"6190250464378880",
10346   "shown":true
10347 }
10348 },{}],76:[function(require,module,exports){
10349 module.exports={
10350   "title":"CSS3 text-align-last",
10351   "description":"CSS property to describe how the last line of a block or a line right before a forced line break when `text-align` is `justify`.",
10352   "spec":"http://www.w3.org/TR/css3-text/#text-align-last-property",
10353   "status":"wd",
10354   "links":[
10355     {
10356       "url":"https://developer.mozilla.org/en-US/docs/Web/CSS/text-align-last",
10357       "title":"MDN text-align-last"
10358     },
10359     {
10360       "url":"http://blogs.adobe.com/webplatform/2014/02/25/improving-your-sites-visual-details-css3-text-align-last/",
10361       "title":"Adobe Web Platform Article"
10362     }
10363   ],
10364   "bugs":[
10365
10366   ],
10367   "categories":[
10368     "CSS3"
10369   ],
10370   "stats":{
10371     "ie":{
10372       "5.5":"a #1",
10373       "6":"a #1",
10374       "7":"a #1",
10375       "8":"a #1",
10376       "9":"a #1",
10377       "10":"a #1",
10378       "11":"a #1",
10379       "TP":"a #1"
10380     },
10381     "firefox":{
10382       "2":"n",
10383       "3":"n",
10384       "3.5":"n",
10385       "3.6":"n",
10386       "4":"n",
10387       "5":"n",
10388       "6":"n",
10389       "7":"n",
10390       "8":"n",
10391       "9":"n",
10392       "10":"n",
10393       "11":"n",
10394       "12":"y x",
10395       "13":"y x",
10396       "14":"y x",
10397       "15":"y x",
10398       "16":"y x",
10399       "17":"y x",
10400       "18":"y x",
10401       "19":"y x",
10402       "20":"y x",
10403       "21":"y x",
10404       "22":"y x",
10405       "23":"y x",
10406       "24":"y x",
10407       "25":"y x",
10408       "26":"y x",
10409       "27":"y x",
10410       "28":"y x",
10411       "29":"y x",
10412       "30":"y x",
10413       "31":"y x",
10414       "32":"y x",
10415       "33":"y x",
10416       "34":"y x",
10417       "35":"y x",
10418       "36":"y x",
10419       "37":"y x",
10420       "38":"y x"
10421     },
10422     "chrome":{
10423       "4":"n",
10424       "5":"n",
10425       "6":"n",
10426       "7":"n",
10427       "8":"n",
10428       "9":"n",
10429       "10":"n",
10430       "11":"n",
10431       "12":"n",
10432       "13":"n",
10433       "14":"n",
10434       "15":"n",
10435       "16":"n",
10436       "17":"n",
10437       "18":"n",
10438       "19":"n",
10439       "20":"n",
10440       "21":"n",
10441       "22":"n",
10442       "23":"n",
10443       "24":"n",
10444       "25":"n",
10445       "26":"n",
10446       "27":"n",
10447       "28":"n",
10448       "29":"n",
10449       "30":"n",
10450       "31":"n",
10451       "32":"n",
10452       "33":"n",
10453       "34":"n",
10454       "35":"n d #2",
10455       "36":"n d #2",
10456       "37":"n d #2",
10457       "38":"n d #2",
10458       "39":"n d #2",
10459       "40":"n d #2",
10460       "41":"n d #2",
10461       "42":"n d #2",
10462       "43":"n d #2"
10463     },
10464     "safari":{
10465       "3.1":"n",
10466       "3.2":"n",
10467       "4":"n",
10468       "5":"n",
10469       "5.1":"n",
10470       "6":"n",
10471       "6.1":"n",
10472       "7":"n",
10473       "7.1":"n",
10474       "8":"n"
10475     },
10476     "opera":{
10477       "9":"n",
10478       "9.5-9.6":"n",
10479       "10.0-10.1":"n",
10480       "10.5":"n",
10481       "10.6":"n",
10482       "11":"n",
10483       "11.1":"n",
10484       "11.5":"n",
10485       "11.6":"n",
10486       "12":"n",
10487       "12.1":"n",
10488       "15":"n",
10489       "16":"n",
10490       "17":"n",
10491       "18":"n",
10492       "19":"n",
10493       "20":"n",
10494       "21":"n",
10495       "22":"n d #3",
10496       "23":"n d #3",
10497       "24":"n d #3",
10498       "25":"n d #3",
10499       "26":"n d #3",
10500       "27":"n d #3",
10501       "28":"n d #3",
10502       "29":"n d #3"
10503     },
10504     "ios_saf":{
10505       "3.2":"n",
10506       "4.0-4.1":"n",
10507       "4.2-4.3":"n",
10508       "5.0-5.1":"n",
10509       "6.0-6.1":"n",
10510       "7.0-7.1":"n",
10511       "8":"n",
10512       "8.1":"n"
10513     },
10514     "op_mini":{
10515       "5.0-8.0":"n"
10516     },
10517     "android":{
10518       "2.1":"n",
10519       "2.2":"n",
10520       "2.3":"n",
10521       "3":"n",
10522       "4":"n",
10523       "4.1":"n",
10524       "4.2-4.3":"n",
10525       "4.4":"n",
10526       "4.4.3-4.4.4":"n",
10527       "37":"n"
10528     },
10529     "bb":{
10530       "7":"n",
10531       "10":"n"
10532     },
10533     "op_mob":{
10534       "10":"n",
10535       "11":"n",
10536       "11.1":"n",
10537       "11.5":"n",
10538       "12":"n",
10539       "12.1":"n",
10540       "24":"n"
10541     },
10542     "and_chr":{
10543       "40":"n"
10544     },
10545     "and_ff":{
10546       "33":"y x"
10547     },
10548     "ie_mob":{
10549       "10":"a #1",
10550       "11":"a #1"
10551     },
10552     "and_uc":{
10553       "9.9":"n"
10554     }
10555   },
10556   "notes":"",
10557   "notes_by_num":{
10558     "1":"In Internet Explorer, the start and end values are not supported.",
10559     "2":"Enabled through the \"Enable Experimental Web Platform Features\" flag in chrome://flags",
10560     "3":"Enabled through the \"Enable Experimental Web Platform Features\" flag in opera://flags"
10561   },
10562   "usage_perc_y":11.65,
10563   "usage_perc_a":17.19,
10564   "ucprefix":false,
10565   "parent":"",
10566   "keywords":"text align last",
10567   "ie_id":"",
10568   "chrome_id":"",
10569   "shown":true
10570 }
10571 },{}],77:[function(require,module,exports){
10572 module.exports={
10573   "title":"CSS3 Transitions",
10574   "description":"Simple method of animating certain properties of an element",
10575   "spec":"http://www.w3.org/TR/css3-transitions/",
10576   "status":"wd",
10577   "links":[
10578     {
10579       "url":"http://www.webdesignerdepot.com/2010/01/css-transitions-101/",
10580       "title":"Article on usage"
10581     },
10582     {
10583       "url":"http://www.css3files.com/transition/",
10584       "title":"Information page"
10585     },
10586     {
10587       "url":"http://www.the-art-of-web.com/css/timing-function/",
10588       "title":"Examples on timing functions"
10589     },
10590     {
10591       "url":"http://www.opera.com/docs/specs/presto2.12/css/transitions/",
10592       "title":"Animation of property types support in Opera"
10593     },
10594     {
10595       "url":"http://docs.webplatform.org/wiki/css/properties/transition",
10596       "title":"WebPlatform Docs"
10597     }
10598   ],
10599   "bugs":[
10600     {
10601       "description":"Not supported on any pseudo-elements besides ::before and ::after for Firefox, Chrome 26+, Opera 16+ and IE10+."
10602     },
10603     {
10604       "description":"Transitionable properties with calc() derived values are not supported below and including IE11 (http://connect.microsoft.com/IE/feedback/details/762719/css3-calc-bug-inside-transition-or-transform)"
10605     },
10606     {
10607       "description":"'background-size' is not supported below and including IE10"
10608     }
10609   ],
10610   "categories":[
10611     "CSS3"
10612   ],
10613   "stats":{
10614     "ie":{
10615       "5.5":"n",
10616       "6":"n",
10617       "7":"n",
10618       "8":"n",
10619       "9":"n",
10620       "10":"y",
10621       "11":"y",
10622       "TP":"y"
10623     },
10624     "firefox":{
10625       "2":"n",
10626       "3":"n",
10627       "3.5":"n",
10628       "3.6":"n",
10629       "4":"y x",
10630       "5":"y x",
10631       "6":"y x",
10632       "7":"y x",
10633       "8":"y x",
10634       "9":"y x",
10635       "10":"y x",
10636       "11":"y x",
10637       "12":"y x",
10638       "13":"y x",
10639       "14":"y x",
10640       "15":"y x",
10641       "16":"y",
10642       "17":"y",
10643       "18":"y",
10644       "19":"y",
10645       "20":"y",
10646       "21":"y",
10647       "22":"y",
10648       "23":"y",
10649       "24":"y",
10650       "25":"y",
10651       "26":"y",
10652       "27":"y",
10653       "28":"y",
10654       "29":"y",
10655       "30":"y",
10656       "31":"y",
10657       "32":"y",
10658       "33":"y",
10659       "34":"y",
10660       "35":"y",
10661       "36":"y",
10662       "37":"y",
10663       "38":"y"
10664     },
10665     "chrome":{
10666       "4":"y x",
10667       "5":"y x",
10668       "6":"y x",
10669       "7":"y x",
10670       "8":"y x",
10671       "9":"y x",
10672       "10":"y x",
10673       "11":"y x",
10674       "12":"y x",
10675       "13":"y x",
10676       "14":"y x",
10677       "15":"y x",
10678       "16":"y x",
10679       "17":"y x",
10680       "18":"y x",
10681       "19":"y x",
10682       "20":"y x",
10683       "21":"y x",
10684       "22":"y x",
10685       "23":"y x",
10686       "24":"y x",
10687       "25":"y x",
10688       "26":"y",
10689       "27":"y",
10690       "28":"y",
10691       "29":"y",
10692       "30":"y",
10693       "31":"y",
10694       "32":"y",
10695       "33":"y",
10696       "34":"y",
10697       "35":"y",
10698       "36":"y",
10699       "37":"y",
10700       "38":"y",
10701       "39":"y",
10702       "40":"y",
10703       "41":"y",
10704       "42":"y",
10705       "43":"y"
10706     },
10707     "safari":{
10708       "3.1":"y x",
10709       "3.2":"y x",
10710       "4":"y x",
10711       "5":"y x",
10712       "5.1":"y x",
10713       "6":"y x",
10714       "6.1":"y",
10715       "7":"y",
10716       "7.1":"y",
10717       "8":"y"
10718     },
10719     "opera":{
10720       "9":"n",
10721       "9.5-9.6":"n",
10722       "10.0-10.1":"n",
10723       "10.5":"y x",
10724       "10.6":"y x",
10725       "11":"y x",
10726       "11.1":"y x",
10727       "11.5":"y x",
10728       "11.6":"y x",
10729       "12":"y x",
10730       "12.1":"y",
10731       "15":"y",
10732       "16":"y",
10733       "17":"y",
10734       "18":"y",
10735       "19":"y",
10736       "20":"y",
10737       "21":"y",
10738       "22":"y",
10739       "23":"y",
10740       "24":"y",
10741       "25":"y",
10742       "26":"y",
10743       "27":"y",
10744       "28":"y",
10745       "29":"y"
10746     },
10747     "ios_saf":{
10748       "3.2":"y x",
10749       "4.0-4.1":"y x",
10750       "4.2-4.3":"y x",
10751       "5.0-5.1":"y x",
10752       "6.0-6.1":"y x",
10753       "7.0-7.1":"y",
10754       "8":"y",
10755       "8.1":"y"
10756     },
10757     "op_mini":{
10758       "5.0-8.0":"n"
10759     },
10760     "android":{
10761       "2.1":"y x",
10762       "2.2":"y x",
10763       "2.3":"y x",
10764       "3":"y x",
10765       "4":"y x",
10766       "4.1":"y x",
10767       "4.2-4.3":"y x",
10768       "4.4":"y",
10769       "4.4.3-4.4.4":"y",
10770       "37":"y"
10771     },
10772     "bb":{
10773       "7":"y x",
10774       "10":"y x"
10775     },
10776     "op_mob":{
10777       "10":"y x",
10778       "11":"y x",
10779       "11.1":"y x",
10780       "11.5":"y x",
10781       "12":"y x",
10782       "12.1":"y",
10783       "24":"y"
10784     },
10785     "and_chr":{
10786       "40":"y"
10787     },
10788     "and_ff":{
10789       "33":"y"
10790     },
10791     "ie_mob":{
10792       "10":"y",
10793       "11":"y"
10794     },
10795     "and_uc":{
10796       "9.9":"y x"
10797     }
10798   },
10799   "notes":"",
10800   "notes_by_num":{
10801
10802   },
10803   "usage_perc_y":87.4,
10804   "usage_perc_a":0,
10805   "ucprefix":false,
10806   "parent":"",
10807   "keywords":"css transition",
10808   "ie_id":"",
10809   "chrome_id":"",
10810   "shown":true
10811 }
10812 },{}],78:[function(require,module,exports){
10813 module.exports={
10814   "title":"CSS3 Box-sizing",
10815   "description":"Method of specifying whether or not an element's borders and padding should be included in size units",
10816   "spec":"http://www.w3.org/TR/css3-ui/#box-sizing",
10817   "status":"wd",
10818   "links":[
10819     {
10820       "url":"https://developer.mozilla.org/En/CSS/Box-sizing",
10821       "title":"MDN article"
10822     },
10823     {
10824       "url":"http://www.456bereastreet.com/archive/201104/controlling_width_with_css3_box-sizing/",
10825       "title":"Blog post"
10826     },
10827     {
10828       "url":"https://github.com/Schepp/box-sizing-polyfill",
10829       "title":"Polyfill for IE"
10830     },
10831     {
10832       "url":"http://css-tricks.com/box-sizing/",
10833       "title":"CSS Tricks"
10834     },
10835     {
10836       "url":"http://docs.webplatform.org/wiki/css/properties/box-sizing",
10837       "title":"WebPlatform Docs"
10838     }
10839   ],
10840   "bugs":[
10841     {
10842       "description":"Android browsers do not calculate correctly the dimensions (width and height) of the HTML select element."
10843     },
10844     {
10845       "description":"Safari 6.0.x does not use box-sizing on elements with display: table;"
10846     },
10847     {
10848       "description":"IE9 will subtract the width of the scrollbar to the width of the element when set to position: absolute, overflow: auto / overflow-y: scroll"
10849     },
10850     {
10851       "description":"IE 8 ignores `box-sizing: border-box` if min/max-width/height is used."
10852     }
10853   ],
10854   "categories":[
10855     "CSS3"
10856   ],
10857   "stats":{
10858     "ie":{
10859       "5.5":"p",
10860       "6":"p",
10861       "7":"p",
10862       "8":"a",
10863       "9":"a",
10864       "10":"a",
10865       "11":"a",
10866       "TP":"a"
10867     },
10868     "firefox":{
10869       "2":"y x",
10870       "3":"y x",
10871       "3.5":"y x",
10872       "3.6":"y x",
10873       "4":"y x",
10874       "5":"y x",
10875       "6":"y x",
10876       "7":"y x",
10877       "8":"y x",
10878       "9":"y x",
10879       "10":"y x",
10880       "11":"y x",
10881       "12":"y x",
10882       "13":"y x",
10883       "14":"y x",
10884       "15":"y x",
10885       "16":"y x",
10886       "17":"y x",
10887       "18":"y x",
10888       "19":"y x",
10889       "20":"y x",
10890       "21":"y x",
10891       "22":"y x",
10892       "23":"y x",
10893       "24":"y x",
10894       "25":"y x",
10895       "26":"y x",
10896       "27":"y x",
10897       "28":"y x",
10898       "29":"y",
10899       "30":"y",
10900       "31":"y",
10901       "32":"y",
10902       "33":"y",
10903       "34":"y",
10904       "35":"y",
10905       "36":"y",
10906       "37":"y",
10907       "38":"y"
10908     },
10909     "chrome":{
10910       "4":"a x",
10911       "5":"a x",
10912       "6":"a x",
10913       "7":"a x",
10914       "8":"a x",
10915       "9":"a x",
10916       "10":"a",
10917       "11":"a",
10918       "12":"a",
10919       "13":"a",
10920       "14":"a",
10921       "15":"a",
10922       "16":"a",
10923       "17":"a",
10924       "18":"a",
10925       "19":"a",
10926       "20":"a",
10927       "21":"a",
10928       "22":"a",
10929       "23":"a",
10930       "24":"a",
10931       "25":"a",
10932       "26":"a",
10933       "27":"a",
10934       "28":"a",
10935       "29":"a",
10936       "30":"a",
10937       "31":"a",
10938       "32":"a",
10939       "33":"a",
10940       "34":"a",
10941       "35":"a",
10942       "36":"a",
10943       "37":"a",
10944       "38":"a",
10945       "39":"a",
10946       "40":"a",
10947       "41":"a",
10948       "42":"a",
10949       "43":"a"
10950     },
10951     "safari":{
10952       "3.1":"a x",
10953       "3.2":"a x",
10954       "4":"a x",
10955       "5":"a x",
10956       "5.1":"a",
10957       "6":"a",
10958       "6.1":"a",
10959       "7":"a",
10960       "7.1":"a",
10961       "8":"a"
10962     },
10963     "opera":{
10964       "9":"n",
10965       "9.5-9.6":"a",
10966       "10.0-10.1":"a",
10967       "10.5":"a",
10968       "10.6":"a",
10969       "11":"a",
10970       "11.1":"a",
10971       "11.5":"a",
10972       "11.6":"a",
10973       "12":"a",
10974       "12.1":"a",
10975       "15":"a",
10976       "16":"a",
10977       "17":"a",
10978       "18":"a",
10979       "19":"a",
10980       "20":"a",
10981       "21":"a",
10982       "22":"a",
10983       "23":"a",
10984       "24":"a",
10985       "25":"a",
10986       "26":"a",
10987       "27":"a",
10988       "28":"a",
10989       "29":"a"
10990     },
10991     "ios_saf":{
10992       "3.2":"a x",
10993       "4.0-4.1":"a x",
10994       "4.2-4.3":"a x",
10995       "5.0-5.1":"a",
10996       "6.0-6.1":"a",
10997       "7.0-7.1":"a",
10998       "8":"a",
10999       "8.1":"a"
11000     },
11001     "op_mini":{
11002       "5.0-8.0":"a"
11003     },
11004     "android":{
11005       "2.1":"a x",
11006       "2.2":"a x",
11007       "2.3":"a x",
11008       "3":"a x",
11009       "4":"a",
11010       "4.1":"a",
11011       "4.2-4.3":"a",
11012       "4.4":"a",
11013       "4.4.3-4.4.4":"a",
11014       "37":"a"
11015     },
11016     "bb":{
11017       "7":"a x",
11018       "10":"a"
11019     },
11020     "op_mob":{
11021       "10":"a",
11022       "11":"a",
11023       "11.1":"a",
11024       "11.5":"a",
11025       "12":"a",
11026       "12.1":"a",
11027       "24":"a"
11028     },
11029     "and_chr":{
11030       "40":"a"
11031     },
11032     "and_ff":{
11033       "33":"y"
11034     },
11035     "ie_mob":{
11036       "10":"a",
11037       "11":"a"
11038     },
11039     "and_uc":{
11040       "9.9":"a"
11041     }
11042   },
11043   "notes":"Partial support refers to supporting only the `content-box` and `border-box` values, not `padding-box` (which was added to the spec later).",
11044   "notes_by_num":{
11045
11046   },
11047   "usage_perc_y":12,
11048   "usage_perc_a":84.84,
11049   "ucprefix":false,
11050   "parent":"",
11051   "keywords":"border-box,content-box,padding-box",
11052   "ie_id":"",
11053   "chrome_id":"",
11054   "shown":true
11055 }
11056 },{}],79:[function(require,module,exports){
11057 module.exports={
11058   "title":"CSS3 Cursors (new values)",
11059   "description":"Support for `zoom-in` and `zoom-out` values for the CSS3 `cursor` property.",
11060   "spec":"http://www.w3.org/TR/css3-ui/#cursor",
11061   "status":"wd",
11062   "links":[
11063     {
11064       "url":"https://developer.mozilla.org/en-US/docs/Web/CSS/cursor",
11065       "title":"MDN Documentation"
11066     }
11067   ],
11068   "bugs":[
11069
11070   ],
11071   "categories":[
11072     "CSS3"
11073   ],
11074   "stats":{
11075     "ie":{
11076       "5.5":"n",
11077       "6":"n",
11078       "7":"n",
11079       "8":"n",
11080       "9":"n",
11081       "10":"n",
11082       "11":"n",
11083       "TP":"n"
11084     },
11085     "firefox":{
11086       "2":"y x",
11087       "3":"y x",
11088       "3.5":"y x",
11089       "3.6":"y x",
11090       "4":"y x",
11091       "5":"y x",
11092       "6":"y x",
11093       "7":"y x",
11094       "8":"y x",
11095       "9":"y x",
11096       "10":"y x",
11097       "11":"y x",
11098       "12":"y x",
11099       "13":"y x",
11100       "14":"y x",
11101       "15":"y x",
11102       "16":"y x",
11103       "17":"y x",
11104       "18":"y x",
11105       "19":"y x",
11106       "20":"y x",
11107       "21":"y x",
11108       "22":"y x",
11109       "23":"y x",
11110       "24":"y",
11111       "25":"y",
11112       "26":"y",
11113       "27":"y",
11114       "28":"y",
11115       "29":"y",
11116       "30":"y",
11117       "31":"y",
11118       "32":"y",
11119       "33":"y",
11120       "34":"y",
11121       "35":"y",
11122       "36":"y",
11123       "37":"y",
11124       "38":"y"
11125     },
11126     "chrome":{
11127       "4":"y x",
11128       "5":"y x",
11129       "6":"y x",
11130       "7":"y x",
11131       "8":"y x",
11132       "9":"y x",
11133       "10":"y x",
11134       "11":"y x",
11135       "12":"y x",
11136       "13":"y x",
11137       "14":"y x",
11138       "15":"y x",
11139       "16":"y x",
11140       "17":"y x",
11141       "18":"y x",
11142       "19":"y x",
11143       "20":"y x",
11144       "21":"y x",
11145       "22":"y x",
11146       "23":"y x",
11147       "24":"y x",
11148       "25":"y x",
11149       "26":"y x",
11150       "27":"y x",
11151       "28":"y x",
11152       "29":"y x",
11153       "30":"y x",
11154       "31":"y x",
11155       "32":"y x",
11156       "33":"y x",
11157       "34":"y x",
11158       "35":"y x",
11159       "36":"y x",
11160       "37":"y",
11161       "38":"y",
11162       "39":"y",
11163       "40":"y",
11164       "41":"y",
11165       "42":"y",
11166       "43":"y"
11167     },
11168     "safari":{
11169       "3.1":"y x",
11170       "3.2":"y x",
11171       "4":"y x",
11172       "5":"y x",
11173       "5.1":"y x",
11174       "6":"y x",
11175       "6.1":"y x",
11176       "7":"y x",
11177       "7.1":"y x",
11178       "8":"y x"
11179     },
11180     "opera":{
11181       "9":"n",
11182       "9.5-9.6":"n",
11183       "10.0-10.1":"n",
11184       "10.5":"n",
11185       "10.6":"n",
11186       "11":"n",
11187       "11.1":"n",
11188       "11.5":"n",
11189       "11.6":"y",
11190       "12":"y",
11191       "12.1":"y",
11192       "15":"y x",
11193       "16":"y x",
11194       "17":"y x",
11195       "18":"y x",
11196       "19":"y x",
11197       "20":"y x",
11198       "21":"y x",
11199       "22":"y x",
11200       "23":"y x",
11201       "24":"y",
11202       "25":"y",
11203       "26":"y",
11204       "27":"y",
11205       "28":"y",
11206       "29":"y"
11207     },
11208     "ios_saf":{
11209       "3.2":"n",
11210       "4.0-4.1":"n",
11211       "4.2-4.3":"n",
11212       "5.0-5.1":"n",
11213       "6.0-6.1":"n",
11214       "7.0-7.1":"n",
11215       "8":"n",
11216       "8.1":"n"
11217     },
11218     "op_mini":{
11219       "5.0-8.0":"n"
11220     },
11221     "android":{
11222       "2.1":"n",
11223       "2.2":"n",
11224       "2.3":"n",
11225       "3":"n",
11226       "4":"n",
11227       "4.1":"n",
11228       "4.2-4.3":"n",
11229       "4.4":"n",
11230       "4.4.3-4.4.4":"n",
11231       "37":"n"
11232     },
11233     "bb":{
11234       "7":"y x",
11235       "10":"y x"
11236     },
11237     "op_mob":{
11238       "10":"n",
11239       "11":"n",
11240       "11.1":"n",
11241       "11.5":"n",
11242       "12":"n",
11243       "12.1":"n",
11244       "24":"n"
11245     },
11246     "and_chr":{
11247       "40":"n"
11248     },
11249     "and_ff":{
11250       "33":"n"
11251     },
11252     "ie_mob":{
11253       "10":"n",
11254       "11":"n"
11255     },
11256     "and_uc":{
11257       "9.9":"n"
11258     }
11259   },
11260   "notes":"Chrome, Safari and Firefox also support the unofficial `grab` and `grabbing` values (with prefix)",
11261   "notes_by_num":{
11262
11263   },
11264   "usage_perc_y":48.23,
11265   "usage_perc_a":0,
11266   "ucprefix":false,
11267   "parent":"",
11268   "keywords":"cursors, pointers",
11269   "ie_id":"",
11270   "chrome_id":"",
11271   "shown":true
11272 }
11273 },{}],80:[function(require,module,exports){
11274 module.exports={
11275   "title":"CSS3 tab-size",
11276   "description":"Method of customizing the width of the tab character. Only effective using 'white-space: pre' or 'white-space: pre-wrap'.",
11277   "spec":"http://www.w3.org/TR/css3-text/#tab-size1",
11278   "status":"wd",
11279   "links":[
11280     {
11281       "url":"https://developer.mozilla.org/en-US/docs/Web/CSS/tab-size",
11282       "title":"MDN article"
11283     }
11284   ],
11285   "bugs":[
11286     {
11287       "description":"Firefox [does not yet](https://bugzilla.mozilla.org/show_bug.cgi?id=943918) support `<length>` values"
11288     }
11289   ],
11290   "categories":[
11291     "CSS3"
11292   ],
11293   "stats":{
11294     "ie":{
11295       "5.5":"n",
11296       "6":"n",
11297       "7":"n",
11298       "8":"n",
11299       "9":"n",
11300       "10":"n",
11301       "11":"n",
11302       "TP":"n"
11303     },
11304     "firefox":{
11305       "2":"n",
11306       "3":"n",
11307       "3.5":"n",
11308       "3.6":"n",
11309       "4":"y x",
11310       "5":"y x",
11311       "6":"y x",
11312       "7":"y x",
11313       "8":"y x",
11314       "9":"y x",
11315       "10":"y x",
11316       "11":"y x",
11317       "12":"y x",
11318       "13":"y x",
11319       "14":"y x",
11320       "15":"y x",
11321       "16":"y x",
11322       "17":"y x",
11323       "18":"y x",
11324       "19":"y x",
11325       "20":"y x",
11326       "21":"y x",
11327       "22":"y x",
11328       "23":"y x",
11329       "24":"y x",
11330       "25":"y x",
11331       "26":"y x",
11332       "27":"y x",
11333       "28":"y x",
11334       "29":"y x",
11335       "30":"y x",
11336       "31":"y x",
11337       "32":"y x",
11338       "33":"y x",
11339       "34":"y x",
11340       "35":"y x",
11341       "36":"y x",
11342       "37":"y x",
11343       "38":"y x"
11344     },
11345     "chrome":{
11346       "4":"n",
11347       "5":"n",
11348       "6":"n",
11349       "7":"n",
11350       "8":"n",
11351       "9":"n",
11352       "10":"n",
11353       "11":"n",
11354       "12":"n",
11355       "13":"n",
11356       "14":"n",
11357       "15":"n",
11358       "16":"n",
11359       "17":"n",
11360       "18":"n",
11361       "19":"n",
11362       "20":"n",
11363       "21":"y",
11364       "22":"y",
11365       "23":"y",
11366       "24":"y",
11367       "25":"y",
11368       "26":"y",
11369       "27":"y",
11370       "28":"y",
11371       "29":"y",
11372       "30":"y",
11373       "31":"y",
11374       "32":"y",
11375       "33":"y",
11376       "34":"y",
11377       "35":"y",
11378       "36":"y",
11379       "37":"y",
11380       "38":"y",
11381       "39":"y",
11382       "40":"y",
11383       "41":"y",
11384       "42":"y",
11385       "43":"y"
11386     },
11387     "safari":{
11388       "3.1":"n",
11389       "3.2":"n",
11390       "4":"n",
11391       "5":"n",
11392       "5.1":"n",
11393       "6":"n",
11394       "6.1":"y",
11395       "7":"y",
11396       "7.1":"y",
11397       "8":"y"
11398     },
11399     "opera":{
11400       "9":"n",
11401       "9.5-9.6":"n",
11402       "10.0-10.1":"n",
11403       "10.5":"n",
11404       "10.6":"y x",
11405       "11":"y x",
11406       "11.1":"y x",
11407       "11.5":"y x",
11408       "11.6":"y x",
11409       "12":"y x",
11410       "12.1":"y x",
11411       "15":"y",
11412       "16":"y",
11413       "17":"y",
11414       "18":"y",
11415       "19":"y",
11416       "20":"y",
11417       "21":"y",
11418       "22":"y",
11419       "23":"y",
11420       "24":"y",
11421       "25":"y",
11422       "26":"y",
11423       "27":"y",
11424       "28":"y",
11425       "29":"y"
11426     },
11427     "ios_saf":{
11428       "3.2":"n",
11429       "4.0-4.1":"n",
11430       "4.2-4.3":"n",
11431       "5.0-5.1":"n",
11432       "6.0-6.1":"n",
11433       "7.0-7.1":"y",
11434       "8":"y",
11435       "8.1":"y"
11436     },
11437     "op_mini":{
11438       "5.0-8.0":"y x"
11439     },
11440     "android":{
11441       "2.1":"n",
11442       "2.2":"n",
11443       "2.3":"n",
11444       "3":"n",
11445       "4":"n",
11446       "4.1":"n",
11447       "4.2-4.3":"n",
11448       "4.4":"y",
11449       "4.4.3-4.4.4":"y",
11450       "37":"y"
11451     },
11452     "bb":{
11453       "7":"y",
11454       "10":"y"
11455     },
11456     "op_mob":{
11457       "10":"n",
11458       "11":"y x",
11459       "11.1":"y x",
11460       "11.5":"y x",
11461       "12":"y x",
11462       "12.1":"y x",
11463       "24":"y"
11464     },
11465     "and_chr":{
11466       "40":"y"
11467     },
11468     "and_ff":{
11469       "33":"y x"
11470     },
11471     "ie_mob":{
11472       "10":"n",
11473       "11":"n"
11474     },
11475     "and_uc":{
11476       "9.9":"n"
11477     }
11478   },
11479   "notes":"",
11480   "notes_by_num":{
11481
11482   },
11483   "usage_perc_y":71.73,
11484   "usage_perc_a":0,
11485   "ucprefix":false,
11486   "parent":"",
11487   "keywords":"tab-size,tab-width",
11488   "ie_id":"",
11489   "chrome_id":"",
11490   "shown":true
11491 }
11492 },{}],81:[function(require,module,exports){
11493 module.exports={
11494   "title":"Flexible Box Layout Module",
11495   "description":"Method of positioning elements in horizontal or vertical stacks.",
11496   "spec":"http://www.w3.org/TR/css3-flexbox/",
11497   "status":"wd",
11498   "links":[
11499     {
11500       "url":"http://bennettfeely.com/flexplorer/",
11501       "title":"Flexbox CSS generator"
11502     },
11503     {
11504       "url":"http://www.adobe.com/devnet/html5/articles/working-with-flexbox-the-new-spec.html",
11505       "title":"Article on using the latest spec"
11506     },
11507     {
11508       "url":"https://dev.opera.com/articles/view/advanced-cross-browser-flexbox/",
11509       "title":"Tutorial on cross-browser support"
11510     },
11511     {
11512       "url":"http://philipwalton.github.io/solved-by-flexbox/",
11513       "title":"Examples on how to solve common layout problems with flexbox"
11514     },
11515     {
11516       "url":"http://css-tricks.com/snippets/css/a-guide-to-flexbox/",
11517       "title":"A Complete Guide to Flexbox"
11518     },
11519     {
11520       "url":"http://the-echoplex.net/flexyboxes/",
11521       "title":"Flexbox playground and code generator"
11522     }
11523   ],
11524   "bugs":[
11525     {
11526       "description":"IE10 and IE11 default values for `flex` are `0 0 auto` rather than `0 1 auto`, as per the draft spec, as of September 2013."
11527     },
11528     {
11529       "description":"In IE10 and IE11, containers with `display: flex` and `flex-direction: column` will not properly calculate their flexed childrens' sizes if the container has `min-height` but no explicit `height` property. [See bug](https://connect.microsoft.com/IE/feedback/details/802625/min-height-and-flexbox-flex-direction-column-dont-work-together-in-ie-10-11-preview)."
11530     },
11531     {
11532       "description":"In Chrome and Safari, the height of (non flex) children are not recognized in percentages. However Firefox and IE recognize and scale the children based on percentage heights. [Chrome bug](http://crbug.com/341310)"
11533     },
11534     {
11535       "description":"Firefox does not support [Flexbox in button elements](https://bugzilla.mozilla.org/show_bug.cgi?id=984869#c2)"
11536     },
11537     {
11538       "description":"[Flexbugs](https://github.com/philipwalton/flexbugs): community-curated list of flexbox issues and cross-browser workarounds for them"
11539     }
11540   ],
11541   "categories":[
11542     "CSS3"
11543   ],
11544   "stats":{
11545     "ie":{
11546       "5.5":"n",
11547       "6":"n",
11548       "7":"n",
11549       "8":"n",
11550       "9":"n",
11551       "10":"a x #2",
11552       "11":"y",
11553       "TP":"y"
11554     },
11555     "firefox":{
11556       "2":"a x #1",
11557       "3":"a x #1",
11558       "3.5":"a x #1",
11559       "3.6":"a x #1",
11560       "4":"a x #1",
11561       "5":"a x #1",
11562       "6":"a x #1",
11563       "7":"a x #1",
11564       "8":"a x #1",
11565       "9":"a x #1",
11566       "10":"a x #1",
11567       "11":"a x #1",
11568       "12":"a x #1",
11569       "13":"a x #1",
11570       "14":"a x #1",
11571       "15":"a x #1",
11572       "16":"a x #1",
11573       "17":"a x #1",
11574       "18":"a x #1",
11575       "19":"a x #1",
11576       "20":"a x #1",
11577       "21":"a x #1",
11578       "22":"a #3",
11579       "23":"a #3",
11580       "24":"a #3",
11581       "25":"a #3",
11582       "26":"a #3",
11583       "27":"a #3",
11584       "28":"y",
11585       "29":"y",
11586       "30":"y",
11587       "31":"y",
11588       "32":"y",
11589       "33":"y",
11590       "34":"y",
11591       "35":"y",
11592       "36":"y",
11593       "37":"y",
11594       "38":"y"
11595     },
11596     "chrome":{
11597       "4":"a x #1",
11598       "5":"a x #1",
11599       "6":"a x #1",
11600       "7":"a x #1",
11601       "8":"a x #1",
11602       "9":"a x #1",
11603       "10":"a x #1",
11604       "11":"a x #1",
11605       "12":"a x #1",
11606       "13":"a x #1",
11607       "14":"a x #1",
11608       "15":"a x #1",
11609       "16":"a x #1",
11610       "17":"a x #1",
11611       "18":"a x #1",
11612       "19":"a x #1",
11613       "20":"a x #1",
11614       "21":"y x",
11615       "22":"y x",
11616       "23":"y x",
11617       "24":"y x",
11618       "25":"y x",
11619       "26":"y x",
11620       "27":"y x",
11621       "28":"y x",
11622       "29":"y",
11623       "30":"y",
11624       "31":"y",
11625       "32":"y",
11626       "33":"y",
11627       "34":"y",
11628       "35":"y",
11629       "36":"y",
11630       "37":"y",
11631       "38":"y",
11632       "39":"y",
11633       "40":"y",
11634       "41":"y",
11635       "42":"y",
11636       "43":"y"
11637     },
11638     "safari":{
11639       "3.1":"a x #1",
11640       "3.2":"a x #1",
11641       "4":"a x #1",
11642       "5":"a x #1",
11643       "5.1":"a x #1",
11644       "6":"a x #1",
11645       "6.1":"y x",
11646       "7":"y x",
11647       "7.1":"y x",
11648       "8":"y x"
11649     },
11650     "opera":{
11651       "9":"n",
11652       "9.5-9.6":"n",
11653       "10.0-10.1":"n",
11654       "10.5":"n",
11655       "10.6":"n",
11656       "11":"n",
11657       "11.1":"n",
11658       "11.5":"n",
11659       "11.6":"n",
11660       "12":"n",
11661       "12.1":"y",
11662       "15":"y x",
11663       "16":"y x",
11664       "17":"y",
11665       "18":"y",
11666       "19":"y",
11667       "20":"y",
11668       "21":"y",
11669       "22":"y",
11670       "23":"y",
11671       "24":"y",
11672       "25":"y",
11673       "26":"y",
11674       "27":"y",
11675       "28":"y",
11676       "29":"y"
11677     },
11678     "ios_saf":{
11679       "3.2":"a x #1",
11680       "4.0-4.1":"a x #1",
11681       "4.2-4.3":"a x #1",
11682       "5.0-5.1":"a x #1",
11683       "6.0-6.1":"a x #1",
11684       "7.0-7.1":"y x",
11685       "8":"y x",
11686       "8.1":"y x"
11687     },
11688     "op_mini":{
11689       "5.0-8.0":"n"
11690     },
11691     "android":{
11692       "2.1":"a x #1",
11693       "2.2":"a x #1",
11694       "2.3":"a x #1",
11695       "3":"a x #1",
11696       "4":"a x #1",
11697       "4.1":"a x #1",
11698       "4.2-4.3":"a x #1",
11699       "4.4":"y",
11700       "4.4.3-4.4.4":"y",
11701       "37":"y"
11702     },
11703     "bb":{
11704       "7":"a x #1",
11705       "10":"y x"
11706     },
11707     "op_mob":{
11708       "10":"n",
11709       "11":"n",
11710       "11.1":"n",
11711       "11.5":"n",
11712       "12":"n",
11713       "12.1":"y",
11714       "24":"y"
11715     },
11716     "and_chr":{
11717       "40":"y"
11718     },
11719     "and_ff":{
11720       "33":"y"
11721     },
11722     "ie_mob":{
11723       "10":"a x #2",
11724       "11":"y"
11725     },
11726     "and_uc":{
11727       "9.9":"a x #1"
11728     }
11729   },
11730   "notes":"Most partial support refers to supporting an [older version](http://www.w3.org/TR/2009/WD-css3-flexbox-20090723/) of the specification or an [older syntax](http://www.w3.org/TR/2012/WD-css3-flexbox-20120322/).",
11731   "notes_by_num":{
11732     "1":"Only supports the [old flexbox](http://www.w3.org/TR/2009/WD-css3-flexbox-20090723) specification and does not support wrapping.",
11733     "2":"Only supports the [2012 syntax](http://www.w3.org/TR/2012/WD-css3-flexbox-20120322/)",
11734     "3":"Does not support flex-wrap or flex-flow properties"
11735   },
11736   "usage_perc_y":76.29,
11737   "usage_perc_a":11.17,
11738   "ucprefix":false,
11739   "parent":"",
11740   "keywords":"flex-box,flex-direction,flex-wrap,flex-flow,flex-grow,flex-basis",
11741   "ie_id":"flexbox",
11742   "chrome_id":"4837301406400512",
11743   "shown":true
11744 }
11745 },{}],82:[function(require,module,exports){
11746 module.exports={
11747   "title":"Font feature settings",
11748   "description":"Method of applying advanced typographic and language-specific font features to supported OpenType fonts.",
11749   "spec":"http://w3.org/TR/css3-fonts/#font-rend-props",
11750   "status":"wd",
11751   "links":[
11752     {
11753       "url":"http://ie.microsoft.com/testdrive/Graphics/opentype/",
11754       "title":"Demo pages (IE/Firefox only)"
11755     },
11756     {
11757       "url":"http://hacks.mozilla.org/2010/11/firefox-4-font-feature-support/",
11758       "title":"Mozilla hacks article"
11759     },
11760     {
11761       "url":"http://html5accessibility.com/",
11762       "title":"Detailed tables on accessability support"
11763     },
11764     {
11765       "url":"http://docs.webplatform.org/wiki/css/properties/font-feature-settings",
11766       "title":"WebPlatform Docs"
11767     }
11768   ],
11769   "bugs":[
11770
11771   ],
11772   "categories":[
11773     "CSS3"
11774   ],
11775   "stats":{
11776     "ie":{
11777       "5.5":"n",
11778       "6":"n",
11779       "7":"n",
11780       "8":"n",
11781       "9":"n",
11782       "10":"y",
11783       "11":"y",
11784       "TP":"y"
11785     },
11786     "firefox":{
11787       "2":"n",
11788       "3":"n",
11789       "3.5":"n",
11790       "3.6":"n",
11791       "4":"a x",
11792       "5":"a x",
11793       "6":"a x",
11794       "7":"a x",
11795       "8":"a x",
11796       "9":"a x",
11797       "10":"a x",
11798       "11":"a x",
11799       "12":"a x",
11800       "13":"a x",
11801       "14":"a x",
11802       "15":"y x",
11803       "16":"y x",
11804       "17":"y x",
11805       "18":"y x",
11806       "19":"y x",
11807       "20":"y x",
11808       "21":"y x",
11809       "22":"y x",
11810       "23":"y x",
11811       "24":"y x",
11812       "25":"y x",
11813       "26":"y x",
11814       "27":"y x",
11815       "28":"y x",
11816       "29":"y x",
11817       "30":"y x",
11818       "31":"y x",
11819       "32":"y x",
11820       "33":"y x",
11821       "34":"y",
11822       "35":"y",
11823       "36":"y",
11824       "37":"y",
11825       "38":"y"
11826     },
11827     "chrome":{
11828       "4":"n",
11829       "5":"n",
11830       "6":"n",
11831       "7":"n",
11832       "8":"n",
11833       "9":"n",
11834       "10":"n",
11835       "11":"n",
11836       "12":"n",
11837       "13":"n",
11838       "14":"n",
11839       "15":"n",
11840       "16":"a x",
11841       "17":"a x",
11842       "18":"a x",
11843       "19":"a x",
11844       "20":"a x",
11845       "21":"y x",
11846       "22":"y x",
11847       "23":"y x",
11848       "24":"y x",
11849       "25":"y x",
11850       "26":"y x",
11851       "27":"y x",
11852       "28":"y x",
11853       "29":"y x",
11854       "30":"y x",
11855       "31":"y x",
11856       "32":"y x",
11857       "33":"y x",
11858       "34":"y x",
11859       "35":"y x",
11860       "36":"y x",
11861       "37":"y x",
11862       "38":"y x",
11863       "39":"y x",
11864       "40":"y x",
11865       "41":"y x",
11866       "42":"y x",
11867       "43":"y x"
11868     },
11869     "safari":{
11870       "3.1":"n",
11871       "3.2":"n",
11872       "4":"a",
11873       "5":"a",
11874       "5.1":"a",
11875       "6":"a",
11876       "6.1":"n",
11877       "7":"n",
11878       "7.1":"n",
11879       "8":"n"
11880     },
11881     "opera":{
11882       "9":"n",
11883       "9.5-9.6":"n",
11884       "10.0-10.1":"n",
11885       "10.5":"n",
11886       "10.6":"n",
11887       "11":"n",
11888       "11.1":"n",
11889       "11.5":"n",
11890       "11.6":"n",
11891       "12":"n",
11892       "12.1":"n",
11893       "15":"y x",
11894       "16":"y x",
11895       "17":"y x",
11896       "18":"y x",
11897       "19":"y x",
11898       "20":"y x",
11899       "21":"y x",
11900       "22":"y x",
11901       "23":"y x",
11902       "24":"y x",
11903       "25":"y x",
11904       "26":"y x",
11905       "27":"y x",
11906       "28":"y x",
11907       "29":"y x"
11908     },
11909     "ios_saf":{
11910       "3.2":"a",
11911       "4.0-4.1":"a",
11912       "4.2-4.3":"a",
11913       "5.0-5.1":"a",
11914       "6.0-6.1":"a",
11915       "7.0-7.1":"n",
11916       "8":"n",
11917       "8.1":"n"
11918     },
11919     "op_mini":{
11920       "5.0-8.0":"n"
11921     },
11922     "android":{
11923       "2.1":"n",
11924       "2.2":"n",
11925       "2.3":"n",
11926       "3":"n",
11927       "4":"n",
11928       "4.1":"n",
11929       "4.2-4.3":"n",
11930       "4.4":"y x",
11931       "4.4.3-4.4.4":"y x",
11932       "37":"y x"
11933     },
11934     "bb":{
11935       "7":"n",
11936       "10":"y x"
11937     },
11938     "op_mob":{
11939       "10":"n",
11940       "11":"n",
11941       "11.1":"n",
11942       "11.5":"n",
11943       "12":"n",
11944       "12.1":"n",
11945       "24":"y x"
11946     },
11947     "and_chr":{
11948       "40":"y x"
11949     },
11950     "and_ff":{
11951       "33":"y x"
11952     },
11953     "ie_mob":{
11954       "10":"n",
11955       "11":"n"
11956     },
11957     "and_uc":{
11958       "9.9":"y x"
11959     }
11960   },
11961   "notes":"Partial support in older Firefox versions refers to using an older syntax. Partial support in older Chrome versions refers to lacking support in Mac OS X. ",
11962   "notes_by_num":{
11963
11964   },
11965   "usage_perc_y":71.96,
11966   "usage_perc_a":1.34,
11967   "ucprefix":false,
11968   "parent":"",
11969   "keywords":"font-feature,font-feature-settings,kern,kerning,font-variant-alternates,ligatures,font-variant-ligatures",
11970   "ie_id":"",
11971   "chrome_id":"",
11972   "shown":true
11973 }
11974 },{}],83:[function(require,module,exports){
11975 module.exports={
11976   "title":"Full Screen API",
11977   "description":"API for allowing content (like a video or canvas element) to take up the entire screen.",
11978   "spec":"http://www.w3.org/TR/fullscreen/",
11979   "status":"wd",
11980   "links":[
11981     {
11982       "url":"https://developer.mozilla.org/en/DOM/Using_full-screen_mode",
11983       "title":"MDN article"
11984     },
11985     {
11986       "url":"http://jlongster.com/2011/11/21/canvas.html",
11987       "title":"Blog post"
11988     },
11989     {
11990       "url":"http://hacks.mozilla.org/2012/01/using-the-fullscreen-api-in-web-browsers/",
11991       "title":"Mozilla hacks article"
11992     },
11993     {
11994       "url":"http://docs.webplatform.org/wiki/dom/Element/requestFullscreen",
11995       "title":"WebPlatform Docs"
11996     }
11997   ],
11998   "bugs":[
11999     {
12000       "description":"IE 11 doesn't allow going to fullscreen mode when the event that triggers `msRequestFullscreen()` is a `keydown` or `pointerdown` event (`keypress` and `click` do work)"
12001     },
12002     {
12003       "description":"Safari blocks access to keyboard events in fullscreen mode (as a security measure)."
12004     },
12005     {
12006       "description":"IE 11 does not allow scrolling when document.documentElement is set to full screen."
12007     },
12008     {
12009       "description":"IE 11 does not properly support fullscreen when opening from an iframe."
12010     },
12011     {
12012       "description":"Opera 12.1 uses the older specificaton's `:fullscreen-ancestor` pseudo-class instead of the  the `::backdrop` pseudo-element."
12013     }
12014   ],
12015   "categories":[
12016     "JS API"
12017   ],
12018   "stats":{
12019     "ie":{
12020       "5.5":"n",
12021       "6":"n",
12022       "7":"n",
12023       "8":"n",
12024       "9":"n",
12025       "10":"n",
12026       "11":"y x",
12027       "TP":"y x"
12028     },
12029     "firefox":{
12030       "2":"n",
12031       "3":"n",
12032       "3.5":"n",
12033       "3.6":"n",
12034       "4":"n",
12035       "5":"n",
12036       "6":"n",
12037       "7":"n",
12038       "8":"n",
12039       "9":"n",
12040       "10":"a x",
12041       "11":"a x",
12042       "12":"a x",
12043       "13":"a x",
12044       "14":"a x",
12045       "15":"a x",
12046       "16":"a x",
12047       "17":"a x",
12048       "18":"a x",
12049       "19":"a x",
12050       "20":"a x",
12051       "21":"a x",
12052       "22":"a x",
12053       "23":"a x",
12054       "24":"a x",
12055       "25":"a x",
12056       "26":"a x",
12057       "27":"a x",
12058       "28":"a x",
12059       "29":"a x",
12060       "30":"a x",
12061       "31":"a x",
12062       "32":"a x",
12063       "33":"a x",
12064       "34":"a x",
12065       "35":"a x",
12066       "36":"a x",
12067       "37":"a x",
12068       "38":"a x"
12069     },
12070     "chrome":{
12071       "4":"n",
12072       "5":"n",
12073       "6":"n",
12074       "7":"n",
12075       "8":"n",
12076       "9":"n",
12077       "10":"n",
12078       "11":"n",
12079       "12":"n",
12080       "13":"n",
12081       "14":"n",
12082       "15":"a x",
12083       "16":"a x",
12084       "17":"a x",
12085       "18":"a x",
12086       "19":"a x",
12087       "20":"y x",
12088       "21":"y x",
12089       "22":"y x",
12090       "23":"y x",
12091       "24":"y x",
12092       "25":"y x",
12093       "26":"y x",
12094       "27":"y x",
12095       "28":"y x",
12096       "29":"y x",
12097       "30":"y x",
12098       "31":"y x",
12099       "32":"y x",
12100       "33":"y x",
12101       "34":"y x",
12102       "35":"y x",
12103       "36":"y x",
12104       "37":"y x",
12105       "38":"y x",
12106       "39":"y x",
12107       "40":"y x",
12108       "41":"y x",
12109       "42":"y x",
12110       "43":"y x"
12111     },
12112     "safari":{
12113       "3.1":"n",
12114       "3.2":"n",
12115       "4":"n",
12116       "5":"n",
12117       "5.1":"a x",
12118       "6":"y x",
12119       "6.1":"y x",
12120       "7":"y x",
12121       "7.1":"y x",
12122       "8":"y x"
12123     },
12124     "opera":{
12125       "9":"n",
12126       "9.5-9.6":"n",
12127       "10.0-10.1":"n",
12128       "10.5":"n",
12129       "10.6":"n",
12130       "11":"n",
12131       "11.1":"n",
12132       "11.5":"n",
12133       "11.6":"n",
12134       "12":"n",
12135       "12.1":"y",
12136       "15":"y x",
12137       "16":"y x",
12138       "17":"y x",
12139       "18":"y x",
12140       "19":"y x",
12141       "20":"y x",
12142       "21":"y x",
12143       "22":"y x",
12144       "23":"y x",
12145       "24":"y x",
12146       "25":"y x",
12147       "26":"y x",
12148       "27":"y x",
12149       "28":"y x",
12150       "29":"y x"
12151     },
12152     "ios_saf":{
12153       "3.2":"n",
12154       "4.0-4.1":"n",
12155       "4.2-4.3":"n",
12156       "5.0-5.1":"n",
12157       "6.0-6.1":"n",
12158       "7.0-7.1":"n",
12159       "8":"n",
12160       "8.1":"n"
12161     },
12162     "op_mini":{
12163       "5.0-8.0":"n"
12164     },
12165     "android":{
12166       "2.1":"n",
12167       "2.2":"n",
12168       "2.3":"n",
12169       "3":"n",
12170       "4":"n",
12171       "4.1":"n",
12172       "4.2-4.3":"n",
12173       "4.4":"n",
12174       "4.4.3-4.4.4":"n",
12175       "37":"n"
12176     },
12177     "bb":{
12178       "7":"n",
12179       "10":"a"
12180     },
12181     "op_mob":{
12182       "10":"n",
12183       "11":"n",
12184       "11.1":"n",
12185       "11.5":"n",
12186       "12":"n",
12187       "12.1":"n",
12188       "24":"y x"
12189     },
12190     "and_chr":{
12191       "40":"y x"
12192     },
12193     "and_ff":{
12194       "33":"a x"
12195     },
12196     "ie_mob":{
12197       "10":"n",
12198       "11":"y x"
12199     },
12200     "and_uc":{
12201       "9.9":"n"
12202     }
12203   },
12204   "notes":"Partial support refers to supporting an earlier draft of the spec.",
12205   "notes_by_num":{
12206
12207   },
12208   "usage_perc_y":54.48,
12209   "usage_perc_a":12.24,
12210   "ucprefix":false,
12211   "parent":"",
12212   "keywords":"full-screen",
12213   "ie_id":"fullscreenapi",
12214   "chrome_id":"5259513871466496",
12215   "shown":true
12216 }
12217 },{}],84:[function(require,module,exports){
12218 module.exports={
12219   "title":"Intrinsic & Extrinsic Sizing",
12220   "description":"Allows for the heights and widths to be specified in intrinsic values using the fill-available, max-content, min-content, and fit-content properties.",
12221   "spec":"http://www.w3.org/TR/css3-sizing/",
12222   "status":"wd",
12223   "links":[
12224     {
12225       "url":"http://demosthenes.info/blog/662/Design-From-the-Inside-Out-With-CSS-MinContent",
12226       "title":"Min-Content tutorial"
12227     }
12228   ],
12229   "bugs":[
12230
12231   ],
12232   "categories":[
12233     "CSS3"
12234   ],
12235   "stats":{
12236     "ie":{
12237       "5.5":"n",
12238       "6":"n",
12239       "7":"n",
12240       "8":"n",
12241       "9":"n",
12242       "10":"n",
12243       "11":"n",
12244       "TP":"n"
12245     },
12246     "firefox":{
12247       "2":"n",
12248       "3":"n",
12249       "3.5":"n",
12250       "3.6":"n",
12251       "4":"y x",
12252       "5":"y x",
12253       "6":"y x",
12254       "7":"y x",
12255       "8":"y x",
12256       "9":"y x",
12257       "10":"y x",
12258       "11":"y x",
12259       "12":"y x",
12260       "13":"y x",
12261       "14":"y x",
12262       "15":"y x",
12263       "16":"y x",
12264       "17":"y x",
12265       "18":"y x",
12266       "19":"y x",
12267       "20":"y x",
12268       "21":"y x",
12269       "22":"y x",
12270       "23":"y x",
12271       "24":"y x",
12272       "25":"y x",
12273       "26":"y x",
12274       "27":"y x",
12275       "28":"y x",
12276       "29":"y x",
12277       "30":"y x",
12278       "31":"y x",
12279       "32":"y x",
12280       "33":"y x",
12281       "34":"y x",
12282       "35":"y x",
12283       "36":"y x",
12284       "37":"y x",
12285       "38":"y x"
12286     },
12287     "chrome":{
12288       "4":"n",
12289       "5":"n",
12290       "6":"n",
12291       "7":"n",
12292       "8":"n",
12293       "9":"n",
12294       "10":"n",
12295       "11":"n",
12296       "12":"n",
12297       "13":"n",
12298       "14":"n",
12299       "15":"n",
12300       "16":"n",
12301       "17":"n",
12302       "18":"n",
12303       "19":"n",
12304       "20":"n",
12305       "21":"n",
12306       "22":"y x",
12307       "23":"y x",
12308       "24":"y x",
12309       "25":"y x",
12310       "26":"y x",
12311       "27":"y x",
12312       "28":"y x",
12313       "29":"y x",
12314       "30":"y x",
12315       "31":"y x",
12316       "32":"y x",
12317       "33":"y x",
12318       "34":"y x",
12319       "35":"y x",
12320       "36":"y x",
12321       "37":"y x",
12322       "38":"y x",
12323       "39":"y x",
12324       "40":"y x",
12325       "41":"y x",
12326       "42":"y x",
12327       "43":"y x"
12328     },
12329     "safari":{
12330       "3.1":"n",
12331       "3.2":"n",
12332       "4":"n",
12333       "5":"n",
12334       "5.1":"n",
12335       "6":"n",
12336       "6.1":"y x",
12337       "7":"y x",
12338       "7.1":"y x",
12339       "8":"y x"
12340     },
12341     "opera":{
12342       "9":"n",
12343       "9.5-9.6":"n",
12344       "10.0-10.1":"n",
12345       "10.5":"n",
12346       "10.6":"n",
12347       "11":"n",
12348       "11.1":"n",
12349       "11.5":"n",
12350       "11.6":"n",
12351       "12":"n",
12352       "12.1":"n",
12353       "15":"y x",
12354       "16":"y x",
12355       "17":"y x",
12356       "18":"y x",
12357       "19":"y x",
12358       "20":"y x",
12359       "21":"y x",
12360       "22":"y x",
12361       "23":"y x",
12362       "24":"y x",
12363       "25":"y x",
12364       "26":"y x",
12365       "27":"y x",
12366       "28":"y x",
12367       "29":"y x"
12368     },
12369     "ios_saf":{
12370       "3.2":"n",
12371       "4.0-4.1":"n",
12372       "4.2-4.3":"n",
12373       "5.0-5.1":"n",
12374       "6.0-6.1":"n",
12375       "7.0-7.1":"y x",
12376       "8":"y x",
12377       "8.1":"y x"
12378     },
12379     "op_mini":{
12380       "5.0-8.0":"n"
12381     },
12382     "android":{
12383       "2.1":"n",
12384       "2.2":"n",
12385       "2.3":"n",
12386       "3":"n",
12387       "4":"n",
12388       "4.1":"n",
12389       "4.2-4.3":"n",
12390       "4.4":"y x",
12391       "4.4.3-4.4.4":"y x",
12392       "37":"y x"
12393     },
12394     "bb":{
12395       "7":"n",
12396       "10":"y x"
12397     },
12398     "op_mob":{
12399       "10":"n",
12400       "11":"n",
12401       "11.1":"n",
12402       "11.5":"n",
12403       "12":"n",
12404       "12.1":"n",
12405       "24":"y x"
12406     },
12407     "and_chr":{
12408       "40":"y x"
12409     },
12410     "and_ff":{
12411       "33":"y x"
12412     },
12413     "ie_mob":{
12414       "10":"n",
12415       "11":"n"
12416     },
12417     "and_uc":{
12418       "9.9":"n"
12419     }
12420   },
12421   "notes":"Prefixes are on the values, not the property names (e.g. -webkit-min-content) Firefox currently supports the \"-moz-available\" property rather than \"-moz-fill-available\".",
12422   "notes_by_num":{
12423
12424   },
12425   "usage_perc_y":68.21,
12426   "usage_perc_a":0,
12427   "ucprefix":false,
12428   "parent":"",
12429   "keywords":"fill-available,max-content,min-content,fit-content,contain-floats",
12430   "ie_id":"cssintrinsicsizing",
12431   "chrome_id":"5901353784180736",
12432   "shown":true
12433 }
12434 },{}],85:[function(require,module,exports){
12435 module.exports={
12436   "title":"CSS3 Multiple column layout",
12437   "description":"Method of flowing information in multiple columns",
12438   "spec":"http://www.w3.org/TR/css3-multicol/",
12439   "status":"cr",
12440   "links":[
12441     {
12442       "url":"https://dev.opera.com/articles/view/css3-multi-column-layout/",
12443       "title":"Dev.Opera article"
12444     },
12445     {
12446       "url":"http://webdesign.tutsplus.com/tutorials/htmlcss-tutorials/an-introduction-to-the-css3-multiple-column-layout-module/",
12447       "title":"Introduction page"
12448     },
12449     {
12450       "url":"http://docs.webplatform.org/wiki/css/properties/column-width",
12451       "title":"WebPlatform Docs"
12452     },
12453     {
12454       "url":"https://github.com/BetleyWhitehorne/CSS3MultiColumn",
12455       "title":"Polyfill"
12456     }
12457   ],
12458   "bugs":[
12459     {
12460       "description":"In Firefox, the property `column-span` (or `-moz-column-span`) does not yet work. See [the bug](https://bugzilla.mozilla.org/show_bug.cgi?id=616436)."
12461     },
12462     {
12463       "description":"In Chrome, the `-webkit-column-count` directive does not yet work with print stylesheets. See the [following bug in Chromium](https://code.google.com/p/chromium/issues/detail?id=99358)."
12464     },
12465     {
12466       "description":"Chrome is reported to incorrectly calculate the container height, and often breaks on margins, padding, and can display 1px of the next column at the bottom of the previous column."
12467     }
12468   ],
12469   "categories":[
12470     "CSS3"
12471   ],
12472   "stats":{
12473     "ie":{
12474       "5.5":"n",
12475       "6":"n",
12476       "7":"n",
12477       "8":"n",
12478       "9":"n",
12479       "10":"y",
12480       "11":"y",
12481       "TP":"y"
12482     },
12483     "firefox":{
12484       "2":"a x",
12485       "3":"a x",
12486       "3.5":"a x",
12487       "3.6":"a x",
12488       "4":"a x",
12489       "5":"a x",
12490       "6":"a x",
12491       "7":"a x",
12492       "8":"a x",
12493       "9":"a x",
12494       "10":"a x",
12495       "11":"a x",
12496       "12":"a x",
12497       "13":"a x",
12498       "14":"a x",
12499       "15":"a x",
12500       "16":"a x",
12501       "17":"a x",
12502       "18":"a x",
12503       "19":"a x",
12504       "20":"a x",
12505       "21":"a x",
12506       "22":"a x",
12507       "23":"a x",
12508       "24":"a x",
12509       "25":"a x",
12510       "26":"a x",
12511       "27":"a x",
12512       "28":"a x",
12513       "29":"a x",
12514       "30":"a x",
12515       "31":"a x",
12516       "32":"a x",
12517       "33":"a x",
12518       "34":"a x",
12519       "35":"a x",
12520       "36":"a x",
12521       "37":"a x",
12522       "38":"a x"
12523     },
12524     "chrome":{
12525       "4":"a x",
12526       "5":"a x",
12527       "6":"a x",
12528       "7":"a x",
12529       "8":"a x",
12530       "9":"a x",
12531       "10":"a x",
12532       "11":"a x",
12533       "12":"a x",
12534       "13":"a x",
12535       "14":"a x",
12536       "15":"a x",
12537       "16":"a x",
12538       "17":"a x",
12539       "18":"a x",
12540       "19":"a x",
12541       "20":"a x",
12542       "21":"a x",
12543       "22":"a x",
12544       "23":"a x",
12545       "24":"a x",
12546       "25":"a x",
12547       "26":"a x",
12548       "27":"a x",
12549       "28":"a x",
12550       "29":"a x",
12551       "30":"a x",
12552       "31":"a x",
12553       "32":"a x",
12554       "33":"a x",
12555       "34":"a x",
12556       "35":"a x",
12557       "36":"a x",
12558       "37":"a x",
12559       "38":"a x",
12560       "39":"a x",
12561       "40":"a x",
12562       "41":"a x",
12563       "42":"a x",
12564       "43":"a x"
12565     },
12566     "safari":{
12567       "3.1":"a x",
12568       "3.2":"a x",
12569       "4":"a x",
12570       "5":"a x",
12571       "5.1":"a x",
12572       "6":"a x",
12573       "6.1":"a x",
12574       "7":"a x",
12575       "7.1":"a x",
12576       "8":"a x"
12577     },
12578     "opera":{
12579       "9":"n",
12580       "9.5-9.6":"n",
12581       "10.0-10.1":"n",
12582       "10.5":"n",
12583       "10.6":"n",
12584       "11":"n",
12585       "11.1":"y",
12586       "11.5":"y",
12587       "11.6":"y",
12588       "12":"y",
12589       "12.1":"y",
12590       "15":"a x",
12591       "16":"a x",
12592       "17":"a x",
12593       "18":"a x",
12594       "19":"a x",
12595       "20":"a x",
12596       "21":"a x",
12597       "22":"a x",
12598       "23":"a x",
12599       "24":"a x",
12600       "25":"a x",
12601       "26":"a x",
12602       "27":"a x",
12603       "28":"a x",
12604       "29":"a x"
12605     },
12606     "ios_saf":{
12607       "3.2":"a x",
12608       "4.0-4.1":"a x",
12609       "4.2-4.3":"a x",
12610       "5.0-5.1":"a x",
12611       "6.0-6.1":"a x",
12612       "7.0-7.1":"a x",
12613       "8":"a x",
12614       "8.1":"a x"
12615     },
12616     "op_mini":{
12617       "5.0-8.0":"y"
12618     },
12619     "android":{
12620       "2.1":"a x",
12621       "2.2":"a x",
12622       "2.3":"a x",
12623       "3":"a x",
12624       "4":"a x",
12625       "4.1":"a x",
12626       "4.2-4.3":"a x",
12627       "4.4":"a x",
12628       "4.4.3-4.4.4":"a x",
12629       "37":"a x"
12630     },
12631     "bb":{
12632       "7":"a x",
12633       "10":"a x"
12634     },
12635     "op_mob":{
12636       "10":"n",
12637       "11":"n",
12638       "11.1":"y",
12639       "11.5":"y",
12640       "12":"y",
12641       "12.1":"y",
12642       "24":"a x"
12643     },
12644     "and_chr":{
12645       "40":"a x"
12646     },
12647     "and_ff":{
12648       "33":"a x"
12649     },
12650     "ie_mob":{
12651       "10":"y",
12652       "11":"y"
12653     },
12654     "and_uc":{
12655       "9.9":"a x"
12656     }
12657   },
12658   "notes":"Partial support refers to not supporting the `break-before`, `break-after`, `break-inside` properties. Webkit browsers do have equivalent support for the non-standard `-webkit-column-break-*` properties while Firefox supports `page-break-*` to accomplish the same result.",
12659   "notes_by_num":{
12660
12661   },
12662   "usage_perc_y":14.04,
12663   "usage_perc_a":76.54,
12664   "ucprefix":false,
12665   "parent":"",
12666   "keywords":"column-count",
12667   "ie_id":"multicolumnfullsupport",
12668   "chrome_id":"6526151266664448",
12669   "shown":true
12670 }
12671 },{}],86:[function(require,module,exports){
12672 module.exports={
12673   "title":"CSS3 object-fit/object-position",
12674   "description":"Method of specifying how an object (image or video) should fit inside its box. object-fit options include \"contain\" (fit according to aspect ratio), \"fill\" (stretches object to fill) and \"cover\" (overflows box but maintains ratio), where object-position allows the object to be repositioned like background-image does.",
12675   "spec":"http://www.w3.org/TR/css3-images/",
12676   "status":"cr",
12677   "links":[
12678     {
12679       "url":"https://dev.opera.com/articles/view/css3-object-fit-object-position/",
12680       "title":"Dev.Opera article"
12681     },
12682     {
12683       "url":"http://docs.webplatform.org/wiki/css/properties/object-fit",
12684       "title":"WebPlatform Docs"
12685     },
12686     {
12687       "url":"https://github.com/anselmh/object-fit",
12688       "title":"object-fit JavaScript-Polyfill"
12689     }
12690   ],
12691   "bugs":[
12692
12693   ],
12694   "categories":[
12695     "CSS3"
12696   ],
12697   "stats":{
12698     "ie":{
12699       "5.5":"n",
12700       "6":"n",
12701       "7":"n",
12702       "8":"n",
12703       "9":"n",
12704       "10":"n",
12705       "11":"n",
12706       "TP":"n"
12707     },
12708     "firefox":{
12709       "2":"n",
12710       "3":"n",
12711       "3.5":"n",
12712       "3.6":"n",
12713       "4":"n",
12714       "5":"n",
12715       "6":"n",
12716       "7":"n",
12717       "8":"n",
12718       "9":"n",
12719       "10":"n",
12720       "11":"n",
12721       "12":"n",
12722       "13":"n",
12723       "14":"n",
12724       "15":"n",
12725       "16":"n",
12726       "17":"n",
12727       "18":"n",
12728       "19":"n",
12729       "20":"n",
12730       "21":"n",
12731       "22":"n",
12732       "23":"n",
12733       "24":"n",
12734       "25":"n",
12735       "26":"n",
12736       "27":"n",
12737       "28":"n",
12738       "29":"n",
12739       "30":"n",
12740       "31":"n",
12741       "32":"n",
12742       "33":"n",
12743       "34":"n",
12744       "35":"n",
12745       "36":"y",
12746       "37":"y",
12747       "38":"y"
12748     },
12749     "chrome":{
12750       "4":"n",
12751       "5":"n",
12752       "6":"n",
12753       "7":"n",
12754       "8":"n",
12755       "9":"n",
12756       "10":"n",
12757       "11":"n",
12758       "12":"n",
12759       "13":"n",
12760       "14":"n",
12761       "15":"n",
12762       "16":"n",
12763       "17":"n",
12764       "18":"n",
12765       "19":"n",
12766       "20":"n",
12767       "21":"n",
12768       "22":"n",
12769       "23":"n",
12770       "24":"n",
12771       "25":"n",
12772       "26":"n",
12773       "27":"n",
12774       "28":"n",
12775       "29":"n",
12776       "30":"n",
12777       "31":"y",
12778       "32":"y",
12779       "33":"y",
12780       "34":"y",
12781       "35":"y",
12782       "36":"y",
12783       "37":"y",
12784       "38":"y",
12785       "39":"y",
12786       "40":"y",
12787       "41":"y",
12788       "42":"y",
12789       "43":"y"
12790     },
12791     "safari":{
12792       "3.1":"n",
12793       "3.2":"n",
12794       "4":"n",
12795       "5":"n",
12796       "5.1":"n",
12797       "6":"n",
12798       "6.1":"n",
12799       "7":"n",
12800       "7.1":"a #1",
12801       "8":"a #1"
12802     },
12803     "opera":{
12804       "9":"n",
12805       "9.5-9.6":"n",
12806       "10.0-10.1":"n",
12807       "10.5":"n",
12808       "10.6":"y x",
12809       "11":"y x",
12810       "11.1":"y x",
12811       "11.5":"y x",
12812       "11.6":"y x",
12813       "12":"y x",
12814       "12.1":"y x",
12815       "15":"n",
12816       "16":"n",
12817       "17":"n",
12818       "18":"n",
12819       "19":"y",
12820       "20":"y",
12821       "21":"y",
12822       "22":"y",
12823       "23":"y",
12824       "24":"y",
12825       "25":"y",
12826       "26":"y",
12827       "27":"y",
12828       "28":"y",
12829       "29":"y"
12830     },
12831     "ios_saf":{
12832       "3.2":"n",
12833       "4.0-4.1":"n",
12834       "4.2-4.3":"n",
12835       "5.0-5.1":"n",
12836       "6.0-6.1":"n",
12837       "7.0-7.1":"n",
12838       "8":"a #1",
12839       "8.1":"a #1"
12840     },
12841     "op_mini":{
12842       "5.0-8.0":"y x"
12843     },
12844     "android":{
12845       "2.1":"n",
12846       "2.2":"n",
12847       "2.3":"n",
12848       "3":"n",
12849       "4":"n",
12850       "4.1":"n",
12851       "4.2-4.3":"n",
12852       "4.4":"n",
12853       "4.4.3-4.4.4":"y",
12854       "37":"y"
12855     },
12856     "bb":{
12857       "7":"n",
12858       "10":"n"
12859     },
12860     "op_mob":{
12861       "10":"n",
12862       "11":"y x",
12863       "11.1":"y x",
12864       "11.5":"y x",
12865       "12":"y x",
12866       "12.1":"y x",
12867       "24":"y"
12868     },
12869     "and_chr":{
12870       "40":"y"
12871     },
12872     "and_ff":{
12873       "33":"n"
12874     },
12875     "ie_mob":{
12876       "10":"n",
12877       "11":"n"
12878     },
12879     "and_uc":{
12880       "9.9":"n"
12881     }
12882   },
12883   "notes":"",
12884   "notes_by_num":{
12885     "1":"Partial support in Safari refers to support for `object-fit` but not `object-position`."
12886   },
12887   "usage_perc_y":46.87,
12888   "usage_perc_a":6.79,
12889   "ucprefix":false,
12890   "parent":"",
12891   "keywords":"objectfit,objectposition",
12892   "ie_id":"objectfitandobjectposition",
12893   "chrome_id":"5302669702856704",
12894   "shown":true
12895 }
12896 },{}],87:[function(require,module,exports){
12897 module.exports={
12898   "title":"Pointer events",
12899   "description":"This specification integrates various inputs from mice, touchscreens, and pens, making separate implementations no longer necessary and authoring for cross-device pointers easier. Not to be mistaken with the unrelated \"pointer-events\" CSS property.",
12900   "spec":"http://www.w3.org/TR/pointerevents/",
12901   "status":"cr",
12902   "links":[
12903     {
12904       "url":"http://blogs.msdn.com/b/ie/archive/2011/09/20/touch-input-for-ie10-and-metro-style-apps.aspx",
12905       "title":"Implementation of Pointer Events in IE10"
12906     },
12907     {
12908       "url":"http://blogs.msdn.com/b/eternalcoding/archive/2013/01/16/hand-js-a-polyfill-for-supporting-pointer-events-on-every-browser.aspx",
12909       "title":"Hand.js, the polyfill for browsers only supporting Touch Events"
12910     },
12911     {
12912       "url":"http://blogs.msdn.com/b/davrous/archive/2013/02/20/handling-touch-in-your-html5-apps-thanks-to-the-pointer-events-of-ie10-and-windows-8.aspx",
12913       "title":"Article & tutorial"
12914     }
12915   ],
12916   "bugs":[
12917
12918   ],
12919   "categories":[
12920     "DOM",
12921     "JS API"
12922   ],
12923   "stats":{
12924     "ie":{
12925       "5.5":"n",
12926       "6":"n",
12927       "7":"n",
12928       "8":"n",
12929       "9":"n",
12930       "10":"a x",
12931       "11":"y",
12932       "TP":"y"
12933     },
12934     "firefox":{
12935       "2":"n",
12936       "3":"n",
12937       "3.5":"n",
12938       "3.6":"n",
12939       "4":"n",
12940       "5":"n",
12941       "6":"p",
12942       "7":"p",
12943       "8":"p",
12944       "9":"p",
12945       "10":"p",
12946       "11":"p",
12947       "12":"p",
12948       "13":"p",
12949       "14":"p",
12950       "15":"p",
12951       "16":"p",
12952       "17":"p",
12953       "18":"p",
12954       "19":"p",
12955       "20":"p",
12956       "21":"p",
12957       "22":"p",
12958       "23":"p",
12959       "24":"p",
12960       "25":"p",
12961       "26":"p",
12962       "27":"p",
12963       "28":"p",
12964       "29":"p",
12965       "30":"p",
12966       "31":"p",
12967       "32":"p",
12968       "33":"p",
12969       "34":"p",
12970       "35":"p",
12971       "36":"p",
12972       "37":"p",
12973       "38":"p"
12974     },
12975     "chrome":{
12976       "4":"n",
12977       "5":"n",
12978       "6":"n",
12979       "7":"n",
12980       "8":"n",
12981       "9":"n",
12982       "10":"n",
12983       "11":"n",
12984       "12":"n",
12985       "13":"n",
12986       "14":"n",
12987       "15":"n",
12988       "16":"n",
12989       "17":"n",
12990       "18":"n",
12991       "19":"n",
12992       "20":"n",
12993       "21":"n",
12994       "22":"p",
12995       "23":"p",
12996       "24":"p",
12997       "25":"p",
12998       "26":"p",
12999       "27":"p",
13000       "28":"p",
13001       "29":"p",
13002       "30":"p",
13003       "31":"p",
13004       "32":"p",
13005       "33":"p",
13006       "34":"p",
13007       "35":"p",
13008       "36":"p",
13009       "37":"p",
13010       "38":"p",
13011       "39":"p",
13012       "40":"p",
13013       "41":"p",
13014       "42":"p",
13015       "43":"p"
13016     },
13017     "safari":{
13018       "3.1":"n",
13019       "3.2":"n",
13020       "4":"n",
13021       "5":"n",
13022       "5.1":"n",
13023       "6":"n",
13024       "6.1":"u",
13025       "7":"u",
13026       "7.1":"u",
13027       "8":"u"
13028     },
13029     "opera":{
13030       "9":"n",
13031       "9.5-9.6":"n",
13032       "10.0-10.1":"n",
13033       "10.5":"n",
13034       "10.6":"n",
13035       "11":"n",
13036       "11.1":"n",
13037       "11.5":"n",
13038       "11.6":"n",
13039       "12":"n",
13040       "12.1":"n",
13041       "15":"p",
13042       "16":"p",
13043       "17":"p",
13044       "18":"p",
13045       "19":"p",
13046       "20":"p",
13047       "21":"p",
13048       "22":"p",
13049       "23":"p",
13050       "24":"p",
13051       "25":"p",
13052       "26":"p",
13053       "27":"p",
13054       "28":"p",
13055       "29":"p"
13056     },
13057     "ios_saf":{
13058       "3.2":"p",
13059       "4.0-4.1":"p",
13060       "4.2-4.3":"p",
13061       "5.0-5.1":"p",
13062       "6.0-6.1":"p",
13063       "7.0-7.1":"p",
13064       "8":"p",
13065       "8.1":"p"
13066     },
13067     "op_mini":{
13068       "5.0-8.0":"n"
13069     },
13070     "android":{
13071       "2.1":"p",
13072       "2.2":"p",
13073       "2.3":"p",
13074       "3":"p",
13075       "4":"p",
13076       "4.1":"p",
13077       "4.2-4.3":"p",
13078       "4.4":"p",
13079       "4.4.3-4.4.4":"p",
13080       "37":"p"
13081     },
13082     "bb":{
13083       "7":"p",
13084       "10":"p"
13085     },
13086     "op_mob":{
13087       "10":"n",
13088       "11":"p",
13089       "11.1":"p",
13090       "11.5":"p",
13091       "12":"p",
13092       "12.1":"p",
13093       "24":"p"
13094     },
13095     "and_chr":{
13096       "40":"p"
13097     },
13098     "and_ff":{
13099       "33":"p"
13100     },
13101     "ie_mob":{
13102       "10":"a x",
13103       "11":"y"
13104     },
13105     "and_uc":{
13106       "9.9":"p"
13107     }
13108   },
13109   "notes":"Partial support in IE10 refers the lack of pointerenter and pointerleave events. Firefox Nightly provides 'dom.w3c_pointer_events.enabled' option to support this specification starting with version 28.",
13110   "notes_by_num":{
13111
13112   },
13113   "usage_perc_y":8.74,
13114   "usage_perc_a":1.97,
13115   "ucprefix":false,
13116   "parent":"",
13117   "keywords":"pointerdown,pointermove,pointerup,pointercancel,pointerover,pointerout,pointerenter,pointerleave",
13118   "ie_id":"pointerevents",
13119   "chrome_id":"4504699138998272",
13120   "shown":true
13121 }
13122 },{}],88:[function(require,module,exports){
13123 module.exports={
13124   "title":"text-decoration styling",
13125   "description":"Method of defining the type, style and color of lines in the text-decoration property. These can be defined as shorthand (e.g. `text-decoration: line-through dashed blue`) or as single properties (e.g. `text-decoration-color: blue`)",
13126   "spec":"http://www.w3.org/TR/css-text-decor-3/#line-decoration",
13127   "status":"cr",
13128   "links":[
13129     {
13130       "url":"https://developer.mozilla.org/en-US/docs/Web/CSS/text-decoration-style",
13131       "title":"MDN Documentation for text-decoration-style"
13132     },
13133     {
13134       "url":"https://developer.mozilla.org/en-US/docs/Web/CSS/text-decoration-color",
13135       "title":"MDN Documentation for text-decoration-color"
13136     },
13137     {
13138       "url":"https://developer.mozilla.org/en-US/docs/Web/CSS/text-decoration-line",
13139       "title":"MDN Documentation for text-decoration-line"
13140     }
13141   ],
13142   "bugs":[
13143
13144   ],
13145   "categories":[
13146     "CSS3"
13147   ],
13148   "stats":{
13149     "ie":{
13150       "5.5":"n",
13151       "6":"n",
13152       "7":"n",
13153       "8":"n",
13154       "9":"n",
13155       "10":"n",
13156       "11":"n",
13157       "TP":"n"
13158     },
13159     "firefox":{
13160       "2":"n",
13161       "3":"n",
13162       "3.5":"n",
13163       "3.6":"n",
13164       "4":"n",
13165       "5":"n",
13166       "6":"y x",
13167       "7":"y x",
13168       "8":"y x",
13169       "9":"y x",
13170       "10":"y x",
13171       "11":"y x",
13172       "12":"y x",
13173       "13":"y x",
13174       "14":"y x",
13175       "15":"y x",
13176       "16":"y x",
13177       "17":"y x",
13178       "18":"y x",
13179       "19":"y x",
13180       "20":"y x",
13181       "21":"y x",
13182       "22":"y x",
13183       "23":"y x",
13184       "24":"y x",
13185       "25":"y x",
13186       "26":"y x",
13187       "27":"y x",
13188       "28":"y x",
13189       "29":"y x",
13190       "30":"y x",
13191       "31":"y x",
13192       "32":"y x",
13193       "33":"y x",
13194       "34":"y x",
13195       "35":"y x",
13196       "36":"y",
13197       "37":"y",
13198       "38":"y"
13199     },
13200     "chrome":{
13201       "4":"n",
13202       "5":"n",
13203       "6":"n",
13204       "7":"n",
13205       "8":"n",
13206       "9":"n",
13207       "10":"n",
13208       "11":"n",
13209       "12":"n",
13210       "13":"n",
13211       "14":"n",
13212       "15":"n",
13213       "16":"n",
13214       "17":"n",
13215       "18":"n",
13216       "19":"n",
13217       "20":"n",
13218       "21":"n",
13219       "22":"n",
13220       "23":"n",
13221       "24":"n",
13222       "25":"n",
13223       "26":"n x d #1",
13224       "27":"n x d #1",
13225       "28":"n x d #1",
13226       "29":"n x d #1",
13227       "30":"n x d #1",
13228       "31":"n x d #1",
13229       "32":"n x d #1",
13230       "33":"n x d #1",
13231       "34":"n x d #1",
13232       "35":"n x d #1",
13233       "36":"n x d #1",
13234       "37":"n x d #1",
13235       "38":"n x d #1",
13236       "39":"n x d #1",
13237       "40":"n x d #1",
13238       "41":"n x d #1",
13239       "42":"n x d #1",
13240       "43":"n x d #1"
13241     },
13242     "safari":{
13243       "3.1":"n",
13244       "3.2":"n",
13245       "4":"n",
13246       "5":"n",
13247       "5.1":"n",
13248       "6":"n",
13249       "6.1":"n",
13250       "7":"n",
13251       "7.1":"a x #2",
13252       "8":"a x #2"
13253     },
13254     "opera":{
13255       "9":"n",
13256       "9.5-9.6":"n",
13257       "10.0-10.1":"n",
13258       "10.5":"n",
13259       "10.6":"n",
13260       "11":"n",
13261       "11.1":"n",
13262       "11.5":"n",
13263       "11.6":"n",
13264       "12":"n",
13265       "12.1":"n",
13266       "15":"n",
13267       "16":"n",
13268       "17":"n",
13269       "18":"n",
13270       "19":"n",
13271       "20":"n",
13272       "21":"n",
13273       "22":"n",
13274       "23":"n",
13275       "24":"n",
13276       "25":"n",
13277       "26":"n",
13278       "27":"n",
13279       "28":"n",
13280       "29":"n"
13281     },
13282     "ios_saf":{
13283       "3.2":"n",
13284       "4.0-4.1":"n",
13285       "4.2-4.3":"n",
13286       "5.0-5.1":"n",
13287       "6.0-6.1":"n",
13288       "7.0-7.1":"n",
13289       "8":"a x #2",
13290       "8.1":"a x #2"
13291     },
13292     "op_mini":{
13293       "5.0-8.0":"n"
13294     },
13295     "android":{
13296       "2.1":"n",
13297       "2.2":"n",
13298       "2.3":"n",
13299       "3":"n",
13300       "4":"n",
13301       "4.1":"n",
13302       "4.2-4.3":"n",
13303       "4.4":"n",
13304       "4.4.3-4.4.4":"n",
13305       "37":"n"
13306     },
13307     "bb":{
13308       "7":"n",
13309       "10":"n"
13310     },
13311     "op_mob":{
13312       "10":"n",
13313       "11":"n",
13314       "11.1":"n",
13315       "11.5":"n",
13316       "12":"n",
13317       "12.1":"n",
13318       "24":"n"
13319     },
13320     "and_chr":{
13321       "40":"n"
13322     },
13323     "and_ff":{
13324       "33":"y x"
13325     },
13326     "ie_mob":{
13327       "10":"n",
13328       "11":"n"
13329     },
13330     "and_uc":{
13331       "9.9":"n"
13332     }
13333   },
13334   "notes":"All browsers support the CSS2 version of `text-decoration`, which matches only the `text-decoration-line` values (`underline`, etc.)",
13335   "notes_by_num":{
13336     "1":"Enabled in Chrome through the \"experimental Web Platform features\" flag in chrome://flags",
13337     "2":"Partial support in Safari refers to not supporting the text-decoration-style property."
13338   },
13339   "usage_perc_y":11.83,
13340   "usage_perc_a":6.79,
13341   "ucprefix":false,
13342   "parent":"",
13343   "keywords":"text-decoration-line,text-decoration-style,text-decoration-color",
13344   "ie_id":"",
13345   "chrome_id":"",
13346   "shown":true
13347 }
13348 },{}],89:[function(require,module,exports){
13349 module.exports={
13350   "title":"text-emphasis styling",
13351   "description":"Method of using small symbols next to each glyph to emphasize a run of text, commonly used in East Asian languages. The `text-emphasis` shorthand, and its `text-emphasis-style` and `text-emphasis-color` longhands, can be used to apply marks to the text. The `text-emphasis-position` property, which inherits separately, allows setting the emphasis marks' position with respect to the text.",
13352   "spec":"http://www.w3.org/TR/css-text-decor-3/#text-emphasis",
13353   "status":"cr",
13354   "links":[
13355     {
13356       "url":"https://github.com/zmmbreeze/jquery.emphasis/",
13357       "title":"A javascript fallback for CSS3 emphasis mark."
13358     }
13359   ],
13360   "bugs":[
13361     {
13362       "description":"Chrome on Android occasionally has issues rendering emphasis glyphs correctly."
13363     }
13364   ],
13365   "categories":[
13366     "CSS3"
13367   ],
13368   "stats":{
13369     "ie":{
13370       "5.5":"n",
13371       "6":"n",
13372       "7":"n",
13373       "8":"n",
13374       "9":"n",
13375       "10":"n",
13376       "11":"n",
13377       "TP":"n"
13378     },
13379     "firefox":{
13380       "2":"n",
13381       "3":"n",
13382       "3.5":"n",
13383       "3.6":"n",
13384       "4":"n",
13385       "5":"n",
13386       "6":"n",
13387       "7":"n",
13388       "8":"n",
13389       "9":"n",
13390       "10":"n",
13391       "11":"n",
13392       "12":"n",
13393       "13":"n",
13394       "14":"n",
13395       "15":"n",
13396       "16":"n",
13397       "17":"n",
13398       "18":"n",
13399       "19":"n",
13400       "20":"n",
13401       "21":"n",
13402       "22":"n",
13403       "23":"n",
13404       "24":"n",
13405       "25":"n",
13406       "26":"n",
13407       "27":"n",
13408       "28":"n",
13409       "29":"n",
13410       "30":"n",
13411       "31":"n",
13412       "32":"n",
13413       "33":"n",
13414       "34":"n",
13415       "35":"n",
13416       "36":"n",
13417       "37":"n",
13418       "38":"n"
13419     },
13420     "chrome":{
13421       "4":"n",
13422       "5":"n",
13423       "6":"n",
13424       "7":"n",
13425       "8":"n",
13426       "9":"n",
13427       "10":"n",
13428       "11":"n",
13429       "12":"n",
13430       "13":"n",
13431       "14":"n",
13432       "15":"n",
13433       "16":"n",
13434       "17":"n",
13435       "18":"n",
13436       "19":"n",
13437       "20":"n",
13438       "21":"n",
13439       "22":"n",
13440       "23":"n",
13441       "24":"n",
13442       "25":"a x #1",
13443       "26":"a x #1",
13444       "27":"a x #1",
13445       "28":"a x #1",
13446       "29":"a x #1",
13447       "30":"a x #1",
13448       "31":"a x #1",
13449       "32":"a x #1",
13450       "33":"a x #1",
13451       "34":"a x #1",
13452       "35":"a x #1",
13453       "36":"a x #1",
13454       "37":"a x #1",
13455       "38":"a x #1",
13456       "39":"a x #1",
13457       "40":"a x #1",
13458       "41":"a x #1",
13459       "42":"a x #1",
13460       "43":"a x #1"
13461     },
13462     "safari":{
13463       "3.1":"n",
13464       "3.2":"n",
13465       "4":"n",
13466       "5":"n",
13467       "5.1":"n",
13468       "6":"n",
13469       "6.1":"a x #1",
13470       "7":"a x #1",
13471       "7.1":"y",
13472       "8":"y"
13473     },
13474     "opera":{
13475       "9":"n",
13476       "9.5-9.6":"n",
13477       "10.0-10.1":"n",
13478       "10.5":"n",
13479       "10.6":"n",
13480       "11":"n",
13481       "11.1":"n",
13482       "11.5":"n",
13483       "11.6":"n",
13484       "12":"n",
13485       "12.1":"n",
13486       "15":"a x #1",
13487       "16":"a x #1",
13488       "17":"a x #1",
13489       "18":"a x #1",
13490       "19":"a x #1",
13491       "20":"a x #1",
13492       "21":"a x #1",
13493       "22":"a x #1",
13494       "23":"a x #1",
13495       "24":"a x #1",
13496       "25":"a x #1",
13497       "26":"a x #1",
13498       "27":"a x #1",
13499       "28":"a x #1",
13500       "29":"a x #1"
13501     },
13502     "ios_saf":{
13503       "3.2":"n",
13504       "4.0-4.1":"n",
13505       "4.2-4.3":"n",
13506       "5.0-5.1":"n",
13507       "6.0-6.1":"n",
13508       "7.0-7.1":"y",
13509       "8":"y",
13510       "8.1":"y"
13511     },
13512     "op_mini":{
13513       "5.0-8.0":"n"
13514     },
13515     "android":{
13516       "2.1":"n",
13517       "2.2":"n",
13518       "2.3":"n",
13519       "3":"n",
13520       "4":"n",
13521       "4.1":"n",
13522       "4.2-4.3":"n",
13523       "4.4":"a x #1",
13524       "4.4.3-4.4.4":"a x #1",
13525       "37":"a x #1"
13526     },
13527     "bb":{
13528       "7":"u",
13529       "10":"u"
13530     },
13531     "op_mob":{
13532       "10":"n",
13533       "11":"n",
13534       "11.1":"n",
13535       "11.5":"n",
13536       "12":"n",
13537       "12.1":"n",
13538       "24":"a x #1"
13539     },
13540     "and_chr":{
13541       "40":"a x #1"
13542     },
13543     "and_ff":{
13544       "33":"n"
13545     },
13546     "ie_mob":{
13547       "10":"n",
13548       "11":"n"
13549     },
13550     "and_uc":{
13551       "9.9":"a x #1"
13552     }
13553   },
13554   "notes":"Some old webkit browsers (like Chrome 24) support `-webkit-text-emphasis`, but does not support CJK languages and is therefore considered unsupported.",
13555   "notes_by_num":{
13556     "1":"Partial support refers to incorrect support for `-webkit-text-emphasis-position`. These browsers support `over` and `under` as values, but not the added `left` and `right` values required by the spec."
13557   },
13558   "usage_perc_y":9.02,
13559   "usage_perc_a":50.97,
13560   "ucprefix":false,
13561   "parent":"",
13562   "keywords":"text-emphasis,text-emphasis-position,text-emphasis-style,text-emphasis-color",
13563   "ie_id":"",
13564   "chrome_id":"",
13565   "shown":true
13566 }
13567 },{}],90:[function(require,module,exports){
13568 module.exports={
13569   "title":"CSS3 Text-overflow",
13570   "description":"Append ellipsis when text overflows its containing element",
13571   "spec":"http://www.w3.org/TR/css3-ui/#text-overflow0",
13572   "status":"wd",
13573   "links":[
13574     {
13575       "url":"https://github.com/rmorse/AutoEllipsis",
13576       "title":"jQuery polyfill for Firefox"
13577     },
13578     {
13579       "url":"https://developer.mozilla.org/En/CSS/Text-overflow",
13580       "title":"MDN article"
13581     },
13582     {
13583       "url":"http://www.css3files.com/text/",
13584       "title":"Information page"
13585     },
13586     {
13587       "url":"https://raw.github.com/phiggins42/has.js/master/detect/css.js#css-text-overflow",
13588       "title":"has.js test"
13589     },
13590     {
13591       "url":"http://docs.webplatform.org/wiki/css/properties/text-overflow",
13592       "title":"WebPlatform Docs"
13593     }
13594   ],
13595   "bugs":[
13596     {
13597       "description":"Does not work on `select` elements work in Chrome and IE, only Firefox."
13598     },
13599     {
13600       "description":"Some Samsung-based browsers, have a bug with overflowing text when ellipsis is set and if `text-rendering` is not `auto`."
13601     }
13602   ],
13603   "categories":[
13604     "CSS3"
13605   ],
13606   "stats":{
13607     "ie":{
13608       "5.5":"n",
13609       "6":"y",
13610       "7":"y",
13611       "8":"y",
13612       "9":"y",
13613       "10":"y",
13614       "11":"y",
13615       "TP":"y"
13616     },
13617     "firefox":{
13618       "2":"p",
13619       "3":"p",
13620       "3.5":"p",
13621       "3.6":"p",
13622       "4":"p",
13623       "5":"p",
13624       "6":"p",
13625       "7":"y",
13626       "8":"y",
13627       "9":"y",
13628       "10":"y",
13629       "11":"y",
13630       "12":"y",
13631       "13":"y",
13632       "14":"y",
13633       "15":"y",
13634       "16":"y",
13635       "17":"y",
13636       "18":"y",
13637       "19":"y",
13638       "20":"y",
13639       "21":"y",
13640       "22":"y",
13641       "23":"y",
13642       "24":"y",
13643       "25":"y",
13644       "26":"y",
13645       "27":"y",
13646       "28":"y",
13647       "29":"y",
13648       "30":"y",
13649       "31":"y",
13650       "32":"y",
13651       "33":"y",
13652       "34":"y",
13653       "35":"y",
13654       "36":"y",
13655       "37":"y",
13656       "38":"y"
13657     },
13658     "chrome":{
13659       "4":"y",
13660       "5":"y",
13661       "6":"y",
13662       "7":"y",
13663       "8":"y",
13664       "9":"y",
13665       "10":"y",
13666       "11":"y",
13667       "12":"y",
13668       "13":"y",
13669       "14":"y",
13670       "15":"y",
13671       "16":"y",
13672       "17":"y",
13673       "18":"y",
13674       "19":"y",
13675       "20":"y",
13676       "21":"y",
13677       "22":"y",
13678       "23":"y",
13679       "24":"y",
13680       "25":"y",
13681       "26":"y",
13682       "27":"y",
13683       "28":"y",
13684       "29":"y",
13685       "30":"y",
13686       "31":"y",
13687       "32":"y",
13688       "33":"y",
13689       "34":"y",
13690       "35":"y",
13691       "36":"y",
13692       "37":"y",
13693       "38":"y",
13694       "39":"y",
13695       "40":"y",
13696       "41":"y",
13697       "42":"y",
13698       "43":"y"
13699     },
13700     "safari":{
13701       "3.1":"y",
13702       "3.2":"y",
13703       "4":"y",
13704       "5":"y",
13705       "5.1":"y",
13706       "6":"y",
13707       "6.1":"y",
13708       "7":"y",
13709       "7.1":"y",
13710       "8":"y"
13711     },
13712     "opera":{
13713       "9":"y x",
13714       "9.5-9.6":"y x",
13715       "10.0-10.1":"y x",
13716       "10.5":"y x",
13717       "10.6":"y x",
13718       "11":"y",
13719       "11.1":"y",
13720       "11.5":"y",
13721       "11.6":"y",
13722       "12":"y",
13723       "12.1":"y",
13724       "15":"y",
13725       "16":"y",
13726       "17":"y",
13727       "18":"y",
13728       "19":"y",
13729       "20":"y",
13730       "21":"y",
13731       "22":"y",
13732       "23":"y",
13733       "24":"y",
13734       "25":"y",
13735       "26":"y",
13736       "27":"y",
13737       "28":"y",
13738       "29":"y"
13739     },
13740     "ios_saf":{
13741       "3.2":"y",
13742       "4.0-4.1":"y",
13743       "4.2-4.3":"y",
13744       "5.0-5.1":"y",
13745       "6.0-6.1":"y",
13746       "7.0-7.1":"y",
13747       "8":"y",
13748       "8.1":"y"
13749     },
13750     "op_mini":{
13751       "5.0-8.0":"y"
13752     },
13753     "android":{
13754       "2.1":"y",
13755       "2.2":"y",
13756       "2.3":"y",
13757       "3":"y",
13758       "4":"y",
13759       "4.1":"y",
13760       "4.2-4.3":"y",
13761       "4.4":"y",
13762       "4.4.3-4.4.4":"y",
13763       "37":"y"
13764     },
13765     "bb":{
13766       "7":"y",
13767       "10":"y"
13768     },
13769     "op_mob":{
13770       "10":"y x",
13771       "11":"y x",
13772       "11.1":"y x",
13773       "11.5":"y x",
13774       "12":"y x",
13775       "12.1":"y",
13776       "24":"y"
13777     },
13778     "and_chr":{
13779       "40":"y"
13780     },
13781     "and_ff":{
13782       "33":"y"
13783     },
13784     "ie_mob":{
13785       "10":"y",
13786       "11":"y"
13787     },
13788     "and_uc":{
13789       "9.9":"y"
13790     }
13791   },
13792   "notes":"",
13793   "notes_by_num":{
13794
13795   },
13796   "usage_perc_y":96.91,
13797   "usage_perc_a":0,
13798   "ucprefix":false,
13799   "parent":"",
13800   "keywords":"textoverflow,ellipsis",
13801   "ie_id":"",
13802   "chrome_id":"",
13803   "shown":true
13804 }
13805 },{}],91:[function(require,module,exports){
13806 module.exports={
13807   "title":"CSS text-size-adjust",
13808   "description":"On mobile devices, the text-size-adjust CSS property allows Web authors to control if and how the text-inflating algorithm is applied to the textual content of the element it is applied to.",
13809   "spec":"http://dev.w3.org/csswg/css-size-adjust/",
13810   "status":"wd",
13811   "links":[
13812     {
13813       "url":"https://developer.mozilla.org/en-US/docs/Web/CSS/text-size-adjust",
13814       "title":"MDN Docs"
13815     }
13816   ],
13817   "bugs":[
13818     {
13819       "description":"There is a bug in Webkit-based desktop browsers. If -webkit-text-size-adjust is explicitely set to none, Webkit-based desktop browsers, like Chrome or Safari, instead of ignoring the property, will prevent the user to zoom in or out the Web page."
13820     },
13821     {
13822       "description":"If the viewport in IE Phone is set using <meta> element, the value of the CSS text-size-adjust property is ignored."
13823     }
13824   ],
13825   "categories":[
13826     "CSS3"
13827   ],
13828   "stats":{
13829     "ie":{
13830       "5.5":"n",
13831       "6":"n",
13832       "7":"n",
13833       "8":"n",
13834       "9":"n",
13835       "10":"n",
13836       "11":"n",
13837       "TP":"n"
13838     },
13839     "firefox":{
13840       "2":"n",
13841       "3":"n",
13842       "3.5":"n",
13843       "3.6":"n",
13844       "4":"n",
13845       "5":"n",
13846       "6":"n",
13847       "7":"n",
13848       "8":"n",
13849       "9":"n",
13850       "10":"n",
13851       "11":"n",
13852       "12":"n",
13853       "13":"n",
13854       "14":"n",
13855       "15":"n",
13856       "16":"n",
13857       "17":"n",
13858       "18":"n",
13859       "19":"n",
13860       "20":"n",
13861       "21":"n",
13862       "22":"n",
13863       "23":"n",
13864       "24":"n",
13865       "25":"n",
13866       "26":"n",
13867       "27":"n",
13868       "28":"n",
13869       "29":"n",
13870       "30":"n",
13871       "31":"n",
13872       "32":"n",
13873       "33":"n",
13874       "34":"n",
13875       "35":"n",
13876       "36":"n",
13877       "37":"n",
13878       "38":"n"
13879     },
13880     "chrome":{
13881       "4":"n",
13882       "5":"n",
13883       "6":"n",
13884       "7":"n",
13885       "8":"n",
13886       "9":"n",
13887       "10":"n",
13888       "11":"n",
13889       "12":"n",
13890       "13":"n",
13891       "14":"n",
13892       "15":"n",
13893       "16":"n",
13894       "17":"n",
13895       "18":"n",
13896       "19":"n",
13897       "20":"n",
13898       "21":"n",
13899       "22":"n",
13900       "23":"n",
13901       "24":"n",
13902       "25":"n",
13903       "26":"n",
13904       "27":"n",
13905       "28":"n",
13906       "29":"n",
13907       "30":"n",
13908       "31":"n",
13909       "32":"n",
13910       "33":"n",
13911       "34":"n",
13912       "35":"n",
13913       "36":"n",
13914       "37":"n",
13915       "38":"n",
13916       "39":"n",
13917       "40":"n",
13918       "41":"n",
13919       "42":"n",
13920       "43":"n"
13921     },
13922     "safari":{
13923       "3.1":"n",
13924       "3.2":"n",
13925       "4":"n",
13926       "5":"n",
13927       "5.1":"n",
13928       "6":"n",
13929       "6.1":"n",
13930       "7":"n",
13931       "7.1":"n",
13932       "8":"n"
13933     },
13934     "opera":{
13935       "9":"n",
13936       "9.5-9.6":"n",
13937       "10.0-10.1":"n",
13938       "10.5":"n",
13939       "10.6":"n",
13940       "11":"n",
13941       "11.1":"n",
13942       "11.5":"n",
13943       "11.6":"n",
13944       "12":"n",
13945       "12.1":"n",
13946       "15":"n",
13947       "16":"n",
13948       "17":"n",
13949       "18":"n",
13950       "19":"n",
13951       "20":"n",
13952       "21":"n",
13953       "22":"n",
13954       "23":"n",
13955       "24":"n",
13956       "25":"n",
13957       "26":"n",
13958       "27":"n",
13959       "28":"n",
13960       "29":"n"
13961     },
13962     "ios_saf":{
13963       "3.2":"n",
13964       "4.0-4.1":"n",
13965       "4.2-4.3":"n",
13966       "5.0-5.1":"y x",
13967       "6.0-6.1":"y x",
13968       "7.0-7.1":"y x",
13969       "8":"y x",
13970       "8.1":"y x"
13971     },
13972     "op_mini":{
13973       "5.0-8.0":"n"
13974     },
13975     "android":{
13976       "2.1":"n",
13977       "2.2":"n",
13978       "2.3":"n",
13979       "3":"n",
13980       "4":"n",
13981       "4.1":"n",
13982       "4.2-4.3":"n",
13983       "4.4":"n",
13984       "4.4.3-4.4.4":"n",
13985       "37":"n"
13986     },
13987     "bb":{
13988       "7":"n",
13989       "10":"n"
13990     },
13991     "op_mob":{
13992       "10":"n",
13993       "11":"n",
13994       "11.1":"n",
13995       "11.5":"n",
13996       "12":"n",
13997       "12.1":"n",
13998       "24":"n"
13999     },
14000     "and_chr":{
14001       "40":"n"
14002     },
14003     "and_ff":{
14004       "33":"y x"
14005     },
14006     "ie_mob":{
14007       "10":"y x",
14008       "11":"y x"
14009     },
14010     "and_uc":{
14011       "9.9":"y x"
14012     }
14013   },
14014   "notes":"",
14015   "notes_by_num":{
14016
14017   },
14018   "usage_perc_y":12.32,
14019   "usage_perc_a":0,
14020   "ucprefix":false,
14021   "parent":"",
14022   "keywords":"",
14023   "ie_id":"",
14024   "chrome_id":"",
14025   "shown":true
14026 }
14027 },{}],92:[function(require,module,exports){
14028 module.exports={
14029   "title":"CSS3 Transforms",
14030   "description":"Method of transforming an element including rotating, scaling, etc.",
14031   "spec":"http://www.w3.org/TR/css3-2d-transforms/",
14032   "status":"wd",
14033   "links":[
14034     {
14035       "url":"http://www.westciv.com/tools/transforms/",
14036       "title":"Live editor"
14037     },
14038     {
14039       "url":"https://developer.mozilla.org/en/CSS/-moz-transform",
14040       "title":"MDN article"
14041     },
14042     {
14043       "url":"http://www.webresourcesdepot.com/cross-browser-css-transforms-csssandpaper/",
14044       "title":"Workaround script for IE"
14045     },
14046     {
14047       "url":"http://www.css3files.com/transform/",
14048       "title":"Information page"
14049     },
14050     {
14051       "url":"http://www.useragentman.com/IETransformsTranslator/",
14052       "title":"Converter for IE"
14053     },
14054     {
14055       "url":"https://raw.github.com/phiggins42/has.js/master/detect/css.js#css-transform",
14056       "title":"has.js test"
14057     },
14058     {
14059       "url":"http://docs.webplatform.org/wiki/css/transforms/transform",
14060       "title":"WebPlatform Docs"
14061     }
14062   ],
14063   "bugs":[
14064     {
14065       "description":"Scaling transforms in Android 2.3 fails to scale element background images."
14066     },
14067     {
14068       "description":"IE 10 and below does not support CSS transforms on SVG elements (though SVG transform attributes do work)."
14069     },
14070     {
14071       "description":"Transforms may break position:fixed styles of contained elements"
14072     }
14073   ],
14074   "categories":[
14075     "CSS3"
14076   ],
14077   "stats":{
14078     "ie":{
14079       "5.5":"n",
14080       "6":"p",
14081       "7":"p",
14082       "8":"p",
14083       "9":"y x",
14084       "10":"y",
14085       "11":"y",
14086       "TP":"y"
14087     },
14088     "firefox":{
14089       "2":"n",
14090       "3":"n",
14091       "3.5":"y x",
14092       "3.6":"y x",
14093       "4":"y x",
14094       "5":"y x",
14095       "6":"y x",
14096       "7":"y x",
14097       "8":"y x",
14098       "9":"y x",
14099       "10":"y x",
14100       "11":"y x",
14101       "12":"y x",
14102       "13":"y x",
14103       "14":"y x",
14104       "15":"y x",
14105       "16":"y",
14106       "17":"y",
14107       "18":"y",
14108       "19":"y",
14109       "20":"y",
14110       "21":"y",
14111       "22":"y",
14112       "23":"y",
14113       "24":"y",
14114       "25":"y",
14115       "26":"y",
14116       "27":"y",
14117       "28":"y",
14118       "29":"y",
14119       "30":"y",
14120       "31":"y",
14121       "32":"y",
14122       "33":"y",
14123       "34":"y",
14124       "35":"y",
14125       "36":"y",
14126       "37":"y",
14127       "38":"y"
14128     },
14129     "chrome":{
14130       "4":"y x",
14131       "5":"y x",
14132       "6":"y x",
14133       "7":"y x",
14134       "8":"y x",
14135       "9":"y x",
14136       "10":"y x",
14137       "11":"y x",
14138       "12":"y x",
14139       "13":"y x",
14140       "14":"y x",
14141       "15":"y x",
14142       "16":"y x",
14143       "17":"y x",
14144       "18":"y x",
14145       "19":"y x",
14146       "20":"y x",
14147       "21":"y x",
14148       "22":"y x",
14149       "23":"y x",
14150       "24":"y x",
14151       "25":"y x",
14152       "26":"y x",
14153       "27":"y x",
14154       "28":"y x",
14155       "29":"y x",
14156       "30":"y x",
14157       "31":"y x",
14158       "32":"y x",
14159       "33":"y x",
14160       "34":"y x",
14161       "35":"y x",
14162       "36":"y",
14163       "37":"y",
14164       "38":"y",
14165       "39":"y",
14166       "40":"y",
14167       "41":"y",
14168       "42":"y",
14169       "43":"y"
14170     },
14171     "safari":{
14172       "3.1":"y x",
14173       "3.2":"y x",
14174       "4":"y x",
14175       "5":"y x",
14176       "5.1":"y x",
14177       "6":"y x",
14178       "6.1":"y x",
14179       "7":"y x",
14180       "7.1":"y x",
14181       "8":"y x"
14182     },
14183     "opera":{
14184       "9":"n",
14185       "9.5-9.6":"n",
14186       "10.0-10.1":"n",
14187       "10.5":"y x",
14188       "10.6":"y x",
14189       "11":"y x",
14190       "11.1":"y x",
14191       "11.5":"y x",
14192       "11.6":"y x",
14193       "12":"y x",
14194       "12.1":"y",
14195       "15":"y x",
14196       "16":"y x",
14197       "17":"y x",
14198       "18":"y x",
14199       "19":"y x",
14200       "20":"y x",
14201       "21":"y x",
14202       "22":"y x",
14203       "23":"y",
14204       "24":"y",
14205       "25":"y",
14206       "26":"y",
14207       "27":"y",
14208       "28":"y",
14209       "29":"y"
14210     },
14211     "ios_saf":{
14212       "3.2":"y x",
14213       "4.0-4.1":"y x",
14214       "4.2-4.3":"y x",
14215       "5.0-5.1":"y x",
14216       "6.0-6.1":"y x",
14217       "7.0-7.1":"y x",
14218       "8":"y x",
14219       "8.1":"y x"
14220     },
14221     "op_mini":{
14222       "5.0-8.0":"n"
14223     },
14224     "android":{
14225       "2.1":"y x",
14226       "2.2":"y x",
14227       "2.3":"y x",
14228       "3":"y x",
14229       "4":"y x",
14230       "4.1":"y x",
14231       "4.2-4.3":"y x",
14232       "4.4":"y x",
14233       "4.4.3-4.4.4":"y x",
14234       "37":"y"
14235     },
14236     "bb":{
14237       "7":"y x",
14238       "10":"y x"
14239     },
14240     "op_mob":{
14241       "10":"n",
14242       "11":"y",
14243       "11.1":"y",
14244       "11.5":"y",
14245       "12":"y",
14246       "12.1":"y",
14247       "24":"y"
14248     },
14249     "and_chr":{
14250       "40":"y"
14251     },
14252     "and_ff":{
14253       "33":"y"
14254     },
14255     "ie_mob":{
14256       "10":"y",
14257       "11":"y"
14258     },
14259     "and_uc":{
14260       "9.9":"y x"
14261     }
14262   },
14263   "notes":"The scale transform can be emulated in IE < 9 using Microsoft's \"zoom\" extension, others are (not easily) possible using the MS Matrix filter",
14264   "notes_by_num":{
14265
14266   },
14267   "usage_perc_y":89.64,
14268   "usage_perc_a":0,
14269   "ucprefix":false,
14270   "parent":"",
14271   "keywords":"transformation,translate,rotation,rotate,scale,css-transforms",
14272   "ie_id":"transforms",
14273   "chrome_id":"6437640580628480",
14274   "shown":true
14275 }
14276 },{}],93:[function(require,module,exports){
14277 module.exports={
14278   "title":"CSS3 3D Transforms",
14279   "description":"Method of transforming an element in the third dimension using the `transform` property. Includes support for the `perspective` property to set the perspective in z-space and the `backface-visibility` property to toggle display of the reverse side of a 3D-transformed element.",
14280   "spec":"http://www.w3.org/TR/css3-3d-transforms/",
14281   "status":"wd",
14282   "links":[
14283     {
14284       "url":"http://css3.bradshawenterprises.com/flip/",
14285       "title":"Multi-browser demo"
14286     },
14287     {
14288       "url":"http://hacks.mozilla.org/2011/10/css-3d-transformations-in-firefox-nightly/",
14289       "title":"Mozilla hacks article"
14290     },
14291     {
14292       "url":"http://thewebrocks.com/demos/3D-css-tester/",
14293       "title":"3D CSS Tester"
14294     },
14295     {
14296       "url":"https://raw.github.com/phiggins42/has.js/master/detect/css.js#css-transform",
14297       "title":"has.js test"
14298     },
14299     {
14300       "url":"http://docs.webplatform.org/wiki/css/transforms/transform",
14301       "title":"WebPlatform Docs"
14302     },
14303     {
14304       "url":"http://desandro.github.io/3dtransforms/",
14305       "title":"Intro to CSS 3D transforms"
14306     }
14307   ],
14308   "bugs":[
14309     {
14310       "description":"Some configurations of Linux and older Windows machines (those without WebGL support) have trouble with 3D transforms and will treat them as if `perspective` was set as `none`."
14311     },
14312     {
14313       "description":"Firefox on Windows [incorrectly renders plugin content within no-op 3D transforms](https://bugzilla.mozilla.org/show_bug.cgi?id=1048279)."
14314     }
14315   ],
14316   "categories":[
14317     "CSS3"
14318   ],
14319   "stats":{
14320     "ie":{
14321       "5.5":"n",
14322       "6":"n",
14323       "7":"n",
14324       "8":"n",
14325       "9":"n",
14326       "10":"a",
14327       "11":"a",
14328       "TP":"y"
14329     },
14330     "firefox":{
14331       "2":"n",
14332       "3":"n",
14333       "3.5":"n",
14334       "3.6":"n",
14335       "4":"n",
14336       "5":"n",
14337       "6":"n",
14338       "7":"n",
14339       "8":"n",
14340       "9":"n",
14341       "10":"y x",
14342       "11":"y x",
14343       "12":"y x",
14344       "13":"y x",
14345       "14":"y x",
14346       "15":"y x",
14347       "16":"y",
14348       "17":"y",
14349       "18":"y",
14350       "19":"y",
14351       "20":"y",
14352       "21":"y",
14353       "22":"y",
14354       "23":"y",
14355       "24":"y",
14356       "25":"y",
14357       "26":"y",
14358       "27":"y",
14359       "28":"y",
14360       "29":"y",
14361       "30":"y",
14362       "31":"y",
14363       "32":"y",
14364       "33":"y",
14365       "34":"y",
14366       "35":"y",
14367       "36":"y",
14368       "37":"y",
14369       "38":"y"
14370     },
14371     "chrome":{
14372       "4":"n",
14373       "5":"n",
14374       "6":"n",
14375       "7":"n",
14376       "8":"n",
14377       "9":"n",
14378       "10":"n",
14379       "11":"n",
14380       "12":"y x",
14381       "13":"y x",
14382       "14":"y x",
14383       "15":"y x",
14384       "16":"y x",
14385       "17":"y x",
14386       "18":"y x",
14387       "19":"y x",
14388       "20":"y x",
14389       "21":"y x",
14390       "22":"y x",
14391       "23":"y x",
14392       "24":"y x",
14393       "25":"y x",
14394       "26":"y x",
14395       "27":"y x",
14396       "28":"y x",
14397       "29":"y x",
14398       "30":"y x",
14399       "31":"y x",
14400       "32":"y x",
14401       "33":"y x",
14402       "34":"y x",
14403       "35":"y x",
14404       "36":"y",
14405       "37":"y",
14406       "38":"y",
14407       "39":"y",
14408       "40":"y",
14409       "41":"y",
14410       "42":"y",
14411       "43":"y"
14412     },
14413     "safari":{
14414       "3.1":"n",
14415       "3.2":"n",
14416       "4":"y x",
14417       "5":"y x",
14418       "5.1":"y x",
14419       "6":"y x",
14420       "6.1":"y x",
14421       "7":"y x",
14422       "7.1":"y x",
14423       "8":"y x"
14424     },
14425     "opera":{
14426       "9":"n",
14427       "9.5-9.6":"n",
14428       "10.0-10.1":"n",
14429       "10.5":"n",
14430       "10.6":"n",
14431       "11":"n",
14432       "11.1":"n",
14433       "11.5":"n",
14434       "11.6":"n",
14435       "12":"n",
14436       "12.1":"n",
14437       "15":"y x",
14438       "16":"y x",
14439       "17":"y x",
14440       "18":"y x",
14441       "19":"y x",
14442       "20":"y x",
14443       "21":"y x",
14444       "22":"y x",
14445       "23":"y",
14446       "24":"y",
14447       "25":"y",
14448       "26":"y",
14449       "27":"y",
14450       "28":"y",
14451       "29":"y"
14452     },
14453     "ios_saf":{
14454       "3.2":"y x",
14455       "4.0-4.1":"y x",
14456       "4.2-4.3":"y x",
14457       "5.0-5.1":"y x",
14458       "6.0-6.1":"y x",
14459       "7.0-7.1":"y x",
14460       "8":"y x",
14461       "8.1":"y x"
14462     },
14463     "op_mini":{
14464       "5.0-8.0":"n"
14465     },
14466     "android":{
14467       "2.1":"n",
14468       "2.2":"n",
14469       "2.3":"n",
14470       "3":"y x",
14471       "4":"y x",
14472       "4.1":"y x",
14473       "4.2-4.3":"y x",
14474       "4.4":"y x",
14475       "4.4.3-4.4.4":"y x",
14476       "37":"y"
14477     },
14478     "bb":{
14479       "7":"y x",
14480       "10":"y x"
14481     },
14482     "op_mob":{
14483       "10":"n",
14484       "11":"n",
14485       "11.1":"n",
14486       "11.5":"n",
14487       "12":"n",
14488       "12.1":"n",
14489       "24":"y"
14490     },
14491     "and_chr":{
14492       "40":"y"
14493     },
14494     "and_ff":{
14495       "33":"y"
14496     },
14497     "ie_mob":{
14498       "10":"a",
14499       "11":"a"
14500     },
14501     "and_uc":{
14502       "9.9":"y x"
14503     }
14504   },
14505   "notes":"Partial support in IE refers to not supporting [the transform-style: preserve-3d property](http://msdn.microsoft.com/en-us/library/ie/hh673529%28v=vs.85%29.aspx#the_ms_transform_style_property). This prevents nesting 3D transformed elements.",
14506   "notes_by_num":{
14507
14508   },
14509   "usage_perc_y":75.88,
14510   "usage_perc_a":10.71,
14511   "ucprefix":false,
14512   "parent":"",
14513   "keywords":"css 3d,3dtransforms,translate3d,backface visibility,perspective",
14514   "ie_id":"transforms,csstransformspreserve3d",
14515   "chrome_id":"6437640580628480",
14516   "shown":true
14517 }
14518 },{}],94:[function(require,module,exports){
14519 module.exports={
14520   "title":"CSS user-select: none",
14521   "description":"Method of preventing text/element selection using CSS. ",
14522   "spec":"https://developer.mozilla.org/en-US/docs/CSS/user-select",
14523   "status":"unoff",
14524   "links":[
14525     {
14526       "url":"https://developer.mozilla.org/en-US/docs/CSS/user-select",
14527       "title":"MDN article"
14528     },
14529     {
14530       "url":"http://css-tricks.com/almanac/properties/u/user-select/",
14531       "title":"CSS Tricks article"
14532     },
14533     {
14534       "url":"http://msdn.microsoft.com/en-us/library/ie/hh781492(v=vs.85).aspx",
14535       "title":"MSDN Documentation"
14536     }
14537   ],
14538   "bugs":[
14539
14540   ],
14541   "categories":[
14542     "CSS"
14543   ],
14544   "stats":{
14545     "ie":{
14546       "5.5":"n",
14547       "6":"n",
14548       "7":"n",
14549       "8":"n",
14550       "9":"n",
14551       "10":"y x",
14552       "11":"y x",
14553       "TP":"y x"
14554     },
14555     "firefox":{
14556       "2":"y x",
14557       "3":"y x",
14558       "3.5":"y x",
14559       "3.6":"y x",
14560       "4":"y x",
14561       "5":"y x",
14562       "6":"y x",
14563       "7":"y x",
14564       "8":"y x",
14565       "9":"y x",
14566       "10":"y x",
14567       "11":"y x",
14568       "12":"y x",
14569       "13":"y x",
14570       "14":"y x",
14571       "15":"y x",
14572       "16":"y x",
14573       "17":"y x",
14574       "18":"y x",
14575       "19":"y x",
14576       "20":"y x",
14577       "21":"y x",
14578       "22":"y x",
14579       "23":"y x",
14580       "24":"y x",
14581       "25":"y x",
14582       "26":"y x",
14583       "27":"y x",
14584       "28":"y x",
14585       "29":"y x",
14586       "30":"y x",
14587       "31":"y x",
14588       "32":"y x",
14589       "33":"y x",
14590       "34":"y x",
14591       "35":"y x",
14592       "36":"y x",
14593       "37":"y x",
14594       "38":"y x"
14595     },
14596     "chrome":{
14597       "4":"u",
14598       "5":"u",
14599       "6":"y x",
14600       "7":"y x",
14601       "8":"y x",
14602       "9":"y x",
14603       "10":"y x",
14604       "11":"y x",
14605       "12":"y x",
14606       "13":"y x",
14607       "14":"y x",
14608       "15":"y x",
14609       "16":"y x",
14610       "17":"y x",
14611       "18":"y x",
14612       "19":"y x",
14613       "20":"y x",
14614       "21":"y x",
14615       "22":"y x",
14616       "23":"y x",
14617       "24":"y x",
14618       "25":"y x",
14619       "26":"y x",
14620       "27":"y x",
14621       "28":"y x",
14622       "29":"y x",
14623       "30":"y x",
14624       "31":"y x",
14625       "32":"y x",
14626       "33":"y x",
14627       "34":"y x",
14628       "35":"y x",
14629       "36":"y x",
14630       "37":"y x",
14631       "38":"y x",
14632       "39":"y x",
14633       "40":"y x",
14634       "41":"y x",
14635       "42":"y x",
14636       "43":"y x"
14637     },
14638     "safari":{
14639       "3.1":"y x",
14640       "3.2":"y x",
14641       "4":"y x",
14642       "5":"y x",
14643       "5.1":"y x",
14644       "6":"y x",
14645       "6.1":"y x",
14646       "7":"y x",
14647       "7.1":"y x",
14648       "8":"y x"
14649     },
14650     "opera":{
14651       "9":"n",
14652       "9.5-9.6":"n",
14653       "10.0-10.1":"n",
14654       "10.5":"n",
14655       "10.6":"n",
14656       "11":"n",
14657       "11.1":"n",
14658       "11.5":"n",
14659       "11.6":"n",
14660       "12":"n",
14661       "12.1":"n",
14662       "15":"y x",
14663       "16":"y x",
14664       "17":"y x",
14665       "18":"y x",
14666       "19":"y x",
14667       "20":"y x",
14668       "21":"y x",
14669       "22":"y x",
14670       "23":"y x",
14671       "24":"y x",
14672       "25":"y x",
14673       "26":"y x",
14674       "27":"y x",
14675       "28":"y x",
14676       "29":"y x"
14677     },
14678     "ios_saf":{
14679       "3.2":"y x",
14680       "4.0-4.1":"y x",
14681       "4.2-4.3":"y x",
14682       "5.0-5.1":"y x",
14683       "6.0-6.1":"y x",
14684       "7.0-7.1":"y x",
14685       "8":"y x",
14686       "8.1":"y x"
14687     },
14688     "op_mini":{
14689       "5.0-8.0":"n"
14690     },
14691     "android":{
14692       "2.1":"y x",
14693       "2.2":"y x",
14694       "2.3":"y x",
14695       "3":"y x",
14696       "4":"y x",
14697       "4.1":"y x",
14698       "4.2-4.3":"y x",
14699       "4.4":"y x",
14700       "4.4.3-4.4.4":"y x",
14701       "37":"y x"
14702     },
14703     "bb":{
14704       "7":"y x",
14705       "10":"y x"
14706     },
14707     "op_mob":{
14708       "10":"n",
14709       "11":"n",
14710       "11.1":"n",
14711       "11.5":"n",
14712       "12":"n",
14713       "12.1":"n",
14714       "24":"y x"
14715     },
14716     "and_chr":{
14717       "40":"y x"
14718     },
14719     "and_ff":{
14720       "33":"y x"
14721     },
14722     "ie_mob":{
14723       "10":"y x",
14724       "11":"y x"
14725     },
14726     "and_uc":{
14727       "9.9":"y x"
14728     }
14729   },
14730   "notes":"Currently the user-select property does not appear in any W3C specification. Support information here is only for \"none\" value, not others.",
14731   "notes_by_num":{
14732
14733   },
14734   "usage_perc_y":87.2,
14735   "usage_perc_a":0,
14736   "ucprefix":false,
14737   "parent":"",
14738   "keywords":"",
14739   "ie_id":"",
14740   "chrome_id":"",
14741   "shown":true
14742 }
14743 },{}],95:[function(require,module,exports){
14744 //????? Greatest Common Divisor
14745 function GCD(a, b) {
14746   if (b === 0) return a
14747   return GCD(b, a % b)
14748 }
14749
14750 function num2fraction(num) {
14751   if (num === 0) return 0
14752
14753   if (typeof num === 'string') {
14754     num = parseFloat(num)
14755   }
14756
14757
14758   var precision = 100000000 //???
14759   var number = num * precision
14760   var gcd = GCD(number, precision)
14761
14762   //??
14763   var numerator = number / gcd
14764   //??
14765   var denominator = precision / gcd
14766
14767   //??
14768   return numerator + '/' + denominator
14769 }
14770
14771 module.exports = num2fraction
14772
14773
14774 },{}],96:[function(require,module,exports){
14775 "use strict";
14776
14777 var _inherits = function (subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; };
14778
14779 var Container = require("./container");
14780
14781 // CSS at-rule like \93this.keyframes name { }\94.
14782 //
14783 // Can contain declarations (like this.font-face or this.page) ot another rules.
14784 var AtRule = (function (Container) {
14785     function AtRule(defaults) {
14786         this.type = "atrule";
14787         Container.call(this, defaults);
14788     }
14789
14790     _inherits(AtRule, Container);
14791
14792     // Stringify at-rule
14793     AtRule.prototype.stringify = function stringify(builder, semicolon) {
14794         var name = "@" + this.name;
14795         var params = this.params ? this.stringifyRaw("params") : "";
14796
14797         if (typeof this.afterName != "undefined") {
14798             name += this.afterName;
14799         } else if (params) {
14800             name += " ";
14801         }
14802
14803         if (this.nodes) {
14804             this.stringifyBlock(builder, name + params);
14805         } else {
14806             var before = this.style("before");
14807             if (before) builder(before);
14808             var end = (this.between || "") + (semicolon ? ";" : "");
14809             builder(name + params + end, this);
14810         }
14811     };
14812
14813     // Hack to mark, that at-rule contains children
14814     AtRule.prototype.append = function append(child) {
14815         if (!this.nodes) this.nodes = [];
14816         return Container.prototype.append.call(this, child);
14817     };
14818
14819     // Hack to mark, that at-rule contains children
14820     AtRule.prototype.prepend = function prepend(child) {
14821         if (!this.nodes) this.nodes = [];
14822         return Container.prototype.prepend.call(this, child);
14823     };
14824
14825     // Hack to mark, that at-rule contains children
14826     AtRule.prototype.insertBefore = function insertBefore(exist, add) {
14827         if (!this.nodes) this.nodes = [];
14828         return Container.prototype.insertBefore.call(this, exist, add);
14829     };
14830
14831     // Hack to mark, that at-rule contains children
14832     AtRule.prototype.insertAfter = function insertAfter(exist, add) {
14833         if (!this.nodes) this.nodes = [];
14834         return Container.prototype.insertAfter.call(this, exist, add);
14835     };
14836
14837     return AtRule;
14838 })(Container);
14839
14840 module.exports = AtRule;
14841 },{"./container":98}],97:[function(require,module,exports){
14842 "use strict";
14843
14844 var _inherits = function (subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; };
14845
14846 var Node = require("./node");
14847
14848 // CSS comment between declarations or rules
14849 var Comment = (function (Node) {
14850     function Comment(defaults) {
14851         this.type = "comment";
14852         Node.call(this, defaults);
14853     }
14854
14855     _inherits(Comment, Node);
14856
14857     // Stringify declaration
14858     Comment.prototype.stringify = function stringify(builder) {
14859         var before = this.style("before");
14860         if (before) builder(before);
14861         var left = this.style("left", "commentLeft");
14862         var right = this.style("right", "commentRight");
14863         builder("/*" + left + this.text + right + "*/", this);
14864     };
14865
14866     return Comment;
14867 })(Node);
14868
14869 module.exports = Comment;
14870 },{"./node":104}],98:[function(require,module,exports){
14871 "use strict";
14872
14873 var _prototypeProperties = function (child, staticProps, instanceProps) { if (staticProps) Object.defineProperties(child, staticProps); if (instanceProps) Object.defineProperties(child.prototype, instanceProps); };
14874
14875 var _inherits = function (subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; };
14876
14877 var Node = require("./node");
14878 var Comment = require("./comment");
14879 var Declaration = require("./declaration");
14880
14881 // CSS node, that contain another nodes (like at-rules or rules with selectors)
14882 var Container = (function (Node) {
14883     function Container() {
14884         if (Node != null) {
14885             Node.apply(this, arguments);
14886         }
14887     }
14888
14889     _inherits(Container, Node);
14890
14891     // Stringify container children
14892     Container.prototype.stringifyContent = function stringifyContent(builder) {
14893         if (!this.nodes) return;
14894
14895         var i,
14896             last = this.nodes.length - 1;
14897         while (last > 0) {
14898             if (this.nodes[last].type != "comment") break;
14899             last -= 1;
14900         }
14901
14902         var semicolon = this.style("semicolon");
14903         for (i = 0; i < this.nodes.length; i++) {
14904             this.nodes[i].stringify(builder, last != i || semicolon);
14905         }
14906     };
14907
14908     // Stringify node with start (for example, selector) and brackets block
14909     // with child inside
14910     Container.prototype.stringifyBlock = function stringifyBlock(builder, start) {
14911         var before = this.style("before");
14912         if (before) builder(before);
14913
14914         var between = this.style("between", "beforeOpen");
14915         builder(start + between + "{", this, "start");
14916
14917         var after;
14918         if (this.nodes && this.nodes.length) {
14919             this.stringifyContent(builder);
14920             after = this.style("after");
14921         } else {
14922             after = this.style("after", "emptyBody");
14923         }
14924
14925         if (after) builder(after);
14926         builder("}", this, "end");
14927     };
14928
14929     // Add child to end of list without any checks.
14930     // Please, use `append()` method, `push()` is mostly for parser.
14931     Container.prototype.push = function push(child) {
14932         child.parent = this;
14933         this.nodes.push(child);
14934         return this;
14935     };
14936
14937     // Execute `callback` on every child element. First arguments will be child
14938     // node, second will be index.
14939     //
14940     //   css.each( (rule, i) => {
14941     //       console.log(rule.type + ' at ' + i);
14942     //   });
14943     //
14944     // It is safe for add and remove elements to list while iterating:
14945     //
14946     //  css.each( (rule) => {
14947     //      css.insertBefore( rule, addPrefix(rule) );
14948     //      # On next iteration will be next rule, regardless of that
14949     //      # list size was increased
14950     //  });
14951     Container.prototype.each = function each(callback) {
14952         if (!this.lastEach) this.lastEach = 0;
14953         if (!this.indexes) this.indexes = {};
14954
14955         this.lastEach += 1;
14956         var id = this.lastEach;
14957         this.indexes[id] = 0;
14958
14959         if (!this.nodes) return;
14960
14961         var index, result;
14962         while (this.indexes[id] < this.nodes.length) {
14963             index = this.indexes[id];
14964             result = callback(this.nodes[index], index);
14965             if (result === false) break;
14966
14967             this.indexes[id] += 1;
14968         }
14969
14970         delete this.indexes[id];
14971
14972         if (result === false) return false;
14973     };
14974
14975     // Execute callback on every child in all rules inside.
14976     //
14977     // First argument will be child node, second will be index inside parent.
14978     //
14979     //   css.eachInside( (node, i) => {
14980     //       console.log(node.type + ' at ' + i);
14981     //   });
14982     //
14983     // Also as `each` it is safe of insert/remove nodes inside iterating.
14984     Container.prototype.eachInside = function eachInside(callback) {
14985         return this.each(function (child, i) {
14986             var result = callback(child, i);
14987
14988             if (result !== false && child.eachInside) {
14989                 result = child.eachInside(callback);
14990             }
14991
14992             if (result === false) return result;
14993         });
14994     };
14995
14996     // Execute callback on every declaration in all rules inside.
14997     // It will goes inside at-rules recursivelly.
14998     //
14999     // First argument will be declaration node, second will be index inside
15000     // parent rule.
15001     //
15002     //   css.eachDecl( (decl, i) => {
15003     //       console.log(decl.prop + ' in ' + decl.parent.selector + ':' + i);
15004     //   });
15005     //
15006     // Also as `each` it is safe of insert/remove nodes inside iterating.
15007     //
15008     // You can filter declrataion by property name:
15009     //
15010     //   css.eachDecl('background', (decl) => { });
15011     Container.prototype.eachDecl = function eachDecl(prop, callback) {
15012         if (!callback) {
15013             callback = prop;
15014             return this.eachInside(function (child, i) {
15015                 if (child.type == "decl") {
15016                     var result = callback(child, i);
15017                     if (result === false) return result;
15018                 }
15019             });
15020         } else if (prop instanceof RegExp) {
15021             return this.eachInside(function (child, i) {
15022                 if (child.type == "decl" && prop.test(child.prop)) {
15023                     var result = callback(child, i);
15024                     if (result === false) return result;
15025                 }
15026             });
15027         } else {
15028             return this.eachInside(function (child, i) {
15029                 if (child.type == "decl" && child.prop == prop) {
15030                     var result = callback(child, i);
15031                     if (result === false) return result;
15032                 }
15033             });
15034         }
15035     };
15036
15037     // Execute `callback` on every rule in conatiner and inside child at-rules.
15038     //
15039     // First argument will be rule node, second will be index inside parent.
15040     //
15041     //   css.eachRule( (rule, i) => {
15042     //       if ( parent.type == 'atrule' ) {
15043     //           console.log(rule.selector + ' in ' + rule.parent.name);
15044     //       } else {
15045     //           console.log(rule.selector + ' at ' + i);
15046     //       }
15047     //   });
15048     Container.prototype.eachRule = function eachRule(callback) {
15049         return this.eachInside(function (child, i) {
15050             if (child.type == "rule") {
15051                 var result = callback(child, i);
15052                 if (result === false) return result;
15053             }
15054         });
15055     };
15056
15057     // Execute `callback` on every at-rule in conatiner and inside at-rules.
15058     //
15059     // First argument will be at-rule node, second will be index inside parent.
15060     //
15061     //   css.eachAtRule( (atrule, parent, i) => {
15062     //       if ( parent.type == 'atrule' ) {
15063     //           console.log(atrule.name + ' in ' + atrule.parent.name);
15064     //       } else {
15065     //           console.log(atrule.name + ' at ' + i);
15066     //       }
15067     //   });
15068     //
15069     // You can filter at-rules by name:
15070     //
15071     //   css.eachAtRule('keyframes', (atrule) => { });
15072     Container.prototype.eachAtRule = function eachAtRule(name, callback) {
15073         if (!callback) {
15074             callback = name;
15075             return this.eachInside(function (child, i) {
15076                 if (child.type == "atrule") {
15077                     var result = callback(child, i);
15078                     if (result === false) return result;
15079                 }
15080             });
15081         } else if (name instanceof RegExp) {
15082             return this.eachInside(function (child, i) {
15083                 if (child.type == "atrule" && name.test(child.name)) {
15084                     var result = callback(child, i);
15085                     if (result === false) return result;
15086                 }
15087             });
15088         } else {
15089             return this.eachInside(function (child, i) {
15090                 if (child.type == "atrule" && child.name == name) {
15091                     var result = callback(child, i);
15092                     if (result === false) return result;
15093                 }
15094             });
15095         }
15096     };
15097
15098     // Execute callback on every block comment (only between rules
15099     // and declarations, not inside selectors and values) in all rules inside.
15100     //
15101     // First argument will be comment node, second will be index inside
15102     // parent rule.
15103     //
15104     //   css.eachComment( (comment, i) => {
15105     //       console.log(comment.content + ' at ' + i);
15106     //   });
15107     //
15108     // Also as `each` it is safe of insert/remove nodes inside iterating.
15109     Container.prototype.eachComment = function eachComment(callback) {
15110         return this.eachInside(function (child, i) {
15111             if (child.type == "comment") {
15112                 var result = callback(child, i);
15113                 if (result === false) return result;
15114             }
15115         });
15116     };
15117
15118     // Add child to container.
15119     //
15120     //   css.append(rule);
15121     //
15122     // You can add declaration by hash:
15123     //
15124     //   rule.append({ prop: 'color', value: 'black' });
15125     Container.prototype.append = function append(child) {
15126         var nodes = this.normalize(child, this.last);
15127         for (var _iterator = nodes, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
15128             var node;
15129             if (_isArray) {
15130                 if (_i >= _iterator.length) break;
15131                 node = _iterator[_i++];
15132             } else {
15133                 _i = _iterator.next();
15134                 if (_i.done) break;
15135                 node = _i.value;
15136             }
15137             this.nodes.push(node);
15138         }
15139
15140         return this;
15141     };
15142
15143     // Add child to beginning of container
15144     //
15145     //   css.prepend(rule);
15146     //
15147     // You can add declaration by hash:
15148     //
15149     //   rule.prepend({ prop: 'color', value: 'black' });
15150     Container.prototype.prepend = function prepend(child) {
15151         var nodes = this.normalize(child, this.first, "prepend").reverse();
15152         for (var _iterator = nodes, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
15153             var node;
15154             if (_isArray) {
15155                 if (_i >= _iterator.length) break;
15156                 node = _iterator[_i++];
15157             } else {
15158                 _i = _iterator.next();
15159                 if (_i.done) break;
15160                 node = _i.value;
15161             }
15162             this.nodes.unshift(node);
15163         }
15164
15165         for (var id in this.indexes) {
15166             this.indexes[id] = this.indexes[id] + nodes.length;
15167         }
15168
15169         return this;
15170     };
15171
15172     // Insert new `added` child before `exist`.
15173     // You can set node object or node index (it will be faster) in `exist`.
15174     //
15175     //   css.insertAfter(1, rule);
15176     //
15177     // You can add declaration by hash:
15178     //
15179     //   rule.insertBefore(1, { prop: 'color', value: 'black' });
15180     Container.prototype.insertBefore = function insertBefore(exist, add) {
15181         exist = this.index(exist);
15182
15183         var type = exist === 0 ? "prepend" : false;
15184         var nodes = this.normalize(add, this.nodes[exist], type).reverse();
15185         for (var _iterator = nodes, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
15186             var node;
15187             if (_isArray) {
15188                 if (_i >= _iterator.length) break;
15189                 node = _iterator[_i++];
15190             } else {
15191                 _i = _iterator.next();
15192                 if (_i.done) break;
15193                 node = _i.value;
15194             }
15195             this.nodes.splice(exist, 0, node);
15196         }
15197
15198         var index;
15199         for (var id in this.indexes) {
15200             index = this.indexes[id];
15201             if (exist <= index) {
15202                 this.indexes[id] = index + nodes.length;
15203             }
15204         }
15205
15206         return this;
15207     };
15208
15209     // Insert new `added` child after `exist`.
15210     // You can set node object or node index (it will be faster) in `exist`.
15211     //
15212     //   css.insertAfter(1, rule);
15213     //
15214     // You can add declaration by hash:
15215     //
15216     //   rule.insertAfter(1, { prop: 'color', value: 'black' });
15217     Container.prototype.insertAfter = function insertAfter(exist, add) {
15218         exist = this.index(exist);
15219
15220         var nodes = this.normalize(add, this.nodes[exist]).reverse();
15221         for (var _iterator = nodes, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
15222             var node;
15223             if (_isArray) {
15224                 if (_i >= _iterator.length) break;
15225                 node = _iterator[_i++];
15226             } else {
15227                 _i = _iterator.next();
15228                 if (_i.done) break;
15229                 node = _i.value;
15230             }
15231             this.nodes.splice(exist + 1, 0, node);
15232         }
15233
15234         var index;
15235         for (var id in this.indexes) {
15236             index = this.indexes[id];
15237             if (exist < index) {
15238                 this.indexes[id] = index + nodes.length;
15239             }
15240         }
15241
15242         return this;
15243     };
15244
15245     // Remove `child` by index or node.
15246     //
15247     //   css.remove(2);
15248     Container.prototype.remove = function remove(child) {
15249         child = this.index(child);
15250         this.nodes[child].parent = undefined;
15251         this.nodes.splice(child, 1);
15252
15253         var index;
15254         for (var id in this.indexes) {
15255             index = this.indexes[id];
15256             if (index >= child) {
15257                 this.indexes[id] = index - 1;
15258             }
15259         }
15260
15261         return this;
15262     };
15263
15264     // Remove all children in node.
15265     //
15266     //   css.removeAll();
15267     Container.prototype.removeAll = function removeAll() {
15268         for (var _iterator = this.nodes, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
15269             var node;
15270             if (_isArray) {
15271                 if (_i >= _iterator.length) break;
15272                 node = _iterator[_i++];
15273             } else {
15274                 _i = _iterator.next();
15275                 if (_i.done) break;
15276                 node = _i.value;
15277             }
15278             node.parent = undefined;
15279         }
15280
15281         this.nodes = [];
15282         return this;
15283     };
15284
15285     // Recursivelly check all declarations inside node and replace
15286     // `regexp` by `callback`.
15287     //
15288     //   css.replaceValues('black', '#000');
15289     //
15290     // Argumets `regexp` and `callback` is same as in `String#replace()`.
15291     //
15292     // You can speed up checks by `props` and `fast` options:
15293     //
15294     //   css.replaceValues(/\d+rem/, { fast: 'rem', props: ['width'] },
15295     //       function (str) {
15296     //           return (14 * parseInt(str)) + 'px';
15297     //       })
15298     Container.prototype.replaceValues = function replaceValues(regexp, opts, callback) {
15299         if (!callback) {
15300             callback = opts;
15301             opts = {};
15302         }
15303
15304         this.eachDecl(function (decl) {
15305             if (opts.props && opts.props.indexOf(decl.prop) == -1) return;
15306             if (opts.fast && decl.value.indexOf(opts.fast) == -1) return;
15307
15308             decl.value = decl.value.replace(regexp, callback);
15309         });
15310
15311         return this;
15312     };
15313
15314     // Return true if all nodes return true in `condition`.
15315     // Just shorcut for `nodes.every`.
15316     Container.prototype.every = function every(condition) {
15317         return this.nodes.every(condition);
15318     };
15319
15320     // Return true if one or more nodes return true in `condition`.
15321     // Just shorcut for `nodes.some`.
15322     Container.prototype.some = function some(condition) {
15323         return this.nodes.some(condition);
15324     };
15325
15326     // Return index of child
15327     Container.prototype.index = function index(child) {
15328         if (typeof child == "number") {
15329             return child;
15330         } else {
15331             return this.nodes.indexOf(child);
15332         }
15333     };
15334
15335     // Normalize child before insert. Copy before from `sample`.
15336     Container.prototype.normalize = function normalize(nodes, sample) {
15337         var _this = this;
15338         if (!Array.isArray(nodes)) {
15339             if (nodes.type == "root") {
15340                 nodes = nodes.nodes;
15341             } else if (nodes.type) {
15342                 nodes = [nodes];
15343             } else if (nodes.prop) {
15344                 nodes = [new Declaration(nodes)];
15345             } else if (nodes.selector) {
15346                 var Rule = require("./rule");
15347                 nodes = [new Rule(nodes)];
15348             } else if (nodes.name) {
15349                 var AtRule = require("./at-rule");
15350                 nodes = [new AtRule(nodes)];
15351             } else if (nodes.text) {
15352                 nodes = [new Comment(nodes)];
15353             }
15354         }
15355
15356         var processed = nodes.map(function (child) {
15357             if (child.parent) child = child.clone();
15358             if (typeof child.before == "undefined") {
15359                 if (sample && typeof sample.before != "undefined") {
15360                     child.before = sample.before.replace(/[^\s]/g, "");
15361                 }
15362             }
15363             child.parent = _this;
15364             return child;
15365         });
15366
15367         return processed;
15368     };
15369
15370     _prototypeProperties(Container, null, {
15371         first: {
15372
15373             // Shortcut to get first child
15374             get: function () {
15375                 if (!this.nodes) return undefined;
15376                 return this.nodes[0];
15377             },
15378             enumerable: true,
15379             configurable: true
15380         },
15381         last: {
15382
15383             // Shortcut to get first child
15384             get: function () {
15385                 if (!this.nodes) return undefined;
15386                 return this.nodes[this.nodes.length - 1];
15387             },
15388             enumerable: true,
15389             configurable: true
15390         }
15391     });
15392
15393     return Container;
15394 })(Node);
15395
15396 module.exports = Container;
15397 },{"./at-rule":96,"./comment":97,"./declaration":100,"./node":104,"./rule":111}],99:[function(require,module,exports){
15398 (function (process){
15399 "use strict";
15400
15401 var _inherits = function (subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; };
15402
15403 var PreviousMap = require("./previous-map");
15404
15405 var path = require("path");
15406
15407 // Error while CSS parsing
15408 var CssSyntaxError = (function (SyntaxError) {
15409     function CssSyntaxError(message, line, column, source, file) {
15410         this.reason = message;
15411
15412         this.message = file ? file : "<css input>";
15413         if (typeof line != "undefined" && typeof column != "undefined") {
15414             this.line = line;
15415             this.column = column;
15416             this.message += ":" + line + ":" + column + ": " + message;
15417         } else {
15418             this.message += ": " + message;
15419         }
15420
15421         if (file) this.file = file;
15422         if (source) this.source = source;
15423
15424         if (Error.captureStackTrace) {
15425             Error.captureStackTrace(this, CssSyntaxError);
15426         }
15427     }
15428
15429     _inherits(CssSyntaxError, SyntaxError);
15430
15431     // Return source of broken lines
15432     CssSyntaxError.prototype.highlight = function highlight(color) {
15433         var num = this.line - 1;
15434         var lines = this.source.split("\n");
15435
15436         var prev = num > 0 ? lines[num - 1] + "\n" : "";
15437         var broken = lines[num];
15438         var next = num < lines.length - 1 ? "\n" + lines[num + 1] : "";
15439
15440         var mark = "\n";
15441         for (var i = 0; i < this.column - 1; i++) {
15442             mark += " ";
15443         }
15444
15445         if (typeof color == "undefined" && typeof process != "undefined") {
15446             if (process.stdout && process.env) {
15447                 color = process.stdout.isTTY && !process.env.NODE_DISABLE_COLORS;
15448             }
15449         }
15450
15451         if (color) {
15452             mark += "\u001b[1;31m^\u001b[0m";
15453         } else {
15454             mark += "^";
15455         }
15456
15457         return prev + broken + mark + next;
15458     };
15459
15460     CssSyntaxError.prototype.setMozillaProps = function setMozillaProps() {
15461         var sample = Error.call(this, message);
15462         if (sample.columnNumber) this.columnNumber = this.column;
15463         if (sample.description) this.description = this.message;
15464         if (sample.lineNumber) this.lineNumber = this.line;
15465         if (sample.fileName) this.fileName = this.file;
15466     };
15467
15468     CssSyntaxError.prototype.toString = function toString() {
15469         var text = this.message;
15470         if (this.source) text += "\n" + this.highlight();
15471         return this.name + ": " + text;
15472     };
15473
15474     return CssSyntaxError;
15475 })(SyntaxError);
15476
15477 CssSyntaxError.prototype.name = "CssSyntaxError";
15478
15479 module.exports = CssSyntaxError;
15480 }).call(this,require('_process'))
15481 },{"./previous-map":108,"_process":54,"path":53}],100:[function(require,module,exports){
15482 "use strict";
15483
15484 var _inherits = function (subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; };
15485
15486 var Node = require("./node");
15487 var vendor = require("./vendor");
15488
15489 // CSS declaration like \93color: black\94 in rules
15490 var Declaration = (function (Node) {
15491     function Declaration(defaults) {
15492         this.type = "decl";
15493         Node.call(this, defaults);
15494     }
15495
15496     _inherits(Declaration, Node);
15497
15498     // Stringify declaration
15499     Declaration.prototype.stringify = function stringify(builder, semicolon) {
15500         var before = this.style("before");
15501         if (before) builder(before);
15502
15503         var between = this.style("between", "colon");
15504         var string = this.prop + between + this.stringifyRaw("value");
15505
15506         if (this.important) {
15507             string += this._important || " !important";
15508         }
15509
15510         if (semicolon) string += ";";
15511         builder(string, this);
15512     };
15513
15514     return Declaration;
15515 })(Node);
15516
15517 module.exports = Declaration;
15518 },{"./node":104,"./vendor":113}],101:[function(require,module,exports){
15519 "use strict";
15520
15521 var CssSyntaxError = require("./css-syntax-error");
15522 var PreviousMap = require("./previous-map");
15523 var Parser = require("./parser");
15524
15525 var path = require("path");
15526
15527 var sequence = 0;
15528
15529 var Input = (function () {
15530     function Input(css) {
15531         var opts = arguments[1] === undefined ? {} : arguments[1];
15532         this.css = css.toString();
15533
15534         if (this.css[0] == "?" || this.css[0] == "?") {
15535             this.css = this.css.slice(1);
15536         }
15537
15538         this.safe = !!opts.safe;
15539
15540         if (opts.from) this.file = path.resolve(opts.from);
15541
15542         var map = new PreviousMap(this.css, opts, this.id);
15543         if (map.text) {
15544             this.map = map;
15545             var file = map.consumer().file;
15546             if (!this.file && file) this.file = this.mapResolve(file);
15547         }
15548
15549         if (this.file) {
15550             this.from = this.file;
15551         } else {
15552             sequence += 1;
15553             this.id = "<input css " + sequence + ">";
15554             this.from = this.id;
15555         }
15556         if (this.map) this.map.file = this.from;
15557     }
15558
15559     // Throw syntax error from this input
15560     Input.prototype.error = function error(message, line, column) {
15561         var error = new CssSyntaxError(message);
15562
15563         var origin = this.origin(line, column);
15564         if (origin) {
15565             error = new CssSyntaxError(message, origin.line, origin.column, origin.source, origin.file);
15566
15567             error.generated = {
15568                 line: line,
15569                 column: column,
15570                 source: this.css
15571             };
15572             if (this.file) error.generated.file = this.file;
15573         } else {
15574             error = new CssSyntaxError(message, line, column, this.css, this.file);
15575         }
15576
15577         return error;
15578     };
15579
15580     // Get origin position of code if source map was given
15581     Input.prototype.origin = function origin(line, column) {
15582         if (!this.map) return false;
15583         var consumer = this.map.consumer();
15584
15585         var from = consumer.originalPositionFor({ line: line, column: column });
15586         if (!from.source) return false;
15587
15588         var result = {
15589             file: this.mapResolve(from.source),
15590             line: from.line,
15591             column: from.column
15592         };
15593
15594         var source = consumer.sourceContentFor(result.file);
15595         if (source) result.source = source;
15596
15597         return result;
15598     };
15599
15600     // Return path relative from source map root
15601     Input.prototype.mapResolve = function mapResolve(file) {
15602         return path.resolve(this.map.consumer().sourceRoot || ".", file);
15603     };
15604
15605     return Input;
15606 })();
15607
15608 module.exports = Input;
15609 },{"./css-syntax-error":99,"./parser":106,"./previous-map":108,"path":53}],102:[function(require,module,exports){
15610 "use strict";
15611
15612 // Methods to parse list and split it to array
15613 var list = {
15614
15615     // Split string to array by separator symbols with function and inside strings
15616     // cheching
15617     split: function (string, separators, last) {
15618         var array = [];
15619         var current = "";
15620         var split = false;
15621
15622         var func = 0;
15623         var quote = false;
15624         var escape = false;
15625
15626         for (var i = 0; i < string.length; i++) {
15627             var letter = string[i];
15628
15629             if (quote) {
15630                 if (escape) {
15631                     escape = false;
15632                 } else if (letter == "\\") {
15633                     escape = true;
15634                 } else if (letter == quote) {
15635                     quote = false;
15636                 }
15637             } else if (letter == "\"" || letter == "'") {
15638                 quote = letter;
15639             } else if (letter == "(") {
15640                 func += 1;
15641             } else if (letter == ")") {
15642                 if (func > 0) func -= 1;
15643             } else if (func === 0) {
15644                 for (var j = 0; j < separators.length; j++) {
15645                     if (letter == separators[j]) split = true;
15646                 }
15647             }
15648
15649             if (split) {
15650                 if (current !== "") array.push(current.trim());
15651                 current = "";
15652                 split = false;
15653             } else {
15654                 current += letter;
15655             }
15656         }
15657
15658         if (last || current !== "") array.push(current.trim());
15659         return array;
15660     },
15661
15662     // Split list devided by space:
15663     //
15664     //   list.space('a b') #=> ['a', 'b']
15665     //
15666     // It check for fuction and strings:
15667     //
15668     //   list.space('calc(1px + 1em) "b c"') #=> ['calc(1px + 1em)', '"b c"']
15669     space: function (string) {
15670         return this.split(string, [" ", "\n", "\t"]);
15671     },
15672
15673     // Split list devided by comma
15674     //
15675     //   list.comma('a, b') #=> ['a', 'b']
15676     //
15677     // It check for fuction and strings:
15678     //
15679     //   list.comma('rgba(0, 0, 0, 0) white') #=> ['rgba(0, 0, 0, 0)', '"white"']
15680     comma: function (string) {
15681         return this.split(string, [","], true);
15682     }
15683
15684 };
15685
15686 module.exports = list;
15687 },{}],103:[function(require,module,exports){
15688 "use strict";
15689
15690 var Result = require("./result");
15691
15692 var mozilla = require("source-map");
15693 var Base64 = require("js-base64").Base64;
15694 var path = require("path");
15695
15696 // All tools to generate source maps
15697 var MapGenerator = (function () {
15698     function MapGenerator(root, opts) {
15699         this.root = root;
15700         this.opts = opts;
15701         this.mapOpts = opts.map || {};
15702     }
15703
15704     // Should map be generated
15705     MapGenerator.prototype.isMap = function isMap() {
15706         if (typeof this.opts.map != "undefined") {
15707             return !!this.opts.map;
15708         } else {
15709             return this.previous().length > 0;
15710         }
15711     };
15712
15713     // Return source map arrays from previous compilation step (like Sass)
15714     MapGenerator.prototype.previous = function previous() {
15715         var _this = this;
15716         if (!this.previousMaps) {
15717             this.previousMaps = [];
15718             this.root.eachInside(function (node) {
15719                 if (node.source && node.source.input.map) {
15720                     var map = node.source.input.map;
15721                     if (_this.previousMaps.indexOf(map) == -1) {
15722                         _this.previousMaps.push(map);
15723                     }
15724                 }
15725             });
15726         }
15727
15728         return this.previousMaps;
15729     };
15730
15731     // Should we inline source map to annotation comment
15732     MapGenerator.prototype.isInline = function isInline() {
15733         if (typeof this.mapOpts.inline != "undefined") {
15734             return this.mapOpts.inline;
15735         }
15736
15737         var annotation = this.mapOpts.annotation;
15738         if (typeof annotation != "undefined" && annotation !== true) {
15739             return false;
15740         }
15741
15742         if (this.previous().length) {
15743             return this.previous().some(function (i) {
15744                 return i.inline;
15745             });
15746         } else {
15747             return true;
15748         }
15749     };
15750
15751     // Should we set sourcesContent
15752     MapGenerator.prototype.isSourcesContent = function isSourcesContent() {
15753         if (typeof this.mapOpts.sourcesContent != "undefined") {
15754             return this.mapOpts.sourcesContent;
15755         }
15756         if (this.previous().length) {
15757             return this.previous().some(function (i) {
15758                 return i.withContent();
15759             });
15760         } else {
15761             return true;
15762         }
15763     };
15764
15765     // Clear source map annotation comment
15766     MapGenerator.prototype.clearAnnotation = function clearAnnotation() {
15767         if (this.mapOpts.annotation === false) return;
15768
15769         var node;
15770         for (var i = this.root.nodes.length - 1; i >= 0; i--) {
15771             node = this.root.nodes[i];
15772             if (node.type != "comment") continue;
15773             if (node.text.match(/^# sourceMappingURL=/)) {
15774                 this.root.remove(i);
15775                 return;
15776             }
15777         }
15778     };
15779
15780     // Set origin CSS content
15781     MapGenerator.prototype.setSourcesContent = function setSourcesContent() {
15782         var _this = this;
15783         var already = {};
15784         this.root.eachInside(function (node) {
15785             if (node.source) {
15786                 var from = node.source.input.from;
15787                 if (from && !already[from]) {
15788                     already[from] = true;
15789                     var relative = _this.relative(from);
15790                     _this.map.setSourceContent(relative, node.source.input.css);
15791                 }
15792             }
15793         });
15794     };
15795
15796     // Apply source map from previous compilation step (like Sass)
15797     MapGenerator.prototype.applyPrevMaps = function applyPrevMaps() {
15798         for (var _iterator = this.previous(), _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
15799             var prev;
15800             if (_isArray) {
15801                 if (_i >= _iterator.length) break;
15802                 prev = _iterator[_i++];
15803             } else {
15804                 _i = _iterator.next();
15805                 if (_i.done) break;
15806                 prev = _i.value;
15807             }
15808             var from = this.relative(prev.file);
15809             var root = prev.root || path.dirname(prev.file);
15810             var map;
15811
15812             if (this.mapOpts.sourcesContent === false) {
15813                 map = new mozilla.SourceMapConsumer(prev.text);
15814                 map.sourcesContent = map.sourcesContent.map(function (i) {
15815                     return null;
15816                 });
15817             } else {
15818                 map = prev.consumer();
15819             }
15820
15821             this.map.applySourceMap(map, from, this.relative(root));
15822         }
15823     };
15824
15825     // Should we add annotation comment
15826     MapGenerator.prototype.isAnnotation = function isAnnotation() {
15827         if (this.isInline()) {
15828             return true;
15829         } else if (typeof this.mapOpts.annotation != "undefined") {
15830             return this.mapOpts.annotation;
15831         } else if (this.previous().length) {
15832             return this.previous().some(function (i) {
15833                 return i.annotation;
15834             });
15835         } else {
15836             return true;
15837         }
15838     };
15839
15840     // Add source map annotation comment if it is needed
15841     MapGenerator.prototype.addAnnotation = function addAnnotation() {
15842         var content;
15843
15844         if (this.isInline()) {
15845             content = "data:application/json;base64," + Base64.encode(this.map.toString());
15846         } else if (typeof this.mapOpts.annotation == "string") {
15847             content = this.mapOpts.annotation;
15848         } else {
15849             content = this.outputFile() + ".map";
15850         }
15851
15852         this.css += "\n/*# sourceMappingURL=" + content + " */";
15853     };
15854
15855     // Return output CSS file path
15856     MapGenerator.prototype.outputFile = function outputFile() {
15857         if (this.opts.to) {
15858             return this.relative(this.opts.to);
15859         } else if (this.opts.from) {
15860             return this.relative(this.opts.from);
15861         } else {
15862             return "to.css";
15863         }
15864     };
15865
15866     // Return Result object with map
15867     MapGenerator.prototype.generateMap = function generateMap() {
15868         this.stringify();
15869         if (this.isSourcesContent()) this.setSourcesContent();
15870         if (this.previous().length > 0) this.applyPrevMaps();
15871         if (this.isAnnotation()) this.addAnnotation();
15872
15873         if (this.isInline()) {
15874             return [this.css];
15875         } else {
15876             return [this.css, this.map];
15877         }
15878     };
15879
15880     // Return path relative from output CSS file
15881     MapGenerator.prototype.relative = function relative(file) {
15882         var from = this.opts.to ? path.dirname(this.opts.to) : ".";
15883
15884         if (typeof this.mapOpts.annotation == "string") {
15885             from = path.dirname(path.resolve(from, this.mapOpts.annotation));
15886         }
15887
15888         file = path.relative(from, file);
15889         if (path.sep == "\\") {
15890             return file.replace(/\\/g, "/");
15891         } else {
15892             return file;
15893         }
15894     };
15895
15896     // Return path of node source for map
15897     MapGenerator.prototype.sourcePath = function sourcePath(node) {
15898         return this.relative(node.source.input.from);
15899     };
15900
15901     // Return CSS string and source map
15902     MapGenerator.prototype.stringify = function stringify() {
15903         var _this = this;
15904         this.css = "";
15905         this.map = new mozilla.SourceMapGenerator({ file: this.outputFile() });
15906
15907         var line = 1;
15908         var column = 1;
15909
15910         var lines, last;
15911         var builder = function (str, node, type) {
15912             _this.css += str;
15913
15914             if (node && node.source && node.source.start && type != "end") {
15915                 _this.map.addMapping({
15916                     source: _this.sourcePath(node),
15917                     original: {
15918                         line: node.source.start.line,
15919                         column: node.source.start.column - 1
15920                     },
15921                     generated: {
15922                         line: line,
15923                         column: column - 1
15924                     }
15925                 });
15926             }
15927
15928             lines = str.match(/\n/g);
15929             if (lines) {
15930                 line += lines.length;
15931                 last = str.lastIndexOf("\n");
15932                 column = str.length - last;
15933             } else {
15934                 column = column + str.length;
15935             }
15936
15937             if (node && node.source && node.source.end && type != "start") {
15938                 _this.map.addMapping({
15939                     source: _this.sourcePath(node),
15940                     original: {
15941                         line: node.source.end.line,
15942                         column: node.source.end.column
15943                     },
15944                     generated: {
15945                         line: line,
15946                         column: column
15947                     }
15948                 });
15949             }
15950         };
15951
15952         this.root.stringify(builder);
15953     };
15954
15955     // Return Result object with or without map
15956     MapGenerator.prototype.generate = function generate() {
15957         this.clearAnnotation();
15958
15959         if (this.isMap()) {
15960             return this.generateMap();
15961         } else {
15962             return [this.root.toString()];
15963         }
15964     };
15965
15966     return MapGenerator;
15967 })();
15968
15969 module.exports = MapGenerator;
15970 },{"./result":109,"js-base64":114,"path":53,"source-map":115}],104:[function(require,module,exports){
15971 "use strict";
15972
15973 var CssSyntaxError = require("./css-syntax-error");
15974
15975 // Recursivly clone objects
15976 var clone = function (obj, parent) {
15977     if (typeof obj != "object") return obj;
15978     var cloned = new obj.constructor();
15979
15980     for (var i in obj) {
15981         if (!obj.hasOwnProperty(i)) continue;
15982         var value = obj[i];
15983
15984         if (i == "parent" && typeof value == "object") {
15985             if (parent) cloned[i] = parent;
15986         } else if (i == "source") {
15987             cloned[i] = value;
15988         } else if (value instanceof Array) {
15989             cloned[i] = value.map(function (i) {
15990                 return clone(i, cloned);
15991             });
15992         } else if (i != "before" && i != "after" && i != "between" && i != "semicolon") {
15993             cloned[i] = clone(value, cloned);
15994         }
15995     }
15996
15997     return cloned;
15998 };
15999
16000 // Some common methods for all CSS nodes
16001 var Node = (function () {
16002     function Node() {
16003         var defaults = arguments[0] === undefined ? {} : arguments[0];
16004         for (var name in defaults) {
16005             this[name] = defaults[name];
16006         }
16007     }
16008
16009     // Return error to mark error in your plugin syntax:
16010     //
16011     //   if ( wrongVariable ) {
16012     //       throw decl.error('Wrong variable');
16013     //   }
16014     //
16015     // You can also get origin line and column from previous source map:
16016     //
16017     //   if ( deprectedSyntax ) {
16018     //       var error = decl.error('Deprected syntax');
16019     //       console.warn(error.toString());
16020     //   }
16021     Node.prototype.error = function error(message) {
16022         if (this.source) {
16023             var pos = this.source.start;
16024             return this.source.input.error(message, pos.line, pos.column);
16025         } else {
16026             return new CssSyntaxError(message);
16027         }
16028     };
16029
16030     // Remove this node from parent
16031     //
16032     //   decl.removeSelf();
16033     //
16034     // Note, that removing by index is faster:
16035     //
16036     //   rule.each( (decl, i) => rule.remove(i) );
16037     Node.prototype.removeSelf = function removeSelf() {
16038         if (this.parent) {
16039             this.parent.remove(this);
16040         }
16041         this.parent = undefined;
16042         return this;
16043     };
16044
16045     // Shortcut to insert nodes before and remove self.
16046     //
16047     //   importNode.replace( loadedRoot );
16048     Node.prototype.replace = function replace(nodes) {
16049         this.parent.insertBefore(this, nodes);
16050         this.parent.remove(this);
16051         return this;
16052     };
16053
16054     // Return CSS string of current node
16055     //
16056     //   decl.toString(); //=> "  color: black"
16057     Node.prototype.toString = function toString() {
16058         var result = "";
16059         var builder = function (str) {
16060             return result += str;
16061         };
16062         this.stringify(builder);
16063         return result;
16064     };
16065
16066     // Clone current node
16067     //
16068     //   rule.append( decl.clone() );
16069     //
16070     // You can override properties while cloning:
16071     //
16072     //   rule.append( decl.clone({ value: '0' }) );
16073     Node.prototype.clone = (function (_clone) {
16074         var _cloneWrapper = function clone() {
16075             return _clone.apply(this, arguments);
16076         };
16077
16078         _cloneWrapper.toString = function () {
16079             return _clone.toString();
16080         };
16081
16082         return _cloneWrapper;
16083     })(function () {
16084         var overrides = arguments[0] === undefined ? {} : arguments[0];
16085         var cloned = clone(this);
16086         for (var name in overrides) {
16087             cloned[name] = overrides[name];
16088         }
16089         return cloned;
16090     });
16091
16092
16093     // Clone node and insert clone before current one.
16094     // It accept properties to change in clone and return new node.
16095     //
16096     //   decl.cloneBefore({ prop: '-webkit-' + del.prop });
16097     Node.prototype.cloneBefore = function cloneBefore() {
16098         var overrides = arguments[0] === undefined ? {} : arguments[0];
16099         var cloned = this.clone(overrides);
16100         this.parent.insertBefore(this, cloned);
16101         return cloned;
16102     };
16103
16104     // Clone node and insert clone after current one.
16105     // It accept properties to change in clone and return new node.
16106     //
16107     //   decl.cloneAfter({ value: convertToRem(decl.value) });
16108     Node.prototype.cloneAfter = function cloneAfter() {
16109         var overrides = arguments[0] === undefined ? {} : arguments[0];
16110         var cloned = this.clone(overrides);
16111         this.parent.insertAfter(this, cloned);
16112         return cloned;
16113     };
16114
16115     // Replace with node by another one.
16116     //
16117     //   decl.replaceWith(fixedDecl);
16118     Node.prototype.replaceWith = function replaceWith(node) {
16119         this.parent.insertBefore(this, node);
16120         this.removeSelf();
16121         return this;
16122     };
16123
16124     // Remove node from current place and put to end of new one.
16125     // It will also clean node code styles, but will keep `between` if old
16126     // parent and new parent has same root.
16127     //
16128     //   rule.moveTo(atRule);
16129     Node.prototype.moveTo = function moveTo(container) {
16130         this.cleanStyles(this.root() == container.root());
16131         this.removeSelf();
16132         container.append(this);
16133         return this;
16134     };
16135
16136     // Remove node from current place and put to before other node.
16137     // It will also clean node code styles, but will keep `between` if old
16138     // parent and new parent has same root.
16139     //
16140     //   rule.moveBefore(rule.parent);
16141     Node.prototype.moveBefore = function moveBefore(node) {
16142         this.cleanStyles(this.root() == node.root());
16143         this.removeSelf();
16144         node.parent.insertBefore(node, this);
16145         return this;
16146     };
16147
16148     // Remove node from current place and put to after other node.
16149     // It will also clean node code styles, but will keep `between` if old
16150     // parent and new parent has same root.
16151     //
16152     //   rule.moveAfter(rule.parent);
16153     Node.prototype.moveAfter = function moveAfter(node) {
16154         this.cleanStyles(this.root() == node.root());
16155         this.removeSelf();
16156         node.parent.insertAfter(node, this);
16157         return this;
16158     };
16159
16160     // Return next node in parent. If current node is last one,
16161     // method will return `undefined`.
16162     //
16163     //   var next = decl.next();
16164     //   if ( next && next.prop == removePrefix(decl.prop) ) {
16165     //       decl.removeSelf();
16166     //   }
16167     Node.prototype.next = function next() {
16168         var index = this.parent.index(this);
16169         return this.parent.nodes[index + 1];
16170     };
16171
16172     // Return previous node in parent. If current node is first one,
16173     // method will return `undefined`.
16174     //
16175     //   var prev = decl.prev();
16176     //   if ( prev && removePrefix(prev.prop) == decl.prop) ) {
16177     //       prev.removeSelf();
16178     //   }
16179     Node.prototype.prev = function prev() {
16180         var index = this.parent.index(this);
16181         return this.parent.nodes[index - 1];
16182     };
16183
16184     // Remove `parent` node on cloning to fix circular structures
16185     Node.prototype.toJSON = function toJSON() {
16186         var fixed = {};
16187
16188         for (var name in this) {
16189             if (!this.hasOwnProperty(name)) continue;
16190             if (name == "parent") continue;
16191             var value = this[name];
16192
16193             if (value instanceof Array) {
16194                 fixed[name] = value.map(function (i) {
16195                     return typeof i == "object" && i.toJSON ? i.toJSON() : i;
16196                 });
16197             } else if (typeof value == "object" && value.toJSON) {
16198                 fixed[name] = value.toJSON();
16199             } else {
16200                 fixed[name] = value;
16201             }
16202         }
16203
16204         return fixed;
16205     };
16206
16207     // Copy code style from first node with same type
16208     Node.prototype.style = function style(own, detect) {
16209         var value;
16210         if (!detect) detect = own;
16211
16212         // Already had
16213         if (own) {
16214             value = this[own];
16215             if (typeof value != "undefined") return value;
16216         }
16217
16218         var parent = this.parent;
16219
16220         // Hack for first rule in CSS
16221         if (detect == "before") {
16222             if (!parent || parent.type == "root" && parent.first == this) {
16223                 return "";
16224             }
16225         }
16226
16227         // Floating child without parent
16228         if (!parent) return this.defaultStyle[detect];
16229
16230         // Detect style by other nodes
16231         var root = this.root();
16232         if (!root.styleCache) root.styleCache = {};
16233         if (typeof root.styleCache[detect] != "undefined") {
16234             return root.styleCache[detect];
16235         }
16236
16237         if (detect == "semicolon") {
16238             root.eachInside(function (i) {
16239                 if (i.nodes && i.nodes.length && i.last.type == "decl") {
16240                     value = i.semicolon;
16241                     if (typeof value != "undefined") return false;
16242                 }
16243             });
16244         } else if (detect == "emptyBody") {
16245             root.eachInside(function (i) {
16246                 if (i.nodes && i.nodes.length === 0) {
16247                     value = i.after;
16248                     if (typeof value != "undefined") return false;
16249                 }
16250             });
16251         } else if (detect == "indent") {
16252             root.eachInside(function (i) {
16253                 var p = i.parent;
16254                 if (p != root && p.parent && p.parent == root) {
16255                     if (typeof i.before != "undefined") {
16256                         var parts = i.before.split("\n");
16257                         value = parts[parts.length - 1];
16258                         value = value.replace(/[^\s]/g, "");
16259                         return false;
16260                     }
16261                 }
16262             });
16263         } else if (detect == "beforeComment") {
16264             root.eachComment(function (i) {
16265                 if (typeof i.before != "undefined") {
16266                     value = i.before;
16267                     if (value.indexOf("\n") != -1) {
16268                         value = value.replace(/[^\n]+$/, "");
16269                     }
16270                     return false;
16271                 }
16272             });
16273             if (typeof value == "undefined") {
16274                 value = this.style(null, "beforeDecl");
16275             }
16276         } else if (detect == "beforeDecl") {
16277             root.eachDecl(function (i) {
16278                 if (typeof i.before != "undefined") {
16279                     value = i.before;
16280                     if (value.indexOf("\n") != -1) {
16281                         value = value.replace(/[^\n]+$/, "");
16282                     }
16283                     return false;
16284                 }
16285             });
16286             if (typeof value == "undefined") {
16287                 value = this.style(null, "beforeRule");
16288             }
16289         } else if (detect == "beforeRule") {
16290             root.eachInside(function (i) {
16291                 if (i.nodes && (i.parent != root || root.first != i)) {
16292                     if (typeof i.before != "undefined") {
16293                         value = i.before;
16294                         if (value.indexOf("\n") != -1) {
16295                             value = value.replace(/[^\n]+$/, "");
16296                         }
16297                         return false;
16298                     }
16299                 }
16300             });
16301         } else if (detect == "beforeClose") {
16302             root.eachInside(function (i) {
16303                 if (i.nodes && i.nodes.length > 0) {
16304                     if (typeof i.after != "undefined") {
16305                         value = i.after;
16306                         if (value.indexOf("\n") != -1) {
16307                             value = value.replace(/[^\n]+$/, "");
16308                         }
16309                         return false;
16310                     }
16311                 }
16312             });
16313         } else if (detect == "before" || detect == "after") {
16314             if (this.type == "decl") {
16315                 value = this.style(null, "beforeDecl");
16316             } else if (this.type == "comment") {
16317                 value = this.style(null, "beforeComment");
16318             } else if (detect == "before") {
16319                 value = this.style(null, "beforeRule");
16320             } else {
16321                 value = this.style(null, "beforeClose");
16322             }
16323
16324             var node = this.parent;
16325             var depth = 0;
16326             while (node && node.type != "root") {
16327                 depth += 1;
16328                 node = node.parent;
16329             }
16330
16331             if (value.indexOf("\n") != -1) {
16332                 var indent = this.style(null, "indent");
16333                 if (indent.length) {
16334                     for (var step = 0; step < depth; step++) value += indent;
16335                 }
16336             }
16337
16338             return value;
16339         } else if (detect == "colon") {
16340             root.eachDecl(function (i) {
16341                 if (typeof i.between != "undefined") {
16342                     value = i.between.replace(/[^\s:]/g, "");
16343                     return false;
16344                 }
16345             });
16346         } else if (detect == "beforeOpen") {
16347             root.eachInside(function (i) {
16348                 if (i.type != "decl") {
16349                     value = i.between;
16350                     if (typeof value != "undefined") return false;
16351                 }
16352             });
16353         } else {
16354             root.eachInside(function (i) {
16355                 value = i[own];
16356                 if (typeof value != "undefined") return false;
16357             });
16358         }
16359
16360         if (typeof value == "undefined") value = this.defaultStyle[detect];
16361
16362         root.styleCache[detect] = value;
16363         return value;
16364     };
16365
16366     // Return top parent , parent of parents.
16367     Node.prototype.root = function root() {
16368         var result = this;
16369         while (result.parent) result = result.parent;
16370         return result;
16371     };
16372
16373     // Recursivelly remove all code style properties (`before` and `between`).
16374     Node.prototype.cleanStyles = function cleanStyles(keepBetween) {
16375         delete this.before;
16376         delete this.after;
16377         if (!keepBetween) delete this.between;
16378
16379         if (this.nodes) {
16380             for (var _iterator = this.nodes, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
16381                 var node;
16382                 if (_isArray) {
16383                     if (_i >= _iterator.length) break;
16384                     node = _iterator[_i++];
16385                 } else {
16386                     _i = _iterator.next();
16387                     if (_i.done) break;
16388                     node = _i.value;
16389                 }
16390                 node.cleanStyles(keepBetween);
16391             }
16392         }
16393     };
16394
16395     // Use raw value if origin was not changed
16396     Node.prototype.stringifyRaw = function stringifyRaw(prop) {
16397         var value = this[prop];
16398         var raw = this["_" + prop];
16399         if (raw && raw.value === value) {
16400             return raw.raw;
16401         } else {
16402             return value;
16403         }
16404     };
16405
16406     return Node;
16407 })();
16408
16409 // Default code style
16410 Node.prototype.defaultStyle = {
16411     colon: ": ",
16412     indent: "    ",
16413     beforeDecl: "\n",
16414     beforeRule: "\n",
16415     beforeOpen: " ",
16416     beforeClose: "\n",
16417     beforeComment: "\n",
16418     after: "\n",
16419     emptyBody: "",
16420     commentLeft: " ",
16421     commentRight: " "
16422 };
16423
16424 module.exports = Node;
16425 },{"./css-syntax-error":99}],105:[function(require,module,exports){
16426 "use strict";
16427
16428 var Parser = require("./parser");
16429 var Input = require("./input");
16430
16431 module.exports = function (css, opts) {
16432     var input = new Input(css, opts);
16433
16434     var parser = new Parser(input);
16435     parser.tokenize();
16436     parser.loop();
16437
16438     return parser.root;
16439 };
16440 },{"./input":101,"./parser":106}],106:[function(require,module,exports){
16441 "use strict";
16442
16443 var Declaration = require("./declaration");
16444 var tokenize = require("./tokenize");
16445 var Comment = require("./comment");
16446 var AtRule = require("./at-rule");
16447 var Root = require("./root");
16448 var Rule = require("./rule");
16449
16450 // CSS parser
16451 var Parser = (function () {
16452     function Parser(input) {
16453         this.input = input;
16454
16455         this.pos = 0;
16456         this.root = new Root();
16457         this.current = this.root;
16458         this.spaces = "";
16459         this.semicolon = false;
16460
16461         this.root.source = { input: input };
16462         if (input.map) this.root.prevMap = input.map;
16463     }
16464
16465     Parser.prototype.tokenize = (function (_tokenize) {
16466         var _tokenizeWrapper = function tokenize() {
16467             return _tokenize.apply(this, arguments);
16468         };
16469
16470         _tokenizeWrapper.toString = function () {
16471             return _tokenize.toString();
16472         };
16473
16474         return _tokenizeWrapper;
16475     })(function () {
16476         this.tokens = tokenize(this.input);
16477     });
16478     Parser.prototype.loop = function loop() {
16479         var token;
16480         while (this.pos < this.tokens.length) {
16481             token = this.tokens[this.pos];
16482
16483             switch (token[0]) {
16484                 case "word":
16485                 case ":":
16486                     this.word(token);
16487                     break;
16488
16489                 case "}":
16490                     this.end(token);
16491                     break;
16492
16493                 case "comment":
16494                     this.comment(token);
16495                     break;
16496
16497                 case "at-word":
16498                     this.atrule(token);
16499                     break;
16500
16501                 case "{":
16502                     this.emptyRule(token);
16503                     break;
16504
16505                 default:
16506                     this.spaces += token[1];
16507                     break;
16508             }
16509
16510             this.pos += 1;
16511         }
16512         this.endFile();
16513     };
16514
16515     Parser.prototype.comment = function comment(token) {
16516         var node = new Comment();
16517         this.init(node, token[2], token[3]);
16518         node.source.end = { line: token[4], column: token[5] };
16519
16520         var text = token[1].slice(2, -2);
16521         if (text.match(/^\s*$/)) {
16522             node.left = text;
16523             node.text = "";
16524             node.right = "";
16525         } else {
16526             var match = text.match(/^(\s*)([^]*[^\s])(\s*)$/);
16527             node.left = match[1];
16528             node.text = match[2];
16529             node.right = match[3];
16530         }
16531     };
16532
16533     Parser.prototype.emptyRule = function emptyRule(token) {
16534         var node = new Rule();
16535         this.init(node, token[2], token[3]);
16536         node.between = "";
16537         node.selector = "";
16538         this.current = node;
16539     };
16540
16541     Parser.prototype.word = function word() {
16542         var token;
16543         var end = false;
16544         var type = null;
16545         var colon = false;
16546         var bracket = null;
16547         var brackets = 0;
16548
16549         var start = this.pos;
16550         this.pos += 1;
16551         while (true) {
16552             token = this.tokens[this.pos];
16553             if (!token) {
16554                 this.pos -= 1;
16555                 end = true;
16556                 break;
16557             }
16558
16559             type = token[0];
16560             if (type == "(") {
16561                 if (!bracket) bracket = token;
16562                 brackets += 1;
16563             } else if (type == ")") {
16564                 brackets -= 1;
16565                 if (brackets === 0) bracket = null;
16566             } else if (brackets === 0) {
16567                 if (type == ";") {
16568                     if (colon) {
16569                         this.decl(this.tokens.slice(start, this.pos + 1));
16570                         return;
16571                     } else {
16572                         break;
16573                     }
16574                 } else if (type == "{") {
16575                     this.rule(this.tokens.slice(start, this.pos + 1));
16576                     return;
16577                 } else if (type == "}") {
16578                     this.pos -= 1;
16579                     end = true;
16580                     break;
16581                 } else if (type == "at-word") {
16582                     this.pos -= 1;
16583                     break;
16584                 } else {
16585                     if (type == ":") colon = true;
16586                 }
16587             }
16588
16589             this.pos += 1;
16590         }
16591
16592         if (brackets > 0 && !this.input.safe) {
16593             throw this.input.error("Unclosed bracket", bracket[2], bracket[3]);
16594         }
16595
16596         if (end && colon) {
16597             while (this.pos > start) {
16598                 token = this.tokens[this.pos][0];
16599                 if (token != "space" && token != "comment") break;
16600                 this.pos -= 1;
16601             }
16602             this.decl(this.tokens.slice(start, this.pos + 1));
16603             return;
16604         }
16605
16606         if (this.input.safe) {
16607             var buffer = this.tokens.slice(start, this.pos + 1);
16608             this.spaces += buffer.map(function (i) {
16609                 return i[1];
16610             }).join("");
16611         } else {
16612             token = this.tokens[start];
16613             throw this.input.error("Unknown word", token[2], token[3]);
16614         }
16615     };
16616
16617     Parser.prototype.rule = function rule(tokens) {
16618         tokens.pop();
16619
16620         var node = new Rule();
16621         this.init(node, tokens[0][2], tokens[0][3]);
16622
16623         node.between = this.spacesFromEnd(tokens);
16624         this.raw(node, "selector", tokens);
16625         this.current = node;
16626     };
16627
16628     Parser.prototype.decl = function decl(tokens) {
16629         var node = new Declaration();
16630         this.init(node);
16631
16632         var last = tokens[tokens.length - 1];
16633         if (last[0] == ";") {
16634             this.semicolon = true;
16635             tokens.pop();
16636         }
16637         if (last[4]) {
16638             node.source.end = { line: last[4], column: last[5] };
16639         } else {
16640             node.source.end = { line: last[2], column: last[3] };
16641         }
16642
16643         while (tokens[0][0] != "word") {
16644             node.before += tokens.shift()[1];
16645         }
16646         node.source.start = { line: tokens[0][2], column: tokens[0][3] };
16647
16648         node.prop = tokens.shift()[1];
16649         node.between = "";
16650
16651         var token;
16652         while (tokens.length) {
16653             token = tokens.shift();
16654
16655             if (token[0] == ":") {
16656                 node.between += token[1];
16657                 break;
16658             } else if (token[0] != "space" && token[0] != "comment") {
16659                 this.unknownWord(node, token, tokens);
16660             } else {
16661                 node.between += token[1];
16662             }
16663         }
16664
16665         if (node.prop[0] == "_" || node.prop[0] == "*") {
16666             node.before += node.prop[0];
16667             node.prop = node.prop.slice(1);
16668         }
16669         node.between += this.spacesFromStart(tokens);
16670
16671         if (this.input.safe) this.checkMissedSemicolon(tokens);
16672
16673         for (var i = tokens.length - 1; i > 0; i--) {
16674             token = tokens[i];
16675             if (token[1] == "!important") {
16676                 node.important = true;
16677                 var string = this.stringFrom(tokens, i);
16678                 string = this.spacesFromEnd(tokens) + string;
16679                 if (string != " !important") node._important = string;
16680                 break;
16681             } else if (token[0] != "space" && token[0] != "comment") {
16682                 break;
16683             }
16684         }
16685
16686         this.raw(node, "value", tokens);
16687
16688         if (node.value.indexOf(":") != -1 && !this.input.safe) {
16689             this.checkMissedSemicolon(tokens);
16690         }
16691     };
16692
16693     Parser.prototype.atrule = function atrule(token) {
16694         var node = new AtRule();
16695         node.name = token[1].slice(1);
16696         if (node.name === "") {
16697             if (this.input.safe) {
16698                 node.name = "";
16699             } else {
16700                 throw this.input.error("At-rule without name", token[2], token[3]);
16701             }
16702         }
16703         this.init(node, token[2], token[3]);
16704
16705         var next;
16706         var last = false;
16707         var open = false;
16708         var params = [];
16709         while (true) {
16710             this.pos += 1;
16711             token = this.tokens[this.pos];
16712
16713             if (!token) {
16714                 last = true;
16715                 break;
16716             } else if (token[0] == ";") {
16717                 node.source.end = { line: token[2], column: token[3] };
16718                 this.semicolon = true;
16719                 break;
16720             } else if (token[0] == "{") {
16721                 open = true;
16722                 break;
16723             } else {
16724                 params.push(token);
16725             }
16726         }
16727
16728         node.between = this.spacesFromEnd(params);
16729         if (params.length) {
16730             node.afterName = this.spacesFromStart(params);
16731             this.raw(node, "params", params);
16732             if (last) {
16733                 token = params[params.length - 1];
16734                 node.source.end = { line: token[4], column: token[5] };
16735                 this.spaces = node.between;
16736                 node.between = "";
16737             }
16738         } else {
16739             node.afterName = "";
16740             node.params = "";
16741         }
16742
16743         if (open) {
16744             node.nodes = [];
16745             this.current = node;
16746         }
16747     };
16748
16749     Parser.prototype.end = function end(token) {
16750         if (this.current.nodes && this.current.nodes.length) {
16751             this.current.semicolon = this.semicolon;
16752         }
16753         this.semicolon = false;
16754
16755         this.current.after = (this.current.after || "") + this.spaces;
16756         this.spaces = "";
16757
16758         if (this.current.parent) {
16759             this.current.source.end = { line: token[2], column: token[3] };
16760             this.current = this.current.parent;
16761         } else if (!this.input.safe) {
16762             throw this.input.error("Unexpected }", token[2], token[3]);
16763         } else {
16764             this.current.after += "}";
16765         }
16766     };
16767
16768     Parser.prototype.endFile = function endFile() {
16769         if (this.current.parent && !this.input.safe) {
16770             var pos = this.current.source.start;
16771             throw this.input.error("Unclosed block", pos.line, pos.column);
16772         }
16773
16774         if (this.current.nodes && this.current.nodes.length) {
16775             this.current.semicolon = this.semicolon;
16776         }
16777         this.current.after = (this.current.after || "") + this.spaces;
16778
16779         while (this.current.parent) {
16780             this.current = this.current.parent;
16781             this.current.after = "";
16782         }
16783     };
16784
16785     Parser.prototype.unknownWord = function unknownWord(node, token) {
16786         if (this.input.safe) {
16787             node.source.start = { line: token[2], column: token[3] };
16788             node.before += node.prop + node.between;
16789             node.prop = token[1];
16790             node.between = "";
16791         } else {
16792             throw this.input.error("Unknown word", token[2], token[3]);
16793         }
16794     };
16795
16796     Parser.prototype.checkMissedSemicolon = function checkMissedSemicolon(tokens) {
16797         var prev = null;
16798         var colon = false;
16799         var brackets = 0;
16800         var type, token;
16801         for (var i = 0; i < tokens.length; i++) {
16802             token = tokens[i];
16803             type = token[0];
16804
16805             if (type == "(") {
16806                 brackets += 1;
16807             } else if (type == ")") {
16808                 brackets -= 0;
16809             } else if (brackets === 0 && type == ":") {
16810                 if (prev[0] == "word" && prev[1] == "progid") {
16811                     continue;
16812                 } else {
16813                     colon = i;
16814                     break;
16815                 }
16816             }
16817
16818             prev = token;
16819         }
16820
16821         if (colon === false) return;
16822
16823         if (this.input.safe) {
16824             var split;
16825             for (split = colon - 1; split >= 0; split--) {
16826                 if (tokens[split][0] == "word") break;
16827             }
16828             for (split -= 1; split >= 0; split--) {
16829                 if (tokens[split][0] != "space") {
16830                     split += 1;
16831                     break;
16832                 }
16833             }
16834             var other = tokens.splice(split, tokens.length - split);
16835             this.decl(other);
16836         } else {
16837             var founded = 0;
16838             for (var j = colon - 1; j >= 0; j--) {
16839                 token = tokens[j];
16840                 if (token[0] != "space") {
16841                     founded += 1;
16842                     if (founded == 2) break;
16843                 }
16844             }
16845             throw this.input.error("Missed semicolon", token[4], token[5]);
16846         }
16847     };
16848
16849     // Helpers
16850
16851     Parser.prototype.init = function init(node, line, column) {
16852         this.current.push(node);
16853
16854         node.source = { start: { line: line, column: column }, input: this.input };
16855         node.before = this.spaces;
16856         this.spaces = "";
16857         if (node.type != "comment") this.semicolon = false;
16858     };
16859
16860     Parser.prototype.raw = function raw(node, prop, tokens) {
16861         var token;
16862         var value = "";
16863         var clean = true;
16864         for (var _iterator = tokens, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
16865             if (_isArray) {
16866                 if (_i >= _iterator.length) break;
16867                 token = _iterator[_i++];
16868             } else {
16869                 _i = _iterator.next();
16870                 if (_i.done) break;
16871                 token = _i.value;
16872             }
16873             if (token[0] == "comment") {
16874                 clean = false;
16875             } else {
16876                 value += token[1];
16877             }
16878         }
16879
16880         if (!clean) {
16881             var origin = "";
16882             for (var _iterator2 = tokens, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
16883                 if (_isArray2) {
16884                     if (_i2 >= _iterator2.length) break;
16885                     token = _iterator2[_i2++];
16886                 } else {
16887                     _i2 = _iterator2.next();
16888                     if (_i2.done) break;
16889                     token = _i2.value;
16890                 }
16891                 origin += token[1];
16892             }
16893
16894             node["_" + prop] = { value: value, raw: origin };
16895         }
16896         node[prop] = value;
16897     };
16898
16899     Parser.prototype.spacesFromEnd = function spacesFromEnd(tokens) {
16900         var next;
16901         var spaces = "";
16902         while (tokens.length) {
16903             next = tokens[tokens.length - 1][0];
16904             if (next != "space" && next != "comment") break;
16905             spaces += tokens.pop()[1];
16906         }
16907         return spaces;
16908     };
16909
16910     Parser.prototype.spacesFromStart = function spacesFromStart(tokens) {
16911         var next;
16912         var spaces = "";
16913         while (tokens.length) {
16914             next = tokens[0][0];
16915             if (next != "space" && next != "comment") break;
16916             spaces += tokens.shift()[1];
16917         }
16918         return spaces;
16919     };
16920
16921     Parser.prototype.stringFrom = function stringFrom(tokens, from) {
16922         var result = "";
16923         for (var i = from; i < tokens.length; i++) {
16924             result += tokens[i][1];
16925         }
16926         tokens.splice(from, tokens.length - from);
16927         return result;
16928     };
16929
16930     return Parser;
16931 })();
16932
16933 module.exports = Parser;
16934 },{"./at-rule":96,"./comment":97,"./declaration":100,"./root":110,"./rule":111,"./tokenize":112}],107:[function(require,module,exports){
16935 "use strict";
16936
16937 var Declaration = require("./declaration");
16938 var Comment = require("./comment");
16939 var AtRule = require("./at-rule");
16940 var Result = require("./result");
16941 var Rule = require("./rule");
16942 var Root = require("./root");
16943
16944 // List of functions to process CSS
16945 var PostCSS = (function () {
16946     function PostCSS() {
16947         var _this = this;
16948         var plugins = arguments[0] === undefined ? [] : arguments[0];
16949         this.plugins = plugins.map(function (i) {
16950             return _this.normalize(i);
16951         });
16952     }
16953
16954     // Add function as PostCSS plugins
16955     PostCSS.prototype.use = function use(plugin) {
16956         plugin = this.normalize(plugin);
16957         if (typeof plugin == "object" && Array.isArray(plugin.plugins)) {
16958             this.plugins = this.plugins.concat(plugin.plugins);
16959         } else {
16960             this.plugins.push(plugin);
16961         }
16962         return this;
16963     };
16964
16965     // Process CSS throw installed plugins
16966     PostCSS.prototype.process = function process(css) {
16967         var opts = arguments[1] === undefined ? {} : arguments[1];
16968         var parsed;
16969         if (css instanceof Root) {
16970             parsed = css;
16971         } else if (css instanceof Result) {
16972             parsed = css.root;
16973             if (css.map && typeof opts.map == "undefined") {
16974                 opts.map = { prev: css.map };
16975             }
16976         } else {
16977             parsed = postcss.parse(css, opts);
16978         }
16979
16980         for (var _iterator = this.plugins, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
16981             var plugin;
16982             if (_isArray) {
16983                 if (_i >= _iterator.length) break;
16984                 plugin = _iterator[_i++];
16985             } else {
16986                 _i = _iterator.next();
16987                 if (_i.done) break;
16988                 plugin = _i.value;
16989             }
16990             var returned = plugin(parsed, opts);
16991             if (returned instanceof Root) parsed = returned;
16992         }
16993
16994         return parsed.toResult(opts);
16995     };
16996
16997     // Return plugin function
16998     PostCSS.prototype.normalize = function normalize(plugin) {
16999         var type = typeof plugin;
17000         if ((type == "object" || type == "function") && plugin.postcss) {
17001             return plugin.postcss;
17002         } else {
17003             return plugin;
17004         }
17005     };
17006
17007     return PostCSS;
17008 })();
17009
17010 // Framework for CSS postprocessors
17011 //
17012 //   var processor = postcss(function (css) {
17013 //       // Change nodes in css
17014 //   });
17015 //   processor.process(css)
17016 var postcss = function () {
17017     for (var _len = arguments.length, plugins = Array(_len), _key = 0; _key < _len; _key++) {
17018         plugins[_key] = arguments[_key];
17019     }
17020
17021     if (plugins.length == 1 && Array.isArray(plugins[0])) {
17022         plugins = plugins[0];
17023     }
17024     return new PostCSS(plugins);
17025 };
17026
17027 // Compile CSS to nodes
17028 postcss.parse = require("./parse");
17029
17030 // Nodes shortcuts
17031 postcss.comment = function (defaults) {
17032     return new Comment(defaults);
17033 };
17034 postcss.atRule = function (defaults) {
17035     return new AtRule(defaults);
17036 };
17037 postcss.decl = function (defaults) {
17038     return new Declaration(defaults);
17039 };
17040 postcss.rule = function (defaults) {
17041     return new Rule(defaults);
17042 };
17043 postcss.root = function (defaults) {
17044     return new Root(defaults);
17045 };
17046
17047 module.exports = postcss;
17048 },{"./at-rule":96,"./comment":97,"./declaration":100,"./parse":105,"./result":109,"./root":110,"./rule":111}],108:[function(require,module,exports){
17049 "use strict";
17050
17051 var mozilla = require("source-map");
17052 var Base64 = require("js-base64").Base64;
17053 var path = require("path");
17054 var fs = require("fs");
17055
17056 // Detect previous map
17057 var PreviousMap = (function () {
17058     function PreviousMap(css, opts) {
17059         this.loadAnnotation(css);
17060         this.inline = this.startWith(this.annotation, "data:");
17061
17062         var text = this.loadMap(opts.from, opts.map ? opts.map.prev : undefined);
17063         if (text) this.text = text;
17064     }
17065
17066     // Return SourceMapConsumer object to read map
17067     PreviousMap.prototype.consumer = function consumer() {
17068         if (!this.consumerCache) {
17069             this.consumerCache = new mozilla.SourceMapConsumer(this.text);
17070         }
17071         return this.consumerCache;
17072     };
17073
17074     // Is map has sources content
17075     PreviousMap.prototype.withContent = function withContent() {
17076         return !!(this.consumer().sourcesContent && this.consumer().sourcesContent.length > 0);
17077     };
17078
17079     // Is `string` is starting with `start`
17080     PreviousMap.prototype.startWith = function startWith(string, start) {
17081         if (!string) return false;
17082         return string.substr(0, start.length) == start;
17083     };
17084
17085     // Load for annotation comment from previous compilation step
17086     PreviousMap.prototype.loadAnnotation = function loadAnnotation(css) {
17087         var match = css.match(/\/\*\s*# sourceMappingURL=(.*)\s*\*\//);
17088         if (match) this.annotation = match[1].trim();
17089     };
17090
17091     // Encode different type of inline
17092     PreviousMap.prototype.decodeInline = function decodeInline(text) {
17093         var uri = "data:application/json,";
17094         var base64 = "data:application/json;base64,";
17095
17096         if (this.startWith(text, uri)) {
17097             return decodeURIComponent(text.substr(uri.length));
17098         } else if (this.startWith(text, base64)) {
17099             return Base64.decode(text.substr(base64.length));
17100         } else {
17101             var encoding = text.match(/data:application\/json;([^,]+),/)[1];
17102             throw new Error("Unsupported source map encoding " + encoding);
17103         }
17104     };
17105
17106     // Load previous map
17107     PreviousMap.prototype.loadMap = function loadMap(file, prev) {
17108         if (prev === false) return;
17109
17110         if (prev) {
17111             if (typeof prev == "string") {
17112                 return prev;
17113             } else if (prev instanceof mozilla.SourceMapConsumer) {
17114                 return mozilla.SourceMapGenerator.fromSourceMap(prev).toString();
17115             } else if (prev instanceof mozilla.SourceMapGenerator) {
17116                 return prev.toString();
17117             } else if (typeof prev == "object" && prev.mappings) {
17118                 return JSON.stringify(prev);
17119             } else {
17120                 throw new Error("Unsupported previous source map format: " + prev.toString());
17121             }
17122         } else if (this.inline) {
17123             return this.decodeInline(this.annotation);
17124         } else if (this.annotation) {
17125             var map = this.annotation;
17126             if (file) map = path.join(path.dirname(file), map);
17127
17128             this.root = path.dirname(map);
17129             if (fs.existsSync && fs.existsSync(map)) {
17130                 return fs.readFileSync(map, "utf-8").toString().trim();
17131             }
17132         }
17133     };
17134
17135     return PreviousMap;
17136 })();
17137
17138 module.exports = PreviousMap;
17139 },{"fs":48,"js-base64":114,"path":53,"source-map":115}],109:[function(require,module,exports){
17140 "use strict";
17141
17142 var _prototypeProperties = function (child, staticProps, instanceProps) { if (staticProps) Object.defineProperties(child, staticProps); if (instanceProps) Object.defineProperties(child.prototype, instanceProps); };
17143
17144 var MapGenerator = require("./map-generator");
17145
17146 // Object with processed CSS
17147 var Result = (function () {
17148     function Result(root) {
17149         var opts = arguments[1] === undefined ? {} : arguments[1];
17150         this.root = root;
17151         this.opts = opts;
17152     }
17153
17154     // Return CSS string on any try to print
17155     Result.prototype.toString = function toString() {
17156         return this.css;
17157     };
17158
17159     // Generate CSS and map
17160     Result.prototype.stringify = function stringify() {
17161         var map = new MapGenerator(this.root, this.opts);
17162         var generated = map.generate();
17163         this.cssCached = generated[0];
17164         this.mapCached = generated[1];
17165     };
17166
17167     _prototypeProperties(Result, null, {
17168         map: {
17169
17170             // Lazy method to return source map
17171             get: function () {
17172                 if (!this.cssCached) this.stringify();
17173                 return this.mapCached;
17174             },
17175             enumerable: true,
17176             configurable: true
17177         },
17178         css: {
17179
17180             // Lazy method to return CSS string
17181             get: function () {
17182                 if (!this.cssCached) this.stringify();
17183                 return this.cssCached;
17184             },
17185             enumerable: true,
17186             configurable: true
17187         }
17188     });
17189
17190     return Result;
17191 })();
17192
17193 module.exports = Result;
17194 },{"./map-generator":103}],110:[function(require,module,exports){
17195 "use strict";
17196
17197 var _inherits = function (subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; };
17198
17199 var Declaration = require("./declaration");
17200 var Container = require("./container");
17201 var Comment = require("./comment");
17202 var AtRule = require("./at-rule");
17203 var Result = require("./result");
17204 var Rule = require("./rule");
17205
17206 // Root of CSS
17207 var Root = (function (Container) {
17208     function Root(defaults) {
17209         this.type = "root";
17210         this.nodes = [];
17211         Container.call(this, defaults);
17212     }
17213
17214     _inherits(Root, Container);
17215
17216     // Fix space when we remove first child
17217     Root.prototype.remove = function remove(child) {
17218         child = this.index(child);
17219
17220         if (child === 0 && this.nodes.length > 1) {
17221             this.nodes[1].before = this.nodes[child].before;
17222         }
17223
17224         return Container.prototype.remove.call(this, child);
17225     };
17226
17227     // Fix spaces on insert before first rule
17228     Root.prototype.normalize = function normalize(child, sample, type) {
17229         var nodes = Container.prototype.normalize.call(this, child);
17230
17231         if (sample) {
17232             if (type == "prepend") {
17233                 if (this.nodes.length > 1) {
17234                     sample.before = this.nodes[1].before;
17235                 } else {
17236                     delete sample.before;
17237                 }
17238             } else {
17239                 for (var _iterator = nodes, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
17240                     var node;
17241                     if (_isArray) {
17242                         if (_i >= _iterator.length) break;
17243                         node = _iterator[_i++];
17244                     } else {
17245                         _i = _iterator.next();
17246                         if (_i.done) break;
17247                         node = _i.value;
17248                     }
17249                     if (this.first != sample) node.before = sample.before;
17250                 }
17251             }
17252         }
17253
17254         return nodes;
17255     };
17256
17257     // Stringify styles
17258     Root.prototype.stringify = function stringify(builder) {
17259         this.stringifyContent(builder);
17260         if (this.after) builder(this.after);
17261     };
17262
17263     // Generate processing result with optional source map
17264     Root.prototype.toResult = function toResult() {
17265         var opts = arguments[0] === undefined ? {} : arguments[0];
17266         return new Result(this, opts);
17267     };
17268
17269     return Root;
17270 })(Container);
17271
17272 module.exports = Root;
17273 },{"./at-rule":96,"./comment":97,"./container":98,"./declaration":100,"./result":109,"./rule":111}],111:[function(require,module,exports){
17274 "use strict";
17275
17276 var _prototypeProperties = function (child, staticProps, instanceProps) { if (staticProps) Object.defineProperties(child, staticProps); if (instanceProps) Object.defineProperties(child.prototype, instanceProps); };
17277
17278 var _inherits = function (subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; };
17279
17280 var Container = require("./container");
17281 var Declaration = require("./declaration");
17282 var list = require("./list");
17283
17284 // CSS rule like \93a { }\94
17285 var Rule = (function (Container) {
17286     function Rule(defaults) {
17287         this.type = "rule";
17288         this.nodes = [];
17289         Container.call(this, defaults);
17290     }
17291
17292     _inherits(Rule, Container);
17293
17294     // Stringify rule
17295     Rule.prototype.stringify = function stringify(builder) {
17296         this.stringifyBlock(builder, this.stringifyRaw("selector"));
17297     };
17298
17299     _prototypeProperties(Rule, null, {
17300         selectors: {
17301
17302             // Shortcut to get selectors as array
17303
17304             get: function () {
17305                 return list.comma(this.selector);
17306             },
17307             set: function (values) {
17308                 this.selector = values.join(", ");
17309             },
17310             enumerable: true,
17311             configurable: true
17312         }
17313     });
17314
17315     return Rule;
17316 })(Container);
17317
17318 module.exports = Rule;
17319 },{"./container":98,"./declaration":100,"./list":102}],112:[function(require,module,exports){
17320 "use strict";
17321
17322 var singleQuote = "'".charCodeAt(0),
17323     doubleQuote = "\"".charCodeAt(0),
17324     backslash = "\\".charCodeAt(0),
17325     slash = "/".charCodeAt(0),
17326     newline = "\n".charCodeAt(0),
17327     space = " ".charCodeAt(0),
17328     feed = "\f".charCodeAt(0),
17329     tab = "\t".charCodeAt(0),
17330     cr = "\r".charCodeAt(0),
17331     openBracket = "(".charCodeAt(0),
17332     closeBracket = ")".charCodeAt(0),
17333     openCurly = "{".charCodeAt(0),
17334     closeCurly = "}".charCodeAt(0),
17335     semicolon = ";".charCodeAt(0),
17336     asterisk = "*".charCodeAt(0),
17337     colon = ":".charCodeAt(0),
17338     at = "@".charCodeAt(0),
17339     atEnd = /[ \n\t\r\{\(\)'"\\/]/g,
17340     wordEnd = /[ \n\t\r\(\)\{\}:;@!'"\\]|\/(?=\*)/g,
17341     badBracket = /.[\\\/\("'\n]/;
17342
17343 module.exports = function (input) {
17344     var tokens = [];
17345     var css = input.css.valueOf();
17346
17347     var code, next, quote, lines, last, content, escape, nextLine, nextOffset, escaped, escapePos, bad;
17348
17349     var length = css.length;
17350     var offset = -1;
17351     var line = 1;
17352     var pos = 0;
17353
17354     var unclosed = function (what, end) {
17355         if (input.safe) {
17356             css += end;
17357             next = css.length - 1;
17358         } else {
17359             throw input.error("Unclosed " + what, line, pos - offset);
17360         }
17361     };
17362
17363     while (pos < length) {
17364         code = css.charCodeAt(pos);
17365
17366         if (code == newline) {
17367             offset = pos;
17368             line += 1;
17369         }
17370
17371         switch (code) {
17372             case newline:
17373             case space:
17374             case tab:
17375             case cr:
17376             case feed:
17377                 next = pos;
17378                 do {
17379                     next += 1;
17380                     code = css.charCodeAt(next);
17381                     if (code == newline) {
17382                         offset = next;
17383                         line += 1;
17384                     }
17385                 } while (code == space || code == newline || code == tab || code == cr || code == feed);
17386
17387                 tokens.push(["space", css.slice(pos, next)]);
17388                 pos = next - 1;
17389                 break;
17390
17391             case openCurly:
17392                 tokens.push(["{", "{", line, pos - offset]);
17393                 break;
17394
17395             case closeCurly:
17396                 tokens.push(["}", "}", line, pos - offset]);
17397                 break;
17398
17399             case colon:
17400                 tokens.push([":", ":", line, pos - offset]);
17401                 break;
17402
17403             case semicolon:
17404                 tokens.push([";", ";", line, pos - offset]);
17405                 break;
17406
17407             case openBracket:
17408                 next = css.indexOf(")", pos + 1);
17409                 content = css.slice(pos, next + 1);
17410
17411                 if (next == -1 || badBracket.test(content)) {
17412                     tokens.push(["(", "(", line, pos - offset]);
17413                 } else {
17414                     tokens.push(["brackets", content, line, pos - offset, line, next - offset]);
17415                     pos = next;
17416                 }
17417
17418                 break;
17419
17420             case closeBracket:
17421                 tokens.push([")", ")", line, pos - offset]);
17422                 break;
17423
17424             case singleQuote:
17425             case doubleQuote:
17426                 quote = code == singleQuote ? "'" : "\"";
17427                 next = pos;
17428                 do {
17429                     escaped = false;
17430                     next = css.indexOf(quote, next + 1);
17431                     if (next == -1) unclosed("quote", quote);
17432                     escapePos = next;
17433                     while (css.charCodeAt(escapePos - 1) == backslash) {
17434                         escapePos -= 1;
17435                         escaped = !escaped;
17436                     }
17437                 } while (escaped);
17438
17439                 tokens.push(["string", css.slice(pos, next + 1), line, pos - offset, line, next - offset]);
17440                 pos = next;
17441                 break;
17442
17443             case at:
17444                 atEnd.lastIndex = pos + 1;
17445                 atEnd.test(css);
17446                 if (atEnd.lastIndex === 0) {
17447                     next = css.length - 1;
17448                 } else {
17449                     next = atEnd.lastIndex - 2;
17450                 }
17451                 tokens.push(["at-word", css.slice(pos, next + 1), line, pos - offset, line, next - offset]);
17452                 pos = next;
17453                 break;
17454
17455             case backslash:
17456                 next = pos;
17457                 escape = true;
17458                 while (css.charCodeAt(next + 1) == backslash) {
17459                     next += 1;
17460                     escape = !escape;
17461                 }
17462                 code = css.charCodeAt(next + 1);
17463                 if (escape && (code != slash && code != space && code != newline && code != tab && code != cr && code != feed)) {
17464                     next += 1;
17465                 }
17466                 tokens.push(["word", css.slice(pos, next + 1), line, pos - offset, line, next - offset]);
17467                 pos = next;
17468                 break;
17469
17470             default:
17471                 if (code == slash && css.charCodeAt(pos + 1) == asterisk) {
17472                     next = css.indexOf("*/", pos + 2) + 1;
17473                     if (next === 0) unclosed("comment", "*/");
17474
17475                     content = css.slice(pos, next + 1);
17476                     lines = content.split("\n");
17477                     last = lines.length - 1;
17478
17479                     if (last > 0) {
17480                         nextLine = line + last;
17481                         nextOffset = next - lines[last].length;
17482                     } else {
17483                         nextLine = line;
17484                         nextOffset = offset;
17485                     }
17486
17487                     tokens.push(["comment", content, line, pos - offset, nextLine, next - nextOffset]);
17488
17489                     offset = nextOffset;
17490                     line = nextLine;
17491                     pos = next;
17492                 } else {
17493                     wordEnd.lastIndex = pos + 1;
17494                     wordEnd.test(css);
17495                     if (wordEnd.lastIndex === 0) {
17496                         next = css.length - 1;
17497                     } else {
17498                         next = wordEnd.lastIndex - 2;
17499                     }
17500
17501                     tokens.push(["word", css.slice(pos, next + 1), line, pos - offset, line, next - offset]);
17502                     pos = next;
17503                 }
17504
17505                 break;
17506         }
17507
17508         pos++;
17509     }
17510
17511     return tokens;
17512 };
17513 },{}],113:[function(require,module,exports){
17514 "use strict";
17515
17516 // Methods to work with vendor prefixes
17517 var vendor = {
17518
17519     // Return vendor prefix from property name, if it exists
17520     //
17521     //   vendor.prefix('-moz-box-sizing') #=> '-moz-'
17522     //   vendor.prefix('box-sizing')      #=> ''
17523     prefix: function (prop) {
17524         if (prop[0] == "-") {
17525             var sep = prop.indexOf("-", 1);
17526             return prop.substr(0, sep + 1);
17527         } else {
17528             return "";
17529         }
17530     },
17531
17532     // Remove prefix from property name
17533     //
17534     //   vendor.prefix('-moz-box-sizing') #=> 'box-sizing'
17535     //   vendor.prefix('box-sizing')      #=> 'box-sizing'
17536     unprefixed: function (prop) {
17537         if (prop[0] == "-") {
17538             var sep = prop.indexOf("-", 1);
17539             return prop.substr(sep + 1);
17540         } else {
17541             return prop;
17542         }
17543     }
17544
17545 };
17546
17547 module.exports = vendor;
17548 },{}],114:[function(require,module,exports){
17549 (function (global){
17550 /*
17551  * $Id: base64.js,v 2.15 2014/04/05 12:58:57 dankogai Exp dankogai $
17552  *
17553  *  Licensed under the MIT license.
17554  *    http://opensource.org/licenses/mit-license
17555  *
17556  *  References:
17557  *    http://en.wikipedia.org/wiki/Base64
17558  */
17559
17560 (function(global) {
17561     'use strict';
17562     // existing version for noConflict()
17563     var _Base64 = global.Base64;
17564     var version = "2.1.7";
17565     // if node.js, we use Buffer
17566     var buffer;
17567     if (typeof module !== 'undefined' && module.exports) {
17568         buffer = require('buffer').Buffer;
17569     }
17570     // constants
17571     var b64chars
17572         = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
17573     var b64tab = function(bin) {
17574         var t = {};
17575         for (var i = 0, l = bin.length; i < l; i++) t[bin.charAt(i)] = i;
17576         return t;
17577     }(b64chars);
17578     var fromCharCode = String.fromCharCode;
17579     // encoder stuff
17580     var cb_utob = function(c) {
17581         if (c.length < 2) {
17582             var cc = c.charCodeAt(0);
17583             return cc < 0x80 ? c
17584                 : cc < 0x800 ? (fromCharCode(0xc0 | (cc >>> 6))
17585                                 + fromCharCode(0x80 | (cc & 0x3f)))
17586                 : (fromCharCode(0xe0 | ((cc >>> 12) & 0x0f))
17587                    + fromCharCode(0x80 | ((cc >>>  6) & 0x3f))
17588                    + fromCharCode(0x80 | ( cc         & 0x3f)));
17589         } else {
17590             var cc = 0x10000
17591                 + (c.charCodeAt(0) - 0xD800) * 0x400
17592                 + (c.charCodeAt(1) - 0xDC00);
17593             return (fromCharCode(0xf0 | ((cc >>> 18) & 0x07))
17594                     + fromCharCode(0x80 | ((cc >>> 12) & 0x3f))
17595                     + fromCharCode(0x80 | ((cc >>>  6) & 0x3f))
17596                     + fromCharCode(0x80 | ( cc         & 0x3f)));
17597         }
17598     };
17599     var re_utob = /[\uD800-\uDBFF][\uDC00-\uDFFFF]|[^\x00-\x7F]/g;
17600     var utob = function(u) {
17601         return u.replace(re_utob, cb_utob);
17602     };
17603     var cb_encode = function(ccc) {
17604         var padlen = [0, 2, 1][ccc.length % 3],
17605         ord = ccc.charCodeAt(0) << 16
17606             | ((ccc.length > 1 ? ccc.charCodeAt(1) : 0) << 8)
17607             | ((ccc.length > 2 ? ccc.charCodeAt(2) : 0)),
17608         chars = [
17609             b64chars.charAt( ord >>> 18),
17610             b64chars.charAt((ord >>> 12) & 63),
17611             padlen >= 2 ? '=' : b64chars.charAt((ord >>> 6) & 63),
17612             padlen >= 1 ? '=' : b64chars.charAt(ord & 63)
17613         ];
17614         return chars.join('');
17615     };
17616     var btoa = global.btoa ? function(b) {
17617         return global.btoa(b);
17618     } : function(b) {
17619         return b.replace(/[\s\S]{1,3}/g, cb_encode);
17620     };
17621     var _encode = buffer ? function (u) {
17622         return (u.constructor === buffer.constructor ? u : new buffer(u))
17623         .toString('base64')
17624     }
17625     : function (u) { return btoa(utob(u)) }
17626     ;
17627     var encode = function(u, urisafe) {
17628         return !urisafe
17629             ? _encode(String(u))
17630             : _encode(String(u)).replace(/[+\/]/g, function(m0) {
17631                 return m0 == '+' ? '-' : '_';
17632             }).replace(/=/g, '');
17633     };
17634     var encodeURI = function(u) { return encode(u, true) };
17635     // decoder stuff
17636     var re_btou = new RegExp([
17637         '[\xC0-\xDF][\x80-\xBF]',
17638         '[\xE0-\xEF][\x80-\xBF]{2}',
17639         '[\xF0-\xF7][\x80-\xBF]{3}'
17640     ].join('|'), 'g');
17641     var cb_btou = function(cccc) {
17642         switch(cccc.length) {
17643         case 4:
17644             var cp = ((0x07 & cccc.charCodeAt(0)) << 18)
17645                 |    ((0x3f & cccc.charCodeAt(1)) << 12)
17646                 |    ((0x3f & cccc.charCodeAt(2)) <<  6)
17647                 |     (0x3f & cccc.charCodeAt(3)),
17648             offset = cp - 0x10000;
17649             return (fromCharCode((offset  >>> 10) + 0xD800)
17650                     + fromCharCode((offset & 0x3FF) + 0xDC00));
17651         case 3:
17652             return fromCharCode(
17653                 ((0x0f & cccc.charCodeAt(0)) << 12)
17654                     | ((0x3f & cccc.charCodeAt(1)) << 6)
17655                     |  (0x3f & cccc.charCodeAt(2))
17656             );
17657         default:
17658             return  fromCharCode(
17659                 ((0x1f & cccc.charCodeAt(0)) << 6)
17660                     |  (0x3f & cccc.charCodeAt(1))
17661             );
17662         }
17663     };
17664     var btou = function(b) {
17665         return b.replace(re_btou, cb_btou);
17666     };
17667     var cb_decode = function(cccc) {
17668         var len = cccc.length,
17669         padlen = len % 4,
17670         n = (len > 0 ? b64tab[cccc.charAt(0)] << 18 : 0)
17671             | (len > 1 ? b64tab[cccc.charAt(1)] << 12 : 0)
17672             | (len > 2 ? b64tab[cccc.charAt(2)] <<  6 : 0)
17673             | (len > 3 ? b64tab[cccc.charAt(3)]       : 0),
17674         chars = [
17675             fromCharCode( n >>> 16),
17676             fromCharCode((n >>>  8) & 0xff),
17677             fromCharCode( n         & 0xff)
17678         ];
17679         chars.length -= [0, 0, 2, 1][padlen];
17680         return chars.join('');
17681     };
17682     var atob = global.atob ? function(a) {
17683         return global.atob(a);
17684     } : function(a){
17685         return a.replace(/[\s\S]{1,4}/g, cb_decode);
17686     };
17687     var _decode = buffer ? function(a) {
17688         return (a.constructor === buffer.constructor
17689                 ? a : new buffer(a, 'base64')).toString();
17690     }
17691     : function(a) { return btou(atob(a)) };
17692     var decode = function(a){
17693         return _decode(
17694             String(a).replace(/[-_]/g, function(m0) { return m0 == '-' ? '+' : '/' })
17695                 .replace(/[^A-Za-z0-9\+\/]/g, '')
17696         );
17697     };
17698     var noConflict = function() {
17699         var Base64 = global.Base64;
17700         global.Base64 = _Base64;
17701         return Base64;
17702     };
17703     // export Base64
17704     global.Base64 = {
17705         VERSION: version,
17706         atob: atob,
17707         btoa: btoa,
17708         fromBase64: decode,
17709         toBase64: encode,
17710         utob: utob,
17711         encode: encode,
17712         encodeURI: encodeURI,
17713         btou: btou,
17714         decode: decode,
17715         noConflict: noConflict
17716     };
17717     // if ES5 is available, make Base64.extendString() available
17718     if (typeof Object.defineProperty === 'function') {
17719         var noEnum = function(v){
17720             return {value:v,enumerable:false,writable:true,configurable:true};
17721         };
17722         global.Base64.extendString = function () {
17723             Object.defineProperty(
17724                 String.prototype, 'fromBase64', noEnum(function () {
17725                     return decode(this)
17726                 }));
17727             Object.defineProperty(
17728                 String.prototype, 'toBase64', noEnum(function (urisafe) {
17729                     return encode(this, urisafe)
17730                 }));
17731             Object.defineProperty(
17732                 String.prototype, 'toBase64URI', noEnum(function () {
17733                     return encode(this, true)
17734                 }));
17735         };
17736     }
17737     // that's it!
17738 })(this);
17739
17740 if (this['Meteor']) {
17741     Base64 = global.Base64; // for normal export in Meteor.js
17742 }
17743
17744 }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
17745 },{"buffer":49}],115:[function(require,module,exports){
17746 /*
17747  * Copyright 2009-2011 Mozilla Foundation and contributors
17748  * Licensed under the New BSD license. See LICENSE.txt or:
17749  * http://opensource.org/licenses/BSD-3-Clause
17750  */
17751 exports.SourceMapGenerator = require('./source-map/source-map-generator').SourceMapGenerator;
17752 exports.SourceMapConsumer = require('./source-map/source-map-consumer').SourceMapConsumer;
17753 exports.SourceNode = require('./source-map/source-node').SourceNode;
17754
17755 },{"./source-map/source-map-consumer":123,"./source-map/source-map-generator":124,"./source-map/source-node":125}],116:[function(require,module,exports){
17756 /* -*- Mode: js; js-indent-level: 2; -*- */
17757 /*
17758  * Copyright 2011 Mozilla Foundation and contributors
17759  * Licensed under the New BSD license. See LICENSE or:
17760  * http://opensource.org/licenses/BSD-3-Clause
17761  */
17762 if (typeof define !== 'function') {
17763     var define = require('amdefine')(module, require);
17764 }
17765 define(function (require, exports, module) {
17766
17767   var util = require('./util');
17768
17769   /**
17770    * A data structure which is a combination of an array and a set. Adding a new
17771    * member is O(1), testing for membership is O(1), and finding the index of an
17772    * element is O(1). Removing elements from the set is not supported. Only
17773    * strings are supported for membership.
17774    */
17775   function ArraySet() {
17776     this._array = [];
17777     this._set = {};
17778   }
17779
17780   /**
17781    * Static method for creating ArraySet instances from an existing array.
17782    */
17783   ArraySet.fromArray = function ArraySet_fromArray(aArray, aAllowDuplicates) {
17784     var set = new ArraySet();
17785     for (var i = 0, len = aArray.length; i < len; i++) {
17786       set.add(aArray[i], aAllowDuplicates);
17787     }
17788     return set;
17789   };
17790
17791   /**
17792    * Add the given string to this set.
17793    *
17794    * @param String aStr
17795    */
17796   ArraySet.prototype.add = function ArraySet_add(aStr, aAllowDuplicates) {
17797     var isDuplicate = this.has(aStr);
17798     var idx = this._array.length;
17799     if (!isDuplicate || aAllowDuplicates) {
17800       this._array.push(aStr);
17801     }
17802     if (!isDuplicate) {
17803       this._set[util.toSetString(aStr)] = idx;
17804     }
17805   };
17806
17807   /**
17808    * Is the given string a member of this set?
17809    *
17810    * @param String aStr
17811    */
17812   ArraySet.prototype.has = function ArraySet_has(aStr) {
17813     return Object.prototype.hasOwnProperty.call(this._set,
17814                                                 util.toSetString(aStr));
17815   };
17816
17817   /**
17818    * What is the index of the given string in the array?
17819    *
17820    * @param String aStr
17821    */
17822   ArraySet.prototype.indexOf = function ArraySet_indexOf(aStr) {
17823     if (this.has(aStr)) {
17824       return this._set[util.toSetString(aStr)];
17825     }
17826     throw new Error('"' + aStr + '" is not in the set.');
17827   };
17828
17829   /**
17830    * What is the element at the given index?
17831    *
17832    * @param Number aIdx
17833    */
17834   ArraySet.prototype.at = function ArraySet_at(aIdx) {
17835     if (aIdx >= 0 && aIdx < this._array.length) {
17836       return this._array[aIdx];
17837     }
17838     throw new Error('No element indexed by ' + aIdx);
17839   };
17840
17841   /**
17842    * Returns the array representation of this set (which has the proper indices
17843    * indicated by indexOf). Note that this is a copy of the internal array used
17844    * for storing the members so that no one can mess with internal state.
17845    */
17846   ArraySet.prototype.toArray = function ArraySet_toArray() {
17847     return this._array.slice();
17848   };
17849
17850   exports.ArraySet = ArraySet;
17851
17852 });
17853
17854 },{"./util":126,"amdefine":127}],117:[function(require,module,exports){
17855 /* -*- Mode: js; js-indent-level: 2; -*- */
17856 /*
17857  * Copyright 2011 Mozilla Foundation and contributors
17858  * Licensed under the New BSD license. See LICENSE or:
17859  * http://opensource.org/licenses/BSD-3-Clause
17860  *
17861  * Based on the Base 64 VLQ implementation in Closure Compiler:
17862  * https://code.google.com/p/closure-compiler/source/browse/trunk/src/com/google/debugging/sourcemap/Base64VLQ.java
17863  *
17864  * Copyright 2011 The Closure Compiler Authors. All rights reserved.
17865  * Redistribution and use in source and binary forms, with or without
17866  * modification, are permitted provided that the following conditions are
17867  * met:
17868  *
17869  *  * Redistributions of source code must retain the above copyright
17870  *    notice, this list of conditions and the following disclaimer.
17871  *  * Redistributions in binary form must reproduce the above
17872  *    copyright notice, this list of conditions and the following
17873  *    disclaimer in the documentation and/or other materials provided
17874  *    with the distribution.
17875  *  * Neither the name of Google Inc. nor the names of its
17876  *    contributors may be used to endorse or promote products derived
17877  *    from this software without specific prior written permission.
17878  *
17879  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17880  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
17881  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
17882  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
17883  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
17884  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
17885  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
17886  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
17887  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
17888  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
17889  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
17890  */
17891 if (typeof define !== 'function') {
17892     var define = require('amdefine')(module, require);
17893 }
17894 define(function (require, exports, module) {
17895
17896   var base64 = require('./base64');
17897
17898   // A single base 64 digit can contain 6 bits of data. For the base 64 variable
17899   // length quantities we use in the source map spec, the first bit is the sign,
17900   // the next four bits are the actual value, and the 6th bit is the
17901   // continuation bit. The continuation bit tells us whether there are more
17902   // digits in this value following this digit.
17903   //
17904   //   Continuation
17905   //   |    Sign
17906   //   |    |
17907   //   V    V
17908   //   101011
17909
17910   var VLQ_BASE_SHIFT = 5;
17911
17912   // binary: 100000
17913   var VLQ_BASE = 1 << VLQ_BASE_SHIFT;
17914
17915   // binary: 011111
17916   var VLQ_BASE_MASK = VLQ_BASE - 1;
17917
17918   // binary: 100000
17919   var VLQ_CONTINUATION_BIT = VLQ_BASE;
17920
17921   /**
17922    * Converts from a two-complement value to a value where the sign bit is
17923    * placed in the least significant bit.  For example, as decimals:
17924    *   1 becomes 2 (10 binary), -1 becomes 3 (11 binary)
17925    *   2 becomes 4 (100 binary), -2 becomes 5 (101 binary)
17926    */
17927   function toVLQSigned(aValue) {
17928     return aValue < 0
17929       ? ((-aValue) << 1) + 1
17930       : (aValue << 1) + 0;
17931   }
17932
17933   /**
17934    * Converts to a two-complement value from a value where the sign bit is
17935    * placed in the least significant bit.  For example, as decimals:
17936    *   2 (10 binary) becomes 1, 3 (11 binary) becomes -1
17937    *   4 (100 binary) becomes 2, 5 (101 binary) becomes -2
17938    */
17939   function fromVLQSigned(aValue) {
17940     var isNegative = (aValue & 1) === 1;
17941     var shifted = aValue >> 1;
17942     return isNegative
17943       ? -shifted
17944       : shifted;
17945   }
17946
17947   /**
17948    * Returns the base 64 VLQ encoded value.
17949    */
17950   exports.encode = function base64VLQ_encode(aValue) {
17951     var encoded = "";
17952     var digit;
17953
17954     var vlq = toVLQSigned(aValue);
17955
17956     do {
17957       digit = vlq & VLQ_BASE_MASK;
17958       vlq >>>= VLQ_BASE_SHIFT;
17959       if (vlq > 0) {
17960         // There are still more digits in this value, so we must make sure the
17961         // continuation bit is marked.
17962         digit |= VLQ_CONTINUATION_BIT;
17963       }
17964       encoded += base64.encode(digit);
17965     } while (vlq > 0);
17966
17967     return encoded;
17968   };
17969
17970   /**
17971    * Decodes the next base 64 VLQ value from the given string and returns the
17972    * value and the rest of the string via the out parameter.
17973    */
17974   exports.decode = function base64VLQ_decode(aStr, aOutParam) {
17975     var i = 0;
17976     var strLen = aStr.length;
17977     var result = 0;
17978     var shift = 0;
17979     var continuation, digit;
17980
17981     do {
17982       if (i >= strLen) {
17983         throw new Error("Expected more digits in base 64 VLQ value.");
17984       }
17985       digit = base64.decode(aStr.charAt(i++));
17986       continuation = !!(digit & VLQ_CONTINUATION_BIT);
17987       digit &= VLQ_BASE_MASK;
17988       result = result + (digit << shift);
17989       shift += VLQ_BASE_SHIFT;
17990     } while (continuation);
17991
17992     aOutParam.value = fromVLQSigned(result);
17993     aOutParam.rest = aStr.slice(i);
17994   };
17995
17996 });
17997
17998 },{"./base64":118,"amdefine":127}],118:[function(require,module,exports){
17999 /* -*- Mode: js; js-indent-level: 2; -*- */
18000 /*
18001  * Copyright 2011 Mozilla Foundation and contributors
18002  * Licensed under the New BSD license. See LICENSE or:
18003  * http://opensource.org/licenses/BSD-3-Clause
18004  */
18005 if (typeof define !== 'function') {
18006     var define = require('amdefine')(module, require);
18007 }
18008 define(function (require, exports, module) {
18009
18010   var charToIntMap = {};
18011   var intToCharMap = {};
18012
18013   'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
18014     .split('')
18015     .forEach(function (ch, index) {
18016       charToIntMap[ch] = index;
18017       intToCharMap[index] = ch;
18018     });
18019
18020   /**
18021    * Encode an integer in the range of 0 to 63 to a single base 64 digit.
18022    */
18023   exports.encode = function base64_encode(aNumber) {
18024     if (aNumber in intToCharMap) {
18025       return intToCharMap[aNumber];
18026     }
18027     throw new TypeError("Must be between 0 and 63: " + aNumber);
18028   };
18029
18030   /**
18031    * Decode a single base 64 digit to an integer.
18032    */
18033   exports.decode = function base64_decode(aChar) {
18034     if (aChar in charToIntMap) {
18035       return charToIntMap[aChar];
18036     }
18037     throw new TypeError("Not a valid base 64 digit: " + aChar);
18038   };
18039
18040 });
18041
18042 },{"amdefine":127}],119:[function(require,module,exports){
18043 /* -*- Mode: js; js-indent-level: 2; -*- */
18044 /*
18045  * Copyright 2011 Mozilla Foundation and contributors
18046  * Licensed under the New BSD license. See LICENSE or:
18047  * http://opensource.org/licenses/BSD-3-Clause
18048  */
18049 if (typeof define !== 'function') {
18050     var define = require('amdefine')(module, require);
18051 }
18052 define(function (require, exports, module) {
18053
18054   var util = require('./util');
18055   var binarySearch = require('./binary-search');
18056   var ArraySet = require('./array-set').ArraySet;
18057   var base64VLQ = require('./base64-vlq');
18058   var SourceMapConsumer = require('./source-map-consumer').SourceMapConsumer;
18059
18060   /**
18061    * A BasicSourceMapConsumer instance represents a parsed source map which we can
18062    * query for information about the original file positions by giving it a file
18063    * position in the generated source.
18064    *
18065    * The only parameter is the raw source map (either as a JSON string, or
18066    * already parsed to an object). According to the spec, source maps have the
18067    * following attributes:
18068    *
18069    *   - version: Which version of the source map spec this map is following.
18070    *   - sources: An array of URLs to the original source files.
18071    *   - names: An array of identifiers which can be referrenced by individual mappings.
18072    *   - sourceRoot: Optional. The URL root from which all sources are relative.
18073    *   - sourcesContent: Optional. An array of contents of the original source files.
18074    *   - mappings: A string of base64 VLQs which contain the actual mappings.
18075    *   - file: Optional. The generated file this source map is associated with.
18076    *
18077    * Here is an example source map, taken from the source map spec[0]:
18078    *
18079    *     {
18080    *       version : 3,
18081    *       file: "out.js",
18082    *       sourceRoot : "",
18083    *       sources: ["foo.js", "bar.js"],
18084    *       names: ["src", "maps", "are", "fun"],
18085    *       mappings: "AA,AB;;ABCDE;"
18086    *     }
18087    *
18088    * [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit?pli=1#
18089    */
18090   function BasicSourceMapConsumer(aSourceMap) {
18091     var sourceMap = aSourceMap;
18092     if (typeof aSourceMap === 'string') {
18093       sourceMap = JSON.parse(aSourceMap.replace(/^\)\]\}'/, ''));
18094     }
18095
18096     var version = util.getArg(sourceMap, 'version');
18097     var sources = util.getArg(sourceMap, 'sources');
18098     // Sass 3.3 leaves out the 'names' array, so we deviate from the spec (which
18099     // requires the array) to play nice here.
18100     var names = util.getArg(sourceMap, 'names', []);
18101     var sourceRoot = util.getArg(sourceMap, 'sourceRoot', null);
18102     var sourcesContent = util.getArg(sourceMap, 'sourcesContent', null);
18103     var mappings = util.getArg(sourceMap, 'mappings');
18104     var file = util.getArg(sourceMap, 'file', null);
18105
18106     // Once again, Sass deviates from the spec and supplies the version as a
18107     // string rather than a number, so we use loose equality checking here.
18108     if (version != this._version) {
18109       throw new Error('Unsupported version: ' + version);
18110     }
18111
18112     // Some source maps produce relative source paths like "./foo.js" instead of
18113     // "foo.js".  Normalize these first so that future comparisons will succeed.
18114     // See bugzil.la/1090768.
18115     sources = sources.map(util.normalize);
18116
18117     // Pass `true` below to allow duplicate names and sources. While source maps
18118     // are intended to be compressed and deduplicated, the TypeScript compiler
18119     // sometimes generates source maps with duplicates in them. See Github issue
18120     // #72 and bugzil.la/889492.
18121     this._names = ArraySet.fromArray(names, true);
18122     this._sources = ArraySet.fromArray(sources, true);
18123
18124     this.sourceRoot = sourceRoot;
18125     this.sourcesContent = sourcesContent;
18126     this._mappings = mappings;
18127     this.file = file;
18128   }
18129
18130   BasicSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);
18131   BasicSourceMapConsumer.prototype.consumer = SourceMapConsumer;
18132
18133   /**
18134    * Create a BasicSourceMapConsumer from a SourceMapGenerator.
18135    *
18136    * @param SourceMapGenerator aSourceMap
18137    *        The source map that will be consumed.
18138    * @returns BasicSourceMapConsumer
18139    */
18140   BasicSourceMapConsumer.fromSourceMap =
18141     function SourceMapConsumer_fromSourceMap(aSourceMap) {
18142       var smc = Object.create(BasicSourceMapConsumer.prototype);
18143
18144       smc._names = ArraySet.fromArray(aSourceMap._names.toArray(), true);
18145       smc._sources = ArraySet.fromArray(aSourceMap._sources.toArray(), true);
18146       smc.sourceRoot = aSourceMap._sourceRoot;
18147       smc.sourcesContent = aSourceMap._generateSourcesContent(smc._sources.toArray(),
18148                                                               smc.sourceRoot);
18149       smc.file = aSourceMap._file;
18150
18151       smc.__generatedMappings = aSourceMap._mappings.toArray().slice();
18152       smc.__originalMappings = aSourceMap._mappings.toArray().slice()
18153         .sort(util.compareByOriginalPositions);
18154
18155       return smc;
18156     };
18157
18158   /**
18159    * The version of the source mapping spec that we are consuming.
18160    */
18161   BasicSourceMapConsumer.prototype._version = 3;
18162
18163   /**
18164    * The list of original sources.
18165    */
18166   Object.defineProperty(BasicSourceMapConsumer.prototype, 'sources', {
18167     get: function () {
18168       return this._sources.toArray().map(function (s) {
18169         return this.sourceRoot != null ? util.join(this.sourceRoot, s) : s;
18170       }, this);
18171     }
18172   });
18173
18174   /**
18175    * Parse the mappings in a string in to a data structure which we can easily
18176    * query (the ordered arrays in the `this.__generatedMappings` and
18177    * `this.__originalMappings` properties).
18178    */
18179   BasicSourceMapConsumer.prototype._parseMappings =
18180     function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {
18181       var generatedLine = 1;
18182       var previousGeneratedColumn = 0;
18183       var previousOriginalLine = 0;
18184       var previousOriginalColumn = 0;
18185       var previousSource = 0;
18186       var previousName = 0;
18187       var str = aStr;
18188       var temp = {};
18189       var mapping;
18190
18191       while (str.length > 0) {
18192         if (str.charAt(0) === ';') {
18193           generatedLine++;
18194           str = str.slice(1);
18195           previousGeneratedColumn = 0;
18196         }
18197         else if (str.charAt(0) === ',') {
18198           str = str.slice(1);
18199         }
18200         else {
18201           mapping = {};
18202           mapping.generatedLine = generatedLine;
18203
18204           // Generated column.
18205           base64VLQ.decode(str, temp);
18206           mapping.generatedColumn = previousGeneratedColumn + temp.value;
18207           previousGeneratedColumn = mapping.generatedColumn;
18208           str = temp.rest;
18209
18210           if (str.length > 0 && !this._nextCharIsMappingSeparator(str)) {
18211             // Original source.
18212             base64VLQ.decode(str, temp);
18213             mapping.source = this._sources.at(previousSource + temp.value);
18214             previousSource += temp.value;
18215             str = temp.rest;
18216             if (str.length === 0 || this._nextCharIsMappingSeparator(str)) {
18217               throw new Error('Found a source, but no line and column');
18218             }
18219
18220             // Original line.
18221             base64VLQ.decode(str, temp);
18222             mapping.originalLine = previousOriginalLine + temp.value;
18223             previousOriginalLine = mapping.originalLine;
18224             // Lines are stored 0-based
18225             mapping.originalLine += 1;
18226             str = temp.rest;
18227             if (str.length === 0 || this._nextCharIsMappingSeparator(str)) {
18228               throw new Error('Found a source and line, but no column');
18229             }
18230
18231             // Original column.
18232             base64VLQ.decode(str, temp);
18233             mapping.originalColumn = previousOriginalColumn + temp.value;
18234             previousOriginalColumn = mapping.originalColumn;
18235             str = temp.rest;
18236
18237             if (str.length > 0 && !this._nextCharIsMappingSeparator(str)) {
18238               // Original name.
18239               base64VLQ.decode(str, temp);
18240               mapping.name = this._names.at(previousName + temp.value);
18241               previousName += temp.value;
18242               str = temp.rest;
18243             }
18244           }
18245
18246           this.__generatedMappings.push(mapping);
18247           if (typeof mapping.originalLine === 'number') {
18248             this.__originalMappings.push(mapping);
18249           }
18250         }
18251       }
18252
18253       this.__generatedMappings.sort(util.compareByGeneratedPositions);
18254       this.__originalMappings.sort(util.compareByOriginalPositions);
18255     };
18256
18257   /**
18258    * Find the mapping that best matches the hypothetical "needle" mapping that
18259    * we are searching for in the given "haystack" of mappings.
18260    */
18261   BasicSourceMapConsumer.prototype._findMapping =
18262     function SourceMapConsumer_findMapping(aNeedle, aMappings, aLineName,
18263                                            aColumnName, aComparator) {
18264       // To return the position we are searching for, we must first find the
18265       // mapping for the given position and then return the opposite position it
18266       // points to. Because the mappings are sorted, we can use binary search to
18267       // find the best mapping.
18268
18269       if (aNeedle[aLineName] <= 0) {
18270         throw new TypeError('Line must be greater than or equal to 1, got '
18271                             + aNeedle[aLineName]);
18272       }
18273       if (aNeedle[aColumnName] < 0) {
18274         throw new TypeError('Column must be greater than or equal to 0, got '
18275                             + aNeedle[aColumnName]);
18276       }
18277
18278       return binarySearch.search(aNeedle, aMappings, aComparator);
18279     };
18280
18281   /**
18282    * Compute the last column for each generated mapping. The last column is
18283    * inclusive.
18284    */
18285   BasicSourceMapConsumer.prototype.computeColumnSpans =
18286     function SourceMapConsumer_computeColumnSpans() {
18287       for (var index = 0; index < this._generatedMappings.length; ++index) {
18288         var mapping = this._generatedMappings[index];
18289
18290         // Mappings do not contain a field for the last generated columnt. We
18291         // can come up with an optimistic estimate, however, by assuming that
18292         // mappings are contiguous (i.e. given two consecutive mappings, the
18293         // first mapping ends where the second one starts).
18294         if (index + 1 < this._generatedMappings.length) {
18295           var nextMapping = this._generatedMappings[index + 1];
18296
18297           if (mapping.generatedLine === nextMapping.generatedLine) {
18298             mapping.lastGeneratedColumn = nextMapping.generatedColumn - 1;
18299             continue;
18300           }
18301         }
18302
18303         // The last mapping for each line spans the entire line.
18304         mapping.lastGeneratedColumn = Infinity;
18305       }
18306     };
18307
18308   /**
18309    * Returns the original source, line, and column information for the generated
18310    * source's line and column positions provided. The only argument is an object
18311    * with the following properties:
18312    *
18313    *   - line: The line number in the generated source.
18314    *   - column: The column number in the generated source.
18315    *
18316    * and an object is returned with the following properties:
18317    *
18318    *   - source: The original source file, or null.
18319    *   - line: The line number in the original source, or null.
18320    *   - column: The column number in the original source, or null.
18321    *   - name: The original identifier, or null.
18322    */
18323   BasicSourceMapConsumer.prototype.originalPositionFor =
18324     function SourceMapConsumer_originalPositionFor(aArgs) {
18325       var needle = {
18326         generatedLine: util.getArg(aArgs, 'line'),
18327         generatedColumn: util.getArg(aArgs, 'column')
18328       };
18329
18330       var index = this._findMapping(needle,
18331                                     this._generatedMappings,
18332                                     "generatedLine",
18333                                     "generatedColumn",
18334                                     util.compareByGeneratedPositions);
18335
18336       if (index >= 0) {
18337         var mapping = this._generatedMappings[index];
18338
18339         if (mapping.generatedLine === needle.generatedLine) {
18340           var source = util.getArg(mapping, 'source', null);
18341           if (source != null && this.sourceRoot != null) {
18342             source = util.join(this.sourceRoot, source);
18343           }
18344           return {
18345             source: source,
18346             line: util.getArg(mapping, 'originalLine', null),
18347             column: util.getArg(mapping, 'originalColumn', null),
18348             name: util.getArg(mapping, 'name', null)
18349           };
18350         }
18351       }
18352
18353       return {
18354         source: null,
18355         line: null,
18356         column: null,
18357         name: null
18358       };
18359     };
18360
18361   /**
18362    * Returns the original source content. The only argument is the url of the
18363    * original source file. Returns null if no original source content is
18364    * availible.
18365    */
18366   BasicSourceMapConsumer.prototype.sourceContentFor =
18367     function SourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {
18368       if (!this.sourcesContent) {
18369         return null;
18370       }
18371
18372       if (this.sourceRoot != null) {
18373         aSource = util.relative(this.sourceRoot, aSource);
18374       }
18375
18376       if (this._sources.has(aSource)) {
18377         return this.sourcesContent[this._sources.indexOf(aSource)];
18378       }
18379
18380       var url;
18381       if (this.sourceRoot != null
18382           && (url = util.urlParse(this.sourceRoot))) {
18383         // XXX: file:// URIs and absolute paths lead to unexpected behavior for
18384         // many users. We can help them out when they expect file:// URIs to
18385         // behave like it would if they were running a local HTTP server. See
18386         // https://bugzilla.mozilla.org/show_bug.cgi?id=885597.
18387         var fileUriAbsPath = aSource.replace(/^file:\/\//, "");
18388         if (url.scheme == "file"
18389             && this._sources.has(fileUriAbsPath)) {
18390           return this.sourcesContent[this._sources.indexOf(fileUriAbsPath)]
18391         }
18392
18393         if ((!url.path || url.path == "/")
18394             && this._sources.has("/" + aSource)) {
18395           return this.sourcesContent[this._sources.indexOf("/" + aSource)];
18396         }
18397       }
18398
18399       // This function is used recursively from
18400       // IndexedSourceMapConsumer.prototype.sourceContentFor. In that case, we
18401       // don't want to throw if we can't find the source - we just want to
18402       // return null, so we provide a flag to exit gracefully.
18403       if (nullOnMissing) {
18404         return null;
18405       }
18406       else {
18407         throw new Error('"' + aSource + '" is not in the SourceMap.');
18408       }
18409     };
18410
18411   /**
18412    * Returns the generated line and column information for the original source,
18413    * line, and column positions provided. The only argument is an object with
18414    * the following properties:
18415    *
18416    *   - source: The filename of the original source.
18417    *   - line: The line number in the original source.
18418    *   - column: The column number in the original source.
18419    *
18420    * and an object is returned with the following properties:
18421    *
18422    *   - line: The line number in the generated source, or null.
18423    *   - column: The column number in the generated source, or null.
18424    */
18425   BasicSourceMapConsumer.prototype.generatedPositionFor =
18426     function SourceMapConsumer_generatedPositionFor(aArgs) {
18427       var needle = {
18428         source: util.getArg(aArgs, 'source'),
18429         originalLine: util.getArg(aArgs, 'line'),
18430         originalColumn: util.getArg(aArgs, 'column')
18431       };
18432
18433       if (this.sourceRoot != null) {
18434         needle.source = util.relative(this.sourceRoot, needle.source);
18435       }
18436
18437       var index = this._findMapping(needle,
18438                                     this._originalMappings,
18439                                     "originalLine",
18440                                     "originalColumn",
18441                                     util.compareByOriginalPositions);
18442
18443       if (index >= 0) {
18444         var mapping = this._originalMappings[index];
18445
18446         return {
18447           line: util.getArg(mapping, 'generatedLine', null),
18448           column: util.getArg(mapping, 'generatedColumn', null),
18449           lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)
18450         };
18451       }
18452
18453       return {
18454         line: null,
18455         column: null,
18456         lastColumn: null
18457       };
18458     };
18459
18460   exports.BasicSourceMapConsumer = BasicSourceMapConsumer;
18461
18462 });
18463
18464 },{"./array-set":116,"./base64-vlq":117,"./binary-search":120,"./source-map-consumer":123,"./util":126,"amdefine":127}],120:[function(require,module,exports){
18465 /* -*- Mode: js; js-indent-level: 2; -*- */
18466 /*
18467  * Copyright 2011 Mozilla Foundation and contributors
18468  * Licensed under the New BSD license. See LICENSE or:
18469  * http://opensource.org/licenses/BSD-3-Clause
18470  */
18471 if (typeof define !== 'function') {
18472     var define = require('amdefine')(module, require);
18473 }
18474 define(function (require, exports, module) {
18475
18476   /**
18477    * Recursive implementation of binary search.
18478    *
18479    * @param aLow Indices here and lower do not contain the needle.
18480    * @param aHigh Indices here and higher do not contain the needle.
18481    * @param aNeedle The element being searched for.
18482    * @param aHaystack The non-empty array being searched.
18483    * @param aCompare Function which takes two elements and returns -1, 0, or 1.
18484    */
18485   function recursiveSearch(aLow, aHigh, aNeedle, aHaystack, aCompare) {
18486     // This function terminates when one of the following is true:
18487     //
18488     //   1. We find the exact element we are looking for.
18489     //
18490     //   2. We did not find the exact element, but we can return the index of
18491     //      the next closest element that is less than that element.
18492     //
18493     //   3. We did not find the exact element, and there is no next-closest
18494     //      element which is less than the one we are searching for, so we
18495     //      return -1.
18496     var mid = Math.floor((aHigh - aLow) / 2) + aLow;
18497     var cmp = aCompare(aNeedle, aHaystack[mid], true);
18498     if (cmp === 0) {
18499       // Found the element we are looking for.
18500       return mid;
18501     }
18502     else if (cmp > 0) {
18503       // aHaystack[mid] is greater than our needle.
18504       if (aHigh - mid > 1) {
18505         // The element is in the upper half.
18506         return recursiveSearch(mid, aHigh, aNeedle, aHaystack, aCompare);
18507       }
18508       // We did not find an exact match, return the next closest one
18509       // (termination case 2).
18510       return mid;
18511     }
18512     else {
18513       // aHaystack[mid] is less than our needle.
18514       if (mid - aLow > 1) {
18515         // The element is in the lower half.
18516         return recursiveSearch(aLow, mid, aNeedle, aHaystack, aCompare);
18517       }
18518       // The exact needle element was not found in this haystack. Determine if
18519       // we are in termination case (2) or (3) and return the appropriate thing.
18520       return aLow < 0 ? -1 : aLow;
18521     }
18522   }
18523
18524   /**
18525    * This is an implementation of binary search which will always try and return
18526    * the index of next lowest value checked if there is no exact hit. This is
18527    * because mappings between original and generated line/col pairs are single
18528    * points, and there is an implicit region between each of them, so a miss
18529    * just means that you aren't on the very start of a region.
18530    *
18531    * @param aNeedle The element you are looking for.
18532    * @param aHaystack The array that is being searched.
18533    * @param aCompare A function which takes the needle and an element in the
18534    *     array and returns -1, 0, or 1 depending on whether the needle is less
18535    *     than, equal to, or greater than the element, respectively.
18536    */
18537   exports.search = function search(aNeedle, aHaystack, aCompare) {
18538     if (aHaystack.length === 0) {
18539       return -1;
18540     }
18541     return recursiveSearch(-1, aHaystack.length, aNeedle, aHaystack, aCompare)
18542   };
18543
18544 });
18545
18546 },{"amdefine":127}],121:[function(require,module,exports){
18547 /* -*- Mode: js; js-indent-level: 2; -*- */
18548 /*
18549  * Copyright 2011 Mozilla Foundation and contributors
18550  * Licensed under the New BSD license. See LICENSE or:
18551  * http://opensource.org/licenses/BSD-3-Clause
18552  */
18553 if (typeof define !== 'function') {
18554     var define = require('amdefine')(module, require);
18555 }
18556 define(function (require, exports, module) {
18557
18558   var util = require('./util');
18559   var binarySearch = require('./binary-search');
18560   var SourceMapConsumer = require('./source-map-consumer').SourceMapConsumer;
18561   var BasicSourceMapConsumer = require('./basic-source-map-consumer').BasicSourceMapConsumer;
18562
18563   /**
18564    * An IndexedSourceMapConsumer instance represents a parsed source map which
18565    * we can query for information. It differs from BasicSourceMapConsumer in
18566    * that it takes "indexed" source maps (i.e. ones with a "sections" field) as
18567    * input.
18568    *
18569    * The only parameter is a raw source map (either as a JSON string, or already
18570    * parsed to an object). According to the spec for indexed source maps, they
18571    * have the following attributes:
18572    *
18573    *   - version: Which version of the source map spec this map is following.
18574    *   - file: Optional. The generated file this source map is associated with.
18575    *   - sections: A list of section definitions.
18576    *
18577    * Each value under the "sections" field has two fields:
18578    *   - offset: The offset into the original specified at which this section
18579    *       begins to apply, defined as an object with a "line" and "column"
18580    *       field.
18581    *   - map: A source map definition. This source map could also be indexed,
18582    *       but doesn't have to be.
18583    *
18584    * Instead of the "map" field, it's also possible to have a "url" field
18585    * specifying a URL to retrieve a source map from, but that's currently
18586    * unsupported.
18587    *
18588    * Here's an example source map, taken from the source map spec[0], but
18589    * modified to omit a section which uses the "url" field.
18590    *
18591    *  {
18592    *    version : 3,
18593    *    file: "app.js",
18594    *    sections: [{
18595    *      offset: {line:100, column:10},
18596    *      map: {
18597    *        version : 3,
18598    *        file: "section.js",
18599    *        sources: ["foo.js", "bar.js"],
18600    *        names: ["src", "maps", "are", "fun"],
18601    *        mappings: "AAAA,E;;ABCDE;"
18602    *      }
18603    *    }],
18604    *  }
18605    *
18606    * [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit#heading=h.535es3xeprgt
18607    */
18608   function IndexedSourceMapConsumer(aSourceMap) {
18609     var sourceMap = aSourceMap;
18610     if (typeof aSourceMap === 'string') {
18611       sourceMap = JSON.parse(aSourceMap.replace(/^\)\]\}'/, ''));
18612     }
18613
18614     var version = util.getArg(sourceMap, 'version');
18615     var sections = util.getArg(sourceMap, 'sections');
18616
18617     if (version != this._version) {
18618       throw new Error('Unsupported version: ' + version);
18619     }
18620
18621     var lastOffset = {
18622       line: -1,
18623       column: 0
18624     };
18625     this._sections = sections.map(function (s) {
18626       if (s.url) {
18627         // The url field will require support for asynchronicity.
18628         // See https://github.com/mozilla/source-map/issues/16
18629         throw new Error('Support for url field in sections not implemented.');
18630       }
18631       var offset = util.getArg(s, 'offset');
18632       var offsetLine = util.getArg(offset, 'line');
18633       var offsetColumn = util.getArg(offset, 'column');
18634
18635       if (offsetLine < lastOffset.line ||
18636           (offsetLine === lastOffset.line && offsetColumn < lastOffset.column)) {
18637         throw new Error('Section offsets must be ordered and non-overlapping.');
18638       }
18639       lastOffset = offset;
18640
18641       return {
18642         generatedOffset: {
18643           // The offset fields are 0-based, but we use 1-based indices when
18644           // encoding/decoding from VLQ.
18645           generatedLine: offsetLine + 1,
18646           generatedColumn: offsetColumn + 1
18647         },
18648         consumer: new SourceMapConsumer(util.getArg(s, 'map'))
18649       }
18650     });
18651   }
18652
18653   IndexedSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);
18654   IndexedSourceMapConsumer.prototype.constructor = SourceMapConsumer;
18655
18656   /**
18657    * The version of the source mapping spec that we are consuming.
18658    */
18659   IndexedSourceMapConsumer.prototype._version = 3;
18660
18661   /**
18662    * The list of original sources.
18663    */
18664   Object.defineProperty(IndexedSourceMapConsumer.prototype, 'sources', {
18665     get: function () {
18666       var sources = [];
18667       for (var i = 0; i < this._sections.length; i++) {
18668         for (var j = 0; j < this._sections[i].consumer.sources.length; j++) {
18669           sources.push(this._sections[i].consumer.sources[j]);
18670         }
18671       };
18672       return sources;
18673     }
18674   });
18675
18676   /**
18677    * Returns the original source, line, and column information for the generated
18678    * source's line and column positions provided. The only argument is an object
18679    * with the following properties:
18680    *
18681    *   - line: The line number in the generated source.
18682    *   - column: The column number in the generated source.
18683    *
18684    * and an object is returned with the following properties:
18685    *
18686    *   - source: The original source file, or null.
18687    *   - line: The line number in the original source, or null.
18688    *   - column: The column number in the original source, or null.
18689    *   - name: The original identifier, or null.
18690    */
18691   IndexedSourceMapConsumer.prototype.originalPositionFor =
18692     function IndexedSourceMapConsumer_originalPositionFor(aArgs) {
18693       var needle = {
18694         generatedLine: util.getArg(aArgs, 'line'),
18695         generatedColumn: util.getArg(aArgs, 'column')
18696       };
18697
18698       // Find the section containing the generated position we're trying to map
18699       // to an original position.
18700       var sectionIndex = binarySearch.search(needle, this._sections,
18701         function(needle, section) {
18702           var cmp = needle.generatedLine - section.generatedOffset.generatedLine;
18703           if (cmp) {
18704             return cmp;
18705           }
18706
18707           return (needle.generatedColumn -
18708                   section.generatedOffset.generatedColumn);
18709         });
18710       var section = this._sections[sectionIndex];
18711
18712       if (!section) {
18713         return {
18714           source: null,
18715           line: null,
18716           column: null,
18717           name: null
18718         };
18719       }
18720
18721       return section.consumer.originalPositionFor({
18722         line: needle.generatedLine -
18723           (section.generatedOffset.generatedLine - 1),
18724         column: needle.generatedColumn -
18725           (section.generatedOffset.generatedLine === needle.generatedLine
18726            ? section.generatedOffset.generatedColumn - 1
18727            : 0)
18728       });
18729     };
18730
18731   /**
18732    * Returns the original source content. The only argument is the url of the
18733    * original source file. Returns null if no original source content is
18734    * available.
18735    */
18736   IndexedSourceMapConsumer.prototype.sourceContentFor =
18737     function IndexedSourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {
18738       for (var i = 0; i < this._sections.length; i++) {
18739         var section = this._sections[i];
18740
18741         var content = section.consumer.sourceContentFor(aSource, true);
18742         if (content) {
18743           return content;
18744         }
18745       }
18746       if (nullOnMissing) {
18747         return null;
18748       }
18749       else {
18750         throw new Error('"' + aSource + '" is not in the SourceMap.');
18751       }
18752     };
18753
18754   /**
18755    * Returns the generated line and column information for the original source,
18756    * line, and column positions provided. The only argument is an object with
18757    * the following properties:
18758    *
18759    *   - source: The filename of the original source.
18760    *   - line: The line number in the original source.
18761    *   - column: The column number in the original source.
18762    *
18763    * and an object is returned with the following properties:
18764    *
18765    *   - line: The line number in the generated source, or null.
18766    *   - column: The column number in the generated source, or null.
18767    */
18768   IndexedSourceMapConsumer.prototype.generatedPositionFor =
18769     function IndexedSourceMapConsumer_generatedPositionFor(aArgs) {
18770       for (var i = 0; i < this._sections.length; i++) {
18771         var section = this._sections[i];
18772
18773         // Only consider this section if the requested source is in the list of
18774         // sources of the consumer.
18775         if (section.consumer.sources.indexOf(util.getArg(aArgs, 'source')) === -1) {
18776           continue;
18777         }
18778         var generatedPosition = section.consumer.generatedPositionFor(aArgs);
18779         if (generatedPosition) {
18780           var ret = {
18781             line: generatedPosition.line +
18782               (section.generatedOffset.generatedLine - 1),
18783             column: generatedPosition.column +
18784               (section.generatedOffset.generatedLine === generatedPosition.line
18785                ? section.generatedOffset.generatedColumn - 1
18786                : 0)
18787           };
18788           return ret;
18789         }
18790       }
18791
18792       return {
18793         line: null,
18794         column: null
18795       };
18796     };
18797
18798   /**
18799    * Parse the mappings in a string in to a data structure which we can easily
18800    * query (the ordered arrays in the `this.__generatedMappings` and
18801    * `this.__originalMappings` properties).
18802    */
18803   IndexedSourceMapConsumer.prototype._parseMappings =
18804     function IndexedSourceMapConsumer_parseMappings(aStr, aSourceRoot) {
18805       this.__generatedMappings = [];
18806       this.__originalMappings = [];
18807       for (var i = 0; i < this._sections.length; i++) {
18808         var section = this._sections[i];
18809         var sectionMappings = section.consumer._generatedMappings;
18810         for (var j = 0; j < sectionMappings.length; j++) {
18811           var mapping = sectionMappings[i];
18812
18813           var source = mapping.source;
18814           var sourceRoot = section.consumer.sourceRoot;
18815
18816           if (source != null && sourceRoot != null) {
18817             source = util.join(sourceRoot, source);
18818           }
18819
18820           // The mappings coming from the consumer for the section have
18821           // generated positions relative to the start of the section, so we
18822           // need to offset them to be relative to the start of the concatenated
18823           // generated file.
18824           var adjustedMapping = {
18825             source: source,
18826             generatedLine: mapping.generatedLine +
18827               (section.generatedOffset.generatedLine - 1),
18828             generatedColumn: mapping.column +
18829               (section.generatedOffset.generatedLine === mapping.generatedLine)
18830               ? section.generatedOffset.generatedColumn - 1
18831               : 0,
18832             originalLine: mapping.originalLine,
18833             originalColumn: mapping.originalColumn,
18834             name: mapping.name
18835           };
18836
18837           this.__generatedMappings.push(adjustedMapping);
18838           if (typeof adjustedMapping.originalLine === 'number') {
18839             this.__originalMappings.push(adjustedMapping);
18840           }
18841         };
18842       };
18843
18844     this.__generatedMappings.sort(util.compareByGeneratedPositions);
18845     this.__originalMappings.sort(util.compareByOriginalPositions);
18846   };
18847
18848   exports.IndexedSourceMapConsumer = IndexedSourceMapConsumer;
18849 });
18850
18851 },{"./basic-source-map-consumer":119,"./binary-search":120,"./source-map-consumer":123,"./util":126,"amdefine":127}],122:[function(require,module,exports){
18852 /* -*- Mode: js; js-indent-level: 2; -*- */
18853 /*
18854  * Copyright 2014 Mozilla Foundation and contributors
18855  * Licensed under the New BSD license. See LICENSE or:
18856  * http://opensource.org/licenses/BSD-3-Clause
18857  */
18858 if (typeof define !== 'function') {
18859     var define = require('amdefine')(module, require);
18860 }
18861 define(function (require, exports, module) {
18862
18863   var util = require('./util');
18864
18865   /**
18866    * Determine whether mappingB is after mappingA with respect to generated
18867    * position.
18868    */
18869   function generatedPositionAfter(mappingA, mappingB) {
18870     // Optimized for most common case
18871     var lineA = mappingA.generatedLine;
18872     var lineB = mappingB.generatedLine;
18873     var columnA = mappingA.generatedColumn;
18874     var columnB = mappingB.generatedColumn;
18875     return lineB > lineA || lineB == lineA && columnB >= columnA ||
18876            util.compareByGeneratedPositions(mappingA, mappingB) <= 0;
18877   }
18878
18879   /**
18880    * A data structure to provide a sorted view of accumulated mappings in a
18881    * performance conscious manner. It trades a neglibable overhead in general
18882    * case for a large speedup in case of mappings being added in order.
18883    */
18884   function MappingList() {
18885     this._array = [];
18886     this._sorted = true;
18887     // Serves as infimum
18888     this._last = {generatedLine: -1, generatedColumn: 0};
18889   }
18890
18891   /**
18892    * Iterate through internal items. This method takes the same arguments that
18893    * `Array.prototype.forEach` takes.
18894    *
18895    * NOTE: The order of the mappings is NOT guaranteed.
18896    */
18897   MappingList.prototype.unsortedForEach =
18898     function MappingList_forEach(aCallback, aThisArg) {
18899       this._array.forEach(aCallback, aThisArg);
18900     };
18901
18902   /**
18903    * Add the given source mapping.
18904    *
18905    * @param Object aMapping
18906    */
18907   MappingList.prototype.add = function MappingList_add(aMapping) {
18908     var mapping;
18909     if (generatedPositionAfter(this._last, aMapping)) {
18910       this._last = aMapping;
18911       this._array.push(aMapping);
18912     } else {
18913       this._sorted = false;
18914       this._array.push(aMapping);
18915     }
18916   };
18917
18918   /**
18919    * Returns the flat, sorted array of mappings. The mappings are sorted by
18920    * generated position.
18921    *
18922    * WARNING: This method returns internal data without copying, for
18923    * performance. The return value must NOT be mutated, and should be treated as
18924    * an immutable borrow. If you want to take ownership, you must make your own
18925    * copy.
18926    */
18927   MappingList.prototype.toArray = function MappingList_toArray() {
18928     if (!this._sorted) {
18929       this._array.sort(util.compareByGeneratedPositions);
18930       this._sorted = true;
18931     }
18932     return this._array;
18933   };
18934
18935   exports.MappingList = MappingList;
18936
18937 });
18938
18939 },{"./util":126,"amdefine":127}],123:[function(require,module,exports){
18940 /* -*- Mode: js; js-indent-level: 2; -*- */
18941 /*
18942  * Copyright 2011 Mozilla Foundation and contributors
18943  * Licensed under the New BSD license. See LICENSE or:
18944  * http://opensource.org/licenses/BSD-3-Clause
18945  */
18946 if (typeof define !== 'function') {
18947     var define = require('amdefine')(module, require);
18948 }
18949 define(function (require, exports, module) {
18950
18951   var util = require('./util');
18952
18953   function SourceMapConsumer(aSourceMap) {
18954     var sourceMap = aSourceMap;
18955     if (typeof aSourceMap === 'string') {
18956       sourceMap = JSON.parse(aSourceMap.replace(/^\)\]\}'/, ''));
18957     }
18958
18959     // We do late requires because the subclasses require() this file.
18960     if (sourceMap.sections != null) {
18961       var indexedSourceMapConsumer = require('./indexed-source-map-consumer');
18962       return new indexedSourceMapConsumer.IndexedSourceMapConsumer(sourceMap);
18963     } else {
18964       var basicSourceMapConsumer = require('./basic-source-map-consumer');
18965       return new basicSourceMapConsumer.BasicSourceMapConsumer(sourceMap);
18966     }
18967   }
18968
18969   SourceMapConsumer.fromSourceMap = function(aSourceMap) {
18970     var basicSourceMapConsumer = require('./basic-source-map-consumer');
18971     return basicSourceMapConsumer.BasicSourceMapConsumer
18972             .fromSourceMap(aSourceMap);
18973   }
18974
18975   /**
18976    * The version of the source mapping spec that we are consuming.
18977    */
18978   SourceMapConsumer.prototype._version = 3;
18979
18980
18981   // `__generatedMappings` and `__originalMappings` are arrays that hold the
18982   // parsed mapping coordinates from the source map's "mappings" attribute. They
18983   // are lazily instantiated, accessed via the `_generatedMappings` and
18984   // `_originalMappings` getters respectively, and we only parse the mappings
18985   // and create these arrays once queried for a source location. We jump through
18986   // these hoops because there can be many thousands of mappings, and parsing
18987   // them is expensive, so we only want to do it if we must.
18988   //
18989   // Each object in the arrays is of the form:
18990   //
18991   //     {
18992   //       generatedLine: The line number in the generated code,
18993   //       generatedColumn: The column number in the generated code,
18994   //       source: The path to the original source file that generated this
18995   //               chunk of code,
18996   //       originalLine: The line number in the original source that
18997   //                     corresponds to this chunk of generated code,
18998   //       originalColumn: The column number in the original source that
18999   //                       corresponds to this chunk of generated code,
19000   //       name: The name of the original symbol which generated this chunk of
19001   //             code.
19002   //     }
19003   //
19004   // All properties except for `generatedLine` and `generatedColumn` can be
19005   // `null`.
19006   //
19007   // `_generatedMappings` is ordered by the generated positions.
19008   //
19009   // `_originalMappings` is ordered by the original positions.
19010
19011   SourceMapConsumer.prototype.__generatedMappings = null;
19012   Object.defineProperty(SourceMapConsumer.prototype, '_generatedMappings', {
19013     get: function () {
19014       if (!this.__generatedMappings) {
19015         this.__generatedMappings = [];
19016         this.__originalMappings = [];
19017         this._parseMappings(this._mappings, this.sourceRoot);
19018       }
19019
19020       return this.__generatedMappings;
19021     }
19022   });
19023
19024   SourceMapConsumer.prototype.__originalMappings = null;
19025   Object.defineProperty(SourceMapConsumer.prototype, '_originalMappings', {
19026     get: function () {
19027       if (!this.__originalMappings) {
19028         this.__generatedMappings = [];
19029         this.__originalMappings = [];
19030         this._parseMappings(this._mappings, this.sourceRoot);
19031       }
19032
19033       return this.__originalMappings;
19034     }
19035   });
19036
19037   SourceMapConsumer.prototype._nextCharIsMappingSeparator =
19038     function SourceMapConsumer_nextCharIsMappingSeparator(aStr) {
19039       var c = aStr.charAt(0);
19040       return c === ";" || c === ",";
19041     };
19042
19043   /**
19044    * Parse the mappings in a string in to a data structure which we can easily
19045    * query (the ordered arrays in the `this.__generatedMappings` and
19046    * `this.__originalMappings` properties).
19047    */
19048   SourceMapConsumer.prototype._parseMappings =
19049     function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {
19050       throw new Error("Subclasses must implement _parseMappings");
19051     };
19052
19053   SourceMapConsumer.GENERATED_ORDER = 1;
19054   SourceMapConsumer.ORIGINAL_ORDER = 2;
19055
19056   /**
19057    * Iterate over each mapping between an original source/line/column and a
19058    * generated line/column in this source map.
19059    *
19060    * @param Function aCallback
19061    *        The function that is called with each mapping.
19062    * @param Object aContext
19063    *        Optional. If specified, this object will be the value of `this` every
19064    *        time that `aCallback` is called.
19065    * @param aOrder
19066    *        Either `SourceMapConsumer.GENERATED_ORDER` or
19067    *        `SourceMapConsumer.ORIGINAL_ORDER`. Specifies whether you want to
19068    *        iterate over the mappings sorted by the generated file's line/column
19069    *        order or the original's source/line/column order, respectively. Defaults to
19070    *        `SourceMapConsumer.GENERATED_ORDER`.
19071    */
19072   SourceMapConsumer.prototype.eachMapping =
19073     function SourceMapConsumer_eachMapping(aCallback, aContext, aOrder) {
19074       var context = aContext || null;
19075       var order = aOrder || SourceMapConsumer.GENERATED_ORDER;
19076
19077       var mappings;
19078       switch (order) {
19079       case SourceMapConsumer.GENERATED_ORDER:
19080         mappings = this._generatedMappings;
19081         break;
19082       case SourceMapConsumer.ORIGINAL_ORDER:
19083         mappings = this._originalMappings;
19084         break;
19085       default:
19086         throw new Error("Unknown order of iteration.");
19087       }
19088
19089       var sourceRoot = this.sourceRoot;
19090       mappings.map(function (mapping) {
19091         var source = mapping.source;
19092         if (source != null && sourceRoot != null) {
19093           source = util.join(sourceRoot, source);
19094         }
19095         return {
19096           source: source,
19097           generatedLine: mapping.generatedLine,
19098           generatedColumn: mapping.generatedColumn,
19099           originalLine: mapping.originalLine,
19100           originalColumn: mapping.originalColumn,
19101           name: mapping.name
19102         };
19103       }).forEach(aCallback, context);
19104     };
19105
19106   /**
19107    * Returns all generated line and column information for the original source
19108    * and line provided. The only argument is an object with the following
19109    * properties:
19110    *
19111    *   - source: The filename of the original source.
19112    *   - line: The line number in the original source.
19113    *
19114    * and an array of objects is returned, each with the following properties:
19115    *
19116    *   - line: The line number in the generated source, or null.
19117    *   - column: The column number in the generated source, or null.
19118    */
19119   SourceMapConsumer.prototype.allGeneratedPositionsFor =
19120     function SourceMapConsumer_allGeneratedPositionsFor(aArgs) {
19121       // When there is no exact match, BasicSourceMapConsumer.prototype._findMapping
19122       // returns the index of the closest mapping less than the needle. By
19123       // setting needle.originalColumn to Infinity, we thus find the last
19124       // mapping for the given line, provided such a mapping exists.
19125       var needle = {
19126         source: util.getArg(aArgs, 'source'),
19127         originalLine: util.getArg(aArgs, 'line'),
19128         originalColumn: Infinity
19129       };
19130
19131       if (this.sourceRoot != null) {
19132         needle.source = util.relative(this.sourceRoot, needle.source);
19133       }
19134
19135       var mappings = [];
19136
19137       var index = this._findMapping(needle,
19138                                     this._originalMappings,
19139                                     "originalLine",
19140                                     "originalColumn",
19141                                     util.compareByOriginalPositions);
19142       if (index >= 0) {
19143         var mapping = this._originalMappings[index];
19144
19145         while (mapping && mapping.originalLine === needle.originalLine) {
19146           mappings.push({
19147             line: util.getArg(mapping, 'generatedLine', null),
19148             column: util.getArg(mapping, 'generatedColumn', null),
19149             lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)
19150           });
19151
19152           mapping = this._originalMappings[--index];
19153         }
19154       }
19155
19156       return mappings.reverse();
19157     };
19158
19159   exports.SourceMapConsumer = SourceMapConsumer;
19160
19161 });
19162
19163 },{"./basic-source-map-consumer":119,"./indexed-source-map-consumer":121,"./util":126,"amdefine":127}],124:[function(require,module,exports){
19164 /* -*- Mode: js; js-indent-level: 2; -*- */
19165 /*
19166  * Copyright 2011 Mozilla Foundation and contributors
19167  * Licensed under the New BSD license. See LICENSE or:
19168  * http://opensource.org/licenses/BSD-3-Clause
19169  */
19170 if (typeof define !== 'function') {
19171     var define = require('amdefine')(module, require);
19172 }
19173 define(function (require, exports, module) {
19174
19175   var base64VLQ = require('./base64-vlq');
19176   var util = require('./util');
19177   var ArraySet = require('./array-set').ArraySet;
19178   var MappingList = require('./mapping-list').MappingList;
19179
19180   /**
19181    * An instance of the SourceMapGenerator represents a source map which is
19182    * being built incrementally. You may pass an object with the following
19183    * properties:
19184    *
19185    *   - file: The filename of the generated source.
19186    *   - sourceRoot: A root for all relative URLs in this source map.
19187    */
19188   function SourceMapGenerator(aArgs) {
19189     if (!aArgs) {
19190       aArgs = {};
19191     }
19192     this._file = util.getArg(aArgs, 'file', null);
19193     this._sourceRoot = util.getArg(aArgs, 'sourceRoot', null);
19194     this._skipValidation = util.getArg(aArgs, 'skipValidation', false);
19195     this._sources = new ArraySet();
19196     this._names = new ArraySet();
19197     this._mappings = new MappingList();
19198     this._sourcesContents = null;
19199   }
19200
19201   SourceMapGenerator.prototype._version = 3;
19202
19203   /**
19204    * Creates a new SourceMapGenerator based on a SourceMapConsumer
19205    *
19206    * @param aSourceMapConsumer The SourceMap.
19207    */
19208   SourceMapGenerator.fromSourceMap =
19209     function SourceMapGenerator_fromSourceMap(aSourceMapConsumer) {
19210       var sourceRoot = aSourceMapConsumer.sourceRoot;
19211       var generator = new SourceMapGenerator({
19212         file: aSourceMapConsumer.file,
19213         sourceRoot: sourceRoot
19214       });
19215       aSourceMapConsumer.eachMapping(function (mapping) {
19216         var newMapping = {
19217           generated: {
19218             line: mapping.generatedLine,
19219             column: mapping.generatedColumn
19220           }
19221         };
19222
19223         if (mapping.source != null) {
19224           newMapping.source = mapping.source;
19225           if (sourceRoot != null) {
19226             newMapping.source = util.relative(sourceRoot, newMapping.source);
19227           }
19228
19229           newMapping.original = {
19230             line: mapping.originalLine,
19231             column: mapping.originalColumn
19232           };
19233
19234           if (mapping.name != null) {
19235             newMapping.name = mapping.name;
19236           }
19237         }
19238
19239         generator.addMapping(newMapping);
19240       });
19241       aSourceMapConsumer.sources.forEach(function (sourceFile) {
19242         var content = aSourceMapConsumer.sourceContentFor(sourceFile);
19243         if (content != null) {
19244           generator.setSourceContent(sourceFile, content);
19245         }
19246       });
19247       return generator;
19248     };
19249
19250   /**
19251    * Add a single mapping from original source line and column to the generated
19252    * source's line and column for this source map being created. The mapping
19253    * object should have the following properties:
19254    *
19255    *   - generated: An object with the generated line and column positions.
19256    *   - original: An object with the original line and column positions.
19257    *   - source: The original source file (relative to the sourceRoot).
19258    *   - name: An optional original token name for this mapping.
19259    */
19260   SourceMapGenerator.prototype.addMapping =
19261     function SourceMapGenerator_addMapping(aArgs) {
19262       var generated = util.getArg(aArgs, 'generated');
19263       var original = util.getArg(aArgs, 'original', null);
19264       var source = util.getArg(aArgs, 'source', null);
19265       var name = util.getArg(aArgs, 'name', null);
19266
19267       if (!this._skipValidation) {
19268         this._validateMapping(generated, original, source, name);
19269       }
19270
19271       if (source != null && !this._sources.has(source)) {
19272         this._sources.add(source);
19273       }
19274
19275       if (name != null && !this._names.has(name)) {
19276         this._names.add(name);
19277       }
19278
19279       this._mappings.add({
19280         generatedLine: generated.line,
19281         generatedColumn: generated.column,
19282         originalLine: original != null && original.line,
19283         originalColumn: original != null && original.column,
19284         source: source,
19285         name: name
19286       });
19287     };
19288
19289   /**
19290    * Set the source content for a source file.
19291    */
19292   SourceMapGenerator.prototype.setSourceContent =
19293     function SourceMapGenerator_setSourceContent(aSourceFile, aSourceContent) {
19294       var source = aSourceFile;
19295       if (this._sourceRoot != null) {
19296         source = util.relative(this._sourceRoot, source);
19297       }
19298
19299       if (aSourceContent != null) {
19300         // Add the source content to the _sourcesContents map.
19301         // Create a new _sourcesContents map if the property is null.
19302         if (!this._sourcesContents) {
19303           this._sourcesContents = {};
19304         }
19305         this._sourcesContents[util.toSetString(source)] = aSourceContent;
19306       } else if (this._sourcesContents) {
19307         // Remove the source file from the _sourcesContents map.
19308         // If the _sourcesContents map is empty, set the property to null.
19309         delete this._sourcesContents[util.toSetString(source)];
19310         if (Object.keys(this._sourcesContents).length === 0) {
19311           this._sourcesContents = null;
19312         }
19313       }
19314     };
19315
19316   /**
19317    * Applies the mappings of a sub-source-map for a specific source file to the
19318    * source map being generated. Each mapping to the supplied source file is
19319    * rewritten using the supplied source map. Note: The resolution for the
19320    * resulting mappings is the minimium of this map and the supplied map.
19321    *
19322    * @param aSourceMapConsumer The source map to be applied.
19323    * @param aSourceFile Optional. The filename of the source file.
19324    *        If omitted, SourceMapConsumer's file property will be used.
19325    * @param aSourceMapPath Optional. The dirname of the path to the source map
19326    *        to be applied. If relative, it is relative to the SourceMapConsumer.
19327    *        This parameter is needed when the two source maps aren't in the same
19328    *        directory, and the source map to be applied contains relative source
19329    *        paths. If so, those relative source paths need to be rewritten
19330    *        relative to the SourceMapGenerator.
19331    */
19332   SourceMapGenerator.prototype.applySourceMap =
19333     function SourceMapGenerator_applySourceMap(aSourceMapConsumer, aSourceFile, aSourceMapPath) {
19334       var sourceFile = aSourceFile;
19335       // If aSourceFile is omitted, we will use the file property of the SourceMap
19336       if (aSourceFile == null) {
19337         if (aSourceMapConsumer.file == null) {
19338           throw new Error(
19339             'SourceMapGenerator.prototype.applySourceMap requires either an explicit source file, ' +
19340             'or the source map\'s "file" property. Both were omitted.'
19341           );
19342         }
19343         sourceFile = aSourceMapConsumer.file;
19344       }
19345       var sourceRoot = this._sourceRoot;
19346       // Make "sourceFile" relative if an absolute Url is passed.
19347       if (sourceRoot != null) {
19348         sourceFile = util.relative(sourceRoot, sourceFile);
19349       }
19350       // Applying the SourceMap can add and remove items from the sources and
19351       // the names array.
19352       var newSources = new ArraySet();
19353       var newNames = new ArraySet();
19354
19355       // Find mappings for the "sourceFile"
19356       this._mappings.unsortedForEach(function (mapping) {
19357         if (mapping.source === sourceFile && mapping.originalLine != null) {
19358           // Check if it can be mapped by the source map, then update the mapping.
19359           var original = aSourceMapConsumer.originalPositionFor({
19360             line: mapping.originalLine,
19361             column: mapping.originalColumn
19362           });
19363           if (original.source != null) {
19364             // Copy mapping
19365             mapping.source = original.source;
19366             if (aSourceMapPath != null) {
19367               mapping.source = util.join(aSourceMapPath, mapping.source)
19368             }
19369             if (sourceRoot != null) {
19370               mapping.source = util.relative(sourceRoot, mapping.source);
19371             }
19372             mapping.originalLine = original.line;
19373             mapping.originalColumn = original.column;
19374             if (original.name != null) {
19375               mapping.name = original.name;
19376             }
19377           }
19378         }
19379
19380         var source = mapping.source;
19381         if (source != null && !newSources.has(source)) {
19382           newSources.add(source);
19383         }
19384
19385         var name = mapping.name;
19386         if (name != null && !newNames.has(name)) {
19387           newNames.add(name);
19388         }
19389
19390       }, this);
19391       this._sources = newSources;
19392       this._names = newNames;
19393
19394       // Copy sourcesContents of applied map.
19395       aSourceMapConsumer.sources.forEach(function (sourceFile) {
19396         var content = aSourceMapConsumer.sourceContentFor(sourceFile);
19397         if (content != null) {
19398           if (aSourceMapPath != null) {
19399             sourceFile = util.join(aSourceMapPath, sourceFile);
19400           }
19401           if (sourceRoot != null) {
19402             sourceFile = util.relative(sourceRoot, sourceFile);
19403           }
19404           this.setSourceContent(sourceFile, content);
19405         }
19406       }, this);
19407     };
19408
19409   /**
19410    * A mapping can have one of the three levels of data:
19411    *
19412    *   1. Just the generated position.
19413    *   2. The Generated position, original position, and original source.
19414    *   3. Generated and original position, original source, as well as a name
19415    *      token.
19416    *
19417    * To maintain consistency, we validate that any new mapping being added falls
19418    * in to one of these categories.
19419    */
19420   SourceMapGenerator.prototype._validateMapping =
19421     function SourceMapGenerator_validateMapping(aGenerated, aOriginal, aSource,
19422                                                 aName) {
19423       if (aGenerated && 'line' in aGenerated && 'column' in aGenerated
19424           && aGenerated.line > 0 && aGenerated.column >= 0
19425           && !aOriginal && !aSource && !aName) {
19426         // Case 1.
19427         return;
19428       }
19429       else if (aGenerated && 'line' in aGenerated && 'column' in aGenerated
19430                && aOriginal && 'line' in aOriginal && 'column' in aOriginal
19431                && aGenerated.line > 0 && aGenerated.column >= 0
19432                && aOriginal.line > 0 && aOriginal.column >= 0
19433                && aSource) {
19434         // Cases 2 and 3.
19435         return;
19436       }
19437       else {
19438         throw new Error('Invalid mapping: ' + JSON.stringify({
19439           generated: aGenerated,
19440           source: aSource,
19441           original: aOriginal,
19442           name: aName
19443         }));
19444       }
19445     };
19446
19447   /**
19448    * Serialize the accumulated mappings in to the stream of base 64 VLQs
19449    * specified by the source map format.
19450    */
19451   SourceMapGenerator.prototype._serializeMappings =
19452     function SourceMapGenerator_serializeMappings() {
19453       var previousGeneratedColumn = 0;
19454       var previousGeneratedLine = 1;
19455       var previousOriginalColumn = 0;
19456       var previousOriginalLine = 0;
19457       var previousName = 0;
19458       var previousSource = 0;
19459       var result = '';
19460       var mapping;
19461
19462       var mappings = this._mappings.toArray();
19463
19464       for (var i = 0, len = mappings.length; i < len; i++) {
19465         mapping = mappings[i];
19466
19467         if (mapping.generatedLine !== previousGeneratedLine) {
19468           previousGeneratedColumn = 0;
19469           while (mapping.generatedLine !== previousGeneratedLine) {
19470             result += ';';
19471             previousGeneratedLine++;
19472           }
19473         }
19474         else {
19475           if (i > 0) {
19476             if (!util.compareByGeneratedPositions(mapping, mappings[i - 1])) {
19477               continue;
19478             }
19479             result += ',';
19480           }
19481         }
19482
19483         result += base64VLQ.encode(mapping.generatedColumn
19484                                    - previousGeneratedColumn);
19485         previousGeneratedColumn = mapping.generatedColumn;
19486
19487         if (mapping.source != null) {
19488           result += base64VLQ.encode(this._sources.indexOf(mapping.source)
19489                                      - previousSource);
19490           previousSource = this._sources.indexOf(mapping.source);
19491
19492           // lines are stored 0-based in SourceMap spec version 3
19493           result += base64VLQ.encode(mapping.originalLine - 1
19494                                      - previousOriginalLine);
19495           previousOriginalLine = mapping.originalLine - 1;
19496
19497           result += base64VLQ.encode(mapping.originalColumn
19498                                      - previousOriginalColumn);
19499           previousOriginalColumn = mapping.originalColumn;
19500
19501           if (mapping.name != null) {
19502             result += base64VLQ.encode(this._names.indexOf(mapping.name)
19503                                        - previousName);
19504             previousName = this._names.indexOf(mapping.name);
19505           }
19506         }
19507       }
19508
19509       return result;
19510     };
19511
19512   SourceMapGenerator.prototype._generateSourcesContent =
19513     function SourceMapGenerator_generateSourcesContent(aSources, aSourceRoot) {
19514       return aSources.map(function (source) {
19515         if (!this._sourcesContents) {
19516           return null;
19517         }
19518         if (aSourceRoot != null) {
19519           source = util.relative(aSourceRoot, source);
19520         }
19521         var key = util.toSetString(source);
19522         return Object.prototype.hasOwnProperty.call(this._sourcesContents,
19523                                                     key)
19524           ? this._sourcesContents[key]
19525           : null;
19526       }, this);
19527     };
19528
19529   /**
19530    * Externalize the source map.
19531    */
19532   SourceMapGenerator.prototype.toJSON =
19533     function SourceMapGenerator_toJSON() {
19534       var map = {
19535         version: this._version,
19536         sources: this._sources.toArray(),
19537         names: this._names.toArray(),
19538         mappings: this._serializeMappings()
19539       };
19540       if (this._file != null) {
19541         map.file = this._file;
19542       }
19543       if (this._sourceRoot != null) {
19544         map.sourceRoot = this._sourceRoot;
19545       }
19546       if (this._sourcesContents) {
19547         map.sourcesContent = this._generateSourcesContent(map.sources, map.sourceRoot);
19548       }
19549
19550       return map;
19551     };
19552
19553   /**
19554    * Render the source map being generated to a string.
19555    */
19556   SourceMapGenerator.prototype.toString =
19557     function SourceMapGenerator_toString() {
19558       return JSON.stringify(this);
19559     };
19560
19561   exports.SourceMapGenerator = SourceMapGenerator;
19562
19563 });
19564
19565 },{"./array-set":116,"./base64-vlq":117,"./mapping-list":122,"./util":126,"amdefine":127}],125:[function(require,module,exports){
19566 /* -*- Mode: js; js-indent-level: 2; -*- */
19567 /*
19568  * Copyright 2011 Mozilla Foundation and contributors
19569  * Licensed under the New BSD license. See LICENSE or:
19570  * http://opensource.org/licenses/BSD-3-Clause
19571  */
19572 if (typeof define !== 'function') {
19573     var define = require('amdefine')(module, require);
19574 }
19575 define(function (require, exports, module) {
19576
19577   var SourceMapGenerator = require('./source-map-generator').SourceMapGenerator;
19578   var util = require('./util');
19579
19580   // Matches a Windows-style `\r\n` newline or a `\n` newline used by all other
19581   // operating systems these days (capturing the result).
19582   var REGEX_NEWLINE = /(\r?\n)/;
19583
19584   // Newline character code for charCodeAt() comparisons
19585   var NEWLINE_CODE = 10;
19586
19587   // Private symbol for identifying `SourceNode`s when multiple versions of
19588   // the source-map library are loaded. This MUST NOT CHANGE across
19589   // versions!
19590   var isSourceNode = "$$$isSourceNode$$$";
19591
19592   /**
19593    * SourceNodes provide a way to abstract over interpolating/concatenating
19594    * snippets of generated JavaScript source code while maintaining the line and
19595    * column information associated with the original source code.
19596    *
19597    * @param aLine The original line number.
19598    * @param aColumn The original column number.
19599    * @param aSource The original source's filename.
19600    * @param aChunks Optional. An array of strings which are snippets of
19601    *        generated JS, or other SourceNodes.
19602    * @param aName The original identifier.
19603    */
19604   function SourceNode(aLine, aColumn, aSource, aChunks, aName) {
19605     this.children = [];
19606     this.sourceContents = {};
19607     this.line = aLine == null ? null : aLine;
19608     this.column = aColumn == null ? null : aColumn;
19609     this.source = aSource == null ? null : aSource;
19610     this.name = aName == null ? null : aName;
19611     this[isSourceNode] = true;
19612     if (aChunks != null) this.add(aChunks);
19613   }
19614
19615   /**
19616    * Creates a SourceNode from generated code and a SourceMapConsumer.
19617    *
19618    * @param aGeneratedCode The generated code
19619    * @param aSourceMapConsumer The SourceMap for the generated code
19620    * @param aRelativePath Optional. The path that relative sources in the
19621    *        SourceMapConsumer should be relative to.
19622    */
19623   SourceNode.fromStringWithSourceMap =
19624     function SourceNode_fromStringWithSourceMap(aGeneratedCode, aSourceMapConsumer, aRelativePath) {
19625       // The SourceNode we want to fill with the generated code
19626       // and the SourceMap
19627       var node = new SourceNode();
19628
19629       // All even indices of this array are one line of the generated code,
19630       // while all odd indices are the newlines between two adjacent lines
19631       // (since `REGEX_NEWLINE` captures its match).
19632       // Processed fragments are removed from this array, by calling `shiftNextLine`.
19633       var remainingLines = aGeneratedCode.split(REGEX_NEWLINE);
19634       var shiftNextLine = function() {
19635         var lineContents = remainingLines.shift();
19636         // The last line of a file might not have a newline.
19637         var newLine = remainingLines.shift() || "";
19638         return lineContents + newLine;
19639       };
19640
19641       // We need to remember the position of "remainingLines"
19642       var lastGeneratedLine = 1, lastGeneratedColumn = 0;
19643
19644       // The generate SourceNodes we need a code range.
19645       // To extract it current and last mapping is used.
19646       // Here we store the last mapping.
19647       var lastMapping = null;
19648
19649       aSourceMapConsumer.eachMapping(function (mapping) {
19650         if (lastMapping !== null) {
19651           // We add the code from "lastMapping" to "mapping":
19652           // First check if there is a new line in between.
19653           if (lastGeneratedLine < mapping.generatedLine) {
19654             var code = "";
19655             // Associate first line with "lastMapping"
19656             addMappingWithCode(lastMapping, shiftNextLine());
19657             lastGeneratedLine++;
19658             lastGeneratedColumn = 0;
19659             // The remaining code is added without mapping
19660           } else {
19661             // There is no new line in between.
19662             // Associate the code between "lastGeneratedColumn" and
19663             // "mapping.generatedColumn" with "lastMapping"
19664             var nextLine = remainingLines[0];
19665             var code = nextLine.substr(0, mapping.generatedColumn -
19666                                           lastGeneratedColumn);
19667             remainingLines[0] = nextLine.substr(mapping.generatedColumn -
19668                                                 lastGeneratedColumn);
19669             lastGeneratedColumn = mapping.generatedColumn;
19670             addMappingWithCode(lastMapping, code);
19671             // No more remaining code, continue
19672             lastMapping = mapping;
19673             return;
19674           }
19675         }
19676         // We add the generated code until the first mapping
19677         // to the SourceNode without any mapping.
19678         // Each line is added as separate string.
19679         while (lastGeneratedLine < mapping.generatedLine) {
19680           node.add(shiftNextLine());
19681           lastGeneratedLine++;
19682         }
19683         if (lastGeneratedColumn < mapping.generatedColumn) {
19684           var nextLine = remainingLines[0];
19685           node.add(nextLine.substr(0, mapping.generatedColumn));
19686           remainingLines[0] = nextLine.substr(mapping.generatedColumn);
19687           lastGeneratedColumn = mapping.generatedColumn;
19688         }
19689         lastMapping = mapping;
19690       }, this);
19691       // We have processed all mappings.
19692       if (remainingLines.length > 0) {
19693         if (lastMapping) {
19694           // Associate the remaining code in the current line with "lastMapping"
19695           addMappingWithCode(lastMapping, shiftNextLine());
19696         }
19697         // and add the remaining lines without any mapping
19698         node.add(remainingLines.join(""));
19699       }
19700
19701       // Copy sourcesContent into SourceNode
19702       aSourceMapConsumer.sources.forEach(function (sourceFile) {
19703         var content = aSourceMapConsumer.sourceContentFor(sourceFile);
19704         if (content != null) {
19705           if (aRelativePath != null) {
19706             sourceFile = util.join(aRelativePath, sourceFile);
19707           }
19708           node.setSourceContent(sourceFile, content);
19709         }
19710       });
19711
19712       return node;
19713
19714       function addMappingWithCode(mapping, code) {
19715         if (mapping === null || mapping.source === undefined) {
19716           node.add(code);
19717         } else {
19718           var source = aRelativePath
19719             ? util.join(aRelativePath, mapping.source)
19720             : mapping.source;
19721           node.add(new SourceNode(mapping.originalLine,
19722                                   mapping.originalColumn,
19723                                   source,
19724                                   code,
19725                                   mapping.name));
19726         }
19727       }
19728     };
19729
19730   /**
19731    * Add a chunk of generated JS to this source node.
19732    *
19733    * @param aChunk A string snippet of generated JS code, another instance of
19734    *        SourceNode, or an array where each member is one of those things.
19735    */
19736   SourceNode.prototype.add = function SourceNode_add(aChunk) {
19737     if (Array.isArray(aChunk)) {
19738       aChunk.forEach(function (chunk) {
19739         this.add(chunk);
19740       }, this);
19741     }
19742     else if (aChunk[isSourceNode] || typeof aChunk === "string") {
19743       if (aChunk) {
19744         this.children.push(aChunk);
19745       }
19746     }
19747     else {
19748       throw new TypeError(
19749         "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk
19750       );
19751     }
19752     return this;
19753   };
19754
19755   /**
19756    * Add a chunk of generated JS to the beginning of this source node.
19757    *
19758    * @param aChunk A string snippet of generated JS code, another instance of
19759    *        SourceNode, or an array where each member is one of those things.
19760    */
19761   SourceNode.prototype.prepend = function SourceNode_prepend(aChunk) {
19762     if (Array.isArray(aChunk)) {
19763       for (var i = aChunk.length-1; i >= 0; i--) {
19764         this.prepend(aChunk[i]);
19765       }
19766     }
19767     else if (aChunk[isSourceNode] || typeof aChunk === "string") {
19768       this.children.unshift(aChunk);
19769     }
19770     else {
19771       throw new TypeError(
19772         "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk
19773       );
19774     }
19775     return this;
19776   };
19777
19778   /**
19779    * Walk over the tree of JS snippets in this node and its children. The
19780    * walking function is called once for each snippet of JS and is passed that
19781    * snippet and the its original associated source's line/column location.
19782    *
19783    * @param aFn The traversal function.
19784    */
19785   SourceNode.prototype.walk = function SourceNode_walk(aFn) {
19786     var chunk;
19787     for (var i = 0, len = this.children.length; i < len; i++) {
19788       chunk = this.children[i];
19789       if (chunk[isSourceNode]) {
19790         chunk.walk(aFn);
19791       }
19792       else {
19793         if (chunk !== '') {
19794           aFn(chunk, { source: this.source,
19795                        line: this.line,
19796                        column: this.column,
19797                        name: this.name });
19798         }
19799       }
19800     }
19801   };
19802
19803   /**
19804    * Like `String.prototype.join` except for SourceNodes. Inserts `aStr` between
19805    * each of `this.children`.
19806    *
19807    * @param aSep The separator.
19808    */
19809   SourceNode.prototype.join = function SourceNode_join(aSep) {
19810     var newChildren;
19811     var i;
19812     var len = this.children.length;
19813     if (len > 0) {
19814       newChildren = [];
19815       for (i = 0; i < len-1; i++) {
19816         newChildren.push(this.children[i]);
19817         newChildren.push(aSep);
19818       }
19819       newChildren.push(this.children[i]);
19820       this.children = newChildren;
19821     }
19822     return this;
19823   };
19824
19825   /**
19826    * Call String.prototype.replace on the very right-most source snippet. Useful
19827    * for trimming whitespace from the end of a source node, etc.
19828    *
19829    * @param aPattern The pattern to replace.
19830    * @param aReplacement The thing to replace the pattern with.
19831    */
19832   SourceNode.prototype.replaceRight = function SourceNode_replaceRight(aPattern, aReplacement) {
19833     var lastChild = this.children[this.children.length - 1];
19834     if (lastChild[isSourceNode]) {
19835       lastChild.replaceRight(aPattern, aReplacement);
19836     }
19837     else if (typeof lastChild === 'string') {
19838       this.children[this.children.length - 1] = lastChild.replace(aPattern, aReplacement);
19839     }
19840     else {
19841       this.children.push(''.replace(aPattern, aReplacement));
19842     }
19843     return this;
19844   };
19845
19846   /**
19847    * Set the source content for a source file. This will be added to the SourceMapGenerator
19848    * in the sourcesContent field.
19849    *
19850    * @param aSourceFile The filename of the source file
19851    * @param aSourceContent The content of the source file
19852    */
19853   SourceNode.prototype.setSourceContent =
19854     function SourceNode_setSourceContent(aSourceFile, aSourceContent) {
19855       this.sourceContents[util.toSetString(aSourceFile)] = aSourceContent;
19856     };
19857
19858   /**
19859    * Walk over the tree of SourceNodes. The walking function is called for each
19860    * source file content and is passed the filename and source content.
19861    *
19862    * @param aFn The traversal function.
19863    */
19864   SourceNode.prototype.walkSourceContents =
19865     function SourceNode_walkSourceContents(aFn) {
19866       for (var i = 0, len = this.children.length; i < len; i++) {
19867         if (this.children[i][isSourceNode]) {
19868           this.children[i].walkSourceContents(aFn);
19869         }
19870       }
19871
19872       var sources = Object.keys(this.sourceContents);
19873       for (var i = 0, len = sources.length; i < len; i++) {
19874         aFn(util.fromSetString(sources[i]), this.sourceContents[sources[i]]);
19875       }
19876     };
19877
19878   /**
19879    * Return the string representation of this source node. Walks over the tree
19880    * and concatenates all the various snippets together to one string.
19881    */
19882   SourceNode.prototype.toString = function SourceNode_toString() {
19883     var str = "";
19884     this.walk(function (chunk) {
19885       str += chunk;
19886     });
19887     return str;
19888   };
19889
19890   /**
19891    * Returns the string representation of this source node along with a source
19892    * map.
19893    */
19894   SourceNode.prototype.toStringWithSourceMap = function SourceNode_toStringWithSourceMap(aArgs) {
19895     var generated = {
19896       code: "",
19897       line: 1,
19898       column: 0
19899     };
19900     var map = new SourceMapGenerator(aArgs);
19901     var sourceMappingActive = false;
19902     var lastOriginalSource = null;
19903     var lastOriginalLine = null;
19904     var lastOriginalColumn = null;
19905     var lastOriginalName = null;
19906     this.walk(function (chunk, original) {
19907       generated.code += chunk;
19908       if (original.source !== null
19909           && original.line !== null
19910           && original.column !== null) {
19911         if(lastOriginalSource !== original.source
19912            || lastOriginalLine !== original.line
19913            || lastOriginalColumn !== original.column
19914            || lastOriginalName !== original.name) {
19915           map.addMapping({
19916             source: original.source,
19917             original: {
19918               line: original.line,
19919               column: original.column
19920             },
19921             generated: {
19922               line: generated.line,
19923               column: generated.column
19924             },
19925             name: original.name
19926           });
19927         }
19928         lastOriginalSource = original.source;
19929         lastOriginalLine = original.line;
19930         lastOriginalColumn = original.column;
19931         lastOriginalName = original.name;
19932         sourceMappingActive = true;
19933       } else if (sourceMappingActive) {
19934         map.addMapping({
19935           generated: {
19936             line: generated.line,
19937             column: generated.column
19938           }
19939         });
19940         lastOriginalSource = null;
19941         sourceMappingActive = false;
19942       }
19943       for (var idx = 0, length = chunk.length; idx < length; idx++) {
19944         if (chunk.charCodeAt(idx) === NEWLINE_CODE) {
19945           generated.line++;
19946           generated.column = 0;
19947           // Mappings end at eol
19948           if (idx + 1 === length) {
19949             lastOriginalSource = null;
19950             sourceMappingActive = false;
19951           } else if (sourceMappingActive) {
19952             map.addMapping({
19953               source: original.source,
19954               original: {
19955                 line: original.line,
19956                 column: original.column
19957               },
19958               generated: {
19959                 line: generated.line,
19960                 column: generated.column
19961               },
19962               name: original.name
19963             });
19964           }
19965         } else {
19966           generated.column++;
19967         }
19968       }
19969     });
19970     this.walkSourceContents(function (sourceFile, sourceContent) {
19971       map.setSourceContent(sourceFile, sourceContent);
19972     });
19973
19974     return { code: generated.code, map: map };
19975   };
19976
19977   exports.SourceNode = SourceNode;
19978
19979 });
19980
19981 },{"./source-map-generator":124,"./util":126,"amdefine":127}],126:[function(require,module,exports){
19982 /* -*- Mode: js; js-indent-level: 2; -*- */
19983 /*
19984  * Copyright 2011 Mozilla Foundation and contributors
19985  * Licensed under the New BSD license. See LICENSE or:
19986  * http://opensource.org/licenses/BSD-3-Clause
19987  */
19988 if (typeof define !== 'function') {
19989     var define = require('amdefine')(module, require);
19990 }
19991 define(function (require, exports, module) {
19992
19993   /**
19994    * This is a helper function for getting values from parameter/options
19995    * objects.
19996    *
19997    * @param args The object we are extracting values from
19998    * @param name The name of the property we are getting.
19999    * @param defaultValue An optional value to return if the property is missing
20000    * from the object. If this is not specified and the property is missing, an
20001    * error will be thrown.
20002    */
20003   function getArg(aArgs, aName, aDefaultValue) {
20004     if (aName in aArgs) {
20005       return aArgs[aName];
20006     } else if (arguments.length === 3) {
20007       return aDefaultValue;
20008     } else {
20009       throw new Error('"' + aName + '" is a required argument.');
20010     }
20011   }
20012   exports.getArg = getArg;
20013
20014   var urlRegexp = /^(?:([\w+\-.]+):)?\/\/(?:(\w+:\w+)@)?([\w.]*)(?::(\d+))?(\S*)$/;
20015   var dataUrlRegexp = /^data:.+\,.+$/;
20016
20017   function urlParse(aUrl) {
20018     var match = aUrl.match(urlRegexp);
20019     if (!match) {
20020       return null;
20021     }
20022     return {
20023       scheme: match[1],
20024       auth: match[2],
20025       host: match[3],
20026       port: match[4],
20027       path: match[5]
20028     };
20029   }
20030   exports.urlParse = urlParse;
20031
20032   function urlGenerate(aParsedUrl) {
20033     var url = '';
20034     if (aParsedUrl.scheme) {
20035       url += aParsedUrl.scheme + ':';
20036     }
20037     url += '//';
20038     if (aParsedUrl.auth) {
20039       url += aParsedUrl.auth + '@';
20040     }
20041     if (aParsedUrl.host) {
20042       url += aParsedUrl.host;
20043     }
20044     if (aParsedUrl.port) {
20045       url += ":" + aParsedUrl.port
20046     }
20047     if (aParsedUrl.path) {
20048       url += aParsedUrl.path;
20049     }
20050     return url;
20051   }
20052   exports.urlGenerate = urlGenerate;
20053
20054   /**
20055    * Normalizes a path, or the path portion of a URL:
20056    *
20057    * - Replaces consequtive slashes with one slash.
20058    * - Removes unnecessary '.' parts.
20059    * - Removes unnecessary '<dir>/..' parts.
20060    *
20061    * Based on code in the Node.js 'path' core module.
20062    *
20063    * @param aPath The path or url to normalize.
20064    */
20065   function normalize(aPath) {
20066     var path = aPath;
20067     var url = urlParse(aPath);
20068     if (url) {
20069       if (!url.path) {
20070         return aPath;
20071       }
20072       path = url.path;
20073     }
20074     var isAbsolute = (path.charAt(0) === '/');
20075
20076     var parts = path.split(/\/+/);
20077     for (var part, up = 0, i = parts.length - 1; i >= 0; i--) {
20078       part = parts[i];
20079       if (part === '.') {
20080         parts.splice(i, 1);
20081       } else if (part === '..') {
20082         up++;
20083       } else if (up > 0) {
20084         if (part === '') {
20085           // The first part is blank if the path is absolute. Trying to go
20086           // above the root is a no-op. Therefore we can remove all '..' parts
20087           // directly after the root.
20088           parts.splice(i + 1, up);
20089           up = 0;
20090         } else {
20091           parts.splice(i, 2);
20092           up--;
20093         }
20094       }
20095     }
20096     path = parts.join('/');
20097
20098     if (path === '') {
20099       path = isAbsolute ? '/' : '.';
20100     }
20101
20102     if (url) {
20103       url.path = path;
20104       return urlGenerate(url);
20105     }
20106     return path;
20107   }
20108   exports.normalize = normalize;
20109
20110   /**
20111    * Joins two paths/URLs.
20112    *
20113    * @param aRoot The root path or URL.
20114    * @param aPath The path or URL to be joined with the root.
20115    *
20116    * - If aPath is a URL or a data URI, aPath is returned, unless aPath is a
20117    *   scheme-relative URL: Then the scheme of aRoot, if any, is prepended
20118    *   first.
20119    * - Otherwise aPath is a path. If aRoot is a URL, then its path portion
20120    *   is updated with the result and aRoot is returned. Otherwise the result
20121    *   is returned.
20122    *   - If aPath is absolute, the result is aPath.
20123    *   - Otherwise the two paths are joined with a slash.
20124    * - Joining for example 'http://' and 'www.example.com' is also supported.
20125    */
20126   function join(aRoot, aPath) {
20127     if (aRoot === "") {
20128       aRoot = ".";
20129     }
20130     if (aPath === "") {
20131       aPath = ".";
20132     }
20133     var aPathUrl = urlParse(aPath);
20134     var aRootUrl = urlParse(aRoot);
20135     if (aRootUrl) {
20136       aRoot = aRootUrl.path || '/';
20137     }
20138
20139     // `join(foo, '//www.example.org')`
20140     if (aPathUrl && !aPathUrl.scheme) {
20141       if (aRootUrl) {
20142         aPathUrl.scheme = aRootUrl.scheme;
20143       }
20144       return urlGenerate(aPathUrl);
20145     }
20146
20147     if (aPathUrl || aPath.match(dataUrlRegexp)) {
20148       return aPath;
20149     }
20150
20151     // `join('http://', 'www.example.com')`
20152     if (aRootUrl && !aRootUrl.host && !aRootUrl.path) {
20153       aRootUrl.host = aPath;
20154       return urlGenerate(aRootUrl);
20155     }
20156
20157     var joined = aPath.charAt(0) === '/'
20158       ? aPath
20159       : normalize(aRoot.replace(/\/+$/, '') + '/' + aPath);
20160
20161     if (aRootUrl) {
20162       aRootUrl.path = joined;
20163       return urlGenerate(aRootUrl);
20164     }
20165     return joined;
20166   }
20167   exports.join = join;
20168
20169   /**
20170    * Make a path relative to a URL or another path.
20171    *
20172    * @param aRoot The root path or URL.
20173    * @param aPath The path or URL to be made relative to aRoot.
20174    */
20175   function relative(aRoot, aPath) {
20176     if (aRoot === "") {
20177       aRoot = ".";
20178     }
20179
20180     aRoot = aRoot.replace(/\/$/, '');
20181
20182     // XXX: It is possible to remove this block, and the tests still pass!
20183     var url = urlParse(aRoot);
20184     if (aPath.charAt(0) == "/" && url && url.path == "/") {
20185       return aPath.slice(1);
20186     }
20187
20188     return aPath.indexOf(aRoot + '/') === 0
20189       ? aPath.substr(aRoot.length + 1)
20190       : aPath;
20191   }
20192   exports.relative = relative;
20193
20194   /**
20195    * Because behavior goes wacky when you set `__proto__` on objects, we
20196    * have to prefix all the strings in our set with an arbitrary character.
20197    *
20198    * See https://github.com/mozilla/source-map/pull/31 and
20199    * https://github.com/mozilla/source-map/issues/30
20200    *
20201    * @param String aStr
20202    */
20203   function toSetString(aStr) {
20204     return '$' + aStr;
20205   }
20206   exports.toSetString = toSetString;
20207
20208   function fromSetString(aStr) {
20209     return aStr.substr(1);
20210   }
20211   exports.fromSetString = fromSetString;
20212
20213   function strcmp(aStr1, aStr2) {
20214     var s1 = aStr1 || "";
20215     var s2 = aStr2 || "";
20216     return (s1 > s2) - (s1 < s2);
20217   }
20218
20219   /**
20220    * Comparator between two mappings where the original positions are compared.
20221    *
20222    * Optionally pass in `true` as `onlyCompareGenerated` to consider two
20223    * mappings with the same original source/line/column, but different generated
20224    * line and column the same. Useful when searching for a mapping with a
20225    * stubbed out mapping.
20226    */
20227   function compareByOriginalPositions(mappingA, mappingB, onlyCompareOriginal) {
20228     var cmp;
20229
20230     cmp = strcmp(mappingA.source, mappingB.source);
20231     if (cmp) {
20232       return cmp;
20233     }
20234
20235     cmp = mappingA.originalLine - mappingB.originalLine;
20236     if (cmp) {
20237       return cmp;
20238     }
20239
20240     cmp = mappingA.originalColumn - mappingB.originalColumn;
20241     if (cmp || onlyCompareOriginal) {
20242       return cmp;
20243     }
20244
20245     cmp = strcmp(mappingA.name, mappingB.name);
20246     if (cmp) {
20247       return cmp;
20248     }
20249
20250     cmp = mappingA.generatedLine - mappingB.generatedLine;
20251     if (cmp) {
20252       return cmp;
20253     }
20254
20255     return mappingA.generatedColumn - mappingB.generatedColumn;
20256   };
20257   exports.compareByOriginalPositions = compareByOriginalPositions;
20258
20259   /**
20260    * Comparator between two mappings where the generated positions are
20261    * compared.
20262    *
20263    * Optionally pass in `true` as `onlyCompareGenerated` to consider two
20264    * mappings with the same generated line and column, but different
20265    * source/name/original line and column the same. Useful when searching for a
20266    * mapping with a stubbed out mapping.
20267    */
20268   function compareByGeneratedPositions(mappingA, mappingB, onlyCompareGenerated) {
20269     var cmp;
20270
20271     cmp = mappingA.generatedLine - mappingB.generatedLine;
20272     if (cmp) {
20273       return cmp;
20274     }
20275
20276     cmp = mappingA.generatedColumn - mappingB.generatedColumn;
20277     if (cmp || onlyCompareGenerated) {
20278       return cmp;
20279     }
20280
20281     cmp = strcmp(mappingA.source, mappingB.source);
20282     if (cmp) {
20283       return cmp;
20284     }
20285
20286     cmp = mappingA.originalLine - mappingB.originalLine;
20287     if (cmp) {
20288       return cmp;
20289     }
20290
20291     cmp = mappingA.originalColumn - mappingB.originalColumn;
20292     if (cmp) {
20293       return cmp;
20294     }
20295
20296     return strcmp(mappingA.name, mappingB.name);
20297   };
20298   exports.compareByGeneratedPositions = compareByGeneratedPositions;
20299
20300 });
20301
20302 },{"amdefine":127}],127:[function(require,module,exports){
20303 (function (process,__filename){
20304 /** vim: et:ts=4:sw=4:sts=4
20305  * @license amdefine 0.1.0 Copyright (c) 2011, The Dojo Foundation All Rights Reserved.
20306  * Available via the MIT or new BSD license.
20307  * see: http://github.com/jrburke/amdefine for details
20308  */
20309
20310 /*jslint node: true */
20311 /*global module, process */
20312 'use strict';
20313
20314 /**
20315  * Creates a define for node.
20316  * @param {Object} module the "module" object that is defined by Node for the
20317  * current module.
20318  * @param {Function} [requireFn]. Node's require function for the current module.
20319  * It only needs to be passed in Node versions before 0.5, when module.require
20320  * did not exist.
20321  * @returns {Function} a define function that is usable for the current node
20322  * module.
20323  */
20324 function amdefine(module, requireFn) {
20325     'use strict';
20326     var defineCache = {},
20327         loaderCache = {},
20328         alreadyCalled = false,
20329         path = require('path'),
20330         makeRequire, stringRequire;
20331
20332     /**
20333      * Trims the . and .. from an array of path segments.
20334      * It will keep a leading path segment if a .. will become
20335      * the first path segment, to help with module name lookups,
20336      * which act like paths, but can be remapped. But the end result,
20337      * all paths that use this function should look normalized.
20338      * NOTE: this method MODIFIES the input array.
20339      * @param {Array} ary the array of path segments.
20340      */
20341     function trimDots(ary) {
20342         var i, part;
20343         for (i = 0; ary[i]; i+= 1) {
20344             part = ary[i];
20345             if (part === '.') {
20346                 ary.splice(i, 1);
20347                 i -= 1;
20348             } else if (part === '..') {
20349                 if (i === 1 && (ary[2] === '..' || ary[0] === '..')) {
20350                     //End of the line. Keep at least one non-dot
20351                     //path segment at the front so it can be mapped
20352                     //correctly to disk. Otherwise, there is likely
20353                     //no path mapping for a path starting with '..'.
20354                     //This can still fail, but catches the most reasonable
20355                     //uses of ..
20356                     break;
20357                 } else if (i > 0) {
20358                     ary.splice(i - 1, 2);
20359                     i -= 2;
20360                 }
20361             }
20362         }
20363     }
20364
20365     function normalize(name, baseName) {
20366         var baseParts;
20367
20368         //Adjust any relative paths.
20369         if (name && name.charAt(0) === '.') {
20370             //If have a base name, try to normalize against it,
20371             //otherwise, assume it is a top-level require that will
20372             //be relative to baseUrl in the end.
20373             if (baseName) {
20374                 baseParts = baseName.split('/');
20375                 baseParts = baseParts.slice(0, baseParts.length - 1);
20376                 baseParts = baseParts.concat(name.split('/'));
20377                 trimDots(baseParts);
20378                 name = baseParts.join('/');
20379             }
20380         }
20381
20382         return name;
20383     }
20384
20385     /**
20386      * Create the normalize() function passed to a loader plugin's
20387      * normalize method.
20388      */
20389     function makeNormalize(relName) {
20390         return function (name) {
20391             return normalize(name, relName);
20392         };
20393     }
20394
20395     function makeLoad(id) {
20396         function load(value) {
20397             loaderCache[id] = value;
20398         }
20399
20400         load.fromText = function (id, text) {
20401             //This one is difficult because the text can/probably uses
20402             //define, and any relative paths and requires should be relative
20403             //to that id was it would be found on disk. But this would require
20404             //bootstrapping a module/require fairly deeply from node core.
20405             //Not sure how best to go about that yet.
20406             throw new Error('amdefine does not implement load.fromText');
20407         };
20408
20409         return load;
20410     }
20411
20412     makeRequire = function (systemRequire, exports, module, relId) {
20413         function amdRequire(deps, callback) {
20414             if (typeof deps === 'string') {
20415                 //Synchronous, single module require('')
20416                 return stringRequire(systemRequire, exports, module, deps, relId);
20417             } else {
20418                 //Array of dependencies with a callback.
20419
20420                 //Convert the dependencies to modules.
20421                 deps = deps.map(function (depName) {
20422                     return stringRequire(systemRequire, exports, module, depName, relId);
20423                 });
20424
20425                 //Wait for next tick to call back the require call.
20426                 process.nextTick(function () {
20427                     callback.apply(null, deps);
20428                 });
20429             }
20430         }
20431
20432         amdRequire.toUrl = function (filePath) {
20433             if (filePath.indexOf('.') === 0) {
20434                 return normalize(filePath, path.dirname(module.filename));
20435             } else {
20436                 return filePath;
20437             }
20438         };
20439
20440         return amdRequire;
20441     };
20442
20443     //Favor explicit value, passed in if the module wants to support Node 0.4.
20444     requireFn = requireFn || function req() {
20445         return module.require.apply(module, arguments);
20446     };
20447
20448     function runFactory(id, deps, factory) {
20449         var r, e, m, result;
20450
20451         if (id) {
20452             e = loaderCache[id] = {};
20453             m = {
20454                 id: id,
20455                 uri: __filename,
20456                 exports: e
20457             };
20458             r = makeRequire(requireFn, e, m, id);
20459         } else {
20460             //Only support one define call per file
20461             if (alreadyCalled) {
20462                 throw new Error('amdefine with no module ID cannot be called more than once per file.');
20463             }
20464             alreadyCalled = true;
20465
20466             //Use the real variables from node
20467             //Use module.exports for exports, since
20468             //the exports in here is amdefine exports.
20469             e = module.exports;
20470             m = module;
20471             r = makeRequire(requireFn, e, m, module.id);
20472         }
20473
20474         //If there are dependencies, they are strings, so need
20475         //to convert them to dependency values.
20476         if (deps) {
20477             deps = deps.map(function (depName) {
20478                 return r(depName);
20479             });
20480         }
20481
20482         //Call the factory with the right dependencies.
20483         if (typeof factory === 'function') {
20484             result = factory.apply(m.exports, deps);
20485         } else {
20486             result = factory;
20487         }
20488
20489         if (result !== undefined) {
20490             m.exports = result;
20491             if (id) {
20492                 loaderCache[id] = m.exports;
20493             }
20494         }
20495     }
20496
20497     stringRequire = function (systemRequire, exports, module, id, relId) {
20498         //Split the ID by a ! so that
20499         var index = id.indexOf('!'),
20500             originalId = id,
20501             prefix, plugin;
20502
20503         if (index === -1) {
20504             id = normalize(id, relId);
20505
20506             //Straight module lookup. If it is one of the special dependencies,
20507             //deal with it, otherwise, delegate to node.
20508             if (id === 'require') {
20509                 return makeRequire(systemRequire, exports, module, relId);
20510             } else if (id === 'exports') {
20511                 return exports;
20512             } else if (id === 'module') {
20513                 return module;
20514             } else if (loaderCache.hasOwnProperty(id)) {
20515                 return loaderCache[id];
20516             } else if (defineCache[id]) {
20517                 runFactory.apply(null, defineCache[id]);
20518                 return loaderCache[id];
20519             } else {
20520                 if(systemRequire) {
20521                     return systemRequire(originalId);
20522                 } else {
20523                     throw new Error('No module with ID: ' + id);
20524                 }
20525             }
20526         } else {
20527             //There is a plugin in play.
20528             prefix = id.substring(0, index);
20529             id = id.substring(index + 1, id.length);
20530
20531             plugin = stringRequire(systemRequire, exports, module, prefix, relId);
20532
20533             if (plugin.normalize) {
20534                 id = plugin.normalize(id, makeNormalize(relId));
20535             } else {
20536                 //Normalize the ID normally.
20537                 id = normalize(id, relId);
20538             }
20539
20540             if (loaderCache[id]) {
20541                 return loaderCache[id];
20542             } else {
20543                 plugin.load(id, makeRequire(systemRequire, exports, module, relId), makeLoad(id), {});
20544
20545                 return loaderCache[id];
20546             }
20547         }
20548     };
20549
20550     //Create a define function specific to the module asking for amdefine.
20551     function define(id, deps, factory) {
20552         if (Array.isArray(id)) {
20553             factory = deps;
20554             deps = id;
20555             id = undefined;
20556         } else if (typeof id !== 'string') {
20557             factory = id;
20558             id = deps = undefined;
20559         }
20560
20561         if (deps && !Array.isArray(deps)) {
20562             factory = deps;
20563             deps = undefined;
20564         }
20565
20566         if (!deps) {
20567             deps = ['require', 'exports', 'module'];
20568         }
20569
20570         //Set up properties for this module. If an ID, then use
20571         //internal cache. If no ID, then use the external variables
20572         //for this node module.
20573         if (id) {
20574             //Put the module in deep freeze until there is a
20575             //require call for it.
20576             defineCache[id] = [id, deps, factory];
20577         } else {
20578             runFactory(id, deps, factory);
20579         }
20580     }
20581
20582     //define.require, which has access to all the values in the
20583     //cache. Useful for AMD modules that all have IDs in the file,
20584     //but need to finally export a value to node based on one of those
20585     //IDs.
20586     define.require = function (id) {
20587         if (loaderCache[id]) {
20588             return loaderCache[id];
20589         }
20590
20591         if (defineCache[id]) {
20592             runFactory.apply(null, defineCache[id]);
20593             return loaderCache[id];
20594         }
20595     };
20596
20597     define.amd = {};
20598
20599     return define;
20600 }
20601
20602 module.exports = amdefine;
20603
20604 }).call(this,require('_process'),"/../node_modules/postcss/node_modules/source-map/node_modules/amdefine/amdefine.js")
20605 },{"_process":54,"path":53}]},{},[1])(1)
20606 });