@rspack/core 1.0.0-alpha.4 → 1.0.0-beta.0

package/dist/config/browserslistTargetHandler.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * The following code is modified based on
  * https://github.com/webpack/webpack/blob/4b4ca3b/lib/config/browserslistTargetHandler.js
@@ -7,43 +8,38 @@
  * Copyright (c) JS Foundation and other contributors
  * https://github.com/webpack/webpack/blob/main/LICENSE
  */
-"use strict";
-const browserslist = require("../../compiled/browserslist");
-const path = require("path");
-/** @typedef {import("./target").ApiTargetProperties} ApiTargetProperties */
-/** @typedef {import("./target").EcmaTargetProperties} EcmaTargetProperties */
-/** @typedef {import("./target").PlatformTargetProperties} PlatformTargetProperties */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolve = exports.load = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const browserslist_1 = __importDefault(require("../../compiled/browserslist"));
 // [[C:]/path/to/config][:env]
 const inputRx = /^(?:((?:[A-Z]:)?[/\\].*?))?(?::(.+?))?$/i;
 /**
- * @typedef {Object} BrowserslistHandlerConfig
- * @property {string=} configPath
- * @property {string=} env
- * @property {string=} query
- */
-/**
- * @param {string | null | undefined} input input string
- * @param {string} context the context directory
- * @returns {BrowserslistHandlerConfig} config
+ * @param input input string
+ * @param context the context directory
+ * @returns config
  */
 const parse = (input, context) => {
     if (!input) {
         return {};
     }
-    if (path.isAbsolute(input)) {
+    if (node_path_1.default.isAbsolute(input)) {
         const [, configPath, env] = inputRx.exec(input) || [];
         return { configPath, env };
     }
-    const config = browserslist.findConfig(context);
+    const config = browserslist_1.default.findConfig(context);
     if (config && Object.keys(config).includes(input)) {
         return { env: input };
     }
     return { query: input };
 };
 /**
- * @param {string | null | undefined} input input string
- * @param {string} context the context directory
- * @returns {string[] | undefined} selected browsers
+ * @param input input string
+ * @param context the context directory
+ * @returns selected browsers
  */
 const load = (input, context) => {
     const { configPath, env, query } = parse(input, context);
@@ -53,26 +49,27 @@ const load = (input, context) => {
     const config = query
         ? query
         : configPath
-            ? browserslist.loadConfig({
+            ? browserslist_1.default.loadConfig({
                 config: configPath,
                 env
             })
-            : browserslist.loadConfig({ path: context, env });
+            : browserslist_1.default.loadConfig({ path: context, env });
     if (!config)
         return;
-    return browserslist(config);
+    return (0, browserslist_1.default)(config);
 };
+exports.load = load;
 /**
- * @param {string[]} browsers supported browsers list
- * @returns {EcmaTargetProperties & PlatformTargetProperties & ApiTargetProperties} target properties
+ * @param browsers supported browsers list
+ * @returns target properties
  */
-const resolve = browsers => {
+const resolve = (browsers) => {
     /**
      * Checks all against a version number
-     * @param {Record<string, number | [number, number]>} versions first supported version
-     * @returns {boolean} true if supports
+     * @param versions first supported version
+     * @returns true if supports
      */
-    const rawChecker = versions => {
+    const rawChecker = (versions) => {
         return browsers.every(v => {
             const [name, parsedVersion] = v.split(" ");
             if (!name)
@@ -344,7 +341,4 @@ const resolve = browsers => {
         require: nodeProperty
     };
 };
-module.exports = {
-    resolve,
-    load
-};
+exports.resolve = resolve;

package/dist/config/defaults.js

@@ -13,23 +13,23 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.applyRspackOptionsBaseDefaults = exports.applyRspackOptionsDefaults = void 0;
-const assert_1 = __importDefault(require("assert"));
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
 const ModuleTypeConstants_1 = require("../ModuleTypeConstants");
+const Template_1 = require("../Template");
 const builtin_plugin_1 = require("../builtin-plugin");
 const util_1 = require("../util");
 const assertNotNil_1 = require("../util/assertNotNil");
 const cleverMerge_1 = require("../util/cleverMerge");
 const target_1 = require("./target");
-const Template = require("../Template");
 const applyRspackOptionsDefaults = (options) => {
     F(options, "context", () => process.cwd());
     F(options, "target", () => {
         return (0, target_1.getDefaultTarget)(options.context);
     });
     const { mode, target } = options;
-    (0, assert_1.default)(!(0, util_1.isNil)(target));
+    (0, node_assert_1.default)(!(0, util_1.isNil)(target));
     const targetProperties = target === false
         ? false
         : typeof target === "string"
@@ -188,8 +188,8 @@ const applyModuleDefaults = (module, { asyncWebAssembly, css, targetProperties }
         // IGNORE(module.generator): already check to align in 2024.6.27
         F(module.generator, "css", () => ({}));
         (0, assertNotNil_1.assertNotNill)(module.generator.css);
-        D(module.generator["css"], "exportsOnly", !targetProperties || !targetProperties.document);
-        D(module.generator["css"], "esModule", true);
+        D(module.generator.css, "exportsOnly", !targetProperties || !targetProperties.document);
+        D(module.generator.css, "esModule", true);
         F(module.generator, "css/auto", () => ({}));
         (0, assertNotNil_1.assertNotNill)(module.generator["css/auto"]);
         D(module.generator["css/auto"], "exportsOnly", !targetProperties || !targetProperties.document);
@@ -340,10 +340,10 @@ const applyOutputDefaults = (output, { context, outputModule, targetProperties:
         if (Array.isArray(libraryName)) {
             return libraryName.join(".");
         }
-        else if (typeof libraryName === "object") {
+        if (typeof libraryName === "object") {
             return getLibraryName(libraryName.root);
         }
-        else if (typeof libraryName === "string") {
+        if (typeof libraryName === "string") {
             return libraryName;
         }
         return "";
@@ -357,9 +357,9 @@ const applyOutputDefaults = (output, { context, outputModule, targetProperties:
         });
         if (libraryName)
             return libraryName;
-        const pkgPath = path_1.default.resolve(context, "package.json");
+        const pkgPath = node_path_1.default.resolve(context, "package.json");
         try {
-            const packageInfo = JSON.parse(fs_1.default.readFileSync(pkgPath, "utf-8"));
+            const packageInfo = JSON.parse(node_fs_1.default.readFileSync(pkgPath, "utf-8"));
             return packageInfo.name || "";
         }
         catch (err) {
@@ -406,13 +406,12 @@ const applyOutputDefaults = (output, { context, outputModule, targetProperties:
     });
     D(output, "hotUpdateChunkFilename", `[id].[fullhash].hot-update.${output.module ? "mjs" : "js"}`);
     D(output, "hotUpdateMainFilename", "[runtime].[fullhash].hot-update.json");
-    const uniqueNameId = Template.toIdentifier(
-    /** @type {NonNullable<Output["uniqueName"]>} */ output.uniqueName);
+    const uniqueNameId = Template_1.Template.toIdentifier(output.uniqueName);
     F(output, "hotUpdateGlobal", () => "webpackHotUpdate" + uniqueNameId);
     F(output, "chunkLoadingGlobal", () => "webpackChunk" + uniqueNameId);
     D(output, "assetModuleFilename", "[hash][ext][query]");
     D(output, "webassemblyModuleFilename", "[hash].module.wasm");
-    F(output, "path", () => path_1.default.join(process.cwd(), "dist"));
+    F(output, "path", () => node_path_1.default.join(process.cwd(), "dist"));
     F(output, "pathinfo", () => development);
     D(output, "publicPath", tp && (tp.document || tp.importScripts) ? "auto" : "");
     D(output, "hashFunction", futureDefaults ? "xxhash64" : "md4");
@@ -437,20 +436,18 @@ const applyOutputDefaults = (output, { context, outputModule, targetProperties:
                     "JSONP Array push can be chosen when 'document' is available.\n" +
                     helpMessage);
             }
-            else {
-                if (tp.document)
-                    return "array-push";
-                if (tp.require)
-                    return "commonjs";
-                if (tp.nodeBuiltins)
-                    return "commonjs";
-                if (tp.importScripts)
-                    return "array-push";
-                throw new Error("For the selected environment is no default script chunk format available:\n" +
-                    "JSONP Array push can be chosen when 'document' or 'importScripts' is available.\n" +
-                    "CommonJs exports can be chosen when 'require' or node builtins are available.\n" +
-                    helpMessage);
-            }
+            if (tp.document)
+                return "array-push";
+            if (tp.require)
+                return "commonjs";
+            if (tp.nodeBuiltins)
+                return "commonjs";
+            if (tp.importScripts)
+                return "array-push";
+            throw new Error("For the selected environment is no default script chunk format available:\n" +
+                "JSONP Array push can be chosen when 'document' or 'importScripts' is available.\n" +
+                "CommonJs exports can be chosen when 'require' or node builtins are available.\n" +
+                helpMessage);
         }
         throw new Error("Chunk format can't be selected by default when no target is specified");
     });
@@ -539,6 +536,8 @@ const applyOutputDefaults = (output, { context, outputModule, targetProperties:
     D(output, "workerPublicPath", "");
     D(output, "sourceMapFilename", "[file].map[query]");
     F(output, "scriptType", () => (output.module ? "module" : false));
+    D(output, "charset", true);
+    D(output, "chunkLoadTimeout", 120000);
     const { trustedTypes } = output;
     if (trustedTypes) {
         F(trustedTypes, "policyName", () => output.uniqueName.replace(/[^a-zA-Z0-9\-#=_/@.%]+/g, "_") || "webpack");

package/dist/config/normalization.d.ts

@@ -70,6 +70,8 @@ export interface OutputNormalized {
     devtoolModuleFilenameTemplate?: DevtoolModuleFilenameTemplate;
     devtoolFallbackModuleFilenameTemplate?: DevtoolFallbackModuleFilenameTemplate;
     environment?: Environment;
+    charset?: boolean;
+    chunkLoadTimeout?: number;
 }
 export interface ModuleOptionsNormalized {
     defaultRules?: RuleSetRules;

package/dist/config/normalization.js

@@ -17,11 +17,9 @@ const getNormalizedRspackOptions = (config) => {
                 if (typeof ignore === "function") {
                     return ignore;
                 }
-                else {
-                    return (warning) => {
-                        return ignore.test(warning.message);
-                    };
-                }
+                return (warning) => {
+                    return ignore.test(warning.message);
+                };
             })
             : undefined,
         name: config.name,
@@ -117,6 +115,8 @@ const getNormalizedRspackOptions = (config) => {
                 devtoolNamespace: output.devtoolNamespace,
                 devtoolModuleFilenameTemplate: output.devtoolModuleFilenameTemplate,
                 devtoolFallbackModuleFilenameTemplate: output.devtoolFallbackModuleFilenameTemplate,
+                chunkLoadTimeout: output.chunkLoadTimeout,
+                charset: output.charset,
                 environment: cloneObject(output.environment)
             };
         }),

package/dist/config/target.d.ts

@@ -1,150 +1,89 @@
+/**
+ * @param context the context directory
+ * @returns default target
+ */
+export declare const getDefaultTarget: (context: string) => "browserslist" | "web";
 export type PlatformTargetProperties = {
-    /**
-     * web platform, importing of http(s) and std: is available
-     */
+    /** web platform, importing of http(s) and std: is available */
     web: boolean | null;
-    /**
-     * browser platform, running in a normal web browser
-     */
+    /** browser platform, running in a normal web browser */
     browser: boolean | null;
-    /**
-     * (Web)Worker platform, running in a web/shared/service worker
-     */
+    /** (Web)Worker platform, running in a web/shared/service worker */
     webworker: boolean | null;
-    /**
-     * node platform, require of node built-in modules is available
-     */
+    /** node platform, require of node built-in modules is available */
     node: boolean | null;
-    /**
-     * nwjs platform, require of legacy nw.gui is available
-     */
+    /** nwjs platform, require of legacy nw.gui is available */
     nwjs: boolean | null;
-    /**
-     * electron platform, require of some electron built-in modules is available
-     */
+    /** electron platform, require of some electron built-in modules is available */
     electron: boolean | null;
 };
 export type ElectronContextTargetProperties = {
-    /**
-     * in main context
-     */
+    /**  in main context */
     electronMain: boolean | null;
-    /**
-     * in preload context
-     */
+    /**  in preload context */
     electronPreload: boolean | null;
-    /**
-     * in renderer context with node integration
-     */
+    /**  in renderer context with node integration */
     electronRenderer: boolean | null;
 };
 export type ApiTargetProperties = {
-    /**
-     * has require function available
-     */
+    /**  has require function available */
     require: boolean | null;
-    /**
-     * has node.js built-in modules available
-     */
+    /**  has node.js built-in modules available */
     nodeBuiltins: boolean | null;
-    /**
-     * node.js allows to use `node:` prefix for core modules
-     */
+    /**  node.js allows to use `node:` prefix for core modules */
     nodePrefixForCoreModules: boolean | null;
-    /**
-     * has document available (allows script tags)
-     */
+    /**  has document available (allows script tags) */
     document: boolean | null;
-    /**
-     * has importScripts available
-     */
+    /**  has importScripts available */
     importScripts: boolean | null;
-    /**
-     * has importScripts available when creating a worker
-     */
+    /**  has importScripts available when creating a worker */
     importScriptsInWorker: boolean | null;
-    /**
-     * has fetch function available for WebAssembly
-     */
+    /**  has fetch function available for WebAssembly */
     fetchWasm: boolean | null;
-    /**
-     * has global variable available
-     */
+    /**  has global variable available */
     global: boolean | null;
 };
 export type EcmaTargetProperties = {
-    /**
-     * has globalThis variable available
-     */
+    /**  has globalThis variable available */
     globalThis: boolean | null;
-    /**
-     * big int literal syntax is available
-     */
+    /**  big int literal syntax is available */
     bigIntLiteral: boolean | null;
-    /**
-     * const and let variable declarations are available
-     */
+    /**  const and let variable declarations are available */
     const: boolean | null;
-    /**
-     * arrow functions are available
-     */
+    /**  arrow functions are available */
     arrowFunction: boolean | null;
-    /**
-     * for of iteration is available
-     */
+    /**  for of iteration is available */
     forOf: boolean | null;
-    /**
-     * destructuring is available
-     */
+    /**  destructuring is available */
     destructuring: boolean | null;
-    /**
-     * async import() is available
-     */
+    /**  async import() is available */
     dynamicImport: boolean | null;
-    /**
-     * async import() is available when creating a worker
-     */
+    /**  async import() is available when creating a worker */
     dynamicImportInWorker: boolean | null;
-    /**
-     * ESM syntax is available (when in module)
-     */
+    /**  ESM syntax is available (when in module) */
     module: boolean | null;
-    /**
-     * optional chaining is available
-     */
+    /**  optional chaining is available */
     optionalChaining: boolean | null;
-    /**
-     * template literal is available
-     */
+    /**  template literal is available */
     templateLiteral: boolean | null;
-    /**
-     * async functions and await are available
-     */
+    /**  async functions and await are available */
     asyncFunction: boolean | null;
 };
+type Never<T> = {
+    [P in keyof T]?: never;
+};
+type Mix<A, B> = (A & Never<B>) | (Never<A> & B) | (A & B);
+type TargetProperties = Mix<Mix<PlatformTargetProperties, ElectronContextTargetProperties>, Mix<ApiTargetProperties, EcmaTargetProperties>>;
 /**
- * <T>
- */
-export type Never<T> = { [P in keyof T]?: undefined; };
-/**
- * <A, B>
- */
-export type Mix<A, B> = (A & Never<B>) | (Never<A> & B) | (A & B);
-export type TargetProperties = Mix<Mix<PlatformTargetProperties, ElectronContextTargetProperties>, Mix<ApiTargetProperties, EcmaTargetProperties>>;
-/**
- * @param {string} context the context directory
- * @returns {"browserslist" | "web"} default target
- */
-export function getDefaultTarget(context: string): "browserslist" | "web";
-/**
- * @param {string} target the target
- * @param {string} context the context directory
- * @returns {TargetProperties} target properties
+ * @param target the target
+ * @param context the context directory
+ * @returns target properties
  */
-export function getTargetProperties(target: string, context: string): TargetProperties;
+export declare const getTargetProperties: (target: string, context: string) => TargetProperties;
 /**
- * @param {string[]} targets the targets
- * @param {string} context the context directory
- * @returns {TargetProperties} target properties
+ * @param targets the targets
+ * @param context the context directory
+ * @returns target properties
  */
-export function getTargetsProperties(targets: string[], context: string): TargetProperties;
+export declare const getTargetsProperties: (targets: string[], context: string) => TargetProperties;
+export {};

package/dist/config/target.js

@@ -1,3 +1,29 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTargetsProperties = exports.getTargetProperties = exports.getDefaultTarget = void 0;
 /**
  * The following code is modified based on
  * https://github.com/webpack/webpack/blob/4b4ca3b/lib/config/target.js
@@ -7,87 +33,33 @@
  * Copyright (c) JS Foundation and other contributors
  * https://github.com/webpack/webpack/blob/main/LICENSE
  */
-"use strict";
-const { memoize } = require("../util/memoize");
-const getBrowserslistTargetHandler = memoize(() => require("./browserslistTargetHandler"));
+const memoize_1 = require("../util/memoize");
+const browserslistTargetHandler = __importStar(require("./browserslistTargetHandler"));
+const getBrowserslistTargetHandler = (0, memoize_1.memoize)(() => browserslistTargetHandler);
 /**
- * @param {string} context the context directory
- * @returns {"browserslist" | "web"} default target
+ * @param context the context directory
+ * @returns default target
  */
-const getDefaultTarget = context => {
+const getDefaultTarget = (context) => {
     const browsers = getBrowserslistTargetHandler().load(null, context);
     return browsers ? "browserslist" : "web";
 };
+exports.getDefaultTarget = getDefaultTarget;
 /**
- * @typedef {Object} PlatformTargetProperties
- * @property {boolean | null} web web platform, importing of http(s) and std: is available
- * @property {boolean | null} browser browser platform, running in a normal web browser
- * @property {boolean | null} webworker (Web)Worker platform, running in a web/shared/service worker
- * @property {boolean | null} node node platform, require of node built-in modules is available
- * @property {boolean | null} nwjs nwjs platform, require of legacy nw.gui is available
- * @property {boolean | null} electron electron platform, require of some electron built-in modules is available
- */
-/**
- * @typedef {Object} ElectronContextTargetProperties
- * @property {boolean | null} electronMain in main context
- * @property {boolean | null} electronPreload in preload context
- * @property {boolean | null} electronRenderer in renderer context with node integration
- */
-/**
- * @typedef {Object} ApiTargetProperties
- * @property {boolean | null} require has require function available
- * @property {boolean | null} nodeBuiltins has node.js built-in modules available
- * @property {boolean | null} nodePrefixForCoreModules node.js allows to use `node:` prefix for core modules
- * @property {boolean | null} document has document available (allows script tags)
- * @property {boolean | null} importScripts has importScripts available
- * @property {boolean | null} importScriptsInWorker has importScripts available when creating a worker
- * @property {boolean | null} fetchWasm has fetch function available for WebAssembly
- * @property {boolean | null} global has global variable available
- */
-/**
- * @typedef {Object} EcmaTargetProperties
- * @property {boolean | null} globalThis has globalThis variable available
- * @property {boolean | null} bigIntLiteral big int literal syntax is available
- * @property {boolean | null} const const and let variable declarations are available
- * @property {boolean | null} arrowFunction arrow functions are available
- * @property {boolean | null} forOf for of iteration is available
- * @property {boolean | null} destructuring destructuring is available
- * @property {boolean | null} dynamicImport async import() is available
- * @property {boolean | null} dynamicImportInWorker async import() is available when creating a worker
- * @property {boolean | null} module ESM syntax is available (when in module)
- * @property {boolean | null} optionalChaining optional chaining is available
- * @property {boolean | null} templateLiteral template literal is available
- * @property {boolean | null} asyncFunction async functions and await are available
- */
-///** @typedef {PlatformTargetProperties | ApiTargetProperties | EcmaTargetProperties | PlatformTargetProperties & ApiTargetProperties | PlatformTargetProperties & EcmaTargetProperties | ApiTargetProperties & EcmaTargetProperties} TargetProperties */
-/**
- * @template T
- * @typedef {{ [P in keyof T]?: never }} Never<T>
- */
-/**
- * @template A
- * @template B
- * @typedef {(A & Never<B>) | (Never<A> & B) | (A & B)} Mix<A, B>
- */
-/** @typedef {Mix<Mix<PlatformTargetProperties, ElectronContextTargetProperties>, Mix<ApiTargetProperties, EcmaTargetProperties>>} TargetProperties */
-/**
- * @param {string} major major version
- * @param {string | undefined} minor minor version
- * @returns {(vMajor: number, vMinor?: number) => boolean | undefined} check if version is greater or equal
+ * @param major major version
+ * @param minor minor version
+ * @returns check if version is greater or equal
  */
 const versionDependent = (major, minor) => {
     if (!major) {
-        return () => /** @type {undefined} */ (undefined);
+        return () => undefined;
     }
-    /** @type {number} */
     const nMajor = +major;
-    /** @type {number} */
     const nMinor = minor ? +minor : 0;
     return (vMajor, vMinor = 0) => {
         return nMajor > vMajor || (nMajor === vMajor && nMinor >= vMinor);
     };
 };
-/** @type {[string, string, RegExp, (...args: string[]) => Partial<TargetProperties>][]} */
 const TARGETS = [
     [
         "browserslist / browserslist:env / browserslist:query / browserslist:path-to-config / browserslist:path-to-config:env",
@@ -291,9 +263,9 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
     ]
 ];
 /**
- * @param {string} target the target
- * @param {string} context the context directory
- * @returns {TargetProperties} target properties
+ * @param target the target
+ * @param context the context directory
+ * @returns target properties
  */
 const getTargetProperties = (target, context) => {
     for (const [, , regExp, handler] of TARGETS) {
@@ -302,24 +274,19 @@ const getTargetProperties = (target, context) => {
             const [, ...args] = match;
             const result = handler(...args, context);
             if (result)
-                return /** @type {TargetProperties} */ (result);
+                return result;
         }
     }
     throw new Error(`Unknown target '${target}'. The following targets are supported:\n${TARGETS.map(([name, description]) => `* ${name}: ${description}`).join("\n")}`);
 };
-/**
- * @param {TargetProperties[]} targetProperties array of target properties
- * @returns {TargetProperties} merged target properties
- */
-const mergeTargetProperties = targetProperties => {
-    /** @type {Set<keyof TargetProperties>} */
+exports.getTargetProperties = getTargetProperties;
+const mergeTargetProperties = (targetProperties) => {
     const keys = new Set();
     for (const tp of targetProperties) {
         for (const key of Object.keys(tp)) {
-            keys.add(/** @type {keyof TargetProperties} */ (key));
+            keys.add(key);
         }
     }
-    /** @type {Object} */
     const result = {};
     for (const key of keys) {
         let hasTrue = false;
@@ -336,19 +303,16 @@ const mergeTargetProperties = targetProperties => {
             }
         }
         if (hasTrue || hasFalse)
-            /** @type {TargetProperties} */
-            (result)[key] = hasFalse && hasTrue ? null : hasTrue ? true : false;
+            result[key] = hasFalse && hasTrue ? null : hasTrue;
     }
-    return /** @type {TargetProperties} */ (result);
+    return result;
 };
 /**
- * @param {string[]} targets the targets
- * @param {string} context the context directory
- * @returns {TargetProperties} target properties
+ * @param targets the targets
+ * @param context the context directory
+ * @returns target properties
  */
 const getTargetsProperties = (targets, context) => {
-    return mergeTargetProperties(targets.map(t => getTargetProperties(t, context)));
+    return mergeTargetProperties(targets.map(t => (0, exports.getTargetProperties)(t, context)));
 };
-exports.getDefaultTarget = getDefaultTarget;
-exports.getTargetProperties = getTargetProperties;
 exports.getTargetsProperties = getTargetsProperties;