picata 0.0.6__py3-none-any.whl → 0.0.7__py3-none-any.whl

node_modules/csso/README.md

@@ -0,0 +1,422 @@
+[![NPM version](https://img.shields.io/npm/v/csso.svg)](https://www.npmjs.com/package/csso)
+[![Build Status](https://github.com/css/csso/actions/workflows/build.yml/badge.svg)](https://github.com/css/csso/actions/workflows/build.yml)
+[![Coverage Status](https://coveralls.io/repos/github/css/csso/badge.svg?branch=master)](https://coveralls.io/github/css/csso?branch=master)
+[![NPM Downloads](https://img.shields.io/npm/dm/csso.svg)](https://www.npmjs.com/package/csso)
+[![Twitter](https://img.shields.io/badge/Twitter-@cssoptimizer-blue.svg)](https://twitter.com/cssoptimizer)
+
+CSSO (CSS Optimizer) is a CSS minifier. It performs three sort of transformations: cleaning (removing redundants), compression (replacement for the shorter forms) and restructuring (merge of declarations, rules and so on). As a result an output CSS becomes much smaller in size.
+
+## Install
+
+```
+npm install csso
+```
+
+## Usage
+
+```js
+import { minify } from 'csso';
+// CommonJS is also supported
+// const { minify } = require('csso');
+
+const minifiedCss = minify('.test { color: #ff0000; }').css;
+
+console.log(minifiedCss);
+// .test{color:red}
+```
+
+Bundles are also available for use in a browser:
+
+- `dist/csso.js` – minified IIFE with `csso` as global
+```html
+<script src="node_modules/csso/dist/csso.js"></script>
+<script>
+  csso.minify('.example { color: green }');
+</script>
+```
+
+- `dist/csso.esm.js` – minified ES module
+```html
+<script type="module">
+  import { minify } from 'node_modules/csso/dist/csso.esm.js'
+
+  minify('.example { color: green }');
+</script>
+```
+
+One of CDN services like `unpkg` or `jsDelivr` can be used. By default (for short path) a ESM version is exposing. For IIFE version a full path to a bundle should be specified:
+
+```html
+<!-- ESM -->
+<script type="module">
+  import * as csstree from 'https://cdn.jsdelivr.net/npm/csso';
+  import * as csstree from 'https://unpkg.com/csso';
+</script>
+
+<!-- IIFE with an export to global -->
+<script src="https://cdn.jsdelivr.net/npm/csso/dist/csso.js"></script>
+<script src="https://unpkg.com/csso/dist/csso.js"></script>
+```
+
+CSSO is based on [CSSTree](https://github.com/csstree/csstree) to parse CSS into AST, AST traversal and to generate AST back to CSS. All `CSSTree` API is available behind `syntax` field extended with `compress()` method. You may minify CSS step by step:
+
+```js
+import { syntax } from 'csso';
+
+const ast = syntax.parse('.test { color: #ff0000; }');
+const compressedAst = syntax.compress(ast).ast;
+const minifiedCss = syntax.generate(compressedAst);
+
+console.log(minifiedCss);
+// .test{color:red}
+```
+
+Also syntax can be imported using `csso/syntax` entry point:
+
+```js
+import { parse, compress, generate } from 'csso/syntax';
+
+const ast = parse('.test { color: #ff0000; }');
+const compressedAst = compress(ast).ast;
+const minifiedCss = generate(compressedAst);
+
+console.log(minifiedCss);
+// .test{color:red}
+```
+
+> Warning: CSSO doesn't guarantee API behind a `syntax` field as well as AST format. Both might be changed with changes in CSSTree. If you rely heavily on `syntax` API, a better option might be to use CSSTree directly.
+
+## Related projects
+
+- [Web interface](http://css.github.io/csso/csso.html)
+- [csso-cli](https://github.com/css/csso-cli) – command line interface
+- [gulp-csso](https://github.com/ben-eb/gulp-csso) – `Gulp` plugin
+- [grunt-csso](https://github.com/t32k/grunt-csso) – `Grunt` plugin
+- [broccoli-csso](https://github.com/sindresorhus/broccoli-csso) – `Broccoli` plugin
+- [postcss-csso](https://github.com/lahmatiy/postcss-csso) – `PostCSS` plugin
+- [csso-loader](https://github.com/sandark7/csso-loader) – `webpack` loader
+- [csso-webpack-plugin](https://github.com/zoobestik/csso-webpack-plugin) – `webpack` plugin
+- [CSSO Visual Studio Code plugin](https://marketplace.visualstudio.com/items?itemName=Aneryu.csso)
+- [vscode-csso](https://github.com/1000ch/vscode-csso) - Visual Studio Code plugin
+- [atom-csso](https://github.com/1000ch/atom-csso) - Atom plugin
+- [Sublime-csso](https://github.com/1000ch/Sublime-csso) - Sublime plugin
+
+## API
+
+<!-- TOC depthfrom:3 -->
+
+- [minify(source[, options])](#minifysource-options)
+- [minifyBlock(source[, options])](#minifyblocksource-options)
+- [syntax.compress(ast[, options])](#syntaxcompressast-options)
+- [Source maps](#source-maps)
+- [Usage data](#usage-data)
+    - [White list filtering](#white-list-filtering)
+    - [Black list filtering](#black-list-filtering)
+    - [Scopes](#scopes)
+
+<!-- /TOC -->
+
+### minify(source[, options])
+
+Minify `source` CSS passed as `String`.
+
+```js
+const result = csso.minify('.test { color: #ff0000; }', {
+    restructure: false,   // don't change CSS structure, i.e. don't merge declarations, rulesets etc
+    debug: true           // show additional debug information:
+                          // true or number from 1 to 3 (greater number - more details)
+});
+
+console.log(result.css);
+// > .test{color:red}
+```
+
+Returns an object with properties:
+
+- css `String` – resulting CSS
+- map `Object` – instance of [`SourceMapGenerator`](https://github.com/mozilla/source-map#sourcemapgenerator) or `null`
+
+Options:
+
+- sourceMap
+
+  Type: `Boolean`  
+  Default: `false`
+
+  Generate a source map when `true`.
+
+- filename
+
+  Type: `String`  
+  Default: `'<unknown>'`
+
+  Filename of input CSS, uses for source map generation.
+
+- debug
+
+  Type: `Boolean`  
+  Default: `false`
+
+  Output debug information to `stderr`.
+
+- beforeCompress
+
+  Type: `function(ast, options)` or `Array<function(ast, options)>` or `null`  
+  Default: `null`
+
+  Called right after parse is run.
+
+- afterCompress
+
+  Type: `function(compressResult, options)` or `Array<function(compressResult, options)>` or `null`  
+  Default: `null`
+
+  Called right after [`syntax.compress()`](#syntaxcompressast-options) is run.
+
+- Other options are the same as for [`syntax.compress()`](#syntaxcompressast-options) function.
+
+### minifyBlock(source[, options])
+
+The same as `minify()` but for list of declarations. Usually it's a `style` attribute value.
+
+```js
+const result = csso.minifyBlock('color: rgba(255, 0, 0, 1); color: #ff0000');
+
+console.log(result.css);
+// > color:red
+```
+
+### syntax.compress(ast[, options])
+
+Does the main task – compress an AST. This is CSSO's extension in CSSTree syntax API.
+
+> NOTE: `syntax.compress()` performs AST compression by transforming input AST by default (since AST cloning is expensive and needed in rare cases). Use `clone` option with truthy value in case you want to keep input AST untouched.
+
+Returns an object with properties:
+
+- ast `Object` – resulting AST
+
+Options:
+
+- restructure
+
+  Type: `Boolean`  
+  Default: `true`
+
+  Disable or enable a structure optimisations.
+
+- forceMediaMerge
+
+  Type: `Boolean`  
+  Default: `false`
+
+  Enables merging of `@media` rules with the same media query by splitted by other rules. The optimisation is unsafe in general, but should work fine in most cases. Use it on your own risk.
+
+- clone
+
+  Type: `Boolean`  
+  Default: `false`
+
+  Transform a copy of input AST if `true`. Useful in case of AST reuse.
+
+- comments
+
+  Type: `String` or `Boolean`  
+  Default: `true`
+
+  Specify what comments to leave:
+
+  - `'exclamation'` or `true` – leave all exclamation comments (i.e. `/*! .. */`)
+  - `'first-exclamation'` – remove every comment except first one
+  - `false` – remove all comments
+
+- usage
+
+  Type: `Object` or `null`  
+  Default: `null`
+
+  Usage data for advanced optimisations (see [Usage data](#usage-data) for details)
+
+- logger
+
+  Type: `Function` or `null`  
+  Default: `null`
+
+  Function to track every step of transformation.
+
+### Source maps
+
+To get a source map set `true` for `sourceMap` option. Additianaly `filename` option can be passed to specify source file. When `sourceMap` option is `true`, `map` field of result object will contain a [`SourceMapGenerator`](https://github.com/mozilla/source-map#sourcemapgenerator) instance. This object can be mixed with another source map or translated to string.
+
+```js
+const csso = require('csso');
+const css = fs.readFileSync('path/to/my.css', 'utf8');
+const result = csso.minify(css, {
+  filename: 'path/to/my.css', // will be added to source map as reference to source file
+  sourceMap: true             // generate source map
+});
+
+console.log(result);
+// { css: '...minified...', map: SourceMapGenerator {} }
+
+console.log(result.map.toString());
+// '{ .. source map content .. }'
+```
+
+Example of generating source map with respect of source map from input CSS:
+
+```js
+import { SourceMapConsumer } from 'source-map';
+import * as csso from 'csso';
+
+const inputFile = 'path/to/my.css';
+const input = fs.readFileSync(inputFile, 'utf8');
+const inputMap = input.match(/\/\*# sourceMappingURL=(\S+)\s*\*\/\s*$/);
+const output = csso.minify(input, {
+  filename: inputFile,
+  sourceMap: true
+});
+
+// apply input source map to output
+if (inputMap) {
+  output.map.applySourceMap(
+    new SourceMapConsumer(inputMap[1]),
+    inputFile
+  )
+}
+
+// result CSS with source map
+console.log(
+  output.css +
+  '/*# sourceMappingURL=data:application/json;base64,' +
+  Buffer.from(output.map.toString()).toString('base64') +
+  ' */'
+);
+```
+
+### Usage data
+
+`CSSO` can use data about how `CSS` is used in a markup for better compression. File with this data (`JSON`) can be set using `usage` option. Usage data may contain following sections:
+
+- `blacklist` – a set of black lists (see [Black list filtering](#black-list-filtering))
+- `tags` – white list of tags
+- `ids` – white list of ids
+- `classes` – white list of classes
+- `scopes` – groups of classes which never used with classes from other groups on the same element
+
+All sections are optional. Value of `tags`, `ids` and `classes` should be an array of a string, value of `scopes` should be an array of arrays of strings. Other values are ignoring.
+
+#### White list filtering
+
+`tags`, `ids` and `classes` are using on clean stage to filter selectors that contain something not in the lists. Selectors are filtering only by those kind of simple selector which white list is specified. For example, if only `tags` list is specified then type selectors are checking, and if all type selectors in selector present in list or selector has no any type selector it isn't filter.
+
+> `ids` and `classes` are case sensitive, `tags` – is not.
+
+Input CSS:
+
+```css
+* { color: green; }
+ul, ol, li { color: blue; }
+UL.foo, span.bar { color: red; }
+```
+
+Usage data:
+
+```json
+{
+    "tags": ["ul", "LI"]
+}
+```
+
+Resulting CSS:
+
+```css
+*{color:green}ul,li{color:blue}ul.foo{color:red}
+```
+
+Filtering performs for nested selectors too. `:not()` pseudos content is ignoring since the result of matching is unpredictable. Example for the same usage data as above:
+
+```css
+:nth-child(2n of ul, ol) { color: red }
+:nth-child(3n + 1 of img) { color: yellow }
+:not(div, ol, ul) { color: green }
+:has(:matches(ul, ol), ul, ol) { color: blue }
+```
+
+Turns into:
+
+```css
+:nth-child(2n of ul){color:red}:not(div,ol,ul){color:green}:has(:matches(ul),ul){color:blue}
+```
+
+#### Black list filtering
+
+Black list filtering performs the same as white list filtering, but filters things that mentioned in the lists. `blacklist` can contain the lists `tags`, `ids` and `classes`.
+
+Black list has a higher priority, so when something mentioned in the white list and in the black list then white list occurrence is ignoring. The `:not()` pseudos content ignoring as well.
+
+```css
+* { color: green; }
+ul, ol, li { color: blue; }
+UL.foo, li.bar { color: red; }
+```
+
+Usage data:
+
+```json
+{
+    "blacklist": {
+        "tags": ["ul"]
+    },
+    "tags": ["ul", "LI"]
+}
+```
+
+Resulting CSS:
+
+```css
+*{color:green}li{color:blue}li.bar{color:red}
+```
+
+#### Scopes
+
+Scopes is designed for CSS scope isolation solutions such as [css-modules](https://github.com/css-modules/css-modules). Scopes are similar to namespaces and define lists of class names that exclusively used on some markup. This information allows the optimizer to move rules more agressive. Since it assumes selectors from different scopes don't match for the same element. This can improve rule merging.
+
+Suppose we have a file:
+
+```css
+.module1-foo { color: red; }
+.module1-bar { font-size: 1.5em; background: yellow; }
+
+.module2-baz { color: red; }
+.module2-qux { font-size: 1.5em; background: yellow; width: 50px; }
+```
+
+It can be assumed that first two rules are never used with the second two on the same markup. But we can't say that for sure without a markup review. The optimizer doesn't know it either and will perform safe transformations only. The result will be the same as input but with no spaces and some semicolons:
+
+```css
+.module1-foo{color:red}.module1-bar{font-size:1.5em;background:#ff0}.module2-baz{color:red}.module2-qux{font-size:1.5em;background:#ff0;width:50px}
+```
+
+With usage data `CSSO` can produce better output. If follow usage data is provided:
+
+```json
+{
+    "scopes": [
+        ["module1-foo", "module1-bar"],
+        ["module2-baz", "module2-qux"]
+    ]
+}
+```
+
+The result will be (29 bytes extra saving):
+
+```css
+.module1-foo,.module2-baz{color:red}.module1-bar,.module2-qux{font-size:1.5em;background:#ff0}.module2-qux{width:50px}
+```
+
+If class name isn't mentioned in the `scopes` it belongs to default scope. `scopes` data doesn't affect `classes` whitelist. If class name mentioned in `scopes` but missed in `classes` (both sections are specified) it will be filtered.
+
+Note that class name can't be set for several scopes. Also a selector can't have class names from different scopes. In both cases an exception will thrown.
+
+Currently the optimizer doesn't care about changing order safety for out-of-bounds selectors (i.e. selectors that match to elements without class name, e.g. `.scope div` or `.scope ~ :last-child`). It assumes that scoped CSS modules doesn't relay on it's order. It may be fix in future if to be an issue.

node_modules/csso/node_modules/css-tree/README.md

@@ -0,0 +1,193 @@
+<img align="right" width="111" height="111"
+     alt="CSSTree logo"
+     src="https://cloud.githubusercontent.com/assets/270491/19243723/6f9136c6-8f21-11e6-82ac-eeeee4c6c452.png"/>
+
+# CSSTree
+
+[![NPM version](https://img.shields.io/npm/v/css-tree.svg)](https://www.npmjs.com/package/css-tree)
+[![Build Status](https://github.com/csstree/csstree/actions/workflows/build.yml/badge.svg)](https://github.com/csstree/csstree/actions/workflows/build.yml)
+[![Coverage Status](https://coveralls.io/repos/github/csstree/csstree/badge.svg?branch=master)](https://coveralls.io/github/csstree/csstree?branch=master)
+[![NPM Downloads](https://img.shields.io/npm/dm/css-tree.svg)](https://www.npmjs.com/package/css-tree)
+[![Twitter](https://img.shields.io/badge/Twitter-@csstree-blue.svg)](https://twitter.com/csstree)
+
+CSSTree is a tool set for CSS: [fast](https://github.com/postcss/benchmark) detailed parser (CSS → AST), walker (AST traversal), generator (AST → CSS) and lexer (validation and matching) based on specs and browser implementations. The main goal is to be efficient and W3C spec compliant, with focus on CSS analyzing and source-to-source transforming tasks.
+
+## Features
+
+- **Detailed parsing with an adjustable level of detail**
+
+  By default CSSTree parses CSS as detailed as possible, i.e. each single logical part is representing with its own AST node (see [AST format](docs/ast.md) for all possible node types). The parsing detail level can be changed through [parser options](docs/parsing.md#parsesource-options), for example, you can disable parsing of selectors or declaration values for component parts.
+
+- **Tolerant to errors by design**
+
+  Parser behaves as [spec says](https://www.w3.org/TR/css-syntax-3/#error-handling): "When errors occur in CSS, the parser attempts to recover gracefully, throwing away only the minimum amount of content before returning to parsing as normal". The only thing the parser departs from the specification is that it doesn't throw away bad content, but wraps it in a special node type (`Raw`) that allows processing it later.
+
+- **Fast and efficient**
+
+  CSSTree is created with focus on performance and effective memory consumption. Therefore it's [one of the fastest CSS parsers](https://github.com/postcss/benchmark) at the moment.
+
+- **Syntax validation**
+
+  The build-in lexer can test CSS against syntaxes defined by W3C. CSSTree uses [mdn/data](https://github.com/mdn/data/) as a basis for lexer's dictionaries and extends it with vendor specific and legacy syntaxes. Lexer can only check the declaration values currently, but this feature will be extended to other parts of the CSS in the future.
+
+## Projects using CSSTree
+
+- [Svelte](https://github.com/sveltejs/svelte) – Cybernetically enhanced web apps
+- [SVGO](https://github.com/svg/svgo) – Node.js tool for optimizing SVG files
+- [CSSO](https://github.com/css/csso) – CSS minifier with structural optimizations
+- [NativeScript](https://github.com/NativeScript/NativeScript) – NativeScript empowers you to access native APIs from JavaScript directly
+- [react-native-svg](https://github.com/react-native-svg/react-native-svg) – SVG library for React Native, React Native Web, and plain React web projects
+- [penthouse](https://github.com/pocketjoso/penthouse) – Critical Path CSS Generator
+- [Bit](https://github.com/teambit/bit) – Bit is the platform for collaborating on components
+- and more...
+
+## Documentation
+
+- [AST format](docs/ast.md)
+- [Parsing CSS → AST](docs/parsing.md)
+  - [parse(source[, options])](docs/parsing.md#parsesource-options)
+- [Serialization AST → CSS](docs/generate.md)
+  - [generate(ast[, options])](docs/generate.md#generateast-options)
+- [AST traversal](docs/traversal.md)
+  - [walk(ast, options)](docs/traversal.md#walkast-options)
+  - [find(ast, fn)](docs/traversal.md#findast-fn)
+  - [findLast(ast, fn)](docs/traversal.md#findlastast-fn)
+  - [findAll(ast, fn)](docs/traversal.md#findallast-fn)
+- [Util functions](docs/utils.md)
+  - Value encoding & decoding
+    - [property(name)](docs/utils.md#propertyname)
+    - [keyword(name)](docs/utils.md#keywordname)
+    - [ident](docs/utils.md#ident)
+    - [string](docs/utils.md#string)
+    - [url](docs/utils.md#url)
+  - AST transforming
+    - [clone(ast)](docs/utils.md#cloneast)
+    - [fromPlainObject(object)](docs/utils.md#fromplainobjectobject)
+    - [toPlainObject(ast)](docs/utils.md#toplainobjectast)
+- [Value Definition Syntax](docs/definition-syntax.md)
+  - [parse(source)](docs/definition-syntax.md#parsesource)
+  - [walk(node, options, context)](docs/definition-syntax.md#walknode-options-context)
+  - [generate(node, options)](docs/definition-syntax.md#generatenode-options)
+  - [AST format](docs/definition-syntax.md#ast-format)
+
+## Tools
+
+* [AST Explorer](https://astexplorer.net/#/gist/244e2fb4da940df52bf0f4b94277db44/e79aff44611020b22cfd9708f3a99ce09b7d67a8) – explore CSSTree AST format with zero setup
+* [CSS syntax reference](https://csstree.github.io/docs/syntax.html)
+* [CSS syntax validator](https://csstree.github.io/docs/validator.html)
+
+## Related projects
+
+* [csstree-validator](https://github.com/csstree/validator) – NPM package to validate CSS
+* [stylelint-csstree-validator](https://github.com/csstree/stylelint-validator) – plugin for stylelint to validate CSS
+* [Grunt plugin](https://github.com/sergejmueller/grunt-csstree-validator)
+* [Gulp plugin](https://github.com/csstree/gulp-csstree)
+* [Sublime plugin](https://github.com/csstree/SublimeLinter-contrib-csstree)
+* [VS Code plugin](https://github.com/csstree/vscode-plugin)
+* [Atom plugin](https://github.com/csstree/atom-plugin)
+
+## Usage
+
+Install with npm:
+
+```
+npm install css-tree
+```
+
+Basic usage:
+
+```js
+import * as csstree from 'css-tree';
+
+// parse CSS to AST
+const ast = csstree.parse('.example { world: "!" }');
+
+// traverse AST and modify it
+csstree.walk(ast, (node) => {
+    if (node.type === 'ClassSelector' && node.name === 'example') {
+        node.name = 'hello';
+    }
+});
+
+// generate CSS from AST
+console.log(csstree.generate(ast));
+// .hello{world:"!"}
+```
+
+Syntax matching:
+
+```js
+// parse CSS to AST as a declaration value
+const ast = csstree.parse('red 1px solid', { context: 'value' });
+
+// match to syntax of `border` property
+const matchResult = csstree.lexer.matchProperty('border', ast);
+
+// check first value node is a <color>
+console.log(matchResult.isType(ast.children.first, 'color'));
+// true
+
+// get a type list matched to a node
+console.log(matchResult.getTrace(ast.children.first));
+// [ { type: 'Property', name: 'border' },
+//   { type: 'Type', name: 'color' },
+//   { type: 'Type', name: 'named-color' },
+//   { type: 'Keyword', name: 'red' } ]
+```
+
+### Exports
+
+Is it possible to import just a needed part of library like a parser or a walker. That's might useful for loading time or bundle size optimisations. 
+
+```js
+import * as tokenizer from 'css-tree/tokenizer';
+import * as parser from 'css-tree/parser';
+import * as walker from 'css-tree/walker';
+import * as lexer from 'css-tree/lexer';
+import * as definitionSyntax from 'css-tree/definition-syntax';
+import * as data from 'css-tree/definition-syntax-data';
+import * as dataPatch from 'css-tree/definition-syntax-data-patch';
+import * as utils from 'css-tree/utils';
+```
+
+### Using in a browser
+
+Bundles are available for use in a browser:
+
+- `dist/csstree.js` – minified IIFE with `csstree` as global
+```html
+<script src="node_modules/css-tree/dist/csstree.js"></script>
+<script>
+  csstree.parse('.example { color: green }');
+</script>
+```
+
+- `dist/csstree.esm.js` – minified ES module
+```html
+<script type="module">
+  import { parse } from 'node_modules/css-tree/dist/csstree.esm.js'
+  parse('.example { color: green }');
+</script>
+```
+
+One of CDN services like `unpkg` or `jsDelivr` can be used. By default (for short path) a ESM version is exposing. For IIFE version a full path to a bundle should be specified:
+
+```html
+<!-- ESM -->
+<script type="module">
+  import * as csstree from 'https://cdn.jsdelivr.net/npm/css-tree';
+  import * as csstree from 'https://unpkg.com/css-tree';
+</script>
+
+<!-- IIFE with an export to global -->
+<script src="https://cdn.jsdelivr.net/npm/css-tree/dist/csstree.js"></script>
+<script src="https://unpkg.com/css-tree/dist/csstree.js"></script>
+```
+
+## Top level API
+
+![API map](https://cdn.rawgit.com/csstree/csstree/aaf327e/docs/api-map.svg)
+
+## License
+
+MIT

node_modules/csso/node_modules/mdn-data/README.md

@@ -0,0 +1,56 @@
+# MDN data
+
+[https://github.com/mdn/data](https://github.com/mdn/data)
+
+Maintained by the [MDN team at Mozilla](https://wiki.mozilla.org/MDN).
+
+This repository contains general data for Web technologies.
+
+This data is used in MDN documentation, to build
+[information boxes](https://developer.mozilla.org/en-US/docs/Web/CSS/background)
+or [sidebar navigation](https://developer.mozilla.org/en-US/docs/Web/API/Window).
+External tools have started to make use of this data as well.
+For example, the [CSSTree](https://github.com/csstree/csstree/) CSS parser.
+
+
+[![NPM version](https://img.shields.io/npm/v/mdn-data.svg)](https://www.npmjs.com/package/mdn-data)
+[![lint](https://github.com/mdn/data/actions/workflows/lint.yml/badge.svg)](https://github.com/mdn/data/actions/workflows/lint.yml)
+
+## Repository contents
+
+There's a top-level directory for each broad area covered: for example, `api`
+and `css`. Inside each of these directories is one or more
+JSON files containing the data.
+
+### api
+Contains data about Web APIs:
+* API inheritance (interface inheritance and mixin implementations)
+
+### css
+ Contains data about:
+* CSS at-rules
+* CSS properties
+* CSS selectors
+* CSS syntaxes
+* CSS types
+* CSS units
+
+Read more about [CSS data](https://github.com/mdn/data/blob/master/css/readme.md) and the format of the files.
+
+
+### l10n
+The l10n folder contains localization strings that are used in the various
+json files throughout this repository.
+
+## Problems?
+
+If you find a problem, please [file an issue](https://github.com/mdn/data/issues/new).
+
+## Contributing
+
+We're very happy to accept contributions to this data. Please familiarize yourself
+with the schema for the data you're editing, and send us a pull request. See also the [Contributing file](https://github.com/mdn/data/blob/master/CONTRIBUTING.md) for more information.
+
+## See also
+* [https://github.com/mdn/browser-compat-data](https://github.com/mdn/browser-compat-data)
+for compatibility data for Web technologies