lkd-web-kit 0.7.9 → 0.7.10

package/dist/node_modules/next/dist/lib/route-pattern-normalizer.cjs

@@ -0,0 +1,115 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const routePatternNormalizer = require('../../../../_virtual/route-pattern-normalizer.cjs');
+
+var hasRequiredRoutePatternNormalizer;
+
+function requireRoutePatternNormalizer () {
+	if (hasRequiredRoutePatternNormalizer) return routePatternNormalizer.__exports;
+	hasRequiredRoutePatternNormalizer = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", {
+		    value: true
+		});
+		function _export(target, all) {
+		    for(var name in all)Object.defineProperty(target, name, {
+		        enumerable: true,
+		        get: all[name]
+		    });
+		}
+		_export(exports, {
+		    PARAM_SEPARATOR: function() {
+		        return PARAM_SEPARATOR;
+		    },
+		    hasAdjacentParameterIssues: function() {
+		        return hasAdjacentParameterIssues;
+		    },
+		    normalizeAdjacentParameters: function() {
+		        return normalizeAdjacentParameters;
+		    },
+		    normalizeTokensForRegexp: function() {
+		        return normalizeTokensForRegexp;
+		    },
+		    stripNormalizedSeparators: function() {
+		        return stripNormalizedSeparators;
+		    },
+		    stripParameterSeparators: function() {
+		        return stripParameterSeparators;
+		    }
+		});
+		const PARAM_SEPARATOR = '_NEXTSEP_';
+		function hasAdjacentParameterIssues(route) {
+		    if (typeof route !== 'string') return false;
+		    // Check for interception route markers followed immediately by parameters
+		    // Pattern: /(.):param, /(..):param, /(...):param, /(.)(.):param etc.
+		    // These patterns cause "Must have text between two parameters" errors
+		    if (/\/\(\.{1,3}\):[^/\s]+/.test(route)) {
+		        return true;
+		    }
+		    // Check for basic adjacent parameters without separators
+		    // Pattern: :param1:param2 (but not :param* or other URL patterns)
+		    if (/:[a-zA-Z_][a-zA-Z0-9_]*:[a-zA-Z_][a-zA-Z0-9_]*/.test(route)) {
+		        return true;
+		    }
+		    return false;
+		}
+		function normalizeAdjacentParameters(route) {
+		    let normalized = route;
+		    // Handle interception route patterns: (.):param -> (.)_NEXTSEP_:param
+		    normalized = normalized.replace(/(\([^)]*\)):([^/\s]+)/g, `$1${PARAM_SEPARATOR}:$2`);
+		    // Handle other adjacent parameter patterns: :param1:param2 -> :param1_NEXTSEP_:param2
+		    normalized = normalized.replace(/:([^:/\s)]+)(?=:)/g, `:$1${PARAM_SEPARATOR}`);
+		    return normalized;
+		}
+		function normalizeTokensForRegexp(tokens) {
+		    return tokens.map((token)=>{
+		        // Token union type: Token = string | TokenObject
+		        // Literal path segments are strings, parameters/wildcards are objects
+		        if (typeof token === 'object' && token !== null && // Not all token objects have 'modifier' property (e.g., simple text tokens)
+		        'modifier' in token && // Only repeating modifiers (* or +) cause the validation error
+		        // Other modifiers like '?' (optional) are fine
+		        (token.modifier === '*' || token.modifier === '+') && // Token objects can have different shapes depending on route pattern
+		        'prefix' in token && 'suffix' in token && // Both prefix and suffix must be empty strings
+		        // This is what causes the validation error in path-to-regexp
+		        token.prefix === '' && token.suffix === '') {
+		            // Add minimal prefix to satisfy path-to-regexp validation
+		            // We use '/' as it's the most common path delimiter and won't break route matching
+		            // The prefix gets used in regex generation but doesn't affect parameter extraction
+		            return {
+		                ...token,
+		                prefix: '/'
+		            };
+		        }
+		        return token;
+		    });
+		}
+		function stripNormalizedSeparators(pathname) {
+		    // Remove separator after interception route markers
+		    // Pattern: (.)_NEXTSEP_ -> (.), (..)_NEXTSEP_ -> (..), etc.
+		    // The separator appears after the closing paren of interception markers
+		    return pathname.replace(new RegExp(`\\)${PARAM_SEPARATOR}`, 'g'), ')');
+		}
+		function stripParameterSeparators(params) {
+		    const cleaned = {};
+		    for (const [key, value] of Object.entries(params)){
+		        if (typeof value === 'string') {
+		            // Remove the separator if it appears at the start of parameter values
+		            cleaned[key] = value.replace(new RegExp(`^${PARAM_SEPARATOR}`), '');
+		        } else if (Array.isArray(value)) {
+		            // Handle array parameters (from repeated route segments)
+		            cleaned[key] = value.map((item)=>typeof item === 'string' ? item.replace(new RegExp(`^${PARAM_SEPARATOR}`), '') : item);
+		        } else {
+		            cleaned[key] = value;
+		        }
+		    }
+		    return cleaned;
+		}
+
+		
+	} (routePatternNormalizer.__exports));
+	return routePatternNormalizer.__exports;
+}
+
+exports.__require = requireRoutePatternNormalizer;

package/dist/node_modules/next/dist/lib/route-pattern-normalizer.js

@@ -0,0 +1,111 @@
+import { __exports as routePatternNormalizer } from '../../../../_virtual/route-pattern-normalizer.js';
+
+var hasRequiredRoutePatternNormalizer;
+
+function requireRoutePatternNormalizer () {
+	if (hasRequiredRoutePatternNormalizer) return routePatternNormalizer;
+	hasRequiredRoutePatternNormalizer = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", {
+		    value: true
+		});
+		function _export(target, all) {
+		    for(var name in all)Object.defineProperty(target, name, {
+		        enumerable: true,
+		        get: all[name]
+		    });
+		}
+		_export(exports, {
+		    PARAM_SEPARATOR: function() {
+		        return PARAM_SEPARATOR;
+		    },
+		    hasAdjacentParameterIssues: function() {
+		        return hasAdjacentParameterIssues;
+		    },
+		    normalizeAdjacentParameters: function() {
+		        return normalizeAdjacentParameters;
+		    },
+		    normalizeTokensForRegexp: function() {
+		        return normalizeTokensForRegexp;
+		    },
+		    stripNormalizedSeparators: function() {
+		        return stripNormalizedSeparators;
+		    },
+		    stripParameterSeparators: function() {
+		        return stripParameterSeparators;
+		    }
+		});
+		const PARAM_SEPARATOR = '_NEXTSEP_';
+		function hasAdjacentParameterIssues(route) {
+		    if (typeof route !== 'string') return false;
+		    // Check for interception route markers followed immediately by parameters
+		    // Pattern: /(.):param, /(..):param, /(...):param, /(.)(.):param etc.
+		    // These patterns cause "Must have text between two parameters" errors
+		    if (/\/\(\.{1,3}\):[^/\s]+/.test(route)) {
+		        return true;
+		    }
+		    // Check for basic adjacent parameters without separators
+		    // Pattern: :param1:param2 (but not :param* or other URL patterns)
+		    if (/:[a-zA-Z_][a-zA-Z0-9_]*:[a-zA-Z_][a-zA-Z0-9_]*/.test(route)) {
+		        return true;
+		    }
+		    return false;
+		}
+		function normalizeAdjacentParameters(route) {
+		    let normalized = route;
+		    // Handle interception route patterns: (.):param -> (.)_NEXTSEP_:param
+		    normalized = normalized.replace(/(\([^)]*\)):([^/\s]+)/g, `$1${PARAM_SEPARATOR}:$2`);
+		    // Handle other adjacent parameter patterns: :param1:param2 -> :param1_NEXTSEP_:param2
+		    normalized = normalized.replace(/:([^:/\s)]+)(?=:)/g, `:$1${PARAM_SEPARATOR}`);
+		    return normalized;
+		}
+		function normalizeTokensForRegexp(tokens) {
+		    return tokens.map((token)=>{
+		        // Token union type: Token = string | TokenObject
+		        // Literal path segments are strings, parameters/wildcards are objects
+		        if (typeof token === 'object' && token !== null && // Not all token objects have 'modifier' property (e.g., simple text tokens)
+		        'modifier' in token && // Only repeating modifiers (* or +) cause the validation error
+		        // Other modifiers like '?' (optional) are fine
+		        (token.modifier === '*' || token.modifier === '+') && // Token objects can have different shapes depending on route pattern
+		        'prefix' in token && 'suffix' in token && // Both prefix and suffix must be empty strings
+		        // This is what causes the validation error in path-to-regexp
+		        token.prefix === '' && token.suffix === '') {
+		            // Add minimal prefix to satisfy path-to-regexp validation
+		            // We use '/' as it's the most common path delimiter and won't break route matching
+		            // The prefix gets used in regex generation but doesn't affect parameter extraction
+		            return {
+		                ...token,
+		                prefix: '/'
+		            };
+		        }
+		        return token;
+		    });
+		}
+		function stripNormalizedSeparators(pathname) {
+		    // Remove separator after interception route markers
+		    // Pattern: (.)_NEXTSEP_ -> (.), (..)_NEXTSEP_ -> (..), etc.
+		    // The separator appears after the closing paren of interception markers
+		    return pathname.replace(new RegExp(`\\)${PARAM_SEPARATOR}`, 'g'), ')');
+		}
+		function stripParameterSeparators(params) {
+		    const cleaned = {};
+		    for (const [key, value] of Object.entries(params)){
+		        if (typeof value === 'string') {
+		            // Remove the separator if it appears at the start of parameter values
+		            cleaned[key] = value.replace(new RegExp(`^${PARAM_SEPARATOR}`), '');
+		        } else if (Array.isArray(value)) {
+		            // Handle array parameters (from repeated route segments)
+		            cleaned[key] = value.map((item)=>typeof item === 'string' ? item.replace(new RegExp(`^${PARAM_SEPARATOR}`), '') : item);
+		        } else {
+		            cleaned[key] = value;
+		        }
+		    }
+		    return cleaned;
+		}
+
+		
+	} (routePatternNormalizer));
+	return routePatternNormalizer;
+}
+
+export { requireRoutePatternNormalizer as __require };

package/dist/node_modules/next/dist/server/api-utils/get-cookie-parser.cjs

@@ -0,0 +1,39 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const getCookieParser = require('../../../../../_virtual/get-cookie-parser.cjs');
+const index = require('../../compiled/cookie/index.cjs');
+
+var hasRequiredGetCookieParser;
+
+function requireGetCookieParser () {
+	if (hasRequiredGetCookieParser) return getCookieParser.__exports;
+	hasRequiredGetCookieParser = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", {
+		    value: true
+		});
+		Object.defineProperty(exports, "getCookieParser", {
+		    enumerable: true,
+		    get: function() {
+		        return getCookieParser;
+		    }
+		});
+		function getCookieParser(headers) {
+		    return function parseCookie() {
+		        const { cookie } = headers;
+		        if (!cookie) {
+		            return {};
+		        }
+		        const { parse: parseCookieFn } = index.__require();
+		        return parseCookieFn(Array.isArray(cookie) ? cookie.join('; ') : cookie);
+		    };
+		}
+
+		
+	} (getCookieParser.__exports));
+	return getCookieParser.__exports;
+}
+
+exports.__require = requireGetCookieParser;

package/dist/node_modules/next/dist/server/api-utils/get-cookie-parser.js

@@ -0,0 +1,35 @@
+import { __exports as getCookieParser } from '../../../../../_virtual/get-cookie-parser.js';
+import { __require as requireCookie } from '../../compiled/cookie/index.js';
+
+var hasRequiredGetCookieParser;
+
+function requireGetCookieParser () {
+	if (hasRequiredGetCookieParser) return getCookieParser;
+	hasRequiredGetCookieParser = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", {
+		    value: true
+		});
+		Object.defineProperty(exports, "getCookieParser", {
+		    enumerable: true,
+		    get: function() {
+		        return getCookieParser;
+		    }
+		});
+		function getCookieParser(headers) {
+		    return function parseCookie() {
+		        const { cookie } = headers;
+		        if (!cookie) {
+		            return {};
+		        }
+		        const { parse: parseCookieFn } = requireCookie();
+		        return parseCookieFn(Array.isArray(cookie) ? cookie.join('; ') : cookie);
+		    };
+		}
+
+		
+	} (getCookieParser));
+	return getCookieParser;
+}
+
+export { requireGetCookieParser as __require };

package/dist/node_modules/next/dist/shared/lib/bloom-filter.cjs

@@ -0,0 +1,101 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const bloomFilter = require('../../../../../_virtual/bloom-filter.cjs');
+const index = require('../../compiled/gzip-size/index.cjs');
+
+var hasRequiredBloomFilter;
+
+function requireBloomFilter () {
+	if (hasRequiredBloomFilter) return bloomFilter.__exports;
+	hasRequiredBloomFilter = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", {
+		    value: true
+		});
+		Object.defineProperty(exports, "BloomFilter", {
+		    enumerable: true,
+		    get: function() {
+		        return BloomFilter;
+		    }
+		});
+		function murmurhash2(str) {
+		    let h = 0;
+		    for(let i = 0; i < str.length; i++){
+		        const c = str.charCodeAt(i);
+		        h = Math.imul(h ^ c, 0x5bd1e995);
+		        h ^= h >>> 13;
+		        h = Math.imul(h, 0x5bd1e995);
+		    }
+		    return h >>> 0;
+		}
+		// default to 0.01% error rate as the filter compresses very well
+		const DEFAULT_ERROR_RATE = 0.0001;
+		class BloomFilter {
+		    constructor(numItems, errorRate = DEFAULT_ERROR_RATE){
+		        this.numItems = numItems;
+		        this.errorRate = errorRate;
+		        this.numBits = Math.ceil(-(numItems * Math.log(errorRate)) / (Math.log(2) * Math.log(2)));
+		        this.numHashes = Math.ceil(this.numBits / numItems * Math.log(2));
+		        this.bitArray = new Array(this.numBits).fill(0);
+		    }
+		    static from(items, errorRate = DEFAULT_ERROR_RATE) {
+		        const filter = new BloomFilter(items.length, errorRate);
+		        for (const item of items){
+		            filter.add(item);
+		        }
+		        return filter;
+		    }
+		    export() {
+		        const data = {
+		            numItems: this.numItems,
+		            errorRate: this.errorRate,
+		            numBits: this.numBits,
+		            numHashes: this.numHashes,
+		            bitArray: this.bitArray
+		        };
+		        if (process.env.NEXT_RUNTIME === 'nodejs') {
+		            if (this.errorRate < DEFAULT_ERROR_RATE) {
+		                const filterData = JSON.stringify(data);
+		                const gzipSize = index.__require().sync(filterData);
+		                if (gzipSize > 1024) {
+		                    console.warn(`Creating filter with error rate less than 0.1% (0.001) can increase the size dramatically proceed with caution. Received error rate ${this.errorRate} resulted in size ${filterData.length} bytes, ${gzipSize} bytes (gzip)`);
+		                }
+		            }
+		        }
+		        return data;
+		    }
+		    import(data) {
+		        this.numItems = data.numItems;
+		        this.errorRate = data.errorRate;
+		        this.numBits = data.numBits;
+		        this.numHashes = data.numHashes;
+		        this.bitArray = data.bitArray;
+		    }
+		    add(item) {
+		        const hashValues = this.getHashValues(item);
+		        hashValues.forEach((hash)=>{
+		            this.bitArray[hash] = 1;
+		        });
+		    }
+		    contains(item) {
+		        const hashValues = this.getHashValues(item);
+		        return hashValues.every((hash)=>this.bitArray[hash]);
+		    }
+		    getHashValues(item) {
+		        const hashValues = [];
+		        for(let i = 1; i <= this.numHashes; i++){
+		            const hash = murmurhash2(`${item}${i}`) % this.numBits;
+		            hashValues.push(hash);
+		        }
+		        return hashValues;
+		    }
+		}
+
+		
+	} (bloomFilter.__exports));
+	return bloomFilter.__exports;
+}
+
+exports.__require = requireBloomFilter;

package/dist/node_modules/next/dist/shared/lib/bloom-filter.js

@@ -0,0 +1,97 @@
+import { __exports as bloomFilter } from '../../../../../_virtual/bloom-filter.js';
+import { __require as requireGzipSize } from '../../compiled/gzip-size/index.js';
+
+var hasRequiredBloomFilter;
+
+function requireBloomFilter () {
+	if (hasRequiredBloomFilter) return bloomFilter;
+	hasRequiredBloomFilter = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", {
+		    value: true
+		});
+		Object.defineProperty(exports, "BloomFilter", {
+		    enumerable: true,
+		    get: function() {
+		        return BloomFilter;
+		    }
+		});
+		function murmurhash2(str) {
+		    let h = 0;
+		    for(let i = 0; i < str.length; i++){
+		        const c = str.charCodeAt(i);
+		        h = Math.imul(h ^ c, 0x5bd1e995);
+		        h ^= h >>> 13;
+		        h = Math.imul(h, 0x5bd1e995);
+		    }
+		    return h >>> 0;
+		}
+		// default to 0.01% error rate as the filter compresses very well
+		const DEFAULT_ERROR_RATE = 0.0001;
+		class BloomFilter {
+		    constructor(numItems, errorRate = DEFAULT_ERROR_RATE){
+		        this.numItems = numItems;
+		        this.errorRate = errorRate;
+		        this.numBits = Math.ceil(-(numItems * Math.log(errorRate)) / (Math.log(2) * Math.log(2)));
+		        this.numHashes = Math.ceil(this.numBits / numItems * Math.log(2));
+		        this.bitArray = new Array(this.numBits).fill(0);
+		    }
+		    static from(items, errorRate = DEFAULT_ERROR_RATE) {
+		        const filter = new BloomFilter(items.length, errorRate);
+		        for (const item of items){
+		            filter.add(item);
+		        }
+		        return filter;
+		    }
+		    export() {
+		        const data = {
+		            numItems: this.numItems,
+		            errorRate: this.errorRate,
+		            numBits: this.numBits,
+		            numHashes: this.numHashes,
+		            bitArray: this.bitArray
+		        };
+		        if (process.env.NEXT_RUNTIME === 'nodejs') {
+		            if (this.errorRate < DEFAULT_ERROR_RATE) {
+		                const filterData = JSON.stringify(data);
+		                const gzipSize = requireGzipSize().sync(filterData);
+		                if (gzipSize > 1024) {
+		                    console.warn(`Creating filter with error rate less than 0.1% (0.001) can increase the size dramatically proceed with caution. Received error rate ${this.errorRate} resulted in size ${filterData.length} bytes, ${gzipSize} bytes (gzip)`);
+		                }
+		            }
+		        }
+		        return data;
+		    }
+		    import(data) {
+		        this.numItems = data.numItems;
+		        this.errorRate = data.errorRate;
+		        this.numBits = data.numBits;
+		        this.numHashes = data.numHashes;
+		        this.bitArray = data.bitArray;
+		    }
+		    add(item) {
+		        const hashValues = this.getHashValues(item);
+		        hashValues.forEach((hash)=>{
+		            this.bitArray[hash] = 1;
+		        });
+		    }
+		    contains(item) {
+		        const hashValues = this.getHashValues(item);
+		        return hashValues.every((hash)=>this.bitArray[hash]);
+		    }
+		    getHashValues(item) {
+		        const hashValues = [];
+		        for(let i = 1; i <= this.numHashes; i++){
+		            const hash = murmurhash2(`${item}${i}`) % this.numBits;
+		            hashValues.push(hash);
+		        }
+		        return hashValues;
+		    }
+		}
+
+		
+	} (bloomFilter));
+	return bloomFilter;
+}
+
+export { requireBloomFilter as __require };

package/dist/node_modules/next/dist/shared/lib/encode-uri-path.cjs

@@ -0,0 +1,31 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const encodeUriPath = require('../../../../../_virtual/encode-uri-path.cjs');
+
+var hasRequiredEncodeUriPath;
+
+function requireEncodeUriPath () {
+	if (hasRequiredEncodeUriPath) return encodeUriPath.__exports;
+	hasRequiredEncodeUriPath = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", {
+		    value: true
+		});
+		Object.defineProperty(exports, "encodeURIPath", {
+		    enumerable: true,
+		    get: function() {
+		        return encodeURIPath;
+		    }
+		});
+		function encodeURIPath(file) {
+		    return file.split('/').map((p)=>encodeURIComponent(p)).join('/');
+		}
+
+		
+	} (encodeUriPath.__exports));
+	return encodeUriPath.__exports;
+}
+
+exports.__require = requireEncodeUriPath;

package/dist/node_modules/next/dist/shared/lib/encode-uri-path.js

@@ -0,0 +1,27 @@
+import { __exports as encodeUriPath } from '../../../../../_virtual/encode-uri-path.js';
+
+var hasRequiredEncodeUriPath;
+
+function requireEncodeUriPath () {
+	if (hasRequiredEncodeUriPath) return encodeUriPath;
+	hasRequiredEncodeUriPath = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", {
+		    value: true
+		});
+		Object.defineProperty(exports, "encodeURIPath", {
+		    enumerable: true,
+		    get: function() {
+		        return encodeURIPath;
+		    }
+		});
+		function encodeURIPath(file) {
+		    return file.split('/').map((p)=>encodeURIComponent(p)).join('/');
+		}
+
+		
+	} (encodeUriPath));
+	return encodeUriPath;
+}
+
+export { requireEncodeUriPath as __require };

package/dist/node_modules/next/dist/shared/lib/escape-regexp.cjs

@@ -0,0 +1,37 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const escapeRegexp = require('../../../../../_virtual/escape-regexp.cjs');
+
+var hasRequiredEscapeRegexp;
+
+function requireEscapeRegexp () {
+	if (hasRequiredEscapeRegexp) return escapeRegexp.__exports;
+	hasRequiredEscapeRegexp = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", {
+		    value: true
+		});
+		Object.defineProperty(exports, "escapeStringRegexp", {
+		    enumerable: true,
+		    get: function() {
+		        return escapeStringRegexp;
+		    }
+		});
+		const reHasRegExp = /[|\\{}()[\]^$+*?.-]/;
+		const reReplaceRegExp = /[|\\{}()[\]^$+*?.-]/g;
+		function escapeStringRegexp(str) {
+		    // see also: https://github.com/lodash/lodash/blob/2da024c3b4f9947a48517639de7560457cd4ec6c/escapeRegExp.js#L23
+		    if (reHasRegExp.test(str)) {
+		        return str.replace(reReplaceRegExp, '\\$&');
+		    }
+		    return str;
+		}
+
+		
+	} (escapeRegexp.__exports));
+	return escapeRegexp.__exports;
+}
+
+exports.__require = requireEscapeRegexp;

package/dist/node_modules/next/dist/shared/lib/escape-regexp.js

@@ -0,0 +1,33 @@
+import { __exports as escapeRegexp } from '../../../../../_virtual/escape-regexp.js';
+
+var hasRequiredEscapeRegexp;
+
+function requireEscapeRegexp () {
+	if (hasRequiredEscapeRegexp) return escapeRegexp;
+	hasRequiredEscapeRegexp = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", {
+		    value: true
+		});
+		Object.defineProperty(exports, "escapeStringRegexp", {
+		    enumerable: true,
+		    get: function() {
+		        return escapeStringRegexp;
+		    }
+		});
+		const reHasRegExp = /[|\\{}()[\]^$+*?.-]/;
+		const reReplaceRegExp = /[|\\{}()[\]^$+*?.-]/g;
+		function escapeStringRegexp(str) {
+		    // see also: https://github.com/lodash/lodash/blob/2da024c3b4f9947a48517639de7560457cd4ec6c/escapeRegExp.js#L23
+		    if (reHasRegExp.test(str)) {
+		        return str.replace(reReplaceRegExp, '\\$&');
+		    }
+		    return str;
+		}
+
+		
+	} (escapeRegexp));
+	return escapeRegexp;
+}
+
+export { requireEscapeRegexp as __require };

package/dist/node_modules/next/dist/shared/lib/head-manager-context.shared-runtime.cjs

@@ -0,0 +1,36 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const headManagerContext_sharedRuntime = require('../../../../../_virtual/head-manager-context.shared-runtime.cjs');
+const _interop_require_default = require('../../../../@swc/helpers/cjs/_interop_require_default.cjs');
+const React = require('react');
+
+var hasRequiredHeadManagerContext_sharedRuntime;
+
+function requireHeadManagerContext_sharedRuntime () {
+	if (hasRequiredHeadManagerContext_sharedRuntime) return headManagerContext_sharedRuntime.__exports;
+	hasRequiredHeadManagerContext_sharedRuntime = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", {
+		    value: true
+		});
+		Object.defineProperty(exports, "HeadManagerContext", {
+		    enumerable: true,
+		    get: function() {
+		        return HeadManagerContext;
+		    }
+		});
+		const _interop_require_default$1 = /*@__PURE__*/ _interop_require_default.__require();
+		const _react = /*#__PURE__*/ _interop_require_default$1._(React);
+		const HeadManagerContext = _react.default.createContext({});
+		if (process.env.NODE_ENV !== 'production') {
+		    HeadManagerContext.displayName = 'HeadManagerContext';
+		}
+
+		
+	} (headManagerContext_sharedRuntime.__exports));
+	return headManagerContext_sharedRuntime.__exports;
+}
+
+exports.__require = requireHeadManagerContext_sharedRuntime;