0.2.0 - Mid migration

web/node_modules/@emotion/sheet/CHANGELOG.md

@@ -0,0 +1,13 @@
+# @emotion/sheet
+
+## 0.9.4
+
+### Patch Changes
+
+- [`4c62ae9`](https://github.com/emotion-js/emotion/commit/4c62ae9447959d438928e1a26f76f1487983c968) [#1698](https://github.com/emotion-js/emotion/pull/1698) Thanks [@Andarist](https://github.com/Andarist)! - Add LICENSE file
+
+## 0.9.3
+
+### Patch Changes
+
+- [c0eb604d](https://github.com/emotion-js/emotion/commit/c0eb604d) [#1419](https://github.com/emotion-js/emotion/pull/1419) Thanks [@mitchellhamilton](https://github.com/mitchellhamilton)! - Update build tool

web/node_modules/@emotion/sheet/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Emotion team and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

web/node_modules/@emotion/sheet/README.md

@@ -0,0 +1,87 @@
+# @emotion/sheet
+
+> A StyleSheet for css-in-js libraries
+
+```bash
+yarn add @emotion/sheet
+```
+
+```jsx
+import { StyleSheet } from '@emotion/sheet'
+
+const sheet = new StyleSheet({ key: '', container: document.head })
+
+sheet.insert('html { color: hotpink; }')
+```
+
+> **Note:**
+> This is not useful for server-side rendering, you should implement SSR seperately
+
+## StyleSheet
+
+### Options
+
+```ts
+type Options = {
+  nonce?: string
+  key: string
+  container: HTMLElement
+  speedy?: boolean
+  maxLength?: number
+}
+```
+
+#### nonce
+
+A nonce that will be set on each style tag that the sheet inserts for [Content Security Policies](https://developer.mozilla.org/en-US/docs/Web/HTTP/CSP).
+
+#### container
+
+A DOM Node that the sheet will insert all of it's style tags into, this is useful for inserting styles into iframes.
+
+#### key
+
+This will be set as the value of the `data-emotion` attribute on the style tags that get inserted. This is useful to identify different sheets.
+
+#### speedy
+
+This defines how rules are inserted. If it is true, rules will be inserted with [`insertRule`](https://developer.mozilla.org/en-US/docs/Web/API/CSSStyleSheet/insertRule) which is very fast but doesn't allow rules to be edited in DevTools. If it is false, rules will be inserted by appending text nodes to style elements which is much slower than insertRule but allows rules to be edited in DevTools. By default, speedy is enabled in production and disabled in development.
+
+#### maxLength
+
+This defines the number of rules that are inserted into each style tag. This generally shouldn't be modified.
+
+### Methods
+
+#### insert
+
+This method inserts a single rule into the document. It **must** be a single rule otherwise an error will be thrown in speedy mode which is enabled by default in production.
+
+#### flush
+
+This method will remove all style tags that were inserted into the document.
+
+### Example with all options
+
+```jsx
+import { StyleSheet } from '@emotion/sheet'
+
+const container = document.createElement('div')
+
+document.head.appendChild(container)
+
+const sheet = new StyleSheet({
+  nonce: 'some-nonce',
+  key: 'some-key',
+  container,
+  maxLength: 20
+})
+
+sheet.insert('html { color: hotpink; }')
+
+sheet.flush()
+```
+
+# Thanks
+
+This StyleSheet is based on [glamor's StyleSheet](https://github.com/threepointone/glamor) written by [Sunil Pai](https://github.com/threepointone). ❤️

web/node_modules/@emotion/sheet/dist/sheet.browser.cjs.js

@@ -0,0 +1,139 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/*
+
+Based off glamor's StyleSheet, thanks Sunil ❤️
+
+high performance StyleSheet for css-in-js systems
+
+- uses multiple style tags behind the scenes for millions of rules
+- uses `insertRule` for appending in production for *much* faster performance
+
+// usage
+
+import { StyleSheet } from '@emotion/sheet'
+
+let styleSheet = new StyleSheet({ key: '', container: document.head })
+
+styleSheet.insert('#box { border: 1px solid red; }')
+- appends a css rule into the stylesheet
+
+styleSheet.flush()
+- empties the stylesheet of all its contents
+
+*/
+// $FlowFixMe
+function sheetForTag(tag) {
+  if (tag.sheet) {
+    // $FlowFixMe
+    return tag.sheet;
+  } // this weirdness brought to you by firefox
+
+  /* istanbul ignore next */
+
+
+  for (var i = 0; i < document.styleSheets.length; i++) {
+    if (document.styleSheets[i].ownerNode === tag) {
+      // $FlowFixMe
+      return document.styleSheets[i];
+    }
+  }
+}
+
+function createStyleElement(options) {
+  var tag = document.createElement('style');
+  tag.setAttribute('data-emotion', options.key);
+
+  if (options.nonce !== undefined) {
+    tag.setAttribute('nonce', options.nonce);
+  }
+
+  tag.appendChild(document.createTextNode(''));
+  return tag;
+}
+
+var StyleSheet =
+/*#__PURE__*/
+function () {
+  function StyleSheet(options) {
+    this.isSpeedy = options.speedy === undefined ? process.env.NODE_ENV === 'production' : options.speedy;
+    this.tags = [];
+    this.ctr = 0;
+    this.nonce = options.nonce; // key is the value of the data-emotion attribute, it's used to identify different sheets
+
+    this.key = options.key;
+    this.container = options.container;
+    this.before = null;
+  }
+
+  var _proto = StyleSheet.prototype;
+
+  _proto.insert = function insert(rule) {
+    // the max length is how many rules we have per style tag, it's 65000 in speedy mode
+    // it's 1 in dev because we insert source maps that map a single rule to a location
+    // and you can only have one source map per style tag
+    if (this.ctr % (this.isSpeedy ? 65000 : 1) === 0) {
+      var _tag = createStyleElement(this);
+
+      var before;
+
+      if (this.tags.length === 0) {
+        before = this.before;
+      } else {
+        before = this.tags[this.tags.length - 1].nextSibling;
+      }
+
+      this.container.insertBefore(_tag, before);
+      this.tags.push(_tag);
+    }
+
+    var tag = this.tags[this.tags.length - 1];
+
+    if (this.isSpeedy) {
+      var sheet = sheetForTag(tag);
+
+      try {
+        // this is a really hot path
+        // we check the second character first because having "i"
+        // as the second character will happen less often than
+        // having "@" as the first character
+        var isImportRule = rule.charCodeAt(1) === 105 && rule.charCodeAt(0) === 64; // this is the ultrafast version, works across browsers
+        // the big drawback is that the css won't be editable in devtools
+
+        sheet.insertRule(rule, // we need to insert @import rules before anything else
+        // otherwise there will be an error
+        // technically this means that the @import rules will
+        // _usually_(not always since there could be multiple style tags)
+        // be the first ones in prod and generally later in dev
+        // this shouldn't really matter in the real world though
+        // @import is generally only used for font faces from google fonts and etc.
+        // so while this could be technically correct then it would be slower and larger
+        // for a tiny bit of correctness that won't matter in the real world
+        isImportRule ? 0 : sheet.cssRules.length);
+      } catch (e) {
+        if (process.env.NODE_ENV !== 'production') {
+          console.warn("There was a problem inserting the following rule: \"" + rule + "\"", e);
+        }
+      }
+    } else {
+      tag.appendChild(document.createTextNode(rule));
+    }
+
+    this.ctr++;
+  };
+
+  _proto.flush = function flush() {
+    // $FlowFixMe
+    this.tags.forEach(function (tag) {
+      return tag.parentNode.removeChild(tag);
+    });
+    this.tags = [];
+    this.ctr = 0;
+  };
+
+  return StyleSheet;
+}();
+
+exports.StyleSheet = StyleSheet;

web/node_modules/@emotion/sheet/dist/sheet.browser.esm.js

@@ -0,0 +1,135 @@
+/*
+
+Based off glamor's StyleSheet, thanks Sunil ❤️
+
+high performance StyleSheet for css-in-js systems
+
+- uses multiple style tags behind the scenes for millions of rules
+- uses `insertRule` for appending in production for *much* faster performance
+
+// usage
+
+import { StyleSheet } from '@emotion/sheet'
+
+let styleSheet = new StyleSheet({ key: '', container: document.head })
+
+styleSheet.insert('#box { border: 1px solid red; }')
+- appends a css rule into the stylesheet
+
+styleSheet.flush()
+- empties the stylesheet of all its contents
+
+*/
+// $FlowFixMe
+function sheetForTag(tag) {
+  if (tag.sheet) {
+    // $FlowFixMe
+    return tag.sheet;
+  } // this weirdness brought to you by firefox
+
+  /* istanbul ignore next */
+
+
+  for (var i = 0; i < document.styleSheets.length; i++) {
+    if (document.styleSheets[i].ownerNode === tag) {
+      // $FlowFixMe
+      return document.styleSheets[i];
+    }
+  }
+}
+
+function createStyleElement(options) {
+  var tag = document.createElement('style');
+  tag.setAttribute('data-emotion', options.key);
+
+  if (options.nonce !== undefined) {
+    tag.setAttribute('nonce', options.nonce);
+  }
+
+  tag.appendChild(document.createTextNode(''));
+  return tag;
+}
+
+var StyleSheet =
+/*#__PURE__*/
+function () {
+  function StyleSheet(options) {
+    this.isSpeedy = options.speedy === undefined ? process.env.NODE_ENV === 'production' : options.speedy;
+    this.tags = [];
+    this.ctr = 0;
+    this.nonce = options.nonce; // key is the value of the data-emotion attribute, it's used to identify different sheets
+
+    this.key = options.key;
+    this.container = options.container;
+    this.before = null;
+  }
+
+  var _proto = StyleSheet.prototype;
+
+  _proto.insert = function insert(rule) {
+    // the max length is how many rules we have per style tag, it's 65000 in speedy mode
+    // it's 1 in dev because we insert source maps that map a single rule to a location
+    // and you can only have one source map per style tag
+    if (this.ctr % (this.isSpeedy ? 65000 : 1) === 0) {
+      var _tag = createStyleElement(this);
+
+      var before;
+
+      if (this.tags.length === 0) {
+        before = this.before;
+      } else {
+        before = this.tags[this.tags.length - 1].nextSibling;
+      }
+
+      this.container.insertBefore(_tag, before);
+      this.tags.push(_tag);
+    }
+
+    var tag = this.tags[this.tags.length - 1];
+
+    if (this.isSpeedy) {
+      var sheet = sheetForTag(tag);
+
+      try {
+        // this is a really hot path
+        // we check the second character first because having "i"
+        // as the second character will happen less often than
+        // having "@" as the first character
+        var isImportRule = rule.charCodeAt(1) === 105 && rule.charCodeAt(0) === 64; // this is the ultrafast version, works across browsers
+        // the big drawback is that the css won't be editable in devtools
+
+        sheet.insertRule(rule, // we need to insert @import rules before anything else
+        // otherwise there will be an error
+        // technically this means that the @import rules will
+        // _usually_(not always since there could be multiple style tags)
+        // be the first ones in prod and generally later in dev
+        // this shouldn't really matter in the real world though
+        // @import is generally only used for font faces from google fonts and etc.
+        // so while this could be technically correct then it would be slower and larger
+        // for a tiny bit of correctness that won't matter in the real world
+        isImportRule ? 0 : sheet.cssRules.length);
+      } catch (e) {
+        if (process.env.NODE_ENV !== 'production') {
+          console.warn("There was a problem inserting the following rule: \"" + rule + "\"", e);
+        }
+      }
+    } else {
+      tag.appendChild(document.createTextNode(rule));
+    }
+
+    this.ctr++;
+  };
+
+  _proto.flush = function flush() {
+    // $FlowFixMe
+    this.tags.forEach(function (tag) {
+      return tag.parentNode.removeChild(tag);
+    });
+    this.tags = [];
+    this.ctr = 0;
+  };
+
+  return StyleSheet;
+}();
+
+export { StyleSheet };

web/node_modules/@emotion/sheet/dist/sheet.cjs.dev.js

@@ -0,0 +1,139 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/*
+
+Based off glamor's StyleSheet, thanks Sunil ❤️
+
+high performance StyleSheet for css-in-js systems
+
+- uses multiple style tags behind the scenes for millions of rules
+- uses `insertRule` for appending in production for *much* faster performance
+
+// usage
+
+import { StyleSheet } from '@emotion/sheet'
+
+let styleSheet = new StyleSheet({ key: '', container: document.head })
+
+styleSheet.insert('#box { border: 1px solid red; }')
+- appends a css rule into the stylesheet
+
+styleSheet.flush()
+- empties the stylesheet of all its contents
+
+*/
+// $FlowFixMe
+function sheetForTag(tag) {
+  if (tag.sheet) {
+    // $FlowFixMe
+    return tag.sheet;
+  } // this weirdness brought to you by firefox
+
+  /* istanbul ignore next */
+
+
+  for (var i = 0; i < document.styleSheets.length; i++) {
+    if (document.styleSheets[i].ownerNode === tag) {
+      // $FlowFixMe
+      return document.styleSheets[i];
+    }
+  }
+}
+
+function createStyleElement(options) {
+  var tag = document.createElement('style');
+  tag.setAttribute('data-emotion', options.key);
+
+  if (options.nonce !== undefined) {
+    tag.setAttribute('nonce', options.nonce);
+  }
+
+  tag.appendChild(document.createTextNode(''));
+  return tag;
+}
+
+var StyleSheet =
+/*#__PURE__*/
+function () {
+  function StyleSheet(options) {
+    this.isSpeedy = options.speedy === undefined ? process.env.NODE_ENV === 'production' : options.speedy;
+    this.tags = [];
+    this.ctr = 0;
+    this.nonce = options.nonce; // key is the value of the data-emotion attribute, it's used to identify different sheets
+
+    this.key = options.key;
+    this.container = options.container;
+    this.before = null;
+  }
+
+  var _proto = StyleSheet.prototype;
+
+  _proto.insert = function insert(rule) {
+    // the max length is how many rules we have per style tag, it's 65000 in speedy mode
+    // it's 1 in dev because we insert source maps that map a single rule to a location
+    // and you can only have one source map per style tag
+    if (this.ctr % (this.isSpeedy ? 65000 : 1) === 0) {
+      var _tag = createStyleElement(this);
+
+      var before;
+
+      if (this.tags.length === 0) {
+        before = this.before;
+      } else {
+        before = this.tags[this.tags.length - 1].nextSibling;
+      }
+
+      this.container.insertBefore(_tag, before);
+      this.tags.push(_tag);
+    }
+
+    var tag = this.tags[this.tags.length - 1];
+
+    if (this.isSpeedy) {
+      var sheet = sheetForTag(tag);
+
+      try {
+        // this is a really hot path
+        // we check the second character first because having "i"
+        // as the second character will happen less often than
+        // having "@" as the first character
+        var isImportRule = rule.charCodeAt(1) === 105 && rule.charCodeAt(0) === 64; // this is the ultrafast version, works across browsers
+        // the big drawback is that the css won't be editable in devtools
+
+        sheet.insertRule(rule, // we need to insert @import rules before anything else
+        // otherwise there will be an error
+        // technically this means that the @import rules will
+        // _usually_(not always since there could be multiple style tags)
+        // be the first ones in prod and generally later in dev
+        // this shouldn't really matter in the real world though
+        // @import is generally only used for font faces from google fonts and etc.
+        // so while this could be technically correct then it would be slower and larger
+        // for a tiny bit of correctness that won't matter in the real world
+        isImportRule ? 0 : sheet.cssRules.length);
+      } catch (e) {
+        if (process.env.NODE_ENV !== 'production') {
+          console.warn("There was a problem inserting the following rule: \"" + rule + "\"", e);
+        }
+      }
+    } else {
+      tag.appendChild(document.createTextNode(rule));
+    }
+
+    this.ctr++;
+  };
+
+  _proto.flush = function flush() {
+    // $FlowFixMe
+    this.tags.forEach(function (tag) {
+      return tag.parentNode.removeChild(tag);
+    });
+    this.tags = [];
+    this.ctr = 0;
+  };
+
+  return StyleSheet;
+}();
+
+exports.StyleSheet = StyleSheet;

web/node_modules/@emotion/sheet/dist/sheet.cjs.js

@@ -0,0 +1,7 @@
+'use strict';
+
+if (process.env.NODE_ENV === "production") {
+  module.exports = require("./sheet.cjs.prod.js");
+} else {
+  module.exports = require("./sheet.cjs.dev.js");
+}

web/node_modules/@emotion/sheet/dist/sheet.cjs.js.flow

@@ -0,0 +1,2 @@
+// @flow
+export * from "../src/index.js";

web/node_modules/@emotion/sheet/dist/sheet.cjs.prod.js

@@ -0,0 +1,47 @@
+"use strict";
+
+function sheetForTag(tag) {
+  if (tag.sheet) return tag.sheet;
+  for (var i = 0; i < document.styleSheets.length; i++) if (document.styleSheets[i].ownerNode === tag) return document.styleSheets[i];
+}
+
+function createStyleElement(options) {
+  var tag = document.createElement("style");
+  return tag.setAttribute("data-emotion", options.key), void 0 !== options.nonce && tag.setAttribute("nonce", options.nonce), 
+  tag.appendChild(document.createTextNode("")), tag;
+}
+
+Object.defineProperty(exports, "__esModule", {
+  value: !0
+});
+
+var StyleSheet = function() {
+  function StyleSheet(options) {
+    this.isSpeedy = void 0 === options.speedy || options.speedy, this.tags = [], this.ctr = 0, 
+    this.nonce = options.nonce, this.key = options.key, this.container = options.container, 
+    this.before = null;
+  }
+  var _proto = StyleSheet.prototype;
+  return _proto.insert = function(rule) {
+    if (this.ctr % (this.isSpeedy ? 65e3 : 1) == 0) {
+      var before, _tag = createStyleElement(this);
+      before = 0 === this.tags.length ? this.before : this.tags[this.tags.length - 1].nextSibling, 
+      this.container.insertBefore(_tag, before), this.tags.push(_tag);
+    }
+    var tag = this.tags[this.tags.length - 1];
+    if (this.isSpeedy) {
+      var sheet = sheetForTag(tag);
+      try {
+        var isImportRule = 105 === rule.charCodeAt(1) && 64 === rule.charCodeAt(0);
+        sheet.insertRule(rule, isImportRule ? 0 : sheet.cssRules.length);
+      } catch (e) {}
+    } else tag.appendChild(document.createTextNode(rule));
+    this.ctr++;
+  }, _proto.flush = function() {
+    this.tags.forEach(function(tag) {
+      return tag.parentNode.removeChild(tag);
+    }), this.tags = [], this.ctr = 0;
+  }, StyleSheet;
+}();
+
+exports.StyleSheet = StyleSheet;

web/node_modules/@emotion/sheet/dist/sheet.esm.js

@@ -0,0 +1,135 @@
+/*
+
+Based off glamor's StyleSheet, thanks Sunil ❤️
+
+high performance StyleSheet for css-in-js systems
+
+- uses multiple style tags behind the scenes for millions of rules
+- uses `insertRule` for appending in production for *much* faster performance
+
+// usage
+
+import { StyleSheet } from '@emotion/sheet'
+
+let styleSheet = new StyleSheet({ key: '', container: document.head })
+
+styleSheet.insert('#box { border: 1px solid red; }')
+- appends a css rule into the stylesheet
+
+styleSheet.flush()
+- empties the stylesheet of all its contents
+
+*/
+// $FlowFixMe
+function sheetForTag(tag) {
+  if (tag.sheet) {
+    // $FlowFixMe
+    return tag.sheet;
+  } // this weirdness brought to you by firefox
+
+  /* istanbul ignore next */
+
+
+  for (var i = 0; i < document.styleSheets.length; i++) {
+    if (document.styleSheets[i].ownerNode === tag) {
+      // $FlowFixMe
+      return document.styleSheets[i];
+    }
+  }
+}
+
+function createStyleElement(options) {
+  var tag = document.createElement('style');
+  tag.setAttribute('data-emotion', options.key);
+
+  if (options.nonce !== undefined) {
+    tag.setAttribute('nonce', options.nonce);
+  }
+
+  tag.appendChild(document.createTextNode(''));
+  return tag;
+}
+
+var StyleSheet =
+/*#__PURE__*/
+function () {
+  function StyleSheet(options) {
+    this.isSpeedy = options.speedy === undefined ? process.env.NODE_ENV === 'production' : options.speedy;
+    this.tags = [];
+    this.ctr = 0;
+    this.nonce = options.nonce; // key is the value of the data-emotion attribute, it's used to identify different sheets
+
+    this.key = options.key;
+    this.container = options.container;
+    this.before = null;
+  }
+
+  var _proto = StyleSheet.prototype;
+
+  _proto.insert = function insert(rule) {
+    // the max length is how many rules we have per style tag, it's 65000 in speedy mode
+    // it's 1 in dev because we insert source maps that map a single rule to a location
+    // and you can only have one source map per style tag
+    if (this.ctr % (this.isSpeedy ? 65000 : 1) === 0) {
+      var _tag = createStyleElement(this);
+
+      var before;
+
+      if (this.tags.length === 0) {
+        before = this.before;
+      } else {
+        before = this.tags[this.tags.length - 1].nextSibling;
+      }
+
+      this.container.insertBefore(_tag, before);
+      this.tags.push(_tag);
+    }
+
+    var tag = this.tags[this.tags.length - 1];
+
+    if (this.isSpeedy) {
+      var sheet = sheetForTag(tag);
+
+      try {
+        // this is a really hot path
+        // we check the second character first because having "i"
+        // as the second character will happen less often than
+        // having "@" as the first character
+        var isImportRule = rule.charCodeAt(1) === 105 && rule.charCodeAt(0) === 64; // this is the ultrafast version, works across browsers
+        // the big drawback is that the css won't be editable in devtools
+
+        sheet.insertRule(rule, // we need to insert @import rules before anything else
+        // otherwise there will be an error
+        // technically this means that the @import rules will
+        // _usually_(not always since there could be multiple style tags)
+        // be the first ones in prod and generally later in dev
+        // this shouldn't really matter in the real world though
+        // @import is generally only used for font faces from google fonts and etc.
+        // so while this could be technically correct then it would be slower and larger
+        // for a tiny bit of correctness that won't matter in the real world
+        isImportRule ? 0 : sheet.cssRules.length);
+      } catch (e) {
+        if (process.env.NODE_ENV !== 'production') {
+          console.warn("There was a problem inserting the following rule: \"" + rule + "\"", e);
+        }
+      }
+    } else {
+      tag.appendChild(document.createTextNode(rule));
+    }
+
+    this.ctr++;
+  };
+
+  _proto.flush = function flush() {
+    // $FlowFixMe
+    this.tags.forEach(function (tag) {
+      return tag.parentNode.removeChild(tag);
+    });
+    this.tags = [];
+    this.ctr = 0;
+  };
+
+  return StyleSheet;
+}();
+
+export { StyleSheet };

web/node_modules/@emotion/sheet/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@emotion/sheet",
+  "version": "0.9.4",
+  "description": "emotion's stylesheet",
+  "main": "dist/sheet.cjs.js",
+  "module": "dist/sheet.esm.js",
+  "browser": {
+    "./dist/sheet.cjs.js": "./dist/sheet.browser.cjs.js",
+    "./dist/sheet.esm.js": "./dist/sheet.browser.esm.js"
+  },
+  "types": "types/index.d.ts",
+  "license": "MIT",
+  "scripts": {
+    "test:typescript": "dtslint types"
+  },
+  "repository": "https://github.com/emotion-js/emotion/tree/master/packages/sheet",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "src",
+    "dist",
+    "types"
+  ],
+  "devDependencies": {
+    "dtslint": "^0.3.0"
+  }
+}

web/node_modules/@emotion/sheet/src/index.js

@@ -0,0 +1,143 @@
+// @flow
+/*
+
+Based off glamor's StyleSheet, thanks Sunil ❤️
+
+high performance StyleSheet for css-in-js systems
+
+- uses multiple style tags behind the scenes for millions of rules
+- uses `insertRule` for appending in production for *much* faster performance
+
+// usage
+
+import { StyleSheet } from '@emotion/sheet'
+
+let styleSheet = new StyleSheet({ key: '', container: document.head })
+
+styleSheet.insert('#box { border: 1px solid red; }')
+- appends a css rule into the stylesheet
+
+styleSheet.flush()
+- empties the stylesheet of all its contents
+
+*/
+
+// $FlowFixMe
+function sheetForTag(tag: HTMLStyleElement): CSSStyleSheet {
+  if (tag.sheet) {
+    // $FlowFixMe
+    return tag.sheet
+  }
+
+  // this weirdness brought to you by firefox
+  /* istanbul ignore next */
+  for (let i = 0; i < document.styleSheets.length; i++) {
+    if (document.styleSheets[i].ownerNode === tag) {
+      // $FlowFixMe
+      return document.styleSheets[i]
+    }
+  }
+}
+
+export type Options = {
+  nonce?: string,
+  key: string,
+  container: HTMLElement,
+  speedy?: boolean
+}
+
+function createStyleElement(options: {
+  key: string,
+  nonce: string | void
+}): HTMLStyleElement {
+  let tag = document.createElement('style')
+  tag.setAttribute('data-emotion', options.key)
+  if (options.nonce !== undefined) {
+    tag.setAttribute('nonce', options.nonce)
+  }
+  tag.appendChild(document.createTextNode(''))
+  return tag
+}
+
+export class StyleSheet {
+  isSpeedy: boolean
+  ctr: number
+  tags: HTMLStyleElement[]
+  container: HTMLElement
+  key: string
+  nonce: string | void
+  before: Element | null
+  constructor(options: Options) {
+    this.isSpeedy =
+      options.speedy === undefined
+        ? process.env.NODE_ENV === 'production'
+        : options.speedy
+    this.tags = []
+    this.ctr = 0
+    this.nonce = options.nonce
+    // key is the value of the data-emotion attribute, it's used to identify different sheets
+    this.key = options.key
+    this.container = options.container
+    this.before = null
+  }
+  insert(rule: string) {
+    // the max length is how many rules we have per style tag, it's 65000 in speedy mode
+    // it's 1 in dev because we insert source maps that map a single rule to a location
+    // and you can only have one source map per style tag
+    if (this.ctr % (this.isSpeedy ? 65000 : 1) === 0) {
+      let tag = createStyleElement(this)
+      let before
+      if (this.tags.length === 0) {
+        before = this.before
+      } else {
+        before = this.tags[this.tags.length - 1].nextSibling
+      }
+      this.container.insertBefore(tag, before)
+      this.tags.push(tag)
+    }
+    const tag = this.tags[this.tags.length - 1]
+
+    if (this.isSpeedy) {
+      const sheet = sheetForTag(tag)
+      try {
+        // this is a really hot path
+        // we check the second character first because having "i"
+        // as the second character will happen less often than
+        // having "@" as the first character
+        let isImportRule =
+          rule.charCodeAt(1) === 105 && rule.charCodeAt(0) === 64
+        // this is the ultrafast version, works across browsers
+        // the big drawback is that the css won't be editable in devtools
+        sheet.insertRule(
+          rule,
+          // we need to insert @import rules before anything else
+          // otherwise there will be an error
+          // technically this means that the @import rules will
+          // _usually_(not always since there could be multiple style tags)
+          // be the first ones in prod and generally later in dev
+          // this shouldn't really matter in the real world though
+          // @import is generally only used for font faces from google fonts and etc.
+          // so while this could be technically correct then it would be slower and larger
+          // for a tiny bit of correctness that won't matter in the real world
+          isImportRule ? 0 : sheet.cssRules.length
+        )
+      } catch (e) {
+        if (process.env.NODE_ENV !== 'production') {
+          console.warn(
+            `There was a problem inserting the following rule: "${rule}"`,
+            e
+          )
+        }
+      }
+    } else {
+      tag.appendChild(document.createTextNode(rule))
+    }
+    this.ctr++
+  }
+  flush() {
+    // $FlowFixMe
+    this.tags.forEach(tag => tag.parentNode.removeChild(tag))
+    this.tags = []
+    this.ctr = 0
+  }
+}

web/node_modules/@emotion/sheet/types/index.d.ts

@@ -0,0 +1,23 @@
+// Definitions by: Junyoung Clare Jang <https://github.com/Ailrun>
+// TypeScript Version: 2.0
+
+export interface Options {
+  nonce?: string
+  key: string
+  container: HTMLElement
+  speedy?: boolean
+}
+
+export class StyleSheet {
+  isSpeedy: boolean
+  ctr: number
+  tags: Array<HTMLStyleElement>
+  container: HTMLElement
+  maxLength: number
+  key: string
+  nonce?: string
+  before?: Element | null
+  constructor(options?: Options)
+  insert(rule: string): void
+  flush(): void
+}

web/node_modules/@emotion/sheet/types/tests.ts

@@ -0,0 +1,57 @@
+import { Options, StyleSheet } from '@emotion/sheet'
+
+new StyleSheet({
+  key: 'abc',
+  container: document.createElement('div')
+})
+
+new StyleSheet({
+  key: 'abc',
+  container: document.createElement('div'),
+  nonce: 'fefwe090rqr'
+})
+new StyleSheet({
+  key: 'abc',
+  container: document.createElement('div'),
+  speedy: true
+})
+// $ExpectError
+new StyleSheet({
+  container: document.createElement('div'),
+  key: 120
+})
+new StyleSheet({
+  container: document.createElement('div'),
+  // $ExpectError
+  kye: 'abc'
+})
+
+const styleSheet0 = new StyleSheet({
+  key: 'abc',
+  container: document.createElement('div')
+})
+const styleSheet1: StyleSheet = styleSheet0
+const styleSheet2: StyleSheet = new StyleSheet()
+
+const styleSheet = new StyleSheet({
+  key: 'abc',
+  container: document.createElement('div')
+})
+
+styleSheet.insert('.name{ color: black; }')
+styleSheet.insert('.cl{ width: 200px; height: 200px; }')
+// $ExpectError
+styleSheet.insert()
+// $ExpectError
+styleSheet.insert('.name{ color: black; }', undefined as any)
+// $ExpectError
+styleSheet.insert(
+  '.name{ color: black; }',
+  ...((undefined as any) as Array<any>)
+)
+
+styleSheet.flush()
+// $ExpectError
+styleSheet.flush(undefined as any)
+// $ExpectError
+styleSheet.flush(...((undefined as any) as Array<any>))

web/node_modules/@emotion/sheet/types/tsconfig.json

@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    "baseUrl": "../",
+    "forceConsistentCasingInFileNames": true,
+    "jsx": "react",
+    "lib": [
+      "es6",
+      "dom"
+    ],
+    "module": "commonjs",
+    "noEmit": true,
+    "noImplicitAny": true,
+    "noImplicitThis": true,
+    "strict": true,
+    "strictNullChecks": true,
+    "strictFunctionTypes": true,
+    "target": "es5",
+    "typeRoots": [
+      "../"
+    ],
+    "types": []
+  },
+  "include": [
+    "./*.ts",
+    "./*.tsx"
+  ]
+}

web/node_modules/@emotion/sheet/types/tslint.json

@@ -0,0 +1,10 @@
+{
+    "extends": "dtslint/dtslint.json",
+    "rules": {
+        "array-type": [
+            true,
+            "generic"
+        ],
+        "semicolon": false
+    }
+}