vite 5.0.2 → 5.0.4

package/dist/node/chunks/{dep-ErEj4WmL.js → dep-4RECYSE1.js}

@@ -6,8 +6,8 @@ import { promisify as promisify$4, format as format$2, inspect } from 'node:util
 import { performance } from 'node:perf_hooks';
 import { createRequire as createRequire$1, builtinModules } from 'node:module';
 import require$$0$3 from 'tty';
-import esbuild, { transform as transform$1, formatMessages, build as build$3 } from 'esbuild';
 import require$$0$4, { win32, posix, isAbsolute as isAbsolute$1, resolve as resolve$3, relative as relative$1, basename as basename$1, extname, dirname as dirname$1, join as join$1, sep, normalize } from 'path';
+import esbuild, { transform as transform$1, formatMessages, build as build$3 } from 'esbuild';
 import * as require$$0$2 from 'fs';
 import require$$0__default, { existsSync, readFileSync, statSync as statSync$1, readdirSync } from 'fs';
 import require$$0$5 from 'events';
@@ -219,7 +219,16 @@ function alias$1(options = {}) {
             if (matchedEntry.resolverFunction) {
                 return matchedEntry.resolverFunction.call(this, updatedId, importer, resolveOptions);
             }
-            return this.resolve(updatedId, importer, Object.assign({ skipSelf: true }, resolveOptions)).then((resolved) => resolved || { id: updatedId });
+            return this.resolve(updatedId, importer, Object.assign({ skipSelf: true }, resolveOptions)).then((resolved) => {
+                if (resolved)
+                    return resolved;
+                if (!require$$0$4.isAbsolute(updatedId)) {
+                    this.warn(`rewrote ${importee} to ${updatedId} but was not an abolute path and was not handled by other plugins. ` +
+                        `This will lead to duplicated modules for the same path. ` +
+                        `To avoid duplicating modules, you should resolve to an absolute path.`);
+                }
+                return { id: updatedId };
+            });
         }
     };
 }
@@ -5298,7 +5307,7 @@ function makeres (key) {
   return once(function RES () {
     var cbs = reqs[key];
     var len = cbs.length;
-    var args = slice$1(arguments);
+    var args = slice$3(arguments);
 
     // XXX It's somewhat ambiguous whether a new callback added in this
     // pass should be queued for later execution if something in the
@@ -5325,7 +5334,7 @@ function makeres (key) {
   })
 }
 
-function slice$1 (args) {
+function slice$3 (args) {
   var length = args.length;
   var array = [];
 
@@ -6556,10 +6565,10 @@ function getRelativePath(from, to) {
 	return fromParts.concat(toParts).join('/');
 }
 
-const toString$2 = Object.prototype.toString;
+const toString$3 = Object.prototype.toString;
 
 function isObject$2(thing) {
-	return toString$2.call(thing) === '[object Object]';
+	return toString$3.call(thing) === '[object Object]';
 }
 
 function getLocator(source) {
@@ -10657,7 +10666,7 @@ function remapping(input, loader, options) {
     return new SourceMap(traceMappings(tree), opts);
 }
 
-var src$2 = {exports: {}};
+var src$3 = {exports: {}};
 
 var node$1 = {exports: {}};
 
@@ -11674,12 +11683,12 @@ function requireBrowser$1 () {
  */
 
 if (typeof process === 'undefined' || process.type === 'renderer' || process.browser === true || process.__nwjs) {
-	src$2.exports = requireBrowser$1();
+	src$3.exports = requireBrowser$1();
 } else {
-	src$2.exports = requireNode$1();
+	src$3.exports = requireNode$1();
 }
 
-var srcExports$1 = src$2.exports;
+var srcExports$1 = src$3.exports;
 var debug$i = /*@__PURE__*/getDefaultExportFromCjs(srcExports$1);
 
 let pnp;
@@ -12276,8 +12285,8 @@ function numberToPos(source, offset) {
     return { line: line + 1, column };
 }
 function generateCodeFrame(source, start = 0, end) {
-    start = posToNumber(source, start);
-    end = end !== undefined ? posToNumber(source, end) : start;
+    start = Math.max(posToNumber(source, start), 0);
+    end = Math.min(end !== undefined ? posToNumber(source, end) : start, source.length);
     const lines = source.split(splitRE);
     let count = 0;
     const res = [];
@@ -12681,6 +12690,7 @@ function arraify(target) {
 const multilineCommentsRE$1 = /\/\*[^*]*\*+(?:[^/*][^*]*\*+)*\//g;
 const singlelineCommentsRE$1 = /\/\/.*/g;
 const requestQuerySplitRE = /\?(?!.*[/|}])/;
+const requestQueryMaybeEscapedSplitRE = /\\?\?(?!.*[/|}])/;
 function parseRequest(id) {
     const [_, search] = id.split(requestQuerySplitRE, 2);
     if (!search) {
@@ -12945,6 +12955,15 @@ function getPackageManagerCommand(type = 'install') {
 function isDevServer(server) {
     return 'pluginContainer' in server;
 }
+function promiseWithResolvers() {
+    let resolve;
+    let reject;
+    const promise = new Promise((_resolve, _reject) => {
+        resolve = _resolve;
+        reject = _reject;
+    });
+    return { promise, resolve, reject };
+}
 
 /* eslint no-console: 0 */
 const LogLevels = {
@@ -14919,86 +14938,1020 @@ function terserPlugin(config) {
     };
 }
 
-var json = JSON;
+var toString$2 = {}.toString;
 
-var isArray$1 = Array.isArray || function (x) {
-	return {}.toString.call(x) === '[object Array]';
+var isarray = Array.isArray || function (arr) {
+  return toString$2.call(arr) == '[object Array]';
 };
 
-var objectKeys = Object.keys || function (obj) {
-	var has = Object.prototype.hasOwnProperty || function () { return true; };
-	var keys = [];
-	for (var key in obj) {
-		if (has.call(obj, key)) { keys.push(key); }
+var toStr$2 = Object.prototype.toString;
+
+var isArguments = function isArguments(value) {
+	var str = toStr$2.call(value);
+	var isArgs = str === '[object Arguments]';
+	if (!isArgs) {
+		isArgs = str !== '[object Array]' &&
+			value !== null &&
+			typeof value === 'object' &&
+			typeof value.length === 'number' &&
+			value.length >= 0 &&
+			toStr$2.call(value.callee) === '[object Function]';
+	}
+	return isArgs;
+};
+
+var implementation$4;
+var hasRequiredImplementation;
+
+function requireImplementation () {
+	if (hasRequiredImplementation) return implementation$4;
+	hasRequiredImplementation = 1;
+
+	var keysShim;
+	if (!Object.keys) {
+		// modified from https://github.com/es-shims/es5-shim
+		var has = Object.prototype.hasOwnProperty;
+		var toStr = Object.prototype.toString;
+		var isArgs = isArguments; // eslint-disable-line global-require
+		var isEnumerable = Object.prototype.propertyIsEnumerable;
+		var hasDontEnumBug = !isEnumerable.call({ toString: null }, 'toString');
+		var hasProtoEnumBug = isEnumerable.call(function () {}, 'prototype');
+		var dontEnums = [
+			'toString',
+			'toLocaleString',
+			'valueOf',
+			'hasOwnProperty',
+			'isPrototypeOf',
+			'propertyIsEnumerable',
+			'constructor'
+		];
+		var equalsConstructorPrototype = function (o) {
+			var ctor = o.constructor;
+			return ctor && ctor.prototype === o;
+		};
+		var excludedKeys = {
+			$applicationCache: true,
+			$console: true,
+			$external: true,
+			$frame: true,
+			$frameElement: true,
+			$frames: true,
+			$innerHeight: true,
+			$innerWidth: true,
+			$onmozfullscreenchange: true,
+			$onmozfullscreenerror: true,
+			$outerHeight: true,
+			$outerWidth: true,
+			$pageXOffset: true,
+			$pageYOffset: true,
+			$parent: true,
+			$scrollLeft: true,
+			$scrollTop: true,
+			$scrollX: true,
+			$scrollY: true,
+			$self: true,
+			$webkitIndexedDB: true,
+			$webkitStorageInfo: true,
+			$window: true
+		};
+		var hasAutomationEqualityBug = (function () {
+			/* global window */
+			if (typeof window === 'undefined') { return false; }
+			for (var k in window) {
+				try {
+					if (!excludedKeys['$' + k] && has.call(window, k) && window[k] !== null && typeof window[k] === 'object') {
+						try {
+							equalsConstructorPrototype(window[k]);
+						} catch (e) {
+							return true;
+						}
+					}
+				} catch (e) {
+					return true;
+				}
+			}
+			return false;
+		}());
+		var equalsConstructorPrototypeIfNotBuggy = function (o) {
+			/* global window */
+			if (typeof window === 'undefined' || !hasAutomationEqualityBug) {
+				return equalsConstructorPrototype(o);
+			}
+			try {
+				return equalsConstructorPrototype(o);
+			} catch (e) {
+				return false;
+			}
+		};
+
+		keysShim = function keys(object) {
+			var isObject = object !== null && typeof object === 'object';
+			var isFunction = toStr.call(object) === '[object Function]';
+			var isArguments = isArgs(object);
+			var isString = isObject && toStr.call(object) === '[object String]';
+			var theKeys = [];
+
+			if (!isObject && !isFunction && !isArguments) {
+				throw new TypeError('Object.keys called on a non-object');
+			}
+
+			var skipProto = hasProtoEnumBug && isFunction;
+			if (isString && object.length > 0 && !has.call(object, 0)) {
+				for (var i = 0; i < object.length; ++i) {
+					theKeys.push(String(i));
+				}
+			}
+
+			if (isArguments && object.length > 0) {
+				for (var j = 0; j < object.length; ++j) {
+					theKeys.push(String(j));
+				}
+			} else {
+				for (var name in object) {
+					if (!(skipProto && name === 'prototype') && has.call(object, name)) {
+						theKeys.push(String(name));
+					}
+				}
+			}
+
+			if (hasDontEnumBug) {
+				var skipConstructor = equalsConstructorPrototypeIfNotBuggy(object);
+
+				for (var k = 0; k < dontEnums.length; ++k) {
+					if (!(skipConstructor && dontEnums[k] === 'constructor') && has.call(object, dontEnums[k])) {
+						theKeys.push(dontEnums[k]);
+					}
+				}
+			}
+			return theKeys;
+		};
 	}
-	return keys;
-};
-
-var jsonStableStringify = function (obj, opts) {
-	if (!opts) { opts = {}; }
-	if (typeof opts === 'function') { opts = { cmp: opts }; }
-	var space = opts.space || '';
-	if (typeof space === 'number') { space = Array(space + 1).join(' '); }
-	var cycles = typeof opts.cycles === 'boolean' ? opts.cycles : false;
-	var replacer = opts.replacer || function (key, value) { return value; };
-
-	var cmp = opts.cmp && (function (f) {
-		return function (node) {
-			return function (a, b) {
-				var aobj = { key: a, value: node[a] };
-				var bobj = { key: b, value: node[b] };
-				return f(aobj, bobj);
+	implementation$4 = keysShim;
+	return implementation$4;
+}
+
+var slice$2 = Array.prototype.slice;
+var isArgs = isArguments;
+
+var origKeys = Object.keys;
+var keysShim = origKeys ? function keys(o) { return origKeys(o); } : requireImplementation();
+
+var originalKeys = Object.keys;
+
+keysShim.shim = function shimObjectKeys() {
+	if (Object.keys) {
+		var keysWorksWithArguments = (function () {
+			// Safari 5.0 bug
+			var args = Object.keys(arguments);
+			return args && args.length === arguments.length;
+		}(1, 2));
+		if (!keysWorksWithArguments) {
+			Object.keys = function keys(object) { // eslint-disable-line func-name-matching
+				if (isArgs(object)) {
+					return originalKeys(slice$2.call(object));
+				}
+				return originalKeys(object);
 			};
+		}
+	} else {
+		Object.keys = keysShim;
+	}
+	return Object.keys || keysShim;
+};
+
+var objectKeys$1 = keysShim;
+
+var callBind$1 = {exports: {}};
+
+/* eslint no-invalid-this: 1 */
+
+var ERROR_MESSAGE$1 = 'Function.prototype.bind called on incompatible ';
+var toStr$1 = Object.prototype.toString;
+var max = Math.max;
+var funcType$1 = '[object Function]';
+
+var concatty = function concatty(a, b) {
+    var arr = [];
+
+    for (var i = 0; i < a.length; i += 1) {
+        arr[i] = a[i];
+    }
+    for (var j = 0; j < b.length; j += 1) {
+        arr[j + a.length] = b[j];
+    }
+
+    return arr;
+};
+
+var slicy = function slicy(arrLike, offset) {
+    var arr = [];
+    for (var i = offset || 0, j = 0; i < arrLike.length; i += 1, j += 1) {
+        arr[j] = arrLike[i];
+    }
+    return arr;
+};
+
+var joiny = function (arr, joiner) {
+    var str = '';
+    for (var i = 0; i < arr.length; i += 1) {
+        str += arr[i];
+        if (i + 1 < arr.length) {
+            str += joiner;
+        }
+    }
+    return str;
+};
+
+var implementation$3 = function bind(that) {
+    var target = this;
+    if (typeof target !== 'function' || toStr$1.apply(target) !== funcType$1) {
+        throw new TypeError(ERROR_MESSAGE$1 + target);
+    }
+    var args = slicy(arguments, 1);
+
+    var bound;
+    var binder = function () {
+        if (this instanceof bound) {
+            var result = target.apply(
+                this,
+                concatty(args, arguments)
+            );
+            if (Object(result) === result) {
+                return result;
+            }
+            return this;
+        }
+        return target.apply(
+            that,
+            concatty(args, arguments)
+        );
+
+    };
+
+    var boundLength = max(0, target.length - args.length);
+    var boundArgs = [];
+    for (var i = 0; i < boundLength; i++) {
+        boundArgs[i] = '$' + i;
+    }
+
+    bound = Function('binder', 'return function (' + joiny(boundArgs, ',') + '){ return binder.apply(this,arguments); }')(binder);
+
+    if (target.prototype) {
+        var Empty = function Empty() {};
+        Empty.prototype = target.prototype;
+        bound.prototype = new Empty();
+        Empty.prototype = null;
+    }
+
+    return bound;
+};
+
+var implementation$2 = implementation$3;
+
+var functionBind$1 = Function.prototype.bind || implementation$2;
+
+/* eslint complexity: [2, 18], max-statements: [2, 33] */
+var shams = function hasSymbols() {
+	if (typeof Symbol !== 'function' || typeof Object.getOwnPropertySymbols !== 'function') { return false; }
+	if (typeof Symbol.iterator === 'symbol') { return true; }
+
+	var obj = {};
+	var sym = Symbol('test');
+	var symObj = Object(sym);
+	if (typeof sym === 'string') { return false; }
+
+	if (Object.prototype.toString.call(sym) !== '[object Symbol]') { return false; }
+	if (Object.prototype.toString.call(symObj) !== '[object Symbol]') { return false; }
+
+	// temp disabled per https://github.com/ljharb/object.assign/issues/17
+	// if (sym instanceof Symbol) { return false; }
+	// temp disabled per https://github.com/WebReflection/get-own-property-symbols/issues/4
+	// if (!(symObj instanceof Symbol)) { return false; }
+
+	// if (typeof Symbol.prototype.toString !== 'function') { return false; }
+	// if (String(sym) !== Symbol.prototype.toString.call(sym)) { return false; }
+
+	var symVal = 42;
+	obj[sym] = symVal;
+	for (sym in obj) { return false; } // eslint-disable-line no-restricted-syntax, no-unreachable-loop
+	if (typeof Object.keys === 'function' && Object.keys(obj).length !== 0) { return false; }
+
+	if (typeof Object.getOwnPropertyNames === 'function' && Object.getOwnPropertyNames(obj).length !== 0) { return false; }
+
+	var syms = Object.getOwnPropertySymbols(obj);
+	if (syms.length !== 1 || syms[0] !== sym) { return false; }
+
+	if (!Object.prototype.propertyIsEnumerable.call(obj, sym)) { return false; }
+
+	if (typeof Object.getOwnPropertyDescriptor === 'function') {
+		var descriptor = Object.getOwnPropertyDescriptor(obj, sym);
+		if (descriptor.value !== symVal || descriptor.enumerable !== true) { return false; }
+	}
+
+	return true;
+};
+
+var origSymbol = typeof Symbol !== 'undefined' && Symbol;
+var hasSymbolSham = shams;
+
+var hasSymbols$1 = function hasNativeSymbols() {
+	if (typeof origSymbol !== 'function') { return false; }
+	if (typeof Symbol !== 'function') { return false; }
+	if (typeof origSymbol('foo') !== 'symbol') { return false; }
+	if (typeof Symbol('bar') !== 'symbol') { return false; }
+
+	return hasSymbolSham();
+};
+
+var test = {
+	foo: {}
+};
+
+var $Object = Object;
+
+var hasProto$1 = function hasProto() {
+	return { __proto__: test }.foo === test.foo && !({ __proto__: null } instanceof $Object);
+};
+
+/* eslint no-invalid-this: 1 */
+
+var ERROR_MESSAGE = 'Function.prototype.bind called on incompatible ';
+var slice$1 = Array.prototype.slice;
+var toStr = Object.prototype.toString;
+var funcType = '[object Function]';
+
+var implementation$1 = function bind(that) {
+    var target = this;
+    if (typeof target !== 'function' || toStr.call(target) !== funcType) {
+        throw new TypeError(ERROR_MESSAGE + target);
+    }
+    var args = slice$1.call(arguments, 1);
+
+    var bound;
+    var binder = function () {
+        if (this instanceof bound) {
+            var result = target.apply(
+                this,
+                args.concat(slice$1.call(arguments))
+            );
+            if (Object(result) === result) {
+                return result;
+            }
+            return this;
+        } else {
+            return target.apply(
+                that,
+                args.concat(slice$1.call(arguments))
+            );
+        }
+    };
+
+    var boundLength = Math.max(0, target.length - args.length);
+    var boundArgs = [];
+    for (var i = 0; i < boundLength; i++) {
+        boundArgs.push('$' + i);
+    }
+
+    bound = Function('binder', 'return function (' + boundArgs.join(',') + '){ return binder.apply(this,arguments); }')(binder);
+
+    if (target.prototype) {
+        var Empty = function Empty() {};
+        Empty.prototype = target.prototype;
+        bound.prototype = new Empty();
+        Empty.prototype = null;
+    }
+
+    return bound;
+};
+
+var implementation = implementation$1;
+
+var functionBind = Function.prototype.bind || implementation;
+
+var bind$1 = functionBind;
+
+var src$2 = bind$1.call(Function.call, Object.prototype.hasOwnProperty);
+
+var undefined$1;
+
+var $SyntaxError$1 = SyntaxError;
+var $Function = Function;
+var $TypeError$2 = TypeError;
+
+// eslint-disable-next-line consistent-return
+var getEvalledConstructor = function (expressionSyntax) {
+	try {
+		return $Function('"use strict"; return (' + expressionSyntax + ').constructor;')();
+	} catch (e) {}
+};
+
+var $gOPD$1 = Object.getOwnPropertyDescriptor;
+
+var throwTypeError = function () {
+	throw new $TypeError$2();
+};
+var ThrowTypeError = $gOPD$1
+	? (function () {
+		try {
+			return throwTypeError;
+		} catch (calleeThrows) {
+			try {
+				// IE 8 throws on Object.getOwnPropertyDescriptor(arguments, '')
+				return $gOPD$1(arguments, 'callee').get;
+			} catch (gOPDthrows) {
+				return throwTypeError;
+			}
+		}
+	}())
+	: throwTypeError;
+
+var hasSymbols = hasSymbols$1();
+var hasProto = hasProto$1();
+
+var getProto = Object.getPrototypeOf || (
+	hasProto
+		? function (x) { return x.__proto__; } // eslint-disable-line no-proto
+		: null
+);
+
+var needsEval = {};
+
+var TypedArray = typeof Uint8Array === 'undefined' || !getProto ? undefined$1 : getProto(Uint8Array);
+
+var INTRINSICS = {
+	'%AggregateError%': typeof AggregateError === 'undefined' ? undefined$1 : AggregateError,
+	'%Array%': Array,
+	'%ArrayBuffer%': typeof ArrayBuffer === 'undefined' ? undefined$1 : ArrayBuffer,
+	'%ArrayIteratorPrototype%': hasSymbols && getProto ? getProto([][Symbol.iterator]()) : undefined$1,
+	'%AsyncFromSyncIteratorPrototype%': undefined$1,
+	'%AsyncFunction%': needsEval,
+	'%AsyncGenerator%': needsEval,
+	'%AsyncGeneratorFunction%': needsEval,
+	'%AsyncIteratorPrototype%': needsEval,
+	'%Atomics%': typeof Atomics === 'undefined' ? undefined$1 : Atomics,
+	'%BigInt%': typeof BigInt === 'undefined' ? undefined$1 : BigInt,
+	'%BigInt64Array%': typeof BigInt64Array === 'undefined' ? undefined$1 : BigInt64Array,
+	'%BigUint64Array%': typeof BigUint64Array === 'undefined' ? undefined$1 : BigUint64Array,
+	'%Boolean%': Boolean,
+	'%DataView%': typeof DataView === 'undefined' ? undefined$1 : DataView,
+	'%Date%': Date,
+	'%decodeURI%': decodeURI,
+	'%decodeURIComponent%': decodeURIComponent,
+	'%encodeURI%': encodeURI,
+	'%encodeURIComponent%': encodeURIComponent,
+	'%Error%': Error,
+	'%eval%': eval, // eslint-disable-line no-eval
+	'%EvalError%': EvalError,
+	'%Float32Array%': typeof Float32Array === 'undefined' ? undefined$1 : Float32Array,
+	'%Float64Array%': typeof Float64Array === 'undefined' ? undefined$1 : Float64Array,
+	'%FinalizationRegistry%': typeof FinalizationRegistry === 'undefined' ? undefined$1 : FinalizationRegistry,
+	'%Function%': $Function,
+	'%GeneratorFunction%': needsEval,
+	'%Int8Array%': typeof Int8Array === 'undefined' ? undefined$1 : Int8Array,
+	'%Int16Array%': typeof Int16Array === 'undefined' ? undefined$1 : Int16Array,
+	'%Int32Array%': typeof Int32Array === 'undefined' ? undefined$1 : Int32Array,
+	'%isFinite%': isFinite,
+	'%isNaN%': isNaN,
+	'%IteratorPrototype%': hasSymbols && getProto ? getProto(getProto([][Symbol.iterator]())) : undefined$1,
+	'%JSON%': typeof JSON === 'object' ? JSON : undefined$1,
+	'%Map%': typeof Map === 'undefined' ? undefined$1 : Map,
+	'%MapIteratorPrototype%': typeof Map === 'undefined' || !hasSymbols || !getProto ? undefined$1 : getProto(new Map()[Symbol.iterator]()),
+	'%Math%': Math,
+	'%Number%': Number,
+	'%Object%': Object,
+	'%parseFloat%': parseFloat,
+	'%parseInt%': parseInt,
+	'%Promise%': typeof Promise === 'undefined' ? undefined$1 : Promise,
+	'%Proxy%': typeof Proxy === 'undefined' ? undefined$1 : Proxy,
+	'%RangeError%': RangeError,
+	'%ReferenceError%': ReferenceError,
+	'%Reflect%': typeof Reflect === 'undefined' ? undefined$1 : Reflect,
+	'%RegExp%': RegExp,
+	'%Set%': typeof Set === 'undefined' ? undefined$1 : Set,
+	'%SetIteratorPrototype%': typeof Set === 'undefined' || !hasSymbols || !getProto ? undefined$1 : getProto(new Set()[Symbol.iterator]()),
+	'%SharedArrayBuffer%': typeof SharedArrayBuffer === 'undefined' ? undefined$1 : SharedArrayBuffer,
+	'%String%': String,
+	'%StringIteratorPrototype%': hasSymbols && getProto ? getProto(''[Symbol.iterator]()) : undefined$1,
+	'%Symbol%': hasSymbols ? Symbol : undefined$1,
+	'%SyntaxError%': $SyntaxError$1,
+	'%ThrowTypeError%': ThrowTypeError,
+	'%TypedArray%': TypedArray,
+	'%TypeError%': $TypeError$2,
+	'%Uint8Array%': typeof Uint8Array === 'undefined' ? undefined$1 : Uint8Array,
+	'%Uint8ClampedArray%': typeof Uint8ClampedArray === 'undefined' ? undefined$1 : Uint8ClampedArray,
+	'%Uint16Array%': typeof Uint16Array === 'undefined' ? undefined$1 : Uint16Array,
+	'%Uint32Array%': typeof Uint32Array === 'undefined' ? undefined$1 : Uint32Array,
+	'%URIError%': URIError,
+	'%WeakMap%': typeof WeakMap === 'undefined' ? undefined$1 : WeakMap,
+	'%WeakRef%': typeof WeakRef === 'undefined' ? undefined$1 : WeakRef,
+	'%WeakSet%': typeof WeakSet === 'undefined' ? undefined$1 : WeakSet
+};
+
+var doEval = function doEval(name) {
+	var value;
+	if (name === '%AsyncFunction%') {
+		value = getEvalledConstructor('async function () {}');
+	} else if (name === '%GeneratorFunction%') {
+		value = getEvalledConstructor('function* () {}');
+	} else if (name === '%AsyncGeneratorFunction%') {
+		value = getEvalledConstructor('async function* () {}');
+	} else if (name === '%AsyncGenerator%') {
+		var fn = doEval('%AsyncGeneratorFunction%');
+		if (fn) {
+			value = fn.prototype;
+		}
+	} else if (name === '%AsyncIteratorPrototype%') {
+		var gen = doEval('%AsyncGenerator%');
+		if (gen && getProto) {
+			value = getProto(gen.prototype);
+		}
+	}
+
+	INTRINSICS[name] = value;
+
+	return value;
+};
+
+var LEGACY_ALIASES = {
+	'%ArrayBufferPrototype%': ['ArrayBuffer', 'prototype'],
+	'%ArrayPrototype%': ['Array', 'prototype'],
+	'%ArrayProto_entries%': ['Array', 'prototype', 'entries'],
+	'%ArrayProto_forEach%': ['Array', 'prototype', 'forEach'],
+	'%ArrayProto_keys%': ['Array', 'prototype', 'keys'],
+	'%ArrayProto_values%': ['Array', 'prototype', 'values'],
+	'%AsyncFunctionPrototype%': ['AsyncFunction', 'prototype'],
+	'%AsyncGenerator%': ['AsyncGeneratorFunction', 'prototype'],
+	'%AsyncGeneratorPrototype%': ['AsyncGeneratorFunction', 'prototype', 'prototype'],
+	'%BooleanPrototype%': ['Boolean', 'prototype'],
+	'%DataViewPrototype%': ['DataView', 'prototype'],
+	'%DatePrototype%': ['Date', 'prototype'],
+	'%ErrorPrototype%': ['Error', 'prototype'],
+	'%EvalErrorPrototype%': ['EvalError', 'prototype'],
+	'%Float32ArrayPrototype%': ['Float32Array', 'prototype'],
+	'%Float64ArrayPrototype%': ['Float64Array', 'prototype'],
+	'%FunctionPrototype%': ['Function', 'prototype'],
+	'%Generator%': ['GeneratorFunction', 'prototype'],
+	'%GeneratorPrototype%': ['GeneratorFunction', 'prototype', 'prototype'],
+	'%Int8ArrayPrototype%': ['Int8Array', 'prototype'],
+	'%Int16ArrayPrototype%': ['Int16Array', 'prototype'],
+	'%Int32ArrayPrototype%': ['Int32Array', 'prototype'],
+	'%JSONParse%': ['JSON', 'parse'],
+	'%JSONStringify%': ['JSON', 'stringify'],
+	'%MapPrototype%': ['Map', 'prototype'],
+	'%NumberPrototype%': ['Number', 'prototype'],
+	'%ObjectPrototype%': ['Object', 'prototype'],
+	'%ObjProto_toString%': ['Object', 'prototype', 'toString'],
+	'%ObjProto_valueOf%': ['Object', 'prototype', 'valueOf'],
+	'%PromisePrototype%': ['Promise', 'prototype'],
+	'%PromiseProto_then%': ['Promise', 'prototype', 'then'],
+	'%Promise_all%': ['Promise', 'all'],
+	'%Promise_reject%': ['Promise', 'reject'],
+	'%Promise_resolve%': ['Promise', 'resolve'],
+	'%RangeErrorPrototype%': ['RangeError', 'prototype'],
+	'%ReferenceErrorPrototype%': ['ReferenceError', 'prototype'],
+	'%RegExpPrototype%': ['RegExp', 'prototype'],
+	'%SetPrototype%': ['Set', 'prototype'],
+	'%SharedArrayBufferPrototype%': ['SharedArrayBuffer', 'prototype'],
+	'%StringPrototype%': ['String', 'prototype'],
+	'%SymbolPrototype%': ['Symbol', 'prototype'],
+	'%SyntaxErrorPrototype%': ['SyntaxError', 'prototype'],
+	'%TypedArrayPrototype%': ['TypedArray', 'prototype'],
+	'%TypeErrorPrototype%': ['TypeError', 'prototype'],
+	'%Uint8ArrayPrototype%': ['Uint8Array', 'prototype'],
+	'%Uint8ClampedArrayPrototype%': ['Uint8ClampedArray', 'prototype'],
+	'%Uint16ArrayPrototype%': ['Uint16Array', 'prototype'],
+	'%Uint32ArrayPrototype%': ['Uint32Array', 'prototype'],
+	'%URIErrorPrototype%': ['URIError', 'prototype'],
+	'%WeakMapPrototype%': ['WeakMap', 'prototype'],
+	'%WeakSetPrototype%': ['WeakSet', 'prototype']
+};
+
+var bind = functionBind$1;
+var hasOwn$1 = src$2;
+var $concat = bind.call(Function.call, Array.prototype.concat);
+var $spliceApply = bind.call(Function.apply, Array.prototype.splice);
+var $replace = bind.call(Function.call, String.prototype.replace);
+var $strSlice = bind.call(Function.call, String.prototype.slice);
+var $exec = bind.call(Function.call, RegExp.prototype.exec);
+
+/* adapted from https://github.com/lodash/lodash/blob/4.17.15/dist/lodash.js#L6735-L6744 */
+var rePropName = /[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g;
+var reEscapeChar = /\\(\\)?/g; /** Used to match backslashes in property paths. */
+var stringToPath = function stringToPath(string) {
+	var first = $strSlice(string, 0, 1);
+	var last = $strSlice(string, -1);
+	if (first === '%' && last !== '%') {
+		throw new $SyntaxError$1('invalid intrinsic syntax, expected closing `%`');
+	} else if (last === '%' && first !== '%') {
+		throw new $SyntaxError$1('invalid intrinsic syntax, expected opening `%`');
+	}
+	var result = [];
+	$replace(string, rePropName, function (match, number, quote, subString) {
+		result[result.length] = quote ? $replace(subString, reEscapeChar, '$1') : number || match;
+	});
+	return result;
+};
+/* end adaptation */
+
+var getBaseIntrinsic = function getBaseIntrinsic(name, allowMissing) {
+	var intrinsicName = name;
+	var alias;
+	if (hasOwn$1(LEGACY_ALIASES, intrinsicName)) {
+		alias = LEGACY_ALIASES[intrinsicName];
+		intrinsicName = '%' + alias[0] + '%';
+	}
+
+	if (hasOwn$1(INTRINSICS, intrinsicName)) {
+		var value = INTRINSICS[intrinsicName];
+		if (value === needsEval) {
+			value = doEval(intrinsicName);
+		}
+		if (typeof value === 'undefined' && !allowMissing) {
+			throw new $TypeError$2('intrinsic ' + name + ' exists, but is not available. Please file an issue!');
+		}
+
+		return {
+			alias: alias,
+			name: intrinsicName,
+			value: value
+		};
+	}
+
+	throw new $SyntaxError$1('intrinsic ' + name + ' does not exist!');
+};
+
+var getIntrinsic = function GetIntrinsic(name, allowMissing) {
+	if (typeof name !== 'string' || name.length === 0) {
+		throw new $TypeError$2('intrinsic name must be a non-empty string');
+	}
+	if (arguments.length > 1 && typeof allowMissing !== 'boolean') {
+		throw new $TypeError$2('"allowMissing" argument must be a boolean');
+	}
+
+	if ($exec(/^%?[^%]*%?$/, name) === null) {
+		throw new $SyntaxError$1('`%` may not be present anywhere but at the beginning and end of the intrinsic name');
+	}
+	var parts = stringToPath(name);
+	var intrinsicBaseName = parts.length > 0 ? parts[0] : '';
+
+	var intrinsic = getBaseIntrinsic('%' + intrinsicBaseName + '%', allowMissing);
+	var intrinsicRealName = intrinsic.name;
+	var value = intrinsic.value;
+	var skipFurtherCaching = false;
+
+	var alias = intrinsic.alias;
+	if (alias) {
+		intrinsicBaseName = alias[0];
+		$spliceApply(parts, $concat([0, 1], alias));
+	}
+
+	for (var i = 1, isOwn = true; i < parts.length; i += 1) {
+		var part = parts[i];
+		var first = $strSlice(part, 0, 1);
+		var last = $strSlice(part, -1);
+		if (
+			(
+				(first === '"' || first === "'" || first === '`')
+				|| (last === '"' || last === "'" || last === '`')
+			)
+			&& first !== last
+		) {
+			throw new $SyntaxError$1('property names with quotes must have matching quotes');
+		}
+		if (part === 'constructor' || !isOwn) {
+			skipFurtherCaching = true;
+		}
+
+		intrinsicBaseName += '.' + part;
+		intrinsicRealName = '%' + intrinsicBaseName + '%';
+
+		if (hasOwn$1(INTRINSICS, intrinsicRealName)) {
+			value = INTRINSICS[intrinsicRealName];
+		} else if (value != null) {
+			if (!(part in value)) {
+				if (!allowMissing) {
+					throw new $TypeError$2('base intrinsic for ' + name + ' exists, but the property is not available.');
+				}
+				return void undefined$1;
+			}
+			if ($gOPD$1 && (i + 1) >= parts.length) {
+				var desc = $gOPD$1(value, part);
+				isOwn = !!desc;
+
+				// By convention, when a data property is converted to an accessor
+				// property to emulate a data property that does not suffer from
+				// the override mistake, that accessor's getter is marked with
+				// an `originalValue` property. Here, when we detect this, we
+				// uphold the illusion by pretending to see that original data
+				// property, i.e., returning the value rather than the getter
+				// itself.
+				if (isOwn && 'get' in desc && !('originalValue' in desc.get)) {
+					value = desc.get;
+				} else {
+					value = value[part];
+				}
+			} else {
+				isOwn = hasOwn$1(value, part);
+				value = value[part];
+			}
+
+			if (isOwn && !skipFurtherCaching) {
+				INTRINSICS[intrinsicRealName] = value;
+			}
+		}
+	}
+	return value;
+};
+
+var GetIntrinsic$3 = getIntrinsic;
+
+var $defineProperty$1 = GetIntrinsic$3('%Object.defineProperty%', true);
+
+var hasPropertyDescriptors$1 = function hasPropertyDescriptors() {
+	if ($defineProperty$1) {
+		try {
+			$defineProperty$1({}, 'a', { value: 1 });
+			return true;
+		} catch (e) {
+			// IE 8 has a broken defineProperty
+			return false;
+		}
+	}
+	return false;
+};
+
+hasPropertyDescriptors$1.hasArrayLengthDefineBug = function hasArrayLengthDefineBug() {
+	// node v0.6 has a bug where array lengths can be Set but not Defined
+	if (!hasPropertyDescriptors$1()) {
+		return null;
+	}
+	try {
+		return $defineProperty$1([], 'length', { value: 1 }).length !== 1;
+	} catch (e) {
+		// In Firefox 4-22, defining length on an array throws an exception.
+		return true;
+	}
+};
+
+var hasPropertyDescriptors_1 = hasPropertyDescriptors$1;
+
+var GetIntrinsic$2 = getIntrinsic;
+
+var $gOPD = GetIntrinsic$2('%Object.getOwnPropertyDescriptor%', true);
+
+if ($gOPD) {
+	try {
+		$gOPD([], 'length');
+	} catch (e) {
+		// IE 8 has a broken gOPD
+		$gOPD = null;
+	}
+}
+
+var gopd$1 = $gOPD;
+
+var hasPropertyDescriptors = hasPropertyDescriptors_1();
+
+var GetIntrinsic$1 = getIntrinsic;
+
+var $defineProperty = hasPropertyDescriptors && GetIntrinsic$1('%Object.defineProperty%', true);
+if ($defineProperty) {
+	try {
+		$defineProperty({}, 'a', { value: 1 });
+	} catch (e) {
+		// IE 8 has a broken defineProperty
+		$defineProperty = false;
+	}
+}
+
+var $SyntaxError = GetIntrinsic$1('%SyntaxError%');
+var $TypeError$1 = GetIntrinsic$1('%TypeError%');
+
+var gopd = gopd$1;
+
+/** @type {(obj: Record<PropertyKey, unknown>, property: PropertyKey, value: unknown, nonEnumerable?: boolean | null, nonWritable?: boolean | null, nonConfigurable?: boolean | null, loose?: boolean) => void} */
+var defineDataProperty = function defineDataProperty(
+	obj,
+	property,
+	value
+) {
+	if (!obj || (typeof obj !== 'object' && typeof obj !== 'function')) {
+		throw new $TypeError$1('`obj` must be an object or a function`');
+	}
+	if (typeof property !== 'string' && typeof property !== 'symbol') {
+		throw new $TypeError$1('`property` must be a string or a symbol`');
+	}
+	if (arguments.length > 3 && typeof arguments[3] !== 'boolean' && arguments[3] !== null) {
+		throw new $TypeError$1('`nonEnumerable`, if provided, must be a boolean or null');
+	}
+	if (arguments.length > 4 && typeof arguments[4] !== 'boolean' && arguments[4] !== null) {
+		throw new $TypeError$1('`nonWritable`, if provided, must be a boolean or null');
+	}
+	if (arguments.length > 5 && typeof arguments[5] !== 'boolean' && arguments[5] !== null) {
+		throw new $TypeError$1('`nonConfigurable`, if provided, must be a boolean or null');
+	}
+	if (arguments.length > 6 && typeof arguments[6] !== 'boolean') {
+		throw new $TypeError$1('`loose`, if provided, must be a boolean');
+	}
+
+	var nonEnumerable = arguments.length > 3 ? arguments[3] : null;
+	var nonWritable = arguments.length > 4 ? arguments[4] : null;
+	var nonConfigurable = arguments.length > 5 ? arguments[5] : null;
+	var loose = arguments.length > 6 ? arguments[6] : false;
+
+	/* @type {false | TypedPropertyDescriptor<unknown>} */
+	var desc = !!gopd && gopd(obj, property);
+
+	if ($defineProperty) {
+		$defineProperty(obj, property, {
+			configurable: nonConfigurable === null && desc ? desc.configurable : !nonConfigurable,
+			enumerable: nonEnumerable === null && desc ? desc.enumerable : !nonEnumerable,
+			value: value,
+			writable: nonWritable === null && desc ? desc.writable : !nonWritable
+		});
+	} else if (loose || (!nonEnumerable && !nonWritable && !nonConfigurable)) {
+		// must fall back to [[Set]], and was not explicitly asked to make non-enumerable, non-writable, or non-configurable
+		obj[property] = value; // eslint-disable-line no-param-reassign
+	} else {
+		throw new $SyntaxError('This environment does not support defining a property as non-configurable, non-writable, or non-enumerable.');
+	}
+};
+
+var GetIntrinsic = getIntrinsic;
+var define = defineDataProperty;
+var hasDescriptors = hasPropertyDescriptors_1();
+var gOPD = gopd$1;
+
+var $TypeError = GetIntrinsic('%TypeError%');
+var $floor = GetIntrinsic('%Math.floor%');
+
+var setFunctionLength = function setFunctionLength(fn, length) {
+	if (typeof fn !== 'function') {
+		throw new $TypeError('`fn` is not a function');
+	}
+	if (typeof length !== 'number' || length < 0 || length > 0xFFFFFFFF || $floor(length) !== length) {
+		throw new $TypeError('`length` must be a positive 32-bit integer');
+	}
+
+	var loose = arguments.length > 2 && !!arguments[2];
+
+	var functionLengthIsConfigurable = true;
+	var functionLengthIsWritable = true;
+	if ('length' in fn && gOPD) {
+		var desc = gOPD(fn, 'length');
+		if (desc && !desc.configurable) {
+			functionLengthIsConfigurable = false;
+		}
+		if (desc && !desc.writable) {
+			functionLengthIsWritable = false;
+		}
+	}
+
+	if (functionLengthIsConfigurable || functionLengthIsWritable || !loose) {
+		if (hasDescriptors) {
+			define(fn, 'length', length, true, true);
+		} else {
+			define(fn, 'length', length);
+		}
+	}
+	return fn;
+};
+
+(function (module) {
+
+	var bind = functionBind$1;
+	var GetIntrinsic = getIntrinsic;
+	var setFunctionLength$1 = setFunctionLength;
+
+	var $TypeError = GetIntrinsic('%TypeError%');
+	var $apply = GetIntrinsic('%Function.prototype.apply%');
+	var $call = GetIntrinsic('%Function.prototype.call%');
+	var $reflectApply = GetIntrinsic('%Reflect.apply%', true) || bind.call($call, $apply);
+
+	var $defineProperty = GetIntrinsic('%Object.defineProperty%', true);
+	var $max = GetIntrinsic('%Math.max%');
+
+	if ($defineProperty) {
+		try {
+			$defineProperty({}, 'a', { value: 1 });
+		} catch (e) {
+			// IE 8 has a broken defineProperty
+			$defineProperty = null;
+		}
+	}
+
+	module.exports = function callBind(originalFunction) {
+		if (typeof originalFunction !== 'function') {
+			throw new $TypeError('a function is required');
+		}
+		var func = $reflectApply(bind, $call, arguments);
+		return setFunctionLength$1(
+			func,
+			1 + $max(0, originalFunction.length - (arguments.length - 1)),
+			true
+		);
+	};
+
+	var applyBind = function applyBind() {
+		return $reflectApply(bind, $apply, arguments);
+	};
+
+	if ($defineProperty) {
+		$defineProperty(module.exports, 'apply', { value: applyBind });
+	} else {
+		module.exports.apply = applyBind;
+	} 
+} (callBind$1));
+
+var callBindExports = callBind$1.exports;
+
+var jsonStringify = (typeof JSON !== 'undefined' ? JSON : JSON).stringify;
+
+var isArray$1 = isarray;
+var objectKeys = objectKeys$1;
+var callBind = callBindExports;
+
+var strRepeat = function repeat(n, char) {
+	var str = '';
+	for (var i = 0; i < n; i += 1) {
+		str += char;
+	}
+	return str;
+};
+
+var defaultReplacer = function (parent, key, value) { return value; };
+
+var jsonStableStringify = function stableStringify(obj) {
+	var opts = arguments.length > 1 ? arguments[1] : void undefined;
+	var space = (opts && opts.space) || '';
+	if (typeof space === 'number') { space = strRepeat(space, ' '); }
+	var cycles = !!opts && typeof opts.cycles === 'boolean' && opts.cycles;
+	var replacer = opts && opts.replacer ? callBind(opts.replacer) : defaultReplacer;
+
+	var cmpOpt = typeof opts === 'function' ? opts : opts && opts.cmp;
+	var cmp = cmpOpt && function (node) {
+		var get = cmpOpt.length > 2 && function get(k) { return node[k]; };
+		return function (a, b) {
+			return cmpOpt(
+				{ key: a, value: node[a] },
+				{ key: b, value: node[b] },
+				get ? { __proto__: null, get: get } : void undefined
+			);
 		};
-	}(opts.cmp));
+	};
 
 	var seen = [];
 	return (function stringify(parent, key, node, level) {
-		var indent = space ? '\n' + new Array(level + 1).join(space) : '';
+		var indent = space ? '\n' + strRepeat(level, space) : '';
 		var colonSeparator = space ? ': ' : ':';
 
 		if (node && node.toJSON && typeof node.toJSON === 'function') {
 			node = node.toJSON();
 		}
 
-		node = replacer.call(parent, key, node);
+		node = replacer(parent, key, node);
 
 		if (node === undefined) {
 			return;
 		}
 		if (typeof node !== 'object' || node === null) {
-			return json.stringify(node);
+			return jsonStringify(node);
 		}
 		if (isArray$1(node)) {
-			var out = [];
+			var out = '';
 			for (var i = 0; i < node.length; i++) {
-				var item = stringify(node, i, node[i], level + 1) || json.stringify(null);
-				out.push(indent + space + item);
+				var item = stringify(node, i, node[i], level + 1) || jsonStringify(null);
+				out += indent + space + item;
+				if ((i + 1) < node.length) {
+					out += ',';
+				}
 			}
-			return '[' + out.join(',') + indent + ']';
+			return '[' + out + indent + ']';
 		}
 
 		if (seen.indexOf(node) !== -1) {
-			if (cycles) { return json.stringify('__cycle__'); }
+			if (cycles) { return jsonStringify('__cycle__'); }
 			throw new TypeError('Converting circular structure to JSON');
 		} else { seen.push(node); }
 
 		var keys = objectKeys(node).sort(cmp && cmp(node));
-		var out = [];
+		var out = '';
+		var needsComma = false;
 		for (var i = 0; i < keys.length; i++) {
 			var key = keys[i];
 			var value = stringify(node, key, node[key], level + 1);
 
 			if (!value) { continue; }
 
-			var keyValue = json.stringify(key)
-					+ colonSeparator
-					+ value;
+			var keyValue = jsonStringify(key)
+				+ colonSeparator
+				+ value;
 
-			out.push(indent + space + keyValue);
+			out += (needsComma ? ',' : '') + indent + space + keyValue;
+			needsComma = true;
 		}
 		seen.splice(seen.indexOf(node), 1);
-		return '{' + out.join(',') + indent + '}';
+		return '{' + out + indent + '}';
 
 	}({ '': obj }, '', obj, 0));
 };
@@ -28037,49 +28990,18 @@ function resolvePackageEntry(id, { dir, data, setResolvedCache, getResolvedCache
         if (data.exports) {
             entryPoint = resolveExportsOrImports(data, '.', options, targetWeb, 'exports');
         }
-        // handle edge case with browser and module field semantics
-        if (!entryPoint && targetWeb && options.mainFields.includes('browser')) {
-            // check browser field
-            // https://github.com/defunctzombie/package-browser-field-spec
-            const browserEntry = typeof data.browser === 'string'
-                ? data.browser
-                : isObject$1(data.browser) && data.browser['.'];
-            if (browserEntry) {
-                // check if the package also has a "module" field.
-                if (!options.isRequire &&
-                    options.mainFields.includes('module') &&
-                    typeof data.module === 'string' &&
-                    data.module !== browserEntry) {
-                    // if both are present, we may have a problem: some package points both
-                    // to ESM, with "module" targeting Node.js, while some packages points
-                    // "module" to browser ESM and "browser" to UMD/IIFE.
-                    // the heuristics here is to actually read the browser entry when
-                    // possible and check for hints of ESM. If it is not ESM, prefer "module"
-                    // instead; Otherwise, assume it's ESM and use it.
-                    const resolvedBrowserEntry = tryFsResolve(path$o.join(dir, browserEntry), options);
-                    if (resolvedBrowserEntry) {
-                        const content = fs$l.readFileSync(resolvedBrowserEntry, 'utf-8');
-                        if (hasESMSyntax(content)) {
-                            // likely ESM, prefer browser
-                            entryPoint = browserEntry;
-                        }
-                        else {
-                            // non-ESM, UMD or IIFE or CJS(!!! e.g. firebase 7.x), prefer module
-                            entryPoint = data.module;
-                        }
-                    }
-                }
-                else {
-                    entryPoint = browserEntry;
-                }
-            }
-        }
         // fallback to mainFields if still not resolved
         if (!entryPoint) {
             for (const field of options.mainFields) {
-                if (field === 'browser')
-                    continue; // already checked above
-                if (typeof data[field] === 'string') {
+                if (field === 'browser') {
+                    if (targetWeb) {
+                        entryPoint = tryResolveBrowserEntry(dir, data, options);
+                        if (entryPoint) {
+                            break;
+                        }
+                    }
+                }
+                else if (typeof data[field] === 'string') {
                     entryPoint = data[field];
                     break;
                 }
@@ -28238,6 +29160,43 @@ function tryResolveBrowserMapping(id, importer, options, isFilePath, externalize
         }
     }
 }
+function tryResolveBrowserEntry(dir, data, options) {
+    // handle edge case with browser and module field semantics
+    // check browser field
+    // https://github.com/defunctzombie/package-browser-field-spec
+    const browserEntry = typeof data.browser === 'string'
+        ? data.browser
+        : isObject$1(data.browser) && data.browser['.'];
+    if (browserEntry) {
+        // check if the package also has a "module" field.
+        if (!options.isRequire &&
+            options.mainFields.includes('module') &&
+            typeof data.module === 'string' &&
+            data.module !== browserEntry) {
+            // if both are present, we may have a problem: some package points both
+            // to ESM, with "module" targeting Node.js, while some packages points
+            // "module" to browser ESM and "browser" to UMD/IIFE.
+            // the heuristics here is to actually read the browser entry when
+            // possible and check for hints of ESM. If it is not ESM, prefer "module"
+            // instead; Otherwise, assume it's ESM and use it.
+            const resolvedBrowserEntry = tryFsResolve(path$o.join(dir, browserEntry), options);
+            if (resolvedBrowserEntry) {
+                const content = fs$l.readFileSync(resolvedBrowserEntry, 'utf-8');
+                if (hasESMSyntax(content)) {
+                    // likely ESM, prefer browser
+                    return browserEntry;
+                }
+                else {
+                    // non-ESM, UMD or IIFE or CJS(!!! e.g. firebase 7.x), prefer module
+                    return data.module;
+                }
+            }
+        }
+        else {
+            return browserEntry;
+        }
+    }
+}
 /**
  * given a relative path in pkg dir,
  * return a relative path in pkg dir,
@@ -28281,22 +29240,17 @@ var dist = {};
 	        'package.json',
 	        `.${name}rc.json`,
 	        `.${name}rc.js`,
-	        `${name}.config.js`,
 	        `.${name}rc.cjs`,
+	        `.config/${name}rc`,
+	        `.config/${name}rc.json`,
+	        `.config/${name}rc.js`,
+	        `.config/${name}rc.cjs`,
+	        `${name}.config.js`,
 	        `${name}.config.cjs`,
 	    ];
 	}
-	function getSearchPaths(startDir, stopDir) {
-	    return startDir
-	        .split(path.sep)
-	        .reduceRight((acc, _, ind, arr) => {
-	        const currentPath = arr.slice(0, ind + 1).join(path.sep);
-	        if (!acc.passedStopDir)
-	            acc.searchPlaces.push(currentPath || path.sep);
-	        if (currentPath === stopDir)
-	            acc.passedStopDir = true;
-	        return acc;
-	    }, { searchPlaces: [], passedStopDir: false }).searchPlaces;
+	function parentDir(p) {
+	    return path.dirname(p) || path.sep;
 	}
 	exports.defaultLoaders = Object.freeze({
 	    '.js': __require,
@@ -28314,6 +29268,7 @@ var dist = {};
 	        stopDir: os.homedir(),
 	        searchPlaces: getDefaultSearchPlaces(name),
 	        ignoreEmptySearchPlaces: true,
+	        cache: true,
 	        transform: (x) => x,
 	        packageProp: [name],
 	        ...options,
@@ -28336,16 +29291,6 @@ var dist = {};
 	        return obj[props];
 	    return ((Array.isArray(props) ? props : props.split('.')).reduce((acc, prop) => (acc === undefined ? acc : acc[prop]), obj) || null);
 	}
-	function getSearchItems(searchPlaces, searchPaths) {
-	    return searchPaths.reduce((acc, searchPath) => {
-	        searchPlaces.forEach(fileName => acc.push({
-	            fileName,
-	            filepath: path.join(searchPath, fileName),
-	            loaderKey: path.extname(fileName) || 'noExt',
-	        }));
-	        return acc;
-	    }, []);
-	}
 	function validateFilePath(filepath) {
 	    if (!filepath)
 	        throw new Error('load must pass a non-empty string');
@@ -28356,56 +29301,88 @@ var dist = {};
 	    if (typeof loader !== 'function')
 	        throw new Error('loader is not a function');
 	}
+	const makeEmplace = (enableCache) => (c, filepath, res) => {
+	    if (enableCache)
+	        c.set(filepath, res);
+	    return res;
+	};
 	function lilconfig(name, options) {
-	    const { ignoreEmptySearchPlaces, loaders, packageProp, searchPlaces, stopDir, transform, } = getOptions(name, options);
+	    const { ignoreEmptySearchPlaces, loaders, packageProp, searchPlaces, stopDir, transform, cache, } = getOptions(name, options);
+	    const searchCache = new Map();
+	    const loadCache = new Map();
+	    const emplace = makeEmplace(cache);
 	    return {
 	        async search(searchFrom = process.cwd()) {
-	            const searchPaths = getSearchPaths(searchFrom, stopDir);
 	            const result = {
 	                config: null,
 	                filepath: '',
 	            };
-	            const searchItems = getSearchItems(searchPlaces, searchPaths);
-	            for (const { fileName, filepath, loaderKey } of searchItems) {
-	                try {
-	                    await fs.promises.access(filepath);
-	                }
-	                catch (_a) {
-	                    continue;
-	                }
-	                const content = String(await fsReadFileAsync(filepath));
-	                const loader = loaders[loaderKey];
-	                if (fileName === 'package.json') {
-	                    const pkg = await loader(filepath, content);
-	                    const maybeConfig = getPackageProp(packageProp, pkg);
-	                    if (maybeConfig != null) {
-	                        result.config = maybeConfig;
-	                        result.filepath = filepath;
-	                        break;
+	            const visited = new Set();
+	            let dir = searchFrom;
+	            dirLoop: while (true) {
+	                if (cache) {
+	                    const r = searchCache.get(dir);
+	                    if (r !== undefined) {
+	                        for (const p of visited)
+	                            searchCache.set(p, r);
+	                        return r;
 	                    }
-	                    continue;
-	                }
-	                const isEmpty = content.trim() === '';
-	                if (isEmpty && ignoreEmptySearchPlaces)
-	                    continue;
-	                if (isEmpty) {
-	                    result.isEmpty = true;
-	                    result.config = undefined;
+	                    visited.add(dir);
 	                }
-	                else {
-	                    validateLoader(loader, loaderKey);
-	                    result.config = await loader(filepath, content);
+	                for (const searchPlace of searchPlaces) {
+	                    const filepath = path.join(dir, searchPlace);
+	                    try {
+	                        await fs.promises.access(filepath);
+	                    }
+	                    catch (_a) {
+	                        continue;
+	                    }
+	                    const content = String(await fsReadFileAsync(filepath));
+	                    const loaderKey = path.extname(searchPlace) || 'noExt';
+	                    const loader = loaders[loaderKey];
+	                    if (searchPlace === 'package.json') {
+	                        const pkg = await loader(filepath, content);
+	                        const maybeConfig = getPackageProp(packageProp, pkg);
+	                        if (maybeConfig != null) {
+	                            result.config = maybeConfig;
+	                            result.filepath = filepath;
+	                            break dirLoop;
+	                        }
+	                        continue;
+	                    }
+	                    const isEmpty = content.trim() === '';
+	                    if (isEmpty && ignoreEmptySearchPlaces)
+	                        continue;
+	                    if (isEmpty) {
+	                        result.isEmpty = true;
+	                        result.config = undefined;
+	                    }
+	                    else {
+	                        validateLoader(loader, loaderKey);
+	                        result.config = await loader(filepath, content);
+	                    }
+	                    result.filepath = filepath;
+	                    break dirLoop;
 	                }
-	                result.filepath = filepath;
-	                break;
+	                if (dir === stopDir || dir === parentDir(dir))
+	                    break dirLoop;
+	                dir = parentDir(dir);
 	            }
-	            if (result.filepath === '' && result.config === null)
-	                return transform(null);
-	            return transform(result);
+	            const transformed = result.filepath === '' && result.config === null
+	                ? transform(null)
+	                : transform(result);
+	            if (cache) {
+	                for (const p of visited)
+	                    searchCache.set(p, transformed);
+	            }
+	            return transformed;
 	        },
 	        async load(filepath) {
 	            validateFilePath(filepath);
 	            const absPath = path.resolve(process.cwd(), filepath);
+	            if (cache && loadCache.has(absPath)) {
+	                return loadCache.get(absPath);
+	            }
 	            const { base, ext } = path.parse(absPath);
 	            const loaderKey = ext || 'noExt';
 	            const loader = loaders[loaderKey];
@@ -28413,10 +29390,10 @@ var dist = {};
 	            const content = String(await fsReadFileAsync(absPath));
 	            if (base === 'package.json') {
 	                const pkg = await loader(absPath, content);
-	                return transform({
+	                return emplace(loadCache, absPath, transform({
 	                    config: getPackageProp(packageProp, pkg),
 	                    filepath: absPath,
-	                });
+	                }));
 	            }
 	            const result = {
 	                config: null,
@@ -28424,69 +29401,110 @@ var dist = {};
 	            };
 	            const isEmpty = content.trim() === '';
 	            if (isEmpty && ignoreEmptySearchPlaces)
-	                return transform({
+	                return emplace(loadCache, absPath, transform({
 	                    config: undefined,
 	                    filepath: absPath,
 	                    isEmpty: true,
-	                });
+	                }));
 	            result.config = isEmpty
 	                ? undefined
 	                : await loader(absPath, content);
-	            return transform(isEmpty ? { ...result, isEmpty, config: undefined } : result);
+	            return emplace(loadCache, absPath, transform(isEmpty ? { ...result, isEmpty, config: undefined } : result));
+	        },
+	        clearLoadCache() {
+	            if (cache)
+	                loadCache.clear();
+	        },
+	        clearSearchCache() {
+	            if (cache)
+	                searchCache.clear();
+	        },
+	        clearCaches() {
+	            if (cache) {
+	                loadCache.clear();
+	                searchCache.clear();
+	            }
 	        },
 	    };
 	}
 	exports.lilconfig = lilconfig;
 	function lilconfigSync(name, options) {
-	    const { ignoreEmptySearchPlaces, loaders, packageProp, searchPlaces, stopDir, transform, } = getOptions(name, options);
+	    const { ignoreEmptySearchPlaces, loaders, packageProp, searchPlaces, stopDir, transform, cache, } = getOptions(name, options);
+	    const searchCache = new Map();
+	    const loadCache = new Map();
+	    const emplace = makeEmplace(cache);
 	    return {
 	        search(searchFrom = process.cwd()) {
-	            const searchPaths = getSearchPaths(searchFrom, stopDir);
 	            const result = {
 	                config: null,
 	                filepath: '',
 	            };
-	            const searchItems = getSearchItems(searchPlaces, searchPaths);
-	            for (const { fileName, filepath, loaderKey } of searchItems) {
-	                try {
-	                    fs.accessSync(filepath);
-	                }
-	                catch (_a) {
-	                    continue;
-	                }
-	                const loader = loaders[loaderKey];
-	                const content = String(fs.readFileSync(filepath));
-	                if (fileName === 'package.json') {
-	                    const pkg = loader(filepath, content);
-	                    const maybeConfig = getPackageProp(packageProp, pkg);
-	                    if (maybeConfig != null) {
-	                        result.config = maybeConfig;
-	                        result.filepath = filepath;
-	                        break;
+	            const visited = new Set();
+	            let dir = searchFrom;
+	            dirLoop: while (true) {
+	                if (cache) {
+	                    const r = searchCache.get(dir);
+	                    if (r !== undefined) {
+	                        for (const p of visited)
+	                            searchCache.set(p, r);
+	                        return r;
 	                    }
-	                    continue;
-	                }
-	                const isEmpty = content.trim() === '';
-	                if (isEmpty && ignoreEmptySearchPlaces)
-	                    continue;
-	                if (isEmpty) {
-	                    result.isEmpty = true;
-	                    result.config = undefined;
+	                    visited.add(dir);
 	                }
-	                else {
-	                    validateLoader(loader, loaderKey);
-	                    result.config = loader(filepath, content);
+	                for (const searchPlace of searchPlaces) {
+	                    const filepath = path.join(dir, searchPlace);
+	                    try {
+	                        fs.accessSync(filepath);
+	                    }
+	                    catch (_a) {
+	                        continue;
+	                    }
+	                    const loaderKey = path.extname(searchPlace) || 'noExt';
+	                    const loader = loaders[loaderKey];
+	                    const content = String(fs.readFileSync(filepath));
+	                    if (searchPlace === 'package.json') {
+	                        const pkg = loader(filepath, content);
+	                        const maybeConfig = getPackageProp(packageProp, pkg);
+	                        if (maybeConfig != null) {
+	                            result.config = maybeConfig;
+	                            result.filepath = filepath;
+	                            break dirLoop;
+	                        }
+	                        continue;
+	                    }
+	                    const isEmpty = content.trim() === '';
+	                    if (isEmpty && ignoreEmptySearchPlaces)
+	                        continue;
+	                    if (isEmpty) {
+	                        result.isEmpty = true;
+	                        result.config = undefined;
+	                    }
+	                    else {
+	                        validateLoader(loader, loaderKey);
+	                        result.config = loader(filepath, content);
+	                    }
+	                    result.filepath = filepath;
+	                    break dirLoop;
 	                }
-	                result.filepath = filepath;
-	                break;
+	                if (dir === stopDir || dir === parentDir(dir))
+	                    break dirLoop;
+	                dir = parentDir(dir);
+	            }
+	            const transformed = result.filepath === '' && result.config === null
+	                ? transform(null)
+	                : transform(result);
+	            if (cache) {
+	                for (const p of visited)
+	                    searchCache.set(p, transformed);
 	            }
-	            if (result.filepath === '' && result.config === null)
-	                return transform(null);
-	            return transform(result);
+	            return transformed;
 	        },
 	        load(filepath) {
 	            validateFilePath(filepath);
 	            const absPath = path.resolve(process.cwd(), filepath);
+	            if (cache && loadCache.has(absPath)) {
+	                return loadCache.get(absPath);
+	            }
 	            const { base, ext } = path.parse(absPath);
 	            const loaderKey = ext || 'noExt';
 	            const loader = loaders[loaderKey];
@@ -28505,13 +29523,27 @@ var dist = {};
 	            };
 	            const isEmpty = content.trim() === '';
 	            if (isEmpty && ignoreEmptySearchPlaces)
-	                return transform({
+	                return emplace(loadCache, absPath, transform({
 	                    filepath: absPath,
 	                    config: undefined,
 	                    isEmpty: true,
-	                });
+	                }));
 	            result.config = isEmpty ? undefined : loader(absPath, content);
-	            return transform(isEmpty ? { ...result, isEmpty, config: undefined } : result);
+	            return emplace(loadCache, absPath, transform(isEmpty ? { ...result, isEmpty, config: undefined } : result));
+	        },
+	        clearLoadCache() {
+	            if (cache)
+	                loadCache.clear();
+	        },
+	        clearSearchCache() {
+	            if (cache)
+	                searchCache.clear();
+	        },
+	        clearCaches() {
+	            if (cache) {
+	                loadCache.clear();
+	                searchCache.clear();
+	            }
 	        },
 	    };
 	}
@@ -28552,18 +29584,6 @@ function isNode$1(node) {
     return false;
 }
 const hasAnchor = (node) => (isScalar$1(node) || isCollection$1(node)) && !!node.anchor;
-class NodeBase {
-    constructor(type) {
-        Object.defineProperty(this, NODE_TYPE, { value: type });
-    }
-    /** Create a copy of this node.  */
-    clone() {
-        const copy = Object.create(Object.getPrototypeOf(this), Object.getOwnPropertyDescriptors(this));
-        if (this.range)
-            copy.range = this.range.slice();
-        return copy;
-    }
-}
 
 const BREAK$1 = Symbol('break visit');
 const SKIP$1 = Symbol('skip children');
@@ -28910,12 +29930,19 @@ class Directives {
                 onError('Verbatim tags must end with a >');
             return verbatim;
         }
-        const [, handle, suffix] = source.match(/^(.*!)([^!]*)$/);
+        const [, handle, suffix] = source.match(/^(.*!)([^!]*)$/s);
         if (!suffix)
             onError(`The ${source} tag has no suffix`);
         const prefix = this.tags[handle];
-        if (prefix)
-            return prefix + decodeURIComponent(suffix);
+        if (prefix) {
+            try {
+                return prefix + decodeURIComponent(suffix);
+            }
+            catch (error) {
+                onError(String(error));
+                return null;
+            }
+        }
         if (handle === '!')
             return source; // local tag
         onError(`Could not resolve tag: ${source}`);
@@ -29028,6 +30055,126 @@ function createNodeAnchors(doc, prefix) {
     };
 }
 
+/**
+ * Applies the JSON.parse reviver algorithm as defined in the ECMA-262 spec,
+ * in section 24.5.1.1 "Runtime Semantics: InternalizeJSONProperty" of the
+ * 2021 edition: https://tc39.es/ecma262/#sec-json.parse
+ *
+ * Includes extensions for handling Map and Set objects.
+ */
+function applyReviver(reviver, obj, key, val) {
+    if (val && typeof val === 'object') {
+        if (Array.isArray(val)) {
+            for (let i = 0, len = val.length; i < len; ++i) {
+                const v0 = val[i];
+                const v1 = applyReviver(reviver, val, String(i), v0);
+                if (v1 === undefined)
+                    delete val[i];
+                else if (v1 !== v0)
+                    val[i] = v1;
+            }
+        }
+        else if (val instanceof Map) {
+            for (const k of Array.from(val.keys())) {
+                const v0 = val.get(k);
+                const v1 = applyReviver(reviver, val, k, v0);
+                if (v1 === undefined)
+                    val.delete(k);
+                else if (v1 !== v0)
+                    val.set(k, v1);
+            }
+        }
+        else if (val instanceof Set) {
+            for (const v0 of Array.from(val)) {
+                const v1 = applyReviver(reviver, val, v0, v0);
+                if (v1 === undefined)
+                    val.delete(v0);
+                else if (v1 !== v0) {
+                    val.delete(v0);
+                    val.add(v1);
+                }
+            }
+        }
+        else {
+            for (const [k, v0] of Object.entries(val)) {
+                const v1 = applyReviver(reviver, val, k, v0);
+                if (v1 === undefined)
+                    delete val[k];
+                else if (v1 !== v0)
+                    val[k] = v1;
+            }
+        }
+    }
+    return reviver.call(obj, key, val);
+}
+
+/**
+ * Recursively convert any node or its contents to native JavaScript
+ *
+ * @param value - The input value
+ * @param arg - If `value` defines a `toJSON()` method, use this
+ *   as its first argument
+ * @param ctx - Conversion context, originally set in Document#toJS(). If
+ *   `{ keep: true }` is not set, output should be suitable for JSON
+ *   stringification.
+ */
+function toJS(value, arg, ctx) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    if (Array.isArray(value))
+        return value.map((v, i) => toJS(v, String(i), ctx));
+    if (value && typeof value.toJSON === 'function') {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+        if (!ctx || !hasAnchor(value))
+            return value.toJSON(arg, ctx);
+        const data = { aliasCount: 0, count: 1, res: undefined };
+        ctx.anchors.set(value, data);
+        ctx.onCreate = res => {
+            data.res = res;
+            delete ctx.onCreate;
+        };
+        const res = value.toJSON(arg, ctx);
+        if (ctx.onCreate)
+            ctx.onCreate(res);
+        return res;
+    }
+    if (typeof value === 'bigint' && !ctx?.keep)
+        return Number(value);
+    return value;
+}
+
+class NodeBase {
+    constructor(type) {
+        Object.defineProperty(this, NODE_TYPE, { value: type });
+    }
+    /** Create a copy of this node.  */
+    clone() {
+        const copy = Object.create(Object.getPrototypeOf(this), Object.getOwnPropertyDescriptors(this));
+        if (this.range)
+            copy.range = this.range.slice();
+        return copy;
+    }
+    /** A plain JavaScript representation of this node. */
+    toJS(doc, { mapAsMap, maxAliasCount, onAnchor, reviver } = {}) {
+        if (!isDocument(doc))
+            throw new TypeError('A document argument is required');
+        const ctx = {
+            anchors: new Map(),
+            doc,
+            keep: true,
+            mapAsMap: mapAsMap === true,
+            mapKeyWarned: false,
+            maxAliasCount: typeof maxAliasCount === 'number' ? maxAliasCount : 100
+        };
+        const res = toJS(this, '', ctx);
+        if (typeof onAnchor === 'function')
+            for (const { count, res } of ctx.anchors.values())
+                onAnchor(res, count);
+        return typeof reviver === 'function'
+            ? applyReviver(reviver, { '': res }, '', res)
+            : res;
+    }
+}
+
 class Alias extends NodeBase {
     constructor(source) {
         super(ALIAS);
@@ -29063,7 +30210,12 @@ class Alias extends NodeBase {
             const msg = `Unresolved alias (the anchor must be set before the alias): ${this.source}`;
             throw new ReferenceError(msg);
         }
-        const data = anchors.get(source);
+        let data = anchors.get(source);
+        if (!data) {
+            // Resolve anchors for Node.prototype.toJS()
+            toJS(source, null, ctx);
+            data = anchors.get(source);
+        }
         /* istanbul ignore if */
         if (!data || data.res === undefined) {
             const msg = 'This should not happen: Alias anchor was not resolved?';
@@ -29117,40 +30269,6 @@ function getAliasCount(doc, node, anchors) {
     return 1;
 }
 
-/**
- * Recursively convert any node or its contents to native JavaScript
- *
- * @param value - The input value
- * @param arg - If `value` defines a `toJSON()` method, use this
- *   as its first argument
- * @param ctx - Conversion context, originally set in Document#toJS(). If
- *   `{ keep: true }` is not set, output should be suitable for JSON
- *   stringification.
- */
-function toJS(value, arg, ctx) {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-    if (Array.isArray(value))
-        return value.map((v, i) => toJS(v, String(i), ctx));
-    if (value && typeof value.toJSON === 'function') {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-call
-        if (!ctx || !hasAnchor(value))
-            return value.toJSON(arg, ctx);
-        const data = { aliasCount: 0, count: 1, res: undefined };
-        ctx.anchors.set(value, data);
-        ctx.onCreate = res => {
-            data.res = res;
-            delete ctx.onCreate;
-        };
-        const res = value.toJSON(arg, ctx);
-        if (ctx.onCreate)
-            ctx.onCreate(res);
-        return res;
-    }
-    if (typeof value === 'bigint' && !ctx?.keep)
-        return Number(value);
-    return value;
-}
-
 const isScalarValue = (value) => !value || (typeof value !== 'function' && typeof value !== 'object');
 class Scalar extends NodeBase {
     constructor(value) {
@@ -29194,7 +30312,7 @@ function createNode(value, tagName, ctx) {
     if (value instanceof String ||
         value instanceof Number ||
         value instanceof Boolean ||
-        (typeof BigInt === 'function' && value instanceof BigInt) // not supported everywhere
+        (typeof BigInt !== 'undefined' && value instanceof BigInt) // not supported everywhere
     ) {
         // https://tc39.es/ecma262/#sec-serializejsonproperty
         value = value.valueOf();
@@ -29242,9 +30360,13 @@ function createNode(value, tagName, ctx) {
     }
     const node = tagObj?.createNode
         ? tagObj.createNode(ctx.schema, value, ctx)
-        : new Scalar(value);
+        : typeof tagObj?.nodeClass?.from === 'function'
+            ? tagObj.nodeClass.from(ctx.schema, value, ctx)
+            : new Scalar(value);
     if (tagName)
         node.tag = tagName;
+    else if (!tagObj.default)
+        node.tag = tagObj.tag;
     if (ref)
         ref.node = node;
     return node;
@@ -29546,8 +30668,8 @@ function consumeMoreIndentedLines(text, i) {
     return i;
 }
 
-const getFoldOptions = (ctx) => ({
-    indentAtStart: ctx.indentAtStart,
+const getFoldOptions = (ctx, isBlock) => ({
+    indentAtStart: isBlock ? ctx.indent.length : ctx.indentAtStart,
     lineWidth: ctx.options.lineWidth,
     minContentWidth: ctx.options.minContentWidth
 });
@@ -29660,7 +30782,7 @@ function doubleQuotedString(value, ctx) {
     str = start ? str + json.slice(start) : json;
     return implicitKey
         ? str
-        : foldFlowLines(str, indent, FOLD_QUOTED, getFoldOptions(ctx));
+        : foldFlowLines(str, indent, FOLD_QUOTED, getFoldOptions(ctx, false));
 }
 function singleQuotedString(value, ctx) {
     if (ctx.options.singleQuote === false ||
@@ -29672,7 +30794,7 @@ function singleQuotedString(value, ctx) {
     const res = "'" + value.replace(/'/g, "''").replace(/\n+/g, `$&\n${indent}`) + "'";
     return ctx.implicitKey
         ? res
-        : foldFlowLines(res, indent, FOLD_FLOW, getFoldOptions(ctx));
+        : foldFlowLines(res, indent, FOLD_FLOW, getFoldOptions(ctx, false));
 }
 function quotedString(value, ctx) {
     const { singleQuote } = ctx.options;
@@ -29691,6 +30813,15 @@ function quotedString(value, ctx) {
     }
     return qs(value, ctx);
 }
+// The negative lookbehind avoids a polynomial search,
+// but isn't supported yet on Safari: https://caniuse.com/js-regexp-lookbehind
+let blockEndNewlines;
+try {
+    blockEndNewlines = new RegExp('(^|(?<!\n))\n+(?!\n|$)', 'g');
+}
+catch {
+    blockEndNewlines = /\n+(?!\n|$)/g;
+}
 function blockString({ comment, type, value }, ctx, onComment, onChompKeep) {
     const { blockQuote, commentString, lineWidth } = ctx.options;
     // 1. Block can't end in whitespace unless the last line is non-empty.
@@ -29734,7 +30865,7 @@ function blockString({ comment, type, value }, ctx, onComment, onChompKeep) {
         value = value.slice(0, -end.length);
         if (end[end.length - 1] === '\n')
             end = end.slice(0, -1);
-        end = end.replace(/\n+(?!\n|$)/g, `$&${indent}`);
+        end = end.replace(blockEndNewlines, `$&${indent}`);
     }
     // determine indent indicator from whitespace at value start
     let startWithSpace = false;
@@ -29770,13 +30901,13 @@ function blockString({ comment, type, value }, ctx, onComment, onChompKeep) {
         .replace(/(?:^|\n)([\t ].*)(?:([\n\t ]*)\n(?![\n\t ]))?/g, '$1$2') // more-indented lines aren't folded
         //                ^ more-ind. ^ empty     ^ capture next empty lines only at end of indent
         .replace(/\n+/g, `$&${indent}`);
-    const body = foldFlowLines(`${start}${value}${end}`, indent, FOLD_BLOCK, getFoldOptions(ctx));
+    const body = foldFlowLines(`${start}${value}${end}`, indent, FOLD_BLOCK, getFoldOptions(ctx, true));
     return `${header}\n${indent}${body}`;
 }
 function plainString(item, ctx, onComment, onChompKeep) {
     const { type, value } = item;
-    const { actualString, implicitKey, indent, inFlow } = ctx;
-    if ((implicitKey && /[\n[\]{},]/.test(value)) ||
+    const { actualString, implicitKey, indent, indentStep, inFlow } = ctx;
+    if ((implicitKey && value.includes('\n')) ||
         (inFlow && /[[\]{},]/.test(value))) {
         return quotedString(value, ctx);
     }
@@ -29799,9 +30930,14 @@ function plainString(item, ctx, onComment, onChompKeep) {
         // Where allowed & type not set explicitly, prefer block style for multiline strings
         return blockString(item, ctx, onComment, onChompKeep);
     }
-    if (indent === '' && containsDocumentMarker(value)) {
-        ctx.forceBlockIndent = true;
-        return blockString(item, ctx, onComment, onChompKeep);
+    if (containsDocumentMarker(value)) {
+        if (indent === '') {
+            ctx.forceBlockIndent = true;
+            return blockString(item, ctx, onComment, onChompKeep);
+        }
+        else if (implicitKey && indent === indentStep) {
+            return quotedString(value, ctx);
+        }
     }
     const str = value.replace(/\n+/g, `$&\n${indent}`);
     // Verify that output will be parsed as a string, as e.g. plain numbers and
@@ -29815,7 +30951,7 @@ function plainString(item, ctx, onComment, onChompKeep) {
     }
     return implicitKey
         ? str
-        : foldFlowLines(str, indent, FOLD_FLOW, getFoldOptions(ctx));
+        : foldFlowLines(str, indent, FOLD_FLOW, getFoldOptions(ctx, false));
 }
 function stringifyString(item, ctx, onComment, onChompKeep) {
     const { implicitKey, inFlow } = ctx;
@@ -29866,6 +31002,7 @@ function createStringifyContext(doc, options) {
         doubleQuotedAsJSON: false,
         doubleQuotedMinMultiLineLength: 40,
         falseStr: 'false',
+        flowCollectionPadding: true,
         indentSeq: true,
         lineWidth: 80,
         minContentWidth: 20,
@@ -29889,6 +31026,7 @@ function createStringifyContext(doc, options) {
     return {
         anchors: new Set(),
         doc,
+        flowCollectionPadding: opt.flowCollectionPadding ? ' ' : '',
         indent: '',
         indentStep: typeof opt.indent === 'number' ? ' '.repeat(opt.indent) : '  ',
         inFlow,
@@ -30032,19 +31170,18 @@ function stringifyPair({ key, value }, ctx, onComment, onChompKeep) {
         if (keyComment)
             str += lineComment(str, ctx.indent, commentString(keyComment));
     }
-    let vcb = '';
-    let valueComment = null;
+    let vsb, vcb, valueComment;
     if (isNode$1(value)) {
-        if (value.spaceBefore)
-            vcb = '\n';
-        if (value.commentBefore) {
-            const cs = commentString(value.commentBefore);
-            vcb += `\n${indentComment(cs, ctx.indent)}`;
-        }
+        vsb = !!value.spaceBefore;
+        vcb = value.commentBefore;
         valueComment = value.comment;
     }
-    else if (value && typeof value === 'object') {
-        value = doc.createNode(value);
+    else {
+        vsb = false;
+        vcb = null;
+        valueComment = null;
+        if (value && typeof value === 'object')
+            value = doc.createNode(value);
     }
     ctx.implicitKey = false;
     if (!explicitKey && !keyComment && isScalar$1(value))
@@ -30059,24 +31196,50 @@ function stringifyPair({ key, value }, ctx, onComment, onChompKeep) {
         !value.tag &&
         !value.anchor) {
         // If indentSeq === false, consider '- ' as part of indentation where possible
-        ctx.indent = ctx.indent.substr(2);
+        ctx.indent = ctx.indent.substring(2);
     }
     let valueCommentDone = false;
     const valueStr = stringify$2(value, ctx, () => (valueCommentDone = true), () => (chompKeep = true));
     let ws = ' ';
-    if (vcb || keyComment) {
-        if (valueStr === '' && !ctx.inFlow)
-            ws = vcb === '\n' ? '\n\n' : vcb;
-        else
-            ws = `${vcb}\n${ctx.indent}`;
+    if (keyComment || vsb || vcb) {
+        ws = vsb ? '\n' : '';
+        if (vcb) {
+            const cs = commentString(vcb);
+            ws += `\n${indentComment(cs, ctx.indent)}`;
+        }
+        if (valueStr === '' && !ctx.inFlow) {
+            if (ws === '\n')
+                ws = '\n\n';
+        }
+        else {
+            ws += `\n${ctx.indent}`;
+        }
     }
     else if (!explicitKey && isCollection$1(value)) {
-        const flow = valueStr[0] === '[' || valueStr[0] === '{';
-        if (!flow || valueStr.includes('\n'))
-            ws = `\n${ctx.indent}`;
+        const vs0 = valueStr[0];
+        const nl0 = valueStr.indexOf('\n');
+        const hasNewline = nl0 !== -1;
+        const flow = ctx.inFlow ?? value.flow ?? value.items.length === 0;
+        if (hasNewline || !flow) {
+            let hasPropsLine = false;
+            if (hasNewline && (vs0 === '&' || vs0 === '!')) {
+                let sp0 = valueStr.indexOf(' ');
+                if (vs0 === '&' &&
+                    sp0 !== -1 &&
+                    sp0 < nl0 &&
+                    valueStr[sp0 + 1] === '!') {
+                    sp0 = valueStr.indexOf(' ', sp0 + 1);
+                }
+                if (sp0 === -1 || nl0 < sp0)
+                    hasPropsLine = true;
+            }
+            if (!hasPropsLine)
+                ws = `\n${ctx.indent}`;
+        }
     }
-    else if (valueStr === '' || valueStr[0] === '\n')
+    else if (valueStr === '' || valueStr[0] === '\n') {
         ws = '';
+    }
     str += ws + valueStr;
     if (ctx.inFlow) {
         if (valueCommentDone && onComment)
@@ -30093,6 +31256,8 @@ function stringifyPair({ key, value }, ctx, onComment, onChompKeep) {
 
 function warn(logLevel, warning) {
     if (logLevel === 'debug' || logLevel === 'warn') {
+        // https://github.com/typescript-eslint/typescript-eslint/issues/7478
+        // eslint-disable-next-line @typescript-eslint/prefer-optional-chain
         if (typeof process !== 'undefined' && process.emitWarning)
             process.emitWarning(warning);
         else
@@ -30177,7 +31342,7 @@ function stringifyKey(key, jsKey, ctx) {
         return '';
     if (typeof jsKey !== 'object')
         return String(jsKey);
-    if (isNode$1(key) && ctx && ctx.doc) {
+    if (isNode$1(key) && ctx?.doc) {
         const strCtx = createStringifyContext(ctx.doc, {});
         strCtx.anchors = new Set();
         for (const node of ctx.anchors.keys())
@@ -30284,7 +31449,7 @@ function stringifyBlockCollection({ comment, items }, ctx, { blockItemPrefix, fl
     return str;
 }
 function stringifyFlowCollection({ comment, items }, ctx, { flowChars, itemIndent, onComment }) {
-    const { indent, indentStep, options: { commentString } } = ctx;
+    const { indent, indentStep, flowCollectionPadding: fcPadding, options: { commentString } } = ctx;
     itemIndent += indentStep;
     const itemCtx = Object.assign({}, ctx, {
         indent: itemIndent,
@@ -30320,7 +31485,7 @@ function stringifyFlowCollection({ comment, items }, ctx, { flowChars, itemInden
                 if (iv.commentBefore)
                     reqNewline = true;
             }
-            else if (item.value == null && ik && ik.comment) {
+            else if (item.value == null && ik?.comment) {
                 comment = ik.comment;
             }
         }
@@ -30353,11 +31518,11 @@ function stringifyFlowCollection({ comment, items }, ctx, { flowChars, itemInden
             str += `\n${indent}${end}`;
         }
         else {
-            str = `${start} ${lines.join(' ')} ${end}`;
+            str = `${start}${fcPadding}${lines.join(' ')}${fcPadding}${end}`;
         }
     }
     if (comment) {
-        str += lineComment(str, commentString(comment), indent);
+        str += lineComment(str, indent, commentString(comment));
         if (onComment)
             onComment();
     }
@@ -30385,12 +31550,40 @@ function findPair(items, key) {
     return undefined;
 }
 class YAMLMap extends Collection {
+    static get tagName() {
+        return 'tag:yaml.org,2002:map';
+    }
     constructor(schema) {
         super(MAP, schema);
         this.items = [];
     }
-    static get tagName() {
-        return 'tag:yaml.org,2002:map';
+    /**
+     * A generic collection parsing method that can be extended
+     * to other node classes that inherit from YAMLMap
+     */
+    static from(schema, obj, ctx) {
+        const { keepUndefined, replacer } = ctx;
+        const map = new this(schema);
+        const add = (key, value) => {
+            if (typeof replacer === 'function')
+                value = replacer.call(obj, key, value);
+            else if (Array.isArray(replacer) && !replacer.includes(key))
+                return;
+            if (value !== undefined || keepUndefined)
+                map.items.push(createPair(key, value, ctx));
+        };
+        if (obj instanceof Map) {
+            for (const [key, value] of obj)
+                add(key, value);
+        }
+        else if (obj && typeof obj === 'object') {
+            for (const key of Object.keys(obj))
+                add(key, obj[key]);
+        }
+        if (typeof schema.sortMapEntries === 'function') {
+            map.items.sort(schema.sortMapEntries);
+        }
+        return map;
     }
     /**
      * Adds a value to the collection.
@@ -30480,33 +31673,8 @@ class YAMLMap extends Collection {
     }
 }
 
-function createMap(schema, obj, ctx) {
-    const { keepUndefined, replacer } = ctx;
-    const map = new YAMLMap(schema);
-    const add = (key, value) => {
-        if (typeof replacer === 'function')
-            value = replacer.call(obj, key, value);
-        else if (Array.isArray(replacer) && !replacer.includes(key))
-            return;
-        if (value !== undefined || keepUndefined)
-            map.items.push(createPair(key, value, ctx));
-    };
-    if (obj instanceof Map) {
-        for (const [key, value] of obj)
-            add(key, value);
-    }
-    else if (obj && typeof obj === 'object') {
-        for (const key of Object.keys(obj))
-            add(key, obj[key]);
-    }
-    if (typeof schema.sortMapEntries === 'function') {
-        map.items.sort(schema.sortMapEntries);
-    }
-    return map;
-}
 const map$1 = {
     collection: 'map',
-    createNode: createMap,
     default: true,
     nodeClass: YAMLMap,
     tag: 'tag:yaml.org,2002:map',
@@ -30514,17 +31682,18 @@ const map$1 = {
         if (!isMap(map))
             onError('Expected a mapping for this tag');
         return map;
-    }
+    },
+    createNode: (schema, obj, ctx) => YAMLMap.from(schema, obj, ctx)
 };
 
 class YAMLSeq extends Collection {
+    static get tagName() {
+        return 'tag:yaml.org,2002:seq';
+    }
     constructor(schema) {
         super(SEQ, schema);
         this.items = [];
     }
-    static get tagName() {
-        return 'tag:yaml.org,2002:seq';
-    }
     add(value) {
         this.items.push(value);
     }
@@ -30597,6 +31766,21 @@ class YAMLSeq extends Collection {
             onComment
         });
     }
+    static from(schema, obj, ctx) {
+        const { replacer } = ctx;
+        const seq = new this(schema);
+        if (obj && Symbol.iterator in Object(obj)) {
+            let i = 0;
+            for (let it of obj) {
+                if (typeof replacer === 'function') {
+                    const key = obj instanceof Set ? it : String(i++);
+                    it = replacer.call(obj, key, it);
+                }
+                seq.items.push(createNode(it, undefined, ctx));
+            }
+        }
+        return seq;
+    }
 }
 function asItemIndex(key) {
     let idx = isScalar$1(key) ? key.value : key;
@@ -30607,24 +31791,8 @@ function asItemIndex(key) {
         : null;
 }
 
-function createSeq(schema, obj, ctx) {
-    const { replacer } = ctx;
-    const seq = new YAMLSeq(schema);
-    if (obj && Symbol.iterator in Object(obj)) {
-        let i = 0;
-        for (let it of obj) {
-            if (typeof replacer === 'function') {
-                const key = obj instanceof Set ? it : String(i++);
-                it = replacer.call(obj, key, it);
-            }
-            seq.items.push(createNode(it, undefined, ctx));
-        }
-    }
-    return seq;
-}
 const seq = {
     collection: 'seq',
-    createNode: createSeq,
     default: true,
     nodeClass: YAMLSeq,
     tag: 'tag:yaml.org,2002:seq',
@@ -30632,7 +31800,8 @@ const seq = {
         if (!isSeq(seq))
             onError('Expected a sequence for this tag');
         return seq;
-    }
+    },
+    createNode: (schema, obj, ctx) => YAMLSeq.from(schema, obj, ctx)
 };
 
 const string = {
@@ -30957,8 +32126,9 @@ function createPairs(schema, iterable, ctx) {
                     key = keys[0];
                     value = it[key];
                 }
-                else
-                    throw new TypeError(`Expected { key: value } tuple: ${it}`);
+                else {
+                    throw new TypeError(`Expected tuple with one key, not ${keys.length} keys`);
+                }
             }
             else {
                 key = it;
@@ -31010,6 +32180,12 @@ class YAMLOMap extends YAMLSeq {
         }
         return map;
     }
+    static from(schema, iterable, ctx) {
+        const pairs = createPairs(schema, iterable, ctx);
+        const omap = new this();
+        omap.items = pairs.items;
+        return omap;
+    }
 }
 YAMLOMap.tag = 'tag:yaml.org,2002:omap';
 const omap = {
@@ -31033,12 +32209,7 @@ const omap = {
         }
         return Object.assign(new YAMLOMap(), pairs);
     },
-    createNode(schema, iterable, ctx) {
-        const pairs = createPairs(schema, iterable, ctx);
-        const omap = new YAMLOMap();
-        omap.items = pairs.items;
-        return omap;
-    }
+    createNode: (schema, iterable, ctx) => YAMLOMap.from(schema, iterable, ctx)
 };
 
 function boolStringify({ value, source }, ctx) {
@@ -31183,7 +32354,8 @@ class YAMLSet extends YAMLMap {
         let pair;
         if (isPair(key))
             pair = key;
-        else if (typeof key === 'object' &&
+        else if (key &&
+            typeof key === 'object' &&
             'key' in key &&
             'value' in key &&
             key.value === null)
@@ -31228,6 +32400,17 @@ class YAMLSet extends YAMLMap {
         else
             throw new Error('Set items must all have null values');
     }
+    static from(schema, iterable, ctx) {
+        const { replacer } = ctx;
+        const set = new this(schema);
+        if (iterable && Symbol.iterator in Object(iterable))
+            for (let value of iterable) {
+                if (typeof replacer === 'function')
+                    value = replacer.call(iterable, value, value);
+                set.items.push(createPair(value, null, ctx));
+            }
+        return set;
+    }
 }
 YAMLSet.tag = 'tag:yaml.org,2002:set';
 const set = {
@@ -31236,6 +32419,7 @@ const set = {
     nodeClass: YAMLSet,
     default: false,
     tag: 'tag:yaml.org,2002:set',
+    createNode: (schema, iterable, ctx) => YAMLSet.from(schema, iterable, ctx),
     resolve(map, onError) {
         if (isMap(map)) {
             if (map.hasAllNullValues(true))
@@ -31246,17 +32430,6 @@ const set = {
         else
             onError('Expected a mapping for this tag');
         return map;
-    },
-    createNode(schema, iterable, ctx) {
-        const { replacer } = ctx;
-        const set = new YAMLSet(schema);
-        if (iterable && Symbol.iterator in Object(iterable))
-            for (let value of iterable) {
-                if (typeof replacer === 'function')
-                    value = replacer.call(iterable, value, value);
-                set.items.push(createPair(value, null, ctx));
-            }
-        return set;
     }
 };
 
@@ -31303,7 +32476,7 @@ function stringifySexagesimal(node) {
     }
     return (sign +
         parts
-            .map(n => (n < 10 ? '0' + String(n) : String(n)))
+            .map(n => String(n).padStart(2, '0'))
             .join(':')
             .replace(/000000\d*$/, '') // % 60 may introduce error
     );
@@ -31558,59 +32731,6 @@ function stringifyDocument(doc, options) {
     return lines.join('\n') + '\n';
 }
 
-/**
- * Applies the JSON.parse reviver algorithm as defined in the ECMA-262 spec,
- * in section 24.5.1.1 "Runtime Semantics: InternalizeJSONProperty" of the
- * 2021 edition: https://tc39.es/ecma262/#sec-json.parse
- *
- * Includes extensions for handling Map and Set objects.
- */
-function applyReviver(reviver, obj, key, val) {
-    if (val && typeof val === 'object') {
-        if (Array.isArray(val)) {
-            for (let i = 0, len = val.length; i < len; ++i) {
-                const v0 = val[i];
-                const v1 = applyReviver(reviver, val, String(i), v0);
-                if (v1 === undefined)
-                    delete val[i];
-                else if (v1 !== v0)
-                    val[i] = v1;
-            }
-        }
-        else if (val instanceof Map) {
-            for (const k of Array.from(val.keys())) {
-                const v0 = val.get(k);
-                const v1 = applyReviver(reviver, val, k, v0);
-                if (v1 === undefined)
-                    val.delete(k);
-                else if (v1 !== v0)
-                    val.set(k, v1);
-            }
-        }
-        else if (val instanceof Set) {
-            for (const v0 of Array.from(val)) {
-                const v1 = applyReviver(reviver, val, v0, v0);
-                if (v1 === undefined)
-                    val.delete(v0);
-                else if (v1 !== v0) {
-                    val.delete(v0);
-                    val.add(v1);
-                }
-            }
-        }
-        else {
-            for (const [k, v0] of Object.entries(val)) {
-                const v1 = applyReviver(reviver, val, k, v0);
-                if (v1 === undefined)
-                    delete val[k];
-                else if (v1 !== v0)
-                    val[k] = v1;
-            }
-        }
-    }
-    return reviver.call(obj, key, val);
-}
-
 class Document {
     constructor(value, replacer, options) {
         /** A comment before this Document */
@@ -31649,11 +32769,9 @@ class Document {
         else
             this.directives = new Directives({ version });
         this.setSchema(version, options);
-        if (value === undefined)
-            this.contents = null;
-        else {
-            this.contents = this.createNode(value, _replacer, options);
-        }
+        // @ts-expect-error We can't really know that this matches Contents.
+        this.contents =
+            value === undefined ? null : this.createNode(value, _replacer, options);
     }
     /**
      * Create a deep copy of this Document and its contents.
@@ -31672,6 +32790,7 @@ class Document {
         if (this.directives)
             copy.directives = this.directives.clone();
         copy.schema = this.schema.clone();
+        // @ts-expect-error We can't really know that this matches Contents.
         copy.contents = isNode$1(this.contents)
             ? this.contents.clone(copy.schema)
             : this.contents;
@@ -31767,6 +32886,7 @@ class Document {
         if (isEmptyPath(path)) {
             if (this.contents == null)
                 return false;
+            // @ts-expect-error Presumed impossible if Strict extends false
             this.contents = null;
             return true;
         }
@@ -31818,6 +32938,7 @@ class Document {
      */
     set(key, value) {
         if (this.contents == null) {
+            // @ts-expect-error We can't really know that this matches Contents.
             this.contents = collectionFromPath(this.schema, [key], value);
         }
         else if (assertCollection(this.contents)) {
@@ -31829,9 +32950,12 @@ class Document {
      * boolean to add/remove the item from the set.
      */
     setIn(path, value) {
-        if (isEmptyPath(path))
+        if (isEmptyPath(path)) {
+            // @ts-expect-error We can't really know that this matches Contents.
             this.contents = value;
+        }
         else if (this.contents == null) {
+            // @ts-expect-error We can't really know that this matches Contents.
             this.contents = collectionFromPath(this.schema, Array.from(path), value);
         }
         else if (assertCollection(this.contents)) {
@@ -31891,8 +33015,7 @@ class Document {
             keep: !json,
             mapAsMap: mapAsMap === true,
             mapKeyWarned: false,
-            maxAliasCount: typeof maxAliasCount === 'number' ? maxAliasCount : 100,
-            stringify: stringify$2
+            maxAliasCount: typeof maxAliasCount === 'number' ? maxAliasCount : 100
         };
         const res = toJS(this.contents, jsonArg ?? '', ctx);
         if (typeof onAnchor === 'function')
@@ -31978,7 +33101,7 @@ const prettifyError = (src, lc) => (error) => {
         let count = 1;
         const end = error.linePos[1];
         if (end && end.line === line && end.col > col) {
-            count = Math.min(end.col - col, 80 - ci);
+            count = Math.max(1, Math.min(end.col - col, 80 - ci));
         }
         const pointer = ' '.repeat(ci) + '^'.repeat(count);
         error.message += `:\n\n${lineStr}\n${pointer}\n`;
@@ -32178,11 +33301,13 @@ function mapIncludes(ctx, items, search) {
 }
 
 const startColMsg = 'All mapping items must start at the same column';
-function resolveBlockMap({ composeNode, composeEmptyNode }, ctx, bm, onError) {
-    const map = new YAMLMap(ctx.schema);
+function resolveBlockMap({ composeNode, composeEmptyNode }, ctx, bm, onError, tag) {
+    const NodeClass = tag?.nodeClass ?? YAMLMap;
+    const map = new NodeClass(ctx.schema);
     if (ctx.atRoot)
         ctx.atRoot = false;
     let offset = bm.offset;
+    let commentEnd = null;
     for (const collItem of bm.items) {
         const { start, key, sep, value } = collItem;
         // key properties
@@ -32202,7 +33327,7 @@ function resolveBlockMap({ composeNode, composeEmptyNode }, ctx, bm, onError) {
                     onError(offset, 'BAD_INDENT', startColMsg);
             }
             if (!keyProps.anchor && !keyProps.tag && !sep) {
-                // TODO: assert being at last item?
+                commentEnd = keyProps.end;
                 if (keyProps.comment) {
                     if (map.comment)
                         map.comment += '\n' + keyProps.comment;
@@ -32272,15 +33397,19 @@ function resolveBlockMap({ composeNode, composeEmptyNode }, ctx, bm, onError) {
             map.items.push(pair);
         }
     }
-    map.range = [bm.offset, offset, offset];
+    if (commentEnd && commentEnd < offset)
+        onError(commentEnd, 'IMPOSSIBLE', 'Map comment with trailing content');
+    map.range = [bm.offset, offset, commentEnd ?? offset];
     return map;
 }
 
-function resolveBlockSeq({ composeNode, composeEmptyNode }, ctx, bs, onError) {
-    const seq = new YAMLSeq(ctx.schema);
+function resolveBlockSeq({ composeNode, composeEmptyNode }, ctx, bs, onError, tag) {
+    const NodeClass = tag?.nodeClass ?? YAMLSeq;
+    const seq = new NodeClass(ctx.schema);
     if (ctx.atRoot)
         ctx.atRoot = false;
     let offset = bs.offset;
+    let commentEnd = null;
     for (const { start, value } of bs.items) {
         const props = resolveProps(start, {
             indicator: 'seq-item-ind',
@@ -32289,16 +33418,15 @@ function resolveBlockSeq({ composeNode, composeEmptyNode }, ctx, bs, onError) {
             onError,
             startOnNewline: true
         });
-        offset = props.end;
         if (!props.found) {
             if (props.anchor || props.tag || value) {
                 if (value && value.type === 'block-seq')
-                    onError(offset, 'BAD_INDENT', 'All sequence items must start at the same column');
+                    onError(props.end, 'BAD_INDENT', 'All sequence items must start at the same column');
                 else
                     onError(offset, 'MISSING_CHAR', 'Sequence item without - indicator');
             }
             else {
-                // TODO: assert being at last item?
+                commentEnd = props.end;
                 if (props.comment)
                     seq.comment = props.comment;
                 continue;
@@ -32306,13 +33434,13 @@ function resolveBlockSeq({ composeNode, composeEmptyNode }, ctx, bs, onError) {
         }
         const node = value
             ? composeNode(ctx, value, props, onError)
-            : composeEmptyNode(ctx, offset, start, null, props, onError);
+            : composeEmptyNode(ctx, props.end, start, null, props, onError);
         if (ctx.schema.compat)
             flowIndentCheck(bs.indent, value, onError);
         offset = node.range[2];
         seq.items.push(node);
     }
-    seq.range = [bs.offset, offset, offset];
+    seq.range = [bs.offset, offset, commentEnd ?? offset];
     return seq;
 }
 
@@ -32354,12 +33482,11 @@ function resolveEnd(end, offset, reqSpace, onError) {
 
 const blockMsg = 'Block collections are not allowed within flow collections';
 const isBlock$1 = (token) => token && (token.type === 'block-map' || token.type === 'block-seq');
-function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onError) {
+function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onError, tag) {
     const isMap = fc.start.source === '{';
     const fcName = isMap ? 'flow map' : 'flow sequence';
-    const coll = isMap
-        ? new YAMLMap(ctx.schema)
-        : new YAMLSeq(ctx.schema);
+    const NodeClass = (tag?.nodeClass ?? (isMap ? YAMLMap : YAMLSeq));
+    const coll = new NodeClass(ctx.schema);
     coll.flow = true;
     const atRoot = ctx.atRoot;
     if (atRoot)
@@ -32542,35 +33669,45 @@ function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onErr
     return coll;
 }
 
-function composeCollection(CN, ctx, token, tagToken, onError) {
-    let coll;
-    switch (token.type) {
-        case 'block-map': {
-            coll = resolveBlockMap(CN, ctx, token, onError);
-            break;
-        }
-        case 'block-seq': {
-            coll = resolveBlockSeq(CN, ctx, token, onError);
-            break;
-        }
-        case 'flow-collection': {
-            coll = resolveFlowCollection(CN, ctx, token, onError);
-            break;
-        }
-    }
-    if (!tagToken)
-        return coll;
-    const tagName = ctx.directives.tagName(tagToken.source, msg => onError(tagToken, 'TAG_RESOLVE_FAILED', msg));
-    if (!tagName)
-        return coll;
-    // Cast needed due to: https://github.com/Microsoft/TypeScript/issues/3841
+function resolveCollection(CN, ctx, token, onError, tagName, tag) {
+    const coll = token.type === 'block-map'
+        ? resolveBlockMap(CN, ctx, token, onError, tag)
+        : token.type === 'block-seq'
+            ? resolveBlockSeq(CN, ctx, token, onError, tag)
+            : resolveFlowCollection(CN, ctx, token, onError, tag);
     const Coll = coll.constructor;
+    // If we got a tagName matching the class, or the tag name is '!',
+    // then use the tagName from the node class used to create it.
     if (tagName === '!' || tagName === Coll.tagName) {
         coll.tag = Coll.tagName;
         return coll;
     }
-    const expType = isMap(coll) ? 'map' : 'seq';
-    let tag = ctx.schema.tags.find(t => t.collection === expType && t.tag === tagName);
+    if (tagName)
+        coll.tag = tagName;
+    return coll;
+}
+function composeCollection(CN, ctx, token, tagToken, onError) {
+    const tagName = !tagToken
+        ? null
+        : ctx.directives.tagName(tagToken.source, msg => onError(tagToken, 'TAG_RESOLVE_FAILED', msg));
+    const expType = token.type === 'block-map'
+        ? 'map'
+        : token.type === 'block-seq'
+            ? 'seq'
+            : token.start.source === '{'
+                ? 'map'
+                : 'seq';
+    // shortcut: check if it's a generic YAMLMap or YAMLSeq
+    // before jumping into the custom tag logic.
+    if (!tagToken ||
+        !tagName ||
+        tagName === '!' ||
+        (tagName === YAMLMap.tagName && expType === 'map') ||
+        (tagName === YAMLSeq.tagName && expType === 'seq') ||
+        !expType) {
+        return resolveCollection(CN, ctx, token, onError, tagName);
+    }
+    let tag = ctx.schema.tags.find(t => t.tag === tagName && t.collection === expType);
     if (!tag) {
         const kt = ctx.schema.knownTags[tagName];
         if (kt && kt.collection === expType) {
@@ -32578,12 +33715,17 @@ function composeCollection(CN, ctx, token, tagToken, onError) {
             tag = kt;
         }
         else {
-            onError(tagToken, 'TAG_RESOLVE_FAILED', `Unresolved tag: ${tagName}`, true);
-            coll.tag = tagName;
-            return coll;
+            if (kt?.collection) {
+                onError(tagToken, 'BAD_COLLECTION_TYPE', `${kt.tag} used for ${expType} collection, but expects ${kt.collection}`, true);
+            }
+            else {
+                onError(tagToken, 'TAG_RESOLVE_FAILED', `Unresolved tag: ${tagName}`, true);
+            }
+            return resolveCollection(CN, ctx, token, onError, tagName);
         }
     }
-    const res = tag.resolve(coll, msg => onError(tagToken, 'TAG_RESOLVE_FAILED', msg), ctx.options);
+    const coll = resolveCollection(CN, ctx, token, onError, tagName, tag);
+    const res = tag.resolve?.(coll, msg => onError(tagToken, 'TAG_RESOLVE_FAILED', msg), ctx.options) ?? coll;
     const node = isNode$1(res)
         ? res
         : new Scalar(res);
@@ -33154,7 +34296,7 @@ function composeNode(ctx, token, props, onError) {
         node.srcToken = token;
     return node;
 }
-function composeEmptyNode(ctx, offset, before, pos, { spaceBefore, comment, anchor, tag }, onError) {
+function composeEmptyNode(ctx, offset, before, pos, { spaceBefore, comment, anchor, tag, end }, onError) {
     const token = {
         type: 'scalar',
         offset: emptyScalarPosition(offset, before, pos),
@@ -33169,8 +34311,10 @@ function composeEmptyNode(ctx, offset, before, pos, { spaceBefore, comment, anch
     }
     if (spaceBefore)
         node.spaceBefore = true;
-    if (comment)
+    if (comment) {
         node.comment = comment;
+        node.range[2] = end;
+    }
     return node;
 }
 function composeAlias({ options }, { offset, source, end }, onError) {
@@ -33210,6 +34354,7 @@ function composeDoc(options, directives, { offset, start, value, end }, onError)
             !props.hasNewline)
             onError(props.end, 'MISSING_CHAR', 'Block collection cannot start on same line with directives-end marker');
     }
+    // @ts-expect-error If Contents is set, let's trust the user
     doc.contents = value
         ? composeNode(ctx, value, props, onError)
         : composeEmptyNode(ctx, props.end, start, null, props, onError);
@@ -36006,6 +37151,7 @@ const withTypeScriptLoader = (rcFunc) => {
       try {
         // Register TypeScript compiler instance
         registerer = __require('ts-node').register({
+          // transpile to cjs even if compilerOptions.module in tsconfig is not Node16/NodeNext.
           moduleTypes: { '**/*.cts': 'cjs' }
         });
 
@@ -37857,11 +39003,12 @@ function cssPostPlugin(config) {
         ? rollupOptionsOutput[0]
         : rollupOptionsOutput)?.assetFileNames;
     const getCssAssetDirname = (cssAssetName) => {
+        const cssAssetNameDir = path$o.dirname(cssAssetName);
         if (!assetFileNames) {
-            return config.build.assetsDir;
+            return path$o.join(config.build.assetsDir, cssAssetNameDir);
         }
         else if (typeof assetFileNames === 'string') {
-            return path$o.dirname(assetFileNames);
+            return path$o.join(path$o.dirname(assetFileNames), cssAssetNameDir);
         }
         else {
             return path$o.dirname(assetFileNames({
@@ -37997,7 +39144,7 @@ function cssPostPlugin(config) {
                 const encodedPublicUrls = encodePublicUrlsInCSS(config);
                 const relative = config.base === './' || config.base === '';
                 const cssAssetDirname = encodedPublicUrls || relative
-                    ? getCssAssetDirname(cssAssetName)
+                    ? slash$1(getCssAssetDirname(cssAssetName))
                     : undefined;
                 const toRelative = (filename) => {
                     // relative base + extracted CSS
@@ -38030,7 +39177,14 @@ function cssPostPlugin(config) {
                         pureCssChunks.add(chunk);
                     }
                     const isEntry = chunk.isEntry && isPureCssChunk;
-                    const cssAssetName = ensureFileExt(chunk.name, '.css');
+                    const cssFullAssetName = ensureFileExt(chunk.name, '.css');
+                    // if facadeModuleId doesn't exist or doesn't have a CSS extension,
+                    // that means a JS entry file imports a CSS file.
+                    // in this case, only use the filename for the CSS chunk name like JS chunks.
+                    const cssAssetName = chunk.isEntry &&
+                        (!chunk.facadeModuleId || !isCSSRequest(chunk.facadeModuleId))
+                        ? path$o.basename(cssFullAssetName)
+                        : cssFullAssetName;
                     const originalFilename = getChunkOriginalFileName(chunk, config.root, opts.format);
                     chunkCSS = resolveAssetUrlsInCss(chunkCSS, cssAssetName);
                     const previousTask = emitTasks[emitTasks.length - 1];
@@ -38509,8 +39663,8 @@ function createCachedImport(imp) {
         return cached;
     };
 }
-const importPostcssImport = createCachedImport(() => import('./dep-CV-Y9tzJ.js').then(function (n) { return n.i; }));
-const importPostcssModules = createCachedImport(() => import('./dep-sKpqGbYj.js').then(function (n) { return n.i; }));
+const importPostcssImport = createCachedImport(() => import('./dep-nbvvoiwS.js').then(function (n) { return n.i; }));
+const importPostcssModules = createCachedImport(() => import('./dep-GiiHpyM6.js').then(function (n) { return n.i; }));
 const importPostcss = createCachedImport(() => import('postcss'));
 /**
  * @experimental
@@ -58787,25 +59941,37 @@ async function restartServer(server) {
             },
         });
     }
-    let newServer = null;
-    try {
-        // delay ws server listen
-        newServer = await _createServer(inlineConfig, { ws: false });
-    }
-    catch (err) {
-        server.config.logger.error(err.message, {
-            timestamp: true,
-        });
-        server.config.logger.error('server restart failed', { timestamp: true });
-        return;
+    // Reinit the server by creating a new instance using the same inlineConfig
+    // This will triger a reload of the config file and re-create the plugins and
+    // middlewares. We then assign all properties of the new server to the existing
+    // server instance and set the user instance to be used in the new server.
+    // This allows us to keep the same server instance for the user.
+    {
+        let newServer = null;
+        try {
+            // delay ws server listen
+            newServer = await _createServer(inlineConfig, { ws: false });
+        }
+        catch (err) {
+            server.config.logger.error(err.message, {
+                timestamp: true,
+            });
+            server.config.logger.error('server restart failed', { timestamp: true });
+            return;
+        }
+        await server.close();
+        // Assign new server props to existing server instance
+        const middlewares = server.middlewares;
+        newServer._configServerPort = server._configServerPort;
+        newServer._currentServerPort = server._currentServerPort;
+        Object.assign(server, newServer);
+        // Keep the same connect instance so app.use(vite.middlewares) works
+        // after a restart in middlewareMode (.route is always '/')
+        middlewares.stack = newServer.middlewares.stack;
+        server.middlewares = middlewares;
+        // Rebind internal server variable so functions reference the user server
+        newServer._setInternalServer(server);
     }
-    await server.close();
-    // Assign new server props to existing server instance
-    newServer._configServerPort = server._configServerPort;
-    newServer._currentServerPort = server._currentServerPort;
-    Object.assign(server, newServer);
-    // Rebind internal server variable so functions reference the user server
-    newServer._setInternalServer(server);
     const { logger, server: { port, middlewareMode }, } = server.config;
     if (!middlewareMode) {
         await server.listen(port, true);
@@ -58816,7 +59982,7 @@ async function restartServer(server) {
     logger.info('server restarted.', { timestamp: true });
     if (shortcutsOptions) {
         shortcutsOptions.print = false;
-        bindCLIShortcuts(newServer, shortcutsOptions);
+        bindCLIShortcuts(server, shortcutsOptions);
     }
 }
 /**
@@ -59317,15 +60483,12 @@ function definePlugin(config) {
     const isBuildLib = isBuild && config.build.lib;
     // ignore replace process.env in lib build
     const processEnv = {};
-    const processNodeEnv = {};
     if (!isBuildLib) {
         const nodeEnv = process.env.NODE_ENV || config.mode;
         Object.assign(processEnv, {
             'process.env': `{}`,
             'global.process.env': `{}`,
             'globalThis.process.env': `{}`,
-        });
-        Object.assign(processNodeEnv, {
             'process.env.NODE_ENV': JSON.stringify(nodeEnv),
             'global.process.env.NODE_ENV': JSON.stringify(nodeEnv),
             'globalThis.process.env.NODE_ENV': JSON.stringify(nodeEnv),
@@ -59358,11 +60521,10 @@ function definePlugin(config) {
     function generatePattern(ssr) {
         const replaceProcessEnv = !ssr || config.ssr?.target === 'webworker';
         const define = {
-            ...(replaceProcessEnv ? processNodeEnv : {}),
+            ...(replaceProcessEnv ? processEnv : {}),
             ...importMetaKeys,
             ...userDefine,
             ...importMetaFallbackKeys,
-            ...(replaceProcessEnv ? processEnv : {}),
         };
         // Additional define fixes based on `ssr` value
         if ('import.meta.env.SSR' in define) {
@@ -61094,10 +62256,11 @@ class VariableDynamicImportError extends Error {}
 const example = 'For example: import(`./foo/${bar}.js`).';
 
 function sanitizeString(str) {
+  if (str === '') return str;
   if (str.includes('*')) {
     throw new VariableDynamicImportError('A dynamic import cannot contain * characters.');
   }
-  return str;
+  return glob.escapePath(str);
 }
 
 function templateLiteralToGlob(node) {
@@ -61238,7 +62401,9 @@ function parseDynamicImportPattern(strings) {
     if (!userPatternQuery) {
         return null;
     }
-    const [userPattern] = userPatternQuery.split(requestQuerySplitRE, 2);
+    const [userPattern] = userPatternQuery.split(
+    // ? is escaped on posix OS
+    requestQueryMaybeEscapedSplitRE, 2);
     const [rawPattern] = filename.split(requestQuerySplitRE, 2);
     const as = ['worker', 'url', 'raw'].find((key) => rawQuery && key in rawQuery);
     if (as) {
@@ -61627,6 +62792,20 @@ async function createPluginContainer(config, moduleGraph, watcher) {
         _addedImports = null;
         constructor(initialPlugin) {
             this._activePlugin = initialPlugin || null;
+            this.parse = this.parse.bind(this);
+            this.resolve = this.resolve.bind(this);
+            this.load = this.load.bind(this);
+            this.getModuleInfo = this.getModuleInfo.bind(this);
+            this.getModuleIds = this.getModuleIds.bind(this);
+            this.addWatchFile = this.addWatchFile.bind(this);
+            this.getWatchFiles = this.getWatchFiles.bind(this);
+            this.emitFile = this.emitFile.bind(this);
+            this.setAssetSource = this.setAssetSource.bind(this);
+            this.getFileName = this.getFileName.bind(this);
+            this.warn = this.warn.bind(this);
+            this.error = this.error.bind(this);
+            this.debug = this.debug.bind(this);
+            this.info = this.info.bind(this);
         }
         parse(code, opts) {
             return parseAst(code, opts);
@@ -62778,7 +63957,7 @@ async function createDepsOptimizer(config, server) {
             newDepsToLog = [];
         }
     };
-    let depOptimizationProcessing = newDepOptimizationProcessing();
+    let depOptimizationProcessing = promiseWithResolvers();
     let depOptimizationProcessingQueue = [];
     const resolveEnqueuedProcessingPromises = () => {
         // Resolve all the processings (including the ones which were delayed)
@@ -62873,7 +64052,7 @@ async function createDepsOptimizer(config, server) {
         depOptimizationProcessingQueue.push(depOptimizationProcessing);
         // Create a new promise for the next rerun, discovered missing
         // dependencies will be assigned this promise from this point
-        depOptimizationProcessing = newDepOptimizationProcessing();
+        depOptimizationProcessing = promiseWithResolvers();
     }
     function prepareKnownDeps() {
         const knownDeps = {};
@@ -63780,13 +64959,6 @@ async function addManuallyIncludedOptimizeDeps(deps, config, ssr, extra = [], fi
         }
     }
 }
-function newDepOptimizationProcessing() {
-    let resolve;
-    const promise = new Promise((_resolve) => {
-        resolve = _resolve;
-    });
-    return { promise, resolve: resolve };
-}
 // Convert to { id: src }
 function depsFromOptimizedDepInfo(depsInfo) {
     const obj = {};
@@ -64153,7 +65325,6 @@ var index = {
 	initDepsOptimizerMetadata: initDepsOptimizerMetadata,
 	initDevSsrDepsOptimizer: initDevSsrDepsOptimizer,
 	loadCachedDepOptimizationMetadata: loadCachedDepOptimizationMetadata,
-	newDepOptimizationProcessing: newDepOptimizationProcessing,
 	optimizeDeps: optimizeDeps,
 	optimizeServerSsrDeps: optimizeServerSsrDeps,
 	optimizedDepInfoFromFile: optimizedDepInfoFromFile,