feat: 添加所有@rsbuild包到本地packages

- 添加@rsbuild/core、plugin-less、plugin-react、plugin-svgr、plugin-typed-css-modules到本地
- 修改package.json中所有@rsbuild包引用本地路径
- 解决内网环境@rsbuild相关包安装问题

package.json

@@ -68,11 +68,11 @@
     "@antfu/eslint-config": "^2.24.1",
     "@eslint-react/eslint-plugin": "^1.8.0",
     "@eslint/compat": "^1.1.1",
-    "@rsbuild/core": "1.0.1-beta.9",
-    "@rsbuild/plugin-less": "1.0.1-beta.9",
-    "@rsbuild/plugin-react": "1.0.1-beta.9",
-    "@rsbuild/plugin-svgr": "1.0.1-beta.9",
-    "@rsbuild/plugin-typed-css-modules": "^1.0.2",
+    "@rsbuild/core": "file:packages/@rsbuild/core",
+    "@rsbuild/plugin-less": "file:packages/@rsbuild/plugin-less",
+    "@rsbuild/plugin-react": "file:packages/@rsbuild/plugin-react",
+    "@rsbuild/plugin-svgr": "file:packages/@rsbuild/plugin-svgr",
+    "@rsbuild/plugin-typed-css-modules": "file:packages/@rsbuild/plugin-typed-css-modules",
     "@rsdoctor/rspack-plugin": "^0.3.10",
     "@types/node": "^22.0.2",
     "@types/react": "^18.3.3",

packages/core/LICENSE

+MIT License
+
+Copyright (c) 2023-present Bytedance, Inc. and its affiliates.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

packages/core/README.md

+<p align="center">
+  <a href="https://rsbuild.dev" target="blank"><img src="https://github.com/web-infra-dev/rsbuild/assets/7237365/84abc13e-b620-468f-a90b-dbf28e7e9427" alt="Rsbuild Logo" /></a>
+</p>
+
+# Rsbuild
+
+The Rspack-based build tool. It's fast, out-of-the-box and extensible.
+
+## Documentation
+
+https://rsbuild.dev/
+
+## Contributing
+
+Please read the [Contributing Guide](https://github.com/web-infra-dev/rsbuild/blob/main/CONTRIBUTING.md).
+
+## License
+
+Rsbuild is [MIT licensed](https://github.com/web-infra-dev/rsbuild/blob/main/LICENSE).

packages/core/bin/rsbuild.js

+#!/usr/bin/env node
+import { __internalHelper, logger } from '../dist/index.js';
+
+const { runCli, prepareCli } = __internalHelper;
+
+async function main() {
+  prepareCli();
+
+  try {
+    runCli();
+  } catch (err) {
+    logger.error(err);
+  }
+}
+
+main();

packages/core/compiled/browserslist/index.d.ts

+/**
+ * Return array of browsers by selection queries.
+ *
+ * ```js
+ * browserslist('IE >= 10, IE 8') //=> ['ie 11', 'ie 10', 'ie 8']
+ * ```
+ *
+ * @param queries Browser queries.
+ * @param opts Options.
+ * @returns Array with browser names in Can I Use.
+ */
+declare function browserslist(
+  queries?: string | readonly string[] | null,
+  opts?: browserslist.Options
+): string[]
+
+declare namespace browserslist {
+  interface Query {
+    compose: 'or' | 'and'
+    type: string
+    query: string
+    not?: true
+  }
+
+  interface Options {
+    /**
+     * Path to processed file. It will be used to find config files.
+     */
+    path?: string | false
+    /**
+     * Processing environment. It will be used to take right queries
+     * from config file.
+     */
+    env?: string
+    /**
+     * Custom browser usage statistics for "> 1% in my stats" query.
+     */
+    stats?: Stats | string
+    /**
+     * Path to config file with queries.
+     */
+    config?: string
+    /**
+     * Do not throw on unknown version in direct query.
+     */
+    ignoreUnknownVersions?: boolean
+    /**
+     * Throw an error if env is not found.
+     */
+    throwOnMissing?: boolean
+    /**
+     * Disable security checks for extend query.
+     */
+    dangerousExtend?: boolean
+    /**
+     * Alias mobile browsers to the desktop version when Can I Use
+     * doesn’t have data about the specified version.
+     */
+    mobileToDesktop?: boolean
+  }
+
+  type Config = {
+    defaults: string[]
+    [section: string]: string[] | undefined
+  }
+
+  interface Stats {
+    [browser: string]: {
+      [version: string]: number
+    }
+  }
+
+  /**
+   * Browser names aliases.
+   */
+  let aliases: {
+    [alias: string]: string | undefined
+  }
+
+  /**
+   * Aliases to work with joined versions like `ios_saf 7.0-7.1`.
+   */
+  let versionAliases: {
+    [browser: string]:
+      | {
+          [version: string]: string | undefined
+        }
+      | undefined
+  }
+
+  /**
+   * Can I Use only provides a few versions for some browsers (e.g. `and_chr`).
+   *
+   * Fallback to a similar browser for unknown versions.
+   */
+  let desktopNames: {
+    [browser: string]: string | undefined
+  }
+
+  let data: {
+    [browser: string]:
+      | {
+          name: string
+          versions: string[]
+          released: string[]
+          releaseDate: {
+            [version: string]: number | undefined | null
+          }
+        }
+      | undefined
+  }
+
+  let nodeVersions: string[]
+
+  interface Usage {
+    [version: string]: number
+  }
+
+  let usage: {
+    global?: Usage
+    custom?: Usage | null
+    [country: string]: Usage | undefined | null
+  }
+
+  let cache: {
+    [feature: string]: {
+      [name: string]: {
+        [version: string]: string
+      }
+    }
+  }
+
+  /**
+   * Default browsers query
+   */
+  let defaults: readonly string[]
+
+  /**
+   * Which statistics should be used. Country code or custom statistics.
+   * Pass `"my stats"` to load statistics from `Browserslist` files.
+   */
+  type StatsOptions = string | 'my stats' | Stats | { dataByBrowser: Stats }
+
+  /**
+   * Return browsers market coverage.
+   *
+   * ```js
+   * browserslist.coverage(browserslist('> 1% in US'), 'US') //=> 83.1
+   * ```
+   *
+   * @param browsers Browsers names in Can I Use.
+   * @param stats Which statistics should be used.
+   * @returns Total market coverage for all selected browsers.
+   */
+  function coverage(browsers: readonly string[], stats?: StatsOptions): number
+
+  /**
+   * Get queries AST to analyze the config content.
+   *
+   * @param queries Browser queries.
+   * @param opts Options.
+   * @returns An array of the data of each query in the config.
+   */
+  function parse(
+    queries?: string | readonly string[] | null,
+    opts?: browserslist.Options
+  ): Query[]
+
+  function clearCaches(): void
+
+  function parseConfig(string: string): Config
+
+  function readConfig(file: string): Config
+
+  function findConfig(...pathSegments: string[]): Config | undefined
+
+  interface LoadConfigOptions {
+    config?: string
+    path?: string
+    env?: string
+  }
+
+  function loadConfig(options: LoadConfigOptions): string[] | undefined
+}
+
+declare global {
+  namespace NodeJS {
+    interface ProcessEnv {
+      BROWSERSLIST?: string
+      BROWSERSLIST_CONFIG?: string
+      BROWSERSLIST_DANGEROUS_EXTEND?: string
+      BROWSERSLIST_DISABLE_CACHE?: string
+      BROWSERSLIST_ENV?: string
+      BROWSERSLIST_IGNORE_OLD_DATA?: string
+      BROWSERSLIST_STATS?: string
+      BROWSERSLIST_ROOT_PATH?: string
+    }
+  }
+}
+
+export { browserslist as default };

packages/core/compiled/browserslist/license

+The MIT License (MIT)
+
+Copyright 2014 Andrey Sitnik <andrey@sitnik.ru> and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

packages/core/compiled/browserslist/package.json

+{"name":"browserslist","author":"Andrey Sitnik <andrey@sitnik.ru>","version":"4.23.2","funding":[{"type":"opencollective","url":"https://opencollective.com/browserslist"},{"type":"tidelift","url":"https://tidelift.com/funding/github/npm/browserslist"},{"type":"github","url":"https://github.com/sponsors/ai"}],"license":"MIT","types":"index.d.ts","type":"commonjs"}

packages/core/compiled/chokidar/index.d.ts

+/// <reference types="node" />
+import * as fs from 'fs';
+import { EventEmitter } from 'events';
+
+type AnymatchFn = (testString: string) => boolean;
+type AnymatchPattern = string|RegExp|AnymatchFn;
+type AnymatchMatcher = AnymatchPattern|AnymatchPattern[]
+
+// TypeScript Version: 3.0
+
+
+
+declare class FSWatcher extends EventEmitter implements fs.FSWatcher {
+  options: WatchOptions;
+
+  /**
+   * Constructs a new FSWatcher instance with optional WatchOptions parameter.
+   */
+  constructor(options?: WatchOptions);
+
+  /**
+   * Add files, directories, or glob patterns for tracking. Takes an array of strings or just one
+   * string.
+   */
+  add(paths: string | ReadonlyArray<string>): this;
+
+  /**
+   * Stop watching files, directories, or glob patterns. Takes an array of strings or just one
+   * string.
+   */
+  unwatch(paths: string | ReadonlyArray<string>): this;
+
+  /**
+   * Returns an object representing all the paths on the file system being watched by this
+   * `FSWatcher` instance. The object's keys are all the directories (using absolute paths unless
+   * the `cwd` option was used), and the values are arrays of the names of the items contained in
+   * each directory.
+   */
+  getWatched(): {
+    [directory: string]: string[];
+  };
+
+  /**
+   * Removes all listeners from watched files.
+   */
+  close(): Promise<void>;
+
+  on(event: 'add'|'addDir'|'change', listener: (path: string, stats?: fs.Stats) => void): this;
+
+  on(event: 'all', listener: (eventName: 'add'|'addDir'|'change'|'unlink'|'unlinkDir', path: string, stats?: fs.Stats) => void): this;
+
+  /**
+   * Error occurred
+   */
+  on(event: 'error', listener: (error: Error) => void): this;
+
+  /**
+   * Exposes the native Node `fs.FSWatcher events`
+   */
+  on(event: 'raw', listener: (eventName: string, path: string, details: any) => void): this;
+
+  /**
+   * Fires when the initial scan is complete
+   */
+  on(event: 'ready', listener: () => void): this;
+
+  on(event: 'unlink'|'unlinkDir', listener: (path: string) => void): this;
+
+  on(event: string, listener: (...args: any[]) => void): this;
+
+  ref(): this;
+  
+  unref(): this;
+}
+
+interface WatchOptions {
+  /**
+   * Indicates whether the process should continue to run as long as files are being watched. If
+   * set to `false` when using `fsevents` to watch, no more events will be emitted after `ready`,
+   * even if the process continues to run.
+   */
+  persistent?: boolean;
+
+  /**
+   * ([anymatch](https://github.com/micromatch/anymatch)-compatible definition) Defines files/paths to
+   * be ignored. The whole relative or absolute path is tested, not just filename. If a function
+   * with two arguments is provided, it gets called twice per path - once with a single argument
+   * (the path), second time with two arguments (the path and the
+   * [`fs.Stats`](https://nodejs.org/api/fs.html#fs_class_fs_stats) object of that path).
+   */
+  ignored?: AnymatchMatcher;
+
+  /**
+   * If set to `false` then `add`/`addDir` events are also emitted for matching paths while
+   * instantiating the watching as chokidar discovers these file paths (before the `ready` event).
+   */
+  ignoreInitial?: boolean;
+
+  /**
+   * When `false`, only the symlinks themselves will be watched for changes instead of following
+   * the link references and bubbling events through the link's path.
+   */
+  followSymlinks?: boolean;
+
+  /**
+   * The base directory from which watch `paths` are to be derived. Paths emitted with events will
+   * be relative to this.
+   */
+  cwd?: string;
+
+  /**
+   *  If set to true then the strings passed to .watch() and .add() are treated as literal path
+   *  names, even if they look like globs. Default: false.
+   */
+  disableGlobbing?: boolean;
+
+  /**
+   * Whether to use fs.watchFile (backed by polling), or fs.watch. If polling leads to high CPU
+   * utilization, consider setting this to `false`. It is typically necessary to **set this to
+   * `true` to successfully watch files over a network**, and it may be necessary to successfully
+   * watch files in other non-standard situations. Setting to `true` explicitly on OS X overrides
+   * the `useFsEvents` default.
+   */
+  usePolling?: boolean;
+
+  /**
+   * Whether to use the `fsevents` watching interface if available. When set to `true` explicitly
+   * and `fsevents` is available this supercedes the `usePolling` setting. When set to `false` on
+   * OS X, `usePolling: true` becomes the default.
+   */
+  useFsEvents?: boolean;
+
+  /**
+   * If relying upon the [`fs.Stats`](https://nodejs.org/api/fs.html#fs_class_fs_stats) object that
+   * may get passed with `add`, `addDir`, and `change` events, set this to `true` to ensure it is
+   * provided even in cases where it wasn't already available from the underlying watch events.
+   */
+  alwaysStat?: boolean;
+
+  /**
+   * If set, limits how many levels of subdirectories will be traversed.
+   */
+  depth?: number;
+
+  /**
+   * Interval of file system polling.
+   */
+  interval?: number;
+
+  /**
+   * Interval of file system polling for binary files. ([see list of binary extensions](https://gi
+   * thub.com/sindresorhus/binary-extensions/blob/master/binary-extensions.json))
+   */
+  binaryInterval?: number;
+
+  /**
+   *  Indicates whether to watch files that don't have read permissions if possible. If watching
+   *  fails due to `EPERM` or `EACCES` with this set to `true`, the errors will be suppressed
+   *  silently.
+   */
+  ignorePermissionErrors?: boolean;
+
+  /**
+   * `true` if `useFsEvents` and `usePolling` are `false`). Automatically filters out artifacts
+   * that occur when using editors that use "atomic writes" instead of writing directly to the
+   * source file. If a file is re-added within 100 ms of being deleted, Chokidar emits a `change`
+   * event rather than `unlink` then `add`. If the default of 100 ms does not work well for you,
+   * you can override it by setting `atomic` to a custom value, in milliseconds.
+   */
+  atomic?: boolean | number;
+
+  /**
+   * can be set to an object in order to adjust timing params:
+   */
+  awaitWriteFinish?: AwaitWriteFinishOptions | boolean;
+}
+
+interface AwaitWriteFinishOptions {
+  /**
+   * Amount of time in milliseconds for a file size to remain constant before emitting its event.
+   */
+  stabilityThreshold?: number;
+
+  /**
+   * File size polling interval.
+   */
+  pollInterval?: number;
+}
+
+/**
+ * produces an instance of `FSWatcher`.
+ */
+declare function watch(
+  paths: string | ReadonlyArray<string>,
+  options?: WatchOptions
+): FSWatcher;
+
+export { type AwaitWriteFinishOptions, FSWatcher, type WatchOptions, watch };

packages/core/compiled/chokidar/license

+The MIT License (MIT)
+
+Copyright (c) 2012-2019 Paul Miller (https://paulmillr.com), Elan Shanker
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the “Software”), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

packages/core/compiled/chokidar/package.json

+{"name":"chokidar","author":"Paul Miller (https://paulmillr.com)","version":"3.6.0","funding":"https://paulmillr.com/funding/","license":"MIT","types":"index.d.ts","type":"commonjs"}

packages/core/compiled/commander/license

+(The MIT License)
+
+Copyright (c) 2011 TJ Holowaychuk <tj@vision-media.ca>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

packages/core/compiled/commander/package.json

+{"name":"commander","author":"TJ Holowaychuk <tj@vision-media.ca>","version":"12.1.0","license":"MIT","types":"index.d.ts","type":"commonjs"}

packages/core/compiled/connect-history-api-fallback/index.d.ts

+export = any;

packages/core/compiled/connect-history-api-fallback/index.js

+(() => {
+  "use strict";
+  var __webpack_modules__ = {
+    945: (module, exports, __nccwpck_require__) => {
+      var url = __nccwpck_require__(310);
+      exports = module.exports = function historyApiFallback(options) {
+        options = options || {};
+        var logger = getLogger(options);
+        return function (req, res, next) {
+          var headers = req.headers;
+          if (req.method !== "GET" && req.method !== "HEAD") {
+            logger(
+              "Not rewriting",
+              req.method,
+              req.url,
+              "because the method is not GET or HEAD.",
+            );
+            return next();
+          } else if (!headers || typeof headers.accept !== "string") {
+            logger(
+              "Not rewriting",
+              req.method,
+              req.url,
+              "because the client did not send an HTTP accept header.",
+            );
+            return next();
+          } else if (headers.accept.indexOf("application/json") === 0) {
+            logger(
+              "Not rewriting",
+              req.method,
+              req.url,
+              "because the client prefers JSON.",
+            );
+            return next();
+          } else if (!acceptsHtml(headers.accept, options)) {
+            logger(
+              "Not rewriting",
+              req.method,
+              req.url,
+              "because the client does not accept HTML.",
+            );
+            return next();
+          }
+          var parsedUrl = url.parse(req.url);
+          var rewriteTarget;
+          options.rewrites = options.rewrites || [];
+          for (var i = 0; i < options.rewrites.length; i++) {
+            var rewrite = options.rewrites[i];
+            var match = parsedUrl.pathname.match(rewrite.from);
+            if (match !== null) {
+              rewriteTarget = evaluateRewriteRule(
+                parsedUrl,
+                match,
+                rewrite.to,
+                req,
+              );
+              if (rewriteTarget.charAt(0) !== "/") {
+                logger(
+                  "We recommend using an absolute path for the rewrite target.",
+                  "Received a non-absolute rewrite target",
+                  rewriteTarget,
+                  "for URL",
+                  req.url,
+                );
+              }
+              logger("Rewriting", req.method, req.url, "to", rewriteTarget);
+              req.url = rewriteTarget;
+              return next();
+            }
+          }
+          var pathname = parsedUrl.pathname;
+          if (
+            pathname.lastIndexOf(".") > pathname.lastIndexOf("/") &&
+            options.disableDotRule !== true
+          ) {
+            logger(
+              "Not rewriting",
+              req.method,
+              req.url,
+              "because the path includes a dot (.) character.",
+            );
+            return next();
+          }
+          rewriteTarget = options.index || "/index.html";
+          logger("Rewriting", req.method, req.url, "to", rewriteTarget);
+          req.url = rewriteTarget;
+          next();
+        };
+      };
+      function evaluateRewriteRule(parsedUrl, match, rule, req) {
+        if (typeof rule === "string") {
+          return rule;
+        } else if (typeof rule !== "function") {
+          throw new Error(
+            "Rewrite rule can only be of type string or function.",
+          );
+        }
+        return rule({ parsedUrl, match, request: req });
+      }
+      function acceptsHtml(header, options) {
+        options.htmlAcceptHeaders = options.htmlAcceptHeaders || [
+          "text/html",
+          "*/*",
+        ];
+        for (var i = 0; i < options.htmlAcceptHeaders.length; i++) {
+          if (header.indexOf(options.htmlAcceptHeaders[i]) !== -1) {
+            return true;
+          }
+        }
+        return false;
+      }
+      function getLogger(options) {
+        if (options && options.logger) {
+          return options.logger;
+        } else if (options && options.verbose) {
+          return console.log.bind(console);
+        }
+        return function () {};
+      }
+    },
+    310: (module) => {
+      module.exports = require("url");
+    },
+  };
+  var __webpack_module_cache__ = {};
+  function __nccwpck_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (cachedModule !== undefined) {
+      return cachedModule.exports;
+    }
+    var module = (__webpack_module_cache__[moduleId] = { exports: {} });
+    var threw = true;
+    try {
+      __webpack_modules__[moduleId](
+        module,
+        module.exports,
+        __nccwpck_require__,
+      );
+      threw = false;
+    } finally {
+      if (threw) delete __webpack_module_cache__[moduleId];
+    }
+    return module.exports;
+  }
+  if (typeof __nccwpck_require__ !== "undefined")
+    __nccwpck_require__.ab = __dirname + "/";
+  var __webpack_exports__ = __nccwpck_require__(945);
+  module.exports = __webpack_exports__;
+})();

packages/core/compiled/connect-history-api-fallback/license

+The MIT License
+
+Copyright (c) 2022 Ben Blackmore and contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
\ No newline at end of file

packages/core/compiled/connect-history-api-fallback/package.json

+{"name":"connect-history-api-fallback","author":{"name":"Ben Ripkens","email":"bripkens@gmail.com"},"version":"2.0.0","license":"MIT","types":"index.d.ts","type":"commonjs"}

packages/core/compiled/connect/index.d.ts

+/// <reference types="node" />
+import * as http from 'http';
+
+/**
+ * Create a new connect server.
+ */
+declare function createServer(): createServer.Server;
+
+declare namespace createServer {
+    export type ServerHandle = HandleFunction | http.Server;
+
+    export class IncomingMessage extends http.IncomingMessage {
+        originalUrl?: http.IncomingMessage["url"] | undefined;
+    }
+
+    type NextFunction = (err?: any) => void;
+
+    export type SimpleHandleFunction = (req: IncomingMessage, res: http.ServerResponse) => void;
+    export type NextHandleFunction = (req: IncomingMessage, res: http.ServerResponse, next: NextFunction) => void;
+    export type ErrorHandleFunction = (
+        err: any,
+        req: IncomingMessage,
+        res: http.ServerResponse,
+        next: NextFunction,
+    ) => void;
+    export type HandleFunction = SimpleHandleFunction | NextHandleFunction | ErrorHandleFunction;
+
+    export interface ServerStackItem {
+        route: string;
+        handle: ServerHandle;
+    }
+
+    export interface Server extends NodeJS.EventEmitter {
+        (req: http.IncomingMessage, res: http.ServerResponse, next?: Function): void;
+
+        route: string;
+        stack: ServerStackItem[];
+
+        /**
+         * Utilize the given middleware `handle` to the given `route`,
+         * defaulting to _/_. This "route" is the mount-point for the
+         * middleware, when given a value other than _/_ the middleware
+         * is only effective when that segment is present in the request's
+         * pathname.
+         *
+         * For example if we were to mount a function at _/admin_, it would
+         * be invoked on _/admin_, and _/admin/settings_, however it would
+         * not be invoked for _/_, or _/posts_.
+         */
+        use(fn: NextHandleFunction): Server;
+        use(fn: HandleFunction): Server;
+        use(route: string, fn: NextHandleFunction): Server;
+        use(route: string, fn: HandleFunction): Server;
+
+        /**
+         * Handle server requests, punting them down
+         * the middleware stack.
+         */
+        handle(req: http.IncomingMessage, res: http.ServerResponse, next: Function): void;
+
+        /**
+         * Listen for connections.
+         *
+         * This method takes the same arguments
+         * as node's `http.Server#listen()`.
+         *
+         * HTTP and HTTPS:
+         *
+         * If you run your application both as HTTP
+         * and HTTPS you may wrap them individually,
+         * since your Connect "server" is really just
+         * a JavaScript `Function`.
+         *
+         *      var connect = require('connect')
+         *        , http = require('http')
+         *        , https = require('https');
+         *
+         *      var app = connect();
+         *
+         *      http.createServer(app).listen(80);
+         *      https.createServer(options, app).listen(443);
+         */
+        listen(port: number, hostname?: string, backlog?: number, callback?: Function): http.Server;
+        listen(port: number, hostname?: string, callback?: Function): http.Server;
+        listen(path: string, callback?: Function): http.Server;
+        listen(handle: any, listeningListener?: Function): http.Server;
+    }
+}
+
+export { createServer as default };

packages/core/compiled/connect/license

+(The MIT License)
+
+Copyright (c) 2010 Sencha Inc.
+Copyright (c) 2011 LearnBoost
+Copyright (c) 2011-2014 TJ Holowaychuk
+Copyright (c) 2015 Douglas Christopher Wilson
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

packages/core/compiled/connect/package.json

+{"name":"connect","author":"TJ Holowaychuk <tj@vision-media.ca> (http://tjholowaychuk.com)","version":"3.7.0","license":"MIT","types":"index.d.ts","type":"commonjs"}

packages/core/compiled/css-loader/api.js

+"use strict";
+
+/*
+  MIT License http://www.opensource.org/licenses/mit-license.php
+  Author Tobias Koppers @sokra
+*/
+module.exports = function (cssWithMappingToString) {
+  var list = [];
+
+  // return the list of modules as css string
+  list.toString = function toString() {
+    return this.map(function (item) {
+      var content = "";
+      var needLayer = typeof item[5] !== "undefined";
+      if (item[4]) {
+        content += "@supports (".concat(item[4], ") {");
+      }
+      if (item[2]) {
+        content += "@media ".concat(item[2], " {");
+      }
+      if (needLayer) {
+        content += "@layer".concat(item[5].length > 0 ? " ".concat(item[5]) : "", " {");
+      }
+      content += cssWithMappingToString(item);
+      if (needLayer) {
+        content += "}";
+      }
+      if (item[2]) {
+        content += "}";
+      }
+      if (item[4]) {
+        content += "}";
+      }
+      return content;
+    }).join("");
+  };
+
+  // import a list of modules into the list
+  list.i = function i(modules, media, dedupe, supports, layer) {
+    if (typeof modules === "string") {
+      modules = [[null, modules, undefined]];
+    }
+    var alreadyImportedModules = {};
+    if (dedupe) {
+      for (var k = 0; k < this.length; k++) {
+        var id = this[k][0];
+        if (id != null) {
+          alreadyImportedModules[id] = true;
+        }
+      }
+    }
+    for (var _k = 0; _k < modules.length; _k++) {
+      var item = [].concat(modules[_k]);
+      if (dedupe && alreadyImportedModules[item[0]]) {
+        continue;
+      }
+      if (typeof layer !== "undefined") {
+        if (typeof item[5] === "undefined") {
+          item[5] = layer;
+        } else {
+          item[1] = "@layer".concat(item[5].length > 0 ? " ".concat(item[5]) : "", " {").concat(item[1], "}");
+          item[5] = layer;
+        }
+      }
+      if (media) {
+        if (!item[2]) {
+          item[2] = media;
+        } else {
+          item[1] = "@media ".concat(item[2], " {").concat(item[1], "}");
+          item[2] = media;
+        }
+      }
+      if (supports) {
+        if (!item[4]) {
+          item[4] = "".concat(supports);
+        } else {
+          item[1] = "@supports (".concat(item[4], ") {").concat(item[1], "}");
+          item[4] = supports;
+        }
+      }
+      list.push(item);
+    }
+  };
+  return list;
+};
\ No newline at end of file

packages/core/compiled/css-loader/getUrl.js

+"use strict";
+
+module.exports = function (url, options) {
+  if (!options) {
+    options = {};
+  }
+  if (!url) {
+    return url;
+  }
+  url = String(url.__esModule ? url.default : url);
+
+  // If url is already wrapped in quotes, remove them
+  if (/^['"].*['"]$/.test(url)) {
+    url = url.slice(1, -1);
+  }
+  if (options.hash) {
+    url += options.hash;
+  }
+
+  // Should url be wrapped?
+  // See https://drafts.csswg.org/css-values-3/#urls
+  if (/["'() \t\n]|(%20)/.test(url) || options.needQuotes) {
+    return "\"".concat(url.replace(/"/g, '\\"').replace(/\n/g, "\\n"), "\"");
+  }
+  return url;
+};
\ No newline at end of file

packages/core/compiled/css-loader/index.d.ts

+export = any;

packages/core/compiled/css-loader/license

+Copyright JS Foundation and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

packages/core/compiled/css-loader/noSourceMaps.js

+"use strict";
+
+module.exports = function (i) {
+  return i[1];
+};
\ No newline at end of file

packages/core/compiled/css-loader/package.json

+{"name":"css-loader","author":"Tobias Koppers @sokra","version":"7.1.2","funding":{"type":"opencollective","url":"https://opencollective.com/webpack"},"license":"MIT","types":"index.d.ts","type":"commonjs"}

packages/core/compiled/css-loader/semver.js

+module.exports.satisfies = () => true;
\ No newline at end of file

packages/core/compiled/css-loader/sourceMaps.js

+"use strict";
+
+module.exports = function (item) {
+  var content = item[1];
+  var cssMapping = item[3];
+  if (!cssMapping) {
+    return content;
+  }
+  if (typeof btoa === "function") {
+    var base64 = btoa(unescape(encodeURIComponent(JSON.stringify(cssMapping))));
+    var data = "sourceMappingURL=data:application/json;charset=utf-8;base64,".concat(base64);
+    var sourceMapping = "/*# ".concat(data, " */");
+    return [content].concat([sourceMapping]).join("\n");
+  }
+  return [content].join("\n");
+};
\ No newline at end of file

packages/core/compiled/dotenv-expand/index.d.ts

+/// <reference types="node" />
+// TypeScript Version: 3.0
+
+interface DotenvPopulateInput {
+  [name: string]: string;
+}
+
+interface DotenvParseInput {
+  [name: string]: string;
+}
+
+interface DotenvParseOutput {
+  [name: string]: string;
+}
+
+interface DotenvExpandOptions {
+  error?: Error;
+
+  /**
+   * Default: `process.env`
+   *
+   * Specify an object to write your secrets to. Defaults to process.env environment variables.
+   *
+   * example: `const processEnv = {}; require('dotenv').config({ processEnv: processEnv })`
+   */
+  processEnv?: DotenvPopulateInput;
+
+  /**
+   * Default: `object`
+   *
+   * Object coming from dotenv's parsed result.
+   */
+  parsed?: DotenvParseInput;
+}
+
+interface DotenvExpandOutput {
+  error?: Error;
+  parsed?: DotenvParseOutput;
+}
+
+/**
+ * Adds variable expansion on top of dotenv.
+ *
+ * See https://docs.dotenv.org
+ *
+ * @param options - additional options. example: `{ processEnv: {}, error: null, parsed: { { KEY: 'value' } }`
+ * @returns an object with a `parsed` key if successful or `error` key if an error occurred. example: { parsed: { KEY: 'value' } }
+ *
+ */
+declare function expand(options?: DotenvExpandOptions): DotenvExpandOutput
+
+export { type DotenvExpandOptions, type DotenvExpandOutput, type DotenvParseInput, type DotenvParseOutput, type DotenvPopulateInput, expand };

packages/core/compiled/dotenv-expand/index.js

+(() => {
+  "use strict";
+  var __webpack_modules__ = {
+    693: (module) => {
+      const DOTENV_SUBSTITUTION_REGEX =
+        /(\\)?(\$)(?!\()(\{?)([\w.]+)(?::?-((?:\$\{(?:\$\{(?:\$\{[^}]*\}|[^}])*}|[^}])*}|[^}])+))?(\}?)/gi;
+      function _resolveEscapeSequences(value) {
+        return value.replace(/\\\$/g, "$");
+      }
+      function interpolate(value, processEnv, parsed) {
+        return value.replace(
+          DOTENV_SUBSTITUTION_REGEX,
+          (
+            match,
+            escaped,
+            dollarSign,
+            openBrace,
+            key,
+            defaultValue,
+            closeBrace,
+          ) => {
+            if (escaped === "\\") {
+              return match.slice(1);
+            } else {
+              if (processEnv[key]) {
+                if (processEnv[key] === parsed[key]) {
+                  return processEnv[key];
+                } else {
+                  return interpolate(processEnv[key], processEnv, parsed);
+                }
+              }
+              if (parsed[key]) {
+                if (parsed[key] === value) {
+                  return parsed[key];
+                } else {
+                  return interpolate(parsed[key], processEnv, parsed);
+                }
+              }
+              if (defaultValue) {
+                if (defaultValue.startsWith("$")) {
+                  return interpolate(defaultValue, processEnv, parsed);
+                } else {
+                  return defaultValue;
+                }
+              }
+              return "";
+            }
+          },
+        );
+      }
+      function expand(options) {
+        let processEnv = process.env;
+        if (options && options.processEnv != null) {
+          processEnv = options.processEnv;
+        }
+        for (const key in options.parsed) {
+          let value = options.parsed[key];
+          const inProcessEnv = Object.prototype.hasOwnProperty.call(
+            processEnv,
+            key,
+          );
+          if (inProcessEnv) {
+            if (processEnv[key] === options.parsed[key]) {
+              value = interpolate(value, processEnv, options.parsed);
+            } else {
+              value = processEnv[key];
+            }
+          } else {
+            value = interpolate(value, processEnv, options.parsed);
+          }
+          options.parsed[key] = _resolveEscapeSequences(value);
+        }
+        for (const processKey in options.parsed) {
+          processEnv[processKey] = options.parsed[processKey];
+        }
+        return options;
+      }
+      module.exports.expand = expand;
+    },
+  };
+  var __webpack_module_cache__ = {};
+  function __nccwpck_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (cachedModule !== undefined) {
+      return cachedModule.exports;
+    }
+    var module = (__webpack_module_cache__[moduleId] = { exports: {} });
+    var threw = true;
+    try {
+      __webpack_modules__[moduleId](
+        module,
+        module.exports,
+        __nccwpck_require__,
+      );
+      threw = false;
+    } finally {
+      if (threw) delete __webpack_module_cache__[moduleId];
+    }
+    return module.exports;
+  }
+  if (typeof __nccwpck_require__ !== "undefined")
+    __nccwpck_require__.ab = __dirname + "/";
+  var __webpack_exports__ = __nccwpck_require__(693);
+  module.exports = __webpack_exports__;
+})();

packages/core/compiled/dotenv-expand/license

+Copyright (c) 2016, Scott Motte
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+

packages/core/compiled/dotenv-expand/package.json

+{"name":"dotenv-expand","author":"motdotla","version":"11.0.6","funding":"https://dotenvx.com","license":"BSD-2-Clause","types":"index.d.ts","type":"commonjs"}

packages/core/compiled/dotenv/index.d.ts

+/// <reference types="node" />
+import { URL } from 'url';
+
+// TypeScript Version: 3.0
+
+
+interface DotenvParseOutput {
+  [name: string]: string;
+}
+
+/**
+ * Parses a string or buffer in the .env file format into an object.
+ *
+ * See https://dotenvx.com/docs
+ *
+ * @param src - contents to be parsed. example: `'DB_HOST=localhost'`
+ * @returns an object with keys and values based on `src`. example: `{ DB_HOST : 'localhost' }`
+ */
+declare function parse<T extends DotenvParseOutput = DotenvParseOutput>(
+  src: string | Buffer
+): T;
+
+interface DotenvConfigOptions {
+  /**
+   * Default: `path.resolve(process.cwd(), '.env')`
+   *
+   * Specify a custom path if your file containing environment variables is located elsewhere.
+   * Can also be an array of strings, specifying multiple paths.
+   *
+   * example: `require('dotenv').config({ path: '/custom/path/to/.env' })`
+   * example: `require('dotenv').config({ path: ['/path/to/first.env', '/path/to/second.env'] })`
+   */
+  path?: string | string[] | URL;
+
+  /**
+   * Default: `utf8`
+   *
+   * Specify the encoding of your file containing environment variables.
+   *
+   * example: `require('dotenv').config({ encoding: 'latin1' })`
+   */
+  encoding?: string;
+
+  /**
+   * Default: `false`
+   *
+   * Turn on logging to help debug why certain keys or values are not being set as you expect.
+   *
+   * example: `require('dotenv').config({ debug: process.env.DEBUG })`
+   */
+  debug?: boolean;
+
+  /**
+   * Default: `false`
+   *
+   * Override any environment variables that have already been set on your machine with values from your .env file.
+   *
+   * example: `require('dotenv').config({ override: true })`
+   */
+  override?: boolean;
+
+  /**
+   * Default: `process.env`
+   *
+   * Specify an object to write your secrets to. Defaults to process.env environment variables.
+   *
+   * example: `const processEnv = {}; require('dotenv').config({ processEnv: processEnv })`
+   */
+  processEnv?: DotenvPopulateInput;
+
+  /**
+   * Default: `undefined`
+   *
+   * Pass the DOTENV_KEY directly to config options. Defaults to looking for process.env.DOTENV_KEY environment variable. Note this only applies to decrypting .env.vault files. If passed as null or undefined, or not passed at all, dotenv falls back to its traditional job of parsing a .env file.
+   *
+   * example: `require('dotenv').config({ DOTENV_KEY: 'dotenv://:key_1234…@dotenvx.com/vault/.env.vault?environment=production' })`
+   */
+  DOTENV_KEY?: string;
+}
+
+interface DotenvConfigOutput {
+  error?: Error;
+  parsed?: DotenvParseOutput;
+}
+
+interface DotenvPopulateOptions {
+  /**
+   * Default: `false`
+   *
+   * Turn on logging to help debug why certain keys or values are not being set as you expect.
+   *
+   * example: `require('dotenv').config({ debug: process.env.DEBUG })`
+   */
+  debug?: boolean;
+
+  /**
+   * Default: `false`
+   *
+   * Override any environment variables that have already been set on your machine with values from your .env file.
+   *
+   * example: `require('dotenv').config({ override: true })`
+   */
+  override?: boolean;
+}
+
+interface DotenvPopulateInput {
+  [name: string]: string;
+}
+
+/**
+ * Loads `.env` file contents into process.env by default. If `DOTENV_KEY` is present, it smartly attempts to load encrypted `.env.vault` file contents into process.env.
+ *
+ * See https://dotenvx.com/docs
+ *
+ * @param options - additional options. example: `{ path: './custom/path', encoding: 'latin1', debug: true, override: false }`
+ * @returns an object with a `parsed` key if successful or `error` key if an error occurred. example: { parsed: { KEY: 'value' } }
+ *
+ */
+declare function config(options?: DotenvConfigOptions): DotenvConfigOutput;
+
+/**
+ * Loads `.env` file contents into process.env.
+ *
+ * See https://dotenvx.com/docs
+ *
+ * @param options - additional options. example: `{ path: './custom/path', encoding: 'latin1', debug: true, override: false }`
+ * @returns an object with a `parsed` key if successful or `error` key if an error occurred. example: { parsed: { KEY: 'value' } }
+ *
+ */
+declare function configDotenv(options?: DotenvConfigOptions): DotenvConfigOutput;
+
+/**
+ * Loads `source` json contents into `target` like process.env.
+ *
+ * See https://dotenvx.com/docs
+ *
+ * @param processEnv - the target JSON object. in most cases use process.env but you can also pass your own JSON object
+ * @param parsed - the source JSON object
+ * @param options - additional options. example: `{ debug: true, override: false }`
+ * @returns {void}
+ *
+ */
+declare function populate(processEnv: DotenvPopulateInput, parsed: DotenvPopulateInput, options?: DotenvConfigOptions): void;
+
+/**
+ * Decrypt ciphertext
+ *
+ * See https://dotenvx.com/docs
+ *
+ * @param encrypted - the encrypted ciphertext string
+ * @param keyStr - the decryption key string
+ * @returns {string}
+ *
+ */
+declare function decrypt(encrypted: string, keyStr: string): string;
+
+export { type DotenvConfigOptions, type DotenvConfigOutput, type DotenvParseOutput, type DotenvPopulateInput, type DotenvPopulateOptions, config, configDotenv, decrypt, parse, populate };

packages/core/compiled/dotenv/license

+Copyright (c) 2015, Scott Motte
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

packages/core/compiled/dotenv/package.json

+{"name":"dotenv","version":"16.4.5","funding":"https://dotenvx.com","license":"BSD-2-Clause","types":"index.d.ts","type":"commonjs"}

packages/core/compiled/html-rspack-plugin/default_index.ejs

+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <title><%= htmlWebpackPlugin.options.title %></title>
+  </head>
+  <body>
+  </body>
+</html>
\ No newline at end of file

packages/core/compiled/html-rspack-plugin/index.d.ts

+import { AsyncSeriesWaterfallHook } from '@rspack/lite-tapable';
+import { Compiler, Compilation } from '@rspack/core';
+
+declare class HtmlRspackPlugin {
+  constructor(options?: HtmlRspackPlugin.Options);
+
+  userOptions: HtmlRspackPlugin.Options;
+
+  /** Current HtmlRspackPlugin Major */
+  version: number;
+
+  /**
+   * Options after html-webpack-plugin has been initialized with defaults
+   */
+  options?: HtmlRspackPlugin.ProcessedOptions;
+
+  apply(compiler: Compiler): void;
+
+  static getHooks(compilation: Compilation): HtmlRspackPlugin.Hooks;
+
+  /**
+   * Static helper to create a tag object to be get injected into the dom
+   */
+  static createHtmlTagObject(
+    tagName: string,
+    attributes?: { [attributeName: string]: string | boolean },
+    innerHTML?: string,
+  ): HtmlRspackPlugin.HtmlTagObject;
+
+  static readonly version: number;
+}
+
+declare namespace HtmlRspackPlugin {
+  type MinifyOptions = HtmlMinifierOptions;
+
+  interface Options {
+    /**
+     * Emit the file only if it was changed.
+     * @default true
+     */
+    cache?: boolean;
+    /**
+     * List all entries which should be injected
+     */
+    chunks?: 'all' | string[];
+    /**
+     * Allows to control how chunks should be sorted before they are included to the html.
+     * @default 'auto'
+     */
+    chunksSortMode?:
+      | 'auto'
+      // `none` is deprecated and an alias for `auto` now.
+      | 'none'
+      | 'manual'
+      | ((entryNameA: string, entryNameB: string) => number);
+    /**
+     * List all entries which should not be injected
+     */
+    excludeChunks?: string[];
+    /**
+     * Path to the favicon icon
+     */
+    favicon?: false | string;
+    /**
+     * The file to write the HTML to.
+     * Supports subdirectories eg: `assets/admin.html`
+     * [name] will be replaced by the entry name
+     * Supports a function to generate the name
+     *
+     * @default 'index.html'
+     */
+    filename?: string | ((entryName: string) => string);
+    /**
+     * By default the public path is set to `auto` - that way the html-webpack-plugin will try
+     * to set the publicPath according to the current filename and the webpack publicPath setting
+     */
+    publicPath?: string | 'auto';
+    /**
+     * If `true` then append a unique `webpack` compilation hash to all included scripts and CSS files.
+     * This is useful for cache busting
+     */
+    hash?: boolean;
+    /**
+     * Inject all assets into the given `template` or `templateContent`.
+     */
+    inject?:
+      | false // Don't inject scripts
+      | true // Inject scripts into body
+      | 'body' // Inject scripts into body
+      | 'head'; // Inject scripts into head
+    /**
+     * Set up script loading
+     * blocking will result in <script src="..."></script>
+     * defer will result in <script defer src="..."></script>
+     *
+     * @default 'defer'
+     */
+    scriptLoading?: 'blocking' | 'defer' | 'module' | 'systemjs-module';
+    /**
+     * Inject meta tags
+     */
+    meta?:
+      | false // Disable injection
+      | {
+          [name: string]:
+            | string
+            | false // name content pair e.g. {viewport: 'width=device-width, initial-scale=1, shrink-to-fit=no'}`
+            | { [attributeName: string]: string | boolean }; // custom properties e.g. { name:"viewport" content:"width=500, initial-scale=1" }
+        };
+    /**
+     * A function to minify the HTML
+     */
+    minify?: (html: string) => string | Promise<string>;
+    /**
+     * Render errors into the HTML page
+     */
+    showErrors?: boolean;
+    /**
+     * The `webpack` require path to the template.
+     * @see https://github.com/jantimon/html-webpack-plugin/blob/master/docs/template-option.md
+     */
+    template?: string;
+    /**
+     * Allow to use a html string instead of reading from a file
+     */
+    templateContent?:
+      | false // Use the template option instead to load a file
+      | string
+      | ((templateParameters: {
+          [option: string]: any;
+        }) => string | Promise<string>)
+      | Promise<string>;
+    /**
+     * Allows to overwrite the parameters used in the template
+     */
+    templateParameters?:
+      | false // Pass an empty object to the template function
+      | ((
+          compilation: Compilation,
+          assets: {
+            publicPath: string;
+            js: Array<string>;
+            css: Array<string>;
+            favicon?: string;
+          },
+          assetTags: {
+            headTags: HtmlTagObject[];
+            bodyTags: HtmlTagObject[];
+          },
+          options: ProcessedOptions,
+        ) => { [option: string]: any } | Promise<{ [option: string]: any }>)
+      | { [option: string]: any };
+    /**
+     * The title to use for the generated HTML document
+     */
+    title?: string;
+    /**
+     * Enforce self closing tags e.g. <link />
+     */
+    xhtml?: boolean;
+    /**
+     * In addition to the options actually used by this plugin, you can use this hash to pass arbitrary data through
+     * to your template.
+     */
+    [option: string]: any;
+  }
+
+  /**
+   * The plugin options after adding default values
+   */
+  interface ProcessedOptions extends Required<Options> {
+    minify?: Options['minify'];
+  }
+
+  /**
+   * The values which are available during template execution
+   *
+   * Please keep in mind that the `templateParameter` options allows to change them
+   */
+  interface TemplateParameter {
+    compilation: Compilation;
+    htmlWebpackPlugin: {
+      tags: {
+        headTags: HtmlTagObject[];
+        bodyTags: HtmlTagObject[];
+      };
+      files: {
+        publicPath: string;
+        js: Array<string>;
+        css: Array<string>;
+        favicon?: string;
+      };
+      options: Options;
+    };
+    webpackConfig: any;
+  }
+
+  interface Hooks {
+    alterAssetTags: AsyncSeriesWaterfallHook<{
+      assetTags: {
+        scripts: HtmlTagObject[];
+        styles: HtmlTagObject[];
+        meta: HtmlTagObject[];
+      };
+      publicPath: string;
+      outputName: string;
+      plugin: HtmlRspackPlugin;
+    }>;
+
+    alterAssetTagGroups: AsyncSeriesWaterfallHook<{
+      headTags: HtmlTagObject[];
+      bodyTags: HtmlTagObject[];
+      outputName: string;
+      publicPath: string;
+      plugin: HtmlRspackPlugin;
+    }>;
+
+    afterTemplateExecution: AsyncSeriesWaterfallHook<{
+      html: string;
+      headTags: HtmlTagObject[];
+      bodyTags: HtmlTagObject[];
+      outputName: string;
+      plugin: HtmlRspackPlugin;
+    }>;
+
+    beforeAssetTagGeneration: AsyncSeriesWaterfallHook<{
+      assets: {
+        publicPath: string;
+        js: Array<string>;
+        css: Array<string>;
+        favicon?: string;
+      };
+      outputName: string;
+      plugin: HtmlRspackPlugin;
+    }>;
+
+    beforeEmit: AsyncSeriesWaterfallHook<{
+      html: string;
+      outputName: string;
+      plugin: HtmlRspackPlugin;
+    }>;
+
+    afterEmit: AsyncSeriesWaterfallHook<{
+      outputName: string;
+      plugin: HtmlRspackPlugin;
+    }>;
+  }
+
+  /**
+   * A tag element according to the htmlWebpackPlugin object notation
+   */
+  interface HtmlTagObject {
+    /**
+     * Attributes of the html tag
+     * E.g. `{'disabled': true, 'value': 'demo'}`
+     */
+    attributes: {
+      [attributeName: string]: string | boolean | null | undefined;
+    };
+    /**
+     * The tag name e.g. `'div'`
+     */
+    tagName: string;
+    /**
+     * The inner HTML
+     */
+    innerHTML?: string;
+    /**
+     * Whether this html must not contain innerHTML
+     * @see https://www.w3.org/TR/html5/syntax.html#void-elements
+     */
+    voidTag: boolean;
+    /**
+     * Meta information about the tag
+     * E.g. `{'plugin': 'html-webpack-plugin'}`
+     */
+    meta: {
+      plugin?: string;
+      [metaAttributeName: string]: any;
+    };
+  }
+}
+
+export { HtmlRspackPlugin as default };

packages/core/compiled/html-rspack-plugin/license

+Copyright JS Foundation and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

packages/core/compiled/html-rspack-plugin/loader.js

+/* This loader renders the template with lodash.template if no other loader was found */
+// @ts-nocheck
+
+/**
+ * This is a minimal implementation of `lodash.template`
+ * Modified based on lodash v4.17.21
+ * License: https://github.com/lodash/lodash/blob/main/LICENSE
+ */
+/** Used to match template delimiters. */
+const reEscape = /<%-([\s\S]+?)%>/g;
+/** Used to match template delimiters. */
+const reEvaluate = /<%([\s\S]+?)%>/g;
+/** Used to match template delimiters. */
+const reInterpolate = /<%=([\s\S]+?)%>/g;
+/** Used to match empty string literals in compiled template source. */
+const reEmptyStringLeading = /\b__p \+= '';/g,
+  reEmptyStringMiddle = /\b(__p \+=) '' \+/g,
+  reEmptyStringTrailing = /(__e\(.*?\)|\b__t\)) \+\n'';/g;
+
+/** Used to match unescaped characters in compiled string literals. */
+const reUnescapedString = /['\n\r\u2028\u2029\\]/g;
+
+/** Used to escape characters for inclusion in compiled string literals. */
+const stringEscapes = {
+  '\\': '\\',
+  "'": "'",
+  '\n': 'n',
+  '\r': 'r',
+  '\u2028': 'u2028',
+  '\u2029': 'u2029',
+};
+
+const escapeStringChar = (chr) => '\\' + stringEscapes[chr];
+
+function template(string) {
+  let isEscaping;
+  let isEvaluating;
+  let index = 0;
+  let source = "__p += '";
+
+  // Compile the regexp to match each delimiter.
+  const reDelimiters = RegExp(
+    reEscape.source +
+      '|' +
+      reInterpolate.source +
+      '|' +
+      reEvaluate.source +
+      '|$',
+    'g',
+  );
+
+  string.replace(
+    reDelimiters,
+    function (
+      match,
+      escapeValue,
+      interpolateValue,
+      evaluateValue,
+      offset,
+    ) {
+      // Escape characters that can't be included in string literals.
+      source += string
+        .slice(index, offset)
+        .replace(reUnescapedString, escapeStringChar);
+
+      // Replace delimiters with snippets.
+      if (escapeValue) {
+        isEscaping = true;
+        source += "' +\n__e(" + escapeValue + ") +\n'";
+      }
+      if (evaluateValue) {
+        isEvaluating = true;
+        source += "';\n" + evaluateValue + ";\n__p += '";
+      }
+      if (interpolateValue) {
+        source +=
+          "' +\n((__t = (" + interpolateValue + ")) == null ? '' : __t) +\n'";
+      }
+      index = offset + match.length;
+
+      // The JS engine embedded in Adobe products needs `match` returned in
+      // order to produce the correct `offset` value.
+      return match;
+    },
+  );
+
+  source += "';\n";
+
+  // Cleanup code by stripping empty strings.
+  source = (isEvaluating ? source.replace(reEmptyStringLeading, '') : source)
+    .replace(reEmptyStringMiddle, '$1')
+    .replace(reEmptyStringTrailing, '$1;');
+
+  // Frame code as the function body.
+  source =
+    'function(' +
+    'data' +
+    ') {\n' +
+    "let __t, __p = ''" +
+    (isEscaping ? ', __e = lodashEscape' : '') +
+    (isEvaluating
+      ? ', __j = Array.prototype.join;\n' +
+        "function print() { __p += __j.call(arguments, '') }\n"
+      : ';\n') +
+    source +
+    'return __p\n}';
+
+  return { compiled: source, isEscaping };
+}
+
+module.exports = function (source) {
+  const allLoadersButThisOne = this.loaders.filter(
+    (loader) => loader.normal !== module.exports,
+  );
+
+  // This loader shouldn't kick in if there is any other loader
+  if (allLoadersButThisOne.length > 0) {
+    return source;
+  }
+
+  // Allow only one html-webpack-plugin loader to allow loader options in the webpack config
+  const htmlWebpackPluginLoaders = this.loaders.filter(
+    (loader) => loader.normal === module.exports,
+  );
+  const lastHtmlRspackPluginLoader =
+    htmlWebpackPluginLoaders[htmlWebpackPluginLoaders.length - 1];
+  if (this.loaders[this.loaderIndex] !== lastHtmlRspackPluginLoader) {
+    return source;
+  }
+
+  if (/\.(c|m)?js$/.test(this.resourcePath)) {
+    return source;
+  }
+
+  const escapeCode = `const htmlEscapes = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#39;",
+};
+const escapeHtmlChar = (key) => htmlEscapes[key];
+const reUnescapedHtml = /[&<>"']/g, reHasUnescapedHtml = RegExp(reUnescapedHtml.source);
+
+function lodashEscape(string) {
+  string = string.toString();
+  return string && reHasUnescapedHtml.test(string)
+    ? string.replace(reUnescapedHtml, escapeHtmlChar)
+    : string;
+};`;
+
+  // The following part renders the template with lodash as a minimalistic loader
+  const { compiled, isEscaping } = template(source);
+  // Use `eval("require")("lodash")` to enforce using the native nodejs require
+  // during template execution
+  return `
+module.exports = function (templateParams) { with(templateParams) {
+  ${isEscaping ? escapeCode : ''}
+  // Execute the lodash template
+  return (${compiled})(); 
+}}`;
+};

packages/core/compiled/html-rspack-plugin/package.json

+{"name":"html-rspack-plugin","author":"Jan Nicklas <j.nicklas@me.com> (https://github.com/jantimon)","version":"6.0.0-beta.9","funding":{"type":"opencollective","url":"https://opencollective.com/html-webpack-plugin"},"license":"MIT","types":"index.d.ts","type":"commonjs"}

packages/core/compiled/http-proxy-middleware/license

+The MIT License (MIT)
+
+Copyright (c) 2015 Steven Chim
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

packages/core/compiled/http-proxy-middleware/package.json

+{"name":"http-proxy-middleware","author":"Steven Chim","version":"2.0.6","license":"MIT","types":"index.d.ts","type":"commonjs"}

packages/core/compiled/jiti/index.d.ts

+export = any;

packages/core/compiled/jiti/license

+MIT License
+
+Copyright (c) Pooya Parsa <pooya@pi0.io>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

packages/core/compiled/jiti/package.json

+{"name":"jiti","version":"1.21.6","license":"MIT","types":"index.d.ts","type":"commonjs"}

packages/core/compiled/launch-editor-middleware/index.d.ts

+export = any;

packages/core/compiled/launch-editor-middleware/license

+The MIT License (MIT)
+
+Copyright (c) 2017-present, Yuxi (Evan) You
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

packages/core/compiled/launch-editor-middleware/package.json

+{"name":"launch-editor-middleware","author":"Evan You","version":"2.8.0","license":"MIT","types":"index.d.ts","type":"commonjs"}

packages/core/compiled/on-finished/index.d.ts

+/// <reference types="node" />
+import { IncomingMessage, OutgoingMessage } from 'http';
+
+declare function onFinished<T extends IncomingMessage | OutgoingMessage>(
+    msg: T,
+    listener: (err: Error | null, msg: T) => void,
+): T;
+
+declare namespace onFinished {
+    function isFinished(msg: IncomingMessage | OutgoingMessage): boolean;
+}
+
+export { onFinished as default };

packages/core/compiled/on-finished/index.js

+(() => {
+  "use strict";
+  var __webpack_modules__ = {
+    261: (module) => {
+      /*!
+       * ee-first
+       * Copyright(c) 2014 Jonathan Ong
+       * MIT Licensed
+       */
+      module.exports = first;
+      function first(stuff, done) {
+        if (!Array.isArray(stuff))
+          throw new TypeError("arg must be an array of [ee, events...] arrays");
+        var cleanups = [];
+        for (var i = 0; i < stuff.length; i++) {
+          var arr = stuff[i];
+          if (!Array.isArray(arr) || arr.length < 2)
+            throw new TypeError("each array member must be [ee, events...]");
+          var ee = arr[0];
+          for (var j = 1; j < arr.length; j++) {
+            var event = arr[j];
+            var fn = listener(event, callback);
+            ee.on(event, fn);
+            cleanups.push({ ee, event, fn });
+          }
+        }
+        function callback() {
+          cleanup();
+          done.apply(null, arguments);
+        }
+        function cleanup() {
+          var x;
+          for (var i = 0; i < cleanups.length; i++) {
+            x = cleanups[i];
+            x.ee.removeListener(x.event, x.fn);
+          }
+        }
+        function thunk(fn) {
+          done = fn;
+        }
+        thunk.cancel = cleanup;
+        return thunk;
+      }
+      function listener(event, done) {
+        return function onevent(arg1) {
+          var args = new Array(arguments.length);
+          var ee = this;
+          var err = event === "error" ? arg1 : null;
+          for (var i = 0; i < args.length; i++) {
+            args[i] = arguments[i];
+          }
+          done(err, ee, event, args);
+        };
+      }
+    },
+    772: (module, __unused_webpack_exports, __nccwpck_require__) => {
+      /*!
+       * on-finished
+       * Copyright(c) 2013 Jonathan Ong
+       * Copyright(c) 2014 Douglas Christopher Wilson
+       * MIT Licensed
+       */
+      module.exports = onFinished;
+      module.exports.isFinished = isFinished;
+      var asyncHooks = tryRequireAsyncHooks();
+      var first = __nccwpck_require__(261);
+      var defer =
+        typeof setImmediate === "function"
+          ? setImmediate
+          : function (fn) {
+              process.nextTick(fn.bind.apply(fn, arguments));
+            };
+      function onFinished(msg, listener) {
+        if (isFinished(msg) !== false) {
+          defer(listener, null, msg);
+          return msg;
+        }
+        attachListener(msg, wrap(listener));
+        return msg;
+      }
+      function isFinished(msg) {
+        var socket = msg.socket;
+        if (typeof msg.finished === "boolean") {
+          return Boolean(msg.finished || (socket && !socket.writable));
+        }
+        if (typeof msg.complete === "boolean") {
+          return Boolean(
+            msg.upgrade ||
+              !socket ||
+              !socket.readable ||
+              (msg.complete && !msg.readable),
+          );
+        }
+        return undefined;
+      }
+      function attachFinishedListener(msg, callback) {
+        var eeMsg;
+        var eeSocket;
+        var finished = false;
+        function onFinish(error) {
+          eeMsg.cancel();
+          eeSocket.cancel();
+          finished = true;
+          callback(error);
+        }
+        eeMsg = eeSocket = first([[msg, "end", "finish"]], onFinish);
+        function onSocket(socket) {
+          msg.removeListener("socket", onSocket);
+          if (finished) return;
+          if (eeMsg !== eeSocket) return;
+          eeSocket = first([[socket, "error", "close"]], onFinish);
+        }
+        if (msg.socket) {
+          onSocket(msg.socket);
+          return;
+        }
+        msg.on("socket", onSocket);
+        if (msg.socket === undefined) {
+          patchAssignSocket(msg, onSocket);
+        }
+      }
+      function attachListener(msg, listener) {
+        var attached = msg.__onFinished;
+        if (!attached || !attached.queue) {
+          attached = msg.__onFinished = createListener(msg);
+          attachFinishedListener(msg, attached);
+        }
+        attached.queue.push(listener);
+      }
+      function createListener(msg) {
+        function listener(err) {
+          if (msg.__onFinished === listener) msg.__onFinished = null;
+          if (!listener.queue) return;
+          var queue = listener.queue;
+          listener.queue = null;
+          for (var i = 0; i < queue.length; i++) {
+            queue[i](err, msg);
+          }
+        }
+        listener.queue = [];
+        return listener;
+      }
+      function patchAssignSocket(res, callback) {
+        var assignSocket = res.assignSocket;
+        if (typeof assignSocket !== "function") return;
+        res.assignSocket = function _assignSocket(socket) {
+          assignSocket.call(this, socket);
+          callback(socket);
+        };
+      }
+      function tryRequireAsyncHooks() {
+        try {
+          return __nccwpck_require__(852);
+        } catch (e) {
+          return {};
+        }
+      }
+      function wrap(fn) {
+        var res;
+        if (asyncHooks.AsyncResource) {
+          res = new asyncHooks.AsyncResource(fn.name || "bound-anonymous-fn");
+        }
+        if (!res || !res.runInAsyncScope) {
+          return fn;
+        }
+        return res.runInAsyncScope.bind(res, fn, null);
+      }
+    },
+    852: (module) => {
+      module.exports = require("async_hooks");
+    },
+  };
+  var __webpack_module_cache__ = {};
+  function __nccwpck_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (cachedModule !== undefined) {
+      return cachedModule.exports;
+    }
+    var module = (__webpack_module_cache__[moduleId] = { exports: {} });
+    var threw = true;
+    try {
+      __webpack_modules__[moduleId](
+        module,
+        module.exports,
+        __nccwpck_require__,
+      );
+      threw = false;
+    } finally {
+      if (threw) delete __webpack_module_cache__[moduleId];
+    }
+    return module.exports;
+  }
+  if (typeof __nccwpck_require__ !== "undefined")
+    __nccwpck_require__.ab = __dirname + "/";
+  var __webpack_exports__ = __nccwpck_require__(772);
+  module.exports = __webpack_exports__;
+})();

packages/core/compiled/on-finished/license

+(The MIT License)
+
+Copyright (c) 2013 Jonathan Ong <me@jongleberry.com>
+Copyright (c) 2014 Douglas Christopher Wilson <doug@somethingdoug.com>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

packages/core/compiled/on-finished/package.json

+{"name":"on-finished","version":"2.4.1","license":"MIT","types":"index.d.ts","type":"commonjs"}

packages/core/compiled/open/index.d.ts

+export = any;

packages/core/compiled/open/package.json

+{"name":"open","author":{"name":"Sindre Sorhus","email":"sindresorhus@gmail.com","url":"https://sindresorhus.com"},"version":"8.4.2","funding":"https://github.com/sponsors/sindresorhus","license":"MIT","types":"index.d.ts","type":"commonjs"}

packages/core/compiled/picocolors/index.d.ts

+type Formatter = (input: string | number | null | undefined) => string
+
+interface Colors {
+	isColorSupported: boolean
+	reset: Formatter
+	bold: Formatter
+	dim: Formatter
+	italic: Formatter
+	underline: Formatter
+	inverse: Formatter
+	hidden: Formatter
+	strikethrough: Formatter
+	black: Formatter
+	red: Formatter
+	green: Formatter
+	yellow: Formatter
+	blue: Formatter
+	magenta: Formatter
+	cyan: Formatter
+	white: Formatter
+	gray: Formatter
+	bgBlack: Formatter
+	bgRed: Formatter
+	bgGreen: Formatter
+	bgYellow: Formatter
+	bgBlue: Formatter
+	bgMagenta: Formatter
+	bgCyan: Formatter
+	bgWhite: Formatter
+}
+
+declare const picocolors: Colors & { createColors: (enabled?: boolean) => Colors }
+
+export { picocolors as default };

packages/core/compiled/picocolors/index.js

+(() => {
+  var __webpack_modules__ = {
+    701: (module, __unused_webpack_exports, __nccwpck_require__) => {
+      let argv = process.argv || [],
+        env = process.env;
+      let isColorSupported =
+        !("NO_COLOR" in env || argv.includes("--no-color")) &&
+        ("FORCE_COLOR" in env ||
+          argv.includes("--color") ||
+          process.platform === "win32" ||
+          (require != null &&
+            __nccwpck_require__(224).isatty(1) &&
+            env.TERM !== "dumb") ||
+          "CI" in env);
+      let formatter =
+        (open, close, replace = open) =>
+        (input) => {
+          let string = "" + input;
+          let index = string.indexOf(close, open.length);
+          return ~index
+            ? open + replaceClose(string, close, replace, index) + close
+            : open + string + close;
+        };
+      let replaceClose = (string, close, replace, index) => {
+        let result = "";
+        let cursor = 0;
+        do {
+          result += string.substring(cursor, index) + replace;
+          cursor = index + close.length;
+          index = string.indexOf(close, cursor);
+        } while (~index);
+        return result + string.substring(cursor);
+      };
+      let createColors = (enabled = isColorSupported) => {
+        let init = enabled ? formatter : () => String;
+        return {
+          isColorSupported: enabled,
+          reset: init("", ""),
+          bold: init("", "", ""),
+          dim: init("", "", ""),
+          italic: init("", ""),
+          underline: init("", ""),
+          inverse: init("", ""),
+          hidden: init("", ""),
+          strikethrough: init("", ""),
+          black: init("", ""),
+          red: init("", ""),
+          green: init("", ""),
+          yellow: init("", ""),
+          blue: init("", ""),
+          magenta: init("", ""),
+          cyan: init("", ""),
+          white: init("", ""),
+          gray: init("", ""),
+          bgBlack: init("", ""),
+          bgRed: init("", ""),
+          bgGreen: init("", ""),
+          bgYellow: init("", ""),
+          bgBlue: init("", ""),
+          bgMagenta: init("", ""),
+          bgCyan: init("", ""),
+          bgWhite: init("", ""),
+        };
+      };
+      module.exports = createColors();
+      module.exports.createColors = createColors;
+    },
+    224: (module) => {
+      "use strict";
+      module.exports = require("tty");
+    },
+  };
+  var __webpack_module_cache__ = {};
+  function __nccwpck_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (cachedModule !== undefined) {
+      return cachedModule.exports;
+    }
+    var module = (__webpack_module_cache__[moduleId] = { exports: {} });
+    var threw = true;
+    try {
+      __webpack_modules__[moduleId](
+        module,
+        module.exports,
+        __nccwpck_require__,
+      );
+      threw = false;
+    } finally {
+      if (threw) delete __webpack_module_cache__[moduleId];
+    }
+    return module.exports;
+  }
+  if (typeof __nccwpck_require__ !== "undefined")
+    __nccwpck_require__.ab = __dirname + "/";
+  var __webpack_exports__ = __nccwpck_require__(701);
+  module.exports = __webpack_exports__;
+})();

packages/core/compiled/picocolors/license

+ISC License
+
+Copyright (c) 2021 Alexey Raspopov, Kostiantyn Denysov, Anton Verinov
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

packages/core/compiled/picocolors/package.json

+{"name":"picocolors","author":"Alexey Raspopov","version":"1.0.1","license":"ISC","types":"index.d.ts","type":"commonjs"}

packages/core/compiled/postcss-load-config/index.d.ts

+export = any;

packages/core/compiled/postcss-load-config/license

+The MIT License (MIT)
+
+Copyright Michael Ciniawsky <michael.ciniawsky@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

packages/core/compiled/postcss-load-config/package.json

+{"name":"postcss-load-config","author":"Michael Ciniawky <michael.ciniawsky@gmail.com>","version":"6.0.1","funding":[{"type":"opencollective","url":"https://opencollective.com/postcss/"},{"type":"github","url":"https://github.com/sponsors/ai"}],"license":"MIT","types":"index.d.ts","type":"commonjs"}

packages/core/compiled/postcss-loader/index.d.ts

+export = any;

packages/core/compiled/postcss-loader/license

+Copyright JS Foundation and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
\ No newline at end of file

packages/core/compiled/postcss-loader/package.json

+{"name":"postcss-loader","author":"Andrey Sitnik <andrey@sitnik.ru>","version":"8.1.1","funding":{"type":"opencollective","url":"https://opencollective.com/webpack"},"license":"MIT","types":"index.d.ts","type":"commonjs"}

packages/core/compiled/postcss-loader/semver.js

+module.exports.satisfies = () => true;
\ No newline at end of file

packages/core/compiled/rslog/index.d.ts

+type ColorFn = (input: string | number | null | undefined) => string;
+
+declare let LOG_TYPES: {
+    error: {
+        label: string;
+        level: "error";
+        color: ColorFn;
+    };
+    warn: {
+        label: string;
+        level: "warn";
+        color: ColorFn;
+    };
+    info: {
+        label: string;
+        level: "info";
+        color: ColorFn;
+    };
+    start: {
+        label: string;
+        level: "info";
+        color: ColorFn;
+    };
+    ready: {
+        label: string;
+        level: "info";
+        color: ColorFn;
+    };
+    success: {
+        label: string;
+        level: "info";
+        color: ColorFn;
+    };
+    log: {
+        level: "log";
+    };
+    debug: {
+        label: string;
+        level: "verbose";
+        color: ColorFn;
+    };
+};
+
+type LogLevel = 'error' | 'warn' | 'info' | 'log' | 'verbose';
+type LogMessage = unknown;
+interface LogType {
+    label?: string;
+    level: LogLevel;
+    color?: ColorFn;
+}
+type LogFunction = (message?: LogMessage, ...args: any[]) => void;
+interface Options {
+    level?: LogLevel;
+}
+type LogMethods = keyof typeof LOG_TYPES;
+type Logger = Record<LogMethods, LogFunction> & {
+    greet: (message: string) => void;
+    level: LogLevel;
+    override: (customLogger: Partial<Record<LogMethods, LogFunction>>) => void;
+};
+
+declare let createLogger: (options?: Options) => Logger;
+
+declare let logger: Logger;
+
+export { type LogFunction, type LogLevel, type LogMessage, type LogType, type Logger, type Options, createLogger, logger };

packages/core/compiled/rslog/license

+MIT License
+
+Copyright (c) 2023-present Bytedance, Inc. and its affiliates.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

packages/core/compiled/rslog/package.json

+{"name":"rslog","version":"1.2.2","types":"index.d.ts","type":"commonjs"}

packages/core/compiled/rspack-chain/package.json

+{"name":"rspack-chain","author":"rspack-contrib","version":"0.7.4","license":"MPL-2.0","types":"index.d.ts","type":"commonjs"}

packages/core/compiled/rspack-manifest-plugin/index.d.ts

+export = any;

packages/core/compiled/rspack-manifest-plugin/license

+The MIT License (MIT)
+
+Copyright (c) Dane Thurber <dane.thurber@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

packages/core/compiled/rspack-manifest-plugin/package.json

+{"name":"rspack-manifest-plugin","author":"Dane Thurber <dane.thurber@gmail.com>","version":"5.0.1","license":"MIT","types":"index.d.ts","type":"commonjs"}

packages/core/compiled/sirv/index.d.ts

+export = any;

packages/core/compiled/sirv/package.json

+{"name":"sirv","author":{"name":"Luke Edwards","email":"luke@lukeed.com","url":"https://lukeed.com"},"version":"2.0.4","license":"MIT","types":"index.d.ts","type":"commonjs"}

packages/core/compiled/style-loader/index.d.ts

+export = any;

packages/core/compiled/style-loader/license

+Copyright JS Foundation and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

packages/core/compiled/style-loader/package.json

+{"name":"style-loader","author":"Tobias Koppers @sokra","version":"3.3.4","funding":{"type":"opencollective","url":"https://opencollective.com/webpack"},"license":"MIT","types":"index.d.ts","type":"commonjs"}

packages/core/compiled/style-loader/runtime/injectStylesIntoLinkTag.js

+"use strict";
+
+module.exports = function (url, options) {
+  if (typeof document === "undefined") {
+    return function () {};
+  }
+  options = options || {};
+  options.attributes = typeof options.attributes === "object" ? options.attributes : {};
+  if (typeof options.attributes.nonce === "undefined") {
+    var nonce = typeof __webpack_nonce__ !== "undefined" ? __webpack_nonce__ : null;
+    if (nonce) {
+      options.attributes.nonce = nonce;
+    }
+  }
+  var linkElement = document.createElement("link");
+  linkElement.rel = "stylesheet";
+  linkElement.href = url;
+  Object.keys(options.attributes).forEach(function (key) {
+    linkElement.setAttribute(key, options.attributes[key]);
+  });
+  options.insert(linkElement);
+  return function (newUrl) {
+    if (typeof newUrl === "string") {
+      linkElement.href = newUrl;
+    } else {
+      linkElement.parentNode.removeChild(linkElement);
+    }
+  };
+};
\ No newline at end of file