@rsbuild/core 1.0.0 → 1.0.1-beta.0

package/compiled/postcss-loader/license

@@ -0,0 +1,20 @@
+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.

package/compiled/postcss-loader/package.json

@@ -0,0 +1 @@
+{"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"}

package/compiled/postcss-loader/semver.js

@@ -0,0 +1 @@
+module.exports.satisfies = () => true;

package/compiled/postcss-value-parser/index.d.ts

@@ -0,0 +1 @@
+export = any;

package/compiled/postcss-value-parser/index.js

@@ -0,0 +1,495 @@
+(() => {
+  var __webpack_modules__ = {
+    555: (module, __unused_webpack_exports, __nccwpck_require__) => {
+      var parse = __nccwpck_require__(108);
+      var walk = __nccwpck_require__(629);
+      var stringify = __nccwpck_require__(377);
+      function ValueParser(value) {
+        if (this instanceof ValueParser) {
+          this.nodes = parse(value);
+          return this;
+        }
+        return new ValueParser(value);
+      }
+      ValueParser.prototype.toString = function () {
+        return Array.isArray(this.nodes) ? stringify(this.nodes) : "";
+      };
+      ValueParser.prototype.walk = function (cb, bubble) {
+        walk(this.nodes, cb, bubble);
+        return this;
+      };
+      ValueParser.unit = __nccwpck_require__(419);
+      ValueParser.walk = walk;
+      ValueParser.stringify = stringify;
+      module.exports = ValueParser;
+    },
+    108: (module) => {
+      var openParentheses = "(".charCodeAt(0);
+      var closeParentheses = ")".charCodeAt(0);
+      var singleQuote = "'".charCodeAt(0);
+      var doubleQuote = '"'.charCodeAt(0);
+      var backslash = "\\".charCodeAt(0);
+      var slash = "/".charCodeAt(0);
+      var comma = ",".charCodeAt(0);
+      var colon = ":".charCodeAt(0);
+      var star = "*".charCodeAt(0);
+      var uLower = "u".charCodeAt(0);
+      var uUpper = "U".charCodeAt(0);
+      var plus = "+".charCodeAt(0);
+      var isUnicodeRange = /^[a-f0-9?-]+$/i;
+      module.exports = function (input) {
+        var tokens = [];
+        var value = input;
+        var next,
+          quote,
+          prev,
+          token,
+          escape,
+          escapePos,
+          whitespacePos,
+          parenthesesOpenPos;
+        var pos = 0;
+        var code = value.charCodeAt(pos);
+        var max = value.length;
+        var stack = [{ nodes: tokens }];
+        var balanced = 0;
+        var parent;
+        var name = "";
+        var before = "";
+        var after = "";
+        while (pos < max) {
+          if (code <= 32) {
+            next = pos;
+            do {
+              next += 1;
+              code = value.charCodeAt(next);
+            } while (code <= 32);
+            token = value.slice(pos, next);
+            prev = tokens[tokens.length - 1];
+            if (code === closeParentheses && balanced) {
+              after = token;
+            } else if (prev && prev.type === "div") {
+              prev.after = token;
+              prev.sourceEndIndex += token.length;
+            } else if (
+              code === comma ||
+              code === colon ||
+              (code === slash &&
+                value.charCodeAt(next + 1) !== star &&
+                (!parent ||
+                  (parent &&
+                    parent.type === "function" &&
+                    parent.value !== "calc")))
+            ) {
+              before = token;
+            } else {
+              tokens.push({
+                type: "space",
+                sourceIndex: pos,
+                sourceEndIndex: next,
+                value: token,
+              });
+            }
+            pos = next;
+          } else if (code === singleQuote || code === doubleQuote) {
+            next = pos;
+            quote = code === singleQuote ? "'" : '"';
+            token = { type: "string", sourceIndex: pos, quote };
+            do {
+              escape = false;
+              next = value.indexOf(quote, next + 1);
+              if (~next) {
+                escapePos = next;
+                while (value.charCodeAt(escapePos - 1) === backslash) {
+                  escapePos -= 1;
+                  escape = !escape;
+                }
+              } else {
+                value += quote;
+                next = value.length - 1;
+                token.unclosed = true;
+              }
+            } while (escape);
+            token.value = value.slice(pos + 1, next);
+            token.sourceEndIndex = token.unclosed ? next : next + 1;
+            tokens.push(token);
+            pos = next + 1;
+            code = value.charCodeAt(pos);
+          } else if (code === slash && value.charCodeAt(pos + 1) === star) {
+            next = value.indexOf("*/", pos);
+            token = {
+              type: "comment",
+              sourceIndex: pos,
+              sourceEndIndex: next + 2,
+            };
+            if (next === -1) {
+              token.unclosed = true;
+              next = value.length;
+              token.sourceEndIndex = next;
+            }
+            token.value = value.slice(pos + 2, next);
+            tokens.push(token);
+            pos = next + 2;
+            code = value.charCodeAt(pos);
+          } else if (
+            (code === slash || code === star) &&
+            parent &&
+            parent.type === "function" &&
+            parent.value === "calc"
+          ) {
+            token = value[pos];
+            tokens.push({
+              type: "word",
+              sourceIndex: pos - before.length,
+              sourceEndIndex: pos + token.length,
+              value: token,
+            });
+            pos += 1;
+            code = value.charCodeAt(pos);
+          } else if (code === slash || code === comma || code === colon) {
+            token = value[pos];
+            tokens.push({
+              type: "div",
+              sourceIndex: pos - before.length,
+              sourceEndIndex: pos + token.length,
+              value: token,
+              before,
+              after: "",
+            });
+            before = "";
+            pos += 1;
+            code = value.charCodeAt(pos);
+          } else if (openParentheses === code) {
+            next = pos;
+            do {
+              next += 1;
+              code = value.charCodeAt(next);
+            } while (code <= 32);
+            parenthesesOpenPos = pos;
+            token = {
+              type: "function",
+              sourceIndex: pos - name.length,
+              value: name,
+              before: value.slice(parenthesesOpenPos + 1, next),
+            };
+            pos = next;
+            if (
+              name === "url" &&
+              code !== singleQuote &&
+              code !== doubleQuote
+            ) {
+              next -= 1;
+              do {
+                escape = false;
+                next = value.indexOf(")", next + 1);
+                if (~next) {
+                  escapePos = next;
+                  while (value.charCodeAt(escapePos - 1) === backslash) {
+                    escapePos -= 1;
+                    escape = !escape;
+                  }
+                } else {
+                  value += ")";
+                  next = value.length - 1;
+                  token.unclosed = true;
+                }
+              } while (escape);
+              whitespacePos = next;
+              do {
+                whitespacePos -= 1;
+                code = value.charCodeAt(whitespacePos);
+              } while (code <= 32);
+              if (parenthesesOpenPos < whitespacePos) {
+                if (pos !== whitespacePos + 1) {
+                  token.nodes = [
+                    {
+                      type: "word",
+                      sourceIndex: pos,
+                      sourceEndIndex: whitespacePos + 1,
+                      value: value.slice(pos, whitespacePos + 1),
+                    },
+                  ];
+                } else {
+                  token.nodes = [];
+                }
+                if (token.unclosed && whitespacePos + 1 !== next) {
+                  token.after = "";
+                  token.nodes.push({
+                    type: "space",
+                    sourceIndex: whitespacePos + 1,
+                    sourceEndIndex: next,
+                    value: value.slice(whitespacePos + 1, next),
+                  });
+                } else {
+                  token.after = value.slice(whitespacePos + 1, next);
+                  token.sourceEndIndex = next;
+                }
+              } else {
+                token.after = "";
+                token.nodes = [];
+              }
+              pos = next + 1;
+              token.sourceEndIndex = token.unclosed ? next : pos;
+              code = value.charCodeAt(pos);
+              tokens.push(token);
+            } else {
+              balanced += 1;
+              token.after = "";
+              token.sourceEndIndex = pos + 1;
+              tokens.push(token);
+              stack.push(token);
+              tokens = token.nodes = [];
+              parent = token;
+            }
+            name = "";
+          } else if (closeParentheses === code && balanced) {
+            pos += 1;
+            code = value.charCodeAt(pos);
+            parent.after = after;
+            parent.sourceEndIndex += after.length;
+            after = "";
+            balanced -= 1;
+            stack[stack.length - 1].sourceEndIndex = pos;
+            stack.pop();
+            parent = stack[balanced];
+            tokens = parent.nodes;
+          } else {
+            next = pos;
+            do {
+              if (code === backslash) {
+                next += 1;
+              }
+              next += 1;
+              code = value.charCodeAt(next);
+            } while (
+              next < max &&
+              !(
+                code <= 32 ||
+                code === singleQuote ||
+                code === doubleQuote ||
+                code === comma ||
+                code === colon ||
+                code === slash ||
+                code === openParentheses ||
+                (code === star &&
+                  parent &&
+                  parent.type === "function" &&
+                  parent.value === "calc") ||
+                (code === slash &&
+                  parent.type === "function" &&
+                  parent.value === "calc") ||
+                (code === closeParentheses && balanced)
+              )
+            );
+            token = value.slice(pos, next);
+            if (openParentheses === code) {
+              name = token;
+            } else if (
+              (uLower === token.charCodeAt(0) ||
+                uUpper === token.charCodeAt(0)) &&
+              plus === token.charCodeAt(1) &&
+              isUnicodeRange.test(token.slice(2))
+            ) {
+              tokens.push({
+                type: "unicode-range",
+                sourceIndex: pos,
+                sourceEndIndex: next,
+                value: token,
+              });
+            } else {
+              tokens.push({
+                type: "word",
+                sourceIndex: pos,
+                sourceEndIndex: next,
+                value: token,
+              });
+            }
+            pos = next;
+          }
+        }
+        for (pos = stack.length - 1; pos; pos -= 1) {
+          stack[pos].unclosed = true;
+          stack[pos].sourceEndIndex = value.length;
+        }
+        return stack[0].nodes;
+      };
+    },
+    377: (module) => {
+      function stringifyNode(node, custom) {
+        var type = node.type;
+        var value = node.value;
+        var buf;
+        var customResult;
+        if (custom && (customResult = custom(node)) !== undefined) {
+          return customResult;
+        } else if (type === "word" || type === "space") {
+          return value;
+        } else if (type === "string") {
+          buf = node.quote || "";
+          return buf + value + (node.unclosed ? "" : buf);
+        } else if (type === "comment") {
+          return "/*" + value + (node.unclosed ? "" : "*/");
+        } else if (type === "div") {
+          return (node.before || "") + value + (node.after || "");
+        } else if (Array.isArray(node.nodes)) {
+          buf = stringify(node.nodes, custom);
+          if (type !== "function") {
+            return buf;
+          }
+          return (
+            value +
+            "(" +
+            (node.before || "") +
+            buf +
+            (node.after || "") +
+            (node.unclosed ? "" : ")")
+          );
+        }
+        return value;
+      }
+      function stringify(nodes, custom) {
+        var result, i;
+        if (Array.isArray(nodes)) {
+          result = "";
+          for (i = nodes.length - 1; ~i; i -= 1) {
+            result = stringifyNode(nodes[i], custom) + result;
+          }
+          return result;
+        }
+        return stringifyNode(nodes, custom);
+      }
+      module.exports = stringify;
+    },
+    419: (module) => {
+      var minus = "-".charCodeAt(0);
+      var plus = "+".charCodeAt(0);
+      var dot = ".".charCodeAt(0);
+      var exp = "e".charCodeAt(0);
+      var EXP = "E".charCodeAt(0);
+      function likeNumber(value) {
+        var code = value.charCodeAt(0);
+        var nextCode;
+        if (code === plus || code === minus) {
+          nextCode = value.charCodeAt(1);
+          if (nextCode >= 48 && nextCode <= 57) {
+            return true;
+          }
+          var nextNextCode = value.charCodeAt(2);
+          if (nextCode === dot && nextNextCode >= 48 && nextNextCode <= 57) {
+            return true;
+          }
+          return false;
+        }
+        if (code === dot) {
+          nextCode = value.charCodeAt(1);
+          if (nextCode >= 48 && nextCode <= 57) {
+            return true;
+          }
+          return false;
+        }
+        if (code >= 48 && code <= 57) {
+          return true;
+        }
+        return false;
+      }
+      module.exports = function (value) {
+        var pos = 0;
+        var length = value.length;
+        var code;
+        var nextCode;
+        var nextNextCode;
+        if (length === 0 || !likeNumber(value)) {
+          return false;
+        }
+        code = value.charCodeAt(pos);
+        if (code === plus || code === minus) {
+          pos++;
+        }
+        while (pos < length) {
+          code = value.charCodeAt(pos);
+          if (code < 48 || code > 57) {
+            break;
+          }
+          pos += 1;
+        }
+        code = value.charCodeAt(pos);
+        nextCode = value.charCodeAt(pos + 1);
+        if (code === dot && nextCode >= 48 && nextCode <= 57) {
+          pos += 2;
+          while (pos < length) {
+            code = value.charCodeAt(pos);
+            if (code < 48 || code > 57) {
+              break;
+            }
+            pos += 1;
+          }
+        }
+        code = value.charCodeAt(pos);
+        nextCode = value.charCodeAt(pos + 1);
+        nextNextCode = value.charCodeAt(pos + 2);
+        if (
+          (code === exp || code === EXP) &&
+          ((nextCode >= 48 && nextCode <= 57) ||
+            ((nextCode === plus || nextCode === minus) &&
+              nextNextCode >= 48 &&
+              nextNextCode <= 57))
+        ) {
+          pos += nextCode === plus || nextCode === minus ? 3 : 2;
+          while (pos < length) {
+            code = value.charCodeAt(pos);
+            if (code < 48 || code > 57) {
+              break;
+            }
+            pos += 1;
+          }
+        }
+        return { number: value.slice(0, pos), unit: value.slice(pos) };
+      };
+    },
+    629: (module) => {
+      module.exports = function walk(nodes, cb, bubble) {
+        var i, max, node, result;
+        for (i = 0, max = nodes.length; i < max; i += 1) {
+          node = nodes[i];
+          if (!bubble) {
+            result = cb(node, i, nodes);
+          }
+          if (
+            result !== false &&
+            node.type === "function" &&
+            Array.isArray(node.nodes)
+          ) {
+            walk(node.nodes, cb, bubble);
+          }
+          if (bubble) {
+            cb(node, i, nodes);
+          }
+        }
+      };
+    },
+  };
+  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__(555);
+  module.exports = __webpack_exports__;
+})();

package/compiled/postcss-value-parser/license

@@ -0,0 +1,22 @@
+Copyright (c) Bogdan Chadkin <trysound@yandex.ru>
+
+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.

package/compiled/postcss-value-parser/package.json

@@ -0,0 +1 @@
+{"name":"postcss-value-parser","author":"Bogdan Chadkin <trysound@yandex.ru>","version":"4.2.0","license":"MIT","types":"index.d.ts","type":"commonjs"}

package/compiled/rslog/index.d.ts

@@ -0,0 +1,66 @@
+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 };