ranuts 0.1.0-alpha → 0.1.0-alpha-21

package/dist/vite.config.d.ts

@@ -0,0 +1,11 @@
+import type { BuildOptions, UserConfig } from 'vite';
+export declare const umd: BuildOptions;
+export declare const umdUtil: BuildOptions;
+export declare const umdWasm: BuildOptions;
+export declare const umdReact: BuildOptions;
+export declare const umdNode: BuildOptions;
+export declare const umdMl: BuildOptions;
+export declare const es: BuildOptions;
+export declare const viteConfig: UserConfig;
+declare const _default: UserConfig;
+export default _default;

package/dist/ws-D7Jt2dzL.js

@@ -0,0 +1,703 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var _a;
+import { Socket } from "node:net";
+import http from "node:http";
+import os from "node:os";
+import fs, { createReadStream, createWriteStream, stat, readdir, readdirSync, statSync } from "node:fs";
+import { F as FMT, w as strParse, u as setMime, h as getMime } from "./color-BgjAdNyp.js";
+import tty from "node:tty";
+import process$1, { hrtime } from "node:process";
+import childProcess from "node:child_process";
+import readline from "node:readline";
+import https from "node:https";
+import path, { resolve, join } from "node:path";
+import { promisify } from "node:util";
+import { Buffer as Buffer$1 } from "node:buffer";
+import crypto from "node:crypto";
+function ipv4() {
+  const interfaces = os.networkInterfaces();
+  for (const name in interfaces) {
+    const iface = interfaces[name];
+    if (iface) {
+      for (let i = 0; i < iface.length; i++) {
+        const alias = iface[i];
+        if (alias.family === "IPv4" && alias.address !== "127.0.0.1" && !alias.internal) {
+          return alias.address;
+        }
+      }
+    }
+  }
+}
+class Server {
+  constructor() {
+    __publicField(this, "middleware");
+    __publicField(this, "ctx");
+    const req = new http.IncomingMessage(new Socket());
+    const res = new http.ServerResponse(req);
+    this.ctx = {
+      ipv4,
+      req,
+      res
+    };
+    this.middleware = [];
+  }
+  use(handle) {
+    if (!handle) {
+      throw new Error("the use function has an incorrect argument");
+    }
+    this.middleware.push(handle);
+  }
+  listen(...args) {
+    const fn = compose(this.middleware);
+    const server = http.createServer((req, res) => {
+      this.ctx.req = req;
+      this.ctx.res = res;
+      fn(this.ctx).then().catch(onerror);
+    });
+    return server.listen(...args);
+  }
+}
+function onerror(err) {
+  console.error(err.stack || err.toString());
+}
+function compose(middleware) {
+  if (!Array.isArray(middleware)) throw new TypeError("Middleware stack must be an array!");
+  for (const fn of middleware) {
+    if (typeof fn !== "function") throw new TypeError("Middleware must be composed of functions!");
+  }
+  return function(ctx, next) {
+    let index = -1;
+    function dispatch(i) {
+      if (i <= index) return Promise.reject(new Error("next() called multiple times"));
+      index = i;
+      let fn = middleware[i];
+      if (i === middleware.length && next) fn = next;
+      if (!fn) return Promise.resolve();
+      try {
+        return Promise.resolve(fn(ctx, dispatch.bind(null, i + 1)));
+      } catch (err) {
+        return Promise.reject(err);
+      }
+    }
+    return dispatch(0);
+  };
+}
+const readFile = (path2, format = "utf-8") => {
+  const controller = new AbortController();
+  const signal = controller.signal;
+  const result = new Promise((resolve2, reject) => {
+    fs.readFile(path2, { encoding: format, signal }, (err, data) => {
+      if (err) {
+        controller.abort();
+        reject({ success: false, _identification: false, data: err });
+      } else {
+        resolve2({ success: true, _identification: true, data });
+      }
+    });
+  });
+  result.abort = controller.abort;
+  return result;
+};
+const appendFile = (path2, content) => new Promise((resolve2, reject) => {
+  fs.appendFile(path2, content, (err) => {
+    err ? reject({ success: false, _identification: false, data: err }) : readFile(path2).then((result) => {
+      resolve2(result);
+    });
+  });
+});
+const isColorSupported = ((_a = process$1) == null ? void 0 : _a.env) && !("NO_COLOR" in process$1.env || process$1.argv.includes("--no-color")) && ("FORCE_COLOR" in process$1.env || process$1.argv.includes("--color") || process$1.platform === "win32" || tty.isatty(1) && process$1.env.TERM !== "dumb" || "CI" in process$1.env);
+const OPEN = 0;
+const CLOSE = 1;
+const formatter = (open, close, replace = open) => (input) => {
+  const string = "" + input;
+  const index = string.indexOf(close, open.length);
+  return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+};
+const replaceClose = (string, close, replace, index) => {
+  const start = string.substring(0, index) + replace;
+  const end = string.substring(index + close.length);
+  const nextIndex = end.indexOf(close);
+  return ~nextIndex ? start + replaceClose(end, close, replace, nextIndex) : start + end;
+};
+const colors = (enabled = isColorSupported) => {
+  const result = {};
+  Object.keys(FMT).forEach((key) => result[key] = enabled ? formatter(FMT[key][OPEN], FMT[key][CLOSE]) : String);
+  return result;
+};
+const createColors = (enabled = isColorSupported) => ({
+  isColorSupported: enabled,
+  reset: enabled ? (s) => `${FMT.reset[OPEN]}${s}${FMT.reset[CLOSE]}` : String,
+  bold: enabled ? formatter(FMT.bold[OPEN], FMT.bold[CLOSE], `${FMT.bold[CLOSE]}${FMT.bold[OPEN]}`) : String,
+  dim: enabled ? formatter(FMT.dim[OPEN], FMT.dim[CLOSE], `${FMT.dim[CLOSE]}${FMT.dim[OPEN]}`) : String
+});
+const color = Object.assign({}, colors(), createColors());
+const bodyMiddleware = (options = {}) => {
+  const { uploadDir = ".", encoding = "", json = true } = options;
+  return (ctx, next) => {
+    var _a2;
+    const { req, res } = ctx;
+    const { url, method } = req;
+    const [path2 = "", search = ""] = (url == null ? void 0 : url.split("?")) || [];
+    const query = search ? new URLSearchParams(search) : {};
+    if (!ctx.request) {
+      ctx.request = {};
+    }
+    ctx.request.method = method;
+    ctx.request.path = path2;
+    ctx.request.url = url;
+    ctx.request.query = query;
+    const contentType = req.headers["content-type"];
+    if (contentType === "application/json") {
+      if (encoding) {
+        req.setEncoding(encoding);
+      } else {
+        req.setEncoding("utf-8");
+      }
+      let body = "";
+      req.on("data", (data) => {
+        body += data;
+      });
+      req.on("end", () => {
+        res.setHeader("content-type", "application/json;charset=UTF-8");
+        try {
+          ctx.request.body = json ? JSON.parse(body) : body;
+        } catch (_error) {
+          ctx.request.body = body;
+        }
+        next();
+      });
+    }
+    if (contentType == null ? void 0 : contentType.includes("multipart/form-data;")) {
+      const [__, boundaryStr] = ((_a2 = req.headers["content-type"]) == null ? void 0 : _a2.split(";").map((item) => item.trim())) || [];
+      const [_, boundary] = boundaryStr.split("=");
+      if (encoding) {
+        req.setEncoding(encoding);
+      } else {
+        req.setEncoding("binary");
+      }
+      let body = "";
+      req.on("data", (data) => {
+        body += data;
+      });
+      req.on("end", () => {
+        const payload = {};
+        body.split("\r\n").slice(0, 4).forEach((item) => {
+          Object.assign(payload, strParse(item, ";", /=|:/));
+        });
+        const fileContentType = payload["Content-Type"];
+        const fileName = Buffer.from(payload["filename"], "latin1").toString("utf8");
+        const fileDataIndex = body.indexOf(fileContentType) + fileContentType.length;
+        const fileData = body.substring(fileDataIndex).replace(/^\s+/, "");
+        const finalData = fileData.substring(0, fileData.indexOf(`--${boundary}--`));
+        fs.writeFile(`${uploadDir}/${fileName}`, finalData, { encoding: "binary" }, (error) => {
+          if (!error) {
+            res.setHeader("content-type", "application/json;charset=UTF-8");
+            next();
+          } else {
+            throw error;
+          }
+        });
+      });
+    }
+  };
+};
+const runCommand = (command, args) => {
+  return new Promise((resolve2, reject) => {
+    const executedCommand = childProcess.spawn(command, args, {
+      stdio: "inherit",
+      // 子进程继承父进程的 stdio（标准输入/输出）流。这意味着子进程可以使用父进程的 stdin（标准输入流）和 stdout（标准输出流）。
+      shell: true
+      // 指示 spawn 方法在 shell 中执行命令。
+    });
+    executedCommand.on("error", (e) => reject(e));
+    executedCommand.on("exit", (c) => c === 0 ? resolve2() : reject(new Error(`Command exited with code ${c}`)));
+  });
+};
+const prompt = ({ message, stream = process.stderr, defaultResponse = "Y" }) => {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: stream
+  });
+  return new Promise((resolve2) => {
+    rl.question(`${message} `, (answer) => {
+      rl.close();
+      const response = (answer || defaultResponse).toLowerCase();
+      response === "y" || response === "yes" ? resolve2(true) : resolve2(false);
+    });
+  });
+};
+const noop = () => {
+};
+const PARAM_LENGTH = 3;
+function noCallbackHandler(ctx, connectMiddleware, next) {
+  connectMiddleware(ctx.req, ctx.res, noop);
+  return next();
+}
+function withCallbackHandler(ctx, connectMiddleware, next) {
+  return new Promise((resolve2, reject) => {
+    connectMiddleware(ctx.req, ctx.res, (err) => {
+      err ? reject(err) : resolve2(next());
+    });
+  });
+}
+function connect(connectMiddleware) {
+  const handler = connectMiddleware.length < PARAM_LENGTH ? noCallbackHandler : withCallbackHandler;
+  return function connect2(ctx, next) {
+    return handler(ctx, connectMiddleware, next);
+  };
+}
+const queryFileInfo = (path2) => new Promise((resolve2, reject) => {
+  fs.stat(path2, (err, data) => {
+    err ? reject({ success: false, _identification: false, data: err }) : resolve2({ success: true, _identification: true, data });
+  });
+});
+const get = ({ url }) => {
+  return new Promise((resolve2, reject) => {
+    https.get(url, (res) => {
+      const list = [];
+      res.on("data", (chunk) => {
+        list.push(chunk);
+      });
+      res.on("end", () => {
+        const { data = [] } = JSON.parse(Buffer.concat(list).toString());
+        data.forEach((item) => {
+        });
+        resolve2({ success: true, data, message: "request success" });
+      });
+    }).on("error", (err) => {
+      console.log("Error: ", err.message);
+      reject({ success: false, data: err, message: err.message });
+    });
+  });
+};
+const getIPAdress = () => {
+  const interfaces = os.networkInterfaces();
+  for (const name in interfaces) {
+    const iface = interfaces[name];
+    for (let i = 0; i < iface.length; i++) {
+      const alias = iface[i];
+      if (alias.family === "IPv4" && alias.address !== "127.0.0.1" && !alias.internal) {
+        return alias.address;
+      }
+    }
+  }
+};
+function paresUrl(req) {
+  const url = req.url;
+  if (url === void 0) return;
+  let obj = req._parsedUrl;
+  if (obj && obj._raw === url) return obj;
+  obj = {};
+  obj.query = obj.search = void 0;
+  obj.href = obj.path = obj.pathname = url;
+  const idx = url.indexOf("?", 1);
+  if (idx !== -1) {
+    obj.search = url.substring(idx);
+    obj.query = obj.search.substring(1);
+    obj.pathname = url.substring(0, idx);
+  }
+  obj._raw = url;
+  return req._parsedUrl = obj;
+}
+const readDir = (options) => {
+  const { dirPath } = options;
+  try {
+    return fs.readdirSync(dirPath);
+  } catch (error) {
+    throw error;
+  }
+};
+class Router {
+  constructor() {
+    __publicField(this, "ctx");
+    __publicField(this, "map");
+    __publicField(this, "methods");
+    __publicField(this, "paths");
+    this.map = /* @__PURE__ */ new Map();
+    this.methods = /* @__PURE__ */ new Set();
+    this.paths = /* @__PURE__ */ new Set();
+  }
+  get(url, handler) {
+    this.addHandlerToMap("GET")(url, handler);
+  }
+  post(url, handler) {
+    this.addHandlerToMap("POST")(url, handler);
+  }
+  put(url, handler) {
+    this.addHandlerToMap("PUT")(url, handler);
+  }
+  patch(url, handler) {
+    this.addHandlerToMap("PATCH")(url, handler);
+  }
+  del(url, handler) {
+    this.addHandlerToMap("DELETE")(url, handler);
+  }
+  head(url, handler) {
+    this.addHandlerToMap("HEAD")(url, handler);
+  }
+  options(url, handler) {
+    this.addHandlerToMap("OPTIONS")(url, handler);
+  }
+  addHandlerToMap(method) {
+    this.methods.add(method);
+    return (url, handler) => {
+      this.paths.add(url);
+      let path2 = this.map.get(method);
+      if (!path2) {
+        path2 = /* @__PURE__ */ new Map();
+        this.map.set(method, path2);
+      }
+      path2.set(url, handler);
+    };
+  }
+  routes() {
+    return (ctx, next) => {
+      this.ctx = ctx;
+      const { path: path2, method } = ctx.request;
+      const pathMap = this.map.get(method);
+      const handler = pathMap ? pathMap.get(path2) : next;
+      handler && handler(ctx, next);
+    };
+  }
+  allowedMethods() {
+    return (ctx) => {
+      const { res } = ctx;
+      const { path: path2, method } = ctx.request;
+      if (!this.methods.has(method) && this.paths.has(path2)) {
+        res.statusCode = 405;
+        res.end("405, method is not allowed");
+      }
+      if (this.methods.has(method) && !this.paths.has(path2)) {
+        res.statusCode = 404;
+        res.end("404, the request address does not exist");
+      }
+      if (!this.methods.has(method) && !this.paths.has(path2)) {
+        res.statusCode = 501;
+        res.end("501, not support the functionality needed to satisfy the request");
+      }
+    };
+  }
+}
+const staticMiddleware = (option = {}) => {
+  const { pathname, fileTypes = {} } = option;
+  return async (ctx, next) => {
+    try {
+      const { req, res } = ctx;
+      if (req.url) {
+        const htmlContentType = "text/html";
+        const dirPath = pathname ? pathname : process.cwd();
+        const root = path.normalize(path.resolve(dirPath));
+        const extension = path.extname(req.url).slice(1);
+        Object.keys(fileTypes).forEach((key) => setMime(key, fileTypes[key]));
+        const type = extension ? getMime(extension) : htmlContentType;
+        const supportedExtension = Boolean(type);
+        if (!supportedExtension) {
+          res.writeHead(404, { "Content-Type": "text/html" });
+          res.end("404: File not found");
+          return;
+        }
+        let fileName = req.url;
+        if (req.url === "/") {
+          fileName = "index.html";
+        } else if (!extension) {
+          try {
+            fs.accessSync(path.join(root, req.url + ".html"), fs.constants.F_OK);
+            fileName = req.url + ".html";
+          } catch (_e) {
+            fileName = path.join(req.url, "index.html");
+          }
+        }
+        const filePath = path.join(root, fileName);
+        const isPathUnderRoot = path.normalize(path.resolve(filePath)).startsWith(root);
+        if (!isPathUnderRoot) {
+          res.writeHead(404, { "Content-Type": "text/html" });
+          res.end("404: File not found");
+          return;
+        }
+        fs.readFile(filePath, (err, data) => {
+          if (err) {
+            res.writeHead(404, { "Content-Type": "text/html" });
+            res.end("404: File not found");
+          } else {
+            res.writeHead(200, { "Content-Type": type });
+            res.end(data);
+          }
+        });
+      } else {
+        console.log("request has not url");
+      }
+      await next();
+    } catch (_error) {
+    }
+  };
+};
+const startTask = () => {
+  if (typeof window !== "undefined") {
+    const startTime = window.performance.now();
+    return Symbol.for(`${startTime}`);
+  }
+  if (typeof process !== "undefined") {
+    const startTime = hrtime.bigint();
+    return Symbol.for(`${startTime}`);
+  }
+  return Symbol.for(`${Date.now()}`);
+};
+const readStream = (option) => {
+  const { path: path2 } = option;
+  if (path2) {
+    const stream = createReadStream(path2);
+    return stream;
+  }
+  throw new Error("path is not defined");
+};
+const writeStream = (option) => {
+  const { path: path2 } = option;
+  if (path2) {
+    const stream = createWriteStream(path2);
+    return stream;
+  }
+  throw new Error("path is not defined");
+};
+const taskEnd = (symbol) => {
+  const startTime = Symbol.keyFor(symbol);
+  if (typeof window !== "undefined" && startTime) {
+    return window.performance.now() - Number(startTime);
+  }
+  if (typeof process !== "undefined" && startTime) {
+    return hrtime.bigint() - BigInt(startTime);
+  }
+  return Date.now() - Number(startTime);
+};
+const toStats = promisify(stat);
+const toRead = promisify(readdir);
+async function traverse(dir, callback, pre = "") {
+  dir = resolve(".", dir);
+  await toRead(dir).then((arr) => {
+    return Promise.all(
+      arr.map((str) => {
+        const abs = join(dir, str);
+        return toStats(abs).then((stats) => {
+          return stats.isDirectory() ? traverse(abs, callback, join(pre, str)) : callback(join(pre, str), abs, stats);
+        });
+      })
+    );
+  });
+}
+function traverseSync(dir, callback, pre = "") {
+  dir = resolve(".", dir);
+  const arr = readdirSync(dir);
+  let i = 0, abs, stats;
+  for (; i < arr.length; i++) {
+    abs = join(dir, arr[i]);
+    stats = statSync(abs);
+    stats.isDirectory() ? traverseSync(abs, callback, join(pre, arr[i])) : callback(join(pre, arr[i]), abs, stats);
+  }
+}
+const watchFile = (path2, interval = 20) => new Promise((resolve2) => {
+  fs.watchFile(path2, { interval }, (curr, prev) => {
+    if (curr.mtime !== prev.mtime) {
+      fs.unwatchFile(path2);
+      resolve2({
+        success: true,
+        _identification: true,
+        data: {},
+        message: "file is changed"
+      });
+    } else {
+      resolve2({
+        success: false,
+        _identification: false,
+        data: {},
+        message: "file is not changed"
+      });
+    }
+  });
+});
+function createFrame(content, options) {
+  const len = Buffer$1.byteLength(content);
+  let buf = null;
+  if (len > 65535) {
+    buf = Buffer$1.alloc(10 + len);
+    buf[1] = 127;
+    buf.writeUInt32BE(len, 6);
+    buf.write(content, 10);
+  } else if (len > 125) {
+    buf = Buffer$1.alloc(4 + len);
+    buf[1] = 126;
+    buf.writeUInt16BE(len, 2);
+    buf.write(content, 4);
+  } else {
+    buf = Buffer$1.alloc(2 + len);
+    buf[1] = len;
+    buf.write(content, 2);
+  }
+  if (options) {
+    const opcode = options.opcode;
+    if (opcode && opcode < 15 && opcode >= 0) buf[0] = 128 | opcode;
+  } else buf[0] = 129;
+  return buf;
+}
+function parseFrameMeta(source) {
+  const src = Buffer$1.from(source);
+  const len7 = src[1] & 127;
+  let len = 0;
+  let lenMeta = 0;
+  const masked = src[1] >= 128;
+  if (len7 === 127) {
+    len = src.readUInt32BE(6);
+    lenMeta = 10;
+  } else if (len7 === 126) {
+    len = src.readUInt16BE(2);
+    lenMeta = 4;
+  } else {
+    len = len7;
+    lenMeta = 2;
+  }
+  return {
+    fin: src[0] >= 128,
+    opcode: src[0] & 15,
+    mask: masked,
+    maskKey: masked ? src.subarray(lenMeta, lenMeta + (masked ? 4 : 0)) : null,
+    len7,
+    len,
+    lenMeta: lenMeta + (masked ? 4 : 0)
+  };
+}
+function iMask(data, key) {
+  if (!key) return data;
+  const d = Buffer$1.from(data);
+  for (let i = 0; i < d.length; ++i) d[i] = d[i] ^ key[i % 4];
+  return d;
+}
+function Event() {
+  const listeners = {};
+  this.on = (event, callback) => {
+    if (listeners[event]) listeners[event].push(callback);
+    else listeners[event] = [callback];
+  };
+  this.off = (event, callback) => {
+    const e = listeners[event];
+    const i = e.indexOf(callback);
+    if (e && i !== -1) e.splice(i, 1);
+  };
+  this.emit = (event, param) => {
+    if (listeners[event]) listeners[event].forEach((callback) => callback(param));
+  };
+}
+function WSS(server) {
+  Event.call(this);
+  const clients = [];
+  this.server = server;
+  this.clients = clients;
+  this.broadcast = (data) => {
+    clients.forEach((v) => {
+      v.send(data);
+    });
+  };
+  server.on("upgrade", (req, socket) => {
+    socket.write(
+      [
+        "HTTP/1.1 101 Switching Protocols",
+        "Upgrade: websocket",
+        "Connection: Upgrade",
+        "Sec-WebSocket-Accept: " + crypto.createHash("sha1").update(req.headers["sec-websocket-key"] + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11").digest("base64")
+      ].join("\n") + "\n\n"
+    );
+    const cli = {
+      // this is the `cli` parameter  when you `connect`
+      send(data, options) {
+        socket.write(createFrame(data, options));
+      },
+      ping() {
+        socket.write(createFrame("", { opcode: 9 }));
+      },
+      pong() {
+        socket.write(createFrame("", { opcode: 10 }));
+      },
+      close() {
+        const cliI = clients.indexOf(cli);
+        if (cliI === -1) return false;
+        clients.splice(clients.indexOf(cli), 1);
+        socket.write(createFrame("", { opcode: 8 }));
+        cli.emit("close");
+        socket.destroy();
+      },
+      socket
+      // you can use `cli.socket` to get the socket object
+    };
+    Event.call(cli);
+    this.emit("connect", cli);
+    clients.push(cli);
+    let buf = Buffer$1.allocUnsafe(0);
+    let messageData = Buffer$1.allocUnsafe(0);
+    const dataList = [];
+    let frameEnd = true;
+    function nextFrame() {
+      const meta = parseFrameMeta(buf);
+      dataList.push({
+        l: meta.lenMeta,
+        f: () => {
+          frameEnd = false;
+          dataList.push({
+            l: meta.len,
+            f: (d) => {
+              messageData = Buffer$1.concat([messageData, iMask(d, meta.maskKey)]);
+              frameEnd = true;
+              if (meta.fin) {
+                if (meta.opcode === 8) return cli.close();
+                if (meta.opcode === 9) return cli.pong();
+                cli.emit("message", messageData);
+                messageData = Buffer$1.allocUnsafe(0);
+              }
+            }
+          });
+        }
+      });
+    }
+    socket.on("data", (chunk) => {
+      buf = Buffer$1.concat([buf, chunk]);
+      if (frameEnd) nextFrame();
+      while (dataList[0] && buf.byteLength >= dataList[0].l) {
+        const l = dataList[0].l;
+        dataList[0].f(buf.subarray(0, l));
+        buf = buf.subarray(l);
+        dataList.splice(0, 1);
+      }
+    });
+    socket.on("end", () => {
+      cli.close();
+    });
+    socket.on("error", (err) => {
+      cli.emit("error", err);
+      cli.close();
+    });
+  });
+}
+export {
+  Router as R,
+  Server as S,
+  WSS as W,
+  appendFile as a,
+  bodyMiddleware as b,
+  color as c,
+  connect as d,
+  getIPAdress as e,
+  prompt as f,
+  get as g,
+  readFile as h,
+  isColorSupported as i,
+  readStream as j,
+  runCommand as k,
+  staticMiddleware as l,
+  traverse as m,
+  traverseSync as n,
+  writeStream as o,
+  paresUrl as p,
+  queryFileInfo as q,
+  readDir as r,
+  startTask as s,
+  taskEnd as t,
+  watchFile as w
+};