index.browser.mjs
No OneTemporary
Actions

Subscribers

None

File Metadata

Created: Sat, Dec 14, 02:05

index.browser.mjs
View Options

	import { declare } from '@babel/helper-plugin-utils';
	import _getTargets, { prettifyTargets, getInclusionReasons, isRequired } from '@babel/helper-compilation-targets';
	import * as _babel from '@babel/core';

	const {
	types: t$1,
	template: template
	} = _babel.default \|\| _babel;
	function intersection(a, b) {
	const result = new Set();
	a.forEach(v => b.has(v) && result.add(v));
	return result;
	}
	function has$1(object, key) {
	return Object.prototype.hasOwnProperty.call(object, key);
	}

	function getType(target) {
	return Object.prototype.toString.call(target).slice(8, -1);
	}

	function resolveId(path) {
	if (path.isIdentifier() && !path.scope.hasBinding(path.node.name,
	/* noGlobals */
	true)) {
	return path.node.name;
	}

	const {
	deopt
	} = path.evaluate();

	if (deopt && deopt.isIdentifier()) {
	return deopt.node.name;
	}
	}

	function resolveKey(path, computed = false) {
	const {
	scope
	} = path;
	if (path.isStringLiteral()) return path.node.value;
	const isIdentifier = path.isIdentifier();

	if (isIdentifier && !(computed \|\| path.parent.computed)) {
	return path.node.name;
	}

	if (computed && path.isMemberExpression() && path.get("object").isIdentifier({
	name: "Symbol"
	}) && !scope.hasBinding("Symbol",
	/* noGlobals */
	true)) {
	const sym = resolveKey(path.get("property"), path.node.computed);
	if (sym) return "Symbol." + sym;
	}

	if (!isIdentifier \|\| scope.hasBinding(path.node.name,
	/* noGlobals */
	true)) {
	const {
	value
	} = path.evaluate();
	if (typeof value === "string") return value;
	}
	}
	function resolveSource(obj) {
	if (obj.isMemberExpression() && obj.get("property").isIdentifier({
	name: "prototype"
	})) {
	const id = resolveId(obj.get("object"));

	if (id) {
	return {
	id,
	placement: "prototype"
	};
	}

	return {
	id: null,
	placement: null
	};
	}

	const id = resolveId(obj);

	if (id) {
	return {
	id,
	placement: "static"
	};
	}

	const {
	value
	} = obj.evaluate();

	if (value !== undefined) {
	return {
	id: getType(value),
	placement: "prototype"
	};
	} else if (obj.isRegExpLiteral()) {
	return {
	id: "RegExp",
	placement: "prototype"
	};
	} else if (obj.isFunction()) {
	return {
	id: "Function",
	placement: "prototype"
	};
	}

	return {
	id: null,
	placement: null
	};
	}
	function getImportSource({
	node
	}) {
	if (node.specifiers.length === 0) return node.source.value;
	}
	function getRequireSource({
	node
	}) {
	if (!t$1.isExpressionStatement(node)) return;
	const {
	expression
	} = node;

	if (t$1.isCallExpression(expression) && t$1.isIdentifier(expression.callee) && expression.callee.name === "require" && expression.arguments.length === 1 && t$1.isStringLiteral(expression.arguments[0])) {
	return expression.arguments[0].value;
	}
	}

	function hoist(node) {
	// @ts-expect-error
	node._blockHoist = 3;
	return node;
	}

	function createUtilsGetter(cache) {
	return path => {
	const prog = path.findParent(p => p.isProgram());
	return {
	injectGlobalImport(url) {
	cache.storeAnonymous(prog, url, (isScript, source) => {
	return isScript ? template.statement.ast`require(${source})` : t$1.importDeclaration([], source);
	});
	},

	injectNamedImport(url, name, hint = name) {
	return cache.storeNamed(prog, url, name, (isScript, source, name) => {
	const id = prog.scope.generateUidIdentifier(hint);
	return {
	node: isScript ? hoist(template.statement.ast`
	var ${id} = require(${source}).${name}
	`) : t$1.importDeclaration([t$1.importSpecifier(id, name)], source),
	name: id.name
	};
	});
	},

	injectDefaultImport(url, hint = url) {
	return cache.storeNamed(prog, url, "default", (isScript, source) => {
	const id = prog.scope.generateUidIdentifier(hint);
	return {
	node: isScript ? hoist(template.statement.ast`var ${id} = require(${source})`) : t$1.importDeclaration([t$1.importDefaultSpecifier(id)], source),
	name: id.name
	};
	});
	}

	};
	};
	}

	const {
	types: t
	} = _babel.default \|\| _babel;
	class ImportsCache {
	constructor(resolver) {
	this._imports = new WeakMap();
	this._anonymousImports = new WeakMap();
	this._lastImports = new WeakMap();
	this._resolver = resolver;
	}

	storeAnonymous(programPath, url, // eslint-disable-next-line no-undef
	getVal) {
	const key = this._normalizeKey(programPath, url);

	const imports = this._ensure(this._anonymousImports, programPath, Set);

	if (imports.has(key)) return;
	const node = getVal(programPath.node.sourceType === "script", t.stringLiteral(this._resolver(url)));
	imports.add(key);

	this._injectImport(programPath, node);
	}

	storeNamed(programPath, url, name, getVal) {
	const key = this._normalizeKey(programPath, url, name);

	const imports = this._ensure(this._imports, programPath, Map);

	if (!imports.has(key)) {
	const {
	node,
	name: id
	} = getVal(programPath.node.sourceType === "script", t.stringLiteral(this._resolver(url)), t.identifier(name));
	imports.set(key, id);

	this._injectImport(programPath, node);
	}

	return t.identifier(imports.get(key));
	}

	_injectImport(programPath, node) {
	const lastImport = this._lastImports.get(programPath);

	let newNodes;

	if (lastImport && lastImport.node && // Sometimes the AST is modified and the "last import"
	// we have has been replaced
	lastImport.parent === programPath.node && lastImport.container === programPath.node.body) {
	newNodes = lastImport.insertAfter(node);
	} else {
	newNodes = programPath.unshiftContainer("body", node);
	}

	const newNode = newNodes[newNodes.length - 1];

	this._lastImports.set(programPath, newNode);
	/*
	let lastImport;
	programPath.get("body").forEach(path => {
	if (path.isImportDeclaration()) lastImport = path;
	if (
	path.isExpressionStatement() &&
	isRequireCall(path.get("expression"))
	) {
	lastImport = path;
	}
	if (
	path.isVariableDeclaration() &&
	path.get("declarations").length === 1 &&
	(isRequireCall(path.get("declarations.0.init")) \|\|
	(path.get("declarations.0.init").isMemberExpression() &&
	isRequireCall(path.get("declarations.0.init.object"))))
	) {
	lastImport = path;
	}
	});*/

	}

	_ensure(map, programPath, Collection) {
	let collection = map.get(programPath);

	if (!collection) {
	collection = new Collection();
	map.set(programPath, collection);
	}

	return collection;
	}

	_normalizeKey(programPath, url, name = "") {
	const {
	sourceType
	} = programPath.node; // If we rely on the imported binding (the "name" parameter), we also need to cache
	// based on the sourceType. This is because the module transforms change the names
	// of the import variables.

	return `${name && sourceType}::${url}::${name}`;
	}

	}

	const presetEnvSilentDebugHeader = "#__secret_key__@babel/preset-env__don't_log_debug_header_and_resolved_targets";
	function stringifyTargetsMultiline(targets) {
	return JSON.stringify(prettifyTargets(targets), null, 2);
	}

	function patternToRegExp(pattern) {
	if (pattern instanceof RegExp) return pattern;

	try {
	return new RegExp(`^${pattern}$`);
	} catch {
	return null;
	}
	}

	function buildUnusedError(label, unused) {
	if (!unused.length) return "";
	return ` - The following "${label}" patterns didn't match any polyfill:\n` + unused.map(original => ` ${String(original)}\n`).join("");
	}

	function buldDuplicatesError(duplicates) {
	if (!duplicates.size) return "";
	return ` - The following polyfills were matched both by "include" and "exclude" patterns:\n` + Array.from(duplicates, name => ` ${name}\n`).join("");
	}

	function validateIncludeExclude(provider, polyfills, includePatterns, excludePatterns) {
	let current;

	const filter = pattern => {
	const regexp = patternToRegExp(pattern);
	if (!regexp) return false;
	let matched = false;

	for (const polyfill of polyfills) {
	if (regexp.test(polyfill)) {
	matched = true;
	current.add(polyfill);
	}
	}

	return !matched;
	}; // prettier-ignore


	const include = current = new Set();
	const unusedInclude = Array.from(includePatterns).filter(filter); // prettier-ignore

	const exclude = current = new Set();
	const unusedExclude = Array.from(excludePatterns).filter(filter);
	const duplicates = intersection(include, exclude);

	if (duplicates.size > 0 \|\| unusedInclude.length > 0 \|\| unusedExclude.length > 0) {
	throw new Error(`Error while validating the "${provider}" provider options:\n` + buildUnusedError("include", unusedInclude) + buildUnusedError("exclude", unusedExclude) + buldDuplicatesError(duplicates));
	}

	return {
	include,
	exclude
	};
	}
	function applyMissingDependenciesDefaults(options, babelApi) {
	const {
	missingDependencies = {}
	} = options;
	if (missingDependencies === false) return false;
	const caller = babelApi.caller(caller => caller == null ? void 0 : caller.name);
	const {
	log = "deferred",
	inject = caller === "rollup-plugin-babel" ? "throw" : "import",
	all = false
	} = missingDependencies;
	return {
	log,
	inject,
	all
	};
	}

	var usage = (callProvider => {
	function property(object, key, placement, path) {
	return callProvider({
	kind: "property",
	object,
	key,
	placement
	}, path);
	}

	return {
	// Symbol(), new Promise
	ReferencedIdentifier(path) {
	const {
	node: {
	name
	},
	scope
	} = path;
	if (scope.getBindingIdentifier(name)) return;
	callProvider({
	kind: "global",
	name
	}, path);
	},

	MemberExpression(path) {
	const key = resolveKey(path.get("property"), path.node.computed);
	if (!key \|\| key === "prototype") return;
	const object = path.get("object");

	if (object.isIdentifier()) {
	const binding = object.scope.getBinding(object.node.name);
	if (binding && binding.path.isImportNamespaceSpecifier()) return;
	}

	const source = resolveSource(object);
	return property(source.id, key, source.placement, path);
	},

	ObjectPattern(path) {
	const {
	parentPath,
	parent
	} = path;
	let obj; // const { keys, values } = Object

	if (parentPath.isVariableDeclarator()) {
	obj = parentPath.get("init"); // ({ keys, values } = Object)
	} else if (parentPath.isAssignmentExpression()) {
	obj = parentPath.get("right"); // !function ({ keys, values }) {...} (Object)
	// resolution does not work after properties transform :-(
	} else if (parentPath.isFunction()) {
	const grand = parentPath.parentPath;

	if (grand.isCallExpression() \|\| grand.isNewExpression()) {
	if (grand.node.callee === parent) {
	obj = grand.get("arguments")[path.key];
	}
	}
	}

	let id = null;
	let placement = null;
	if (obj) ({
	id,
	placement
	} = resolveSource(obj));

	for (const prop of path.get("properties")) {
	if (prop.isObjectProperty()) {
	const key = resolveKey(prop.get("key"));
	if (key) property(id, key, placement, prop);
	}
	}
	},

	BinaryExpression(path) {
	if (path.node.operator !== "in") return;
	const source = resolveSource(path.get("right"));
	const key = resolveKey(path.get("left"), true);
	if (!key) return;
	callProvider({
	kind: "in",
	object: source.id,
	key,
	placement: source.placement
	}, path);
	}

	};
	});

	var entry = (callProvider => ({
	ImportDeclaration(path) {
	const source = getImportSource(path);
	if (!source) return;
	callProvider({
	kind: "import",
	source
	}, path);
	},

	Program(path) {
	path.get("body").forEach(bodyPath => {
	const source = getRequireSource(bodyPath);
	if (!source) return;
	callProvider({
	kind: "import",
	source
	}, bodyPath);
	});
	}

	}));

	function resolve(dirname, moduleName, absoluteImports) {
	if (absoluteImports === false) return moduleName;
	throw new Error(`"absoluteImports" is not supported in bundles prepared for the browser.`);
	} // eslint-disable-next-line @typescript-eslint/no-unused-vars

	function has(basedir, name) {
	return true;
	} // eslint-disable-next-line @typescript-eslint/no-unused-vars

	function logMissing(missingDeps) {} // eslint-disable-next-line @typescript-eslint/no-unused-vars

	function laterLogMissing(missingDeps) {}

	const PossibleGlobalObjects = new Set(["global", "globalThis", "self", "window"]);
	function createMetaResolver(polyfills) {
	const {
	static: staticP,
	instance: instanceP,
	global: globalP
	} = polyfills;
	return meta => {
	if (meta.kind === "global" && globalP && has$1(globalP, meta.name)) {
	return {
	kind: "global",
	desc: globalP[meta.name],
	name: meta.name
	};
	}

	if (meta.kind === "property" \|\| meta.kind === "in") {
	const {
	placement,
	object,
	key
	} = meta;

	if (object && placement === "static") {
	if (globalP && PossibleGlobalObjects.has(object) && has$1(globalP, key)) {
	return {
	kind: "global",
	desc: globalP[key],
	name: key
	};
	}

	if (staticP && has$1(staticP, object) && has$1(staticP[object], key)) {
	return {
	kind: "static",
	desc: staticP[object][key],
	name: `${object}$${key}`
	};
	}
	}

	if (instanceP && has$1(instanceP, key)) {
	return {
	kind: "instance",
	desc: instanceP[key],
	name: `${key}`
	};
	}
	}
	};
	}

	const getTargets = _getTargets.default \|\| _getTargets;

	function resolveOptions(options, babelApi) {
	const {
	method,
	targets: targetsOption,
	ignoreBrowserslistConfig,
	configPath,
	debug,
	shouldInjectPolyfill,
	absoluteImports,
	...providerOptions
	} = options;

	if (isEmpty(options)) {
	throw new Error(`\
	This plugin requires options, for example:
	{
	"plugins": [
	["<plugin name>", { method: "usage-pure" }]
	]
	}

	See more options at https://github.com/babel/babel-polyfills/blob/main/docs/usage.md`);
	}

	let methodName;
	if (method === "usage-global") methodName = "usageGlobal";else if (method === "entry-global") methodName = "entryGlobal";else if (method === "usage-pure") methodName = "usagePure";else if (typeof method !== "string") {
	throw new Error(".method must be a string");
	} else {
	throw new Error(`.method must be one of "entry-global", "usage-global"` + ` or "usage-pure" (received ${JSON.stringify(method)})`);
	}

	if (typeof shouldInjectPolyfill === "function") {
	if (options.include \|\| options.exclude) {
	throw new Error(`.include and .exclude are not supported when using the` + ` .shouldInjectPolyfill function.`);
	}
	} else if (shouldInjectPolyfill != null) {
	throw new Error(`.shouldInjectPolyfill must be a function, or undefined` + ` (received ${JSON.stringify(shouldInjectPolyfill)})`);
	}

	if (absoluteImports != null && typeof absoluteImports !== "boolean" && typeof absoluteImports !== "string") {
	throw new Error(`.absoluteImports must be a boolean, a string, or undefined` + ` (received ${JSON.stringify(absoluteImports)})`);
	}

	let targets;

	if ( // If any browserslist-related option is specified, fallback to the old
	// behavior of not using the targets specified in the top-level options.
	targetsOption \|\| configPath \|\| ignoreBrowserslistConfig) {
	const targetsObj = typeof targetsOption === "string" \|\| Array.isArray(targetsOption) ? {
	browsers: targetsOption
	} : targetsOption;
	targets = getTargets(targetsObj, {
	ignoreBrowserslistConfig,
	configPath
	});
	} else {
	targets = babelApi.targets();
	}

	return {
	method,
	methodName,
	targets,
	absoluteImports: absoluteImports != null ? absoluteImports : false,
	shouldInjectPolyfill,
	debug: !!debug,
	providerOptions: providerOptions
	};
	}

	function instantiateProvider(factory, options, missingDependencies, dirname, debugLog, babelApi) {
	const {
	method,
	methodName,
	targets,
	debug,
	shouldInjectPolyfill,
	providerOptions,
	absoluteImports
	} = resolveOptions(options, babelApi);
	const getUtils = createUtilsGetter(new ImportsCache(moduleName => resolve(dirname, moduleName, absoluteImports))); // eslint-disable-next-line prefer-const

	let include, exclude;
	let polyfillsSupport;
	let polyfillsNames;
	let filterPolyfills;
	const depsCache = new Map();
	const api = {
	babel: babelApi,
	getUtils,
	method: options.method,
	targets,
	createMetaResolver,

	shouldInjectPolyfill(name) {
	if (polyfillsNames === undefined) {
	throw new Error(`Internal error in the ${factory.name} provider: ` + `shouldInjectPolyfill() can't be called during initialization.`);
	}

	if (!polyfillsNames.has(name)) {
	console.warn(`Internal error in the ${provider.name} provider: ` + `unknown polyfill "${name}".`);
	}

	if (filterPolyfills && !filterPolyfills(name)) return false;
	let shouldInject = isRequired(name, targets, {
	compatData: polyfillsSupport,
	includes: include,
	excludes: exclude
	});

	if (shouldInjectPolyfill) {
	shouldInject = shouldInjectPolyfill(name, shouldInject);

	if (typeof shouldInject !== "boolean") {
	throw new Error(`.shouldInjectPolyfill must return a boolean.`);
	}
	}

	return shouldInject;
	},

	debug(name) {
	var _debugLog, _debugLog$polyfillsSu;

	debugLog().found = true;
	if (!debug \|\| !name) return;
	if (debugLog().polyfills.has(provider.name)) return;
	debugLog().polyfills.add(name);
	(_debugLog$polyfillsSu = (_debugLog = debugLog()).polyfillsSupport) != null ? _debugLog$polyfillsSu : _debugLog.polyfillsSupport = polyfillsSupport;
	},

	assertDependency(name, version = "*") {
	if (missingDependencies === false) return;

	if (absoluteImports) {
	// If absoluteImports is not false, we will try resolving
	// the dependency and throw if it's not possible. We can
	// skip the check here.
	return;
	}

	const dep = version === "*" ? name : `${name}@^${version}`;
	const found = missingDependencies.all ? false : mapGetOr(depsCache, `${name} :: ${dirname}`, () => has());

	if (!found) {
	debugLog().missingDeps.add(dep);
	}
	}

	};
	const provider = factory(api, providerOptions, dirname);

	if (typeof provider[methodName] !== "function") {
	throw new Error(`The "${provider.name \|\| factory.name}" provider doesn't ` + `support the "${method}" polyfilling method.`);
	}

	if (Array.isArray(provider.polyfills)) {
	polyfillsNames = new Set(provider.polyfills);
	filterPolyfills = provider.filterPolyfills;
	} else if (provider.polyfills) {
	polyfillsNames = new Set(Object.keys(provider.polyfills));
	polyfillsSupport = provider.polyfills;
	filterPolyfills = provider.filterPolyfills;
	} else {
	polyfillsNames = new Set();
	}

	({
	include,
	exclude
	} = validateIncludeExclude(provider.name \|\| factory.name, polyfillsNames, providerOptions.include \|\| [], providerOptions.exclude \|\| []));
	return {
	debug,
	method,
	targets,
	provider,

	callProvider(payload, path) {
	const utils = getUtils(path);
	provider[methodName](payload, utils, path);
	}

	};
	}

	function definePolyfillProvider(factory) {
	return declare((babelApi, options, dirname) => {
	babelApi.assertVersion(7);
	const {
	traverse
	} = babelApi;
	let debugLog;
	const missingDependencies = applyMissingDependenciesDefaults(options, babelApi);
	const {
	debug,
	method,
	targets,
	provider,
	callProvider
	} = instantiateProvider(factory, options, missingDependencies, dirname, () => debugLog, babelApi);
	const createVisitor = method === "entry-global" ? entry : usage;
	const visitor = provider.visitor ? traverse.visitors.merge([createVisitor(callProvider), provider.visitor]) : createVisitor(callProvider);

	if (debug && debug !== presetEnvSilentDebugHeader) {
	console.log(`${provider.name}: \`DEBUG\` option`);
	console.log(`\nUsing targets: ${stringifyTargetsMultiline(targets)}`);
	console.log(`\nUsing polyfills with \`${method}\` method:`);
	}

	return {
	name: "inject-polyfills",
	visitor,

	pre() {
	var _provider$pre;

	debugLog = {
	polyfills: new Set(),
	polyfillsSupport: undefined,
	found: false,
	providers: new Set(),
	missingDeps: new Set()
	};
	(_provider$pre = provider.pre) == null ? void 0 : _provider$pre.apply(this, arguments);
	},

	post() {
	var _provider$post;

	(_provider$post = provider.post) == null ? void 0 : _provider$post.apply(this, arguments);

	if (missingDependencies !== false) {
	if (missingDependencies.log === "per-file") {
	logMissing(debugLog.missingDeps);
	} else {
	laterLogMissing(debugLog.missingDeps);
	}
	}

	if (!debug) return;
	if (this.filename) console.log(`\n[${this.filename}]`);

	if (debugLog.polyfills.size === 0) {
	console.log(method === "entry-global" ? debugLog.found ? `Based on your targets, the ${provider.name} polyfill did not add any polyfill.` : `The entry point for the ${provider.name} polyfill has not been found.` : `Based on your code and targets, the ${provider.name} polyfill did not add any polyfill.`);
	return;
	}

	if (method === "entry-global") {
	console.log(`The ${provider.name} polyfill entry has been replaced with ` + `the following polyfills:`);
	} else {
	console.log(`The ${provider.name} polyfill added the following polyfills:`);
	}

	for (const name of debugLog.polyfills) {
	var _debugLog$polyfillsSu2;

	if ((_debugLog$polyfillsSu2 = debugLog.polyfillsSupport) != null && _debugLog$polyfillsSu2[name]) {
	const filteredTargets = getInclusionReasons(name, targets, debugLog.polyfillsSupport);
	const formattedTargets = JSON.stringify(filteredTargets).replace(/,/g, ", ").replace(/^\{"/, '{ "').replace(/"\}$/, '" }');
	console.log(` ${name} ${formattedTargets}`);
	} else {
	console.log(` ${name}`);
	}
	}
	}

	};
	});
	}

	function mapGetOr(map, key, getDefault) {
	let val = map.get(key);

	if (val === undefined) {
	val = getDefault();
	map.set(key, val);
	}

	return val;
	}

	function isEmpty(obj) {
	return Object.keys(obj).length === 0;
	}

	export default definePolyfillProvider;
	//# sourceMappingURL=index.browser.mjs.map

index.browser.mjsNo OneTemporaryActions

File Metadata

index.browser.mjsView Options

Event Timeline

index.browser.mjs
No OneTemporary
Actions

index.browser.mjs
View Options