Context Navigation

source: imaps-frontend/node_modules/vite/dist/node-cjs/publicUtils.cjs

main

Last change on this file was d565449, checked in by stefan toskovski <stefantoska84@…>, 4 weeks ago
Update repo after prototype presentation
Property mode set to `100644`
File size: 156.0 KB

Line
1	'use strict';
2
3	var path$3 = require('node:path');
4	var node_url = require('node:url');
5	var fs$1 = require('node:fs');
6	var esbuild = require('esbuild');
7	var node_module = require('node:module');
8	var require$$0 = require('tty');
9	var require$$1 = require('util');
10	var require$$0$1 = require('path');
11	var require$$0$2 = require('crypto');
12	var fs$2 = require('fs');
13	var readline = require('node:readline');
14	var require$$2 = require('os');
15
16	var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
17	const { version: version$2 } = JSON.parse(
18	fs$1.readFileSync(new URL("../../package.json", (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.src \|\| new URL('node-cjs/publicUtils.cjs', document.baseURI).href)))).toString()
19	);
20	const VERSION = version$2;
21	const FS_PREFIX = `/@fs/`;
22	const VITE_PACKAGE_DIR = path$3.resolve(
23	// import.meta.url is `dist/node/constants.js` after bundle
24	node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.src \|\| new URL('node-cjs/publicUtils.cjs', document.baseURI).href))),
25	"../../.."
26	);
27	const CLIENT_ENTRY = path$3.resolve(VITE_PACKAGE_DIR, "dist/client/client.mjs");
28	path$3.resolve(VITE_PACKAGE_DIR, "dist/client/env.mjs");
29	path$3.dirname(CLIENT_ENTRY);
30
31	const comma = ','.charCodeAt(0);
32	const semicolon = ';'.charCodeAt(0);
33	const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
34	const intToChar = new Uint8Array(64); // 64 possible chars.
35	const charToInt = new Uint8Array(128); // z is 122 in ASCII
36	for (let i = 0; i < chars.length; i++) {
37	const c = chars.charCodeAt(i);
38	intToChar[i] = c;
39	charToInt[c] = i;
40	}
41	// Provide a fallback for older environments.
42	const td = typeof TextDecoder !== 'undefined'
43	? /* #__PURE__ */ new TextDecoder()
44	: typeof Buffer !== 'undefined'
45	? {
46	decode(buf) {
47	const out = Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength);
48	return out.toString();
49	},
50	}
51	: {
52	decode(buf) {
53	let out = '';
54	for (let i = 0; i < buf.length; i++) {
55	out += String.fromCharCode(buf[i]);
56	}
57	return out;
58	},
59	};
60	function encode(decoded) {
61	const state = new Int32Array(5);
62	const bufLength = 1024 * 16;
63	const subLength = bufLength - 36;
64	const buf = new Uint8Array(bufLength);
65	const sub = buf.subarray(0, subLength);
66	let pos = 0;
67	let out = '';
68	for (let i = 0; i < decoded.length; i++) {
69	const line = decoded[i];
70	if (i > 0) {
71	if (pos === bufLength) {
72	out += td.decode(buf);
73	pos = 0;
74	}
75	buf[pos++] = semicolon;
76	}
77	if (line.length === 0)
78	continue;
79	state[0] = 0;
80	for (let j = 0; j < line.length; j++) {
81	const segment = line[j];
82	// We can push up to 5 ints, each int can take at most 7 chars, and we
83	// may push a comma.
84	if (pos > subLength) {
85	out += td.decode(sub);
86	buf.copyWithin(0, subLength, pos);
87	pos -= subLength;
88	}
89	if (j > 0)
90	buf[pos++] = comma;
91	pos = encodeInteger(buf, pos, state, segment, 0); // genColumn
92	if (segment.length === 1)
93	continue;
94	pos = encodeInteger(buf, pos, state, segment, 1); // sourcesIndex
95	pos = encodeInteger(buf, pos, state, segment, 2); // sourceLine
96	pos = encodeInteger(buf, pos, state, segment, 3); // sourceColumn
97	if (segment.length === 4)
98	continue;
99	pos = encodeInteger(buf, pos, state, segment, 4); // namesIndex
100	}
101	}
102	return out + td.decode(buf.subarray(0, pos));
103	}
104	function encodeInteger(buf, pos, state, segment, j) {
105	const next = segment[j];
106	let num = next - state[j];
107	state[j] = next;
108	num = num < 0 ? (-num << 1) \| 1 : num << 1;
109	do {
110	let clamped = num & 0b011111;
111	num >>>= 5;
112	if (num > 0)
113	clamped \|= 0b100000;
114	buf[pos++] = intToChar[clamped];
115	} while (num > 0);
116	return pos;
117	}
118
119	function getDefaultExportFromCjs (x) {
120	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
121	}
122
123	function commonjsRequire(path) {
124	throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
125	}
126
127	var picocolors = {exports: {}};
128
129	let argv = process.argv \|\| [],
130	env = process.env;
131	let isColorSupported =
132	!("NO_COLOR" in env \|\| argv.includes("--no-color")) &&
133	("FORCE_COLOR" in env \|\|
134	argv.includes("--color") \|\|
135	process.platform === "win32" \|\|
136	(commonjsRequire != null && require$$0.isatty(1) && env.TERM !== "dumb") \|\|
137	"CI" in env);
138
139	let formatter =
140	(open, close, replace = open) =>
141	input => {
142	let string = "" + input;
143	let index = string.indexOf(close, open.length);
144	return ~index
145	? open + replaceClose(string, close, replace, index) + close
146	: open + string + close
147	};
148
149	let replaceClose = (string, close, replace, index) => {
150	let result = "";
151	let cursor = 0;
152	do {
153	result += string.substring(cursor, index) + replace;
154	cursor = index + close.length;
155	index = string.indexOf(close, cursor);
156	} while (~index)
157	return result + string.substring(cursor)
158	};
159
160	let createColors = (enabled = isColorSupported) => {
161	let init = enabled ? formatter : () => String;
162	return {
163	isColorSupported: enabled,
164	reset: init("\x1b[0m", "\x1b[0m"),
165	bold: init("\x1b[1m", "\x1b[22m", "\x1b[22m\x1b[1m"),
166	dim: init("\x1b[2m", "\x1b[22m", "\x1b[22m\x1b[2m"),
167	italic: init("\x1b[3m", "\x1b[23m"),
168	underline: init("\x1b[4m", "\x1b[24m"),
169	inverse: init("\x1b[7m", "\x1b[27m"),
170	hidden: init("\x1b[8m", "\x1b[28m"),
171	strikethrough: init("\x1b[9m", "\x1b[29m"),
172	black: init("\x1b[30m", "\x1b[39m"),
173	red: init("\x1b[31m", "\x1b[39m"),
174	green: init("\x1b[32m", "\x1b[39m"),
175	yellow: init("\x1b[33m", "\x1b[39m"),
176	blue: init("\x1b[34m", "\x1b[39m"),
177	magenta: init("\x1b[35m", "\x1b[39m"),
178	cyan: init("\x1b[36m", "\x1b[39m"),
179	white: init("\x1b[37m", "\x1b[39m"),
180	gray: init("\x1b[90m", "\x1b[39m"),
181	bgBlack: init("\x1b[40m", "\x1b[49m"),
182	bgRed: init("\x1b[41m", "\x1b[49m"),
183	bgGreen: init("\x1b[42m", "\x1b[49m"),
184	bgYellow: init("\x1b[43m", "\x1b[49m"),
185	bgBlue: init("\x1b[44m", "\x1b[49m"),
186	bgMagenta: init("\x1b[45m", "\x1b[49m"),
187	bgCyan: init("\x1b[46m", "\x1b[49m"),
188	bgWhite: init("\x1b[47m", "\x1b[49m"),
189	}
190	};
191
192	picocolors.exports = createColors();
193	picocolors.exports.createColors = createColors;
194
195	var picocolorsExports = picocolors.exports;
196	var colors = /@__PURE__/getDefaultExportFromCjs(picocolorsExports);
197
198	var src = {exports: {}};
199
200	var browser$1 = {exports: {}};
201
202	/**
203	* Helpers.
204	*/
205
206	var ms;
207	var hasRequiredMs;
208
209	function requireMs () {
210	if (hasRequiredMs) return ms;
211	hasRequiredMs = 1;
212	var s = 1000;
213	var m = s * 60;
214	var h = m * 60;
215	var d = h * 24;
216	var w = d * 7;
217	var y = d * 365.25;
218
219	/**
220	* Parse or format the given `val`.
221	*
222	* Options:
223	*
224	* - `long` verbose formatting [false]
225	*
226	* @param {String\|Number} val
227	* @param {Object} [options]
228	* @throws {Error} throw an error if val is not a non-empty string or a number
229	* @return {String\|Number}
230	* @api public
231	*/
232
233	ms = function(val, options) {
234	options = options \|\| {};
235	var type = typeof val;
236	if (type === 'string' && val.length > 0) {
237	return parse(val);
238	} else if (type === 'number' && isFinite(val)) {
239	return options.long ? fmtLong(val) : fmtShort(val);
240	}
241	throw new Error(
242	'val is not a non-empty string or a valid number. val=' +
243	JSON.stringify(val)
244	);
245	};
246
247	/**
248	* Parse the given `str` and return milliseconds.
249	*
250	* @param {String} str
251	* @return {Number}
252	* @api private
253	*/
254
255	function parse(str) {
256	str = String(str);
257	if (str.length > 100) {
258	return;
259	}
260	var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?\|msecs?\|ms\|seconds?\|secs?\|s\|minutes?\|mins?\|m\|hours?\|hrs?\|h\|days?\|d\|weeks?\|w\|years?\|yrs?\|y)?$/i.exec(
261	str
262	);
263	if (!match) {
264	return;
265	}
266	var n = parseFloat(match[1]);
267	var type = (match[2] \|\| 'ms').toLowerCase();
268	switch (type) {
269	case 'years':
270	case 'year':
271	case 'yrs':
272	case 'yr':
273	case 'y':
274	return n * y;
275	case 'weeks':
276	case 'week':
277	case 'w':
278	return n * w;
279	case 'days':
280	case 'day':
281	case 'd':
282	return n * d;
283	case 'hours':
284	case 'hour':
285	case 'hrs':
286	case 'hr':
287	case 'h':
288	return n * h;
289	case 'minutes':
290	case 'minute':
291	case 'mins':
292	case 'min':
293	case 'm':
294	return n * m;
295	case 'seconds':
296	case 'second':
297	case 'secs':
298	case 'sec':
299	case 's':
300	return n * s;
301	case 'milliseconds':
302	case 'millisecond':
303	case 'msecs':
304	case 'msec':
305	case 'ms':
306	return n;
307	default:
308	return undefined;
309	}
310	}
311
312	/**
313	* Short format for `ms`.
314	*
315	* @param {Number} ms
316	* @return {String}
317	* @api private
318	*/
319
320	function fmtShort(ms) {
321	var msAbs = Math.abs(ms);
322	if (msAbs >= d) {
323	return Math.round(ms / d) + 'd';
324	}
325	if (msAbs >= h) {
326	return Math.round(ms / h) + 'h';
327	}
328	if (msAbs >= m) {
329	return Math.round(ms / m) + 'm';
330	}
331	if (msAbs >= s) {
332	return Math.round(ms / s) + 's';
333	}
334	return ms + 'ms';
335	}
336
337	/**
338	* Long format for `ms`.
339	*
340	* @param {Number} ms
341	* @return {String}
342	* @api private
343	*/
344
345	function fmtLong(ms) {
346	var msAbs = Math.abs(ms);
347	if (msAbs >= d) {
348	return plural(ms, msAbs, d, 'day');
349	}
350	if (msAbs >= h) {
351	return plural(ms, msAbs, h, 'hour');
352	}
353	if (msAbs >= m) {
354	return plural(ms, msAbs, m, 'minute');
355	}
356	if (msAbs >= s) {
357	return plural(ms, msAbs, s, 'second');
358	}
359	return ms + ' ms';
360	}
361
362	/**
363	* Pluralization helper.
364	*/
365
366	function plural(ms, msAbs, n, name) {
367	var isPlural = msAbs >= n * 1.5;
368	return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');
369	}
370	return ms;
371	}
372
373	var common;
374	var hasRequiredCommon;
375
376	function requireCommon () {
377	if (hasRequiredCommon) return common;
378	hasRequiredCommon = 1;
379	/**
380	* This is the common logic for both the Node.js and web browser
381	* implementations of `debug()`.
382	*/
383
384	function setup(env) {
385	createDebug.debug = createDebug;
386	createDebug.default = createDebug;
387	createDebug.coerce = coerce;
388	createDebug.disable = disable;
389	createDebug.enable = enable;
390	createDebug.enabled = enabled;
391	createDebug.humanize = requireMs();
392	createDebug.destroy = destroy;
393
394	Object.keys(env).forEach(key => {
395	createDebug[key] = env[key];
396	});
397
398	/**
399	* The currently active debug mode names, and names to skip.
400	*/
401
402	createDebug.names = [];
403	createDebug.skips = [];
404
405	/**
406	* Map of special "%n" handling functions, for the debug "format" argument.
407	*
408	* Valid key names are a single, lower or upper-case letter, i.e. "n" and "N".
409	*/
410	createDebug.formatters = {};
411
412	/**
413	* Selects a color for a debug namespace
414	* @param {String} namespace The namespace string for the debug instance to be colored
415	* @return {Number\|String} An ANSI color code for the given namespace
416	* @api private
417	*/
418	function selectColor(namespace) {
419	let hash = 0;
420
421	for (let i = 0; i < namespace.length; i++) {
422	hash = ((hash << 5) - hash) + namespace.charCodeAt(i);
423	hash \|= 0; // Convert to 32bit integer
424	}
425
426	return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
427	}
428	createDebug.selectColor = selectColor;
429
430	/**
431	* Create a debugger with the given `namespace`.
432	*
433	* @param {String} namespace
434	* @return {Function}
435	* @api public
436	*/
437	function createDebug(namespace) {
438	let prevTime;
439	let enableOverride = null;
440	let namespacesCache;
441	let enabledCache;
442
443	function debug(...args) {
444	// Disabled?
445	if (!debug.enabled) {
446	return;
447	}
448
449	const self = debug;
450
451	// Set `diff` timestamp
452	const curr = Number(new Date());
453	const ms = curr - (prevTime \|\| curr);
454	self.diff = ms;
455	self.prev = prevTime;
456	self.curr = curr;
457	prevTime = curr;
458
459	args[0] = createDebug.coerce(args[0]);
460
461	if (typeof args[0] !== 'string') {
462	// Anything else let's inspect with %O
463	args.unshift('%O');
464	}
465
466	// Apply any `formatters` transformations
467	let index = 0;
468	args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
469	// If we encounter an escaped % then don't increase the array index
470	if (match === '%%') {
471	return '%';
472	}
473	index++;
474	const formatter = createDebug.formatters[format];
475	if (typeof formatter === 'function') {
476	const val = args[index];
477	match = formatter.call(self, val);
478
479	// Now we need to remove `args[index]` since it's inlined in the `format`
480	args.splice(index, 1);
481	index--;
482	}
483	return match;
484	});
485
486	// Apply env-specific formatting (colors, etc.)
487	createDebug.formatArgs.call(self, args);
488
489	const logFn = self.log \|\| createDebug.log;
490	logFn.apply(self, args);
491	}
492
493	debug.namespace = namespace;
494	debug.useColors = createDebug.useColors();
495	debug.color = createDebug.selectColor(namespace);
496	debug.extend = extend;
497	debug.destroy = createDebug.destroy; // XXX Temporary. Will be removed in the next major release.
498
499	Object.defineProperty(debug, 'enabled', {
500	enumerable: true,
501	configurable: false,
502	get: () => {
503	if (enableOverride !== null) {
504	return enableOverride;
505	}
506	if (namespacesCache !== createDebug.namespaces) {
507	namespacesCache = createDebug.namespaces;
508	enabledCache = createDebug.enabled(namespace);
509	}
510
511	return enabledCache;
512	},
513	set: v => {
514	enableOverride = v;
515	}
516	});
517
518	// Env-specific initialization logic for debug instances
519	if (typeof createDebug.init === 'function') {
520	createDebug.init(debug);
521	}
522
523	return debug;
524	}
525
526	function extend(namespace, delimiter) {
527	const newDebug = createDebug(this.namespace + (typeof delimiter === 'undefined' ? ':' : delimiter) + namespace);
528	newDebug.log = this.log;
529	return newDebug;
530	}
531
532	/**
533	* Enables a debug mode by namespaces. This can include modes
534	* separated by a colon and wildcards.
535	*
536	* @param {String} namespaces
537	* @api public
538	*/
539	function enable(namespaces) {
540	createDebug.save(namespaces);
541	createDebug.namespaces = namespaces;
542
543	createDebug.names = [];
544	createDebug.skips = [];
545
546	let i;
547	const split = (typeof namespaces === 'string' ? namespaces : '').split(/[\s,]+/);
548	const len = split.length;
549
550	for (i = 0; i < len; i++) {
551	if (!split[i]) {
552	// ignore empty strings
553	continue;
554	}
555
556	namespaces = split[i].replace(/\/g, '.?');
557
558	if (namespaces[0] === '-') {
559	createDebug.skips.push(new RegExp('^' + namespaces.slice(1) + '$'));
560	} else {
561	createDebug.names.push(new RegExp('^' + namespaces + '$'));
562	}
563	}
564	}
565
566	/**
567	* Disable debug output.
568	*
569	* @return {String} namespaces
570	* @api public
571	*/
572	function disable() {
573	const namespaces = [
574	...createDebug.names.map(toNamespace),
575	...createDebug.skips.map(toNamespace).map(namespace => '-' + namespace)
576	].join(',');
577	createDebug.enable('');
578	return namespaces;
579	}
580
581	/**
582	* Returns true if the given mode name is enabled, false otherwise.
583	*
584	* @param {String} name
585	* @return {Boolean}
586	* @api public
587	*/
588	function enabled(name) {
589	if (name[name.length - 1] === '*') {
590	return true;
591	}
592
593	let i;
594	let len;
595
596	for (i = 0, len = createDebug.skips.length; i < len; i++) {
597	if (createDebug.skips[i].test(name)) {
598	return false;
599	}
600	}
601
602	for (i = 0, len = createDebug.names.length; i < len; i++) {
603	if (createDebug.names[i].test(name)) {
604	return true;
605	}
606	}
607
608	return false;
609	}
610
611	/**
612	* Convert regexp to namespace
613	*
614	* @param {RegExp} regxep
615	* @return {String} namespace
616	* @api private
617	*/
618	function toNamespace(regexp) {
619	return regexp.toString()
620	.substring(2, regexp.toString().length - 2)
621	.replace(/\.\\?$/, '');
622	}
623
624	/**
625	* Coerce `val`.
626	*
627	* @param {Mixed} val
628	* @return {Mixed}
629	* @api private
630	*/
631	function coerce(val) {
632	if (val instanceof Error) {
633	return val.stack \|\| val.message;
634	}
635	return val;
636	}
637
638	/**
639	* XXX DO NOT USE. This is a temporary stub function.
640	* XXX It WILL be removed in the next major release.
641	*/
642	function destroy() {
643	console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
644	}
645
646	createDebug.enable(createDebug.load());
647
648	return createDebug;
649	}
650
651	common = setup;
652	return common;
653	}
654
655	/* eslint-env browser */
656
657	var hasRequiredBrowser;
658
659	function requireBrowser () {
660	if (hasRequiredBrowser) return browser$1.exports;
661	hasRequiredBrowser = 1;
662	(function (module, exports) {
663	/**
664	* This is the web browser implementation of `debug()`.
665	*/
666
667	exports.formatArgs = formatArgs;
668	exports.save = save;
669	exports.load = load;
670	exports.useColors = useColors;
671	exports.storage = localstorage();
672	exports.destroy = (() => {
673	let warned = false;
674
675	return () => {
676	if (!warned) {
677	warned = true;
678	console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
679	}
680	};
681	})();
682
683	/**
684	* Colors.
685	*/
686
687	exports.colors = [
688	'#0000CC',
689	'#0000FF',
690	'#0033CC',
691	'#0033FF',
692	'#0066CC',
693	'#0066FF',
694	'#0099CC',
695	'#0099FF',
696	'#00CC00',
697	'#00CC33',
698	'#00CC66',
699	'#00CC99',
700	'#00CCCC',
701	'#00CCFF',
702	'#3300CC',
703	'#3300FF',
704	'#3333CC',
705	'#3333FF',
706	'#3366CC',
707	'#3366FF',
708	'#3399CC',
709	'#3399FF',
710	'#33CC00',
711	'#33CC33',
712	'#33CC66',
713	'#33CC99',
714	'#33CCCC',
715	'#33CCFF',
716	'#6600CC',
717	'#6600FF',
718	'#6633CC',
719	'#6633FF',
720	'#66CC00',
721	'#66CC33',
722	'#9900CC',
723	'#9900FF',
724	'#9933CC',
725	'#9933FF',
726	'#99CC00',
727	'#99CC33',
728	'#CC0000',
729	'#CC0033',
730	'#CC0066',
731	'#CC0099',
732	'#CC00CC',
733	'#CC00FF',
734	'#CC3300',
735	'#CC3333',
736	'#CC3366',
737	'#CC3399',
738	'#CC33CC',
739	'#CC33FF',
740	'#CC6600',
741	'#CC6633',
742	'#CC9900',
743	'#CC9933',
744	'#CCCC00',
745	'#CCCC33',
746	'#FF0000',
747	'#FF0033',
748	'#FF0066',
749	'#FF0099',
750	'#FF00CC',
751	'#FF00FF',
752	'#FF3300',
753	'#FF3333',
754	'#FF3366',
755	'#FF3399',
756	'#FF33CC',
757	'#FF33FF',
758	'#FF6600',
759	'#FF6633',
760	'#FF9900',
761	'#FF9933',
762	'#FFCC00',
763	'#FFCC33'
764	];
765
766	/**
767	* Currently only WebKit-based Web Inspectors, Firefox >= v31,
768	* and the Firebug extension (any Firefox version) are known
769	* to support "%c" CSS customizations.
770	*
771	* TODO: add a `localStorage` variable to explicitly enable/disable colors
772	*/
773
774	// eslint-disable-next-line complexity
775	function useColors() {
776	// NB: In an Electron preload script, document will be defined but not fully
777	// initialized. Since we know we're in Chrome, we'll just detect this case
778	// explicitly
779	if (typeof window !== 'undefined' && window.process && (window.process.type === 'renderer' \|\| window.process.__nwjs)) {
780	return true;
781	}
782
783	// Internet Explorer and Edge do not support colors.
784	if (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge\|trident)\/(\d+)/)) {
785	return false;
786	}
787
788	// Is webkit? http://stackoverflow.com/a/16459606/376773
789	// document is undefined in react-native: https://github.com/facebook/react-native/pull/1632
790	return (typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance) \|\|
791	// Is firebug? http://stackoverflow.com/a/398120/376773
792	(typeof window !== 'undefined' && window.console && (window.console.firebug \|\| (window.console.exception && window.console.table))) \|\|
793	// Is firefox >= v31?
794	// https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
795	(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31) \|\|
796	// Double check webkit in userAgent just in case we are in a worker
797	(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/));
798	}
799
800	/**
801	* Colorize log arguments if enabled.
802	*
803	* @api public
804	*/
805
806	function formatArgs(args) {
807	args[0] = (this.useColors ? '%c' : '') +
808	this.namespace +
809	(this.useColors ? ' %c' : ' ') +
810	args[0] +
811	(this.useColors ? '%c ' : ' ') +
812	'+' + module.exports.humanize(this.diff);
813
814	if (!this.useColors) {
815	return;
816	}
817
818	const c = 'color: ' + this.color;
819	args.splice(1, 0, c, 'color: inherit');
820
821	// The final "%c" is somewhat tricky, because there could be other
822	// arguments passed either before or after the %c, so we need to
823	// figure out the correct index to insert the CSS into
824	let index = 0;
825	let lastC = 0;
826	args[0].replace(/%[a-zA-Z%]/g, match => {
827	if (match === '%%') {
828	return;
829	}
830	index++;
831	if (match === '%c') {
832	// We only are interested in the last %c
833	// (the user may have provided their own)
834	lastC = index;
835	}
836	});
837
838	args.splice(lastC, 0, c);
839	}
840
841	/**
842	* Invokes `console.debug()` when available.
843	* No-op when `console.debug` is not a "function".
844	* If `console.debug` is not available, falls back
845	* to `console.log`.
846	*
847	* @api public
848	*/
849	exports.log = console.debug \|\| console.log \|\| (() => {});
850
851	/**
852	* Save `namespaces`.
853	*
854	* @param {String} namespaces
855	* @api private
856	*/
857	function save(namespaces) {
858	try {
859	if (namespaces) {
860	exports.storage.setItem('debug', namespaces);
861	} else {
862	exports.storage.removeItem('debug');
863	}
864	} catch (error) {
865	// Swallow
866	// XXX (@Qix-) should we be logging these?
867	}
868	}
869
870	/**
871	* Load `namespaces`.
872	*
873	* @return {String} returns the previously persisted debug modes
874	* @api private
875	*/
876	function load() {
877	let r;
878	try {
879	r = exports.storage.getItem('debug');
880	} catch (error) {
881	// Swallow
882	// XXX (@Qix-) should we be logging these?
883	}
884
885	// If debug isn't set in LS, and we're in Electron, try to load $DEBUG
886	if (!r && typeof process !== 'undefined' && 'env' in process) {
887	r = process.env.DEBUG;
888	}
889
890	return r;
891	}
892
893	/**
894	* Localstorage attempts to return the localstorage.
895	*
896	* This is necessary because safari throws
897	* when a user disables cookies/localstorage
898	* and you attempt to access it.
899	*
900	* @return {LocalStorage}
901	* @api private
902	*/
903
904	function localstorage() {
905	try {
906	// TVMLKit (Apple TV JS Runtime) does not have a window object, just localStorage in the global context
907	// The Browser also has localStorage in the global context.
908	return localStorage;
909	} catch (error) {
910	// Swallow
911	// XXX (@Qix-) should we be logging these?
912	}
913	}
914
915	module.exports = requireCommon()(exports);
916
917	const {formatters} = module.exports;
918
919	/**
920	* Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
921	*/
922
923	formatters.j = function (v) {
924	try {
925	return JSON.stringify(v);
926	} catch (error) {
927	return '[UnexpectedJSONParseError]: ' + error.message;
928	}
929	};
930	} (browser$1, browser$1.exports));
931	return browser$1.exports;
932	}
933
934	var node = {exports: {}};
935
936	/**
937	* Module dependencies.
938	*/
939
940	var hasRequiredNode;
941
942	function requireNode () {
943	if (hasRequiredNode) return node.exports;
944	hasRequiredNode = 1;
945	(function (module, exports) {
946	const tty = require$$0;
947	const util = require$$1;
948
949	/**
950	* This is the Node.js implementation of `debug()`.
951	*/
952
953	exports.init = init;
954	exports.log = log;
955	exports.formatArgs = formatArgs;
956	exports.save = save;
957	exports.load = load;
958	exports.useColors = useColors;
959	exports.destroy = util.deprecate(
960	() => {},
961	'Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.'
962	);
963
964	/**
965	* Colors.
966	*/
967
968	exports.colors = [6, 2, 3, 4, 5, 1];
969
970	try {
971	// Optional dependency (as in, doesn't need to be installed, NOT like optionalDependencies in package.json)
972	// eslint-disable-next-line import/no-extraneous-dependencies
973	const supportsColor = require('supports-color');
974
975	if (supportsColor && (supportsColor.stderr \|\| supportsColor).level >= 2) {
976	exports.colors = [
977	20,
978	21,
979	26,
980	27,
981	32,
982	33,
983	38,
984	39,
985	40,
986	41,
987	42,
988	43,
989	44,
990	45,
991	56,
992	57,
993	62,
994	63,
995	68,
996	69,
997	74,
998	75,
999	76,
1000	77,
1001	78,
1002	79,
1003	80,
1004	81,
1005	92,
1006	93,
1007	98,
1008	99,
1009	112,
1010	113,
1011	128,
1012	129,
1013	134,
1014	135,
1015	148,
1016	149,
1017	160,
1018	161,
1019	162,
1020	163,
1021	164,
1022	165,
1023	166,
1024	167,
1025	168,
1026	169,
1027	170,
1028	171,
1029	172,
1030	173,
1031	178,
1032	179,
1033	184,
1034	185,
1035	196,
1036	197,
1037	198,
1038	199,
1039	200,
1040	201,
1041	202,
1042	203,
1043	204,
1044	205,
1045	206,
1046	207,
1047	208,
1048	209,
1049	214,
1050	215,
1051	220,
1052	221
1053	];
1054	}
1055	} catch (error) {
1056	// Swallow - we only care if `supports-color` is available; it doesn't have to be.
1057	}
1058
1059	/**
1060	* Build up the default `inspectOpts` object from the environment variables.
1061	*
1062	* $ DEBUG_COLORS=no DEBUG_DEPTH=10 DEBUG_SHOW_HIDDEN=enabled node script.js
1063	*/
1064
1065	exports.inspectOpts = Object.keys(process.env).filter(key => {
1066	return /^debug_/i.test(key);
1067	}).reduce((obj, key) => {
1068	// Camel-case
1069	const prop = key
1070	.substring(6)
1071	.toLowerCase()
1072	.replace(/_([a-z])/g, (_, k) => {
1073	return k.toUpperCase();
1074	});
1075
1076	// Coerce string value into JS value
1077	let val = process.env[key];
1078	if (/^(yes\|on\|true\|enabled)$/i.test(val)) {
1079	val = true;
1080	} else if (/^(no\|off\|false\|disabled)$/i.test(val)) {
1081	val = false;
1082	} else if (val === 'null') {
1083	val = null;
1084	} else {
1085	val = Number(val);
1086	}
1087
1088	obj[prop] = val;
1089	return obj;
1090	}, {});
1091
1092	/**
1093	* Is stdout a TTY? Colored output is enabled when `true`.
1094	*/
1095
1096	function useColors() {
1097	return 'colors' in exports.inspectOpts ?
1098	Boolean(exports.inspectOpts.colors) :
1099	tty.isatty(process.stderr.fd);
1100	}
1101
1102	/**
1103	* Adds ANSI color escape codes if enabled.
1104	*
1105	* @api public
1106	*/
1107
1108	function formatArgs(args) {
1109	const {namespace: name, useColors} = this;
1110
1111	if (useColors) {
1112	const c = this.color;
1113	const colorCode = '\u001B[3' + (c < 8 ? c : '8;5;' + c);
1114	const prefix = ` ${colorCode};1m${name} \u001B[0m`;
1115
1116	args[0] = prefix + args[0].split('\n').join('\n' + prefix);
1117	args.push(colorCode + 'm+' + module.exports.humanize(this.diff) + '\u001B[0m');
1118	} else {
1119	args[0] = getDate() + name + ' ' + args[0];
1120	}
1121	}
1122
1123	function getDate() {
1124	if (exports.inspectOpts.hideDate) {
1125	return '';
1126	}
1127	return new Date().toISOString() + ' ';
1128	}
1129
1130	/**
1131	* Invokes `util.formatWithOptions()` with the specified arguments and writes to stderr.
1132	*/
1133
1134	function log(...args) {
1135	return process.stderr.write(util.formatWithOptions(exports.inspectOpts, ...args) + '\n');
1136	}
1137
1138	/**
1139	* Save `namespaces`.
1140	*
1141	* @param {String} namespaces
1142	* @api private
1143	*/
1144	function save(namespaces) {
1145	if (namespaces) {
1146	process.env.DEBUG = namespaces;
1147	} else {
1148	// If you set a process.env field to null or undefined, it gets cast to the
1149	// string 'null' or 'undefined'. Just delete instead.
1150	delete process.env.DEBUG;
1151	}
1152	}
1153
1154	/**
1155	* Load `namespaces`.
1156	*
1157	* @return {String} returns the previously persisted debug modes
1158	* @api private
1159	*/
1160
1161	function load() {
1162	return process.env.DEBUG;
1163	}
1164
1165	/**
1166	* Init logic for `debug` instances.
1167	*
1168	* Create a new `inspectOpts` object in case `useColors` is set
1169	* differently for a particular `debug` instance.
1170	*/
1171
1172	function init(debug) {
1173	debug.inspectOpts = {};
1174
1175	const keys = Object.keys(exports.inspectOpts);
1176	for (let i = 0; i < keys.length; i++) {
1177	debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
1178	}
1179	}
1180
1181	module.exports = requireCommon()(exports);
1182
1183	const {formatters} = module.exports;
1184
1185	/**
1186	* Map %o to `util.inspect()`, all on a single line.
1187	*/
1188
1189	formatters.o = function (v) {
1190	this.inspectOpts.colors = this.useColors;
1191	return util.inspect(v, this.inspectOpts)
1192	.split('\n')
1193	.map(str => str.trim())
1194	.join(' ');
1195	};
1196
1197	/**
1198	* Map %O to `util.inspect()`, allowing multiple lines if needed.
1199	*/
1200
1201	formatters.O = function (v) {
1202	this.inspectOpts.colors = this.useColors;
1203	return util.inspect(v, this.inspectOpts);
1204	};
1205	} (node, node.exports));
1206	return node.exports;
1207	}
1208
1209	/**
1210	* Detect Electron renderer / nwjs process, which is node, but we should
1211	* treat as a browser.
1212	*/
1213
1214	if (typeof process === 'undefined' \|\| process.type === 'renderer' \|\| process.browser === true \|\| process.__nwjs) {
1215	src.exports = requireBrowser();
1216	} else {
1217	src.exports = requireNode();
1218	}
1219
1220	var srcExports = src.exports;
1221	var debug$2 = /@__PURE__/getDefaultExportFromCjs(srcExports);
1222
1223	var utils$3 = {};
1224
1225	const path$2 = require$$0$1;
1226	const WIN_SLASH = '\\\\/';
1227	const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
1228
1229	/**
1230	* Posix glob regex
1231	*/
1232
1233	const DOT_LITERAL = '\\.';
1234	const PLUS_LITERAL = '\\+';
1235	const QMARK_LITERAL = '\\?';
1236	const SLASH_LITERAL = '\\/';
1237	const ONE_CHAR = '(?=.)';
1238	const QMARK = '[^/]';
1239	const END_ANCHOR = `(?:${SLASH_LITERAL}\|$)`;
1240	const START_ANCHOR = `(?:^\|${SLASH_LITERAL})`;
1241	const DOTS_SLASH = `${DOT_LITERAL}{1,2}${END_ANCHOR}`;
1242	const NO_DOT = `(?!${DOT_LITERAL})`;
1243	const NO_DOTS = `(?!${START_ANCHOR}${DOTS_SLASH})`;
1244	const NO_DOT_SLASH = `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`;
1245	const NO_DOTS_SLASH = `(?!${DOTS_SLASH})`;
1246	const QMARK_NO_DOT = `[^.${SLASH_LITERAL}]`;
1247	const STAR = `${QMARK}*?`;
1248
1249	const POSIX_CHARS = {
1250	DOT_LITERAL,
1251	PLUS_LITERAL,
1252	QMARK_LITERAL,
1253	SLASH_LITERAL,
1254	ONE_CHAR,
1255	QMARK,
1256	END_ANCHOR,
1257	DOTS_SLASH,
1258	NO_DOT,
1259	NO_DOTS,
1260	NO_DOT_SLASH,
1261	NO_DOTS_SLASH,
1262	QMARK_NO_DOT,
1263	STAR,
1264	START_ANCHOR
1265	};
1266
1267	/**
1268	* Windows glob regex
1269	*/
1270
1271	const WINDOWS_CHARS = {
1272	...POSIX_CHARS,
1273
1274	SLASH_LITERAL: `[${WIN_SLASH}]`,
1275	QMARK: WIN_NO_SLASH,
1276	STAR: `${WIN_NO_SLASH}*?`,
1277	DOTS_SLASH: `${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]\|$)`,
1278	NO_DOT: `(?!${DOT_LITERAL})`,
1279	NO_DOTS: `(?!(?:^\|[${WIN_SLASH}])${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]\|$))`,
1280	NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}(?:[${WIN_SLASH}]\|$))`,
1281	NO_DOTS_SLASH: `(?!${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]\|$))`,
1282	QMARK_NO_DOT: `[^.${WIN_SLASH}]`,
1283	START_ANCHOR: `(?:^\|[${WIN_SLASH}])`,
1284	END_ANCHOR: `(?:[${WIN_SLASH}]\|$)`
1285	};
1286
1287	/**
1288	* POSIX Bracket Regex
1289	*/
1290
1291	const POSIX_REGEX_SOURCE$1 = {
1292	alnum: 'a-zA-Z0-9',
1293	alpha: 'a-zA-Z',
1294	ascii: '\\x00-\\x7F',
1295	blank: ' \\t',
1296	cntrl: '\\x00-\\x1F\\x7F',
1297	digit: '0-9',
1298	graph: '\\x21-\\x7E',
1299	lower: 'a-z',
1300	print: '\\x20-\\x7E ',
1301	punct: '\\-!"#$%&\'()\\*+,./:;<=>?@[\\]^_`{\|}~',
1302	space: ' \\t\\r\\n\\v\\f',
1303	upper: 'A-Z',
1304	word: 'A-Za-z0-9_',
1305	xdigit: 'A-Fa-f0-9'
1306	};
1307
1308	var constants$2 = {
1309	MAX_LENGTH: 1024 * 64,
1310	POSIX_REGEX_SOURCE: POSIX_REGEX_SOURCE$1,
1311
1312	// regular expressions
1313	REGEX_BACKSLASH: /\\(?![*+?^${}(\|)[\]])/g,
1314	REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()\|\\/]+/,
1315	REGEX_SPECIAL_CHARS: /[-*+?.^${}(\|)[\]]/,
1316	REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g,
1317	REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(\|)[\]])/g,
1318	REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]\|\\(?=.))/g,
1319
1320	// Replace globs with equivalent patterns to reduce parsing time.
1321	REPLACEMENTS: {
1322	'**': '',
1323	'/': '**',
1324	'//': ''
1325	},
1326
1327	// Digits
1328	CHAR_0: 48, /* 0 */
1329	CHAR_9: 57, /* 9 */
1330
1331	// Alphabet chars.
1332	CHAR_UPPERCASE_A: 65, /* A */
1333	CHAR_LOWERCASE_A: 97, /* a */
1334	CHAR_UPPERCASE_Z: 90, /* Z */
1335	CHAR_LOWERCASE_Z: 122, /* z */
1336
1337	CHAR_LEFT_PARENTHESES: 40, /* ( */
1338	CHAR_RIGHT_PARENTHESES: 41, /* ) */
1339
1340	CHAR_ASTERISK: 42, /* * */
1341
1342	// Non-alphabetic chars.
1343	CHAR_AMPERSAND: 38, /* & */
1344	CHAR_AT: 64, /* @ */
1345	CHAR_BACKWARD_SLASH: 92, /* \ */
1346	CHAR_CARRIAGE_RETURN: 13, /* \r */
1347	CHAR_CIRCUMFLEX_ACCENT: 94, /* ^ */
1348	CHAR_COLON: 58, /* : */
1349	CHAR_COMMA: 44, /* , */
1350	CHAR_DOT: 46, /* . */
1351	CHAR_DOUBLE_QUOTE: 34, /* " */
1352	CHAR_EQUAL: 61, /* = */
1353	CHAR_EXCLAMATION_MARK: 33, /* ! */
1354	CHAR_FORM_FEED: 12, /* \f */
1355	CHAR_FORWARD_SLASH: 47, /* / */
1356	CHAR_GRAVE_ACCENT: 96, /* ` */
1357	CHAR_HASH: 35, /* # */
1358	CHAR_HYPHEN_MINUS: 45, /* - */
1359	CHAR_LEFT_ANGLE_BRACKET: 60, /* < */
1360	CHAR_LEFT_CURLY_BRACE: 123, /* { */
1361	CHAR_LEFT_SQUARE_BRACKET: 91, /* [ */
1362	CHAR_LINE_FEED: 10, /* \n */
1363	CHAR_NO_BREAK_SPACE: 160, /* \u00A0 */
1364	CHAR_PERCENT: 37, /* % */
1365	CHAR_PLUS: 43, /* + */
1366	CHAR_QUESTION_MARK: 63, /* ? */
1367	CHAR_RIGHT_ANGLE_BRACKET: 62, /* > */
1368	CHAR_RIGHT_CURLY_BRACE: 125, /* } */
1369	CHAR_RIGHT_SQUARE_BRACKET: 93, /* ] */
1370	CHAR_SEMICOLON: 59, /* ; */
1371	CHAR_SINGLE_QUOTE: 39, /* ' */
1372	CHAR_SPACE: 32, /* */
1373	CHAR_TAB: 9, /* \t */
1374	CHAR_UNDERSCORE: 95, /* _ */
1375	CHAR_VERTICAL_LINE: 124, /* \| */
1376	CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279, /* \uFEFF */
1377
1378	SEP: path$2.sep,
1379
1380	/**
1381	* Create EXTGLOB_CHARS
1382	*/
1383
1384	extglobChars(chars) {
1385	return {
1386	'!': { type: 'negate', open: '(?:(?!(?:', close: `))${chars.STAR})` },
1387	'?': { type: 'qmark', open: '(?:', close: ')?' },
1388	'+': { type: 'plus', open: '(?:', close: ')+' },
1389	'': { type: 'star', open: '(?:', close: ')' },
1390	'@': { type: 'at', open: '(?:', close: ')' }
1391	};
1392	},
1393
1394	/**
1395	* Create GLOB_CHARS
1396	*/
1397
1398	globChars(win32) {
1399	return win32 === true ? WINDOWS_CHARS : POSIX_CHARS;
1400	}
1401	};
1402
1403	(function (exports) {
1404
1405	const path = require$$0$1;
1406	const win32 = process.platform === 'win32';
1407	const {
1408	REGEX_BACKSLASH,
1409	REGEX_REMOVE_BACKSLASH,
1410	REGEX_SPECIAL_CHARS,
1411	REGEX_SPECIAL_CHARS_GLOBAL
1412	} = constants$2;
1413
1414	exports.isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val);
1415	exports.hasRegexChars = str => REGEX_SPECIAL_CHARS.test(str);
1416	exports.isRegexChar = str => str.length === 1 && exports.hasRegexChars(str);
1417	exports.escapeRegex = str => str.replace(REGEX_SPECIAL_CHARS_GLOBAL, '\\$1');
1418	exports.toPosixSlashes = str => str.replace(REGEX_BACKSLASH, '/');
1419
1420	exports.removeBackslashes = str => {
1421	return str.replace(REGEX_REMOVE_BACKSLASH, match => {
1422	return match === '\\' ? '' : match;
1423	});
1424	};
1425
1426	exports.supportsLookbehinds = () => {
1427	const segs = process.version.slice(1).split('.').map(Number);
1428	if (segs.length === 3 && segs[0] >= 9 \|\| (segs[0] === 8 && segs[1] >= 10)) {
1429	return true;
1430	}
1431	return false;
1432	};
1433
1434	exports.isWindows = options => {
1435	if (options && typeof options.windows === 'boolean') {
1436	return options.windows;
1437	}
1438	return win32 === true \|\| path.sep === '\\';
1439	};
1440
1441	exports.escapeLast = (input, char, lastIdx) => {
1442	const idx = input.lastIndexOf(char, lastIdx);
1443	if (idx === -1) return input;
1444	if (input[idx - 1] === '\\') return exports.escapeLast(input, char, idx - 1);
1445	return `${input.slice(0, idx)}\\${input.slice(idx)}`;
1446	};
1447
1448	exports.removePrefix = (input, state = {}) => {
1449	let output = input;
1450	if (output.startsWith('./')) {
1451	output = output.slice(2);
1452	state.prefix = './';
1453	}
1454	return output;
1455	};
1456
1457	exports.wrapOutput = (input, state = {}, options = {}) => {
1458	const prepend = options.contains ? '' : '^';
1459	const append = options.contains ? '' : '$';
1460
1461	let output = `${prepend}(?:${input})${append}`;
1462	if (state.negated === true) {
1463	output = `(?:^(?!${output}).*$)`;
1464	}
1465	return output;
1466	};
1467	} (utils$3));
1468
1469	const utils$2 = utils$3;
1470	const {
1471	CHAR_ASTERISK, /* * */
1472	CHAR_AT, /* @ */
1473	CHAR_BACKWARD_SLASH, /* \ */
1474	CHAR_COMMA, /* , */
1475	CHAR_DOT, /* . */
1476	CHAR_EXCLAMATION_MARK, /* ! */
1477	CHAR_FORWARD_SLASH, /* / */
1478	CHAR_LEFT_CURLY_BRACE, /* { */
1479	CHAR_LEFT_PARENTHESES, /* ( */
1480	CHAR_LEFT_SQUARE_BRACKET, /* [ */
1481	CHAR_PLUS, /* + */
1482	CHAR_QUESTION_MARK, /* ? */
1483	CHAR_RIGHT_CURLY_BRACE, /* } */
1484	CHAR_RIGHT_PARENTHESES, /* ) */
1485	CHAR_RIGHT_SQUARE_BRACKET /* ] */
1486	} = constants$2;
1487
1488	const isPathSeparator = code => {
1489	return code === CHAR_FORWARD_SLASH \|\| code === CHAR_BACKWARD_SLASH;
1490	};
1491
1492	const depth = token => {
1493	if (token.isPrefix !== true) {
1494	token.depth = token.isGlobstar ? Infinity : 1;
1495	}
1496	};
1497
1498	/**
1499	* Quickly scans a glob pattern and returns an object with a handful of
1500	* useful properties, like `isGlob`, `path` (the leading non-glob, if it exists),
1501	* `glob` (the actual pattern), `negated` (true if the path starts with `!` but not
1502	* with `!(`) and `negatedExtglob` (true if the path starts with `!(`).
1503	*
1504	* ```js
1505	* const pm = require('picomatch');
1506	* console.log(pm.scan('foo/bar/*.js'));
1507	* { isGlob: true, input: 'foo/bar/.js', base: 'foo/bar', glob: '.js' }
1508	* ```
1509	* @param {String} `str`
1510	* @param {Object} `options`
1511	* @return {Object} Returns an object with tokens and regex source string.
1512	* @api public
1513	*/
1514
1515	const scan$1 = (input, options) => {
1516	const opts = options \|\| {};
1517
1518	const length = input.length - 1;
1519	const scanToEnd = opts.parts === true \|\| opts.scanToEnd === true;
1520	const slashes = [];
1521	const tokens = [];
1522	const parts = [];
1523
1524	let str = input;
1525	let index = -1;
1526	let start = 0;
1527	let lastIndex = 0;
1528	let isBrace = false;
1529	let isBracket = false;
1530	let isGlob = false;
1531	let isExtglob = false;
1532	let isGlobstar = false;
1533	let braceEscaped = false;
1534	let backslashes = false;
1535	let negated = false;
1536	let negatedExtglob = false;
1537	let finished = false;
1538	let braces = 0;
1539	let prev;
1540	let code;
1541	let token = { value: '', depth: 0, isGlob: false };
1542
1543	const eos = () => index >= length;
1544	const peek = () => str.charCodeAt(index + 1);
1545	const advance = () => {
1546	prev = code;
1547	return str.charCodeAt(++index);
1548	};
1549
1550	while (index < length) {
1551	code = advance();
1552	let next;
1553
1554	if (code === CHAR_BACKWARD_SLASH) {
1555	backslashes = token.backslashes = true;
1556	code = advance();
1557
1558	if (code === CHAR_LEFT_CURLY_BRACE) {
1559	braceEscaped = true;
1560	}
1561	continue;
1562	}
1563
1564	if (braceEscaped === true \|\| code === CHAR_LEFT_CURLY_BRACE) {
1565	braces++;
1566
1567	while (eos() !== true && (code = advance())) {
1568	if (code === CHAR_BACKWARD_SLASH) {
1569	backslashes = token.backslashes = true;
1570	advance();
1571	continue;
1572	}
1573
1574	if (code === CHAR_LEFT_CURLY_BRACE) {
1575	braces++;
1576	continue;
1577	}
1578
1579	if (braceEscaped !== true && code === CHAR_DOT && (code = advance()) === CHAR_DOT) {
1580	isBrace = token.isBrace = true;
1581	isGlob = token.isGlob = true;
1582	finished = true;
1583
1584	if (scanToEnd === true) {
1585	continue;
1586	}
1587
1588	break;
1589	}
1590
1591	if (braceEscaped !== true && code === CHAR_COMMA) {
1592	isBrace = token.isBrace = true;
1593	isGlob = token.isGlob = true;
1594	finished = true;
1595
1596	if (scanToEnd === true) {
1597	continue;
1598	}
1599
1600	break;
1601	}
1602
1603	if (code === CHAR_RIGHT_CURLY_BRACE) {
1604	braces--;
1605
1606	if (braces === 0) {
1607	braceEscaped = false;
1608	isBrace = token.isBrace = true;
1609	finished = true;
1610	break;
1611	}
1612	}
1613	}
1614
1615	if (scanToEnd === true) {
1616	continue;
1617	}
1618
1619	break;
1620	}
1621
1622	if (code === CHAR_FORWARD_SLASH) {
1623	slashes.push(index);
1624	tokens.push(token);
1625	token = { value: '', depth: 0, isGlob: false };
1626
1627	if (finished === true) continue;
1628	if (prev === CHAR_DOT && index === (start + 1)) {
1629	start += 2;
1630	continue;
1631	}
1632
1633	lastIndex = index + 1;
1634	continue;
1635	}
1636
1637	if (opts.noext !== true) {
1638	const isExtglobChar = code === CHAR_PLUS
1639	\|\| code === CHAR_AT
1640	\|\| code === CHAR_ASTERISK
1641	\|\| code === CHAR_QUESTION_MARK
1642	\|\| code === CHAR_EXCLAMATION_MARK;
1643
1644	if (isExtglobChar === true && peek() === CHAR_LEFT_PARENTHESES) {
1645	isGlob = token.isGlob = true;
1646	isExtglob = token.isExtglob = true;
1647	finished = true;
1648	if (code === CHAR_EXCLAMATION_MARK && index === start) {
1649	negatedExtglob = true;
1650	}
1651
1652	if (scanToEnd === true) {
1653	while (eos() !== true && (code = advance())) {
1654	if (code === CHAR_BACKWARD_SLASH) {
1655	backslashes = token.backslashes = true;
1656	code = advance();
1657	continue;
1658	}
1659
1660	if (code === CHAR_RIGHT_PARENTHESES) {
1661	isGlob = token.isGlob = true;
1662	finished = true;
1663	break;
1664	}
1665	}
1666	continue;
1667	}
1668	break;
1669	}
1670	}
1671
1672	if (code === CHAR_ASTERISK) {
1673	if (prev === CHAR_ASTERISK) isGlobstar = token.isGlobstar = true;
1674	isGlob = token.isGlob = true;
1675	finished = true;
1676
1677	if (scanToEnd === true) {
1678	continue;
1679	}
1680	break;
1681	}
1682
1683	if (code === CHAR_QUESTION_MARK) {
1684	isGlob = token.isGlob = true;
1685	finished = true;
1686
1687	if (scanToEnd === true) {
1688	continue;
1689	}
1690	break;
1691	}
1692
1693	if (code === CHAR_LEFT_SQUARE_BRACKET) {
1694	while (eos() !== true && (next = advance())) {
1695	if (next === CHAR_BACKWARD_SLASH) {
1696	backslashes = token.backslashes = true;
1697	advance();
1698	continue;
1699	}
1700
1701	if (next === CHAR_RIGHT_SQUARE_BRACKET) {
1702	isBracket = token.isBracket = true;
1703	isGlob = token.isGlob = true;
1704	finished = true;
1705	break;
1706	}
1707	}
1708
1709	if (scanToEnd === true) {
1710	continue;
1711	}
1712
1713	break;
1714	}
1715
1716	if (opts.nonegate !== true && code === CHAR_EXCLAMATION_MARK && index === start) {
1717	negated = token.negated = true;
1718	start++;
1719	continue;
1720	}
1721
1722	if (opts.noparen !== true && code === CHAR_LEFT_PARENTHESES) {
1723	isGlob = token.isGlob = true;
1724
1725	if (scanToEnd === true) {
1726	while (eos() !== true && (code = advance())) {
1727	if (code === CHAR_LEFT_PARENTHESES) {
1728	backslashes = token.backslashes = true;
1729	code = advance();
1730	continue;
1731	}
1732
1733	if (code === CHAR_RIGHT_PARENTHESES) {
1734	finished = true;
1735	break;
1736	}
1737	}
1738	continue;
1739	}
1740	break;
1741	}
1742
1743	if (isGlob === true) {
1744	finished = true;
1745
1746	if (scanToEnd === true) {
1747	continue;
1748	}
1749
1750	break;
1751	}
1752	}
1753
1754	if (opts.noext === true) {
1755	isExtglob = false;
1756	isGlob = false;
1757	}
1758
1759	let base = str;
1760	let prefix = '';
1761	let glob = '';
1762
1763	if (start > 0) {
1764	prefix = str.slice(0, start);
1765	str = str.slice(start);
1766	lastIndex -= start;
1767	}
1768
1769	if (base && isGlob === true && lastIndex > 0) {
1770	base = str.slice(0, lastIndex);
1771	glob = str.slice(lastIndex);
1772	} else if (isGlob === true) {
1773	base = '';
1774	glob = str;
1775	} else {
1776	base = str;
1777	}
1778
1779	if (base && base !== '' && base !== '/' && base !== str) {
1780	if (isPathSeparator(base.charCodeAt(base.length - 1))) {
1781	base = base.slice(0, -1);
1782	}
1783	}
1784
1785	if (opts.unescape === true) {
1786	if (glob) glob = utils$2.removeBackslashes(glob);
1787
1788	if (base && backslashes === true) {
1789	base = utils$2.removeBackslashes(base);
1790	}
1791	}
1792
1793	const state = {
1794	prefix,
1795	input,
1796	start,
1797	base,
1798	glob,
1799	isBrace,
1800	isBracket,
1801	isGlob,
1802	isExtglob,
1803	isGlobstar,
1804	negated,
1805	negatedExtglob
1806	};
1807
1808	if (opts.tokens === true) {
1809	state.maxDepth = 0;
1810	if (!isPathSeparator(code)) {
1811	tokens.push(token);
1812	}
1813	state.tokens = tokens;
1814	}
1815
1816	if (opts.parts === true \|\| opts.tokens === true) {
1817	let prevIndex;
1818
1819	for (let idx = 0; idx < slashes.length; idx++) {
1820	const n = prevIndex ? prevIndex + 1 : start;
1821	const i = slashes[idx];
1822	const value = input.slice(n, i);
1823	if (opts.tokens) {
1824	if (idx === 0 && start !== 0) {
1825	tokens[idx].isPrefix = true;
1826	tokens[idx].value = prefix;
1827	} else {
1828	tokens[idx].value = value;
1829	}
1830	depth(tokens[idx]);
1831	state.maxDepth += tokens[idx].depth;
1832	}
1833	if (idx !== 0 \|\| value !== '') {
1834	parts.push(value);
1835	}
1836	prevIndex = i;
1837	}
1838
1839	if (prevIndex && prevIndex + 1 < input.length) {
1840	const value = input.slice(prevIndex + 1);
1841	parts.push(value);
1842
1843	if (opts.tokens) {
1844	tokens[tokens.length - 1].value = value;
1845	depth(tokens[tokens.length - 1]);
1846	state.maxDepth += tokens[tokens.length - 1].depth;
1847	}
1848	}
1849
1850	state.slashes = slashes;
1851	state.parts = parts;
1852	}
1853
1854	return state;
1855	};
1856
1857	var scan_1 = scan$1;
1858
1859	const constants$1 = constants$2;
1860	const utils$1 = utils$3;
1861
1862	/**
1863	* Constants
1864	*/
1865
1866	const {
1867	MAX_LENGTH,
1868	POSIX_REGEX_SOURCE,
1869	REGEX_NON_SPECIAL_CHARS,
1870	REGEX_SPECIAL_CHARS_BACKREF,
1871	REPLACEMENTS
1872	} = constants$1;
1873
1874	/**
1875	* Helpers
1876	*/
1877
1878	const expandRange = (args, options) => {
1879	if (typeof options.expandRange === 'function') {
1880	return options.expandRange(...args, options);
1881	}
1882
1883	args.sort();
1884	const value = `[${args.join('-')}]`;
1885
1886	return value;
1887	};
1888
1889	/**
1890	* Create the message for a syntax error
1891	*/
1892
1893	const syntaxError = (type, char) => {
1894	return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
1895	};
1896
1897	/**
1898	* Parse the given input string.
1899	* @param {String} input
1900	* @param {Object} options
1901	* @return {Object}
1902	*/
1903
1904	const parse$2 = (input, options) => {
1905	if (typeof input !== 'string') {
1906	throw new TypeError('Expected a string');
1907	}
1908
1909	input = REPLACEMENTS[input] \|\| input;
1910
1911	const opts = { ...options };
1912	const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
1913
1914	let len = input.length;
1915	if (len > max) {
1916	throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
1917	}
1918
1919	const bos = { type: 'bos', value: '', output: opts.prepend \|\| '' };
1920	const tokens = [bos];
1921
1922	const capture = opts.capture ? '' : '?:';
1923	const win32 = utils$1.isWindows(options);
1924
1925	// create constants based on platform, for windows or posix
1926	const PLATFORM_CHARS = constants$1.globChars(win32);
1927	const EXTGLOB_CHARS = constants$1.extglobChars(PLATFORM_CHARS);
1928
1929	const {
1930	DOT_LITERAL,
1931	PLUS_LITERAL,
1932	SLASH_LITERAL,
1933	ONE_CHAR,
1934	DOTS_SLASH,
1935	NO_DOT,
1936	NO_DOT_SLASH,
1937	NO_DOTS_SLASH,
1938	QMARK,
1939	QMARK_NO_DOT,
1940	STAR,
1941	START_ANCHOR
1942	} = PLATFORM_CHARS;
1943
1944	const globstar = opts => {
1945	return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
1946	};
1947
1948	const nodot = opts.dot ? '' : NO_DOT;
1949	const qmarkNoDot = opts.dot ? QMARK : QMARK_NO_DOT;
1950	let star = opts.bash === true ? globstar(opts) : STAR;
1951
1952	if (opts.capture) {
1953	star = `(${star})`;
1954	}
1955
1956	// minimatch options support
1957	if (typeof opts.noext === 'boolean') {
1958	opts.noextglob = opts.noext;
1959	}
1960
1961	const state = {
1962	input,
1963	index: -1,
1964	start: 0,
1965	dot: opts.dot === true,
1966	consumed: '',
1967	output: '',
1968	prefix: '',
1969	backtrack: false,
1970	negated: false,
1971	brackets: 0,
1972	braces: 0,
1973	parens: 0,
1974	quotes: 0,
1975	globstar: false,
1976	tokens
1977	};
1978
1979	input = utils$1.removePrefix(input, state);
1980	len = input.length;
1981
1982	const extglobs = [];
1983	const braces = [];
1984	const stack = [];
1985	let prev = bos;
1986	let value;
1987
1988	/**
1989	* Tokenizing helpers
1990	*/
1991
1992	const eos = () => state.index === len - 1;
1993	const peek = state.peek = (n = 1) => input[state.index + n];
1994	const advance = state.advance = () => input[++state.index] \|\| '';
1995	const remaining = () => input.slice(state.index + 1);
1996	const consume = (value = '', num = 0) => {
1997	state.consumed += value;
1998	state.index += num;
1999	};
2000
2001	const append = token => {
2002	state.output += token.output != null ? token.output : token.value;
2003	consume(token.value);
2004	};
2005
2006	const negate = () => {
2007	let count = 1;
2008
2009	while (peek() === '!' && (peek(2) !== '(' \|\| peek(3) === '?')) {
2010	advance();
2011	state.start++;
2012	count++;
2013	}
2014
2015	if (count % 2 === 0) {
2016	return false;
2017	}
2018
2019	state.negated = true;
2020	state.start++;
2021	return true;
2022	};
2023
2024	const increment = type => {
2025	state[type]++;
2026	stack.push(type);
2027	};
2028
2029	const decrement = type => {
2030	state[type]--;
2031	stack.pop();
2032	};
2033
2034	/**
2035	* Push tokens onto the tokens array. This helper speeds up
2036	* tokenizing by 1) helping us avoid backtracking as much as possible,
2037	* and 2) helping us avoid creating extra tokens when consecutive
2038	* characters are plain text. This improves performance and simplifies
2039	* lookbehinds.
2040	*/
2041
2042	const push = tok => {
2043	if (prev.type === 'globstar') {
2044	const isBrace = state.braces > 0 && (tok.type === 'comma' \|\| tok.type === 'brace');
2045	const isExtglob = tok.extglob === true \|\| (extglobs.length && (tok.type === 'pipe' \|\| tok.type === 'paren'));
2046
2047	if (tok.type !== 'slash' && tok.type !== 'paren' && !isBrace && !isExtglob) {
2048	state.output = state.output.slice(0, -prev.output.length);
2049	prev.type = 'star';
2050	prev.value = '*';
2051	prev.output = star;
2052	state.output += prev.output;
2053	}
2054	}
2055
2056	if (extglobs.length && tok.type !== 'paren') {
2057	extglobs[extglobs.length - 1].inner += tok.value;
2058	}
2059
2060	if (tok.value \|\| tok.output) append(tok);
2061	if (prev && prev.type === 'text' && tok.type === 'text') {
2062	prev.value += tok.value;
2063	prev.output = (prev.output \|\| '') + tok.value;
2064	return;
2065	}
2066
2067	tok.prev = prev;
2068	tokens.push(tok);
2069	prev = tok;
2070	};
2071
2072	const extglobOpen = (type, value) => {
2073	const token = { ...EXTGLOB_CHARS[value], conditions: 1, inner: '' };
2074
2075	token.prev = prev;
2076	token.parens = state.parens;
2077	token.output = state.output;
2078	const output = (opts.capture ? '(' : '') + token.open;
2079
2080	increment('parens');
2081	push({ type, value, output: state.output ? '' : ONE_CHAR });
2082	push({ type: 'paren', extglob: true, value: advance(), output });
2083	extglobs.push(token);
2084	};
2085
2086	const extglobClose = token => {
2087	let output = token.close + (opts.capture ? ')' : '');
2088	let rest;
2089
2090	if (token.type === 'negate') {
2091	let extglobStar = star;
2092
2093	if (token.inner && token.inner.length > 1 && token.inner.includes('/')) {
2094	extglobStar = globstar(opts);
2095	}
2096
2097	if (extglobStar !== star \|\| eos() \|\| /^\)+$/.test(remaining())) {
2098	output = token.close = `)$))${extglobStar}`;
2099	}
2100
2101	if (token.inner.includes('*') && (rest = remaining()) && /^\.[^\\/.]+$/.test(rest)) {
2102	// Any non-magical string (`.ts`) or even nested expression (`.{ts,tsx}`) can follow after the closing parenthesis.
2103	// In this case, we need to parse the string and use it in the output of the original pattern.
2104	// Suitable patterns: `/!(.d).ts`, `/!(.d).{ts,tsx}`, `*/!(-dbg).@(js)`.
2105	//
2106	// Disabling the `fastpaths` option due to a problem with parsing strings as `.ts` in the pattern like `*/!(.d).ts`.
2107	const expression = parse$2(rest, { ...options, fastpaths: false }).output;
2108
2109	output = token.close = `)${expression})${extglobStar})`;
2110	}
2111
2112	if (token.prev.type === 'bos') {
2113	state.negatedExtglob = true;
2114	}
2115	}
2116
2117	push({ type: 'paren', extglob: true, value, output });
2118	decrement('parens');
2119	};
2120
2121	/**
2122	* Fast paths
2123	*/
2124
2125	if (opts.fastpaths !== false && !/(^[*!]\|[/()[\]{}"])/.test(input)) {
2126	let backslashes = false;
2127
2128	let output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars, first, rest, index) => {
2129	if (first === '\\') {
2130	backslashes = true;
2131	return m;
2132	}
2133
2134	if (first === '?') {
2135	if (esc) {
2136	return esc + first + (rest ? QMARK.repeat(rest.length) : '');
2137	}
2138	if (index === 0) {
2139	return qmarkNoDot + (rest ? QMARK.repeat(rest.length) : '');
2140	}
2141	return QMARK.repeat(chars.length);
2142	}
2143
2144	if (first === '.') {
2145	return DOT_LITERAL.repeat(chars.length);
2146	}
2147
2148	if (first === '*') {
2149	if (esc) {
2150	return esc + first + (rest ? star : '');
2151	}
2152	return star;
2153	}
2154	return esc ? m : `\\${m}`;
2155	});
2156
2157	if (backslashes === true) {
2158	if (opts.unescape === true) {
2159	output = output.replace(/\\/g, '');
2160	} else {
2161	output = output.replace(/\\+/g, m => {
2162	return m.length % 2 === 0 ? '\\\\' : (m ? '\\' : '');
2163	});
2164	}
2165	}
2166
2167	if (output === input && opts.contains === true) {
2168	state.output = input;
2169	return state;
2170	}
2171
2172	state.output = utils$1.wrapOutput(output, state, options);
2173	return state;
2174	}
2175
2176	/**
2177	* Tokenize input until we reach end-of-string
2178	*/
2179
2180	while (!eos()) {
2181	value = advance();
2182
2183	if (value === '\u0000') {
2184	continue;
2185	}
2186
2187	/**
2188	* Escaped characters
2189	*/
2190
2191	if (value === '\\') {
2192	const next = peek();
2193
2194	if (next === '/' && opts.bash !== true) {
2195	continue;
2196	}
2197
2198	if (next === '.' \|\| next === ';') {
2199	continue;
2200	}
2201
2202	if (!next) {
2203	value += '\\';
2204	push({ type: 'text', value });
2205	continue;
2206	}
2207
2208	// collapse slashes to reduce potential for exploits
2209	const match = /^\\+/.exec(remaining());
2210	let slashes = 0;
2211
2212	if (match && match[0].length > 2) {
2213	slashes = match[0].length;
2214	state.index += slashes;
2215	if (slashes % 2 !== 0) {
2216	value += '\\';
2217	}
2218	}
2219
2220	if (opts.unescape === true) {
2221	value = advance();
2222	} else {
2223	value += advance();
2224	}
2225
2226	if (state.brackets === 0) {
2227	push({ type: 'text', value });
2228	continue;
2229	}
2230	}
2231
2232	/**
2233	* If we're inside a regex character class, continue
2234	* until we reach the closing bracket.
2235	*/
2236
2237	if (state.brackets > 0 && (value !== ']' \|\| prev.value === '[' \|\| prev.value === '[^')) {
2238	if (opts.posix !== false && value === ':') {
2239	const inner = prev.value.slice(1);
2240	if (inner.includes('[')) {
2241	prev.posix = true;
2242
2243	if (inner.includes(':')) {
2244	const idx = prev.value.lastIndexOf('[');
2245	const pre = prev.value.slice(0, idx);
2246	const rest = prev.value.slice(idx + 2);
2247	const posix = POSIX_REGEX_SOURCE[rest];
2248	if (posix) {
2249	prev.value = pre + posix;
2250	state.backtrack = true;
2251	advance();
2252
2253	if (!bos.output && tokens.indexOf(prev) === 1) {
2254	bos.output = ONE_CHAR;
2255	}
2256	continue;
2257	}
2258	}
2259	}
2260	}
2261
2262	if ((value === '[' && peek() !== ':') \|\| (value === '-' && peek() === ']')) {
2263	value = `\\${value}`;
2264	}
2265
2266	if (value === ']' && (prev.value === '[' \|\| prev.value === '[^')) {
2267	value = `\\${value}`;
2268	}
2269
2270	if (opts.posix === true && value === '!' && prev.value === '[') {
2271	value = '^';
2272	}
2273
2274	prev.value += value;
2275	append({ value });
2276	continue;
2277	}
2278
2279	/**
2280	* If we're inside a quoted string, continue
2281	* until we reach the closing double quote.
2282	*/
2283
2284	if (state.quotes === 1 && value !== '"') {
2285	value = utils$1.escapeRegex(value);
2286	prev.value += value;
2287	append({ value });
2288	continue;
2289	}
2290
2291	/**
2292	* Double quotes
2293	*/
2294
2295	if (value === '"') {
2296	state.quotes = state.quotes === 1 ? 0 : 1;
2297	if (opts.keepQuotes === true) {
2298	push({ type: 'text', value });
2299	}
2300	continue;
2301	}
2302
2303	/**
2304	* Parentheses
2305	*/
2306
2307	if (value === '(') {
2308	increment('parens');
2309	push({ type: 'paren', value });
2310	continue;
2311	}
2312
2313	if (value === ')') {
2314	if (state.parens === 0 && opts.strictBrackets === true) {
2315	throw new SyntaxError(syntaxError('opening', '('));
2316	}
2317
2318	const extglob = extglobs[extglobs.length - 1];
2319	if (extglob && state.parens === extglob.parens + 1) {
2320	extglobClose(extglobs.pop());
2321	continue;
2322	}
2323
2324	push({ type: 'paren', value, output: state.parens ? ')' : '\\)' });
2325	decrement('parens');
2326	continue;
2327	}
2328
2329	/**
2330	* Square brackets
2331	*/
2332
2333	if (value === '[') {
2334	if (opts.nobracket === true \|\| !remaining().includes(']')) {
2335	if (opts.nobracket !== true && opts.strictBrackets === true) {
2336	throw new SyntaxError(syntaxError('closing', ']'));
2337	}
2338
2339	value = `\\${value}`;
2340	} else {
2341	increment('brackets');
2342	}
2343
2344	push({ type: 'bracket', value });
2345	continue;
2346	}
2347
2348	if (value === ']') {
2349	if (opts.nobracket === true \|\| (prev && prev.type === 'bracket' && prev.value.length === 1)) {
2350	push({ type: 'text', value, output: `\\${value}` });
2351	continue;
2352	}
2353
2354	if (state.brackets === 0) {
2355	if (opts.strictBrackets === true) {
2356	throw new SyntaxError(syntaxError('opening', '['));
2357	}
2358
2359	push({ type: 'text', value, output: `\\${value}` });
2360	continue;
2361	}
2362
2363	decrement('brackets');
2364
2365	const prevValue = prev.value.slice(1);
2366	if (prev.posix !== true && prevValue[0] === '^' && !prevValue.includes('/')) {
2367	value = `/${value}`;
2368	}
2369
2370	prev.value += value;
2371	append({ value });
2372
2373	// when literal brackets are explicitly disabled
2374	// assume we should match with a regex character class
2375	if (opts.literalBrackets === false \|\| utils$1.hasRegexChars(prevValue)) {
2376	continue;
2377	}
2378
2379	const escaped = utils$1.escapeRegex(prev.value);
2380	state.output = state.output.slice(0, -prev.value.length);
2381
2382	// when literal brackets are explicitly enabled
2383	// assume we should escape the brackets to match literal characters
2384	if (opts.literalBrackets === true) {
2385	state.output += escaped;
2386	prev.value = escaped;
2387	continue;
2388	}
2389
2390	// when the user specifies nothing, try to match both
2391	prev.value = `(${capture}${escaped}\|${prev.value})`;
2392	state.output += prev.value;
2393	continue;
2394	}
2395
2396	/**
2397	* Braces
2398	*/
2399
2400	if (value === '{' && opts.nobrace !== true) {
2401	increment('braces');
2402
2403	const open = {
2404	type: 'brace',
2405	value,
2406	output: '(',
2407	outputIndex: state.output.length,
2408	tokensIndex: state.tokens.length
2409	};
2410
2411	braces.push(open);
2412	push(open);
2413	continue;
2414	}
2415
2416	if (value === '}') {
2417	const brace = braces[braces.length - 1];
2418
2419	if (opts.nobrace === true \|\| !brace) {
2420	push({ type: 'text', value, output: value });
2421	continue;
2422	}
2423
2424	let output = ')';
2425
2426	if (brace.dots === true) {
2427	const arr = tokens.slice();
2428	const range = [];
2429
2430	for (let i = arr.length - 1; i >= 0; i--) {
2431	tokens.pop();
2432	if (arr[i].type === 'brace') {
2433	break;
2434	}
2435	if (arr[i].type !== 'dots') {
2436	range.unshift(arr[i].value);
2437	}
2438	}
2439
2440	output = expandRange(range, opts);
2441	state.backtrack = true;
2442	}
2443
2444	if (brace.comma !== true && brace.dots !== true) {
2445	const out = state.output.slice(0, brace.outputIndex);
2446	const toks = state.tokens.slice(brace.tokensIndex);
2447	brace.value = brace.output = '\\{';
2448	value = output = '\\}';
2449	state.output = out;
2450	for (const t of toks) {
2451	state.output += (t.output \|\| t.value);
2452	}
2453	}
2454
2455	push({ type: 'brace', value, output });
2456	decrement('braces');
2457	braces.pop();
2458	continue;
2459	}
2460
2461	/**
2462	* Pipes
2463	*/
2464
2465	if (value === '\|') {
2466	if (extglobs.length > 0) {
2467	extglobs[extglobs.length - 1].conditions++;
2468	}
2469	push({ type: 'text', value });
2470	continue;
2471	}
2472
2473	/**
2474	* Commas
2475	*/
2476
2477	if (value === ',') {
2478	let output = value;
2479
2480	const brace = braces[braces.length - 1];
2481	if (brace && stack[stack.length - 1] === 'braces') {
2482	brace.comma = true;
2483	output = '\|';
2484	}
2485
2486	push({ type: 'comma', value, output });
2487	continue;
2488	}
2489
2490	/**
2491	* Slashes
2492	*/
2493
2494	if (value === '/') {
2495	// if the beginning of the glob is "./", advance the start
2496	// to the current index, and don't add the "./" characters
2497	// to the state. This greatly simplifies lookbehinds when
2498	// checking for BOS characters like "!" and "." (not "./")
2499	if (prev.type === 'dot' && state.index === state.start + 1) {
2500	state.start = state.index + 1;
2501	state.consumed = '';
2502	state.output = '';
2503	tokens.pop();
2504	prev = bos; // reset "prev" to the first token
2505	continue;
2506	}
2507
2508	push({ type: 'slash', value, output: SLASH_LITERAL });
2509	continue;
2510	}
2511
2512	/**
2513	* Dots
2514	*/
2515
2516	if (value === '.') {
2517	if (state.braces > 0 && prev.type === 'dot') {
2518	if (prev.value === '.') prev.output = DOT_LITERAL;
2519	const brace = braces[braces.length - 1];
2520	prev.type = 'dots';
2521	prev.output += value;
2522	prev.value += value;
2523	brace.dots = true;
2524	continue;
2525	}
2526
2527	if ((state.braces + state.parens) === 0 && prev.type !== 'bos' && prev.type !== 'slash') {
2528	push({ type: 'text', value, output: DOT_LITERAL });
2529	continue;
2530	}
2531
2532	push({ type: 'dot', value, output: DOT_LITERAL });
2533	continue;
2534	}
2535
2536	/**
2537	* Question marks
2538	*/
2539
2540	if (value === '?') {
2541	const isGroup = prev && prev.value === '(';
2542	if (!isGroup && opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
2543	extglobOpen('qmark', value);
2544	continue;
2545	}
2546
2547	if (prev && prev.type === 'paren') {
2548	const next = peek();
2549	let output = value;
2550
2551	if (next === '<' && !utils$1.supportsLookbehinds()) {
2552	throw new Error('Node.js v10 or higher is required for regex lookbehinds');
2553	}
2554
2555	if ((prev.value === '(' && !/[!=<:]/.test(next)) \|\| (next === '<' && !/<([!=]\|\w+>)/.test(remaining()))) {
2556	output = `\\${value}`;
2557	}
2558
2559	push({ type: 'text', value, output });
2560	continue;
2561	}
2562
2563	if (opts.dot !== true && (prev.type === 'slash' \|\| prev.type === 'bos')) {
2564	push({ type: 'qmark', value, output: QMARK_NO_DOT });
2565	continue;
2566	}
2567
2568	push({ type: 'qmark', value, output: QMARK });
2569	continue;
2570	}
2571
2572	/**
2573	* Exclamation
2574	*/
2575
2576	if (value === '!') {
2577	if (opts.noextglob !== true && peek() === '(') {
2578	if (peek(2) !== '?' \|\| !/[!=<:]/.test(peek(3))) {
2579	extglobOpen('negate', value);
2580	continue;
2581	}
2582	}
2583
2584	if (opts.nonegate !== true && state.index === 0) {
2585	negate();
2586	continue;
2587	}
2588	}
2589
2590	/**
2591	* Plus
2592	*/
2593
2594	if (value === '+') {
2595	if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
2596	extglobOpen('plus', value);
2597	continue;
2598	}
2599
2600	if ((prev && prev.value === '(') \|\| opts.regex === false) {
2601	push({ type: 'plus', value, output: PLUS_LITERAL });
2602	continue;
2603	}
2604
2605	if ((prev && (prev.type === 'bracket' \|\| prev.type === 'paren' \|\| prev.type === 'brace')) \|\| state.parens > 0) {
2606	push({ type: 'plus', value });
2607	continue;
2608	}
2609
2610	push({ type: 'plus', value: PLUS_LITERAL });
2611	continue;
2612	}
2613
2614	/**
2615	* Plain text
2616	*/
2617
2618	if (value === '@') {
2619	if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
2620	push({ type: 'at', extglob: true, value, output: '' });
2621	continue;
2622	}
2623
2624	push({ type: 'text', value });
2625	continue;
2626	}
2627
2628	/**
2629	* Plain text
2630	*/
2631
2632	if (value !== '*') {
2633	if (value === '$' \|\| value === '^') {
2634	value = `\\${value}`;
2635	}
2636
2637	const match = REGEX_NON_SPECIAL_CHARS.exec(remaining());
2638	if (match) {
2639	value += match[0];
2640	state.index += match[0].length;
2641	}
2642
2643	push({ type: 'text', value });
2644	continue;
2645	}
2646
2647	/**
2648	* Stars
2649	*/
2650
2651	if (prev && (prev.type === 'globstar' \|\| prev.star === true)) {
2652	prev.type = 'star';
2653	prev.star = true;
2654	prev.value += value;
2655	prev.output = star;
2656	state.backtrack = true;
2657	state.globstar = true;
2658	consume(value);
2659	continue;
2660	}
2661
2662	let rest = remaining();
2663	if (opts.noextglob !== true && /^\([^?]/.test(rest)) {
2664	extglobOpen('star', value);
2665	continue;
2666	}
2667
2668	if (prev.type === 'star') {
2669	if (opts.noglobstar === true) {
2670	consume(value);
2671	continue;
2672	}
2673
2674	const prior = prev.prev;
2675	const before = prior.prev;
2676	const isStart = prior.type === 'slash' \|\| prior.type === 'bos';
2677	const afterStar = before && (before.type === 'star' \|\| before.type === 'globstar');
2678
2679	if (opts.bash === true && (!isStart \|\| (rest[0] && rest[0] !== '/'))) {
2680	push({ type: 'star', value, output: '' });
2681	continue;
2682	}
2683
2684	const isBrace = state.braces > 0 && (prior.type === 'comma' \|\| prior.type === 'brace');
2685	const isExtglob = extglobs.length && (prior.type === 'pipe' \|\| prior.type === 'paren');
2686	if (!isStart && prior.type !== 'paren' && !isBrace && !isExtglob) {
2687	push({ type: 'star', value, output: '' });
2688	continue;
2689	}
2690
2691	// strip consecutive `/**/`
2692	while (rest.slice(0, 3) === '/**') {
2693	const after = input[state.index + 4];
2694	if (after && after !== '/') {
2695	break;
2696	}
2697	rest = rest.slice(3);
2698	consume('/**', 3);
2699	}
2700
2701	if (prior.type === 'bos' && eos()) {
2702	prev.type = 'globstar';
2703	prev.value += value;
2704	prev.output = globstar(opts);
2705	state.output = prev.output;
2706	state.globstar = true;
2707	consume(value);
2708	continue;
2709	}
2710
2711	if (prior.type === 'slash' && prior.prev.type !== 'bos' && !afterStar && eos()) {
2712	state.output = state.output.slice(0, -(prior.output + prev.output).length);
2713	prior.output = `(?:${prior.output}`;
2714
2715	prev.type = 'globstar';
2716	prev.output = globstar(opts) + (opts.strictSlashes ? ')' : '\|$)');
2717	prev.value += value;
2718	state.globstar = true;
2719	state.output += prior.output + prev.output;
2720	consume(value);
2721	continue;
2722	}
2723
2724	if (prior.type === 'slash' && prior.prev.type !== 'bos' && rest[0] === '/') {
2725	const end = rest[1] !== void 0 ? '\|$' : '';
2726
2727	state.output = state.output.slice(0, -(prior.output + prev.output).length);
2728	prior.output = `(?:${prior.output}`;
2729
2730	prev.type = 'globstar';
2731	prev.output = `${globstar(opts)}${SLASH_LITERAL}\|${SLASH_LITERAL}${end})`;
2732	prev.value += value;
2733
2734	state.output += prior.output + prev.output;
2735	state.globstar = true;
2736
2737	consume(value + advance());
2738
2739	push({ type: 'slash', value: '/', output: '' });
2740	continue;
2741	}
2742
2743	if (prior.type === 'bos' && rest[0] === '/') {
2744	prev.type = 'globstar';
2745	prev.value += value;
2746	prev.output = `(?:^\|${SLASH_LITERAL}\|${globstar(opts)}${SLASH_LITERAL})`;
2747	state.output = prev.output;
2748	state.globstar = true;
2749	consume(value + advance());
2750	push({ type: 'slash', value: '/', output: '' });
2751	continue;
2752	}
2753
2754	// remove single star from output
2755	state.output = state.output.slice(0, -prev.output.length);
2756
2757	// reset previous token to globstar
2758	prev.type = 'globstar';
2759	prev.output = globstar(opts);
2760	prev.value += value;
2761
2762	// reset output with globstar
2763	state.output += prev.output;
2764	state.globstar = true;
2765	consume(value);
2766	continue;
2767	}
2768
2769	const token = { type: 'star', value, output: star };
2770
2771	if (opts.bash === true) {
2772	token.output = '.*?';
2773	if (prev.type === 'bos' \|\| prev.type === 'slash') {
2774	token.output = nodot + token.output;
2775	}
2776	push(token);
2777	continue;
2778	}
2779
2780	if (prev && (prev.type === 'bracket' \|\| prev.type === 'paren') && opts.regex === true) {
2781	token.output = value;
2782	push(token);
2783	continue;
2784	}
2785
2786	if (state.index === state.start \|\| prev.type === 'slash' \|\| prev.type === 'dot') {
2787	if (prev.type === 'dot') {
2788	state.output += NO_DOT_SLASH;
2789	prev.output += NO_DOT_SLASH;
2790
2791	} else if (opts.dot === true) {
2792	state.output += NO_DOTS_SLASH;
2793	prev.output += NO_DOTS_SLASH;
2794
2795	} else {
2796	state.output += nodot;
2797	prev.output += nodot;
2798	}
2799
2800	if (peek() !== '*') {
2801	state.output += ONE_CHAR;
2802	prev.output += ONE_CHAR;
2803	}
2804	}
2805
2806	push(token);
2807	}
2808
2809	while (state.brackets > 0) {
2810	if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', ']'));
2811	state.output = utils$1.escapeLast(state.output, '[');
2812	decrement('brackets');
2813	}
2814
2815	while (state.parens > 0) {
2816	if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', ')'));
2817	state.output = utils$1.escapeLast(state.output, '(');
2818	decrement('parens');
2819	}
2820
2821	while (state.braces > 0) {
2822	if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', '}'));
2823	state.output = utils$1.escapeLast(state.output, '{');
2824	decrement('braces');
2825	}
2826
2827	if (opts.strictSlashes !== true && (prev.type === 'star' \|\| prev.type === 'bracket')) {
2828	push({ type: 'maybe_slash', value: '', output: `${SLASH_LITERAL}?` });
2829	}
2830
2831	// rebuild the output if we had to backtrack at any point
2832	if (state.backtrack === true) {
2833	state.output = '';
2834
2835	for (const token of state.tokens) {
2836	state.output += token.output != null ? token.output : token.value;
2837
2838	if (token.suffix) {
2839	state.output += token.suffix;
2840	}
2841	}
2842	}
2843
2844	return state;
2845	};
2846
2847	/**
2848	* Fast paths for creating regular expressions for common glob patterns.
2849	* This can significantly speed up processing and has very little downside
2850	* impact when none of the fast paths match.
2851	*/
2852
2853	parse$2.fastpaths = (input, options) => {
2854	const opts = { ...options };
2855	const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
2856	const len = input.length;
2857	if (len > max) {
2858	throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
2859	}
2860
2861	input = REPLACEMENTS[input] \|\| input;
2862	const win32 = utils$1.isWindows(options);
2863
2864	// create constants based on platform, for windows or posix
2865	const {
2866	DOT_LITERAL,
2867	SLASH_LITERAL,
2868	ONE_CHAR,
2869	DOTS_SLASH,
2870	NO_DOT,
2871	NO_DOTS,
2872	NO_DOTS_SLASH,
2873	STAR,
2874	START_ANCHOR
2875	} = constants$1.globChars(win32);
2876
2877	const nodot = opts.dot ? NO_DOTS : NO_DOT;
2878	const slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT;
2879	const capture = opts.capture ? '' : '?:';
2880	const state = { negated: false, prefix: '' };
2881	let star = opts.bash === true ? '.*?' : STAR;
2882
2883	if (opts.capture) {
2884	star = `(${star})`;
2885	}
2886
2887	const globstar = opts => {
2888	if (opts.noglobstar === true) return star;
2889	return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
2890	};
2891
2892	const create = str => {
2893	switch (str) {
2894	case '*':
2895	return `${nodot}${ONE_CHAR}${star}`;
2896
2897	case '.*':
2898	return `${DOT_LITERAL}${ONE_CHAR}${star}`;
2899
2900	case '.':
2901	return `${nodot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
2902
2903	case '/':
2904	return `${nodot}${star}${SLASH_LITERAL}${ONE_CHAR}${slashDot}${star}`;
2905
2906	case '**':
2907	return nodot + globstar(opts);
2908
2909	case '*/':
2910	return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${ONE_CHAR}${star}`;
2911
2912	case '*/.*':
2913	return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
2914
2915	case '*/.':
2916	return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${DOT_LITERAL}${ONE_CHAR}${star}`;
2917
2918	default: {
2919	const match = /^(.*?)\.(\w+)$/.exec(str);
2920	if (!match) return;
2921
2922	const source = create(match[1]);
2923	if (!source) return;
2924
2925	return source + DOT_LITERAL + match[2];
2926	}
2927	}
2928	};
2929
2930	const output = utils$1.removePrefix(input, state);
2931	let source = create(output);
2932
2933	if (source && opts.strictSlashes !== true) {
2934	source += `${SLASH_LITERAL}?`;
2935	}
2936
2937	return source;
2938	};
2939
2940	var parse_1$1 = parse$2;
2941
2942	const path$1 = require$$0$1;
2943	const scan = scan_1;
2944	const parse$1 = parse_1$1;
2945	const utils = utils$3;
2946	const constants = constants$2;
2947	const isObject$2 = val => val && typeof val === 'object' && !Array.isArray(val);
2948
2949	/**
2950	* Creates a matcher function from one or more glob patterns. The
2951	* returned function takes a string to match as its first argument,
2952	* and returns true if the string is a match. The returned matcher
2953	* function also takes a boolean as the second argument that, when true,
2954	* returns an object with additional information.
2955	*
2956	* ```js
2957	* const picomatch = require('picomatch');
2958	* // picomatch(glob[, options]);
2959	*
2960	* const isMatch = picomatch('.!(a)');
2961	* console.log(isMatch('a.a')); //=> false
2962	* console.log(isMatch('a.b')); //=> true
2963	* ```
2964	* @name picomatch
2965	* @param {String\|Array} `globs` One or more glob patterns.
2966	* @param {Object=} `options`
2967	* @return {Function=} Returns a matcher function.
2968	* @api public
2969	*/
2970
2971	const picomatch$1 = (glob, options, returnState = false) => {
2972	if (Array.isArray(glob)) {
2973	const fns = glob.map(input => picomatch$1(input, options, returnState));
2974	const arrayMatcher = str => {
2975	for (const isMatch of fns) {
2976	const state = isMatch(str);
2977	if (state) return state;
2978	}
2979	return false;
2980	};
2981	return arrayMatcher;
2982	}
2983
2984	const isState = isObject$2(glob) && glob.tokens && glob.input;
2985
2986	if (glob === '' \|\| (typeof glob !== 'string' && !isState)) {
2987	throw new TypeError('Expected pattern to be a non-empty string');
2988	}
2989
2990	const opts = options \|\| {};
2991	const posix = utils.isWindows(options);
2992	const regex = isState
2993	? picomatch$1.compileRe(glob, options)
2994	: picomatch$1.makeRe(glob, options, false, true);
2995
2996	const state = regex.state;
2997	delete regex.state;
2998
2999	let isIgnored = () => false;
3000	if (opts.ignore) {
3001	const ignoreOpts = { ...options, ignore: null, onMatch: null, onResult: null };
3002	isIgnored = picomatch$1(opts.ignore, ignoreOpts, returnState);
3003	}
3004
3005	const matcher = (input, returnObject = false) => {
3006	const { isMatch, match, output } = picomatch$1.test(input, regex, options, { glob, posix });
3007	const result = { glob, state, regex, posix, input, output, match, isMatch };
3008
3009	if (typeof opts.onResult === 'function') {
3010	opts.onResult(result);
3011	}
3012
3013	if (isMatch === false) {
3014	result.isMatch = false;
3015	return returnObject ? result : false;
3016	}
3017
3018	if (isIgnored(input)) {
3019	if (typeof opts.onIgnore === 'function') {
3020	opts.onIgnore(result);
3021	}
3022	result.isMatch = false;
3023	return returnObject ? result : false;
3024	}
3025
3026	if (typeof opts.onMatch === 'function') {
3027	opts.onMatch(result);
3028	}
3029	return returnObject ? result : true;
3030	};
3031
3032	if (returnState) {
3033	matcher.state = state;
3034	}
3035
3036	return matcher;
3037	};
3038
3039	/**
3040	* Test `input` with the given `regex`. This is used by the main
3041	* `picomatch()` function to test the input string.
3042	*
3043	* ```js
3044	* const picomatch = require('picomatch');
3045	* // picomatch.test(input, regex[, options]);
3046	*
3047	* console.log(picomatch.test('foo/bar', /^(?:([^/]?)\/([^/]?))$/));
3048	* // { isMatch: true, match: [ 'foo/', 'foo', 'bar' ], output: 'foo/bar' }
3049	* ```
3050	* @param {String} `input` String to test.
3051	* @param {RegExp} `regex`
3052	* @return {Object} Returns an object with matching info.
3053	* @api public
3054	*/
3055
3056	picomatch$1.test = (input, regex, options, { glob, posix } = {}) => {
3057	if (typeof input !== 'string') {
3058	throw new TypeError('Expected input to be a string');
3059	}
3060
3061	if (input === '') {
3062	return { isMatch: false, output: '' };
3063	}
3064
3065	const opts = options \|\| {};
3066	const format = opts.format \|\| (posix ? utils.toPosixSlashes : null);
3067	let match = input === glob;
3068	let output = (match && format) ? format(input) : input;
3069
3070	if (match === false) {
3071	output = format ? format(input) : input;
3072	match = output === glob;
3073	}
3074
3075	if (match === false \|\| opts.capture === true) {
3076	if (opts.matchBase === true \|\| opts.basename === true) {
3077	match = picomatch$1.matchBase(input, regex, options, posix);
3078	} else {
3079	match = regex.exec(output);
3080	}
3081	}
3082
3083	return { isMatch: Boolean(match), match, output };
3084	};
3085
3086	/**
3087	* Match the basename of a filepath.
3088	*
3089	* ```js
3090	* const picomatch = require('picomatch');
3091	* // picomatch.matchBase(input, glob[, options]);
3092	* console.log(picomatch.matchBase('foo/bar.js', '*.js'); // true
3093	* ```
3094	* @param {String} `input` String to test.
3095	* @param {RegExp\|String} `glob` Glob pattern or regex created by [.makeRe](#makeRe).
3096	* @return {Boolean}
3097	* @api public
3098	*/
3099
3100	picomatch$1.matchBase = (input, glob, options, posix = utils.isWindows(options)) => {
3101	const regex = glob instanceof RegExp ? glob : picomatch$1.makeRe(glob, options);
3102	return regex.test(path$1.basename(input));
3103	};
3104
3105	/**
3106	* Returns true if any of the given glob `patterns` match the specified `string`.
3107	*
3108	* ```js
3109	* const picomatch = require('picomatch');
3110	* // picomatch.isMatch(string, patterns[, options]);
3111	*
3112	* console.log(picomatch.isMatch('a.a', ['b.', '.a'])); //=> true
3113	* console.log(picomatch.isMatch('a.a', 'b.*')); //=> false
3114	* ```
3115	* @param {String\|Array} str The string to test.
3116	* @param {String\|Array} patterns One or more glob patterns to use for matching.
3117	* @param {Object} [options] See available [options](#options).
3118	* @return {Boolean} Returns true if any patterns match `str`
3119	* @api public
3120	*/
3121
3122	picomatch$1.isMatch = (str, patterns, options) => picomatch$1(patterns, options)(str);
3123
3124	/**
3125	* Parse a glob pattern to create the source string for a regular
3126	* expression.
3127	*
3128	* ```js
3129	* const picomatch = require('picomatch');
3130	* const result = picomatch.parse(pattern[, options]);
3131	* ```
3132	* @param {String} `pattern`
3133	* @param {Object} `options`
3134	* @return {Object} Returns an object with useful properties and output to be used as a regex source string.
3135	* @api public
3136	*/
3137
3138	picomatch$1.parse = (pattern, options) => {
3139	if (Array.isArray(pattern)) return pattern.map(p => picomatch$1.parse(p, options));
3140	return parse$1(pattern, { ...options, fastpaths: false });
3141	};
3142
3143	/**
3144	* Scan a glob pattern to separate the pattern into segments.
3145	*
3146	* ```js
3147	* const picomatch = require('picomatch');
3148	* // picomatch.scan(input[, options]);
3149	*
3150	* const result = picomatch.scan('!./foo/*.js');
3151	* console.log(result);
3152	* { prefix: '!./',
3153	* input: '!./foo/*.js',
3154	* start: 3,
3155	* base: 'foo',
3156	* glob: '*.js',
3157	* isBrace: false,
3158	* isBracket: false,
3159	* isGlob: true,
3160	* isExtglob: false,
3161	* isGlobstar: false,
3162	* negated: true }
3163	* ```
3164	* @param {String} `input` Glob pattern to scan.
3165	* @param {Object} `options`
3166	* @return {Object} Returns an object with
3167	* @api public
3168	*/
3169
3170	picomatch$1.scan = (input, options) => scan(input, options);
3171
3172	/**
3173	* Compile a regular expression from the `state` object returned by the
3174	* [parse()](#parse) method.
3175	*
3176	* @param {Object} `state`
3177	* @param {Object} `options`
3178	* @param {Boolean} `returnOutput` Intended for implementors, this argument allows you to return the raw output from the parser.
3179	* @param {Boolean} `returnState` Adds the state to a `state` property on the returned regex. Useful for implementors and debugging.
3180	* @return {RegExp}
3181	* @api public
3182	*/
3183
3184	picomatch$1.compileRe = (state, options, returnOutput = false, returnState = false) => {
3185	if (returnOutput === true) {
3186	return state.output;
3187	}
3188
3189	const opts = options \|\| {};
3190	const prepend = opts.contains ? '' : '^';
3191	const append = opts.contains ? '' : '$';
3192
3193	let source = `${prepend}(?:${state.output})${append}`;
3194	if (state && state.negated === true) {
3195	source = `^(?!${source}).*$`;
3196	}
3197
3198	const regex = picomatch$1.toRegex(source, options);
3199	if (returnState === true) {
3200	regex.state = state;
3201	}
3202
3203	return regex;
3204	};
3205
3206	/**
3207	* Create a regular expression from a parsed glob pattern.
3208	*
3209	* ```js
3210	* const picomatch = require('picomatch');
3211	* const state = picomatch.parse('*.js');
3212	* // picomatch.compileRe(state[, options]);
3213	*
3214	* console.log(picomatch.compileRe(state));
3215	* //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
3216	* ```
3217	* @param {String} `state` The object returned from the `.parse` method.
3218	* @param {Object} `options`
3219	* @param {Boolean} `returnOutput` Implementors may use this argument to return the compiled output, instead of a regular expression. This is not exposed on the options to prevent end-users from mutating the result.
3220	* @param {Boolean} `returnState` Implementors may use this argument to return the state from the parsed glob with the returned regular expression.
3221	* @return {RegExp} Returns a regex created from the given pattern.
3222	* @api public
3223	*/
3224
3225	picomatch$1.makeRe = (input, options = {}, returnOutput = false, returnState = false) => {
3226	if (!input \|\| typeof input !== 'string') {
3227	throw new TypeError('Expected a non-empty string');
3228	}
3229
3230	let parsed = { negated: false, fastpaths: true };
3231
3232	if (options.fastpaths !== false && (input[0] === '.' \|\| input[0] === '*')) {
3233	parsed.output = parse$1.fastpaths(input, options);
3234	}
3235
3236	if (!parsed.output) {
3237	parsed = parse$1(input, options);
3238	}
3239
3240	return picomatch$1.compileRe(parsed, options, returnOutput, returnState);
3241	};
3242
3243	/**
3244	* Create a regular expression from the given regex source string.
3245	*
3246	* ```js
3247	* const picomatch = require('picomatch');
3248	* // picomatch.toRegex(source[, options]);
3249	*
3250	* const { output } = picomatch.parse('*.js');
3251	* console.log(picomatch.toRegex(output));
3252	* //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
3253	* ```
3254	* @param {String} `source` Regular expression source string.
3255	* @param {Object} `options`
3256	* @return {RegExp}
3257	* @api public
3258	*/
3259
3260	picomatch$1.toRegex = (source, options) => {
3261	try {
3262	const opts = options \|\| {};
3263	return new RegExp(source, opts.flags \|\| (opts.nocase ? 'i' : ''));
3264	} catch (err) {
3265	if (options && options.debug === true) throw err;
3266	return /$^/;
3267	}
3268	};
3269
3270	/**
3271	* Picomatch constants.
3272	* @return {Object}
3273	*/
3274
3275	picomatch$1.constants = constants;
3276
3277	/**
3278	* Expose "picomatch"
3279	*/
3280
3281	var picomatch_1 = picomatch$1;
3282
3283	var picomatch = picomatch_1;
3284
3285	var pm = /@__PURE__/getDefaultExportFromCjs(picomatch);
3286
3287	// Helper since Typescript can't detect readonly arrays with Array.isArray
3288	function isArray(arg) {
3289	return Array.isArray(arg);
3290	}
3291	function ensureArray(thing) {
3292	if (isArray(thing))
3293	return thing;
3294	if (thing == null)
3295	return [];
3296	return [thing];
3297	}
3298
3299	const normalizePath$1 = function normalizePath(filename) {
3300	return filename.split(require$$0$1.win32.sep).join(require$$0$1.posix.sep);
3301	};
3302
3303	function getMatcherString(id, resolutionBase) {
3304	if (resolutionBase === false \|\| require$$0$1.isAbsolute(id) \|\| id.startsWith('**')) {
3305	return normalizePath$1(id);
3306	}
3307	// resolve('') is valid and will default to process.cwd()
3308	const basePath = normalizePath$1(require$$0$1.resolve(resolutionBase \|\| ''))
3309	// escape all possible (posix + win) path characters that might interfere with regex
3310	.replace(/[-^$*+?.()\|[\]{}]/g, '\\$&');
3311	// Note that we use posix.join because:
3312	// 1. the basePath has been normalized to use /
3313	// 2. the incoming glob (id) matcher, also uses /
3314	// otherwise Node will force backslash (\) on windows
3315	return require$$0$1.posix.join(basePath, normalizePath$1(id));
3316	}
3317	const createFilter$1 = function createFilter(include, exclude, options) {
3318	const resolutionBase = options && options.resolve;
3319	const getMatcher = (id) => id instanceof RegExp
3320	? id
3321	: {
3322	test: (what) => {
3323	// this refactor is a tad overly verbose but makes for easy debugging
3324	const pattern = getMatcherString(id, resolutionBase);
3325	const fn = pm(pattern, { dot: true });
3326	const result = fn(what);
3327	return result;
3328	}
3329	};
3330	const includeMatchers = ensureArray(include).map(getMatcher);
3331	const excludeMatchers = ensureArray(exclude).map(getMatcher);
3332	return function result(id) {
3333	if (typeof id !== 'string')
3334	return false;
3335	if (/\0/.test(id))
3336	return false;
3337	const pathId = normalizePath$1(id);
3338	for (let i = 0; i < excludeMatchers.length; ++i) {
3339	const matcher = excludeMatchers[i];
3340	if (matcher.test(pathId))
3341	return false;
3342	}
3343	for (let i = 0; i < includeMatchers.length; ++i) {
3344	const matcher = includeMatchers[i];
3345	if (matcher.test(pathId))
3346	return true;
3347	}
3348	return !includeMatchers.length;
3349	};
3350	};
3351
3352	const reservedWords = 'break case class catch const continue debugger default delete do else export extends finally for function if import in instanceof let new return super switch this throw try typeof var void while with yield enum await implements package protected static interface private public';
3353	const builtins = 'arguments Infinity NaN undefined null true false eval uneval isFinite isNaN parseFloat parseInt decodeURI decodeURIComponent encodeURI encodeURIComponent escape unescape Object Function Boolean Symbol Error EvalError InternalError RangeError ReferenceError SyntaxError TypeError URIError Number Math Date String RegExp Array Int8Array Uint8Array Uint8ClampedArray Int16Array Uint16Array Int32Array Uint32Array Float32Array Float64Array Map Set WeakMap WeakSet SIMD ArrayBuffer DataView JSON Promise Generator GeneratorFunction Reflect Proxy Intl';
3354	const forbiddenIdentifiers = new Set(`${reservedWords} ${builtins}`.split(' '));
3355	forbiddenIdentifiers.add('');
3356
3357	const isWindows = typeof process !== "undefined" && process.platform === "win32";
3358	const windowsSlashRE = /\\/g;
3359	function slash(p) {
3360	return p.replace(windowsSlashRE, "/");
3361	}
3362	const postfixRE = /[?#].*$/;
3363	function cleanUrl(url) {
3364	return url.replace(postfixRE, "");
3365	}
3366	function withTrailingSlash(path) {
3367	if (path[path.length - 1] !== "/") {
3368	return `${path}/`;
3369	}
3370	return path;
3371	}
3372
3373	if (process.versions.pnp) {
3374	try {
3375	node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.src \|\| new URL('node-cjs/publicUtils.cjs', document.baseURI).href)))("pnpapi");
3376	} catch {
3377	}
3378	}
3379
3380	const createFilter = createFilter$1;
3381	node_module.builtinModules.filter((id) => !id.includes(":"));
3382	function isInNodeModules(id) {
3383	return id.includes("node_modules");
3384	}
3385	const _require = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.src \|\| new URL('node-cjs/publicUtils.cjs', document.baseURI).href)));
3386	function resolveDependencyVersion(dep, pkgRelativePath = "../../package.json") {
3387	const pkgPath = path$3.resolve(_require.resolve(dep), pkgRelativePath);
3388	return JSON.parse(fs$1.readFileSync(pkgPath, "utf-8")).version;
3389	}
3390	const rollupVersion = resolveDependencyVersion("rollup");
3391	const filter = process.env.VITE_DEBUG_FILTER;
3392	const DEBUG = process.env.DEBUG;
3393	function createDebugger(namespace, options = {}) {
3394	const log = debug$2(namespace);
3395	const { onlyWhenFocused } = options;
3396	let enabled = log.enabled;
3397	if (enabled && onlyWhenFocused) {
3398	const ns = typeof onlyWhenFocused === "string" ? onlyWhenFocused : namespace;
3399	enabled = !!DEBUG?.includes(ns);
3400	}
3401	if (enabled) {
3402	return (...args) => {
3403	if (!filter \|\| args.some((a) => a?.includes?.(filter))) {
3404	log(...args);
3405	}
3406	};
3407	}
3408	}
3409	function testCaseInsensitiveFS() {
3410	if (!CLIENT_ENTRY.endsWith("client.mjs")) {
3411	throw new Error(
3412	`cannot test case insensitive FS, CLIENT_ENTRY const doesn't contain client.mjs`
3413	);
3414	}
3415	if (!fs$1.existsSync(CLIENT_ENTRY)) {
3416	throw new Error(
3417	"cannot test case insensitive FS, CLIENT_ENTRY does not point to an existing file: " + CLIENT_ENTRY
3418	);
3419	}
3420	return fs$1.existsSync(CLIENT_ENTRY.replace("client.mjs", "cLiEnT.mjs"));
3421	}
3422	const isCaseInsensitiveFS = testCaseInsensitiveFS();
3423	const VOLUME_RE = /^[A-Z]:/i;
3424	function normalizePath(id) {
3425	return path$3.posix.normalize(isWindows ? slash(id) : id);
3426	}
3427	function fsPathFromId(id) {
3428	const fsPath = normalizePath(
3429	id.startsWith(FS_PREFIX) ? id.slice(FS_PREFIX.length) : id
3430	);
3431	return fsPath[0] === "/" \|\| VOLUME_RE.test(fsPath) ? fsPath : `/${fsPath}`;
3432	}
3433	function fsPathFromUrl(url) {
3434	return fsPathFromId(cleanUrl(url));
3435	}
3436	function isParentDirectory(dir, file) {
3437	dir = withTrailingSlash(dir);
3438	return file.startsWith(dir) \|\| isCaseInsensitiveFS && file.toLowerCase().startsWith(dir.toLowerCase());
3439	}
3440	function isSameFileUri(file1, file2) {
3441	return file1 === file2 \|\| isCaseInsensitiveFS && file1.toLowerCase() === file2.toLowerCase();
3442	}
3443	const trailingSeparatorRE = /[?&]$/;
3444	const timestampRE = /\bt=\d{13}&?\b/;
3445	function removeTimestampQuery(url) {
3446	return url.replace(timestampRE, "").replace(trailingSeparatorRE, "");
3447	}
3448	function isObject$1(value) {
3449	return Object.prototype.toString.call(value) === "[object Object]";
3450	}
3451	function tryStatSync(file) {
3452	try {
3453	return fs$1.statSync(file, { throwIfNoEntry: false });
3454	} catch {
3455	}
3456	}
3457	function isFileReadable(filename) {
3458	if (!tryStatSync(filename)) {
3459	return false;
3460	}
3461	try {
3462	fs$1.accessSync(filename, fs$1.constants.R_OK);
3463	return true;
3464	} catch {
3465	return false;
3466	}
3467	}
3468	function arraify(target) {
3469	return Array.isArray(target) ? target : [target];
3470	}
3471	path$3.dirname(node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.src \|\| new URL('node-cjs/publicUtils.cjs', document.baseURI).href))));
3472	function backwardCompatibleWorkerPlugins(plugins) {
3473	if (Array.isArray(plugins)) {
3474	return plugins;
3475	}
3476	if (typeof plugins === "function") {
3477	return plugins();
3478	}
3479	return [];
3480	}
3481	function mergeConfigRecursively(defaults, overrides, rootPath) {
3482	const merged = { ...defaults };
3483	for (const key in overrides) {
3484	const value = overrides[key];
3485	if (value == null) {
3486	continue;
3487	}
3488	const existing = merged[key];
3489	if (existing == null) {
3490	merged[key] = value;
3491	continue;
3492	}
3493	if (key === "alias" && (rootPath === "resolve" \|\| rootPath === "")) {
3494	merged[key] = mergeAlias(existing, value);
3495	continue;
3496	} else if (key === "assetsInclude" && rootPath === "") {
3497	merged[key] = [].concat(existing, value);
3498	continue;
3499	} else if (key === "noExternal" && rootPath === "ssr" && (existing === true \|\| value === true)) {
3500	merged[key] = true;
3501	continue;
3502	} else if (key === "plugins" && rootPath === "worker") {
3503	merged[key] = () => [
3504	...backwardCompatibleWorkerPlugins(existing),
3505	...backwardCompatibleWorkerPlugins(value)
3506	];
3507	continue;
3508	}
3509	if (Array.isArray(existing) \|\| Array.isArray(value)) {
3510	merged[key] = [...arraify(existing), ...arraify(value)];
3511	continue;
3512	}
3513	if (isObject$1(existing) && isObject$1(value)) {
3514	merged[key] = mergeConfigRecursively(
3515	existing,
3516	value,
3517	rootPath ? `${rootPath}.${key}` : key
3518	);
3519	continue;
3520	}
3521	merged[key] = value;
3522	}
3523	return merged;
3524	}
3525	function mergeConfig(defaults, overrides, isRoot = true) {
3526	if (typeof defaults === "function" \|\| typeof overrides === "function") {
3527	throw new Error(`Cannot merge config in form of callback`);
3528	}
3529	return mergeConfigRecursively(defaults, overrides, isRoot ? "" : ".");
3530	}
3531	function mergeAlias(a, b) {
3532	if (!a) return b;
3533	if (!b) return a;
3534	if (isObject$1(a) && isObject$1(b)) {
3535	return { ...a, ...b };
3536	}
3537	return [...normalizeAlias(b), ...normalizeAlias(a)];
3538	}
3539	function normalizeAlias(o = []) {
3540	return Array.isArray(o) ? o.map(normalizeSingleAlias) : Object.keys(o).map(
3541	(find) => normalizeSingleAlias({
3542	find,
3543	replacement: o[find]
3544	})
3545	);
3546	}
3547	function normalizeSingleAlias({
3548	find,
3549	replacement,
3550	customResolver
3551	}) {
3552	if (typeof find === "string" && find[find.length - 1] === "/" && replacement[replacement.length - 1] === "/") {
3553	find = find.slice(0, find.length - 1);
3554	replacement = replacement.slice(0, replacement.length - 1);
3555	}
3556	const alias = {
3557	find,
3558	replacement
3559	};
3560	if (customResolver) {
3561	alias.customResolver = customResolver;
3562	}
3563	return alias;
3564	}
3565
3566	const CSS_LANGS_RE = (
3567	// eslint-disable-next-line regexp/no-unused-capturing-group
3568	/\.(css\|less\|sass\|scss\|styl\|stylus\|pcss\|postcss\|sss)(?:$\|\?)/
3569	);
3570	const isCSSRequest = (request) => CSS_LANGS_RE.test(request);
3571	class SplitVendorChunkCache {
3572	cache;
3573	constructor() {
3574	this.cache = /* @__PURE__ */ new Map();
3575	}
3576	reset() {
3577	this.cache = /* @__PURE__ */ new Map();
3578	}
3579	}
3580	function splitVendorChunk(options = {}) {
3581	const cache = options.cache ?? new SplitVendorChunkCache();
3582	return (id, { getModuleInfo }) => {
3583	if (isInNodeModules(id) && !isCSSRequest(id) && staticImportedByEntry(id, getModuleInfo, cache.cache)) {
3584	return "vendor";
3585	}
3586	};
3587	}
3588	function staticImportedByEntry(id, getModuleInfo, cache, importStack = []) {
3589	if (cache.has(id)) {
3590	return cache.get(id);
3591	}
3592	if (importStack.includes(id)) {
3593	cache.set(id, false);
3594	return false;
3595	}
3596	const mod = getModuleInfo(id);
3597	if (!mod) {
3598	cache.set(id, false);
3599	return false;
3600	}
3601	if (mod.isEntry) {
3602	cache.set(id, true);
3603	return true;
3604	}
3605	const someImporterIs = mod.importers.some(
3606	(importer) => staticImportedByEntry(
3607	importer,
3608	getModuleInfo,
3609	cache,
3610	importStack.concat(id)
3611	)
3612	);
3613	cache.set(id, someImporterIs);
3614	return someImporterIs;
3615	}
3616	function splitVendorChunkPlugin() {
3617	const caches = [];
3618	function createSplitVendorChunk(output, config) {
3619	const cache = new SplitVendorChunkCache();
3620	caches.push(cache);
3621	const build = config.build ?? {};
3622	const format = output?.format;
3623	if (!build.ssr && !build.lib && format !== "umd" && format !== "iife") {
3624	return splitVendorChunk({ cache });
3625	}
3626	}
3627	return {
3628	name: "vite:split-vendor-chunk",
3629	config(config) {
3630	let outputs = config?.build?.rollupOptions?.output;
3631	if (outputs) {
3632	outputs = arraify(outputs);
3633	for (const output of outputs) {
3634	const viteManualChunks = createSplitVendorChunk(output, config);
3635	if (viteManualChunks) {
3636	if (output.manualChunks) {
3637	if (typeof output.manualChunks === "function") {
3638	const userManualChunks = output.manualChunks;
3639	output.manualChunks = (id, api) => {
3640	return userManualChunks(id, api) ?? viteManualChunks(id, api);
3641	};
3642	} else {
3643	console.warn(
3644	"(!) the `splitVendorChunk` plugin doesn't have any effect when using the object form of `build.rollupOptions.output.manualChunks`. Consider using the function form instead."
3645	);
3646	}
3647	} else {
3648	output.manualChunks = viteManualChunks;
3649	}
3650	}
3651	}
3652	} else {
3653	return {
3654	build: {
3655	rollupOptions: {
3656	output: {
3657	manualChunks: createSplitVendorChunk({}, config)
3658	}
3659	}
3660	}
3661	};
3662	}
3663	},
3664	buildStart() {
3665	caches.forEach((cache) => cache.reset());
3666	}
3667	};
3668	}
3669
3670	var convertSourceMap$1 = {};
3671
3672	(function (exports) {
3673
3674	Object.defineProperty(exports, 'commentRegex', {
3675	get: function getCommentRegex () {
3676	// Groups: 1: media type, 2: MIME type, 3: charset, 4: encoding, 5: data.
3677	return /^\s?\/[\/\][@#]\s+?sourceMappingURL=data:(((?:application\|text)\/json)(?:;charset=([^;,]+?)?)?)?(?:;(base64))?,(.*?)$/mg;
3678	}
3679	});
3680
3681
3682	Object.defineProperty(exports, 'mapFileCommentRegex', {
3683	get: function getMapFileCommentRegex () {
3684	// Matches sourceMappingURL in either // or /* comment styles.
3685	return /(?:\/\/[@#][ \t]+?sourceMappingURL=([^\s'"`]+?)[ \t]?$)\|(?:\/\[@#][ \t]+sourceMappingURL=([^]+?)[ \t]?(?:\\/){1}[ \t]?$)/mg;
3686	}
3687	});
3688
3689	var decodeBase64;
3690	if (typeof Buffer !== 'undefined') {
3691	if (typeof Buffer.from === 'function') {
3692	decodeBase64 = decodeBase64WithBufferFrom;
3693	} else {
3694	decodeBase64 = decodeBase64WithNewBuffer;
3695	}
3696	} else {
3697	decodeBase64 = decodeBase64WithAtob;
3698	}
3699
3700	function decodeBase64WithBufferFrom(base64) {
3701	return Buffer.from(base64, 'base64').toString();
3702	}
3703
3704	function decodeBase64WithNewBuffer(base64) {
3705	if (typeof value === 'number') {
3706	throw new TypeError('The value to decode must not be of type number.');
3707	}
3708	return new Buffer(base64, 'base64').toString();
3709	}
3710
3711	function decodeBase64WithAtob(base64) {
3712	return decodeURIComponent(escape(atob(base64)));
3713	}
3714
3715	function stripComment(sm) {
3716	return sm.split(',').pop();
3717	}
3718
3719	function readFromFileMap(sm, read) {
3720	var r = exports.mapFileCommentRegex.exec(sm);
3721	// for some odd reason //# .. captures in 1 and /* .. */ in 2
3722	var filename = r[1] \|\| r[2];
3723
3724	try {
3725	var sm = read(filename);
3726	if (sm != null && typeof sm.catch === 'function') {
3727	return sm.catch(throwError);
3728	} else {
3729	return sm;
3730	}
3731	} catch (e) {
3732	throwError(e);
3733	}
3734
3735	function throwError(e) {
3736	throw new Error('An error occurred while trying to read the map file at ' + filename + '\n' + e.stack);
3737	}
3738	}
3739
3740	function Converter (sm, opts) {
3741	opts = opts \|\| {};
3742
3743	if (opts.hasComment) {
3744	sm = stripComment(sm);
3745	}
3746
3747	if (opts.encoding === 'base64') {
3748	sm = decodeBase64(sm);
3749	} else if (opts.encoding === 'uri') {
3750	sm = decodeURIComponent(sm);
3751	}
3752
3753	if (opts.isJSON \|\| opts.encoding) {
3754	sm = JSON.parse(sm);
3755	}
3756
3757	this.sourcemap = sm;
3758	}
3759
3760	Converter.prototype.toJSON = function (space) {
3761	return JSON.stringify(this.sourcemap, null, space);
3762	};
3763
3764	if (typeof Buffer !== 'undefined') {
3765	if (typeof Buffer.from === 'function') {
3766	Converter.prototype.toBase64 = encodeBase64WithBufferFrom;
3767	} else {
3768	Converter.prototype.toBase64 = encodeBase64WithNewBuffer;
3769	}
3770	} else {
3771	Converter.prototype.toBase64 = encodeBase64WithBtoa;
3772	}
3773
3774	function encodeBase64WithBufferFrom() {
3775	var json = this.toJSON();
3776	return Buffer.from(json, 'utf8').toString('base64');
3777	}
3778
3779	function encodeBase64WithNewBuffer() {
3780	var json = this.toJSON();
3781	if (typeof json === 'number') {
3782	throw new TypeError('The json to encode must not be of type number.');
3783	}
3784	return new Buffer(json, 'utf8').toString('base64');
3785	}
3786
3787	function encodeBase64WithBtoa() {
3788	var json = this.toJSON();
3789	return btoa(unescape(encodeURIComponent(json)));
3790	}
3791
3792	Converter.prototype.toURI = function () {
3793	var json = this.toJSON();
3794	return encodeURIComponent(json);
3795	};
3796
3797	Converter.prototype.toComment = function (options) {
3798	var encoding, content, data;
3799	if (options != null && options.encoding === 'uri') {
3800	encoding = '';
3801	content = this.toURI();
3802	} else {
3803	encoding = ';base64';
3804	content = this.toBase64();
3805	}
3806	data = 'sourceMappingURL=data:application/json;charset=utf-8' + encoding + ',' + content;
3807	return options != null && options.multiline ? '/# ' + data + ' /' : '//# ' + data;
3808	};
3809
3810	// returns copy instead of original
3811	Converter.prototype.toObject = function () {
3812	return JSON.parse(this.toJSON());
3813	};
3814
3815	Converter.prototype.addProperty = function (key, value) {
3816	if (this.sourcemap.hasOwnProperty(key)) throw new Error('property "' + key + '" already exists on the sourcemap, use set property instead');
3817	return this.setProperty(key, value);
3818	};
3819
3820	Converter.prototype.setProperty = function (key, value) {
3821	this.sourcemap[key] = value;
3822	return this;
3823	};
3824
3825	Converter.prototype.getProperty = function (key) {
3826	return this.sourcemap[key];
3827	};
3828
3829	exports.fromObject = function (obj) {
3830	return new Converter(obj);
3831	};
3832
3833	exports.fromJSON = function (json) {
3834	return new Converter(json, { isJSON: true });
3835	};
3836
3837	exports.fromURI = function (uri) {
3838	return new Converter(uri, { encoding: 'uri' });
3839	};
3840
3841	exports.fromBase64 = function (base64) {
3842	return new Converter(base64, { encoding: 'base64' });
3843	};
3844
3845	exports.fromComment = function (comment) {
3846	var m, encoding;
3847	comment = comment
3848	.replace(/^\/\*/g, '//')
3849	.replace(/\*\/$/g, '');
3850	m = exports.commentRegex.exec(comment);
3851	encoding = m && m[4] \|\| 'uri';
3852	return new Converter(comment, { encoding: encoding, hasComment: true });
3853	};
3854
3855	function makeConverter(sm) {
3856	return new Converter(sm, { isJSON: true });
3857	}
3858
3859	exports.fromMapFileComment = function (comment, read) {
3860	if (typeof read === 'string') {
3861	throw new Error(
3862	'String directory paths are no longer supported with `fromMapFileComment`\n' +
3863	'Please review the Upgrading documentation at https://github.com/thlorenz/convert-source-map#upgrading'
3864	)
3865	}
3866
3867	var sm = readFromFileMap(comment, read);
3868	if (sm != null && typeof sm.then === 'function') {
3869	return sm.then(makeConverter);
3870	} else {
3871	return makeConverter(sm);
3872	}
3873	};
3874
3875	// Finds last sourcemap comment in file or returns null if none was found
3876	exports.fromSource = function (content) {
3877	var m = content.match(exports.commentRegex);
3878	return m ? exports.fromComment(m.pop()) : null;
3879	};
3880
3881	// Finds last sourcemap comment in file or returns null if none was found
3882	exports.fromMapFileSource = function (content, read) {
3883	if (typeof read === 'string') {
3884	throw new Error(
3885	'String directory paths are no longer supported with `fromMapFileSource`\n' +
3886	'Please review the Upgrading documentation at https://github.com/thlorenz/convert-source-map#upgrading'
3887	)
3888	}
3889	var m = content.match(exports.mapFileCommentRegex);
3890	return m ? exports.fromMapFileComment(m.pop(), read) : null;
3891	};
3892
3893	exports.removeComments = function (src) {
3894	return src.replace(exports.commentRegex, '');
3895	};
3896
3897	exports.removeMapFileComments = function (src) {
3898	return src.replace(exports.mapFileCommentRegex, '');
3899	};
3900
3901	exports.generateMapFileComment = function (file, options) {
3902	var data = 'sourceMappingURL=' + file;
3903	return options && options.multiline ? '/# ' + data + ' /' : '//# ' + data;
3904	};
3905	} (convertSourceMap$1));
3906
3907	var convertSourceMap = /@__PURE__/getDefaultExportFromCjs(convertSourceMap$1);
3908
3909	/*!
3910	* etag
3911	* Copyright(c) 2014-2016 Douglas Christopher Wilson
3912	* MIT Licensed
3913	*/
3914
3915	/**
3916	* Module exports.
3917	* @public
3918	*/
3919
3920	var etag_1 = etag;
3921
3922	/**
3923	* Module dependencies.
3924	* @private
3925	*/
3926
3927	var crypto$1 = require$$0$2;
3928	var Stats = fs$2.Stats;
3929
3930	/**
3931	* Module variables.
3932	* @private
3933	*/
3934
3935	var toString$1 = Object.prototype.toString;
3936
3937	/**
3938	* Generate an entity tag.
3939	*
3940	* @param {Buffer\|string} entity
3941	* @return {string}
3942	* @private
3943	*/
3944
3945	function entitytag (entity) {
3946	if (entity.length === 0) {
3947	// fast-path empty
3948	return '"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk"'
3949	}
3950
3951	// compute hash of entity
3952	var hash = crypto$1
3953	.createHash('sha1')
3954	.update(entity, 'utf8')
3955	.digest('base64')
3956	.substring(0, 27);
3957
3958	// compute length of entity
3959	var len = typeof entity === 'string'
3960	? Buffer.byteLength(entity, 'utf8')
3961	: entity.length;
3962
3963	return '"' + len.toString(16) + '-' + hash + '"'
3964	}
3965
3966	/**
3967	* Create a simple ETag.
3968	*
3969	* @param {string\|Buffer\|Stats} entity
3970	* @param {object} [options]
3971	* @param {boolean} [options.weak]
3972	* @return {String}
3973	* @public
3974	*/
3975
3976	function etag (entity, options) {
3977	if (entity == null) {
3978	throw new TypeError('argument entity is required')
3979	}
3980
3981	// support fs.Stats object
3982	var isStats = isstats(entity);
3983	var weak = options && typeof options.weak === 'boolean'
3984	? options.weak
3985	: isStats;
3986
3987	// validate argument
3988	if (!isStats && typeof entity !== 'string' && !Buffer.isBuffer(entity)) {
3989	throw new TypeError('argument entity must be string, Buffer, or fs.Stats')
3990	}
3991
3992	// generate entity tag
3993	var tag = isStats
3994	? stattag(entity)
3995	: entitytag(entity);
3996
3997	return weak
3998	? 'W/' + tag
3999	: tag
4000	}
4001
4002	/**
4003	* Determine if object is a Stats object.
4004	*
4005	* @param {object} obj
4006	* @return {boolean}
4007	* @api private
4008	*/
4009
4010	function isstats (obj) {
4011	// genuine fs.Stats
4012	if (typeof Stats === 'function' && obj instanceof Stats) {
4013	return true
4014	}
4015
4016	// quack quack
4017	return obj && typeof obj === 'object' &&
4018	'ctime' in obj && toString$1.call(obj.ctime) === '[object Date]' &&
4019	'mtime' in obj && toString$1.call(obj.mtime) === '[object Date]' &&
4020	'ino' in obj && typeof obj.ino === 'number' &&
4021	'size' in obj && typeof obj.size === 'number'
4022	}
4023
4024	/**
4025	* Generate a tag for a stat.
4026	*
4027	* @param {object} stat
4028	* @return {string}
4029	* @private
4030	*/
4031
4032	function stattag (stat) {
4033	var mtime = stat.mtime.getTime().toString(16);
4034	var size = stat.size.toString(16);
4035
4036	return '"' + size + '-' + mtime + '"'
4037	}
4038
4039	var getEtag = /@__PURE__/getDefaultExportFromCjs(etag_1);
4040
4041	class BitSet {
4042	constructor(arg) {
4043	this.bits = arg instanceof BitSet ? arg.bits.slice() : [];
4044	}
4045
4046	add(n) {
4047	this.bits[n >> 5] \|= 1 << (n & 31);
4048	}
4049
4050	has(n) {
4051	return !!(this.bits[n >> 5] & (1 << (n & 31)));
4052	}
4053	}
4054
4055	class Chunk {
4056	constructor(start, end, content) {
4057	this.start = start;
4058	this.end = end;
4059	this.original = content;
4060
4061	this.intro = '';
4062	this.outro = '';
4063
4064	this.content = content;
4065	this.storeName = false;
4066	this.edited = false;
4067
4068	{
4069	this.previous = null;
4070	this.next = null;
4071	}
4072	}
4073
4074	appendLeft(content) {
4075	this.outro += content;
4076	}
4077
4078	appendRight(content) {
4079	this.intro = this.intro + content;
4080	}
4081
4082	clone() {
4083	const chunk = new Chunk(this.start, this.end, this.original);
4084
4085	chunk.intro = this.intro;
4086	chunk.outro = this.outro;
4087	chunk.content = this.content;
4088	chunk.storeName = this.storeName;
4089	chunk.edited = this.edited;
4090
4091	return chunk;
4092	}
4093
4094	contains(index) {
4095	return this.start < index && index < this.end;
4096	}
4097
4098	eachNext(fn) {
4099	let chunk = this;
4100	while (chunk) {
4101	fn(chunk);
4102	chunk = chunk.next;
4103	}
4104	}
4105
4106	eachPrevious(fn) {
4107	let chunk = this;
4108	while (chunk) {
4109	fn(chunk);
4110	chunk = chunk.previous;
4111	}
4112	}
4113
4114	edit(content, storeName, contentOnly) {
4115	this.content = content;
4116	if (!contentOnly) {
4117	this.intro = '';
4118	this.outro = '';
4119	}
4120	this.storeName = storeName;
4121
4122	this.edited = true;
4123
4124	return this;
4125	}
4126
4127	prependLeft(content) {
4128	this.outro = content + this.outro;
4129	}
4130
4131	prependRight(content) {
4132	this.intro = content + this.intro;
4133	}
4134
4135	reset() {
4136	this.intro = '';
4137	this.outro = '';
4138	if (this.edited) {
4139	this.content = this.original;
4140	this.storeName = false;
4141	this.edited = false;
4142	}
4143	}
4144
4145	split(index) {
4146	const sliceIndex = index - this.start;
4147
4148	const originalBefore = this.original.slice(0, sliceIndex);
4149	const originalAfter = this.original.slice(sliceIndex);
4150
4151	this.original = originalBefore;
4152
4153	const newChunk = new Chunk(index, this.end, originalAfter);
4154	newChunk.outro = this.outro;
4155	this.outro = '';
4156
4157	this.end = index;
4158
4159	if (this.edited) {
4160	// after split we should save the edit content record into the correct chunk
4161	// to make sure sourcemap correct
4162	// For example:
4163	// ' test'.trim()
4164	// split -> ' ' + 'test'
4165	// ✔️ edit -> '' + 'test'
4166	// ✖️ edit -> 'test' + ''
4167	// TODO is this block necessary?...
4168	newChunk.edit('', false);
4169	this.content = '';
4170	} else {
4171	this.content = originalBefore;
4172	}
4173
4174	newChunk.next = this.next;
4175	if (newChunk.next) newChunk.next.previous = newChunk;
4176	newChunk.previous = this;
4177	this.next = newChunk;
4178
4179	return newChunk;
4180	}
4181
4182	toString() {
4183	return this.intro + this.content + this.outro;
4184	}
4185
4186	trimEnd(rx) {
4187	this.outro = this.outro.replace(rx, '');
4188	if (this.outro.length) return true;
4189
4190	const trimmed = this.content.replace(rx, '');
4191
4192	if (trimmed.length) {
4193	if (trimmed !== this.content) {
4194	this.split(this.start + trimmed.length).edit('', undefined, true);
4195	if (this.edited) {
4196	// save the change, if it has been edited
4197	this.edit(trimmed, this.storeName, true);
4198	}
4199	}
4200	return true;
4201	} else {
4202	this.edit('', undefined, true);
4203
4204	this.intro = this.intro.replace(rx, '');
4205	if (this.intro.length) return true;
4206	}
4207	}
4208
4209	trimStart(rx) {
4210	this.intro = this.intro.replace(rx, '');
4211	if (this.intro.length) return true;
4212
4213	const trimmed = this.content.replace(rx, '');
4214
4215	if (trimmed.length) {
4216	if (trimmed !== this.content) {
4217	const newChunk = this.split(this.end - trimmed.length);
4218	if (this.edited) {
4219	// save the change, if it has been edited
4220	newChunk.edit(trimmed, this.storeName, true);
4221	}
4222	this.edit('', undefined, true);
4223	}
4224	return true;
4225	} else {
4226	this.edit('', undefined, true);
4227
4228	this.outro = this.outro.replace(rx, '');
4229	if (this.outro.length) return true;
4230	}
4231	}
4232	}
4233
4234	function getBtoa() {
4235	if (typeof globalThis !== 'undefined' && typeof globalThis.btoa === 'function') {
4236	return (str) => globalThis.btoa(unescape(encodeURIComponent(str)));
4237	} else if (typeof Buffer === 'function') {
4238	return (str) => Buffer.from(str, 'utf-8').toString('base64');
4239	} else {
4240	return () => {
4241	throw new Error('Unsupported environment: `window.btoa` or `Buffer` should be supported.');
4242	};
4243	}
4244	}
4245
4246	const btoa$1 = /#__PURE__/ getBtoa();
4247
4248	class SourceMap {
4249	constructor(properties) {
4250	this.version = 3;
4251	this.file = properties.file;
4252	this.sources = properties.sources;
4253	this.sourcesContent = properties.sourcesContent;
4254	this.names = properties.names;
4255	this.mappings = encode(properties.mappings);
4256	if (typeof properties.x_google_ignoreList !== 'undefined') {
4257	this.x_google_ignoreList = properties.x_google_ignoreList;
4258	}
4259	}
4260
4261	toString() {
4262	return JSON.stringify(this);
4263	}
4264
4265	toUrl() {
4266	return 'data:application/json;charset=utf-8;base64,' + btoa$1(this.toString());
4267	}
4268	}
4269
4270	function guessIndent(code) {
4271	const lines = code.split('\n');
4272
4273	const tabbed = lines.filter((line) => /^\t+/.test(line));
4274	const spaced = lines.filter((line) => /^ {2,}/.test(line));
4275
4276	if (tabbed.length === 0 && spaced.length === 0) {
4277	return null;
4278	}
4279
4280	// More lines tabbed than spaced? Assume tabs, and
4281	// default to tabs in the case of a tie (or nothing
4282	// to go on)
4283	if (tabbed.length >= spaced.length) {
4284	return '\t';
4285	}
4286
4287	// Otherwise, we need to guess the multiple
4288	const min = spaced.reduce((previous, current) => {
4289	const numSpaces = /^ +/.exec(current)[0].length;
4290	return Math.min(numSpaces, previous);
4291	}, Infinity);
4292
4293	return new Array(min + 1).join(' ');
4294	}
4295
4296	function getRelativePath(from, to) {
4297	const fromParts = from.split(/[/\\]/);
4298	const toParts = to.split(/[/\\]/);
4299
4300	fromParts.pop(); // get dirname
4301
4302	while (fromParts[0] === toParts[0]) {
4303	fromParts.shift();
4304	toParts.shift();
4305	}
4306
4307	if (fromParts.length) {
4308	let i = fromParts.length;
4309	while (i--) fromParts[i] = '..';
4310	}
4311
4312	return fromParts.concat(toParts).join('/');
4313	}
4314
4315	const toString = Object.prototype.toString;
4316
4317	function isObject(thing) {
4318	return toString.call(thing) === '[object Object]';
4319	}
4320
4321	function getLocator(source) {
4322	const originalLines = source.split('\n');
4323	const lineOffsets = [];
4324
4325	for (let i = 0, pos = 0; i < originalLines.length; i++) {
4326	lineOffsets.push(pos);
4327	pos += originalLines[i].length + 1;
4328	}
4329
4330	return function locate(index) {
4331	let i = 0;
4332	let j = lineOffsets.length;
4333	while (i < j) {
4334	const m = (i + j) >> 1;
4335	if (index < lineOffsets[m]) {
4336	j = m;
4337	} else {
4338	i = m + 1;
4339	}
4340	}
4341	const line = i - 1;
4342	const column = index - lineOffsets[line];
4343	return { line, column };
4344	};
4345	}
4346
4347	const wordRegex = /\w/;
4348
4349	class Mappings {
4350	constructor(hires) {
4351	this.hires = hires;
4352	this.generatedCodeLine = 0;
4353	this.generatedCodeColumn = 0;
4354	this.raw = [];
4355	this.rawSegments = this.raw[this.generatedCodeLine] = [];
4356	this.pending = null;
4357	}
4358
4359	addEdit(sourceIndex, content, loc, nameIndex) {
4360	if (content.length) {
4361	const contentLengthMinusOne = content.length - 1;
4362	let contentLineEnd = content.indexOf('\n', 0);
4363	let previousContentLineEnd = -1;
4364	// Loop through each line in the content and add a segment, but stop if the last line is empty,
4365	// else code afterwards would fill one line too many
4366	while (contentLineEnd >= 0 && contentLengthMinusOne > contentLineEnd) {
4367	const segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];
4368	if (nameIndex >= 0) {
4369	segment.push(nameIndex);
4370	}
4371	this.rawSegments.push(segment);
4372
4373	this.generatedCodeLine += 1;
4374	this.raw[this.generatedCodeLine] = this.rawSegments = [];
4375	this.generatedCodeColumn = 0;
4376
4377	previousContentLineEnd = contentLineEnd;
4378	contentLineEnd = content.indexOf('\n', contentLineEnd + 1);
4379	}
4380
4381	const segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];
4382	if (nameIndex >= 0) {
4383	segment.push(nameIndex);
4384	}
4385	this.rawSegments.push(segment);
4386
4387	this.advance(content.slice(previousContentLineEnd + 1));
4388	} else if (this.pending) {
4389	this.rawSegments.push(this.pending);
4390	this.advance(content);
4391	}
4392
4393	this.pending = null;
4394	}
4395
4396	addUneditedChunk(sourceIndex, chunk, original, loc, sourcemapLocations) {
4397	let originalCharIndex = chunk.start;
4398	let first = true;
4399	// when iterating each char, check if it's in a word boundary
4400	let charInHiresBoundary = false;
4401
4402	while (originalCharIndex < chunk.end) {
4403	if (this.hires \|\| first \|\| sourcemapLocations.has(originalCharIndex)) {
4404	const segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];
4405
4406	if (this.hires === 'boundary') {
4407	// in hires "boundary", group segments per word boundary than per char
4408	if (wordRegex.test(original[originalCharIndex])) {
4409	// for first char in the boundary found, start the boundary by pushing a segment
4410	if (!charInHiresBoundary) {
4411	this.rawSegments.push(segment);
4412	charInHiresBoundary = true;
4413	}
4414	} else {
4415	// for non-word char, end the boundary by pushing a segment
4416	this.rawSegments.push(segment);
4417	charInHiresBoundary = false;
4418	}
4419	} else {
4420	this.rawSegments.push(segment);
4421	}
4422	}
4423
4424	if (original[originalCharIndex] === '\n') {
4425	loc.line += 1;
4426	loc.column = 0;
4427	this.generatedCodeLine += 1;
4428	this.raw[this.generatedCodeLine] = this.rawSegments = [];
4429	this.generatedCodeColumn = 0;
4430	first = true;
4431	} else {
4432	loc.column += 1;
4433	this.generatedCodeColumn += 1;
4434	first = false;
4435	}
4436
4437	originalCharIndex += 1;
4438	}
4439
4440	this.pending = null;
4441	}
4442
4443	advance(str) {
4444	if (!str) return;
4445
4446	const lines = str.split('\n');
4447
4448	if (lines.length > 1) {
4449	for (let i = 0; i < lines.length - 1; i++) {
4450	this.generatedCodeLine++;
4451	this.raw[this.generatedCodeLine] = this.rawSegments = [];
4452	}
4453	this.generatedCodeColumn = 0;
4454	}
4455
4456	this.generatedCodeColumn += lines[lines.length - 1].length;
4457	}
4458	}
4459
4460	const n = '\n';
4461
4462	const warned = {
4463	insertLeft: false,
4464	insertRight: false,
4465	storeName: false,
4466	};
4467
4468	class MagicString {
4469	constructor(string, options = {}) {
4470	const chunk = new Chunk(0, string.length, string);
4471
4472	Object.defineProperties(this, {
4473	original: { writable: true, value: string },
4474	outro: { writable: true, value: '' },
4475	intro: { writable: true, value: '' },
4476	firstChunk: { writable: true, value: chunk },
4477	lastChunk: { writable: true, value: chunk },
4478	lastSearchedChunk: { writable: true, value: chunk },
4479	byStart: { writable: true, value: {} },
4480	byEnd: { writable: true, value: {} },
4481	filename: { writable: true, value: options.filename },
4482	indentExclusionRanges: { writable: true, value: options.indentExclusionRanges },
4483	sourcemapLocations: { writable: true, value: new BitSet() },
4484	storedNames: { writable: true, value: {} },
4485	indentStr: { writable: true, value: undefined },
4486	ignoreList: { writable: true, value: options.ignoreList },
4487	});
4488
4489	this.byStart[0] = chunk;
4490	this.byEnd[string.length] = chunk;
4491	}
4492
4493	addSourcemapLocation(char) {
4494	this.sourcemapLocations.add(char);
4495	}
4496
4497	append(content) {
4498	if (typeof content !== 'string') throw new TypeError('outro content must be a string');
4499
4500	this.outro += content;
4501	return this;
4502	}
4503
4504	appendLeft(index, content) {
4505	if (typeof content !== 'string') throw new TypeError('inserted content must be a string');
4506
4507	this._split(index);
4508
4509	const chunk = this.byEnd[index];
4510
4511	if (chunk) {
4512	chunk.appendLeft(content);
4513	} else {
4514	this.intro += content;
4515	}
4516	return this;
4517	}
4518
4519	appendRight(index, content) {
4520	if (typeof content !== 'string') throw new TypeError('inserted content must be a string');
4521
4522	this._split(index);
4523
4524	const chunk = this.byStart[index];
4525
4526	if (chunk) {
4527	chunk.appendRight(content);
4528	} else {
4529	this.outro += content;
4530	}
4531	return this;
4532	}
4533
4534	clone() {
4535	const cloned = new MagicString(this.original, { filename: this.filename });
4536
4537	let originalChunk = this.firstChunk;
4538	let clonedChunk = (cloned.firstChunk = cloned.lastSearchedChunk = originalChunk.clone());
4539
4540	while (originalChunk) {
4541	cloned.byStart[clonedChunk.start] = clonedChunk;
4542	cloned.byEnd[clonedChunk.end] = clonedChunk;
4543
4544	const nextOriginalChunk = originalChunk.next;
4545	const nextClonedChunk = nextOriginalChunk && nextOriginalChunk.clone();
4546
4547	if (nextClonedChunk) {
4548	clonedChunk.next = nextClonedChunk;
4549	nextClonedChunk.previous = clonedChunk;
4550
4551	clonedChunk = nextClonedChunk;
4552	}
4553
4554	originalChunk = nextOriginalChunk;
4555	}
4556
4557	cloned.lastChunk = clonedChunk;
4558
4559	if (this.indentExclusionRanges) {
4560	cloned.indentExclusionRanges = this.indentExclusionRanges.slice();
4561	}
4562
4563	cloned.sourcemapLocations = new BitSet(this.sourcemapLocations);
4564
4565	cloned.intro = this.intro;
4566	cloned.outro = this.outro;
4567
4568	return cloned;
4569	}
4570
4571	generateDecodedMap(options) {
4572	options = options \|\| {};
4573
4574	const sourceIndex = 0;
4575	const names = Object.keys(this.storedNames);
4576	const mappings = new Mappings(options.hires);
4577
4578	const locate = getLocator(this.original);
4579
4580	if (this.intro) {
4581	mappings.advance(this.intro);
4582	}
4583
4584	this.firstChunk.eachNext((chunk) => {
4585	const loc = locate(chunk.start);
4586
4587	if (chunk.intro.length) mappings.advance(chunk.intro);
4588
4589	if (chunk.edited) {
4590	mappings.addEdit(
4591	sourceIndex,
4592	chunk.content,
4593	loc,
4594	chunk.storeName ? names.indexOf(chunk.original) : -1,
4595	);
4596	} else {
4597	mappings.addUneditedChunk(sourceIndex, chunk, this.original, loc, this.sourcemapLocations);
4598	}
4599
4600	if (chunk.outro.length) mappings.advance(chunk.outro);
4601	});
4602
4603	return {
4604	file: options.file ? options.file.split(/[/\\]/).pop() : undefined,
4605	sources: [
4606	options.source ? getRelativePath(options.file \|\| '', options.source) : options.file \|\| '',
4607	],
4608	sourcesContent: options.includeContent ? [this.original] : undefined,
4609	names,
4610	mappings: mappings.raw,
4611	x_google_ignoreList: this.ignoreList ? [sourceIndex] : undefined,
4612	};
4613	}
4614
4615	generateMap(options) {
4616	return new SourceMap(this.generateDecodedMap(options));
4617	}
4618
4619	_ensureindentStr() {
4620	if (this.indentStr === undefined) {
4621	this.indentStr = guessIndent(this.original);
4622	}
4623	}
4624
4625	_getRawIndentString() {
4626	this._ensureindentStr();
4627	return this.indentStr;
4628	}
4629
4630	getIndentString() {
4631	this._ensureindentStr();
4632	return this.indentStr === null ? '\t' : this.indentStr;
4633	}
4634
4635	indent(indentStr, options) {
4636	const pattern = /^[^\r\n]/gm;
4637
4638	if (isObject(indentStr)) {
4639	options = indentStr;
4640	indentStr = undefined;
4641	}
4642
4643	if (indentStr === undefined) {
4644	this._ensureindentStr();
4645	indentStr = this.indentStr \|\| '\t';
4646	}
4647
4648	if (indentStr === '') return this; // noop
4649
4650	options = options \|\| {};
4651
4652	// Process exclusion ranges
4653	const isExcluded = {};
4654
4655	if (options.exclude) {
4656	const exclusions =
4657	typeof options.exclude[0] === 'number' ? [options.exclude] : options.exclude;
4658	exclusions.forEach((exclusion) => {
4659	for (let i = exclusion[0]; i < exclusion[1]; i += 1) {
4660	isExcluded[i] = true;
4661	}
4662	});
4663	}
4664
4665	let shouldIndentNextCharacter = options.indentStart !== false;
4666	const replacer = (match) => {
4667	if (shouldIndentNextCharacter) return `${indentStr}${match}`;
4668	shouldIndentNextCharacter = true;
4669	return match;
4670	};
4671
4672	this.intro = this.intro.replace(pattern, replacer);
4673
4674	let charIndex = 0;
4675	let chunk = this.firstChunk;
4676
4677	while (chunk) {
4678	const end = chunk.end;
4679
4680	if (chunk.edited) {
4681	if (!isExcluded[charIndex]) {
4682	chunk.content = chunk.content.replace(pattern, replacer);
4683
4684	if (chunk.content.length) {
4685	shouldIndentNextCharacter = chunk.content[chunk.content.length - 1] === '\n';
4686	}
4687	}
4688	} else {
4689	charIndex = chunk.start;
4690
4691	while (charIndex < end) {
4692	if (!isExcluded[charIndex]) {
4693	const char = this.original[charIndex];
4694
4695	if (char === '\n') {
4696	shouldIndentNextCharacter = true;
4697	} else if (char !== '\r' && shouldIndentNextCharacter) {
4698	shouldIndentNextCharacter = false;
4699
4700	if (charIndex === chunk.start) {
4701	chunk.prependRight(indentStr);
4702	} else {
4703	this._splitChunk(chunk, charIndex);
4704	chunk = chunk.next;
4705	chunk.prependRight(indentStr);
4706	}
4707	}
4708	}
4709
4710	charIndex += 1;
4711	}
4712	}
4713
4714	charIndex = chunk.end;
4715	chunk = chunk.next;
4716	}
4717
4718	this.outro = this.outro.replace(pattern, replacer);
4719
4720	return this;
4721	}
4722
4723	insert() {
4724	throw new Error(
4725	'magicString.insert(...) is deprecated. Use prependRight(...) or appendLeft(...)',
4726	);
4727	}
4728
4729	insertLeft(index, content) {
4730	if (!warned.insertLeft) {
4731	console.warn(
4732	'magicString.insertLeft(...) is deprecated. Use magicString.appendLeft(...) instead',
4733	); // eslint-disable-line no-console
4734	warned.insertLeft = true;
4735	}
4736
4737	return this.appendLeft(index, content);
4738	}
4739
4740	insertRight(index, content) {
4741	if (!warned.insertRight) {
4742	console.warn(
4743	'magicString.insertRight(...) is deprecated. Use magicString.prependRight(...) instead',
4744	); // eslint-disable-line no-console
4745	warned.insertRight = true;
4746	}
4747
4748	return this.prependRight(index, content);
4749	}
4750
4751	move(start, end, index) {
4752	if (index >= start && index <= end) throw new Error('Cannot move a selection inside itself');
4753
4754	this._split(start);
4755	this._split(end);
4756	this._split(index);
4757
4758	const first = this.byStart[start];
4759	const last = this.byEnd[end];
4760
4761	const oldLeft = first.previous;
4762	const oldRight = last.next;
4763
4764	const newRight = this.byStart[index];
4765	if (!newRight && last === this.lastChunk) return this;
4766	const newLeft = newRight ? newRight.previous : this.lastChunk;
4767
4768	if (oldLeft) oldLeft.next = oldRight;
4769	if (oldRight) oldRight.previous = oldLeft;
4770
4771	if (newLeft) newLeft.next = first;
4772	if (newRight) newRight.previous = last;
4773
4774	if (!first.previous) this.firstChunk = last.next;
4775	if (!last.next) {
4776	this.lastChunk = first.previous;
4777	this.lastChunk.next = null;
4778	}
4779
4780	first.previous = newLeft;
4781	last.next = newRight \|\| null;
4782
4783	if (!newLeft) this.firstChunk = first;
4784	if (!newRight) this.lastChunk = last;
4785	return this;
4786	}
4787
4788	overwrite(start, end, content, options) {
4789	options = options \|\| {};
4790	return this.update(start, end, content, { ...options, overwrite: !options.contentOnly });
4791	}
4792
4793	update(start, end, content, options) {
4794	if (typeof content !== 'string') throw new TypeError('replacement content must be a string');
4795
4796	while (start < 0) start += this.original.length;
4797	while (end < 0) end += this.original.length;
4798
4799	if (end > this.original.length) throw new Error('end is out of bounds');
4800	if (start === end)
4801	throw new Error(
4802	'Cannot overwrite a zero-length range – use appendLeft or prependRight instead',
4803	);
4804
4805	this._split(start);
4806	this._split(end);
4807
4808	if (options === true) {
4809	if (!warned.storeName) {
4810	console.warn(
4811	'The final argument to magicString.overwrite(...) should be an options object. See https://github.com/rich-harris/magic-string',
4812	); // eslint-disable-line no-console
4813	warned.storeName = true;
4814	}
4815
4816	options = { storeName: true };
4817	}
4818	const storeName = options !== undefined ? options.storeName : false;
4819	const overwrite = options !== undefined ? options.overwrite : false;
4820
4821	if (storeName) {
4822	const original = this.original.slice(start, end);
4823	Object.defineProperty(this.storedNames, original, {
4824	writable: true,
4825	value: true,
4826	enumerable: true,
4827	});
4828	}
4829
4830	const first = this.byStart[start];
4831	const last = this.byEnd[end];
4832
4833	if (first) {
4834	let chunk = first;
4835	while (chunk !== last) {
4836	if (chunk.next !== this.byStart[chunk.end]) {
4837	throw new Error('Cannot overwrite across a split point');
4838	}
4839	chunk = chunk.next;
4840	chunk.edit('', false);
4841	}
4842
4843	first.edit(content, storeName, !overwrite);
4844	} else {
4845	// must be inserting at the end
4846	const newChunk = new Chunk(start, end, '').edit(content, storeName);
4847
4848	// TODO last chunk in the array may not be the last chunk, if it's moved...
4849	last.next = newChunk;
4850	newChunk.previous = last;
4851	}
4852	return this;
4853	}
4854
4855	prepend(content) {
4856	if (typeof content !== 'string') throw new TypeError('outro content must be a string');
4857
4858	this.intro = content + this.intro;
4859	return this;
4860	}
4861
4862	prependLeft(index, content) {
4863	if (typeof content !== 'string') throw new TypeError('inserted content must be a string');
4864
4865	this._split(index);
4866
4867	const chunk = this.byEnd[index];
4868
4869	if (chunk) {
4870	chunk.prependLeft(content);
4871	} else {
4872	this.intro = content + this.intro;
4873	}
4874	return this;
4875	}
4876
4877	prependRight(index, content) {
4878	if (typeof content !== 'string') throw new TypeError('inserted content must be a string');
4879
4880	this._split(index);
4881
4882	const chunk = this.byStart[index];
4883
4884	if (chunk) {
4885	chunk.prependRight(content);
4886	} else {
4887	this.outro = content + this.outro;
4888	}
4889	return this;
4890	}
4891
4892	remove(start, end) {
4893	while (start < 0) start += this.original.length;
4894	while (end < 0) end += this.original.length;
4895
4896	if (start === end) return this;
4897
4898	if (start < 0 \|\| end > this.original.length) throw new Error('Character is out of bounds');
4899	if (start > end) throw new Error('end must be greater than start');
4900
4901	this._split(start);
4902	this._split(end);
4903
4904	let chunk = this.byStart[start];
4905
4906	while (chunk) {
4907	chunk.intro = '';
4908	chunk.outro = '';
4909	chunk.edit('');
4910
4911	chunk = end > chunk.end ? this.byStart[chunk.end] : null;
4912	}
4913	return this;
4914	}
4915
4916	reset(start, end) {
4917	while (start < 0) start += this.original.length;
4918	while (end < 0) end += this.original.length;
4919
4920	if (start === end) return this;
4921
4922	if (start < 0 \|\| end > this.original.length) throw new Error('Character is out of bounds');
4923	if (start > end) throw new Error('end must be greater than start');
4924
4925	this._split(start);
4926	this._split(end);
4927
4928	let chunk = this.byStart[start];
4929
4930	while (chunk) {
4931	chunk.reset();
4932
4933	chunk = end > chunk.end ? this.byStart[chunk.end] : null;
4934	}
4935	return this;
4936	}
4937
4938	lastChar() {
4939	if (this.outro.length) return this.outro[this.outro.length - 1];
4940	let chunk = this.lastChunk;
4941	do {
4942	if (chunk.outro.length) return chunk.outro[chunk.outro.length - 1];
4943	if (chunk.content.length) return chunk.content[chunk.content.length - 1];
4944	if (chunk.intro.length) return chunk.intro[chunk.intro.length - 1];
4945	} while ((chunk = chunk.previous));
4946	if (this.intro.length) return this.intro[this.intro.length - 1];
4947	return '';
4948	}
4949
4950	lastLine() {
4951	let lineIndex = this.outro.lastIndexOf(n);
4952	if (lineIndex !== -1) return this.outro.substr(lineIndex + 1);
4953	let lineStr = this.outro;
4954	let chunk = this.lastChunk;
4955	do {
4956	if (chunk.outro.length > 0) {
4957	lineIndex = chunk.outro.lastIndexOf(n);
4958	if (lineIndex !== -1) return chunk.outro.substr(lineIndex + 1) + lineStr;
4959	lineStr = chunk.outro + lineStr;
4960	}
4961
4962	if (chunk.content.length > 0) {
4963	lineIndex = chunk.content.lastIndexOf(n);
4964	if (lineIndex !== -1) return chunk.content.substr(lineIndex + 1) + lineStr;
4965	lineStr = chunk.content + lineStr;
4966	}
4967
4968	if (chunk.intro.length > 0) {
4969	lineIndex = chunk.intro.lastIndexOf(n);
4970	if (lineIndex !== -1) return chunk.intro.substr(lineIndex + 1) + lineStr;
4971	lineStr = chunk.intro + lineStr;
4972	}
4973	} while ((chunk = chunk.previous));
4974	lineIndex = this.intro.lastIndexOf(n);
4975	if (lineIndex !== -1) return this.intro.substr(lineIndex + 1) + lineStr;
4976	return this.intro + lineStr;
4977	}
4978
4979	slice(start = 0, end = this.original.length) {
4980	while (start < 0) start += this.original.length;
4981	while (end < 0) end += this.original.length;
4982
4983	let result = '';
4984
4985	// find start chunk
4986	let chunk = this.firstChunk;
4987	while (chunk && (chunk.start > start \|\| chunk.end <= start)) {
4988	// found end chunk before start
4989	if (chunk.start < end && chunk.end >= end) {
4990	return result;
4991	}
4992
4993	chunk = chunk.next;
4994	}
4995
4996	if (chunk && chunk.edited && chunk.start !== start)
4997	throw new Error(`Cannot use replaced character ${start} as slice start anchor.`);
4998
4999	const startChunk = chunk;
5000	while (chunk) {
5001	if (chunk.intro && (startChunk !== chunk \|\| chunk.start === start)) {
5002	result += chunk.intro;
5003	}
5004
5005	const containsEnd = chunk.start < end && chunk.end >= end;
5006	if (containsEnd && chunk.edited && chunk.end !== end)
5007	throw new Error(`Cannot use replaced character ${end} as slice end anchor.`);
5008
5009	const sliceStart = startChunk === chunk ? start - chunk.start : 0;
5010	const sliceEnd = containsEnd ? chunk.content.length + end - chunk.end : chunk.content.length;
5011
5012	result += chunk.content.slice(sliceStart, sliceEnd);
5013
5014	if (chunk.outro && (!containsEnd \|\| chunk.end === end)) {
5015	result += chunk.outro;
5016	}
5017
5018	if (containsEnd) {
5019	break;
5020	}
5021
5022	chunk = chunk.next;
5023	}
5024
5025	return result;
5026	}
5027
5028	// TODO deprecate this? not really very useful
5029	snip(start, end) {
5030	const clone = this.clone();
5031	clone.remove(0, start);
5032	clone.remove(end, clone.original.length);
5033
5034	return clone;
5035	}
5036
5037	_split(index) {
5038	if (this.byStart[index] \|\| this.byEnd[index]) return;
5039
5040	let chunk = this.lastSearchedChunk;
5041	const searchForward = index > chunk.end;
5042
5043	while (chunk) {
5044	if (chunk.contains(index)) return this._splitChunk(chunk, index);
5045
5046	chunk = searchForward ? this.byStart[chunk.end] : this.byEnd[chunk.start];
5047	}
5048	}
5049
5050	_splitChunk(chunk, index) {
5051	if (chunk.edited && chunk.content.length) {
5052	// zero-length edited chunks are a special case (overlapping replacements)
5053	const loc = getLocator(this.original)(index);
5054	throw new Error(
5055	`Cannot split a chunk that has already been edited (${loc.line}:${loc.column} – "${chunk.original}")`,
5056	);
5057	}
5058
5059	const newChunk = chunk.split(index);
5060
5061	this.byEnd[index] = chunk;
5062	this.byStart[index] = newChunk;
5063	this.byEnd[newChunk.end] = newChunk;
5064
5065	if (chunk === this.lastChunk) this.lastChunk = newChunk;
5066
5067	this.lastSearchedChunk = chunk;
5068	return true;
5069	}
5070
5071	toString() {
5072	let str = this.intro;
5073
5074	let chunk = this.firstChunk;
5075	while (chunk) {
5076	str += chunk.toString();
5077	chunk = chunk.next;
5078	}
5079
5080	return str + this.outro;
5081	}
5082
5083	isEmpty() {
5084	let chunk = this.firstChunk;
5085	do {
5086	if (
5087	(chunk.intro.length && chunk.intro.trim()) \|\|
5088	(chunk.content.length && chunk.content.trim()) \|\|
5089	(chunk.outro.length && chunk.outro.trim())
5090	)
5091	return false;
5092	} while ((chunk = chunk.next));
5093	return true;
5094	}
5095
5096	length() {
5097	let chunk = this.firstChunk;
5098	let length = 0;
5099	do {
5100	length += chunk.intro.length + chunk.content.length + chunk.outro.length;
5101	} while ((chunk = chunk.next));
5102	return length;
5103	}
5104
5105	trimLines() {
5106	return this.trim('[\\r\\n]');
5107	}
5108
5109	trim(charType) {
5110	return this.trimStart(charType).trimEnd(charType);
5111	}
5112
5113	trimEndAborted(charType) {
5114	const rx = new RegExp((charType \|\| '\\s') + '+$');
5115
5116	this.outro = this.outro.replace(rx, '');
5117	if (this.outro.length) return true;
5118
5119	let chunk = this.lastChunk;
5120
5121	do {
5122	const end = chunk.end;
5123	const aborted = chunk.trimEnd(rx);
5124
5125	// if chunk was trimmed, we have a new lastChunk
5126	if (chunk.end !== end) {
5127	if (this.lastChunk === chunk) {
5128	this.lastChunk = chunk.next;
5129	}
5130
5131	this.byEnd[chunk.end] = chunk;
5132	this.byStart[chunk.next.start] = chunk.next;
5133	this.byEnd[chunk.next.end] = chunk.next;
5134	}
5135
5136	if (aborted) return true;
5137	chunk = chunk.previous;
5138	} while (chunk);
5139
5140	return false;
5141	}
5142
5143	trimEnd(charType) {
5144	this.trimEndAborted(charType);
5145	return this;
5146	}
5147	trimStartAborted(charType) {
5148	const rx = new RegExp('^' + (charType \|\| '\\s') + '+');
5149
5150	this.intro = this.intro.replace(rx, '');
5151	if (this.intro.length) return true;
5152
5153	let chunk = this.firstChunk;
5154
5155	do {
5156	const end = chunk.end;
5157	const aborted = chunk.trimStart(rx);
5158
5159	if (chunk.end !== end) {
5160	// special case...
5161	if (chunk === this.lastChunk) this.lastChunk = chunk.next;
5162
5163	this.byEnd[chunk.end] = chunk;
5164	this.byStart[chunk.next.start] = chunk.next;
5165	this.byEnd[chunk.next.end] = chunk.next;
5166	}
5167
5168	if (aborted) return true;
5169	chunk = chunk.next;
5170	} while (chunk);
5171
5172	return false;
5173	}
5174
5175	trimStart(charType) {
5176	this.trimStartAborted(charType);
5177	return this;
5178	}
5179
5180	hasChanged() {
5181	return this.original !== this.toString();
5182	}
5183
5184	_replaceRegexp(searchValue, replacement) {
5185	function getReplacement(match, str) {
5186	if (typeof replacement === 'string') {
5187	return replacement.replace(/\$(\$\|&\|\d+)/g, (_, i) => {
5188	// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_a_parameter
5189	if (i === '$') return '$';
5190	if (i === '&') return match[0];
5191	const num = +i;
5192	if (num < match.length) return match[+i];
5193	return `$${i}`;
5194	});
5195	} else {
5196	return replacement(...match, match.index, str, match.groups);
5197	}
5198	}
5199	function matchAll(re, str) {
5200	let match;
5201	const matches = [];
5202	while ((match = re.exec(str))) {
5203	matches.push(match);
5204	}
5205	return matches;
5206	}
5207	if (searchValue.global) {
5208	const matches = matchAll(searchValue, this.original);
5209	matches.forEach((match) => {
5210	if (match.index != null) {
5211	const replacement = getReplacement(match, this.original);
5212	if (replacement !== match[0]) {
5213	this.overwrite(
5214	match.index,
5215	match.index + match[0].length,
5216	replacement
5217	);
5218	}
5219	}
5220	});
5221	} else {
5222	const match = this.original.match(searchValue);
5223	if (match && match.index != null) {
5224	const replacement = getReplacement(match, this.original);
5225	if (replacement !== match[0]) {
5226	this.overwrite(
5227	match.index,
5228	match.index + match[0].length,
5229	replacement
5230	);
5231	}
5232	}
5233	}
5234	return this;
5235	}
5236
5237	_replaceString(string, replacement) {
5238	const { original } = this;
5239	const index = original.indexOf(string);
5240
5241	if (index !== -1) {
5242	this.overwrite(index, index + string.length, replacement);
5243	}
5244
5245	return this;
5246	}
5247
5248	replace(searchValue, replacement) {
5249	if (typeof searchValue === 'string') {
5250	return this._replaceString(searchValue, replacement);
5251	}
5252
5253	return this._replaceRegexp(searchValue, replacement);
5254	}
5255
5256	_replaceAllString(string, replacement) {
5257	const { original } = this;
5258	const stringLength = string.length;
5259	for (
5260	let index = original.indexOf(string);
5261	index !== -1;
5262	index = original.indexOf(string, index + stringLength)
5263	) {
5264	const previous = original.slice(index, index + stringLength);
5265	if (previous !== replacement)
5266	this.overwrite(index, index + stringLength, replacement);
5267	}
5268
5269	return this;
5270	}
5271
5272	replaceAll(searchValue, replacement) {
5273	if (typeof searchValue === 'string') {
5274	return this._replaceAllString(searchValue, replacement);
5275	}
5276
5277	if (!searchValue.global) {
5278	throw new TypeError(
5279	'MagicString.prototype.replaceAll called with a non-global RegExp argument',
5280	);
5281	}
5282
5283	return this._replaceRegexp(searchValue, replacement);
5284	}
5285	}
5286
5287	const debug$1 = createDebugger("vite:sourcemap", {
5288	onlyWhenFocused: true
5289	});
5290	function genSourceMapUrl(map) {
5291	if (typeof map !== "string") {
5292	map = JSON.stringify(map);
5293	}
5294	return `data:application/json;base64,${Buffer.from(map).toString("base64")}`;
5295	}
5296	function getCodeWithSourcemap(type, code, map) {
5297	if (debug$1) {
5298	code += `
5299	/${JSON.stringify(map, null, 2).replace(/\\//g, "\\/")}/
5300	`;
5301	}
5302	if (type === "js") {
5303	code += `
5304	//# sourceMappingURL=${genSourceMapUrl(map)}`;
5305	} else if (type === "css") {
5306	code += `
5307	/# sourceMappingURL=${genSourceMapUrl(map)} /`;
5308	}
5309	return code;
5310	}
5311
5312	const debug = createDebugger("vite:send", {
5313	onlyWhenFocused: true
5314	});
5315	const alias = {
5316	js: "text/javascript",
5317	css: "text/css",
5318	html: "text/html",
5319	json: "application/json"
5320	};
5321	function send(req, res, content, type, options) {
5322	const {
5323	etag = getEtag(content, { weak: true }),
5324	cacheControl = "no-cache",
5325	headers,
5326	map
5327	} = options;
5328	if (res.writableEnded) {
5329	return;
5330	}
5331	if (req.headers["if-none-match"] === etag) {
5332	res.statusCode = 304;
5333	res.end();
5334	return;
5335	}
5336	res.setHeader("Content-Type", alias[type] \|\| type);
5337	res.setHeader("Cache-Control", cacheControl);
5338	res.setHeader("Etag", etag);
5339	if (headers) {
5340	for (const name in headers) {
5341	res.setHeader(name, headers[name]);
5342	}
5343	}
5344	if (map && "version" in map && map.mappings) {
5345	if (type === "js" \|\| type === "css") {
5346	content = getCodeWithSourcemap(type, content.toString(), map);
5347	}
5348	} else if (type === "js" && (!map \|\| map.mappings !== "")) {
5349	const code = content.toString();
5350	if (convertSourceMap.mapFileCommentRegex.test(code)) {
5351	debug?.(`Skipped injecting fallback sourcemap for ${req.url}`);
5352	} else {
5353	const urlWithoutTimestamp = removeTimestampQuery(req.url);
5354	const ms = new MagicString(code);
5355	content = getCodeWithSourcemap(
5356	type,
5357	code,
5358	ms.generateMap({
5359	source: path$3.basename(urlWithoutTimestamp),
5360	hires: "boundary",
5361	includeContent: true
5362	})
5363	);
5364	}
5365	}
5366	res.statusCode = 200;
5367	res.end(content);
5368	return;
5369	}
5370
5371	const LogLevels = {
5372	silent: 0,
5373	error: 1,
5374	warn: 2,
5375	info: 3
5376	};
5377	let lastType;
5378	let lastMsg;
5379	let sameCount = 0;
5380	function clearScreen() {
5381	const repeatCount = process.stdout.rows - 2;
5382	const blank = repeatCount > 0 ? "\n".repeat(repeatCount) : "";
5383	console.log(blank);
5384	readline.cursorTo(process.stdout, 0, 0);
5385	readline.clearScreenDown(process.stdout);
5386	}
5387	let timeFormatter;
5388	function getTimeFormatter() {
5389	timeFormatter ??= new Intl.DateTimeFormat(void 0, {
5390	hour: "numeric",
5391	minute: "numeric",
5392	second: "numeric"
5393	});
5394	return timeFormatter;
5395	}
5396	function createLogger(level = "info", options = {}) {
5397	if (options.customLogger) {
5398	return options.customLogger;
5399	}
5400	const loggedErrors = /* @__PURE__ */ new WeakSet();
5401	const { prefix = "[vite]", allowClearScreen = true } = options;
5402	const thresh = LogLevels[level];
5403	const canClearScreen = allowClearScreen && process.stdout.isTTY && !process.env.CI;
5404	const clear = canClearScreen ? clearScreen : () => {
5405	};
5406	function format(type, msg, options2 = {}) {
5407	if (options2.timestamp) {
5408	let tag = "";
5409	if (type === "info") {
5410	tag = colors.cyan(colors.bold(prefix));
5411	} else if (type === "warn") {
5412	tag = colors.yellow(colors.bold(prefix));
5413	} else {
5414	tag = colors.red(colors.bold(prefix));
5415	}
5416	return `${colors.dim(getTimeFormatter().format(/* @__PURE__ */ new Date()))} ${tag} ${msg}`;
5417	} else {
5418	return msg;
5419	}
5420	}
5421	function output(type, msg, options2 = {}) {
5422	if (thresh >= LogLevels[type]) {
5423	const method = type === "info" ? "log" : type;
5424	if (options2.error) {
5425	loggedErrors.add(options2.error);
5426	}
5427	if (canClearScreen) {
5428	if (type === lastType && msg === lastMsg) {
5429	sameCount++;
5430	clear();
5431	console[method](
5432	format(type, msg, options2),
5433	colors.yellow(`(x${sameCount + 1})`)
5434	);
5435	} else {
5436	sameCount = 0;
5437	lastMsg = msg;
5438	lastType = type;
5439	if (options2.clear) {
5440	clear();
5441	}
5442	console[method](format(type, msg, options2));
5443	}
5444	} else {
5445	console[method](format(type, msg, options2));
5446	}
5447	}
5448	}
5449	const warnedMessages = /* @__PURE__ */ new Set();
5450	const logger = {
5451	hasWarned: false,
5452	info(msg, opts) {
5453	output("info", msg, opts);
5454	},
5455	warn(msg, opts) {
5456	logger.hasWarned = true;
5457	output("warn", msg, opts);
5458	},
5459	warnOnce(msg, opts) {
5460	if (warnedMessages.has(msg)) return;
5461	logger.hasWarned = true;
5462	output("warn", msg, opts);
5463	warnedMessages.add(msg);
5464	},
5465	error(msg, opts) {
5466	logger.hasWarned = true;
5467	output("error", msg, opts);
5468	},
5469	clearScreen(type) {
5470	if (thresh >= LogLevels[type]) {
5471	clear();
5472	}
5473	},
5474	hasErrorLogged(error) {
5475	return loggedErrors.has(error);
5476	}
5477	};
5478	return logger;
5479	}
5480
5481	const ROOT_FILES = [
5482	// '.git',
5483	// https://pnpm.io/workspaces/
5484	"pnpm-workspace.yaml",
5485	// https://rushjs.io/pages/advanced/config_files/
5486	// 'rush.json',
5487	// https://nx.dev/latest/react/getting-started/nx-setup
5488	// 'workspace.json',
5489	// 'nx.json',
5490	// https://github.com/lerna/lerna#lernajson
5491	"lerna.json"
5492	];
5493	function hasWorkspacePackageJSON(root) {
5494	const path = path$3.join(root, "package.json");
5495	if (!isFileReadable(path)) {
5496	return false;
5497	}
5498	try {
5499	const content = JSON.parse(fs$1.readFileSync(path, "utf-8")) \|\| {};
5500	return !!content.workspaces;
5501	} catch {
5502	return false;
5503	}
5504	}
5505	function hasRootFile(root) {
5506	return ROOT_FILES.some((file) => fs$1.existsSync(path$3.join(root, file)));
5507	}
5508	function hasPackageJSON(root) {
5509	const path = path$3.join(root, "package.json");
5510	return fs$1.existsSync(path);
5511	}
5512	function searchForPackageRoot(current, root = current) {
5513	if (hasPackageJSON(current)) return current;
5514	const dir = path$3.dirname(current);
5515	if (!dir \|\| dir === current) return root;
5516	return searchForPackageRoot(dir, root);
5517	}
5518	function searchForWorkspaceRoot(current, root = searchForPackageRoot(current)) {
5519	if (hasRootFile(current)) return current;
5520	if (hasWorkspacePackageJSON(current)) return current;
5521	const dir = path$3.dirname(current);
5522	if (!dir \|\| dir === current) return root;
5523	return searchForWorkspaceRoot(dir, root);
5524	}
5525
5526	function isFileServingAllowed(url, server) {
5527	if (!server.config.server.fs.strict) return true;
5528	const file = fsPathFromUrl(url);
5529	if (server._fsDenyGlob(file)) return false;
5530	if (server.moduleGraph.safeModulesPath.has(file)) return true;
5531	if (server.config.server.fs.allow.some(
5532	(uri) => isSameFileUri(uri, file) \|\| isParentDirectory(uri, file)
5533	))
5534	return true;
5535	return false;
5536	}
5537
5538	var main$1 = {exports: {}};
5539
5540	var name = "dotenv";
5541	var version$1 = "16.4.5";
5542	var description = "Loads environment variables from .env file";
5543	var main = "lib/main.js";
5544	var types = "lib/main.d.ts";
5545	var exports$1 = {
5546	".": {
5547	types: "./lib/main.d.ts",
5548	require: "./lib/main.js",
5549	"default": "./lib/main.js"
5550	},
5551	"./config": "./config.js",
5552	"./config.js": "./config.js",
5553	"./lib/env-options": "./lib/env-options.js",
5554	"./lib/env-options.js": "./lib/env-options.js",
5555	"./lib/cli-options": "./lib/cli-options.js",
5556	"./lib/cli-options.js": "./lib/cli-options.js",
5557	"./package.json": "./package.json"
5558	};
5559	var scripts = {
5560	"dts-check": "tsc --project tests/types/tsconfig.json",
5561	lint: "standard",
5562	"lint-readme": "standard-markdown",
5563	pretest: "npm run lint && npm run dts-check",
5564	test: "tap tests/*.js --100 -Rspec",
5565	"test:coverage": "tap --coverage-report=lcov",
5566	prerelease: "npm test",
5567	release: "standard-version"
5568	};
5569	var repository = {
5570	type: "git",
5571	url: "git://github.com/motdotla/dotenv.git"
5572	};
5573	var funding = "https://dotenvx.com";
5574	var keywords = [
5575	"dotenv",
5576	"env",
5577	".env",
5578	"environment",
5579	"variables",
5580	"config",
5581	"settings"
5582	];
5583	var readmeFilename = "README.md";
5584	var license = "BSD-2-Clause";
5585	var devDependencies = {
5586	"@definitelytyped/dtslint": "^0.0.133",
5587	"@types/node": "^18.11.3",
5588	decache: "^4.6.1",
5589	sinon: "^14.0.1",
5590	standard: "^17.0.0",
5591	"standard-markdown": "^7.1.0",
5592	"standard-version": "^9.5.0",
5593	tap: "^16.3.0",
5594	tar: "^6.1.11",
5595	typescript: "^4.8.4"
5596	};
5597	var engines = {
5598	node: ">=12"
5599	};
5600	var browser = {
5601	fs: false
5602	};
5603	var require$$4 = {
5604	name: name,
5605	version: version$1,
5606	description: description,
5607	main: main,
5608	types: types,
5609	exports: exports$1,
5610	scripts: scripts,
5611	repository: repository,
5612	funding: funding,
5613	keywords: keywords,
5614	readmeFilename: readmeFilename,
5615	license: license,
5616	devDependencies: devDependencies,
5617	engines: engines,
5618	browser: browser
5619	};
5620
5621	const fs = fs$2;
5622	const path = require$$0$1;
5623	const os = require$$2;
5624	const crypto = require$$0$2;
5625	const packageJson = require$$4;
5626
5627	const version = packageJson.version;
5628
5629	const LINE = /(?:^\|^)\s(?:export\s+)?([\w.-]+)(?:\s=\s?\|:\s+?)(\s'(?:\\'\|[^'])'\|\s"(?:\\"\|[^"])"\|\s`(?:\\`\|[^`])`\|[^#\r\n]+)?\s(?:#.*)?(?:$\|$)/mg;
5630
5631	// Parse src into an Object
5632	function parse (src) {
5633	const obj = {};
5634
5635	// Convert buffer to string
5636	let lines = src.toString();
5637
5638	// Convert line breaks to same format
5639	lines = lines.replace(/\r\n?/mg, '\n');
5640
5641	let match;
5642	while ((match = LINE.exec(lines)) != null) {
5643	const key = match[1];
5644
5645	// Default undefined or null to empty string
5646	let value = (match[2] \|\| '');
5647
5648	// Remove whitespace
5649	value = value.trim();
5650
5651	// Check if double quoted
5652	const maybeQuote = value[0];
5653
5654	// Remove surrounding quotes
5655	value = value.replace(/^(['"`])([\s\S]*)\1$/mg, '$2');
5656
5657	// Expand newlines if double quoted
5658	if (maybeQuote === '"') {
5659	value = value.replace(/\\n/g, '\n');
5660	value = value.replace(/\\r/g, '\r');
5661	}
5662
5663	// Add to object
5664	obj[key] = value;
5665	}
5666
5667	return obj
5668	}
5669
5670	function _parseVault (options) {
5671	const vaultPath = _vaultPath(options);
5672
5673	// Parse .env.vault
5674	const result = DotenvModule.configDotenv({ path: vaultPath });
5675	if (!result.parsed) {
5676	const err = new Error(`MISSING_DATA: Cannot parse ${vaultPath} for an unknown reason`);
5677	err.code = 'MISSING_DATA';
5678	throw err
5679	}
5680
5681	// handle scenario for comma separated keys - for use with key rotation
5682	// example: DOTENV_KEY="dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=prod,dotenv://:key_7890@dotenvx.com/vault/.env.vault?environment=prod"
5683	const keys = _dotenvKey(options).split(',');
5684	const length = keys.length;
5685
5686	let decrypted;
5687	for (let i = 0; i < length; i++) {
5688	try {
5689	// Get full key
5690	const key = keys[i].trim();
5691
5692	// Get instructions for decrypt
5693	const attrs = _instructions(result, key);
5694
5695	// Decrypt
5696	decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key);
5697
5698	break
5699	} catch (error) {
5700	// last key
5701	if (i + 1 >= length) {
5702	throw error
5703	}
5704	// try next key
5705	}
5706	}
5707
5708	// Parse decrypted .env string
5709	return DotenvModule.parse(decrypted)
5710	}
5711
5712	function _log (message) {
5713	console.log(`[dotenv@${version}][INFO] ${message}`);
5714	}
5715
5716	function _warn (message) {
5717	console.log(`[dotenv@${version}][WARN] ${message}`);
5718	}
5719
5720	function _debug (message) {
5721	console.log(`[dotenv@${version}][DEBUG] ${message}`);
5722	}
5723
5724	function _dotenvKey (options) {
5725	// prioritize developer directly setting options.DOTENV_KEY
5726	if (options && options.DOTENV_KEY && options.DOTENV_KEY.length > 0) {
5727	return options.DOTENV_KEY
5728	}
5729
5730	// secondary infra already contains a DOTENV_KEY environment variable
5731	if (process.env.DOTENV_KEY && process.env.DOTENV_KEY.length > 0) {
5732	return process.env.DOTENV_KEY
5733	}
5734
5735	// fallback to empty string
5736	return ''
5737	}
5738
5739	function _instructions (result, dotenvKey) {
5740	// Parse DOTENV_KEY. Format is a URI
5741	let uri;
5742	try {
5743	uri = new URL(dotenvKey);
5744	} catch (error) {
5745	if (error.code === 'ERR_INVALID_URL') {
5746	const err = new Error('INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=development');
5747	err.code = 'INVALID_DOTENV_KEY';
5748	throw err
5749	}
5750
5751	throw error
5752	}
5753
5754	// Get decrypt key
5755	const key = uri.password;
5756	if (!key) {
5757	const err = new Error('INVALID_DOTENV_KEY: Missing key part');
5758	err.code = 'INVALID_DOTENV_KEY';
5759	throw err
5760	}
5761
5762	// Get environment
5763	const environment = uri.searchParams.get('environment');
5764	if (!environment) {
5765	const err = new Error('INVALID_DOTENV_KEY: Missing environment part');
5766	err.code = 'INVALID_DOTENV_KEY';
5767	throw err
5768	}
5769
5770	// Get ciphertext payload
5771	const environmentKey = `DOTENV_VAULT_${environment.toUpperCase()}`;
5772	const ciphertext = result.parsed[environmentKey]; // DOTENV_VAULT_PRODUCTION
5773	if (!ciphertext) {
5774	const err = new Error(`NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${environmentKey} in your .env.vault file.`);
5775	err.code = 'NOT_FOUND_DOTENV_ENVIRONMENT';
5776	throw err
5777	}
5778
5779	return { ciphertext, key }
5780	}
5781
5782	function _vaultPath (options) {
5783	let possibleVaultPath = null;
5784
5785	if (options && options.path && options.path.length > 0) {
5786	if (Array.isArray(options.path)) {
5787	for (const filepath of options.path) {
5788	if (fs.existsSync(filepath)) {
5789	possibleVaultPath = filepath.endsWith('.vault') ? filepath : `${filepath}.vault`;
5790	}
5791	}
5792	} else {
5793	possibleVaultPath = options.path.endsWith('.vault') ? options.path : `${options.path}.vault`;
5794	}
5795	} else {
5796	possibleVaultPath = path.resolve(process.cwd(), '.env.vault');
5797	}
5798
5799	if (fs.existsSync(possibleVaultPath)) {
5800	return possibleVaultPath
5801	}
5802
5803	return null
5804	}
5805
5806	function _resolveHome (envPath) {
5807	return envPath[0] === '~' ? path.join(os.homedir(), envPath.slice(1)) : envPath
5808	}
5809
5810	function _configVault (options) {
5811	_log('Loading env from encrypted .env.vault');
5812
5813	const parsed = DotenvModule._parseVault(options);
5814
5815	let processEnv = process.env;
5816	if (options && options.processEnv != null) {
5817	processEnv = options.processEnv;
5818	}
5819
5820	DotenvModule.populate(processEnv, parsed, options);
5821
5822	return { parsed }
5823	}
5824
5825	function configDotenv (options) {
5826	const dotenvPath = path.resolve(process.cwd(), '.env');
5827	let encoding = 'utf8';
5828	const debug = Boolean(options && options.debug);
5829
5830	if (options && options.encoding) {
5831	encoding = options.encoding;
5832	} else {
5833	if (debug) {
5834	_debug('No encoding is specified. UTF-8 is used by default');
5835	}
5836	}
5837
5838	let optionPaths = [dotenvPath]; // default, look for .env
5839	if (options && options.path) {
5840	if (!Array.isArray(options.path)) {
5841	optionPaths = [_resolveHome(options.path)];
5842	} else {
5843	optionPaths = []; // reset default
5844	for (const filepath of options.path) {
5845	optionPaths.push(_resolveHome(filepath));
5846	}
5847	}
5848	}
5849
5850	// Build the parsed data in a temporary object (because we need to return it). Once we have the final
5851	// parsed data, we will combine it with process.env (or options.processEnv if provided).
5852	let lastError;
5853	const parsedAll = {};
5854	for (const path of optionPaths) {
5855	try {
5856	// Specifying an encoding returns a string instead of a buffer
5857	const parsed = DotenvModule.parse(fs.readFileSync(path, { encoding }));
5858
5859	DotenvModule.populate(parsedAll, parsed, options);
5860	} catch (e) {
5861	if (debug) {
5862	_debug(`Failed to load ${path} ${e.message}`);
5863	}
5864	lastError = e;
5865	}
5866	}
5867
5868	let processEnv = process.env;
5869	if (options && options.processEnv != null) {
5870	processEnv = options.processEnv;
5871	}
5872
5873	DotenvModule.populate(processEnv, parsedAll, options);
5874
5875	if (lastError) {
5876	return { parsed: parsedAll, error: lastError }
5877	} else {
5878	return { parsed: parsedAll }
5879	}
5880	}
5881
5882	// Populates process.env from .env file
5883	function config (options) {
5884	// fallback to original dotenv if DOTENV_KEY is not set
5885	if (_dotenvKey(options).length === 0) {
5886	return DotenvModule.configDotenv(options)
5887	}
5888
5889	const vaultPath = _vaultPath(options);
5890
5891	// dotenvKey exists but .env.vault file does not exist
5892	if (!vaultPath) {
5893	_warn(`You set DOTENV_KEY but you are missing a .env.vault file at ${vaultPath}. Did you forget to build it?`);
5894
5895	return DotenvModule.configDotenv(options)
5896	}
5897
5898	return DotenvModule._configVault(options)
5899	}
5900
5901	function decrypt (encrypted, keyStr) {
5902	const key = Buffer.from(keyStr.slice(-64), 'hex');
5903	let ciphertext = Buffer.from(encrypted, 'base64');
5904
5905	const nonce = ciphertext.subarray(0, 12);
5906	const authTag = ciphertext.subarray(-16);
5907	ciphertext = ciphertext.subarray(12, -16);
5908
5909	try {
5910	const aesgcm = crypto.createDecipheriv('aes-256-gcm', key, nonce);
5911	aesgcm.setAuthTag(authTag);
5912	return `${aesgcm.update(ciphertext)}${aesgcm.final()}`
5913	} catch (error) {
5914	const isRange = error instanceof RangeError;
5915	const invalidKeyLength = error.message === 'Invalid key length';
5916	const decryptionFailed = error.message === 'Unsupported state or unable to authenticate data';
5917
5918	if (isRange \|\| invalidKeyLength) {
5919	const err = new Error('INVALID_DOTENV_KEY: It must be 64 characters long (or more)');
5920	err.code = 'INVALID_DOTENV_KEY';
5921	throw err
5922	} else if (decryptionFailed) {
5923	const err = new Error('DECRYPTION_FAILED: Please check your DOTENV_KEY');
5924	err.code = 'DECRYPTION_FAILED';
5925	throw err
5926	} else {
5927	throw error
5928	}
5929	}
5930	}
5931
5932	// Populate process.env with parsed values
5933	function populate (processEnv, parsed, options = {}) {
5934	const debug = Boolean(options && options.debug);
5935	const override = Boolean(options && options.override);
5936
5937	if (typeof parsed !== 'object') {
5938	const err = new Error('OBJECT_REQUIRED: Please check the processEnv argument being passed to populate');
5939	err.code = 'OBJECT_REQUIRED';
5940	throw err
5941	}
5942
5943	// Set process.env
5944	for (const key of Object.keys(parsed)) {
5945	if (Object.prototype.hasOwnProperty.call(processEnv, key)) {
5946	if (override === true) {
5947	processEnv[key] = parsed[key];
5948	}
5949
5950	if (debug) {
5951	if (override === true) {
5952	_debug(`"${key}" is already defined and WAS overwritten`);
5953	} else {
5954	_debug(`"${key}" is already defined and was NOT overwritten`);
5955	}
5956	}
5957	} else {
5958	processEnv[key] = parsed[key];
5959	}
5960	}
5961	}
5962
5963	const DotenvModule = {
5964	configDotenv,
5965	_configVault,
5966	_parseVault,
5967	config,
5968	decrypt,
5969	parse,
5970	populate
5971	};
5972
5973	main$1.exports.configDotenv = DotenvModule.configDotenv;
5974	main$1.exports._configVault = DotenvModule._configVault;
5975	main$1.exports._parseVault = DotenvModule._parseVault;
5976	main$1.exports.config = DotenvModule.config;
5977	main$1.exports.decrypt = DotenvModule.decrypt;
5978	var parse_1 = main$1.exports.parse = DotenvModule.parse;
5979	main$1.exports.populate = DotenvModule.populate;
5980
5981	main$1.exports = DotenvModule;
5982
5983	// * /
5984	// * (\\)? # is it escaped with a backslash?
5985	// * (\$) # literal $
5986	// * (?!\() # shouldnt be followed by parenthesis
5987	// * (\{?) # first brace wrap opening
5988	// * ([\w.]+) # key
5989	// * (?::-((?:\$\{(?:\$\{(?:\$\{[^}]\}\|[^}])}\|[^}])*}\|[^}])+))? # optional default nested 3 times
5990	// * (\}?) # last brace warp closing
5991	// * /xi
5992
5993	const DOTENV_SUBSTITUTION_REGEX = /(\\)?(\$)(?!\()(\{?)([\w.]+)(?::?-((?:\$\{(?:\$\{(?:\$\{[^}]\}\|[^}])}\|[^}])*}\|[^}])+))?(\}?)/gi;
5994
5995	function _resolveEscapeSequences (value) {
5996	return value.replace(/\\\$/g, '$')
5997	}
5998
5999	function interpolate (value, processEnv, parsed) {
6000	return value.replace(DOTENV_SUBSTITUTION_REGEX, (match, escaped, dollarSign, openBrace, key, defaultValue, closeBrace) => {
6001	if (escaped === '\\') {
6002	return match.slice(1)
6003	} else {
6004	if (processEnv[key]) {
6005	if (processEnv[key] === parsed[key]) {
6006	return processEnv[key]
6007	} else {
6008	// scenario: PASSWORD_EXPAND_NESTED=${PASSWORD_EXPAND}
6009	return interpolate(processEnv[key], processEnv, parsed)
6010	}
6011	}
6012
6013	if (parsed[key]) {
6014	// avoid recursion from EXPAND_SELF=$EXPAND_SELF
6015	if (parsed[key] === value) {
6016	return parsed[key]
6017	} else {
6018	return interpolate(parsed[key], processEnv, parsed)
6019	}
6020	}
6021
6022	if (defaultValue) {
6023	if (defaultValue.startsWith('$')) {
6024	return interpolate(defaultValue, processEnv, parsed)
6025	} else {
6026	return defaultValue
6027	}
6028	}
6029
6030	return ''
6031	}
6032	})
6033	}
6034
6035	function expand (options) {
6036	let processEnv = process.env;
6037	if (options && options.processEnv != null) {
6038	processEnv = options.processEnv;
6039	}
6040
6041	for (const key in options.parsed) {
6042	let value = options.parsed[key];
6043
6044	const inProcessEnv = Object.prototype.hasOwnProperty.call(processEnv, key);
6045	if (inProcessEnv) {
6046	if (processEnv[key] === options.parsed[key]) {
6047	// assume was set to processEnv from the .env file if the values match and therefore interpolate
6048	value = interpolate(value, processEnv, options.parsed);
6049	} else {
6050	// do not interpolate - assume processEnv had the intended value even if containing a $.
6051	value = processEnv[key];
6052	}
6053	} else {
6054	// not inProcessEnv so assume interpolation for this .env key
6055	value = interpolate(value, processEnv, options.parsed);
6056	}
6057
6058	options.parsed[key] = _resolveEscapeSequences(value);
6059	}
6060
6061	for (const processKey in options.parsed) {
6062	processEnv[processKey] = options.parsed[processKey];
6063	}
6064
6065	return options
6066	}
6067
6068	var expand_1 = expand;
6069
6070	function getEnvFilesForMode(mode, envDir) {
6071	return [
6072	/** default file */
6073	`.env`,
6074	/** local file */
6075	`.env.local`,
6076	/** mode file */
6077	`.env.${mode}`,
6078	/** mode local file */
6079	`.env.${mode}.local`
6080	].map((file) => normalizePath(path$3.join(envDir, file)));
6081	}
6082	function loadEnv(mode, envDir, prefixes = "VITE_") {
6083	if (mode === "local") {
6084	throw new Error(
6085	`"local" cannot be used as a mode name because it conflicts with the .local postfix for .env files.`
6086	);
6087	}
6088	prefixes = arraify(prefixes);
6089	const env = {};
6090	const envFiles = getEnvFilesForMode(mode, envDir);
6091	const parsed = Object.fromEntries(
6092	envFiles.flatMap((filePath) => {
6093	if (!tryStatSync(filePath)?.isFile()) return [];
6094	return Object.entries(parse_1(fs$1.readFileSync(filePath)));
6095	})
6096	);
6097	if (parsed.NODE_ENV && process.env.VITE_USER_NODE_ENV === void 0) {
6098	process.env.VITE_USER_NODE_ENV = parsed.NODE_ENV;
6099	}
6100	if (parsed.BROWSER && process.env.BROWSER === void 0) {
6101	process.env.BROWSER = parsed.BROWSER;
6102	}
6103	if (parsed.BROWSER_ARGS && process.env.BROWSER_ARGS === void 0) {
6104	process.env.BROWSER_ARGS = parsed.BROWSER_ARGS;
6105	}
6106	const processEnv = { ...process.env };
6107	expand_1({ parsed, processEnv });
6108	for (const [key, value] of Object.entries(parsed)) {
6109	if (prefixes.some((prefix) => key.startsWith(prefix))) {
6110	env[key] = value;
6111	}
6112	}
6113	for (const key in process.env) {
6114	if (prefixes.some((prefix) => key.startsWith(prefix))) {
6115	env[key] = process.env[key];
6116	}
6117	}
6118	return env;
6119	}
6120	function resolveEnvPrefix({
6121	envPrefix = "VITE_"
6122	}) {
6123	envPrefix = arraify(envPrefix);
6124	if (envPrefix.includes("")) {
6125	throw new Error(
6126	`envPrefix option contains value '', which could lead unexpected exposure of sensitive information.`
6127	);
6128	}
6129	return envPrefix;
6130	}
6131
6132	exports.esbuildVersion = esbuild.version;
6133	exports.createFilter = createFilter;
6134	exports.createLogger = createLogger;
6135	exports.isCSSRequest = isCSSRequest;
6136	exports.isFileServingAllowed = isFileServingAllowed;
6137	exports.loadEnv = loadEnv;
6138	exports.mergeAlias = mergeAlias;
6139	exports.mergeConfig = mergeConfig;
6140	exports.normalizePath = normalizePath;
6141	exports.resolveEnvPrefix = resolveEnvPrefix;
6142	exports.rollupVersion = rollupVersion;
6143	exports.searchForWorkspaceRoot = searchForWorkspaceRoot;
6144	exports.send = send;
6145	exports.splitVendorChunk = splitVendorChunk;
6146	exports.splitVendorChunkPlugin = splitVendorChunkPlugin;
6147	exports.version = VERSION;

Note: See TracBrowser for help on using the repository browser.

Download in other formats:

Original Format