source: frontend/node_modules/rollup/dist/shared/loadConfigFile.js

Last change on this file was 9af201e, checked in by MBK <marija.karapandzova@…>, 12 days ago

Fix frontend appearance
  • Property mode set to 100644
File size: 24.2 KB
Line 
1/*
2 @license
3 Rollup.js v2.80.0
4 Sun, 22 Feb 2026 06:16:40 GMT - commit d17ae15336a45c3c59b2a4aacac2b14186035d28
5
6 https://github.com/rollup/rollup
7
8 Released under the MIT License.
9*/
10'use strict';
11
12const require$$0 = require('path');
13const process$1 = require('process');
14const url = require('url');
15const tty = require('tty');
16const rollup = require('./rollup.js');
17const mergeOptions = require('./mergeOptions.js');
18
19function _interopNamespaceDefault(e) {
20 const n = Object.create(null, { [Symbol.toStringTag]: { value: 'Module' } });
21 if (e) {
22 for (const k in e) {
23 n[k] = e[k];
24 }
25 }
26 n.default = e;
27 return n;
28}
29
30const tty__namespace = /*#__PURE__*/_interopNamespaceDefault(tty);
31
32const {
33 env = {},
34 argv = [],
35 platform = "",
36} = typeof process === "undefined" ? {} : process;
37
38const isDisabled = "NO_COLOR" in env || argv.includes("--no-color");
39const isForced = "FORCE_COLOR" in env || argv.includes("--color");
40const isWindows = platform === "win32";
41const isDumbTerminal = env.TERM === "dumb";
42
43const isCompatibleTerminal =
44 tty__namespace && tty__namespace.isatty && tty__namespace.isatty(1) && env.TERM && !isDumbTerminal;
45
46const isCI =
47 "CI" in env &&
48 ("GITHUB_ACTIONS" in env || "GITLAB_CI" in env || "CIRCLECI" in env);
49
50const isColorSupported =
51 !isDisabled &&
52 (isForced || (isWindows && !isDumbTerminal) || isCompatibleTerminal || isCI);
53
54const replaceClose = (
55 index,
56 string,
57 close,
58 replace,
59 head = string.substring(0, index) + replace,
60 tail = string.substring(index + close.length),
61 next = tail.indexOf(close)
62) => head + (next < 0 ? tail : replaceClose(next, tail, close, replace));
63
64const clearBleed = (index, string, open, close, replace) =>
65 index < 0
66 ? open + string + close
67 : open + replaceClose(index, string, close, replace) + close;
68
69const filterEmpty =
70 (open, close, replace = open, at = open.length + 1) =>
71 (string) =>
72 string || !(string === "" || string === undefined)
73 ? clearBleed(
74 ("" + string).indexOf(close, at),
75 string,
76 open,
77 close,
78 replace
79 )
80 : "";
81
82const init = (open, close, replace) =>
83 filterEmpty(`\x1b[${open}m`, `\x1b[${close}m`, replace);
84
85const colors = {
86 reset: init(0, 0),
87 bold: init(1, 22, "\x1b[22m\x1b[1m"),
88 dim: init(2, 22, "\x1b[22m\x1b[2m"),
89 italic: init(3, 23),
90 underline: init(4, 24),
91 inverse: init(7, 27),
92 hidden: init(8, 28),
93 strikethrough: init(9, 29),
94 black: init(30, 39),
95 red: init(31, 39),
96 green: init(32, 39),
97 yellow: init(33, 39),
98 blue: init(34, 39),
99 magenta: init(35, 39),
100 cyan: init(36, 39),
101 white: init(37, 39),
102 gray: init(90, 39),
103 bgBlack: init(40, 49),
104 bgRed: init(41, 49),
105 bgGreen: init(42, 49),
106 bgYellow: init(43, 49),
107 bgBlue: init(44, 49),
108 bgMagenta: init(45, 49),
109 bgCyan: init(46, 49),
110 bgWhite: init(47, 49),
111 blackBright: init(90, 39),
112 redBright: init(91, 39),
113 greenBright: init(92, 39),
114 yellowBright: init(93, 39),
115 blueBright: init(94, 39),
116 magentaBright: init(95, 39),
117 cyanBright: init(96, 39),
118 whiteBright: init(97, 39),
119 bgBlackBright: init(100, 49),
120 bgRedBright: init(101, 49),
121 bgGreenBright: init(102, 49),
122 bgYellowBright: init(103, 49),
123 bgBlueBright: init(104, 49),
124 bgMagentaBright: init(105, 49),
125 bgCyanBright: init(106, 49),
126 bgWhiteBright: init(107, 49),
127};
128
129const createColors = ({ useColor = isColorSupported } = {}) =>
130 useColor
131 ? colors
132 : Object.keys(colors).reduce(
133 (colors, key) => ({ ...colors, [key]: String }),
134 {}
135 );
136
137createColors();
138
139// @see https://no-color.org
140// @see https://www.npmjs.com/package/chalk
141const { bold, cyan, dim, gray, green, red, underline, yellow } = createColors({
142 useColor: process$1.env.FORCE_COLOR !== '0' && !process$1.env.NO_COLOR
143});
144
145// log to stderr to keep `rollup main.js > bundle.js` from breaking
146const stderr = (...args) => process$1.stderr.write(`${args.join('')}\n`);
147function handleError(err, recover = false) {
148 let description = err.message || err;
149 if (err.name)
150 description = `${err.name}: ${description}`;
151 const message = (err.plugin ? `(plugin ${err.plugin}) ${description}` : description) || err;
152 stderr(bold(red(`[!] ${bold(message.toString())}`)));
153 if (err.url) {
154 stderr(cyan(err.url));
155 }
156 if (err.loc) {
157 stderr(`${rollup.relativeId((err.loc.file || err.id))} (${err.loc.line}:${err.loc.column})`);
158 }
159 else if (err.id) {
160 stderr(rollup.relativeId(err.id));
161 }
162 if (err.frame) {
163 stderr(dim(err.frame));
164 }
165 if (err.stack) {
166 stderr(dim(err.stack));
167 }
168 stderr('');
169 if (!recover)
170 process$1.exit(1);
171}
172
173function batchWarnings() {
174 let count = 0;
175 const deferredWarnings = new Map();
176 let warningOccurred = false;
177 return {
178 add(warning) {
179 count += 1;
180 warningOccurred = true;
181 if (warning.code in deferredHandlers) {
182 rollup.getOrCreate(deferredWarnings, warning.code, () => []).push(warning);
183 }
184 else if (warning.code in immediateHandlers) {
185 immediateHandlers[warning.code](warning);
186 }
187 else {
188 title(warning.message);
189 if (warning.url)
190 info(warning.url);
191 const id = (warning.loc && warning.loc.file) || warning.id;
192 if (id) {
193 const loc = warning.loc
194 ? `${rollup.relativeId(id)} (${warning.loc.line}:${warning.loc.column})`
195 : rollup.relativeId(id);
196 stderr(bold(rollup.relativeId(loc)));
197 }
198 if (warning.frame)
199 info(warning.frame);
200 }
201 },
202 get count() {
203 return count;
204 },
205 flush() {
206 if (count === 0)
207 return;
208 const codes = Array.from(deferredWarnings.keys()).sort((a, b) => deferredWarnings.get(b).length - deferredWarnings.get(a).length);
209 for (const code of codes) {
210 deferredHandlers[code](deferredWarnings.get(code));
211 }
212 deferredWarnings.clear();
213 count = 0;
214 },
215 get warningOccurred() {
216 return warningOccurred;
217 }
218 };
219}
220const immediateHandlers = {
221 MISSING_NODE_BUILTINS(warning) {
222 title(`Missing shims for Node.js built-ins`);
223 stderr(`Creating a browser bundle that depends on ${rollup.printQuotedStringList(warning.modules)}. You might need to include https://github.com/FredKSchott/rollup-plugin-polyfill-node`);
224 },
225 UNKNOWN_OPTION(warning) {
226 title(`You have passed an unrecognized option`);
227 stderr(warning.message);
228 }
229};
230const deferredHandlers = {
231 CIRCULAR_DEPENDENCY(warnings) {
232 title(`Circular dependenc${warnings.length > 1 ? 'ies' : 'y'}`);
233 const displayed = warnings.length > 5 ? warnings.slice(0, 3) : warnings;
234 for (const warning of displayed) {
235 stderr(warning.cycle.join(' -> '));
236 }
237 if (warnings.length > displayed.length) {
238 stderr(`...and ${warnings.length - displayed.length} more`);
239 }
240 },
241 EMPTY_BUNDLE(warnings) {
242 title(`Generated${warnings.length === 1 ? ' an' : ''} empty ${warnings.length > 1 ? 'chunks' : 'chunk'}`);
243 stderr(warnings.map(warning => warning.chunkName).join(', '));
244 },
245 EVAL(warnings) {
246 title('Use of eval is strongly discouraged');
247 info('https://rollupjs.org/guide/en/#avoiding-eval');
248 showTruncatedWarnings(warnings);
249 },
250 MISSING_EXPORT(warnings) {
251 title('Missing exports');
252 info('https://rollupjs.org/guide/en/#error-name-is-not-exported-by-module');
253 for (const warning of warnings) {
254 stderr(bold(warning.importer));
255 stderr(`${warning.missing} is not exported by ${warning.exporter}`);
256 stderr(gray(warning.frame));
257 }
258 },
259 MISSING_GLOBAL_NAME(warnings) {
260 title(`Missing global variable ${warnings.length > 1 ? 'names' : 'name'}`);
261 stderr(`Use output.globals to specify browser global variable names corresponding to external modules`);
262 for (const warning of warnings) {
263 stderr(`${bold(warning.source)} (guessing '${warning.guess}')`);
264 }
265 },
266 MIXED_EXPORTS(warnings) {
267 title('Mixing named and default exports');
268 info(`https://rollupjs.org/guide/en/#outputexports`);
269 stderr(bold('The following entry modules are using named and default exports together:'));
270 warnings.sort((a, b) => (a.id < b.id ? -1 : 1));
271 const displayedWarnings = warnings.length > 5 ? warnings.slice(0, 3) : warnings;
272 for (const warning of displayedWarnings) {
273 stderr(rollup.relativeId(warning.id));
274 }
275 if (displayedWarnings.length < warnings.length) {
276 stderr(`...and ${warnings.length - displayedWarnings.length} other entry modules`);
277 }
278 stderr(`\nConsumers of your bundle will have to use chunk['default'] to access their default export, which may not be what you want. Use \`output.exports: 'named'\` to disable this warning`);
279 },
280 NAMESPACE_CONFLICT(warnings) {
281 title(`Conflicting re-exports`);
282 for (const warning of warnings) {
283 stderr(`"${bold(rollup.relativeId(warning.reexporter))}" re-exports "${warning.name}" from both "${rollup.relativeId(warning.sources[0])}" and "${rollup.relativeId(warning.sources[1])}" (will be ignored)`);
284 }
285 },
286 NON_EXISTENT_EXPORT(warnings) {
287 title(`Import of non-existent ${warnings.length > 1 ? 'exports' : 'export'}`);
288 showTruncatedWarnings(warnings);
289 },
290 PLUGIN_WARNING(warnings) {
291 var _a;
292 const nestedByPlugin = nest(warnings, 'plugin');
293 for (const { key: plugin, items } of nestedByPlugin) {
294 const nestedByMessage = nest(items, 'message');
295 let lastUrl = '';
296 for (const { key: message, items } of nestedByMessage) {
297 title(`Plugin ${plugin}: ${message}`);
298 for (const warning of items) {
299 if (warning.url && warning.url !== lastUrl)
300 info((lastUrl = warning.url));
301 const id = warning.id || ((_a = warning.loc) === null || _a === void 0 ? void 0 : _a.file);
302 if (id) {
303 let loc = rollup.relativeId(id);
304 if (warning.loc) {
305 loc += `: (${warning.loc.line}:${warning.loc.column})`;
306 }
307 stderr(bold(loc));
308 }
309 if (warning.frame)
310 info(warning.frame);
311 }
312 }
313 }
314 },
315 SOURCEMAP_BROKEN(warnings) {
316 title(`Broken sourcemap`);
317 info('https://rollupjs.org/guide/en/#warning-sourcemap-is-likely-to-be-incorrect');
318 const plugins = [...new Set(warnings.map(({ plugin }) => plugin).filter(Boolean))];
319 stderr(`Plugins that transform code (such as ${rollup.printQuotedStringList(plugins)}) should generate accompanying sourcemaps`);
320 },
321 THIS_IS_UNDEFINED(warnings) {
322 title('`this` has been rewritten to `undefined`');
323 info('https://rollupjs.org/guide/en/#error-this-is-undefined');
324 showTruncatedWarnings(warnings);
325 },
326 UNRESOLVED_IMPORT(warnings) {
327 title('Unresolved dependencies');
328 info('https://rollupjs.org/guide/en/#warning-treating-module-as-external-dependency');
329 const dependencies = new Map();
330 for (const warning of warnings) {
331 rollup.getOrCreate(dependencies, warning.source, () => []).push(warning.importer);
332 }
333 for (const [dependency, importers] of dependencies) {
334 stderr(`${bold(dependency)} (imported by ${importers.join(', ')})`);
335 }
336 },
337 UNUSED_EXTERNAL_IMPORT(warnings) {
338 title('Unused external imports');
339 for (const warning of warnings) {
340 stderr(warning.names +
341 ' imported from external module "' +
342 warning.source +
343 '" but never used in ' +
344 rollup.printQuotedStringList(warning.sources.map(id => rollup.relativeId(id))));
345 }
346 }
347};
348function title(str) {
349 stderr(bold(yellow(`(!) ${str}`)));
350}
351function info(url) {
352 stderr(gray(url));
353}
354function nest(array, prop) {
355 const nested = [];
356 const lookup = new Map();
357 for (const item of array) {
358 const key = item[prop];
359 rollup.getOrCreate(lookup, key, () => {
360 const items = {
361 items: [],
362 key
363 };
364 nested.push(items);
365 return items;
366 }).items.push(item);
367 }
368 return nested;
369}
370function showTruncatedWarnings(warnings) {
371 const nestedByModule = nest(warnings, 'id');
372 const displayedByModule = nestedByModule.length > 5 ? nestedByModule.slice(0, 3) : nestedByModule;
373 for (const { key: id, items } of displayedByModule) {
374 stderr(bold(rollup.relativeId(id)));
375 stderr(gray(items[0].frame));
376 if (items.length > 1) {
377 stderr(`...and ${items.length - 1} other ${items.length > 2 ? 'occurrences' : 'occurrence'}`);
378 }
379 }
380 if (nestedByModule.length > displayedByModule.length) {
381 stderr(`\n...and ${nestedByModule.length - displayedByModule.length} other files`);
382 }
383}
384
385const stdinName = '-';
386let stdinResult = null;
387function stdinPlugin(arg) {
388 const suffix = typeof arg == 'string' && arg.length ? '.' + arg : '';
389 return {
390 load(id) {
391 if (id === stdinName || id.startsWith(stdinName + '.')) {
392 return stdinResult || (stdinResult = readStdin());
393 }
394 },
395 name: 'stdin',
396 resolveId(id) {
397 if (id === stdinName) {
398 return id + suffix;
399 }
400 }
401 };
402}
403function readStdin() {
404 return new Promise((resolve, reject) => {
405 const chunks = [];
406 process$1.stdin.setEncoding('utf8');
407 process$1.stdin
408 .on('data', chunk => chunks.push(chunk))
409 .on('end', () => {
410 const result = chunks.join('');
411 resolve(result);
412 })
413 .on('error', err => {
414 reject(err);
415 });
416 });
417}
418
419function waitForInputPlugin() {
420 return {
421 async buildStart(options) {
422 const inputSpecifiers = Array.isArray(options.input)
423 ? options.input
424 : Object.keys(options.input);
425 let lastAwaitedSpecifier = null;
426 checkSpecifiers: while (true) {
427 for (const specifier of inputSpecifiers) {
428 if ((await this.resolve(specifier)) === null) {
429 if (lastAwaitedSpecifier !== specifier) {
430 stderr(`waiting for input ${bold(specifier)}...`);
431 lastAwaitedSpecifier = specifier;
432 }
433 await new Promise(resolve => setTimeout(resolve, 500));
434 continue checkSpecifiers;
435 }
436 }
437 break;
438 }
439 },
440 name: 'wait-for-input'
441 };
442}
443
444async function addCommandPluginsToInputOptions(inputOptions, command) {
445 if (command.stdin !== false) {
446 inputOptions.plugins.push(stdinPlugin(command.stdin));
447 }
448 if (command.waitForBundleInput === true) {
449 inputOptions.plugins.push(waitForInputPlugin());
450 }
451 await addPluginsFromCommandOption(command.plugin, inputOptions);
452}
453async function addPluginsFromCommandOption(commandPlugin, inputOptions) {
454 if (commandPlugin) {
455 const plugins = Array.isArray(commandPlugin) ? commandPlugin : [commandPlugin];
456 for (const plugin of plugins) {
457 if (/[={}]/.test(plugin)) {
458 // -p plugin=value
459 // -p "{transform(c,i){...}}"
460 await loadAndRegisterPlugin(inputOptions, plugin);
461 }
462 else {
463 // split out plugins joined by commas
464 // -p node-resolve,commonjs,buble
465 for (const p of plugin.split(',')) {
466 await loadAndRegisterPlugin(inputOptions, p);
467 }
468 }
469 }
470 }
471}
472async function loadAndRegisterPlugin(inputOptions, pluginText) {
473 let plugin = null;
474 let pluginArg = undefined;
475 if (pluginText[0] === '{') {
476 // -p "{transform(c,i){...}}"
477 plugin = new Function('return ' + pluginText);
478 }
479 else {
480 const match = pluginText.match(/^([@.:/\\\w|^{}-]+)(=(.*))?$/);
481 if (match) {
482 // -p plugin
483 // -p plugin=arg
484 pluginText = match[1];
485 pluginArg = new Function('return ' + match[3])();
486 }
487 else {
488 throw new Error(`Invalid --plugin argument format: ${JSON.stringify(pluginText)}`);
489 }
490 if (!/^\.|^rollup-plugin-|[@/\\]/.test(pluginText)) {
491 // Try using plugin prefix variations first if applicable.
492 // Prefix order is significant - left has higher precedence.
493 for (const prefix of ['@rollup/plugin-', 'rollup-plugin-']) {
494 try {
495 plugin = await requireOrImport(prefix + pluginText);
496 break;
497 }
498 catch (_a) {
499 // if this does not work, we try requiring the actual name below
500 }
501 }
502 }
503 if (!plugin) {
504 try {
505 if (pluginText[0] == '.')
506 pluginText = require$$0.resolve(pluginText);
507 // Windows absolute paths must be specified as file:// protocol URL
508 // Note that we do not have coverage for Windows-only code paths
509 else if (pluginText.match(/^[A-Za-z]:\\/)) {
510 pluginText = url.pathToFileURL(require$$0.resolve(pluginText)).href;
511 }
512 plugin = await requireOrImport(pluginText);
513 }
514 catch (err) {
515 throw new Error(`Cannot load plugin "${pluginText}": ${err.message}.`);
516 }
517 }
518 }
519 // some plugins do not use `module.exports` for their entry point,
520 // in which case we try the named default export and the plugin name
521 if (typeof plugin === 'object') {
522 plugin = plugin.default || plugin[getCamelizedPluginBaseName(pluginText)];
523 }
524 if (!plugin) {
525 throw new Error(`Cannot find entry for plugin "${pluginText}". The plugin needs to export a function either as "default" or "${getCamelizedPluginBaseName(pluginText)}" for Rollup to recognize it.`);
526 }
527 inputOptions.plugins.push(typeof plugin === 'function' ? plugin.call(plugin, pluginArg) : plugin);
528}
529function getCamelizedPluginBaseName(pluginText) {
530 var _a;
531 return (((_a = pluginText.match(/(@rollup\/plugin-|rollup-plugin-)(.+)$/)) === null || _a === void 0 ? void 0 : _a[2]) || pluginText)
532 .split(/[\\/]/)
533 .slice(-1)[0]
534 .split('.')[0]
535 .split('-')
536 .map((part, index) => (index === 0 || !part ? part : part[0].toUpperCase() + part.slice(1)))
537 .join('');
538}
539async function requireOrImport(pluginPath) {
540 try {
541 return require(pluginPath);
542 }
543 catch (_a) {
544 return import(pluginPath);
545 }
546}
547
548function supportsNativeESM() {
549 return Number(/^v(\d+)/.exec(process$1.version)[1]) >= 13;
550}
551async function loadAndParseConfigFile(fileName, commandOptions = {}) {
552 const configs = await loadConfigFile(fileName, commandOptions);
553 const warnings = batchWarnings();
554 try {
555 const normalizedConfigs = [];
556 for (const config of configs) {
557 const options = mergeOptions.mergeOptions(config, commandOptions, warnings.add);
558 await addCommandPluginsToInputOptions(options, commandOptions);
559 normalizedConfigs.push(options);
560 }
561 return { options: normalizedConfigs, warnings };
562 }
563 catch (err) {
564 warnings.flush();
565 throw err;
566 }
567}
568async function loadConfigFile(fileName, commandOptions) {
569 const extension = require$$0.extname(fileName);
570 const configFileExport = commandOptions.configPlugin ||
571 !(extension === '.cjs' || (extension === '.mjs' && supportsNativeESM()))
572 ? await getDefaultFromTranspiledConfigFile(fileName, commandOptions)
573 : extension === '.cjs'
574 ? getDefaultFromCjs(require(fileName))
575 : (await import(url.pathToFileURL(fileName).href)).default;
576 return getConfigList(configFileExport, commandOptions);
577}
578function getDefaultFromCjs(namespace) {
579 return namespace.__esModule ? namespace.default : namespace;
580}
581async function getDefaultFromTranspiledConfigFile(fileName, commandOptions) {
582 const warnings = batchWarnings();
583 const inputOptions = {
584 external: (id) => (id[0] !== '.' && !require$$0.isAbsolute(id)) || id.slice(-5, id.length) === '.json',
585 input: fileName,
586 onwarn: warnings.add,
587 plugins: [],
588 treeshake: false
589 };
590 await addPluginsFromCommandOption(commandOptions.configPlugin, inputOptions);
591 const bundle = await rollup.rollup(inputOptions);
592 if (!commandOptions.silent && warnings.count > 0) {
593 stderr(bold(`loaded ${rollup.relativeId(fileName)} with warnings`));
594 warnings.flush();
595 }
596 const { output: [{ code }] } = await bundle.generate({
597 exports: 'named',
598 format: 'cjs',
599 plugins: [
600 {
601 name: 'transpile-import-meta',
602 resolveImportMeta(property, { moduleId }) {
603 if (property === 'url') {
604 return `'${url.pathToFileURL(moduleId).href}'`;
605 }
606 if (property == null) {
607 return `{url:'${url.pathToFileURL(moduleId).href}'}`;
608 }
609 }
610 }
611 ]
612 });
613 return loadConfigFromBundledFile(fileName, code);
614}
615function loadConfigFromBundledFile(fileName, bundledCode) {
616 const resolvedFileName = require.resolve(fileName);
617 const extension = require$$0.extname(resolvedFileName);
618 const defaultLoader = require.extensions[extension];
619 require.extensions[extension] = (module, requiredFileName) => {
620 if (requiredFileName === resolvedFileName) {
621 module._compile(bundledCode, requiredFileName);
622 }
623 else {
624 if (defaultLoader) {
625 defaultLoader(module, requiredFileName);
626 }
627 }
628 };
629 delete require.cache[resolvedFileName];
630 try {
631 const config = getDefaultFromCjs(require(fileName));
632 require.extensions[extension] = defaultLoader;
633 return config;
634 }
635 catch (err) {
636 if (err.code === 'ERR_REQUIRE_ESM') {
637 return rollup.error({
638 code: 'TRANSPILED_ESM_CONFIG',
639 message: `While loading the Rollup configuration from "${rollup.relativeId(fileName)}", Node tried to require an ES module from a CommonJS file, which is not supported. A common cause is if there is a package.json file with "type": "module" in the same folder. You can try to fix this by changing the extension of your configuration file to ".cjs" or ".mjs" depending on the content, which will prevent Rollup from trying to preprocess the file but rather hand it to Node directly.`,
640 url: 'https://rollupjs.org/guide/en/#using-untranspiled-config-files'
641 });
642 }
643 throw err;
644 }
645}
646async function getConfigList(configFileExport, commandOptions) {
647 const config = await (typeof configFileExport === 'function'
648 ? configFileExport(commandOptions)
649 : configFileExport);
650 if (Object.keys(config).length === 0) {
651 return rollup.error({
652 code: 'MISSING_CONFIG',
653 message: 'Config file must export an options object, or an array of options objects',
654 url: 'https://rollupjs.org/guide/en/#configuration-files'
655 });
656 }
657 return Array.isArray(config) ? config : [config];
658}
659
660exports.addCommandPluginsToInputOptions = addCommandPluginsToInputOptions;
661exports.batchWarnings = batchWarnings;
662exports.bold = bold;
663exports.cyan = cyan;
664exports.green = green;
665exports.handleError = handleError;
666exports.loadAndParseConfigFile = loadAndParseConfigFile;
667exports.stderr = stderr;
668exports.stdinName = stdinName;
669exports.underline = underline;
670//# sourceMappingURL=loadConfigFile.js.map
Note: See TracBrowser for help on using the repository browser.