@remotion/bundler 4.0.438 → 4.0.440

package/css-loader/CssSyntaxError.js

@@ -0,0 +1,31 @@
+/**
+ * Forked from css-loader v5.2.7
+ * MIT License http://www.opensource.org/licenses/mit-license.php
+ */
+"use strict";
+
+class CssSyntaxError extends Error {
+	constructor(error) {
+		super(error);
+		const {reason, line, column, file} = error;
+		this.name = "CssSyntaxError";
+
+		this.message = `${this.name}\n\n`;
+
+		if (typeof line !== "undefined") {
+			this.message += `(${line}:${column}) `;
+		}
+
+		this.message += file ? `${file} ` : "<css input> ";
+		this.message += `${reason}`;
+		const code = error.showSourceCode();
+
+		if (code) {
+			this.message += `\n\n${code}\n`;
+		}
+
+		this.stack = false;
+	}
+}
+
+module.exports = CssSyntaxError;

package/css-loader/Warning.js

@@ -0,0 +1,25 @@
+/**
+ * Forked from css-loader v5.2.7
+ * MIT License http://www.opensource.org/licenses/mit-license.php
+ */
+"use strict";
+
+class Warning extends Error {
+	constructor(warning) {
+		super(warning);
+		const {text, line, column} = warning;
+		this.name = "Warning";
+
+		this.message = `${this.name}\n\n`;
+
+		if (typeof line !== "undefined") {
+			this.message += `(${line}:${column}) `;
+		}
+
+		this.message += `${text}`;
+
+		this.stack = false;
+	}
+}
+
+module.exports = Warning;

package/css-loader/index.js

@@ -0,0 +1,158 @@
+/**
+ * Forked from css-loader v5.2.7
+ * MIT License http://www.opensource.org/licenses/mit-license.php
+ * Author Tobias Koppers @sokra
+ *
+ * Simplified for Remotion's use case:
+ * - No CSS Modules support
+ * - No ICSS support
+ * - No schema-utils validation (we control the options)
+ * - No semver postcss version check
+ * - Hardcoded default options (url: true, import: true, esModule: true)
+ */
+'use strict';
+
+const {getOptions, stringifyRequest} = require('loader-utils');
+const postcss = require('postcss');
+const CssSyntaxError = require('./CssSyntaxError');
+const Warning = require('./Warning');
+const {importParser, urlParser} = require('./plugins');
+const {
+	normalizeUrl,
+	requestify,
+	getFilter,
+	getPreRequester,
+	getImportCode,
+	getModuleCode,
+	getExportCode,
+	resolveRequests,
+	isUrlRequestable,
+	normalizeSourceMap,
+	sort,
+	combineRequests,
+	WEBPACK_IGNORE_COMMENT_REGEXP,
+} = require('./utils');
+
+async function loader(content, map, meta) {
+	const callback = this.async();
+
+	const sourceMap = this.sourceMap || false;
+	const esModule = true;
+
+	const replacements = [];
+
+	// Import plugin
+	const importPluginImports = [];
+	const importPluginApi = [];
+
+	const importResolver = this.getResolve({
+		conditionNames: ['style'],
+		extensions: ['.css'],
+		mainFields: ['css', 'style', 'main', '...'],
+		mainFiles: ['index', '...'],
+	});
+
+	const plugins = [
+		importParser({
+			imports: importPluginImports,
+			api: importPluginApi,
+			context: this.context,
+			rootContext: this.rootContext,
+			filter: getFilter(true, this.resourcePath),
+			resolver: importResolver,
+			urlHandler: (url) =>
+				stringifyRequest(
+					this,
+					combineRequests(getPreRequester(this)(undefined), url),
+				),
+		}),
+	];
+
+	// URL plugin
+	const urlPluginImports = [];
+
+	const urlResolver = this.getResolve({
+		conditionNames: ['asset'],
+		mainFields: ['asset'],
+		mainFiles: [],
+		extensions: [],
+	});
+
+	plugins.push(
+		urlParser({
+			imports: urlPluginImports,
+			replacements,
+			context: this.context,
+			rootContext: this.rootContext,
+			filter: getFilter(true, this.resourcePath),
+			resolver: urlResolver,
+			urlHandler: (url) => stringifyRequest(this, url),
+		}),
+	);
+
+	const {resourcePath} = this;
+	let result;
+
+	try {
+		result = await postcss(plugins).process(content, {
+			hideNothingWarning: true,
+			from: resourcePath,
+			to: resourcePath,
+			map: sourceMap
+				? {
+						prev: map ? normalizeSourceMap(map, resourcePath) : null,
+						inline: false,
+						annotation: false,
+					}
+				: false,
+		});
+	} catch (error) {
+		if (error.file) {
+			this.addDependency(error.file);
+		}
+
+		callback(
+			error.name === 'CssSyntaxError' ? new CssSyntaxError(error) : error,
+		);
+		return;
+	}
+
+	for (const warning of result.warnings()) {
+		this.emitWarning(new Warning(warning));
+	}
+
+	const imports = []
+		.concat(importPluginImports.sort(sort))
+		.concat(urlPluginImports.sort(sort));
+	const api = [].concat(importPluginApi.sort(sort));
+
+	imports.unshift({
+		importName: '___CSS_LOADER_API_IMPORT___',
+		url: stringifyRequest(this, require.resolve('./runtime/api')),
+	});
+
+	if (sourceMap) {
+		imports.unshift({
+			importName: '___CSS_LOADER_API_SOURCEMAP_IMPORT___',
+			url: stringifyRequest(
+				this,
+				require.resolve('./runtime/cssWithMappingToString'),
+			),
+		});
+	}
+
+	const options = {
+		sourceMap,
+		esModule,
+		modules: false,
+	};
+
+	const importCode = getImportCode(imports, options);
+	const moduleCode = getModuleCode(result, api, replacements, options, this);
+	const exportCode = getExportCode([], replacements, false, options);
+
+	callback(null, `${importCode}${moduleCode}${exportCode}`);
+}
+
+module.exports = loader;
+module.exports.default = loader;

package/css-loader/plugins/index.js

@@ -0,0 +1,13 @@
+/**
+ * Forked from css-loader v5.2.7
+ * MIT License http://www.opensource.org/licenses/mit-license.php
+ *
+ * Removed ICSS parser (not used in Remotion).
+ */
+"use strict";
+
+const importParser = require("./postcss-import-parser");
+const urlParser = require("./postcss-url-parser");
+
+exports.importParser = importParser;
+exports.urlParser = urlParser;

package/css-loader/plugins/postcss-import-parser.js

@@ -0,0 +1,258 @@
+/**
+ * Forked from css-loader v5.2.7
+ * MIT License http://www.opensource.org/licenses/mit-license.php
+ */
+"use strict";
+
+const valueParser = require("postcss-value-parser");
+const {
+	normalizeUrl,
+	isUrlRequestable,
+	requestify,
+	resolveRequests,
+	WEBPACK_IGNORE_COMMENT_REGEXP,
+} = require("../utils");
+
+function parseNode(atRule, key) {
+	// Convert only top-level @import
+	if (atRule.parent.type !== "root") {
+		return;
+	}
+
+	if (
+		atRule.raws &&
+		atRule.raws.afterName &&
+		atRule.raws.afterName.trim().length > 0
+	) {
+		const lastCommentIndex = atRule.raws.afterName.lastIndexOf("/*");
+		const matched = atRule.raws.afterName
+			.slice(lastCommentIndex)
+			.match(WEBPACK_IGNORE_COMMENT_REGEXP);
+
+		if (matched && matched[2] === "true") {
+			return;
+		}
+	}
+
+	const prevNode = atRule.prev();
+
+	if (prevNode && prevNode.type === "comment") {
+		const matched = prevNode.text.match(WEBPACK_IGNORE_COMMENT_REGEXP);
+
+		if (matched && matched[2] === "true") {
+			return;
+		}
+	}
+
+	if (atRule.nodes) {
+		const error = new Error(
+			"It looks like you didn't end your @import statement correctly. Child nodes are attached to it.",
+		);
+		error.node = atRule;
+		throw error;
+	}
+
+	const {nodes: paramsNodes} = valueParser(atRule[key]);
+
+	if (
+		paramsNodes.length === 0 ||
+		(paramsNodes[0].type !== "string" && paramsNodes[0].type !== "function")
+	) {
+		const error = new Error(
+			`Unable to find uri in "${atRule.toString()}"`,
+		);
+		error.node = atRule;
+		throw error;
+	}
+
+	let isStringValue;
+	let url;
+
+	if (paramsNodes[0].type === "string") {
+		isStringValue = true;
+		url = paramsNodes[0].value;
+	} else {
+		if (paramsNodes[0].value.toLowerCase() !== "url") {
+			const error = new Error(
+				`Unable to find uri in "${atRule.toString()}"`,
+			);
+			error.node = atRule;
+			throw error;
+		}
+
+		isStringValue =
+			paramsNodes[0].nodes.length !== 0 &&
+			paramsNodes[0].nodes[0].type === "string";
+		url = isStringValue
+			? paramsNodes[0].nodes[0].value
+			: valueParser.stringify(paramsNodes[0].nodes);
+	}
+
+	url = normalizeUrl(url, isStringValue);
+	const isRequestable = isUrlRequestable(url);
+	let prefix;
+
+	if (isRequestable) {
+		const queryParts = url.split("!");
+
+		if (queryParts.length > 1) {
+			url = queryParts.pop();
+			prefix = queryParts.join("!");
+		}
+	}
+
+	if (url.trim().length === 0) {
+		const error = new Error(
+			`Unable to find uri in "${atRule.toString()}"`,
+		);
+		error.node = atRule;
+		throw error;
+	}
+
+	const mediaNodes = paramsNodes.slice(1);
+	let media;
+
+	if (mediaNodes.length > 0) {
+		media = valueParser.stringify(mediaNodes).trim().toLowerCase();
+	}
+
+	return {
+		atRule,
+		prefix,
+		url,
+		media,
+		isRequestable,
+	};
+}
+
+const plugin = (options = {}) => {
+	return {
+		postcssPlugin: "postcss-import-parser",
+
+		prepare(result) {
+			const parsedAtRules = [];
+			return {
+				AtRule: {
+					import(atRule) {
+						let parsedAtRule;
+
+						try {
+							parsedAtRule = parseNode(atRule, "params", result);
+						} catch (error) {
+							result.warn(error.message, {
+								node: error.node,
+							});
+						}
+
+						if (!parsedAtRule) {
+							return;
+						}
+
+						parsedAtRules.push(parsedAtRule);
+					},
+				},
+
+				async OnceExit() {
+					if (parsedAtRules.length === 0) {
+						return;
+					}
+
+					const resolvedAtRules = await Promise.all(
+						parsedAtRules.map(async (parsedAtRule) => {
+							const {atRule, isRequestable, prefix, url, media} =
+								parsedAtRule;
+
+							if (options.filter) {
+								const needKeep = await options.filter(url, media);
+
+								if (!needKeep) {
+									return;
+								}
+							}
+
+							if (isRequestable) {
+								const request = requestify(url, options.rootContext);
+								const {resolver, context} = options;
+								const resolvedUrl = await resolveRequests(
+									resolver,
+									context,
+									[...new Set([request, url])],
+								);
+
+								if (!resolvedUrl) {
+									return;
+								}
+
+								atRule.remove();
+
+								return {
+									url: resolvedUrl,
+									media,
+									prefix,
+									isRequestable,
+								};
+							}
+
+							atRule.remove();
+
+							return {
+								url,
+								media,
+								prefix,
+								isRequestable,
+							};
+						}),
+					);
+					const urlToNameMap = new Map();
+
+					for (
+						let index = 0;
+						index <= resolvedAtRules.length - 1;
+						index++
+					) {
+						const resolvedAtRule = resolvedAtRules[index];
+
+						if (!resolvedAtRule) {
+							continue;
+						}
+
+						const {url, isRequestable, media} = resolvedAtRule;
+
+						if (!isRequestable) {
+							options.api.push({
+								url,
+								media,
+								index,
+							});
+
+							continue;
+						}
+
+						const {prefix} = resolvedAtRule;
+						const newUrl = prefix ? `${prefix}!${url}` : url;
+						let importName = urlToNameMap.get(newUrl);
+
+						if (!importName) {
+							importName = `___CSS_LOADER_AT_RULE_IMPORT_${urlToNameMap.size}___`;
+							urlToNameMap.set(newUrl, importName);
+							options.imports.push({
+								importName,
+								url: options.urlHandler(newUrl),
+								index,
+							});
+						}
+
+						options.api.push({
+							importName,
+							media,
+							index,
+						});
+					}
+				},
+			};
+		},
+	};
+};
+
+plugin.postcss = true;
+module.exports = plugin;