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

package/dist/Template.js

@@ -1,40 +1,15 @@
-/*
-    MIT License http://www.opensource.org/licenses/mit-license.php
-    Author Tobias Koppers @sokra
-*/
 "use strict";
-const { ConcatSource, PrefixSource } = require("../compiled/webpack-sources");
-const { WEBPACK_MODULE_TYPE_RUNTIME } = require("./ModuleTypeConstants");
-const RuntimeGlobals = require("./RuntimeGlobals");
-/** @typedef {import("../compiled/webpack-sources").Source} Source */
-// /** @typedef {import("../declarations/WebpackOptions").Output} OutputOptions */
-/** @typedef {any} OutputOptions */
-// /** @typedef {import("./Chunk")} Chunk */
-/** @typedef {any} Chunk */
-// /** @typedef {import("./ChunkGraph")} ChunkGraph */
-/** @typedef {any} ChunkGraph */
-// /** @typedef {import("./CodeGenerationResults")} CodeGenerationResults */
-/** @typedef {any} CodeGenerationResults */
-// /** @typedef {import("./Compilation").AssetInfo} AssetInfo */
-/** @typedef {any} AssetInfo */
-// /** @typedef {import("./Compilation").PathData} PathData */
-/** @typedef {any} PathData */
-// /** @typedef {import("./DependencyTemplates")} DependencyTemplates */
-/** @typedef {any} DependencyTemplates */
-// /** @typedef {import("./Module")} Module */
-/** @typedef {any} Module */
-// /** @typedef {import("./ModuleGraph")} ModuleGraph */
-/** @typedef {any} ModuleGraph */
-// /** @typedef {import("./ModuleTemplate")} ModuleTemplate */
-/** @typedef {any} ModuleTemplate */
-// /** @typedef {import("./RuntimeModule")} RuntimeModule */
-/** @typedef {any} RuntimeModule */
-// /** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {any} RuntimeTemplate */
-// /** @typedef {import("./javascript/JavascriptModulesPlugin").ChunkRenderContext} ChunkRenderContext */
-/** @typedef {any} ChunkRenderContext */
-// /** @typedef {import("./javascript/JavascriptModulesPlugin").RenderContext} RenderContext */
-/** @typedef {any} RenderContext */
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/Template.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Template = void 0;
 const START_LOWERCASE_ALPHABET_CODE = "a".charCodeAt(0);
 const START_UPPERCASE_ALPHABET_CODE = "A".charCodeAt(0);
 const DELTA_A_TO_Z = "z".charCodeAt(0) - START_LOWERCASE_ALPHABET_CODE + 1;
@@ -48,51 +23,11 @@ const IDENTIFIER_ALPHA_NUMERIC_NAME_REPLACE_REGEX = /[^a-zA-Z0-9$]+/g;
 const COMMENT_END_REGEX = /\*\//g;
 const PATH_NAME_NORMALIZE_REPLACE_REGEX = /[^a-zA-Z0-9_!§$()=\-^°]+/g;
 const MATCH_PADDED_HYPHENS_REPLACE_REGEX = /^-|-$/g;
-/**
- * @typedef {Object} RenderManifestOptions
- * @property {Chunk} chunk the chunk used to render
- * @property {string} hash
- * @property {string} fullHash
- * @property {OutputOptions} outputOptions
- * @property {CodeGenerationResults} codeGenerationResults
- * @property {{javascript: ModuleTemplate}} moduleTemplates
- * @property {DependencyTemplates} dependencyTemplates
- * @property {RuntimeTemplate} runtimeTemplate
- * @property {ModuleGraph} moduleGraph
- * @property {ChunkGraph} chunkGraph
- */
-/** @typedef {RenderManifestEntryTemplated | RenderManifestEntryStatic} RenderManifestEntry */
-/**
- * @typedef {Object} RenderManifestEntryTemplated
- * @property {function(): Source} render
- * @property {string | function(PathData, AssetInfo=): string} filenameTemplate
- * @property {PathData=} pathOptions
- * @property {AssetInfo=} info
- * @property {string} identifier
- * @property {string=} hash
- * @property {boolean=} auxiliary
- */
-/**
- * @typedef {Object} RenderManifestEntryStatic
- * @property {function(): Source} render
- * @property {string} filename
- * @property {AssetInfo} info
- * @property {string} identifier
- * @property {string=} hash
- * @property {boolean=} auxiliary
- */
-/**
- * @typedef {Object} HasId
- * @property {number | string} id
- */
-/**
- * @typedef {function(Module, number): boolean} ModuleFilterPredicate
- */
 class Template {
     /**
      *
-     * @param {Function} fn a runtime function (.runtime.js) "template"
-     * @returns {string} the updated and normalized function string
+     * @param fn a runtime function (.runtime.js) "template"
+     * @returns the updated and normalized function string
      */
     static getFunctionContent(fn) {
         return fn
@@ -102,8 +37,8 @@ class Template {
             .replace(LINE_SEPARATOR_REGEX, "\n");
     }
     /**
-     * @param {any} str the string converted to identifier
-     * @returns {string} created identifier
+     * @param str the string converted to identifier
+     * @returns created identifier
      */
     static toIdentifier(str) {
         if (typeof str !== "string")
@@ -114,8 +49,8 @@ class Template {
     }
     /**
      *
-     * @param {string} str string to be converted to commented in bundle code
-     * @returns {string} returns a commented version of string
+     * @param str string to be converted to commented in bundle code
+     * @returns returns a commented version of string
      */
     static toComment(str) {
         if (!str)
@@ -124,8 +59,8 @@ class Template {
     }
     /**
      *
-     * @param {string} str string to be converted to "normal comment"
-     * @returns {string} returns a commented version of string
+     * @param str string to be converted to "normal comment"
+     * @returns returns a commented version of string
      */
     static toNormalComment(str) {
         if (!str)
@@ -133,8 +68,8 @@ class Template {
         return `/* ${str.replace(COMMENT_END_REGEX, "* /")} */`;
     }
     /**
-     * @param {string} str string path to be normalized
-     * @returns {string} normalized bundle-safe path
+     * @param str string path to be normalized
+     * @returns normalized bundle-safe path
      */
     static toPath(str) {
         if (typeof str !== "string")
@@ -145,8 +80,8 @@ class Template {
     }
     // map number to a single character a-z, A-Z or multiple characters if number is too big
     /**
-     * @param {number} n number to convert to ident
-     * @returns {string} returns single character ident
+     * @param n number to convert to ident
+     * @returns returns single character ident
      */
     static numberToIdentifier(n) {
         if (n >= NUMBER_OF_IDENTIFIER_START_CHARS) {
@@ -168,8 +103,8 @@ class Template {
         return "$";
     }
     /**
-     * @param {number} n number to convert to ident
-     * @returns {string} returns single character ident
+     * @param n number to convert to ident
+     * @returns returns single character ident
      */
     static numberToIdentifierContinuation(n) {
         if (n >= NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS) {
@@ -197,26 +132,24 @@ class Template {
     }
     /**
      *
-     * @param {string | string[]} s string to convert to identity
-     * @returns {string} converted identity
+     * @param s string to convert to identity
+     * @returns converted identity
      */
     static indent(s) {
         if (Array.isArray(s)) {
             return s.map(Template.indent).join("\n");
         }
-        else {
-            const str = s.trimEnd();
-            if (!str)
-                return "";
-            const ind = str[0] === "\n" ? "" : "\t";
-            return ind + str.replace(/\n([^\n])/g, "\n\t$1");
-        }
+        const str = s.trimEnd();
+        if (!str)
+            return "";
+        const ind = str[0] === "\n" ? "" : "\t";
+        return ind + str.replace(/\n([^\n])/g, "\n\t$1");
     }
     /**
      *
-     * @param {string|string[]} s string to create prefix for
-     * @param {string} prefix prefix to compose
-     * @returns {string} returns new prefix string
+     * @param s string to create prefix for
+     * @param prefix prefix to compose
+     * @returns returns new prefix string
      */
     static prefix(s, prefix) {
         const str = Template.asString(s).trim();
@@ -227,8 +160,8 @@ class Template {
     }
     /**
      *
-     * @param {string|string[]} str string or string collection
-     * @returns {string} returns a single string from array
+     * @param str string or string collection
+     * @returns returns a single string from array
      */
     static asString(str) {
         if (Array.isArray(str)) {
@@ -237,12 +170,8 @@ class Template {
         return str;
     }
     /**
-     * @typedef {Object} WithId
-     * @property {string|number} id
-     */
-    /**
-     * @param {WithId[]} modules a collection of modules to get array bounds for
-     * @returns {[number, number] | false} returns the upper and lower array bounds
+     * @param modules a collection of modules to get array bounds for
+     * @returns returns the upper and lower array bounds
      * or false if not every module has a number based id
      */
     static getModulesArrayBounds(modules) {
@@ -271,130 +200,5 @@ class Template {
         const arrayOverhead = minId === 0 ? maxId : 16 + `${minId}`.length + maxId;
         return arrayOverhead < objectOverhead ? [minId, maxId] : false;
     }
-    /**
-     * @param {ChunkRenderContext} renderContext render context
-     * @param {Module[]} modules modules to render (should be ordered by identifier)
-     * @param {function(Module): Source} renderModule function to render a module
-     * @param {string=} prefix applying prefix strings
-     * @returns {Source | null} rendered chunk modules in a Source object or null if no modules
-     */
-    static renderChunkModules(renderContext, modules, renderModule, prefix = "") {
-        const { chunkGraph } = renderContext;
-        var source = new ConcatSource();
-        if (modules.length === 0) {
-            return null;
-        }
-        /** @type {{id: string|number, source: Source|string}[]} */
-        const allModules = modules.map(module => {
-            return {
-                id: chunkGraph.getModuleId(module),
-                source: renderModule(module) || "false"
-            };
-        });
-        const bounds = Template.getModulesArrayBounds(allModules);
-        if (bounds) {
-            // Render a spare array
-            const minId = bounds[0];
-            const maxId = bounds[1];
-            if (minId !== 0) {
-                source.add(`Array(${minId}).concat(`);
-            }
-            source.add("[\n");
-            /** @type {Map<string|number, {id: string|number, source: Source|string}>} */
-            const modules = new Map();
-            for (const module of allModules) {
-                modules.set(module.id, module);
-            }
-            for (let idx = minId; idx <= maxId; idx++) {
-                const module = modules.get(idx);
-                if (idx !== minId) {
-                    source.add(",\n");
-                }
-                source.add(`/* ${idx} */`);
-                if (module) {
-                    source.add("\n");
-                    source.add(module.source);
-                }
-            }
-            source.add("\n" + prefix + "]");
-            if (minId !== 0) {
-                source.add(")");
-            }
-        }
-        else {
-            // Render an object
-            source.add("{\n");
-            for (let i = 0; i < allModules.length; i++) {
-                const module = allModules[i];
-                if (i !== 0) {
-                    source.add(",\n");
-                }
-                source.add(`\n/***/ ${JSON.stringify(module.id)}:\n`);
-                source.add(module.source);
-            }
-            source.add(`\n\n${prefix}}`);
-        }
-        return source;
-    }
-    /**
-     * @param {RuntimeModule[]} runtimeModules array of runtime modules in order
-     * @param {RenderContext & { codeGenerationResults?: CodeGenerationResults }} renderContext render context
-     * @returns {Source} rendered runtime modules in a Source object
-     */
-    static renderRuntimeModules(runtimeModules, renderContext) {
-        const source = new ConcatSource();
-        for (const module of runtimeModules) {
-            const codeGenerationResults = renderContext.codeGenerationResults;
-            let runtimeSource;
-            if (codeGenerationResults) {
-                runtimeSource = codeGenerationResults.getSource(module, renderContext.chunk.runtime, WEBPACK_MODULE_TYPE_RUNTIME);
-            }
-            else {
-                const codeGenResult = module.codeGeneration({
-                    chunkGraph: renderContext.chunkGraph,
-                    dependencyTemplates: renderContext.dependencyTemplates,
-                    moduleGraph: renderContext.moduleGraph,
-                    runtimeTemplate: renderContext.runtimeTemplate,
-                    runtime: renderContext.chunk.runtime,
-                    codeGenerationResults
-                });
-                if (!codeGenResult)
-                    continue;
-                runtimeSource = codeGenResult.sources.get("runtime");
-            }
-            if (runtimeSource) {
-                source.add(Template.toNormalComment(module.identifier()) + "\n");
-                if (!module.shouldIsolate()) {
-                    source.add(runtimeSource);
-                    source.add("\n\n");
-                }
-                else if (renderContext.runtimeTemplate.supportsArrowFunction()) {
-                    source.add("(() => {\n");
-                    source.add(new PrefixSource("\t", runtimeSource));
-                    source.add("\n})();\n\n");
-                }
-                else {
-                    source.add("!function() {\n");
-                    source.add(new PrefixSource("\t", runtimeSource));
-                    source.add("\n}();\n\n");
-                }
-            }
-        }
-        return source;
-    }
-    /**
-     * @param {RuntimeModule[]} runtimeModules array of runtime modules in order
-     * @param {RenderContext} renderContext render context
-     * @returns {Source} rendered chunk runtime modules in a Source object
-     */
-    static renderChunkRuntimeModules(runtimeModules, renderContext) {
-        return new PrefixSource("/******/ ", new ConcatSource(
-        // @ts-expect-error
-        `function(${RuntimeGlobals.require}) { // webpackRuntimeModules\n`, this.renderRuntimeModules(runtimeModules, renderContext), "}\n"));
-    }
 }
-module.exports = Template;
-module.exports.NUMBER_OF_IDENTIFIER_START_CHARS =
-    NUMBER_OF_IDENTIFIER_START_CHARS;
-module.exports.NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS =
-    NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS;
+exports.Template = Template;

package/dist/builtin-loader/lightningcss/index.d.ts

@@ -0,0 +1,89 @@
+export declare function browserslistToTargets(browserslist: string[]): Record<string, number>;
+export declare function toFeatures(featureOptions: FeatureOptions): Features;
+export declare enum Features {
+    Empty = 0,
+    Nesting = 1,
+    NotSelectorList = 2,
+    DirSelector = 4,
+    LangSelectorList = 8,
+    IsSelector = 16,
+    TextDecorationThicknessPercent = 32,
+    MediaIntervalSyntax = 64,
+    MediaRangeSyntax = 128,
+    CustomMediaQueries = 256,
+    ClampFunction = 512,
+    ColorFunction = 1024,
+    OklabColors = 2048,
+    LabColors = 4096,
+    P3Colors = 8192,
+    HexAlphaColors = 16384,
+    SpaceSeparatedColorNotation = 32768,
+    FontFamilySystemUi = 65536,
+    DoublePositionGradients = 131072,
+    VendorPrefixes = 262144,
+    LogicalProperties = 524288,
+    Selectors = 31,
+    MediaQueries = 448,
+    Color = 64512
+}
+export interface Targets {
+    android?: number;
+    chrome?: number;
+    edge?: number;
+    firefox?: number;
+    ie?: number;
+    ios_saf?: number;
+    opera?: number;
+    safari?: number;
+    samsung?: number;
+}
+export interface Drafts {
+    /** Whether to enable @custom-media rules. */
+    customMedia?: boolean;
+}
+export interface NonStandard {
+    /** Whether to enable the non-standard >>> and /deep/ selector combinators used by Angular and Vue. */
+    deepSelectorCombinator?: boolean;
+}
+export interface PseudoClasses {
+    hover?: string;
+    active?: string;
+    focus?: string;
+    focusVisible?: string;
+    focusWithin?: string;
+}
+export type FeatureOptions = {
+    nesting?: boolean;
+    notSelectorList?: boolean;
+    dirSelector?: boolean;
+    langSelectorList?: boolean;
+    isSelector?: boolean;
+    textDecorationThicknessPercent?: boolean;
+    mediaIntervalSyntax?: boolean;
+    mediaRangeSyntax?: boolean;
+    customMediaQueries?: boolean;
+    clampFunction?: boolean;
+    colorFunction?: boolean;
+    oklabColors?: boolean;
+    labColors?: boolean;
+    p3Colors?: boolean;
+    hexAlphaColors?: boolean;
+    spaceSeparatedColorNotation?: boolean;
+    fontFamilySystemUi?: boolean;
+    doublePositionGradients?: boolean;
+    vendorPrefixes?: boolean;
+    logicalProperties?: boolean;
+    selectors?: boolean;
+    mediaQueries?: boolean;
+    color?: boolean;
+};
+export type LoaderOptions = {
+    errorRecovery?: boolean;
+    targets?: Targets | string[] | string;
+    include?: FeatureOptions;
+    exclude?: FeatureOptions;
+    draft?: Drafts;
+    nonStandard?: NonStandard;
+    pseudoClasses?: PseudoClasses;
+    unusedSymbols?: string[];
+};

package/dist/builtin-loader/lightningcss/index.js

@@ -0,0 +1,175 @@
+"use strict";
+// code modified based on https://github.com/parcel-bundler/lightningcss/blob/34b67a431c043fda5d4979bcdccb3008d082e243/node/browserslistToTargets.js
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Features = exports.toFeatures = exports.browserslistToTargets = void 0;
+/**
+MIT License
+
+Copyright (c) 2021-present Devon Govett
+
+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.
+ */
+const BROWSER_MAPPING = {
+    and_chr: "chrome",
+    and_ff: "firefox",
+    ie_mob: "ie",
+    op_mob: "opera",
+    and_qq: null,
+    and_uc: null,
+    baidu: null,
+    bb: null,
+    kaios: null,
+    op_mini: null
+};
+function browserslistToTargets(browserslist) {
+    const targets = {};
+    for (const browser of browserslist) {
+        const [name, v] = browser.split(" ");
+        if (BROWSER_MAPPING[name] === null) {
+            continue;
+        }
+        const version = parseVersion(v);
+        if (version == null) {
+            continue;
+        }
+        if (targets[name] == null || version < targets[name]) {
+            targets[name] = version;
+        }
+    }
+    return targets;
+}
+exports.browserslistToTargets = browserslistToTargets;
+function toFeatures(featureOptions) {
+    let feature = 0;
+    for (const key of Reflect.ownKeys(featureOptions)) {
+        if (featureOptions[key] !== true) {
+            continue;
+        }
+        switch (key) {
+            case "nesting":
+                feature |= Features.Nesting;
+                break;
+            case "notSelectorList":
+                feature |= Features.NotSelectorList;
+                break;
+            case "dirSelector":
+                feature |= Features.DirSelector;
+                break;
+            case "langSelectorList":
+                feature |= Features.LangSelectorList;
+                break;
+            case "isSelector":
+                feature |= Features.IsSelector;
+                break;
+            case "textDecorationThicknessPercent":
+                feature |= Features.TextDecorationThicknessPercent;
+                break;
+            case "mediaIntervalSyntax":
+                feature |= Features.MediaIntervalSyntax;
+                break;
+            case "mediaRangeSyntax":
+                feature |= Features.MediaRangeSyntax;
+                break;
+            case "customMediaQueries":
+                feature |= Features.CustomMediaQueries;
+                break;
+            case "clampFunction":
+                feature |= Features.ClampFunction;
+                break;
+            case "colorFunction":
+                feature |= Features.ColorFunction;
+                break;
+            case "oklabColors":
+                feature |= Features.OklabColors;
+                break;
+            case "labColors":
+                feature |= Features.LabColors;
+                break;
+            case "p3Colors":
+                feature |= Features.P3Colors;
+                break;
+            case "hexAlphaColors":
+                feature |= Features.HexAlphaColors;
+                break;
+            case "spaceSeparatedColorNotation":
+                feature |= Features.SpaceSeparatedColorNotation;
+                break;
+            case "fontFamilySystemUi":
+                feature |= Features.FontFamilySystemUi;
+                break;
+            case "doublePositionGradients":
+                feature |= Features.DoublePositionGradients;
+                break;
+            case "vendorPrefixes":
+                feature |= Features.VendorPrefixes;
+                break;
+            case "logicalProperties":
+                feature |= Features.LogicalProperties;
+                break;
+            case "selectors":
+                feature |= Features.Selectors;
+                break;
+            case "mediaQueries":
+                feature |= Features.MediaQueries;
+                break;
+            case "color":
+                feature |= Features.Color;
+                break;
+        }
+    }
+    return feature;
+}
+exports.toFeatures = toFeatures;
+function parseVersion(version) {
+    const [major, minor = 0, patch = 0] = version
+        .split("-")[0]
+        .split(".")
+        .map(v => Number.parseInt(v, 10));
+    if (isNaN(major) || isNaN(minor) || isNaN(patch)) {
+        return null;
+    }
+    return (major << 16) | (minor << 8) | patch;
+}
+var Features;
+(function (Features) {
+    Features[Features["Empty"] = 0] = "Empty";
+    Features[Features["Nesting"] = 1] = "Nesting";
+    Features[Features["NotSelectorList"] = 2] = "NotSelectorList";
+    Features[Features["DirSelector"] = 4] = "DirSelector";
+    Features[Features["LangSelectorList"] = 8] = "LangSelectorList";
+    Features[Features["IsSelector"] = 16] = "IsSelector";
+    Features[Features["TextDecorationThicknessPercent"] = 32] = "TextDecorationThicknessPercent";
+    Features[Features["MediaIntervalSyntax"] = 64] = "MediaIntervalSyntax";
+    Features[Features["MediaRangeSyntax"] = 128] = "MediaRangeSyntax";
+    Features[Features["CustomMediaQueries"] = 256] = "CustomMediaQueries";
+    Features[Features["ClampFunction"] = 512] = "ClampFunction";
+    Features[Features["ColorFunction"] = 1024] = "ColorFunction";
+    Features[Features["OklabColors"] = 2048] = "OklabColors";
+    Features[Features["LabColors"] = 4096] = "LabColors";
+    Features[Features["P3Colors"] = 8192] = "P3Colors";
+    Features[Features["HexAlphaColors"] = 16384] = "HexAlphaColors";
+    Features[Features["SpaceSeparatedColorNotation"] = 32768] = "SpaceSeparatedColorNotation";
+    Features[Features["FontFamilySystemUi"] = 65536] = "FontFamilySystemUi";
+    Features[Features["DoublePositionGradients"] = 131072] = "DoublePositionGradients";
+    Features[Features["VendorPrefixes"] = 262144] = "VendorPrefixes";
+    Features[Features["LogicalProperties"] = 524288] = "LogicalProperties";
+    Features[Features["Selectors"] = 31] = "Selectors";
+    Features[Features["MediaQueries"] = 448] = "MediaQueries";
+    Features[Features["Color"] = 64512] = "Color";
+})(Features = exports.Features || (exports.Features = {}));