path-serializer 0.5.1 → 0.6.0

package/dist/cjs/index.cjs

@@ -0,0 +1,643 @@
+var __webpack_modules__ = {
+    "./node_modules/.pnpm/upath@2.0.1/node_modules/upath/build/code/upath.js" (__unused_rspack_module, exports1, __webpack_require__) {
+        var VERSION = '2.0.1';
+        var extraFn, extraFunctions, isFunction, isString, isValidExt, name, path, propName, propValue, toUnix, upath, slice = [].slice, indexOf = [].indexOf || function(item) {
+            for(var i = 0, l = this.length; i < l; i++)if (i in this && this[i] === item) return i;
+            return -1;
+        }, hasProp = {}.hasOwnProperty;
+        path = __webpack_require__("path");
+        isFunction = function(val) {
+            return "function" == typeof val;
+        };
+        isString = function(val) {
+            return "string" == typeof val || !!val && "object" == typeof val && "[object String]" === Object.prototype.toString.call(val);
+        };
+        upath = exports1;
+        upath.VERSION = null != VERSION ? VERSION : "NO-VERSION";
+        toUnix = function(p) {
+            p = p.replace(/\\/g, "/");
+            p = p.replace(/(?<!^)\/+/g, "/");
+            return p;
+        };
+        for(propName in path){
+            propValue = path[propName];
+            if (isFunction(propValue)) upath[propName] = function(propName) {
+                return function() {
+                    var args, result;
+                    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
+                    args = args.map(function(p) {
+                        if (isString(p)) return toUnix(p);
+                        return p;
+                    });
+                    result = path[propName].apply(path, args);
+                    if (isString(result)) return toUnix(result);
+                    return result;
+                };
+            }(propName);
+            else upath[propName] = propValue;
+        }
+        upath.sep = "/";
+        extraFunctions = {
+            toUnix: toUnix,
+            normalizeSafe: function(p) {
+                var result;
+                p = toUnix(p);
+                result = upath.normalize(p);
+                if (!p.startsWith("./") || result.startsWith("./") || result.startsWith("..")) {
+                    if (p.startsWith("//") && !result.startsWith("//")) result = p.startsWith("//./") ? "//." + result : "/" + result;
+                } else result = "./" + result;
+                return result;
+            },
+            normalizeTrim: function(p) {
+                p = upath.normalizeSafe(p);
+                if (p.endsWith("/")) return p.slice(0, +(p.length - 2) + 1 || 9000000000);
+                return p;
+            },
+            joinSafe: function() {
+                var p, p0, result;
+                p = 1 <= arguments.length ? slice.call(arguments, 0) : [];
+                result = upath.join.apply(null, p);
+                if (p.length > 0) {
+                    p0 = toUnix(p[0]);
+                    if (!p0.startsWith("./") || result.startsWith("./") || result.startsWith("..")) {
+                        if (p0.startsWith("//") && !result.startsWith("//")) result = p0.startsWith("//./") ? "//." + result : "/" + result;
+                    } else result = "./" + result;
+                }
+                return result;
+            },
+            addExt: function(file, ext) {
+                if (!ext) return file;
+                if ("." !== ext[0]) ext = "." + ext;
+                return file + (file.endsWith(ext) ? "" : ext);
+            },
+            trimExt: function(filename, ignoreExts, maxSize) {
+                var oldExt;
+                if (null == maxSize) maxSize = 7;
+                oldExt = upath.extname(filename);
+                if (isValidExt(oldExt, ignoreExts, maxSize)) return filename.slice(0, +(filename.length - oldExt.length - 1) + 1 || 9000000000);
+                return filename;
+            },
+            removeExt: function(filename, ext) {
+                if (!ext) return filename;
+                ext = "." === ext[0] ? ext : "." + ext;
+                if (upath.extname(filename) === ext) return upath.trimExt(filename, [], ext.length);
+                return filename;
+            },
+            changeExt: function(filename, ext, ignoreExts, maxSize) {
+                if (null == maxSize) maxSize = 7;
+                return upath.trimExt(filename, ignoreExts, maxSize) + (ext ? "." === ext[0] ? ext : "." + ext : "");
+            },
+            defaultExt: function(filename, ext, ignoreExts, maxSize) {
+                var oldExt;
+                if (null == maxSize) maxSize = 7;
+                oldExt = upath.extname(filename);
+                if (isValidExt(oldExt, ignoreExts, maxSize)) return filename;
+                return upath.addExt(filename, ext);
+            }
+        };
+        isValidExt = function(ext, ignoreExts, maxSize) {
+            if (null == ignoreExts) ignoreExts = [];
+            return ext && ext.length <= maxSize && indexOf.call(ignoreExts.map(function(e) {
+                return (e && "." !== e[0] ? "." : "") + e;
+            }), ext) < 0;
+        };
+        for(name in extraFunctions)if (hasProp.call(extraFunctions, name)) {
+            extraFn = extraFunctions[name];
+            if (void 0 !== upath[name]) throw new Error("path." + name + " already exists.");
+            upath[name] = extraFn;
+        }
+    },
+    path (module) {
+        "use strict";
+        module.exports = require("path");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+(()=>{
+    "use strict";
+    __webpack_require__.r(__webpack_exports__);
+    __webpack_require__.d(__webpack_exports__, {
+        createSnapshotSerializer: ()=>createSnapshotSerializer
+    });
+    const external_node_url_namespaceObject = require("node:url");
+    function arrayReduce(array, iteratee, accumulator, initAccum) {
+        var index = -1, length = null == array ? 0 : array.length;
+        if (initAccum && length) accumulator = array[++index];
+        while(++index < length)accumulator = iteratee(accumulator, array[index], index, array);
+        return accumulator;
+    }
+    const _arrayReduce = arrayReduce;
+    function basePropertyOf(object) {
+        return function(key) {
+            return null == object ? void 0 : object[key];
+        };
+    }
+    const _basePropertyOf = basePropertyOf;
+    var deburredLetters = {
+        À: 'A',
+        Á: 'A',
+        Â: 'A',
+        Ã: 'A',
+        Ä: 'A',
+        Å: 'A',
+        à: 'a',
+        á: 'a',
+        â: 'a',
+        ã: 'a',
+        ä: 'a',
+        å: 'a',
+        Ç: 'C',
+        ç: 'c',
+        Ð: 'D',
+        ð: 'd',
+        È: 'E',
+        É: 'E',
+        Ê: 'E',
+        Ë: 'E',
+        è: 'e',
+        é: 'e',
+        ê: 'e',
+        ë: 'e',
+        Ì: 'I',
+        Í: 'I',
+        Î: 'I',
+        Ï: 'I',
+        ì: 'i',
+        í: 'i',
+        î: 'i',
+        ï: 'i',
+        Ñ: 'N',
+        ñ: 'n',
+        Ò: 'O',
+        Ó: 'O',
+        Ô: 'O',
+        Õ: 'O',
+        Ö: 'O',
+        Ø: 'O',
+        ò: 'o',
+        ó: 'o',
+        ô: 'o',
+        õ: 'o',
+        ö: 'o',
+        ø: 'o',
+        Ù: 'U',
+        Ú: 'U',
+        Û: 'U',
+        Ü: 'U',
+        ù: 'u',
+        ú: 'u',
+        û: 'u',
+        ü: 'u',
+        Ý: 'Y',
+        ý: 'y',
+        ÿ: 'y',
+        Æ: 'Ae',
+        æ: 'ae',
+        Þ: 'Th',
+        þ: 'th',
+        ß: 'ss',
+        Ā: 'A',
+        Ă: 'A',
+        Ą: 'A',
+        ā: 'a',
+        ă: 'a',
+        ą: 'a',
+        Ć: 'C',
+        Ĉ: 'C',
+        Ċ: 'C',
+        Č: 'C',
+        ć: 'c',
+        ĉ: 'c',
+        ċ: 'c',
+        č: 'c',
+        Ď: 'D',
+        Đ: 'D',
+        ď: 'd',
+        đ: 'd',
+        Ē: 'E',
+        Ĕ: 'E',
+        Ė: 'E',
+        Ę: 'E',
+        Ě: 'E',
+        ē: 'e',
+        ĕ: 'e',
+        ė: 'e',
+        ę: 'e',
+        ě: 'e',
+        Ĝ: 'G',
+        Ğ: 'G',
+        Ġ: 'G',
+        Ģ: 'G',
+        ĝ: 'g',
+        ğ: 'g',
+        ġ: 'g',
+        ģ: 'g',
+        Ĥ: 'H',
+        Ħ: 'H',
+        ĥ: 'h',
+        ħ: 'h',
+        Ĩ: 'I',
+        Ī: 'I',
+        Ĭ: 'I',
+        Į: 'I',
+        İ: 'I',
+        ĩ: 'i',
+        ī: 'i',
+        ĭ: 'i',
+        į: 'i',
+        ı: 'i',
+        Ĵ: 'J',
+        ĵ: 'j',
+        Ķ: 'K',
+        ķ: 'k',
+        ĸ: 'k',
+        Ĺ: 'L',
+        Ļ: 'L',
+        Ľ: 'L',
+        Ŀ: 'L',
+        Ł: 'L',
+        ĺ: 'l',
+        ļ: 'l',
+        ľ: 'l',
+        ŀ: 'l',
+        ł: 'l',
+        Ń: 'N',
+        Ņ: 'N',
+        Ň: 'N',
+        Ŋ: 'N',
+        ń: 'n',
+        ņ: 'n',
+        ň: 'n',
+        ŋ: 'n',
+        Ō: 'O',
+        Ŏ: 'O',
+        Ő: 'O',
+        ō: 'o',
+        ŏ: 'o',
+        ő: 'o',
+        Ŕ: 'R',
+        Ŗ: 'R',
+        Ř: 'R',
+        ŕ: 'r',
+        ŗ: 'r',
+        ř: 'r',
+        Ś: 'S',
+        Ŝ: 'S',
+        Ş: 'S',
+        Š: 'S',
+        ś: 's',
+        ŝ: 's',
+        ş: 's',
+        š: 's',
+        Ţ: 'T',
+        Ť: 'T',
+        Ŧ: 'T',
+        ţ: 't',
+        ť: 't',
+        ŧ: 't',
+        Ũ: 'U',
+        Ū: 'U',
+        Ŭ: 'U',
+        Ů: 'U',
+        Ű: 'U',
+        Ų: 'U',
+        ũ: 'u',
+        ū: 'u',
+        ŭ: 'u',
+        ů: 'u',
+        ű: 'u',
+        ų: 'u',
+        Ŵ: 'W',
+        ŵ: 'w',
+        Ŷ: 'Y',
+        ŷ: 'y',
+        Ÿ: 'Y',
+        Ź: 'Z',
+        Ż: 'Z',
+        Ž: 'Z',
+        ź: 'z',
+        ż: 'z',
+        ž: 'z',
+        IJ: 'IJ',
+        ij: 'ij',
+        Œ: 'Oe',
+        œ: 'oe',
+        ʼn: "'n",
+        ſ: 's'
+    };
+    var deburrLetter = _basePropertyOf(deburredLetters);
+    const _deburrLetter = deburrLetter;
+    var freeGlobal = 'object' == typeof global && global && global.Object === Object && global;
+    const _freeGlobal = freeGlobal;
+    var freeSelf = 'object' == typeof self && self && self.Object === Object && self;
+    var _root_root = _freeGlobal || freeSelf || Function('return this')();
+    const _root = _root_root;
+    var Symbol1 = _root.Symbol;
+    const _Symbol = Symbol1;
+    function arrayMap(array, iteratee) {
+        var index = -1, length = null == array ? 0 : array.length, result = Array(length);
+        while(++index < length)result[index] = iteratee(array[index], index, array);
+        return result;
+    }
+    const _arrayMap = arrayMap;
+    var isArray = Array.isArray;
+    const lodash_es_isArray = isArray;
+    var objectProto = Object.prototype;
+    var _getRawTag_hasOwnProperty = objectProto.hasOwnProperty;
+    var nativeObjectToString = objectProto.toString;
+    var symToStringTag = _Symbol ? _Symbol.toStringTag : void 0;
+    function getRawTag(value) {
+        var isOwn = _getRawTag_hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag];
+        try {
+            value[symToStringTag] = void 0;
+            var unmasked = true;
+        } catch (e) {}
+        var result = nativeObjectToString.call(value);
+        if (unmasked) if (isOwn) value[symToStringTag] = tag;
+        else delete value[symToStringTag];
+        return result;
+    }
+    const _getRawTag = getRawTag;
+    var _objectToString_objectProto = Object.prototype;
+    var _objectToString_nativeObjectToString = _objectToString_objectProto.toString;
+    function objectToString(value) {
+        return _objectToString_nativeObjectToString.call(value);
+    }
+    const _objectToString = objectToString;
+    var nullTag = '[object Null]', undefinedTag = '[object Undefined]';
+    var _baseGetTag_symToStringTag = _Symbol ? _Symbol.toStringTag : void 0;
+    function baseGetTag(value) {
+        if (null == value) return void 0 === value ? undefinedTag : nullTag;
+        return _baseGetTag_symToStringTag && _baseGetTag_symToStringTag in Object(value) ? _getRawTag(value) : _objectToString(value);
+    }
+    const _baseGetTag = baseGetTag;
+    function isObjectLike(value) {
+        return null != value && 'object' == typeof value;
+    }
+    const lodash_es_isObjectLike = isObjectLike;
+    var symbolTag = '[object Symbol]';
+    function isSymbol(value) {
+        return 'symbol' == typeof value || lodash_es_isObjectLike(value) && _baseGetTag(value) == symbolTag;
+    }
+    const lodash_es_isSymbol = isSymbol;
+    var INFINITY = 1 / 0;
+    var symbolProto = _Symbol ? _Symbol.prototype : void 0, symbolToString = symbolProto ? symbolProto.toString : void 0;
+    function baseToString(value) {
+        if ('string' == typeof value) return value;
+        if (lodash_es_isArray(value)) return _arrayMap(value, baseToString) + '';
+        if (lodash_es_isSymbol(value)) return symbolToString ? symbolToString.call(value) : '';
+        var result = value + '';
+        return '0' == result && 1 / value == -INFINITY ? '-0' : result;
+    }
+    const _baseToString = baseToString;
+    function toString_toString(value) {
+        return null == value ? '' : _baseToString(value);
+    }
+    const lodash_es_toString = toString_toString;
+    var reLatin = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g;
+    var rsComboMarksRange = '\\u0300-\\u036f', reComboHalfMarksRange = '\\ufe20-\\ufe2f', rsComboSymbolsRange = '\\u20d0-\\u20ff', rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange;
+    var rsCombo = '[' + rsComboRange + ']';
+    var reComboMark = RegExp(rsCombo, 'g');
+    function deburr(string) {
+        string = lodash_es_toString(string);
+        return string && string.replace(reLatin, _deburrLetter).replace(reComboMark, '');
+    }
+    const lodash_es_deburr = deburr;
+    var reAsciiWord = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;
+    function asciiWords(string) {
+        return string.match(reAsciiWord) || [];
+    }
+    const _asciiWords = asciiWords;
+    var reHasUnicodeWord = /[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/;
+    function hasUnicodeWord(string) {
+        return reHasUnicodeWord.test(string);
+    }
+    const _hasUnicodeWord = hasUnicodeWord;
+    var rsAstralRange = '\\ud800-\\udfff', _unicodeWords_rsComboMarksRange = '\\u0300-\\u036f', _unicodeWords_reComboHalfMarksRange = '\\ufe20-\\ufe2f', _unicodeWords_rsComboSymbolsRange = '\\u20d0-\\u20ff', _unicodeWords_rsComboRange = _unicodeWords_rsComboMarksRange + _unicodeWords_reComboHalfMarksRange + _unicodeWords_rsComboSymbolsRange, rsDingbatRange = '\\u2700-\\u27bf', rsLowerRange = 'a-z\\xdf-\\xf6\\xf8-\\xff', rsMathOpRange = '\\xac\\xb1\\xd7\\xf7', rsNonCharRange = '\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf', rsPunctuationRange = '\\u2000-\\u206f', rsSpaceRange = ' \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000', rsUpperRange = 'A-Z\\xc0-\\xd6\\xd8-\\xde', rsVarRange = '\\ufe0e\\ufe0f', rsBreakRange = rsMathOpRange + rsNonCharRange + rsPunctuationRange + rsSpaceRange;
+    var rsApos = "['\u2019]", rsBreak = '[' + rsBreakRange + ']', _unicodeWords_rsCombo = '[' + _unicodeWords_rsComboRange + ']', rsDigits = '\\d+', rsDingbat = '[' + rsDingbatRange + ']', rsLower = '[' + rsLowerRange + ']', rsMisc = '[^' + rsAstralRange + rsBreakRange + rsDigits + rsDingbatRange + rsLowerRange + rsUpperRange + ']', rsFitz = '\\ud83c[\\udffb-\\udfff]', rsModifier = '(?:' + _unicodeWords_rsCombo + '|' + rsFitz + ')', rsNonAstral = '[^' + rsAstralRange + ']', rsRegional = '(?:\\ud83c[\\udde6-\\uddff]){2}', rsSurrPair = '[\\ud800-\\udbff][\\udc00-\\udfff]', rsUpper = '[' + rsUpperRange + ']', rsZWJ = '\\u200d';
+    var rsMiscLower = '(?:' + rsLower + '|' + rsMisc + ')', rsMiscUpper = '(?:' + rsUpper + '|' + rsMisc + ')', rsOptContrLower = '(?:' + rsApos + '(?:d|ll|m|re|s|t|ve))?', rsOptContrUpper = '(?:' + rsApos + '(?:D|LL|M|RE|S|T|VE))?', reOptMod = rsModifier + '?', rsOptVar = '[' + rsVarRange + ']?', rsOptJoin = '(?:' + rsZWJ + '(?:' + [
+        rsNonAstral,
+        rsRegional,
+        rsSurrPair
+    ].join('|') + ')' + rsOptVar + reOptMod + ')*', rsOrdLower = '\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])', rsOrdUpper = '\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])', rsSeq = rsOptVar + reOptMod + rsOptJoin, rsEmoji = '(?:' + [
+        rsDingbat,
+        rsRegional,
+        rsSurrPair
+    ].join('|') + ')' + rsSeq;
+    var reUnicodeWord = RegExp([
+        rsUpper + '?' + rsLower + '+' + rsOptContrLower + '(?=' + [
+            rsBreak,
+            rsUpper,
+            '$'
+        ].join('|') + ')',
+        rsMiscUpper + '+' + rsOptContrUpper + '(?=' + [
+            rsBreak,
+            rsUpper + rsMiscLower,
+            '$'
+        ].join('|') + ')',
+        rsUpper + '?' + rsMiscLower + '+' + rsOptContrLower,
+        rsUpper + '+' + rsOptContrUpper,
+        rsOrdUpper,
+        rsOrdLower,
+        rsDigits,
+        rsEmoji
+    ].join('|'), 'g');
+    function unicodeWords(string) {
+        return string.match(reUnicodeWord) || [];
+    }
+    const _unicodeWords = unicodeWords;
+    function words(string, pattern, guard) {
+        string = lodash_es_toString(string);
+        pattern = guard ? void 0 : pattern;
+        if (void 0 === pattern) return _hasUnicodeWord(string) ? _unicodeWords(string) : _asciiWords(string);
+        return string.match(pattern) || [];
+    }
+    const lodash_es_words = words;
+    var _createCompounder_rsApos = "['\u2019]";
+    var reApos = RegExp(_createCompounder_rsApos, 'g');
+    function createCompounder(callback) {
+        return function(string) {
+            return _arrayReduce(lodash_es_words(lodash_es_deburr(string).replace(reApos, '')), callback, '');
+        };
+    }
+    const _createCompounder = createCompounder;
+    var snakeCase = _createCompounder(function(result, word, index) {
+        return result + (index ? '_' : '') + word.toLowerCase();
+    });
+    const lodash_es_snakeCase = snakeCase;
+    const external_node_fs_namespaceObject = require("node:fs");
+    var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+    const external_node_os_namespaceObject = require("node:os");
+    var external_node_os_default = /*#__PURE__*/ __webpack_require__.n(external_node_os_namespaceObject);
+    var reRegExpChar = /[\\^$.*+?()[\]{}|]/g, reHasRegExpChar = RegExp(reRegExpChar.source);
+    function escapeRegExp(string) {
+        string = lodash_es_toString(string);
+        return string && reHasRegExpChar.test(string) ? string.replace(reRegExpChar, '\\$&') : string;
+    }
+    const lodash_es_escapeRegExp = escapeRegExp;
+    function getRealTemporaryDirectory() {
+        let ret = null;
+        try {
+            ret = external_node_os_default().tmpdir();
+            ret = external_node_fs_default().realpathSync(ret);
+        } catch  {}
+        return ret;
+    }
+    function compilePathMatcherRegExp(match) {
+        if ('string' != typeof match) return match;
+        const escaped = lodash_es_escapeRegExp(match);
+        return new RegExp(`(?<=\\W|^)${escaped}(?=\\W|$)`, 'g');
+    }
+    function splitPathString(str) {
+        return str.split(/[\\/]/);
+    }
+    function applyPathMatcher(matcher, str, options = {}) {
+        const regex = compilePathMatcherRegExp(matcher.match);
+        const replacer = (substring, ...args)=>{
+            if (options.minPartials && splitPathString(substring).length < options.minPartials) return substring;
+            const ret = 'string' == typeof matcher.mark ? matcher.mark : matcher.mark(substring, ...args);
+            return `<${lodash_es_snakeCase(ret).toUpperCase()}>`;
+        };
+        return str.replace(regex, replacer);
+    }
+    function applyMatcherReplacement(matchers, str, options = {}) {
+        return matchers.reduce((ret, matcher)=>applyPathMatcher(matcher, ret, options), str);
+    }
+    const createTmpDirMatchers = ()=>{
+        const ret = [];
+        const realTmpDir = getRealTemporaryDirectory();
+        realTmpDir && ret.push({
+            match: realTmpDir,
+            mark: 'temp'
+        });
+        const tmpDir = external_node_os_default().tmpdir();
+        tmpDir && ret.push({
+            match: tmpDir,
+            mark: 'temp'
+        });
+        return ret;
+    };
+    const createHomeDirMatchers = ()=>{
+        const ret = [];
+        const homedir = external_node_os_default().homedir();
+        homedir && ret.push({
+            match: homedir,
+            mark: 'home'
+        });
+        return ret;
+    };
+    const external_node_path_namespaceObject = require("node:path");
+    var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+    var upath = __webpack_require__("./node_modules/.pnpm/upath@2.0.1/node_modules/upath/build/code/upath.js");
+    var upath_default = /*#__PURE__*/ __webpack_require__.n(upath);
+    const normalizePathToPosix = (p)=>upath_default().normalizeSafe(external_node_path_default().normalize(p || '')).replace(/^([a-zA-Z]+):/, (_, m)=>`/${m.toLowerCase()}`);
+    const normalizeCodeToPosix = (code)=>code.replace(/(?<![a-zA-Z])([a-zA-Z]:[\\/]+)([-\u4e00-\u9fa5\w\s.()~!@#$%^&()\[\]{}+=]+[\\/]+)*/g, (match, _diskName)=>normalizePathToPosix(match.replace(/[\\]{2,}/g, '\\')));
+    const normalizeCLR = (str)=>str.replace(/\u001b\[1m\u001b\[([0-9;]*)m/g, '<CLR=$1,BOLD>').replace(/\u001b\[1m/g, '<CLR=BOLD>').replace(/\u001b\[39m\u001b\[22m/g, '</CLR>').replace(/\u001b\[([0-9;]*)m/g, '<CLR=$1>').replace(/[0-9]+(\.[0-9]+)*(<\/CLR>)?(\s?s)/g, 'X$2$3');
+    const PNPM_INNER_TOKEN = '<PNPM_INNER>';
+    const PNPM_INNER_DELIMITERS = /[\s!"']/;
+    const LOCAL_PNPM_POSIX = /(?<=\/)(\.pnpm\/.+?\/node_modules)(?=\/)/g;
+    const LOCAL_PNPM_WIN32 = /(?<=\\)(\.pnpm\\.+?\\node_modules)(?=\\)/g;
+    const GLOBAL_PNPM_POSIX = /(?<=\/)pnpm\/store\/.+?\/links\/.+?\/node_modules(?=\/)/g;
+    function replacePnpmInnerPath(str) {
+        const replaced = str.replace(LOCAL_PNPM_POSIX, PNPM_INNER_TOKEN).replace(LOCAL_PNPM_WIN32, PNPM_INNER_TOKEN).replace(GLOBAL_PNPM_POSIX, PNPM_INNER_TOKEN);
+        const parts = replaced.split(PNPM_INNER_TOKEN);
+        if (parts.length <= 1) return replaced;
+        for(let i = 0; i < parts.length - 1; i++){
+            const part = parts[i];
+            let j = part.length - 1;
+            while(j >= 0 && !PNPM_INNER_DELIMITERS.test(part[j]))j--;
+            parts[i] = part.substring(0, j + 1);
+        }
+        return parts.join(PNPM_INNER_TOKEN);
+    }
+    function createSnapshotSerializer(options) {
+        const { root = process.cwd(), workspace = '', replace: customMatchers = [], replacePost: customPostMatchers = [], features = {}, beforeSerialize, afterSerialize } = options || {};
+        const { replaceWorkspaceWithFileProtocol = true, replaceWorkspace = true, replaceRootWithFileProtocol = true, replaceRoot = true, replacePnpmInner = true, replaceTmpDir = true, replaceHomeDir = true, addDoubleQuotes = true, transformWin32Path = true, escapeDoubleQuotes = true, escapeEOL = true, transformCLR = true } = features;
+        function createPathMatchers() {
+            const pathMatchers = [];
+            pathMatchers.push(...customMatchers);
+            if (replaceWorkspace && workspace) pathMatchers.push({
+                mark: 'workspace',
+                match: workspace
+            });
+            if (replaceRoot && root) pathMatchers.push({
+                mark: 'root',
+                match: root
+            });
+            if (replaceTmpDir) pathMatchers.push(...createTmpDirMatchers());
+            if (replaceHomeDir) pathMatchers.push(...createHomeDirMatchers());
+            pathMatchers.push(...customPostMatchers);
+            return pathMatchers;
+        }
+        const pathMatchers = createPathMatchers();
+        for (const matcher of pathMatchers)if ('string' == typeof matcher.match) matcher.match = normalizePathToPosix(matcher.match);
+        const serializer = {
+            test (val) {
+                return 'string' == typeof val;
+            },
+            serialize (val) {
+                let replaced = val;
+                if (beforeSerialize) replaced = beforeSerialize(replaced);
+                if (replaceWorkspaceWithFileProtocol && workspace) replaced = replaced.split((0, external_node_url_namespaceObject.pathToFileURL)(workspace).toString()).join('<WORKSPACE>');
+                if (replaceRootWithFileProtocol && root) replaced = replaced.split((0, external_node_url_namespaceObject.pathToFileURL)(root).toString()).join('<ROOT>');
+                if (transformWin32Path) replaced = normalizeCodeToPosix(replaced);
+                replaced = applyMatcherReplacement(pathMatchers, replaced);
+                if (replacePnpmInner) replaced = replacePnpmInnerPath(replaced);
+                if (transformCLR) replaced = normalizeCLR(replaced);
+                if (escapeDoubleQuotes) replaced = replaced.replace(/"/g, '\\"');
+                if (escapeEOL) replaced = replaced.replace(/\\r\\n/g, '\\n');
+                if (addDoubleQuotes) replaced = `"${replaced}"`;
+                if (afterSerialize) replaced = afterSerialize(replaced);
+                return replaced;
+            }
+        };
+        return serializer;
+    }
+})();
+exports.createSnapshotSerializer = __webpack_exports__.createSnapshotSerializer;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createSnapshotSerializer"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});