@rspack/core 1.0.0-beta.2 → 1.0.0-beta.4

package/dist/stats/DefaultStatsPresetPlugin.js

@@ -39,12 +39,13 @@ const NAMED_PRESETS = {
         orphanModules: true,
         runtimeModules: true,
         // exclude: false,
-        // errorsSpace: Infinity,
-        // warningsSpace: Infinity,
+        excludeModules: false,
+        errorsSpace: Number.POSITIVE_INFINITY,
+        warningsSpace: Number.POSITIVE_INFINITY,
         modulesSpace: Number.POSITIVE_INFINITY,
-        // chunkModulesSpace: Infinity,
+        chunkModulesSpace: Number.POSITIVE_INFINITY,
         assetsSpace: Number.POSITIVE_INFINITY,
-        // reasonsSpace: Infinity,
+        reasonsSpace: Number.POSITIVE_INFINITY,
         children: true
     },
     detailed: {
@@ -66,20 +67,20 @@ const NAMED_PRESETS = {
         publicPath: true,
         logging: true,
         runtimeModules: true,
-        // exclude: false,
-        // errorsSpace: 1000,
-        // warningsSpace: 1000,
+        excludeModules: false,
+        errorsSpace: 1000,
+        warningsSpace: 1000,
         modulesSpace: 1000,
-        assetsSpace: 1000
-        // reasonsSpace: 1000
+        assetsSpace: 1000,
+        reasonsSpace: 1000
     },
     minimal: {
         all: false,
         version: true,
         timings: true,
         modules: true,
-        // errorsSpace: 0,
-        // warningsSpace: 0,
+        errorsSpace: 0,
+        warningsSpace: 0,
         modulesSpace: 0,
         assets: true,
         assetsSpace: 0,
@@ -93,7 +94,7 @@ const NAMED_PRESETS = {
         all: false,
         errors: true,
         errorsCount: true,
-        // errorsSpace: Infinity,
+        errorsSpace: Number.POSITIVE_INFINITY,
         moduleTrace: true,
         logging: "error"
     },
@@ -101,10 +102,10 @@ const NAMED_PRESETS = {
         all: false,
         errors: true,
         errorsCount: true,
-        // errorsSpace: Infinity,
+        errorsSpace: Number.POSITIVE_INFINITY,
         warnings: true,
         warningsCount: true,
-        // warningsSpace: Infinity,
+        warningsSpace: Number.POSITIVE_INFINITY,
         logging: "warn"
     },
     summary: {
@@ -197,7 +198,7 @@ const DEFAULTS = {
     cachedModules: ({ all, cached }, { forToString }) => cached !== undefined ? cached : forToString ? all === true : all !== false,
     moduleAssets: OFF_FOR_TO_STRING,
     depth: OFF_FOR_TO_STRING,
-    // cachedAssets: OFF_FOR_TO_STRING,
+    cachedAssets: OFF_FOR_TO_STRING,
     reasons: OFF_FOR_TO_STRING,
     reasonsSpace: (o, { forToString }) => forToString ? 15 : Number.POSITIVE_INFINITY,
     groupReasonsByOrigin: ON_FOR_TO_STRING,
@@ -271,9 +272,7 @@ const NORMALIZER = {
         });
     },
     logging: (value) => {
-        if (value === true)
-            value = "log";
-        return value;
+        return value === true ? "log" : value;
     },
     loggingDebug: (value) => {
         const array = !Array.isArray(value) ? (value ? [value] : []) : value;

package/dist/stats/StatsFactory.js

@@ -39,12 +39,11 @@ class StatsFactory {
             ]))
         });
         const hooks = this.hooks;
-        this._caches = Object.keys(hooks).reduce((prev, curr) => {
-            return {
-                ...prev,
-                [curr]: new Map()
-            };
-        }, {});
+        const caches = {};
+        for (const key of Object.keys(hooks)) {
+            caches[key] = new Map();
+        }
+        this._caches = caches;
         this._inCreate = false;
     }
     _getAllLevelHooks(hookMap, cache, type) {
@@ -71,10 +70,9 @@ class StatsFactory {
         }
     }
     _forEachLevelWaterfall(hookMap, cache, type, data, fn) {
-        for (const hook of this._getAllLevelHooks(hookMap, cache, type)) {
-            data = fn(hook, data);
-        }
-        return data;
+        return this._getAllLevelHooks(hookMap, cache, type).reduce((data, hook) => {
+            return fn(hook, data);
+        }, data);
     }
     _forEachLevelFilter(hookMap, cache, type, items, fn, forceClone) {
         const hooks = this._getAllLevelHooks(hookMap, cache, type);

package/dist/stats/StatsPrinter.js

@@ -71,10 +71,9 @@ class StatsPrinter {
         }
     }
     _forEachLevelWaterfall(hookMap, type, data, fn) {
-        for (const hook of this._getAllLevelHooks(hookMap, type)) {
-            data = fn(hook, data);
-        }
-        return data;
+        return this._getAllLevelHooks(hookMap, type).reduce((data, hook) => {
+            return fn(hook, data);
+        }, data);
     }
     print(type, object, baseContext) {
         if (this._inPrint) {

package/dist/stats/statsFactoryUtils.d.ts

@@ -1,16 +1,89 @@
 /// <reference types="node" />
 import type * as binding from "@rspack/binding";
+import type { JsOriginRecord } from "@rspack/binding";
 import type { Compilation, NormalizedStatsOptions } from "../Compilation";
 import { type Comparator } from "../util/comparators";
 import type { StatsFactory, StatsFactoryContext } from "./StatsFactory";
-export type KnownStatsChunkGroup = binding.JsStatsChunkGroup;
-export type KnownStatsChunk = Omit<binding.JsStatsChunk, "sizes" | "origins"> & {
-    sizes: Record<string, number>;
-    origins: StatsChunkOrigin[];
+export type KnownStatsChunkGroup = {
+    name?: string;
+    chunks?: (string | number)[];
+    assets?: {
+        name: string;
+        size?: number;
+    }[];
+    filteredAssets?: number;
+    assetsSize?: number;
+    auxiliaryAssets?: {
+        name: string;
+        size?: number;
+    }[];
+    filteredAuxiliaryAssets?: number;
+    auxiliaryAssetsSize?: number;
+    children?: {
+        preload?: StatsChunkGroup[];
+        prefetch?: StatsChunkGroup[];
+    };
+    childAssets?: {
+        preload?: string[];
+        prefetch?: string[];
+    };
+    isOverSizeLimit?: boolean;
+};
+export type KnownStatsChunk = {
+    type: string;
+    rendered: boolean;
+    initial: boolean;
+    entry: boolean;
+    reason?: string;
+    size: number;
+    sizes?: Record<string, number>;
+    names?: string[];
+    idHints?: string[];
+    runtime?: string[];
+    files?: string[];
+    auxiliaryFiles?: string[];
+    hash?: string;
+    childrenByOrder?: Record<string, (string | number)[]>;
+    id?: string | number;
+    siblings?: (string | number)[];
+    parents?: (string | number)[];
+    children?: (string | number)[];
+    modules?: StatsModule[];
+    filteredModules?: number;
+    origins?: StatsChunkOrigin[];
+};
+export type KnownAssetInfo = {
+    immutable?: boolean;
+    minimized?: boolean;
+    fullhash?: string | string[];
+    chunkhash?: string | string[];
+    contenthash?: string | string[];
+    sourceFilename?: string;
+    size?: number;
+    development?: boolean;
+    hotModuleReplacement?: boolean;
+    javascriptModule?: boolean;
+    related?: Record<string, string | string[]>;
+};
+export type AssetInfo = KnownAssetInfo & Record<string, any>;
+export type StatsChunkGroup = KnownStatsChunkGroup & Record<string, any>;
+export type KnownStatsAsset = {
+    type: string;
+    name: string;
+    info: AssetInfo;
+    size: number;
+    emitted: boolean;
+    cached: boolean;
+    related?: StatsAsset[];
+    chunkNames?: (string | number)[];
+    chunkIdHints?: (string | number)[];
+    chunks?: (string | null | undefined)[];
+    auxiliaryChunkNames?: (string | number)[];
+    auxiliaryChunks?: (string | null | undefined)[];
+    auxiliaryChunkIdHints?: (string | number)[];
+    filteredRelated?: number;
+    isOverSizeLimit?: boolean;
 };
-export type KnownStatsAssetInfo = Omit<binding.JsStatsAssetInfo, "related">;
-export type StatsChunkGroup = binding.JsStatsChunkGroup & Record<string, any>;
-export type KnownStatsAsset = Omit<binding.JsStatsAsset, "info">;
 export type StatsAsset = KnownStatsAsset & Record<string, any>;
 export type StatsChunk = KnownStatsChunk & Record<string, any>;
 export type KnownStatsModule = {
@@ -61,15 +134,28 @@ export type KnownStatsProfile = {
     building: number;
 };
 export type StatsModule = KnownStatsModule & Record<string, any>;
-export type StatsModuleIssuer = Omit<binding.JsStatsModuleIssuer, "identifier"> & {
+export type KnownStatsModuleIssuer = {
     identifier?: string;
-} & Record<string, any>;
-export type StatsError = Omit<binding.JsStatsError, "moduleIdentifier"> & {
-    moduleIdentifier?: string;
-} & Record<string, any>;
-export type StatsWarnings = Omit<binding.JsStatsWarning, "moduleIdentifier"> & {
+    name?: string;
+    id?: string | number;
+};
+export type StatsModuleIssuer = KnownStatsModuleIssuer & Record<string, any>;
+export type KnownStatsError = {
+    message: string;
+    chunkName?: string;
+    chunkEntry?: boolean;
+    chunkInitial?: boolean;
+    file?: string;
     moduleIdentifier?: string;
-} & Record<string, any>;
+    moduleName?: string;
+    loc?: string;
+    chunkId?: string | number;
+    moduleId?: string | number;
+    moduleTrace?: StatsModuleTraceItem[];
+    details?: any;
+    stack?: string;
+};
+export type StatsError = KnownStatsError & Record<string, any>;
 export type StatsModuleTraceItem = {
     originIdentifier?: string;
     originName?: string;
@@ -78,9 +164,18 @@ export type StatsModuleTraceItem = {
     originId?: string;
     moduleId?: string;
 };
-export type StatsModuleReason = Omit<binding.JsStatsModuleReason, "moduleIdentifier"> & {
+export type KnownStatsModuleReason = {
     moduleIdentifier?: string;
-} & Record<string, any>;
+    module?: string;
+    moduleName?: string;
+    resolvedModuleIdentifier?: string;
+    resolvedModule?: string;
+    type?: string;
+    userRequest?: string;
+    moduleId?: string | null;
+    resolvedModuleId?: string | number | null;
+};
+export type StatsModuleReason = KnownStatsModuleReason & Record<string, any>;
 export type KnownStatsChunkOrigin = {
     module: string;
     moduleIdentifier: string;
@@ -112,7 +207,7 @@ export type KnownStatsCompilation = {
     namedChunkGroups?: Record<string, StatsChunkGroup>;
     errors?: StatsError[];
     errorsCount?: number;
-    warnings?: StatsWarnings[];
+    warnings?: StatsError[];
     warningsCount?: number;
     filteredModules?: number;
     children?: StatsCompilation[];
@@ -137,7 +232,7 @@ export type KnownStatsLoggingEntry = {
 type ExtractorsByOption<T, O> = {
     [x: string]: (object: O, data: T, context: StatsFactoryContext, options: any, factory: StatsFactory) => void;
 };
-export type PreprocessedAsset = StatsAsset & {
+export type PreprocessedAsset = binding.JsStatsAsset & {
     type: string;
     related: PreprocessedAsset[];
     info: binding.JsStatsAssetInfo;
@@ -156,8 +251,9 @@ export type SimpleExtractors = {
     profile: ExtractorsByOption<binding.JsStatsModuleProfile, StatsProfile>;
     moduleReason: ExtractorsByOption<binding.JsStatsModuleReason, StatsModuleReason>;
     chunk: ExtractorsByOption<binding.JsStatsChunk, KnownStatsChunk>;
+    chunkOrigin: ExtractorsByOption<JsOriginRecord, StatsChunkOrigin>;
     error: ExtractorsByOption<binding.JsStatsError, StatsError>;
-    warning: ExtractorsByOption<binding.JsStatsWarning, StatsWarnings>;
+    warning: ExtractorsByOption<binding.JsStatsWarning, StatsError>;
     moduleTraceItem: ExtractorsByOption<binding.JsStatsModuleTrace, StatsModuleTraceItem>;
 };
 export declare const uniqueArray: <T, I>(items: Iterable<T>, selector: (arg: T) => Iterable<I>) => I[];
@@ -188,4 +284,8 @@ export declare const mergeToObject: (items: {
     name: string;
 }[]) => Object;
 export declare function resolveStatsMillisecond(s: binding.JsStatsMillisecond): number;
+export declare const errorsSpaceLimit: (errors: StatsError[], max: number) => {
+    errors: StatsError[];
+    filtered: number;
+};
 export {};

package/dist/stats/statsFactoryUtils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveStatsMillisecond = exports.mergeToObject = exports.moduleGroup = exports.assetGroup = exports.sortByField = exports.countWithChildren = exports.spaceLimited = exports.collapse = exports.getTotalItems = exports.iterateConfig = exports.uniqueOrderedArray = exports.uniqueArray = void 0;
+exports.errorsSpaceLimit = exports.resolveStatsMillisecond = exports.mergeToObject = exports.moduleGroup = exports.assetGroup = exports.sortByField = exports.countWithChildren = exports.spaceLimited = exports.collapse = exports.getTotalItems = exports.iterateConfig = exports.uniqueOrderedArray = exports.uniqueArray = void 0;
 const comparators_1 = require("../util/comparators");
 const uniqueArray = (items, selector) => {
     const set = new Set();
@@ -279,3 +279,64 @@ function resolveStatsMillisecond(s) {
     return s.secs * 1000 + s.subsecMillis;
 }
 exports.resolveStatsMillisecond = resolveStatsMillisecond;
+const errorsSpaceLimit = (errors, max) => {
+    let filtered = 0;
+    // Can not fit into limit
+    // print only messages
+    if (errors.length + 1 >= max) {
+        return {
+            errors: errors.map(error => {
+                if (typeof error === "string" || !error.details)
+                    return error;
+                filtered++;
+                return { ...error, details: "" };
+            }),
+            filtered
+        };
+    }
+    let fullLength = errors.length;
+    let result = errors;
+    let i = 0;
+    for (; i < errors.length; i++) {
+        const error = errors[i];
+        if (typeof error !== "string" && error.details) {
+            const splitted = error.details.split("\n");
+            const len = splitted.length;
+            fullLength += len;
+            if (fullLength > max) {
+                result = i > 0 ? errors.slice(0, i) : [];
+                const overLimit = fullLength - max + 1;
+                const error = errors[i++];
+                result.push({
+                    ...error,
+                    details: error.details.split("\n").slice(0, -overLimit).join("\n"),
+                    filteredDetails: overLimit
+                });
+                filtered = errors.length - i;
+                for (; i < errors.length; i++) {
+                    const error = errors[i];
+                    if (typeof error === "string" || !error.details)
+                        result.push(error);
+                    result.push({ ...error, details: "" });
+                }
+                break;
+            }
+            if (fullLength === max) {
+                result = errors.slice(0, ++i);
+                filtered = errors.length - i;
+                for (; i < errors.length; i++) {
+                    const error = errors[i];
+                    if (typeof error === "string" || !error.details)
+                        result.push(error);
+                    result.push({ ...error, details: "" });
+                }
+                break;
+            }
+        }
+    }
+    return {
+        errors: result,
+        filtered
+    };
+};
+exports.errorsSpaceLimit = errorsSpaceLimit;

package/dist/util/assertNotNil.d.ts

@@ -1 +1 @@
-export declare function assertNotNill(value: any): asserts value;
+export declare function assertNotNill(value: unknown): asserts value;

package/dist/util/assetCondition.d.ts

@@ -0,0 +1,2 @@
+export type AssetCondition = string | RegExp;
+export type AssetConditions = AssetCondition | AssetCondition[];

package/dist/util/assetCondition.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/util/cleverMerge.js

@@ -247,11 +247,12 @@ const _cleverMerge = (first, second, internalCaching = false) => {
         : parseObject(first);
     const { static: firstInfo, dynamic: firstDynamicInfo } = firstObject;
     // If the first argument has a dynamic part we modify the dynamic part to merge the second argument
+    let secondObj = second;
     if (firstDynamicInfo !== undefined) {
         let { byProperty, fn } = firstDynamicInfo;
         const fnInfo = fn[DYNAMIC_INFO];
         if (fnInfo) {
-            second = internalCaching
+            secondObj = internalCaching
                 ? (0, exports.cachedCleverMerge)(fnInfo[1], second)
                 : (0, exports.cleverMerge)(fnInfo[1], second);
             fn = fnInfo[0];
@@ -259,10 +260,10 @@ const _cleverMerge = (first, second, internalCaching = false) => {
         const newFn = (...args) => {
             const fnResult = fn(...args);
             return internalCaching
-                ? (0, exports.cachedCleverMerge)(fnResult, second)
-                : (0, exports.cleverMerge)(fnResult, second);
+                ? (0, exports.cachedCleverMerge)(fnResult, secondObj)
+                : (0, exports.cleverMerge)(fnResult, secondObj);
         };
-        newFn[DYNAMIC_INFO] = [fn, second];
+        newFn[DYNAMIC_INFO] = [fn, secondObj];
         return serializeObject(firstObject.static, { byProperty, fn: newFn });
     }
     // If the first part is static only, we merge the static parts and keep the dynamic part of the second argument

package/dist/util/createHash.js

@@ -113,12 +113,17 @@ class DebugHash extends hash_1.default {
      * @returns updated hash
      */
     update(data, _inputEncoding) {
-        if (typeof data !== "string")
-            data = data.toString("utf-8");
-        if (data.startsWith("debug-digest-")) {
-            data = Buffer.from(data.slice("debug-digest-".length), "hex").toString();
+        let normalizedData;
+        if (typeof data !== "string") {
+            normalizedData = data.toString("utf-8");
         }
-        this.string += `[${data}](${new Error().stack?.split("\n", 3)[2]})\n`;
+        else {
+            normalizedData = data;
+        }
+        if (normalizedData.startsWith("debug-digest-")) {
+            normalizedData = Buffer.from(normalizedData.slice("debug-digest-".length), "hex").toString();
+        }
+        this.string += `[${normalizedData}](${new Error().stack?.split("\n", 3)[2]})\n`;
         return this;
     }
     /**

package/dist/util/hash/wasm-hash.js

@@ -43,11 +43,12 @@ class WasmHash {
      */
     update(data, encoding) {
         if (typeof data === "string") {
-            while (data.length > exports.MAX_SHORT_STRING) {
-                this._updateWithShortString(data.slice(0, exports.MAX_SHORT_STRING), encoding);
-                data = data.slice(exports.MAX_SHORT_STRING);
+            let normalizedData = data;
+            while (normalizedData.length > exports.MAX_SHORT_STRING) {
+                this._updateWithShortString(normalizedData.slice(0, exports.MAX_SHORT_STRING), encoding);
+                normalizedData = normalizedData.slice(exports.MAX_SHORT_STRING);
             }
-            this._updateWithShortString(data, encoding);
+            this._updateWithShortString(normalizedData, encoding);
             return this;
         }
         this._updateWithBuffer(data);

package/dist/util/identifier.d.ts

@@ -70,10 +70,10 @@ export declare const parseResourceWithoutFragment: {
     bindCache(associatedObjectForCache: object): (str: string) => ParsedResourceWithoutFragment;
 };
 /**
- * @param {string} filename the filename which should be undone
- * @param {string} outputPath the output path that is restored (only relevant when filename contains "..")
- * @param {boolean} enforceRelative true returns ./ for empty paths
- * @returns {string} repeated ../ to leave the directory of the provided filename to be back on output dir
+ * @param filename the filename which should be undone
+ * @param outputPath the output path that is restored (only relevant when filename contains "..")
+ * @param enforceRelative true returns ./ for empty paths
+ * @returns repeated ../ to leave the directory of the provided filename to be back on output dir
  */
 export declare const getUndoPath: (filename: string, outputPath: string, enforceRelative: boolean) => string;
 export {};

package/dist/util/identifier.js

@@ -293,28 +293,28 @@ const _parseResourceWithoutFragment = (str) => {
 };
 exports.parseResourceWithoutFragment = makeCacheable(_parseResourceWithoutFragment);
 /**
- * @param {string} filename the filename which should be undone
- * @param {string} outputPath the output path that is restored (only relevant when filename contains "..")
- * @param {boolean} enforceRelative true returns ./ for empty paths
- * @returns {string} repeated ../ to leave the directory of the provided filename to be back on output dir
+ * @param filename the filename which should be undone
+ * @param outputPath the output path that is restored (only relevant when filename contains "..")
+ * @param enforceRelative true returns ./ for empty paths
+ * @returns repeated ../ to leave the directory of the provided filename to be back on output dir
  */
 const getUndoPath = (filename, outputPath, enforceRelative) => {
     let depth = -1;
     let append = "";
-    outputPath = outputPath.replace(/[\\/]$/, "");
+    let path = outputPath.replace(/[\\/]$/, "");
     for (const part of filename.split(/[/\\]+/)) {
         if (part === "..") {
             if (depth > -1) {
                 depth--;
             }
             else {
-                const i = outputPath.lastIndexOf("/");
-                const j = outputPath.lastIndexOf("\\");
+                const i = path.lastIndexOf("/");
+                const j = path.lastIndexOf("\\");
                 const pos = i < 0 ? j : j < 0 ? i : Math.max(i, j);
                 if (pos < 0)
-                    return `${outputPath}/`;
-                append = `${outputPath.slice(pos + 1)}/${append}`;
-                outputPath = outputPath.slice(0, pos);
+                    return `${path}/`;
+                append = `${path.slice(pos + 1)}/${append}`;
+                path = path.slice(0, pos);
             }
         }
         else if (part !== ".") {

package/dist/util/memoize.js

@@ -4,15 +4,16 @@ exports.memoizeValue = exports.memoizeFn = exports.memoize = void 0;
 const memoize = (fn) => {
     let cache = false;
     let result;
+    let callback = fn;
     return () => {
         if (cache) {
             return result;
         }
-        result = fn();
+        result = callback();
         cache = true;
         // Allow to clean up memory for fn
         // and all dependent resources
-        fn = undefined;
+        callback = undefined;
         return result;
     };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rspack/core",
-  "version": "1.0.0-beta.2",
+  "version": "1.0.0-beta.4",
   "webpackVersion": "5.75.0",
   "license": "MIT",
   "description": "The fast Rust-based web bundler with webpack-compatible API",
@@ -58,9 +58,9 @@
   },
   "dependencies": {
     "@module-federation/runtime-tools": "0.2.3",
+    "@rspack/lite-tapable": "1.0.0-beta.5",
     "caniuse-lite": "^1.0.30001616",
-    "@rspack/lite-tapable": "1.0.0-beta.2",
-    "@rspack/binding": "1.0.0-beta.2"
+    "@rspack/binding": "1.0.0-beta.4"
   },
   "peerDependencies": {
     "@swc/helpers": ">=0.5.1"

package/dist/builtin-plugin/css-extract/loader-options.json

@@ -1,37 +0,0 @@
-{
-    "title": "Mini CSS Extract Plugin Loader options",
-    "type": "object",
-    "additionalProperties": false,
-    "properties": {
-        "publicPath": {
-            "anyOf": [
-                {
-                    "type": "string"
-                },
-                {
-                    "instanceof": "Function"
-                }
-            ],
-            "description": "Specifies a custom public path for the external resources like images, files, etc inside CSS.",
-            "link": "https://github.com/webpack-contrib/mini-css-extract-plugin#publicpath"
-        },
-        "emit": {
-            "type": "boolean",
-            "description": "If true, emits a file (writes a file to the filesystem). If false, the plugin will extract the CSS but will not emit the file",
-            "link": "https://github.com/webpack-contrib/mini-css-extract-plugin#emit"
-        },
-        "esModule": {
-            "type": "boolean",
-            "description": "Generates JS modules that use the ES modules syntax.",
-            "link": "https://github.com/webpack-contrib/mini-css-extract-plugin#esmodule"
-        },
-        "layer": {
-            "type": "string"
-        },
-        "defaultExport": {
-            "type": "boolean",
-            "description": "Duplicate the named export with CSS modules locals to the default export (only when `esModules: true` for css-loader).",
-            "link": "https://github.com/webpack-contrib/mini-css-extract-plugin#defaultexports"
-        }
-    }
-}