save code

frontend/node_modules/is-async-function/.eslintrc

@@ -0,0 +1,9 @@
+{
+	"root": true,
+
+	"extends": "@ljharb",
+
+	"rules": {
+		"no-new-func": 1,
+	},
+}

frontend/node_modules/is-async-function/.nycrc

@@ -0,0 +1,9 @@
+{
+	"all": true,
+	"check-coverage": false,
+	"reporter": ["text-summary", "text", "html", "json"],
+	"exclude": [
+		"coverage",
+		"test"
+	]
+}

frontend/node_modules/is-async-function/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 Jordan Harband
+
+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.

frontend/node_modules/is-async-function/index.js

@@ -0,0 +1,32 @@
+'use strict';
+
+var callBound = require('call-bound');
+var safeRegexTest = require('safe-regex-test');
+
+var toStr = callBound('Object.prototype.toString');
+var fnToStr = callBound('Function.prototype.toString');
+var isFnRegex = safeRegexTest(/^\s*async(?:\s+function(?:\s+|\()|\s*\()/);
+
+var hasToStringTag = require('has-tostringtag/shams')();
+var getProto = require('get-proto');
+
+var getAsyncFunc = require('async-function');
+
+/** @type {import('.')} */
+module.exports = function isAsyncFunction(fn) {
+	if (typeof fn !== 'function') {
+		return false;
+	}
+	if (isFnRegex(fnToStr(fn))) {
+		return true;
+	}
+	if (!hasToStringTag) {
+		var str = toStr(fn);
+		return str === '[object AsyncFunction]';
+	}
+	if (!getProto) {
+		return false;
+	}
+	var asyncFunc = getAsyncFunc();
+	return asyncFunc && asyncFunc.prototype === getProto(fn);
+};

frontend/node_modules/is-async-function/test/index.js

@@ -0,0 +1,91 @@
+'use strict';
+
+/* globals window */
+
+var test = require('tape');
+var isAsyncFunction = require('../index');
+var generatorFuncs = require('make-generator-function')();
+var asyncFuncs = require('make-async-function').list();
+var hasToStringTag = require('has-tostringtag/shams')();
+
+var forEach = require('for-each');
+
+test('returns false for non-functions', function (t) {
+	var nonFuncs = [
+		true,
+		false,
+		null,
+		undefined,
+		{},
+		[],
+		/a/g,
+		'string',
+		42,
+		new Date()
+	];
+	t.plan(nonFuncs.length);
+	forEach(nonFuncs, function (nonFunc) {
+		t.notOk(isAsyncFunction(nonFunc), nonFunc + ' is not a function');
+	});
+	t.end();
+});
+
+test('returns false for non-async functions', function (t) {
+	var func = function () {};
+	t.notOk(isAsyncFunction(func), 'anonymous function is not an async function');
+
+	var namedFunc = function foo() {};
+	t.notOk(isAsyncFunction(namedFunc), 'named function is not an async function');
+
+	if (typeof window === 'undefined') {
+		t.skip('window.alert is not an async function');
+	} else {
+		t.notOk(isAsyncFunction(window.alert), 'window.alert is not an async function');
+	}
+	t.end();
+});
+
+var fakeToString = function () { return 'async function () { return "TOTALLY REAL I SWEAR!"; }'; };
+
+test('returns false for non-async function with faked toString', function (t) {
+	var func = function () {};
+	func.toString = fakeToString;
+
+	t.notEqual(String(func), Function.prototype.toString.apply(func), 'faked toString is not real toString');
+	t.notOk(isAsyncFunction(func), 'anonymous function with faked toString is not an async function');
+	t.end();
+});
+
+test('returns false for generator functions', function (t) {
+	if (generatorFuncs.length > 0) {
+		forEach(generatorFuncs, function (generatorFunc) {
+			t.notOk(isAsyncFunction(generatorFunc), generatorFunc + ' is not async function');
+		});
+	} else {
+		t.skip('generator function is not async function - this environment does not support ES6 generator functions. Please use an engine that supports them.');
+	}
+	t.end();
+});
+
+test('returns false for non-async function with faked @@toStringTag', { skip: !hasToStringTag || asyncFuncs.length === 0 }, function (t) {
+	var asyncFunc = asyncFuncs[0];
+	/** @type {{ toString(): unknown; valueOf(): unknown; [Symbol.toStringTag]?: unknown }} */
+	var fakeAsyncFunction = {
+		toString: function () { return String(asyncFunc); },
+		valueOf: function () { return asyncFunc; }
+	};
+	fakeAsyncFunction[Symbol.toStringTag] = 'AsyncFunction';
+	t.notOk(isAsyncFunction(fakeAsyncFunction), 'fake AsyncFunction with @@toStringTag "AsyncFunction" is not an async function');
+	t.end();
+});
+
+test('returns true for async functions', function (t) {
+	if (asyncFuncs.length > 0) {
+		forEach(asyncFuncs, function (asyncFunc) {
+			t.ok(isAsyncFunction(asyncFunc), asyncFunc + ' is async function');
+		});
+	} else {
+		t.skip('async function is async function - this environment does not support ES2018 async functions. Please use an engine that supports them.');
+	}
+	t.end();
+});