@rsdoctor/types 1.5.2 → 1.5.3

package/dist/index.cjs

@@ -0,0 +1,549 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    Config: ()=>config_namespaceObject,
+    Linter: ()=>linter_namespaceObject,
+    Babel: ()=>babel_namespaceObject,
+    Modules: ()=>modules_namespaceObject,
+    Constants: ()=>constants_namespaceObject,
+    Err: ()=>error_namespaceObject,
+    Plugin: ()=>plugin_namespaceObject,
+    Rule: ()=>rule_namespaceObject,
+    Manifest: ()=>manifest_namespaceObject,
+    SDK: ()=>sdk_namespaceObject,
+    Logger: ()=>logger_namespaceObject,
+    Client: ()=>client_namespaceObject,
+    Esbuild: ()=>esbuild_namespaceObject,
+    Thirdparty: ()=>thirdparty_namespaceObject,
+    Common: ()=>common_namespaceObject
+});
+var manifest_namespaceObject = {};
+__webpack_require__.r(manifest_namespaceObject);
+__webpack_require__.d(manifest_namespaceObject, {
+    RsdoctorManifestClientConstant: ()=>manifest_RsdoctorManifestClientConstant,
+    RsdoctorManifestClientRoutes: ()=>manifest_RsdoctorManifestClientRoutes
+});
+var esbuild_namespaceObject = {};
+__webpack_require__.r(esbuild_namespaceObject);
+var babel_namespaceObject = {};
+__webpack_require__.r(babel_namespaceObject);
+var common_namespaceObject = {};
+__webpack_require__.r(common_namespaceObject);
+var error_namespaceObject = {};
+__webpack_require__.r(error_namespaceObject);
+__webpack_require__.d(error_namespaceObject, {
+    ErrorLevel: ()=>error_ErrorLevel
+});
+var logger_namespaceObject = {};
+__webpack_require__.r(logger_namespaceObject);
+__webpack_require__.d(logger_namespaceObject, {
+    LogLevel: ()=>logger_LogLevel
+});
+var apis_namespaceObject = {};
+__webpack_require__.r(apis_namespaceObject);
+__webpack_require__.d(apis_namespaceObject, {
+    API: ()=>apis_API,
+    APIExtends: ()=>apis_APIExtends
+});
+var sdk_namespaceObject = {};
+__webpack_require__.r(sdk_namespaceObject);
+__webpack_require__.d(sdk_namespaceObject, {
+    DependencyKind: ()=>module_DependencyKind,
+    IMode: ()=>instance_IMode,
+    ModuleKind: ()=>module_ModuleKind,
+    ServerAPI: ()=>apis_namespaceObject,
+    StatementKind: ()=>statement_StatementKind,
+    ToDataType: ()=>module_ToDataType
+});
+var modules_namespaceObject = {};
+__webpack_require__.r(modules_namespaceObject);
+var linter_namespaceObject = {};
+__webpack_require__.r(linter_namespaceObject);
+__webpack_require__.d(linter_namespaceObject, {
+    Severity: ()=>error_ErrorLevel
+});
+var rule_namespaceObject = {};
+__webpack_require__.r(rule_namespaceObject);
+__webpack_require__.d(rule_namespaceObject, {
+    RsdoctorRuleClientConstant: ()=>code_RsdoctorRuleClientConstant,
+    RuleErrorMap: ()=>RuleErrorMap,
+    RuleMessageCategory: ()=>type_RuleMessageCategory,
+    RuleMessageCodeEnumerated: ()=>type_RuleMessageCodeEnumerated
+});
+var thirdparty_namespaceObject = {};
+__webpack_require__.r(thirdparty_namespaceObject);
+var client_namespaceObject = {};
+__webpack_require__.r(client_namespaceObject);
+__webpack_require__.d(client_namespaceObject, {
+    RsdoctorClientDiffState: ()=>client_RsdoctorClientDiffState,
+    RsdoctorClientRoutes: ()=>client_RsdoctorClientRoutes,
+    RsdoctorClientUrlQuery: ()=>client_RsdoctorClientUrlQuery
+});
+var constants_namespaceObject = {};
+__webpack_require__.r(constants_namespaceObject);
+__webpack_require__.d(constants_namespaceObject, {
+    BundleExtension: ()=>BundleExtension,
+    CSSExtension: ()=>CSSExtension,
+    FontExtensions: ()=>FontExtensions,
+    HtmlExtension: ()=>HtmlExtension,
+    ImgExtensions: ()=>ImgExtensions,
+    JSExtension: ()=>JSExtension,
+    JSExtensions: ()=>JSExtensions,
+    MapExtensions: ()=>MapExtensions,
+    MediaExtensions: ()=>MediaExtensions,
+    RsdoctorClientUrl: ()=>RsdoctorClientUrl,
+    RsdoctorMonitorDocBId: ()=>RsdoctorMonitorDocBId,
+    RsdoctorMonitorNodeBId: ()=>RsdoctorMonitorNodeBId,
+    RsdoctorMonitorWebBId: ()=>RsdoctorMonitorWebBId,
+    RsdoctorOutputFolder: ()=>RsdoctorOutputFolder,
+    RsdoctorOutputManifest: ()=>RsdoctorOutputManifest,
+    RsdoctorOutputManifestPath: ()=>RsdoctorOutputManifestPath,
+    RsdoctorProcessEnvDebugKey: ()=>RsdoctorProcessEnvDebugKey,
+    StatsFilePath: ()=>StatsFilePath,
+    WINDOW_RSDOCTOR_TAG: ()=>WINDOW_RSDOCTOR_TAG
+});
+var plugin_namespaceObject = {};
+__webpack_require__.r(plugin_namespaceObject);
+var config_namespaceObject = {};
+__webpack_require__.r(config_namespaceObject);
+var manifest_RsdoctorManifestClientRoutes = /*#__PURE__*/ function(RsdoctorManifestClientRoutes) {
+    RsdoctorManifestClientRoutes["Overall"] = "Overall";
+    RsdoctorManifestClientRoutes["WebpackLoaders"] = "Compile.WebpackLoaders";
+    RsdoctorManifestClientRoutes["ModuleResolve"] = "Compile.ModuleResolve";
+    RsdoctorManifestClientRoutes["WebpackPlugins"] = "Compile.WebpackPlugins";
+    RsdoctorManifestClientRoutes["BundleSize"] = "Bundle.BundleSize";
+    RsdoctorManifestClientRoutes["ModuleGraph"] = "Bundle.ModuleGraph";
+    RsdoctorManifestClientRoutes["TreeShaking"] = "Bundle.TreeShaking";
+    return RsdoctorManifestClientRoutes;
+}({});
+var manifest_RsdoctorManifestClientConstant = /*#__PURE__*/ function(RsdoctorManifestClientConstant) {
+    RsdoctorManifestClientConstant["WindowPropertyForManifestUrl"] = "__DEVTOOLS_MANIFEST_URL__";
+    return RsdoctorManifestClientConstant;
+}({});
+var error_ErrorLevel = /*#__PURE__*/ function(ErrorLevel) {
+    ErrorLevel[ErrorLevel["Ignore"] = 0] = "Ignore";
+    ErrorLevel[ErrorLevel["Warn"] = 1] = "Warn";
+    ErrorLevel[ErrorLevel["Error"] = 2] = "Error";
+    return ErrorLevel;
+}({});
+var logger_LogLevel = /*#__PURE__*/ function(LogLevel) {
+    LogLevel[LogLevel["Silent"] = 0] = "Silent";
+    LogLevel[LogLevel["Error"] = 1] = "Error";
+    LogLevel[LogLevel["Warning"] = 2] = "Warning";
+    LogLevel[LogLevel["Info"] = 3] = "Info";
+    LogLevel[LogLevel["Debug"] = 4] = "Debug";
+    LogLevel[LogLevel["Verbose"] = 5] = "Verbose";
+    return LogLevel;
+}({});
+var module_DependencyKind = /*#__PURE__*/ function(DependencyKind) {
+    DependencyKind[DependencyKind["Unknown"] = 0] = "Unknown";
+    DependencyKind[DependencyKind["ImportStatement"] = 1] = "ImportStatement";
+    DependencyKind[DependencyKind["DynamicImport"] = 2] = "DynamicImport";
+    DependencyKind[DependencyKind["RequireCall"] = 3] = "RequireCall";
+    DependencyKind[DependencyKind["AMDRequire"] = 4] = "AMDRequire";
+    return DependencyKind;
+}({});
+var module_ModuleKind = /*#__PURE__*/ function(ModuleKind) {
+    ModuleKind[ModuleKind["Normal"] = 0] = "Normal";
+    ModuleKind[ModuleKind["Concatenation"] = 1] = "Concatenation";
+    return ModuleKind;
+}({});
+var module_ToDataType = /*#__PURE__*/ function(ToDataType) {
+    ToDataType[ToDataType["NoCode"] = 0] = "NoCode";
+    ToDataType[ToDataType["Normal"] = 1] = "Normal";
+    ToDataType[ToDataType["NoSource"] = 2] = "NoSource";
+    ToDataType[ToDataType["NoSourceAndAssets"] = 3] = "NoSourceAndAssets";
+    ToDataType[ToDataType["All"] = 4] = "All";
+    return ToDataType;
+}({});
+var apis_API = /*#__PURE__*/ function(API) {
+    API["ApplyErrorFix"] = "/api/apply/error/fix";
+    API["Env"] = "/api/env";
+    API["EntryHtml"] = "/index.html";
+    API["Manifest"] = "/api/manifest.json";
+    API["LoadDataByKey"] = "/api/data/key";
+    API["SendAPIDataToClient"] = "/api/socket/send";
+    API["GetProjectInfo"] = "/api/project/info";
+    API["GetClientRoutes"] = "/api/routes";
+    API["ReportLoader"] = "/api/loader/report";
+    API["GetLoaderNames"] = "/api/loader/names";
+    API["GetLoaderChartData"] = "/api/loader/chart/data";
+    API["GetLoaderFileTree"] = "/api/loader/filetree";
+    API["GetLoaderFileDetails"] = "/api/loader/file";
+    API["GetLoaderFolderStatistics"] = "/api/loader/folder/statics";
+    API["GetLoaderFileFirstInput"] = "/api/loader/input";
+    API["GetLoaderFileInputAndOutput"] = "/api/loader/inputandoutput";
+    API["GetDirectoriesLoaders"] = "/api/loader/directories";
+    API["ReportSourceMap"] = "/api/sourcemap/report";
+    API["GetResolverFileTree"] = "/api/resolver/filetree";
+    API["GetResolverFileDetails"] = "/api/resolver/file";
+    API["GetPluginSummary"] = "/api/plugins/summary";
+    API["GetPluginData"] = "/api/plugins/data";
+    API["GetSummaryBundles"] = "/api/graph/bundles/summary";
+    API["GetChunkGraph"] = "/api/graph/chunks/graph";
+    API["GetAssetsSummary"] = "/api/graph/assets/summary";
+    API["GetAssetDetails"] = "/api/graph/asset/details";
+    API["GetChunksByModuleId"] = "/api/graph/chunk/module";
+    API["GetModuleDetails"] = "/api/graph/module/details";
+    API["GetModulesByModuleIds"] = "/api/graph/modules/ids";
+    API["GetEntryPoints"] = "/api/graph/entrypoints";
+    API["GetModuleCodeByModuleId"] = "/api/graph/module/code";
+    API["GetModuleCodeByModuleIds"] = "/api/graph/module/codes";
+    API["GetAllModuleGraph"] = "/api/graph/module/all";
+    API["GetAllChunkGraph"] = "/api/graph/chunk/all";
+    API["GetLayers"] = "/api/graph/layers";
+    API["GetSearchModules"] = "/api/search/modules";
+    API["GetSearchModuleInChunk"] = "/api/search/chunk/modules";
+    API["GetAllModuleGraphFilter"] = "/api/graph/module/filter";
+    API["GetModuleByName"] = "/api/graph/module/name";
+    API["GetModuleIssuerPath"] = "/api/graph/module/issuer_path";
+    API["GetPackageInfo"] = "/api/package/info";
+    API["GetPackageDependency"] = "/api/package/dependency";
+    API["GetPackageRelationAlertDetails"] = "/api/alerts/details/package/relation";
+    API["GetOverlayAlerts"] = "/api/alerts/overlay";
+    API["GetBundleAlerts"] = "/api/alerts/bundle";
+    API["BundleDiffManifest"] = "/api/bundle_diff/manifest.json";
+    API["GetBundleDiffSummary"] = "/api/bundle_diff/summary";
+    API["GetChunkGraphAI"] = "/api/graph/chunks/graph/ai";
+    API["GetChunkByIdAI"] = "/api/graph/chunk/id/ai";
+    return API;
+}({});
+var apis_APIExtends = /*#__PURE__*/ function(APIExtends) {
+    APIExtends["GetCompileProgress"] = "/api/progress";
+    return APIExtends;
+}({});
+var statement_StatementKind = /*#__PURE__*/ function(StatementKind) {
+    StatementKind[StatementKind["ImportDefault"] = 100] = "ImportDefault";
+    StatementKind[StatementKind["ImportNamed"] = 101] = "ImportNamed";
+    StatementKind[StatementKind["ImportDefaultWithNamed"] = 102] = "ImportDefaultWithNamed";
+    StatementKind[StatementKind["ImportDefaultWithNamespace"] = 103] = "ImportDefaultWithNamespace";
+    StatementKind[StatementKind["ImportNamespace"] = 104] = "ImportNamespace";
+    StatementKind[StatementKind["ImportSideEffect"] = 105] = "ImportSideEffect";
+    StatementKind[StatementKind["ImportDynamic"] = 106] = "ImportDynamic";
+    StatementKind[StatementKind["ExportDeclaration"] = 200] = "ExportDeclaration";
+    StatementKind[StatementKind["ExportList"] = 201] = "ExportList";
+    StatementKind[StatementKind["ExportDefault"] = 202] = "ExportDefault";
+    StatementKind[StatementKind["ExportAggregating"] = 203] = "ExportAggregating";
+    StatementKind[StatementKind["ExportNamespace"] = 204] = "ExportNamespace";
+    StatementKind[StatementKind["RequireCall"] = 300] = "RequireCall";
+    StatementKind[StatementKind["RequireName"] = 301] = "RequireName";
+    StatementKind[StatementKind["RequireExports"] = 302] = "RequireExports";
+    StatementKind[StatementKind["RequireExportAggregating"] = 303] = "RequireExportAggregating";
+    StatementKind[StatementKind["RequireExportName"] = 304] = "RequireExportName";
+    StatementKind[StatementKind["Unknown"] = 999] = "Unknown";
+    return StatementKind;
+}({});
+var instance_IMode = /*#__PURE__*/ function(IMode) {
+    IMode["brief"] = "brief";
+    IMode["lite"] = "lite";
+    IMode["normal"] = "normal";
+    return IMode;
+}({});
+const code = 'E1001';
+const message = {
+    code,
+    title: 'Duplicate Packages',
+    type: 'markdown',
+    category: 'bundle',
+    description: `
+#### Description
+
+There is a same name package which is bundled in multiple versions in your application.
+
+This negatively impacts the bundle size of your application.
+
+#### General Solution
+
+Add an entry in \`resolve.alias\` to configure Webpack to route any package references to a single specified path.
+
+For example, if \`lodash\` is duplicated in your bundle, the following configuration would make all Lodash imports refer to the \`lodash\` instance found at \`./node_modules/lodash\`:
+
+\`\`\`js
+{
+  alias: {
+    lodash: path.resolve(__dirname, 'node_modules/lodash')
+  }
+}
+\`\`\`
+`
+};
+const E1002_code = 'E1002';
+const E1002_message = {
+    code: E1002_code,
+    title: 'Cross Chunks Packages',
+    type: 'markdown',
+    category: 'bundle',
+    description: `
+#### Description
+
+There is a package with the same version that is duplicated across different chunks in your application. This redundancy increases the overall bundle size, which is not optimal for performance.
+
+#### General Solution
+
+To address this issue, you can use Rspack's **SplitChunksPlugin** to extract common dependencies into a separate chunk. This ensures that the same package is not duplicated across multiple chunks, thereby reducing the bundle size.
+
+For example, if **lodash** is being duplicated across different chunks, you can configure the **optimization.splitChunks** option in your Webpack configuration to extract **lodash** into a separate chunk:
+
+\`\`\`
+module.exports = {
+  optimization: {
+    splitChunks: {
+      cacheGroups: {
+        commons: {
+          test: /[\\/]node_modules[\\/]lodash[\\/]/,
+          name: 'lodash',
+          chunks: 'all',
+        },
+      },
+    },
+  },
+};
+\`\`\`
+
+This configuration will automatically split out common dependencies (including those from \`node_modules\`) into separate chunks, ensuring that no package is duplicated across different chunks.
+`
+};
+const E1003_code = 'E1003';
+const E1003_message = {
+    code: E1003_code,
+    title: 'Loader Performance Optimization',
+    type: 'markdown',
+    category: 'compile',
+    description: `
+#### Description
+
+Usually the slow compile of most projects is due to the slow execution of the loaders.
+
+And the loaders always pre-process many unnecessary files, such as \`node_modules files\` and \`already compiled files\`.
+
+#### General Solution
+
+Set \`exclude\` to the \`module.rules\` of webpack configuration for target loader.
+
+For example, if \`node_modules/lodash\` is processed by the \`babel-loader\` that make the compile slowly:
+
+\`\`\`
+{
+  module: {
+    rules: [
+      {
+        test: /\\.js$/,
+        use: 'babel-loader',
+        exclude: [
+          /node_modules\\/lodash/
+        ]
+      }
+    ]
+  }
+}
+\`\`\`
+`
+};
+const E1004_code = 'E1004';
+const E1004_message = {
+    code: E1004_code,
+    title: 'ECMA Version Check',
+    type: 'markdown',
+    category: 'bundle',
+    description: `
+#### Description
+
+Detect if there is a newer version of ECMA syntax in the js bundle file
+`
+};
+const E1005_code = 'E1005';
+const E1005_message = {
+    code: E1005_code,
+    title: 'Default Import Check',
+    type: 'markdown',
+    category: 'compile',
+    description: `
+#### Description
+
+Usually webpack will automatically compatible different modules that has different types, but in a special case, the operation of compatibility will fail.
+That is, when you use \`Default Import\` to import a cjs module, and this cjs module do not have the compatible statement, such as \`exports.default = \`.
+
+#### General Solution
+
+1. for cjs module, write a \`exports.default = \` statement for default export.
+2. use \`Namespace Import\` for import the cjs module.
+
+For example, for the package \`htmlparser2@7.2.0\`:
+
+\`\`\`ts
+// you should use this
+import * as Parser from 'htmlparser2';
+
+// can not use this
+import Parser from 'htmlparser2';
+\`\`\`
+`
+};
+const E1006_code = 'E1006';
+const E1006_message = {
+    code: E1006_code,
+    title: 'Module Mixed Chunks',
+    type: 'markdown',
+    category: 'bundle',
+    description: "\n#### Description\n\nWhen a module is included in both **initial chunks** and **async chunks**, the same module code is bundled into multiple chunks, increasing output size and potentially affecting first-screen load and cache efficiency.\n\n- **Initial chunks**: Chunks loaded with the main entry (e.g. entry points, synchronous `import` in the main bundle).\n- **Async chunks**: Chunks loaded on demand via dynamic `import()` or similar.\n\nIn the **Module Mixed Chunks** tab of Bundle Alerts, each entry shows the module path, **Initial Chunks** list, and **Async Chunks** list so you can locate duplicated modules.\n\n#### Common Causes\n\n- **Same module referenced in two ways**: The module is both synchronously imported in the main bundle or entry and dynamically `import()`ed elsewhere, so the bundler emits it in both initial and async chunks.\n- **A file is both an entry and an async chunk**: e.g. a utility module is configured as an entry and also `import()`ed in app code, so it appears in the entry's initial chunk and in a dynamically loaded async chunk.\n- **splitChunks overlapping with entry**: A path is split into an async chunk via `splitChunks` / `chunkSplit`, but that path is also an entry or a main-bundle dependency, leading to mixed chunk types.\n\n#### General Solution\n\n1. **Use a single import style**: Prefer one way to reference a module—either all synchronous imports (initial) or all dynamic `import()` (async). Avoid the same file being both synchronously imported in the main bundle and dynamically imported elsewhere.\n2. **Review entry vs dynamic loading**: If a file is both an entry and part of an async chunk, remove one of those usages or extract it into a single shared chunk via build config so both initial and async chunks reference it instead of duplicating it.\n3. **Adjust splitChunks**: Check rules for that module path in `optimization.splitChunks` (Rspack/Webpack) or `performance.chunkSplit` (Rsbuild), and avoid the same module being split into both initial and async chunks. Use `chunks: 'async'` or `chunks: 'initial'` where appropriate, or control which chunk type it goes into via `cacheGroups` and `test` / `chunks`.\n4. **Trace dependencies**: From the reported module path and chunk list, search the codebase for references to that module, distinguish sync vs dynamic imports, then converge to a single chunk type or extract a common chunk.\n"
+};
+var type_RuleMessageCodeEnumerated = /*#__PURE__*/ function(RuleMessageCodeEnumerated) {
+    RuleMessageCodeEnumerated["Extend"] = "EXTEND";
+    RuleMessageCodeEnumerated["Overlay"] = "OVERLAY";
+    return RuleMessageCodeEnumerated;
+}({});
+var type_RuleMessageCategory = /*#__PURE__*/ function(RuleMessageCategory) {
+    RuleMessageCategory["Compile"] = "compile";
+    RuleMessageCategory["Bundle"] = "bundle";
+    RuleMessageCategory["EMO"] = "emo";
+    return RuleMessageCategory;
+}({});
+const RuleErrorMap = {
+    ["E1001"]: message,
+    ["E1002"]: E1002_message,
+    ["E1003"]: E1003_message,
+    ["E1004"]: E1004_message,
+    ["E1005"]: E1005_message,
+    ["E1006"]: E1006_message
+};
+var code_RsdoctorRuleClientConstant = /*#__PURE__*/ function(RsdoctorRuleClientConstant) {
+    RsdoctorRuleClientConstant["UrlQueryForErrorCode"] = "code";
+    return RsdoctorRuleClientConstant;
+}({});
+var client_RsdoctorClientUrlQuery = /*#__PURE__*/ function(RsdoctorClientUrlQuery) {
+    RsdoctorClientUrlQuery["BundleDiffFiles"] = "__bundle_files__";
+    RsdoctorClientUrlQuery["ManifestFile"] = "manifest";
+    RsdoctorClientUrlQuery["EnableRoutes"] = "enableRoutes";
+    return RsdoctorClientUrlQuery;
+}({});
+var client_RsdoctorClientRoutes = /*#__PURE__*/ function(RsdoctorClientRoutes) {
+    RsdoctorClientRoutes["Home"] = "/";
+    RsdoctorClientRoutes["Overall"] = "/overall";
+    RsdoctorClientRoutes["WebpackLoaderOverall"] = "/webpack/loaders/overall";
+    RsdoctorClientRoutes["WebpackLoaderAnalysis"] = "/webpack/loaders/analysis";
+    RsdoctorClientRoutes["ModuleResolve"] = "/module/resolve";
+    RsdoctorClientRoutes["WebpackPlugins"] = "/webpack/plugins";
+    RsdoctorClientRoutes["BundleSize"] = "/bundle/size";
+    RsdoctorClientRoutes["ModuleAnalyze"] = "/module/analyze";
+    RsdoctorClientRoutes["TreeShaking"] = "/treeshaking";
+    RsdoctorClientRoutes["BundleDiff"] = "/resources/bundle/diff";
+    RsdoctorClientRoutes["RuleIndex"] = "/resources/rules";
+    RsdoctorClientRoutes["Uploader"] = "/resources/uploader";
+    RsdoctorClientRoutes["EmoCheck"] = "/emo/check";
+    return RsdoctorClientRoutes;
+}({});
+var client_RsdoctorClientDiffState = /*#__PURE__*/ function(RsdoctorClientDiffState) {
+    RsdoctorClientDiffState["Equal"] = "-";
+    RsdoctorClientDiffState["Up"] = "UP";
+    RsdoctorClientDiffState["Down"] = "DOWN";
+    return RsdoctorClientDiffState;
+}({});
+const JSExtension = '.js';
+const BundleExtension = '.bundle';
+const JSExtensions = [
+    JSExtension,
+    BundleExtension
+];
+const CSSExtension = '.css';
+const HtmlExtension = '.html';
+const ImgExtensions = [
+    '.png',
+    '.jpg',
+    '.svg',
+    '.webp',
+    '.jpeg',
+    '.gif',
+    '.bmp'
+];
+const MediaExtensions = [
+    '.mp3',
+    '.mp4',
+    '.avi',
+    '.wav',
+    '.flv',
+    '.mov',
+    '.mpg',
+    '.mpeg'
+];
+const FontExtensions = [
+    '.ttf',
+    '.fnt',
+    '.fon',
+    '.otf',
+    '.woff',
+    '.woff2'
+];
+const MapExtensions = [
+    '.js.map',
+    '.css.map',
+    '.ts.map',
+    '.LICENSE.txt'
+];
+const RsdoctorOutputFolder = '.rsdoctor';
+const RsdoctorOutputManifest = 'manifest.json';
+const RsdoctorOutputManifestPath = `${RsdoctorOutputFolder}/${RsdoctorOutputManifest}`;
+const StatsFilePath = 'dist/stats.json';
+const RsdoctorMonitorNodeBId = 'Rsdoctor';
+const RsdoctorMonitorWebBId = 'Rsdoctor-Client';
+const RsdoctorMonitorDocBId = 'Rsdoctor-Doc';
+const RsdoctorProcessEnvDebugKey = 'rsdoctor';
+const RsdoctorClientUrl = '';
+const WINDOW_RSDOCTOR_TAG = '__RSDOCTOR__';
+exports.Babel = __webpack_exports__.Babel;
+exports.Client = __webpack_exports__.Client;
+exports.Common = __webpack_exports__.Common;
+exports.Config = __webpack_exports__.Config;
+exports.Constants = __webpack_exports__.Constants;
+exports.Err = __webpack_exports__.Err;
+exports.Esbuild = __webpack_exports__.Esbuild;
+exports.Linter = __webpack_exports__.Linter;
+exports.Logger = __webpack_exports__.Logger;
+exports.Manifest = __webpack_exports__.Manifest;
+exports.Modules = __webpack_exports__.Modules;
+exports.Plugin = __webpack_exports__.Plugin;
+exports.Rule = __webpack_exports__.Rule;
+exports.SDK = __webpack_exports__.SDK;
+exports.Thirdparty = __webpack_exports__.Thirdparty;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "Babel",
+    "Client",
+    "Common",
+    "Config",
+    "Constants",
+    "Err",
+    "Esbuild",
+    "Linter",
+    "Logger",
+    "Manifest",
+    "Modules",
+    "Plugin",
+    "Rule",
+    "SDK",
+    "Thirdparty"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});