truffle
Version:
Truffle - Simple development framework for Ethereum
1,245 lines (1,029 loc) • 34.3 kB
JavaScript
/******/ (() => { // webpackBootstrap
/******/ var __webpack_modules__ = ({
/***/ 15959:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
;
const net = __webpack_require__(41808);
class Locked extends Error {
constructor(port) {
super(`${port} is locked`);
}
}
const lockedPorts = {
old: new Set(),
young: new Set()
};
// On this interval, the old locked ports are discarded,
// the young locked ports are moved to old locked ports,
// and a new young set for locked ports are created.
const releaseOldLockedPortsIntervalMs = 1000 * 15;
// Lazily create interval on first use
let interval;
const getAvailablePort = options => new Promise((resolve, reject) => {
const server = net.createServer();
server.unref();
server.on('error', reject);
server.listen(options, () => {
const {port} = server.address();
server.close(() => {
resolve(port);
});
});
});
const portCheckSequence = function * (ports) {
if (ports) {
yield * ports;
}
yield 0; // Fall back to 0 if anything else failed
};
module.exports = async options => {
let ports;
if (options) {
ports = typeof options.port === 'number' ? [options.port] : options.port;
}
if (interval === undefined) {
interval = setInterval(() => {
lockedPorts.old = lockedPorts.young;
lockedPorts.young = new Set();
}, releaseOldLockedPortsIntervalMs);
// Does not exist in some environments (Electron, Jest jsdom env, browser, etc).
if (interval.unref) {
interval.unref();
}
}
for (const port of portCheckSequence(ports)) {
try {
let availablePort = await getAvailablePort({...options, port}); // eslint-disable-line no-await-in-loop
while (lockedPorts.old.has(availablePort) || lockedPorts.young.has(availablePort)) {
if (port !== 0) {
throw new Locked(port);
}
availablePort = await getAvailablePort({...options, port}); // eslint-disable-line no-await-in-loop
}
lockedPorts.young.add(availablePort);
return availablePort;
} catch (error) {
if (!['EADDRINUSE', 'EACCES'].includes(error.code) && !(error instanceof Locked)) {
throw error;
}
}
}
throw new Error('No available ports found');
};
module.exports.makeRange = (from, to) => {
if (!Number.isInteger(from) || !Number.isInteger(to)) {
throw new TypeError('`from` and `to` must be integer numbers');
}
if (from < 1024 || from > 65535) {
throw new RangeError('`from` must be between 1024 and 65535');
}
if (to < 1024 || to > 65536) {
throw new RangeError('`to` must be between 1024 and 65536');
}
if (to < from) {
throw new RangeError('`to` must be greater than or equal to `from`');
}
const generator = function * (from, to) {
for (let port = from; port <= to; port++) {
yield port;
}
};
return generator(from, to);
};
/***/ }),
/***/ 86067:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
module.exports = {
run: __webpack_require__(46394),
meta: __webpack_require__(43059)
};
/***/ }),
/***/ 43059:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
const OS = __webpack_require__(22037);
module.exports = {
command: "test",
description: "Run JavaScript and Solidity tests",
builder: {
"show-events": {
describe: "Show all test logs",
type: "boolean",
default: false
},
"compile-all-debug": {
describe: "Compile in debug mode",
type: "boolean",
default: false
},
"debug": {
describe: "Enable in-test debugging",
type: "boolean",
default: false
},
"debug-global": {
describe: "Specify debug global function name",
default: "debug"
},
"runner-output-only": {
describe: "Suppress all output except for test runner output.",
type: "boolean",
default: false
},
"bail": {
alias: "b",
describe: "Bail after first test failure",
type: "boolean",
default: false
},
"grep": {
alias: "g",
type: "string",
describe:
`Use mocha's "grep" option while running tests. This ` +
`option only runs tests that match the supplied regex/string.`
},
"stacktrace": {
alias: "t",
describe: "Produce Solidity stacktraces",
type: "boolean",
default: false
},
"stacktrace-extra": {
describe: "Produce Solidity stacktraces and compile in debug mode",
type: "boolean",
default: false
},
"reporter": {
alias: "r",
describe: "Specify the type of mocha reporter",
default: undefined
}
},
help: {
usage:
`truffle test [<test_file>] [--compile-all[-debug]] [--compile-none] ` +
`[--migrate-none] ` +
`[--network <name>]${OS.EOL} ` +
`[--verbose-rpc] [--show-events] [--debug] ` +
`[--debug-global <identifier>] [--bail|-b]${OS.EOL} ` +
` [--stacktrace[-extra]] [--grep|-g <regex>] ` +
`[--reporter|-r <name>] `,
options: [
{
option: "<test_file>",
description:
"Name of the test file to be run. Can include path information if the file " +
"does not exist in the\n current directory."
},
{
option: "--compile-all",
description:
"Compile all contracts instead of intelligently choosing which contracts need " +
"to be compiled."
},
{
option: "--compile-none",
description: "Do not compile any contracts before running the tests"
},
{
option: "--compile-all-debug",
description:
"Compile all contracts and do so in debug mode for extra revert info. May " +
"cause errors on large\n contracts."
},
{
option: "--migrate-none",
description: "Do not migrate any contracts before running the tests."
},
{
option: "--verbose-rpc",
description:
"Log communication between Truffle and the Ethereum client."
},
{
option: "--show-events",
description: "Log all contract events."
},
{
option: "--debug",
description:
"Provides global debug() function for in-test debugging. " +
"JS tests only; implies --compile-all."
},
{
option: "--debug-global <identifier>",
description:
'Specify global identifier for debug function. Default: "debug"'
},
{
option: "--runner-output-only",
description: "Suppress all output except for test runner output."
},
{
option: "--bail|-b",
description: "Bail after first test failure."
},
{
option: "--stacktrace",
description:
"Allows for mixed JS/Solidity stacktraces when a Truffle Contract transaction " +
"or deployment\n reverts. Does not apply to calls or gas estimates. " +
"Implies --compile-all. Experimental. Alias: -t"
},
{
option: "--stacktrace-extra",
description: "Shortcut for --stacktrace --compile-all-debug."
},
{
option: "--grep|-g",
description:
'Use mocha\'s "grep" option while running tests. This ' +
"option only runs tests that match the supplied regex/string."
},
{
option: "--reporter|-r <name>",
description:
"Specify the type of mocha reporter to use during testing. Default: 'spec'"
}
],
allowedGlobalOptions: ["network", "config"]
}
};
/***/ }),
/***/ 95614:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
const Config = __webpack_require__(20553);
const analytics = {
send: function(eventObject) {
const userConfig = Config.getUserConfig();
if (!userConfig.get("enableAnalytics")) {
// don't bother with creating a new process if we already
// know the user doesn't want to send analytics
return;
}
let analyticsPath;
const path = __webpack_require__(71017);
if (true) {
analyticsPath = path.join(__dirname, "analytics.bundled.js");
} else {}
const cp = __webpack_require__(32081);
const child = cp.fork(analyticsPath, { silent: true });
child.send(eventObject);
}
};
module.exports = analytics;
/***/ }),
/***/ 86927:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
const { IPC } = __webpack_require__(39813);
const path = __webpack_require__(71017);
const { spawn } = __webpack_require__(32081);
const debug = __webpack_require__(15158);
const chalk = __webpack_require__(34061);
const Develop = {
start: async function (ipcNetwork, ganacheOptions = {}) {
let chainPath;
// The path to the dev env process depends on whether or not
// we're running in the bundled version. If not, use chain.js
// directly, otherwise let the bundle point at the bundled version.
if (true) {
// Remember: In the bundled version, __dirname refers to the
// build directory where cli.bundled.js and cli.chain.js live.
chainPath = path.join(__dirname, "chain.bundled.js");
} else {}
const logger = ganacheOptions.logger || console;
//check that genesis-time config option passed through the
//truffle-config.js file is a valid time.
if (ganacheOptions.time && isNaN(Date.parse(ganacheOptions.time))) {
ganacheOptions.time = Date.now();
logger.log(
"\x1b[31m%s\x1b[0m",
"Invalid Date passed to genesis-time, using current Date instead",
"\x1b[0m"
);
}
const stringifiedOptions = JSON.stringify(ganacheOptions);
const optionsBuffer = Buffer.from(stringifiedOptions);
const base64OptionsString = optionsBuffer.toString("base64");
return spawn("node", [chainPath, ipcNetwork, base64OptionsString], {
detached: true,
stdio: "ignore"
});
},
/**
* Connect to an existing Ganache server or start a new one.
* @param {object} options
* @param {object} options.ipcOptions - options for IPC connection
* @param {boolean} options.ipcOptions.log - whether to log IPC messages. Defaults to false.
* @param {string} options.ipcOptions.network - network name. Defaults to "develop".
* @param {boolean} options.ipcOptions.retry - whether to retry connection. Defaults to false.
* @param {string} options.solidityLogDisplayPrefix - prefix to display before solidity log messages. Defaults to "".
* @returns {Promise<(): void>} - IPC disconnection function.
*/
connect: function ({ ipcOptions, solidityLogDisplayPrefix }) {
const debugServer = debug("develop:ipc:server");
const debugClient = debug("develop:ipc:client");
const debugRPC = debug("develop:ganache");
const ganacheColor = {
hex: "#ffaf5f", // ganache's color in hex
xterm: 215 // Xterm's number equivalent
};
debugRPC.color = ganacheColor.xterm;
ipcOptions.retry = ipcOptions.retry || false;
ipcOptions.log = ipcOptions.log || false;
ipcOptions.network = ipcOptions.network || "develop";
solidityLogDisplayPrefix = solidityLogDisplayPrefix || "";
var ipcNetwork = ipcOptions.network;
var ipc = new IPC();
ipc.config.appspace = "truffle.";
// set connectPath explicitly
var dirname = ipc.config.socketRoot;
var basename = `${ipc.config.appspace}${ipcNetwork}`;
var connectPath = path.join(dirname, basename);
var loggers = {};
ipc.config.silent = !debugClient.enabled;
ipc.config.logger = debugClient;
const sanitizeAndCallFn =
fn =>
(...args) => {
// HACK-y: replace `{}` that is getting logged instead of ""
if (
args.length === 1 &&
typeof args[0] === "object" &&
Object.keys(args[0]).length === 0
) {
args[0] = "";
}
fn.apply(undefined, args);
};
if (debugServer.enabled) {
loggers.ipc = debugServer;
}
// create a logger to present Ganache's console log messages
const createSolidityLogger = prefix => {
return maybeMultipleLines =>
maybeMultipleLines.split("\n").forEach(
// decorate each line's prefix.
line => console.log(chalk.hex(ganacheColor.hex)(` ${prefix}`), line)
);
};
// enable output/logger for solidity console.log
loggers.solidity = sanitizeAndCallFn(
createSolidityLogger(solidityLogDisplayPrefix)
);
if (ipcOptions.log) {
debugRPC.enabled = true;
loggers.ganache = sanitizeAndCallFn(debugRPC);
}
if (!ipcOptions.retry) {
ipc.config.maxRetries = 0;
}
var disconnect = function () {
ipc.disconnect(ipcNetwork);
};
return new Promise((resolve, reject) => {
ipc.connectTo(ipcNetwork, connectPath, function () {
ipc.of[ipcNetwork].on("destroy", function () {
reject(new Error("IPC connection destroyed"));
});
ipc.of[ipcNetwork].on("truffle.ready", function () {
resolve(disconnect);
});
Object.keys(loggers).forEach(function (key) {
var log = loggers[key];
if (log) {
var message = `truffle.${key}.log`;
ipc.of[ipcNetwork].on(message, log);
}
});
});
});
},
/**
* Connect to a managed Ganache service. This will connect to an existing
* Ganache service if one exists, or, create a new one to connect to.
*
* @param {Object} ipcOptions - IPC connection options.
* @param {string} ipcOptions.network - the network name.
* @param {Object} ganacheOptions - Ganache options if service is necessary.
* @param {string} solidityLogDisplayPrefix - solidity log messages prefix.
* @returns {Promise<Object>} - object with `disconnect` function and
* `started` boolean. The `disconnect` function is used to disconnect
* from the Ganache service. The `started` boolean is true if a new
* Ganache service was started, false otherwise.
*/
connectOrStart: async function (
ipcOptions,
ganacheOptions,
solidityLogDisplayPrefix = ""
) {
ipcOptions.retry = false;
const ipcNetwork = ipcOptions.network || "develop";
let started = false;
let disconnect;
try {
disconnect = await this.connect({ ipcOptions, solidityLogDisplayPrefix });
} catch (_error) {
await this.start(ipcNetwork, ganacheOptions);
ipcOptions.retry = true;
disconnect = await this.connect({ ipcOptions, solidityLogDisplayPrefix });
started = true;
} finally {
return {
disconnect,
started
};
}
}
};
module.exports = Develop;
/***/ }),
/***/ 53234:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
const Web3 = __webpack_require__(3283);
const { createInterfaceAdapter } = __webpack_require__(36339);
const expect = __webpack_require__(14096);
const TruffleError = __webpack_require__(73321);
const { Resolver } = __webpack_require__(48511);
const Artifactor = __webpack_require__(29463);
const Ganache = __webpack_require__(11651);
const Provider = __webpack_require__(509);
const Environment = {
// It's important config is a Config object and not a vanilla object
detect: async function (config) {
expect.options(config, ["networks"]);
helpers.setUpConfig(config);
helpers.validateNetworkConfig(config);
const interfaceAdapter = createInterfaceAdapter({
provider: config.provider,
networkType: config.network_config.type
});
await Provider.testConnection(config);
await helpers.detectAndSetNetworkId(config, interfaceAdapter);
await helpers.setFromOnConfig(config, interfaceAdapter);
},
// Ensure you call Environment.detect() first.
fork: async function (config, ganacheOptions) {
expect.options(config, ["from", "provider", "networks", "network"]);
const interfaceAdapter = createInterfaceAdapter({
provider: config.provider,
networkType: config.network_config.type
});
let accounts;
try {
accounts = await interfaceAdapter.getAccounts();
} catch {
// don't prevent Truffle from working if user doesn't provide some way
// to sign transactions (e.g. no reason to disallow debugging)
accounts = [];
}
const block = await interfaceAdapter.getBlock("latest");
const upstreamNetwork = config.network;
const upstreamConfig = config.networks[upstreamNetwork];
const forkedNetwork = config.network + "-fork";
ganacheOptions = {
...ganacheOptions,
fork: config.provider,
miner: {
...ganacheOptions.miner,
blockGasLimit: block.gasLimit
}
};
if (accounts.length > 0) ganacheOptions.unlocked_accounts = accounts;
config.networks[forkedNetwork] = {
network_id: config.network_id,
provider: Ganache.provider(ganacheOptions),
from: config.from,
gas: upstreamConfig.gas,
gasPrice: upstreamConfig.gasPrice
};
config.network = forkedNetwork;
},
develop: async (config, ganacheOptions) => {
expect.options(config, ["networks"]);
const network = config.network || "develop";
const url = `http://${ganacheOptions.host}:${ganacheOptions.port}/`;
config.networks[network] = {
...config.networks[network],
network_id: ganacheOptions.network_id,
provider: function () {
return new Web3.providers.HttpProvider(url, { keepAlive: false });
}
};
config.network = network;
return await Environment.detect(config);
}
};
const helpers = {
setFromOnConfig: async (config, interfaceAdapter) => {
if (config.from) return;
try {
const accounts = await interfaceAdapter.getAccounts();
config.networks[config.network].from = accounts[0];
} catch {
// don't prevent Truffle from working if user doesn't provide some way
// to sign transactions (e.g. no reason to disallow debugging)
}
},
detectAndSetNetworkId: async (config, interfaceAdapter) => {
const configNetworkId = config.networks[config.network].network_id;
const providerNetworkId = await interfaceAdapter.getNetworkId();
if (configNetworkId !== "*") {
// Ensure the network id matches the one in the config for safety
if (providerNetworkId.toString() !== configNetworkId.toString()) {
const error =
`The network id specified in the truffle config ` +
`(${configNetworkId}) does not match the one returned by the network ` +
`(${providerNetworkId}). Ensure that both the network and the ` +
`provider are properly configured.`;
throw new Error(error);
}
} else {
// We have a "*" network. Get the current network and replace it with the real one.
// TODO: Should we replace this with the blockchain uri?
config.networks[config.network].network_id = providerNetworkId;
}
},
validateNetworkConfig: config => {
const networkConfig = config.network_config;
if (!networkConfig) {
throw new TruffleError(
`Unknown network "${config.network}` +
`". See your Truffle configuration file for available networks.`
);
}
const configNetworkId = config.network_config.network_id;
if (configNetworkId == null) {
throw new Error(
`You must specify a network_id in your '` +
`${config.network}' configuration in order to use this network.`
);
}
},
setUpConfig: config => {
if (!config.resolver) {
config.resolver = new Resolver(config);
}
if (!config.artifactor) {
config.artifactor = new Artifactor(config.contracts_build_directory);
}
if (!config.network) {
if (config.networks["development"]) {
config.network = "development";
} else {
config.network = "ganache";
config.networks[config.network] = {
host: "127.0.0.1",
port: 7545,
network_id: 5777
};
}
}
const currentNetworkSettings = config.networks[config.network];
if (
currentNetworkSettings &&
currentNetworkSettings.ens &&
currentNetworkSettings.ens.registry
) {
config.ens.registryAddress = currentNetworkSettings.ens.registry.address;
}
}
};
module.exports = Environment;
/***/ }),
/***/ 76765:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
const Environment = __webpack_require__(53234);
const Develop = __webpack_require__(86927);
module.exports = { Environment, Develop };
/***/ }),
/***/ 48511:
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
;
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.Resolver = void 0;
const resolver_1 = __webpack_require__(43563);
Object.defineProperty(exports, "Resolver", ({ enumerable: true, get: function () { return resolver_1.Resolver; } }));
exports["default"] = resolver_1.Resolver;
//# sourceMappingURL=index.js.map
/***/ }),
/***/ 70972:
/***/ ((module) => {
;
module.exports = require("@truffle/db-loader");
/***/ }),
/***/ 92851:
/***/ ((module) => {
;
module.exports = require("@truffle/debugger");
/***/ }),
/***/ 11651:
/***/ ((module) => {
;
module.exports = require("ganache");
/***/ }),
/***/ 3270:
/***/ ((module) => {
;
module.exports = require("mocha");
/***/ }),
/***/ 44516:
/***/ ((module) => {
;
module.exports = require("original-require");
/***/ }),
/***/ 39491:
/***/ ((module) => {
;
module.exports = require("assert");
/***/ }),
/***/ 50852:
/***/ ((module) => {
;
module.exports = require("async_hooks");
/***/ }),
/***/ 14300:
/***/ ((module) => {
;
module.exports = require("buffer");
/***/ }),
/***/ 32081:
/***/ ((module) => {
;
module.exports = require("child_process");
/***/ }),
/***/ 22057:
/***/ ((module) => {
;
module.exports = require("constants");
/***/ }),
/***/ 6113:
/***/ ((module) => {
;
module.exports = require("crypto");
/***/ }),
/***/ 71891:
/***/ ((module) => {
;
module.exports = require("dgram");
/***/ }),
/***/ 82361:
/***/ ((module) => {
;
module.exports = require("events");
/***/ }),
/***/ 57147:
/***/ ((module) => {
;
module.exports = require("fs");
/***/ }),
/***/ 73292:
/***/ ((module) => {
;
module.exports = require("fs/promises");
/***/ }),
/***/ 13685:
/***/ ((module) => {
;
module.exports = require("http");
/***/ }),
/***/ 95687:
/***/ ((module) => {
;
module.exports = require("https");
/***/ }),
/***/ 98188:
/***/ ((module) => {
;
module.exports = require("module");
/***/ }),
/***/ 41808:
/***/ ((module) => {
;
module.exports = require("net");
/***/ }),
/***/ 22037:
/***/ ((module) => {
;
module.exports = require("os");
/***/ }),
/***/ 71017:
/***/ ((module) => {
;
module.exports = require("path");
/***/ }),
/***/ 85477:
/***/ ((module) => {
;
module.exports = require("punycode");
/***/ }),
/***/ 63477:
/***/ ((module) => {
;
module.exports = require("querystring");
/***/ }),
/***/ 14521:
/***/ ((module) => {
;
module.exports = require("readline");
/***/ }),
/***/ 38102:
/***/ ((module) => {
;
module.exports = require("repl");
/***/ }),
/***/ 12781:
/***/ ((module) => {
;
module.exports = require("stream");
/***/ }),
/***/ 71576:
/***/ ((module) => {
;
module.exports = require("string_decoder");
/***/ }),
/***/ 39512:
/***/ ((module) => {
;
module.exports = require("timers");
/***/ }),
/***/ 24404:
/***/ ((module) => {
;
module.exports = require("tls");
/***/ }),
/***/ 76224:
/***/ ((module) => {
;
module.exports = require("tty");
/***/ }),
/***/ 57310:
/***/ ((module) => {
;
module.exports = require("url");
/***/ }),
/***/ 73837:
/***/ ((module) => {
;
module.exports = require("util");
/***/ }),
/***/ 26144:
/***/ ((module) => {
;
module.exports = require("vm");
/***/ }),
/***/ 59796:
/***/ ((module) => {
;
module.exports = require("zlib");
/***/ })
/******/ });
/************************************************************************/
/******/ // The module cache
/******/ var __webpack_module_cache__ = {};
/******/
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/ // Check if module is in cache
/******/ var cachedModule = __webpack_module_cache__[moduleId];
/******/ if (cachedModule !== undefined) {
/******/ return cachedModule.exports;
/******/ }
/******/ // Create a new module (and put it into the cache)
/******/ var module = __webpack_module_cache__[moduleId] = {
/******/ id: moduleId,
/******/ loaded: false,
/******/ exports: {}
/******/ };
/******/
/******/ // Execute the module function
/******/ __webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ // Flag the module as loaded
/******/ module.loaded = true;
/******/
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/
/******/ // expose the modules object (__webpack_modules__)
/******/ __webpack_require__.m = __webpack_modules__;
/******/
/******/ // expose the module cache
/******/ __webpack_require__.c = __webpack_module_cache__;
/******/
/******/ // the startup function
/******/ __webpack_require__.x = () => {
/******/ // Load entry module and return exports
/******/ var __webpack_exports__ = __webpack_require__.O(undefined, [5158,9129,6127,5674,6674,439,406,7657,6434,1503,1698,1833,1071,9612,3613,8834,8100,4914,2895,9813,6062,6276,5498,8569,7941,553,4273,102,3077,7017,2478,5523,8852,458,6394], () => (__webpack_require__(86067)))
/******/ __webpack_exports__ = __webpack_require__.O(__webpack_exports__);
/******/ return __webpack_exports__;
/******/ };
/******/
/************************************************************************/
/******/ /* webpack/runtime/amd options */
/******/ (() => {
/******/ __webpack_require__.amdO = {};
/******/ })();
/******/
/******/ /* webpack/runtime/chunk loaded */
/******/ (() => {
/******/ var deferred = [];
/******/ __webpack_require__.O = (result, chunkIds, fn, priority) => {
/******/ if(chunkIds) {
/******/ priority = priority || 0;
/******/ for(var i = deferred.length; i > 0 && deferred[i - 1][2] > priority; i--) deferred[i] = deferred[i - 1];
/******/ deferred[i] = [chunkIds, fn, priority];
/******/ return;
/******/ }
/******/ var notFulfilled = Infinity;
/******/ for (var i = 0; i < deferred.length; i++) {
/******/ var [chunkIds, fn, priority] = deferred[i];
/******/ var fulfilled = true;
/******/ for (var j = 0; j < chunkIds.length; j++) {
/******/ if ((priority & 1 === 0 || notFulfilled >= priority) && Object.keys(__webpack_require__.O).every((key) => (__webpack_require__.O[key](chunkIds[j])))) {
/******/ chunkIds.splice(j--, 1);
/******/ } else {
/******/ fulfilled = false;
/******/ if(priority < notFulfilled) notFulfilled = priority;
/******/ }
/******/ }
/******/ if(fulfilled) {
/******/ deferred.splice(i--, 1)
/******/ var r = fn();
/******/ if (r !== undefined) result = r;
/******/ }
/******/ }
/******/ return result;
/******/ };
/******/ })();
/******/
/******/ /* webpack/runtime/compat get default export */
/******/ (() => {
/******/ // getDefaultExport function for compatibility with non-harmony modules
/******/ __webpack_require__.n = (module) => {
/******/ var getter = module && module.__esModule ?
/******/ () => (module['default']) :
/******/ () => (module);
/******/ __webpack_require__.d(getter, { a: getter });
/******/ return getter;
/******/ };
/******/ })();
/******/
/******/ /* webpack/runtime/define property getters */
/******/ (() => {
/******/ // define getter functions for harmony exports
/******/ __webpack_require__.d = (exports, definition) => {
/******/ for(var key in definition) {
/******/ if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
/******/ Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
/******/ }
/******/ }
/******/ };
/******/ })();
/******/
/******/ /* webpack/runtime/ensure chunk */
/******/ (() => {
/******/ __webpack_require__.f = {};
/******/ // This file contains only the entry chunk.
/******/ // The chunk loading function for additional chunks
/******/ __webpack_require__.e = (chunkId) => {
/******/ return Promise.all(Object.keys(__webpack_require__.f).reduce((promises, key) => {
/******/ __webpack_require__.f[key](chunkId, promises);
/******/ return promises;
/******/ }, []));
/******/ };
/******/ })();
/******/
/******/ /* webpack/runtime/get javascript chunk filename */
/******/ (() => {
/******/ // This function allow to reference async chunks and sibling chunks for the entrypoint
/******/ __webpack_require__.u = (chunkId) => {
/******/ // return url for filenames based on template
/******/ return "" + chunkId + ".bundled.js";
/******/ };
/******/ })();
/******/
/******/ /* webpack/runtime/hasOwnProperty shorthand */
/******/ (() => {
/******/ __webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
/******/ })();
/******/
/******/ /* webpack/runtime/make namespace object */
/******/ (() => {
/******/ // define __esModule on exports
/******/ __webpack_require__.r = (exports) => {
/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ }
/******/ Object.defineProperty(exports, '__esModule', { value: true });
/******/ };
/******/ })();
/******/
/******/ /* webpack/runtime/node module decorator */
/******/ (() => {
/******/ __webpack_require__.nmd = (module) => {
/******/ module.paths = [];
/******/ if (!module.children) module.children = [];
/******/ return module;
/******/ };
/******/ })();
/******/
/******/ /* webpack/runtime/require chunk loading */
/******/ (() => {
/******/ // no baseURI
/******/
/******/ // object to store loaded chunks
/******/ // "1" means "loaded", otherwise not loaded yet
/******/ var installedChunks = {
/******/ 5043: 1
/******/ };
/******/
/******/ __webpack_require__.O.require = (chunkId) => (installedChunks[chunkId]);
/******/
/******/ var installChunk = (chunk) => {
/******/ var moreModules = chunk.modules, chunkIds = chunk.ids, runtime = chunk.runtime;
/******/ for(var moduleId in moreModules) {
/******/ if(__webpack_require__.o(moreModules, moduleId)) {
/******/ __webpack_require__.m[moduleId] = moreModules[moduleId];
/******/ }
/******/ }
/******/ if(runtime) runtime(__webpack_require__);
/******/ for(var i = 0; i < chunkIds.length; i++)
/******/ installedChunks[chunkIds[i]] = 1;
/******/ __webpack_require__.O();
/******/ };
/******/
/******/ // require() chunk loading for javascript
/******/ __webpack_require__.f.require = (chunkId, promises) => {
/******/ // "1" is the signal for "already loaded"
/******/ if(!installedChunks[chunkId]) {
/******/ if(true) { // all chunks have JS
/******/ installChunk(require("./" + __webpack_require__.u(chunkId)));
/******/ } else installedChunks[chunkId] = 1;
/******/ }
/******/ };
/******/
/******/ // no external install chunk
/******/
/******/ // no HMR
/******/
/******/ // no HMR manifest
/******/ })();
/******/
/******/ /* webpack/runtime/startup chunk dependencies */
/******/ (() => {
/******/ var next = __webpack_require__.x;
/******/ __webpack_require__.x = () => {
/******/ __webpack_require__.e(5158);
/******/ __webpack_require__.e(9129);
/******/ __webpack_require__.e(6127);
/******/ __webpack_require__.e(5674);
/******/ __webpack_require__.e(6674);
/******/ __webpack_require__.e(439);
/******/ __webpack_require__.e(406);
/******/ __webpack_require__.e(7657);
/******/ __webpack_require__.e(6434);
/******/ __webpack_require__.e(1503);
/******/ __webpack_require__.e(1698);
/******/ __webpack_require__.e(1833);
/******/ __webpack_require__.e(1071);
/******/ __webpack_require__.e(9612);
/******/ __webpack_require__.e(3613);
/******/ __webpack_require__.e(8834);
/******/ __webpack_require__.e(8100);
/******/ __webpack_require__.e(4914);
/******/ __webpack_require__.e(2895);
/******/ __webpack_require__.e(9813);
/******/ __webpack_require__.e(6062);
/******/ __webpack_require__.e(6276);
/******/ __webpack_require__.e(5498);
/******/ __webpack_require__.e(8569);
/******/ __webpack_require__.e(7941);
/******/ __webpack_require__.e(553);
/******/ __webpack_require__.e(4273);
/******/ __webpack_require__.e(102);
/******/ __webpack_require__.e(3077);
/******/ __webpack_require__.e(7017);
/******/ __webpack_require__.e(2478);
/******/ __webpack_require__.e(5523);
/******/ __webpack_require__.e(8852);
/******/ __webpack_require__.e(458);
/******/ __webpack_require__.e(6394);
/******/ return next();
/******/ };
/******/ })();
/******/
/************************************************************************/
/******/
/******/ // module cache are used so entry inlining is disabled
/******/ // run startup
/******/ var __webpack_exports__ = __webpack_require__.x();
/******/ var __webpack_export_target__ = exports;
/******/ for(var i in __webpack_exports__) __webpack_export_target__[i] = __webpack_exports__[i];
/******/ if(__webpack_exports__.__esModule) Object.defineProperty(__webpack_export_target__, "__esModule", { value: true });
/******/
/******/ })()
;
//# sourceMappingURL=test.bundled.js.map