create-docusaurus 0.0.0-4375 → 0.0.0-4379

package/templates/facebook/node_modules/@stylelint/postcss-css-in-js/template-parse.js

@@ -0,0 +1,19 @@
+'use strict';
+
+const Input = require('postcss/lib/input');
+const TemplateParser = require('./template-parser');
+
+function templateParse(css, opts) {
+	const input = new Input(css, opts);
+
+	input.quasis = opts.quasis;
+	input.templateLiteralStyles = opts.templateLiteralStyles;
+	input.parseOptions = opts;
+	const parser = new TemplateParser(input);
+
+	parser.parse();
+
+	return parser.root;
+}
+
+module.exports = templateParse;

package/templates/facebook/node_modules/@stylelint/postcss-css-in-js/template-parser-helper.js

@@ -0,0 +1,260 @@
+'use strict';
+
+const Literal = require('./literal');
+const postcssParse = require('postcss/lib/parse');
+const reNewLine = /(?:\r?\n|\r)/gm;
+const isLiteral = (token) => token[0] === 'word' && /^\$\{[\s\S]*\}$/.test(token[1]);
+
+function literal(start) {
+	if (!isLiteral(start)) {
+		return;
+	}
+
+	const tokens = [];
+	let hasWord;
+	let type;
+	let token;
+
+	while ((token = this.tokenizer.nextToken())) {
+		tokens.push(token);
+		type = token[0];
+
+		if (type.length === 1) {
+			break;
+		} else if (type === 'word') {
+			hasWord = true;
+		}
+	}
+
+	while (tokens.length) {
+		this.tokenizer.back(tokens.pop());
+	}
+
+	if (type === '{' || (type === ':' && !hasWord)) {
+		return;
+	}
+
+	const node = new Literal({
+		text: start[1],
+	});
+
+	this.init(node, start[2], start[3]);
+
+	const input = this.input;
+
+	if (input.templateLiteralStyles) {
+		const offset = input.quasis[0].start;
+		const nodeIndex = getNodeIndex(node, input);
+		const start = offset + nodeIndex;
+		const end = start + node.text.length;
+		const templateLiteralStyles = input.templateLiteralStyles.filter(
+			(style) => style.startIndex <= end && start < style.endIndex,
+		);
+
+		if (templateLiteralStyles.length) {
+			const nodes = parseTemplateLiteralStyles(templateLiteralStyles, input, [
+				nodeIndex,
+				nodeIndex + node.text.length,
+			]);
+
+			if (nodes.length) {
+				node.nodes = nodes;
+				nodes.forEach((n) => (n.parent = node));
+			}
+		}
+	}
+
+	return node;
+}
+
+function freeSemicolon(token) {
+	this.spaces += token[1];
+	const nodes = this.current.nodes;
+	const prev = nodes && nodes[nodes.length - 1];
+
+	if (prev && /^(rule|literal)$/.test(prev.type) && !prev.raws.ownSemicolon) {
+		prev.raws.ownSemicolon = this.spaces;
+		this.spaces = '';
+	}
+}
+
+module.exports = {
+	freeSemicolon,
+	literal,
+};
+
+function parseTemplateLiteralStyles(styles, input, range) {
+	const offset = input.quasis[0].start;
+	const source = input.css;
+
+	const opts = Object.assign({}, input.parseOptions);
+
+	delete opts.templateLiteralStyles;
+	delete opts.expressions;
+	delete opts.quasis;
+
+	const parseStyle = docFixer(offset, source, opts);
+
+	const nodes = [];
+	let index = range[0];
+
+	styles
+		.sort((a, b) => a.startIndex - b.startIndex)
+		.forEach((style) => {
+			const root = parseStyle(style);
+
+			if (!root || !root.nodes.length) {
+				return;
+			}
+
+			root.raws.beforeStart = source.slice(index, style.startIndex - offset);
+			root.raws.afterEnd = '';
+
+			if (style.endIndex) {
+				index = style.endIndex - offset;
+			} else {
+				index = style.startIndex - offset + (style.content || root.source.input.css).length;
+			}
+
+			nodes.push(root);
+		});
+
+	if (nodes.length) {
+		nodes[nodes.length - 1].raws.afterEnd = source.slice(index, range[1]);
+	}
+
+	return nodes;
+}
+
+class LocalFixer {
+	constructor(offset, lines, style, templateParse) {
+		const startIndex = style.startIndex - offset;
+		let line = 0;
+		let column = startIndex;
+
+		lines.some((lineEndIndex, lineNumber) => {
+			if (lineEndIndex >= startIndex) {
+				line = lineNumber--;
+
+				if (lineNumber in lines) {
+					column = startIndex - lines[lineNumber] - 1;
+				}
+
+				return true;
+			}
+		});
+
+		this.line = line;
+		this.column = column;
+		this.style = style;
+		this.templateParse = templateParse;
+	}
+	object(object) {
+		if (object) {
+			if (object.line === 1) {
+				object.column += this.column;
+			}
+
+			object.line += this.line;
+		}
+	}
+	node(node) {
+		this.object(node.source.start);
+		this.object(node.source.end);
+	}
+	root(root) {
+		this.node(root);
+		root.walk((node) => {
+			this.node(node);
+		});
+	}
+	error(error) {
+		if (error && error.name === 'CssSyntaxError') {
+			this.object(error);
+			this.object(error.input);
+			error.message = error.message.replace(
+				/:\d+:\d+:/,
+				':' + error.line + ':' + error.column + ':',
+			);
+		}
+
+		return error;
+	}
+	parse(opts) {
+		const style = this.style;
+		const syntax = style.syntax;
+		let root = style.root;
+
+		try {
+			root = this.templateParse(
+				style.content,
+				Object.assign(
+					{},
+					opts,
+					{
+						map: false,
+					},
+					style.opts,
+				),
+			);
+		} catch (error) {
+			if (style.ignoreErrors) {
+				return;
+			} else if (!style.skipConvert) {
+				this.error(error);
+			}
+
+			throw error;
+		}
+
+		if (!style.skipConvert) {
+			this.root(root);
+		}
+
+		root.source.inline = Boolean(style.inline);
+		root.source.lang = style.lang;
+		root.source.syntax = syntax;
+
+		return root;
+	}
+}
+
+function docFixer(offset, source, opts) {
+	let match;
+	const lines = [];
+
+	reNewLine.lastIndex = 0;
+	while ((match = reNewLine.exec(source))) {
+		lines.push(match.index);
+	}
+	lines.push(source.length);
+
+	return function parseStyle(style) {
+		const parse = style.syntax ? style.syntax.parse : postcssParse;
+
+		return new LocalFixer(offset, lines, style, parse).parse(opts);
+	};
+}
+
+function getNodeIndex(node, input) {
+	const source = input.css;
+	let match;
+	let line = 1;
+	let lastIndex = -1;
+
+	reNewLine.lastIndex = 0;
+	while ((match = reNewLine.exec(source))) {
+		if (line === node.source.start.line) {
+			return lastIndex + node.source.start.column;
+		}
+
+		lastIndex = match.index;
+		line++;
+	}
+
+	if (line === node.source.start.line) {
+		return lastIndex + node.source.start.column;
+	}
+
+	return source.length;
+}

package/templates/facebook/node_modules/@stylelint/postcss-css-in-js/template-parser.js

@@ -0,0 +1,20 @@
+'use strict';
+
+const helper = require('./template-parser-helper');
+const Parser = require('postcss/lib/parser');
+const templateTokenize = require('./template-tokenize');
+
+class TemplateParser extends Parser {
+	createTokenizer() {
+		this.tokenizer = templateTokenize(this.input);
+	}
+	other() {
+		const args = arguments;
+
+		return helper.literal.apply(this, args) || super.other.apply(this, args);
+	}
+	freeSemicolon() {
+		return helper.freeSemicolon.apply(this, arguments);
+	}
+}
+module.exports = TemplateParser;

package/templates/facebook/node_modules/@stylelint/postcss-css-in-js/template-safe-parse.js

@@ -0,0 +1,19 @@
+'use strict';
+
+const Input = require('postcss/lib/input');
+const TemplateSafeParser = require('./template-safe-parser');
+
+function templateSafeParse(css, opts) {
+	const input = new Input(css, opts);
+
+	input.quasis = opts.quasis;
+	input.templateLiteralStyles = opts.templateLiteralStyles;
+	input.parseOptions = opts;
+	const parser = new TemplateSafeParser(input);
+
+	parser.parse();
+
+	return parser.root;
+}
+
+module.exports = templateSafeParse;

package/templates/facebook/node_modules/@stylelint/postcss-css-in-js/template-safe-parser.js

@@ -0,0 +1,21 @@
+'use strict';
+
+const helper = require('./template-parser-helper');
+// eslint-disable-next-line node/no-unpublished-require
+const SafeParser = require('postcss-safe-parser/lib/safe-parser');
+const templateTokenize = require('./template-tokenize');
+
+class TemplateSafeParser extends SafeParser {
+	createTokenizer() {
+		this.tokenizer = templateTokenize(this.input, { ignoreErrors: true });
+	}
+	other() {
+		const args = arguments;
+
+		return helper.literal.apply(this, args) || super.other.apply(this, args);
+	}
+	freeSemicolon() {
+		return helper.freeSemicolon.apply(this, arguments);
+	}
+}
+module.exports = TemplateSafeParser;

package/templates/facebook/node_modules/@stylelint/postcss-css-in-js/template-stringifier.js

@@ -0,0 +1,23 @@
+'use strict';
+
+const Stringifier = require('postcss/lib/stringifier');
+
+class TemplateStringifier extends Stringifier {
+	literal(node) {
+		if (node.nodes && node.nodes.length) {
+			node.nodes.forEach((root) => {
+				this.builder(root.raws.beforeStart, root, 'beforeStart');
+				this.stringify(root);
+				this.builder(root.raws.afterEnd, root, 'afterEnd');
+			});
+		} else {
+			this.builder(node.text, node);
+		}
+
+		if (node.raws.ownSemicolon) {
+			this.builder(node.raws.ownSemicolon, node, 'end');
+		}
+	}
+}
+
+module.exports = TemplateStringifier;

package/templates/facebook/node_modules/@stylelint/postcss-css-in-js/template-stringify.js

@@ -0,0 +1,9 @@
+'use strict';
+
+const TemplateStringifier = require('./template-stringifier');
+
+module.exports = function TemplateStringify(node, builder) {
+	const str = new TemplateStringifier(builder);
+
+	str.stringify(node);
+};

package/templates/facebook/node_modules/@stylelint/postcss-css-in-js/template-tokenize.js

@@ -0,0 +1,67 @@
+'use strict';
+
+const tokenize = require('postcss/lib/tokenize');
+
+function templateTokenize(input) {
+	let pos = input.quasis[0].start;
+	const quasis = input.quasis.filter((quasi) => quasi.start !== quasi.end);
+	const tokenizer = tokenize.apply(this, arguments);
+
+	function tokenInExpressions(token, returned) {
+		const start = pos;
+
+		pos += token[1].length;
+
+		if (
+			!quasis.some((quasi) => start >= quasi.start && pos <= quasi.end) ||
+			(returned.length && token[0] === returned[0][0])
+		) {
+			return true;
+		} else if (returned.length) {
+			back(token);
+		}
+	}
+
+	function back(token) {
+		pos -= token[1].length;
+
+		return tokenizer.back.apply(tokenizer, arguments);
+	}
+
+	function nextToken() {
+		const args = arguments;
+		const returned = [];
+		let token;
+		let line;
+		let column;
+
+		while (
+			(token = tokenizer.nextToken.apply(tokenizer, args)) &&
+			tokenInExpressions(token, returned)
+		) {
+			line = token[4] || token[2] || line;
+			column = token[5] || token[3] || column;
+			returned.push(token);
+		}
+
+		if (returned.length) {
+			token = [
+				returned[0][0],
+				returned.map((token) => token[1]).join(''),
+				returned[0][2],
+				returned[0][3],
+				line,
+				column,
+			];
+		}
+
+		return token;
+	}
+
+	return Object.assign({}, tokenizer, {
+		back,
+		nextToken,
+	});
+}
+
+module.exports = templateTokenize;

package/templates/facebook/node_modules/@stylelint/postcss-css-in-js/un-camel-case.js

@@ -0,0 +1,13 @@
+'use strict';
+
+function unCamelCase(str) {
+	return str.replace(/[\w-]+/g, (s) =>
+		/^[A-Z]?[a-z]*(?:[A-Z][a-z]*)+$/.test(s)
+			? s
+					.replace(/[A-Z]/g, (s) => '-' + s.toLowerCase())
+					.replace(/^(o|ms|moz|khtml|epub|(\w+-?)*webkit)(?=-)/i, '-$1')
+			: s,
+	);
+}
+
+module.exports = unCamelCase;

package/templates/facebook/node_modules/@stylelint/postcss-markdown/CHANGELOG.md

@@ -0,0 +1,13 @@
+# Changelog
+
+## 0.36.2
+
+- Fixed: outdated remark dependencies
+
+## 0.36.1
+
+- Fixed: outdated dependencies
+
+## Previous changes
+
+See [postcss-markdown releases](https://github.com/gucong3000/postcss-markdown).

package/templates/facebook/node_modules/@stylelint/postcss-markdown/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 刘祺
+
+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.

package/templates/facebook/node_modules/@stylelint/postcss-markdown/README.md

@@ -0,0 +1,92 @@
+# PostCSS Markdown Syntax
+
+[![NPM version](https://img.shields.io/npm/v/@stylelint/postcss-markdown.svg)](https://www.npmjs.org/package/@stylelint/postcss-markdown) [![Build Status](https://github.com/stylelint/postcss-markdown/workflows/CI/badge.svg)](https://github.com/stylelint/postcss-markdown/actions)
+
+<img align="right" width="95" height="95"
+	title="Philosopher’s stone, logo of PostCSS"
+	src="http://postcss.github.io/postcss/logo.svg">
+
+[PostCSS](https://github.com/postcss/postcss) Syntax for parsing [Markdown](https://daringfireball.net/projects/markdown/syntax)
+
+## Getting Started
+
+First thing's first, install the module:
+
+```
+npm install postcss-syntax postcss-markdown --save-dev
+```
+
+If you want support SCSS/SASS/LESS/SugarSS syntax, you need to install the corresponding module.
+
+- SCSS: [postcss-scss](https://github.com/postcss/postcss-scss)
+- SASS: [postcss-sass](https://github.com/aleshaoleg/postcss-sass)
+- LESS: [postcss-less](https://github.com/shellscape/postcss-less)
+- SugarSS: [sugarss](https://github.com/postcss/sugarss)
+
+## Use Cases
+
+```js
+var syntax = require("postcss-syntax")({
+  // Enable support for HTML (default: true) See: https://github.com/gucong3000/postcss-html
+  htmlInMd: true,
+  // syntax for parse scss (non-required options)
+  scss: require("postcss-scss"),
+  // syntax for parse less (non-required options)
+  less: require("postcss-less"),
+  // syntax for parse css blocks (non-required options)
+  css: require("postcss-safe-parser")
+});
+var autoprefixer = require("autoprefixer");
+postcss([autoprefixer])
+  .process(source, { syntax: syntax })
+  .then(function(result) {
+    // An alias for the result.css property. Use it with syntaxes that generate non-CSS output.
+    result.content;
+  });
+```
+
+input:
+
+<pre><code># title
+
+```css
+::placeholder {
+	color: gray;
+}
+```
+</code></pre>
+
+output:
+
+<pre><code># title
+
+```css
+::-webkit-input-placeholder {
+	color: gray;
+}
+:-ms-input-placeholder {
+	color: gray;
+}
+::-ms-input-placeholder {
+	color: gray;
+}
+::placeholder {
+	color: gray;
+}
+```
+</code></pre>
+
+If you want support SCSS/SASS/LESS/SugarSS syntax, you need to install these module:
+
+- SCSS: [postcss-scss](https://github.com/postcss/postcss-scss)
+- SASS: [postcss-sass](https://github.com/aleshaoleg/postcss-sass)
+- LESS: [postcss-less](https://github.com/shellscape/postcss-less)
+- SugarSS: [sugarss](https://github.com/postcss/sugarss)
+
+## Advanced Use Cases
+
+See: [postcss-syntax](https://github.com/gucong3000/postcss-syntax)
+
+## Style Transformations
+
+The main use case of this plugin is apply PostCSS transformations to CSS (and CSS-like) code blocks in markdown file.

package/templates/facebook/node_modules/@stylelint/postcss-markdown/extract.js

@@ -0,0 +1,42 @@
+"use strict";
+
+const remark = require("remark");
+const findAllAfter = require("unist-util-find-all-after");
+
+function mdParser (source, opts, result) {
+	const htmlInMd = opts.syntax.config.htmlInMd;
+	if (!result && (htmlInMd == null || htmlInMd)) {
+		result = require("postcss-html/extract")(source, opts, []);
+	}
+	const ast = remark().parse(source);
+	const blocks = findAllAfter(ast, 0, (node) => (
+		node.type === "code"
+	)).map((block) => {
+		if (result && (!block.lang || !/^(?:[sx]?html?|[sx]ht)$/i.test(block.lang))) {
+			result = result.filter(styleHtm => {
+				return styleHtm.startIndex >= block.position.end.offset ||
+					styleHtm.startIndex + styleHtm.content.length <= block.position.start.offset;
+			});
+		}
+		if (block.lang && /^(?:(?:\w*c)|le|wx|sa?|sugar)ss$/i.test(block.lang)) {
+			let startIndex = source.indexOf(block.lang, block.position.start.offset) + block.lang.length;
+			if (block.value) {
+				startIndex = source.indexOf(block.value, startIndex);
+			} else {
+				startIndex = source.indexOf("\n", startIndex) + 1;
+			}
+			return {
+				startIndex: startIndex,
+				lang: block.lang.toLowerCase(),
+				isMarkdown: true,
+				content: source.slice(startIndex, block.position.end.offset).replace(/[ \t]*`*$/, ""),
+			};
+		}
+	}).filter(Boolean);
+	if (result) {
+		return result.concat(blocks);
+	} else {
+		return blocks;
+	}
+};
+module.exports = mdParser;

package/templates/facebook/node_modules/@stylelint/postcss-markdown/index.js

@@ -0,0 +1,5 @@
+"use strict";
+const extract = require("./extract");
+const syntax = require("postcss-syntax/syntax")(extract, "markdown");
+
+module.exports = syntax;

package/templates/facebook/node_modules/@stylelint/postcss-markdown/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@stylelint/postcss-markdown",
+  "version": "0.36.2",
+  "description": "PostCSS syntax for parsing Markdown",
+  "repository": "stylelint/postcss-markdown",
+  "keywords": [
+    "postcss",
+    "syntax",
+    "markdown",
+    "html",
+    "css",
+    "less",
+    "sass",
+    "scss",
+    "sss",
+    "sugarss"
+  ],
+  "main": "index.js",
+  "files": [
+    "*.js"
+  ],
+  "author": "gucong",
+  "license": "MIT",
+  "nyc": {
+    "reporter": [
+      "lcov",
+      "text"
+    ],
+    "all": true,
+    "cache": true,
+    "check-coverage": true
+  },
+  "scripts": {
+    "mocha": "mocha --no-timeouts",
+    "test": "nyc npm run mocha",
+    "debug": "npm run mocha -- --inspect-brk",
+    "release": "np"
+  },
+  "dependencies": {
+    "remark": "^13.0.0",
+    "unist-util-find-all-after": "^3.0.2"
+  },
+  "peerDependencies": {
+    "postcss": ">=7.0.0",
+    "postcss-syntax": ">=0.36.2"
+  },
+  "devDependencies": {
+    "chai": "^4.2.0",
+    "codecov": "^3.8.1",
+    "mocha": "^8.2.1",
+    "np": "^7.0.0",
+    "nyc": "^15.1.0",
+    "postcss": ">=7.0.27",
+    "postcss-html": ">=0.36.0",
+    "postcss-less": "^3.1.4",
+    "postcss-scss": "^2.0.0",
+    "postcss-syntax": ">=0.36.2",
+    "sugarss": "^2.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}