From 9bce51f651aad297ef9eb6df832bfdaf1de05d84 Mon Sep 17 00:00:00 2001
From: WXL <wl_5969728@163.com>
Date: 星期三, 22 四月 2026 14:27:54 +0800
Subject: [PATCH] 青岛推送
---
node_modules/webpack/lib/util/identifier.js | 127 ++++++++++++++++++++++++++++++++++++------
1 files changed, 108 insertions(+), 19 deletions(-)
diff --git a/node_modules/webpack/lib/util/identifier.js b/node_modules/webpack/lib/util/identifier.js
index 1bcdc51..5d24e71 100644
--- a/node_modules/webpack/lib/util/identifier.js
+++ b/node_modules/webpack/lib/util/identifier.js
@@ -6,11 +6,12 @@
const path = require("path");
-const WINDOWS_ABS_PATH_REGEXP = /^[a-zA-Z]:[\\/]/;
+const WINDOWS_ABS_PATH_REGEXP = /^[a-z]:[\\/]/i;
const SEGMENTS_SPLIT_REGEXP = /([|!])/;
const WINDOWS_PATH_SEPARATOR_REGEXP = /\\/g;
/**
+ * Relative path to request.
* @param {string} relativePath relative path
* @returns {string} request
*/
@@ -22,6 +23,7 @@
};
/**
+ * Absolute to request.
* @param {string} context context for relative path
* @param {string} maybeAbsolutePath path to make relative
* @returns {string} relative path in request style
@@ -70,6 +72,7 @@
};
/**
+ * Request to absolute.
* @param {string} context context for relative path
* @param {string} relativePath path
* @returns {string} absolute path
@@ -84,27 +87,32 @@
/** @typedef {EXPECTED_OBJECT} AssociatedObjectForCache */
/**
+ * Defines the make cacheable result type used by this module.
* @template T
* @typedef {(value: string, cache?: AssociatedObjectForCache) => T} MakeCacheableResult
*/
/**
+ * Defines the bind cache result fn type used by this module.
* @template T
* @typedef {(value: string) => T} BindCacheResultFn
*/
/**
+ * Defines the bind cache type used by this module.
* @template T
* @typedef {(cache: AssociatedObjectForCache) => BindCacheResultFn<T>} BindCache
*/
/**
+ * Returns } cacheable function.
* @template T
* @param {((value: string) => T)} realFn real function
* @returns {MakeCacheableResult<T> & { bindCache: BindCache<T> }} cacheable function
*/
const makeCacheable = (realFn) => {
/**
+ * Defines the cache item type used by this module.
* @template T
* @typedef {Map<string, T>} CacheItem
*/
@@ -112,6 +120,7 @@
const cache = new WeakMap();
/**
+ * Returns cache item.
* @param {AssociatedObjectForCache} associatedObjectForCache an object to which the cache will be attached
* @returns {CacheItem<T>} cache item
*/
@@ -139,6 +148,7 @@
fn.bindCache = (associatedObjectForCache) => {
const cache = getCache(associatedObjectForCache);
/**
+ * Returns value.
* @param {string} str string
* @returns {T} value
*/
@@ -161,11 +171,13 @@
/** @typedef {(value: string, associatedObjectForCache?: AssociatedObjectForCache) => BindContextCacheForContextResultFn} BindContextCacheForContext */
/**
+ * Creates cacheable with context.
* @param {(context: string, identifier: string) => string} fn function
* @returns {MakeCacheableWithContextResult & { bindCache: BindCacheForContext, bindContextCache: BindContextCacheForContext }} cacheable function with context
*/
const makeCacheableWithContext = (fn) => {
- /** @type {WeakMap<AssociatedObjectForCache, Map<string, Map<string, string>>>} */
+ /** @typedef {Map<string, Map<string, string>>} InnerCache */
+ /** @type {WeakMap<AssociatedObjectForCache, InnerCache>} */
const cache = new WeakMap();
/** @type {MakeCacheableWithContextResult & { bindCache: BindCacheForContext, bindContextCache: BindContextCacheForContext }} */
@@ -178,6 +190,7 @@
cache.set(associatedObjectForCache, innerCache);
}
+ /** @type {undefined | string} */
let cachedResult;
let innerSubCache = innerCache.get(context);
if (innerSubCache === undefined) {
@@ -196,6 +209,7 @@
/** @type {BindCacheForContext} */
cachedFn.bindCache = (associatedObjectForCache) => {
+ /** @type {undefined | InnerCache} */
let innerCache;
if (associatedObjectForCache) {
innerCache = cache.get(associatedObjectForCache);
@@ -208,11 +222,13 @@
}
/**
+ * Returns the returned relative path.
* @param {string} context context used to create relative path
* @param {string} identifier identifier used to create relative path
* @returns {string} the returned relative path
*/
const boundFn = (context, identifier) => {
+ /** @type {undefined | string} */
let cachedResult;
let innerSubCache = innerCache.get(context);
if (innerSubCache === undefined) {
@@ -234,6 +250,7 @@
/** @type {BindContextCacheForContext} */
cachedFn.bindContextCache = (context, associatedObjectForCache) => {
+ /** @type {undefined | Map<string, string>} */
let innerSubCache;
if (associatedObjectForCache) {
let innerCache = cache.get(associatedObjectForCache);
@@ -251,6 +268,7 @@
}
/**
+ * Returns the returned relative path.
* @param {string} identifier identifier used to create relative path
* @returns {string} the returned relative path
*/
@@ -271,6 +289,7 @@
};
/**
+ * Make paths relative.
* @param {string} context context for relative path
* @param {string} identifier identifier for path
* @returns {string} a converted relative path
@@ -282,6 +301,7 @@
.join("");
/**
+ * Make paths absolute.
* @param {string} context context for relative path
* @param {string} identifier identifier for path
* @returns {string} a converted relative path
@@ -293,6 +313,7 @@
.join("");
/**
+ * Returns a new request string avoiding absolute paths when possible.
* @param {string} context absolute context path
* @param {string} request any request string may containing absolute paths, query string, etc.
* @returns {string} a new request string avoiding absolute paths when possible
@@ -306,6 +327,7 @@
const contextify = makeCacheableWithContext(_contextify);
/**
+ * Returns a new request string using absolute paths when possible.
* @param {string} context absolute context path
* @param {string} request any request string
* @returns {string} a new request string using absolute paths when possible
@@ -321,24 +343,67 @@
const PATH_QUERY_FRAGMENT_REGEXP =
/^((?:\0.|[^?#\0])*)(\?(?:\0.|[^#\0])*)?(#.*)?$/;
const PATH_QUERY_REGEXP = /^((?:\0.|[^?\0])*)(\?.*)?$/;
+const ZERO_ESCAPE_REGEXP = /\0(.)/g;
/** @typedef {{ resource: string, path: string, query: string, fragment: string }} ParsedResource */
/** @typedef {{ resource: string, path: string, query: string }} ParsedResourceWithoutFragment */
/**
+ * Returns parsed parts.
* @param {string} str the path with query and fragment
* @returns {ParsedResource} parsed parts
*/
const _parseResource = (str) => {
- const match =
- /** @type {[string, string, string | undefined, string | undefined]} */
- (/** @type {unknown} */ (PATH_QUERY_FRAGMENT_REGEXP.exec(str)));
- return {
- resource: str,
- path: match[1].replace(/\0(.)/g, "$1"),
- query: match[2] ? match[2].replace(/\0(.)/g, "$1") : "",
- fragment: match[3] || ""
- };
+ const firstEscape = str.indexOf("\0");
+
+ // Handle `\0`
+ if (firstEscape !== -1) {
+ const match =
+ /** @type {[string, string, string | undefined, string | undefined]} */
+ (/** @type {unknown} */ (PATH_QUERY_FRAGMENT_REGEXP.exec(str)));
+
+ return {
+ resource: str,
+ path: match[1].replace(ZERO_ESCAPE_REGEXP, "$1"),
+ query: match[2] ? match[2].replace(ZERO_ESCAPE_REGEXP, "$1") : "",
+ fragment: match[3] || ""
+ };
+ }
+
+ /** @type {ParsedResource} */
+ const result = { resource: str, path: "", query: "", fragment: "" };
+ const queryStart = str.indexOf("?");
+ const fragmentStart = str.indexOf("#");
+
+ if (fragmentStart < 0) {
+ if (queryStart < 0) {
+ result.path = result.resource;
+
+ // No fragment, no query
+ return result;
+ }
+
+ result.path = str.slice(0, queryStart);
+ result.query = str.slice(queryStart);
+
+ // Query, no fragment
+ return result;
+ }
+
+ if (queryStart < 0 || fragmentStart < queryStart) {
+ result.path = str.slice(0, fragmentStart);
+ result.fragment = str.slice(fragmentStart);
+
+ // Fragment, no query
+ return result;
+ }
+
+ result.path = str.slice(0, queryStart);
+ result.query = str.slice(queryStart, fragmentStart);
+ result.fragment = str.slice(fragmentStart);
+
+ // Query and fragment
+ return result;
};
/**
@@ -347,17 +412,41 @@
* @returns {ParsedResourceWithoutFragment} parsed parts
*/
const _parseResourceWithoutFragment = (str) => {
- const match =
- /** @type {[string, string, string | undefined]} */
- (/** @type {unknown} */ (PATH_QUERY_REGEXP.exec(str)));
- return {
- resource: str,
- path: match[1].replace(/\0(.)/g, "$1"),
- query: match[2] ? match[2].replace(/\0(.)/g, "$1") : ""
- };
+ const firstEscape = str.indexOf("\0");
+
+ // Handle `\0`
+ if (firstEscape !== -1) {
+ const match =
+ /** @type {[string, string, string | undefined]} */
+ (/** @type {unknown} */ (PATH_QUERY_REGEXP.exec(str)));
+
+ return {
+ resource: str,
+ path: match[1].replace(ZERO_ESCAPE_REGEXP, "$1"),
+ query: match[2] ? match[2].replace(ZERO_ESCAPE_REGEXP, "$1") : ""
+ };
+ }
+
+ /** @type {ParsedResourceWithoutFragment} */
+ const result = { resource: str, path: "", query: "" };
+ const queryStart = str.indexOf("?");
+
+ if (queryStart < 0) {
+ result.path = result.resource;
+
+ // No query
+ return result;
+ }
+
+ result.path = str.slice(0, queryStart);
+ result.query = str.slice(queryStart);
+
+ // Query
+ return result;
};
/**
+ * Returns repeated ../ to leave the directory of the provided filename to be back on output dir.
* @param {string} filename the filename which should be undone
* @param {string} outputPath the output path that is restored (only relevant when filename contains "..")
* @param {boolean} enforceRelative true returns ./ for empty paths
--
Gitblit v1.9.3