@lifo-sh/core 0.5.0 → 0.5.6

package/dist/args-BhoL0JcG.js

@@ -0,0 +1,58 @@
+function parseArgs(args, spec) {
+  const flags = {};
+  const positional = [];
+  const shortMap = {};
+  for (const [long, def] of Object.entries(spec)) {
+    if (def.short) shortMap[def.short] = long;
+    flags[long] = def.type === "boolean" ? false : "";
+  }
+  let stopFlags = false;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (stopFlags || !arg.startsWith("-") || arg === "-") {
+      positional.push(arg);
+      continue;
+    }
+    if (arg === "--") {
+      stopFlags = true;
+      continue;
+    }
+    if (arg.startsWith("--")) {
+      const eqIdx = arg.indexOf("=");
+      if (eqIdx !== -1) {
+        const name = arg.slice(2, eqIdx);
+        const value = arg.slice(eqIdx + 1);
+        if (name in spec) {
+          flags[name] = spec[name].type === "boolean" ? true : value;
+        }
+      } else {
+        const name = arg.slice(2);
+        if (name in spec) {
+          if (spec[name].type === "string") {
+            flags[name] = args[++i] ?? "";
+          } else {
+            flags[name] = true;
+          }
+        }
+      }
+      continue;
+    }
+    const chars = arg.slice(1);
+    for (let j = 0; j < chars.length; j++) {
+      const ch = chars[j];
+      const longName = shortMap[ch];
+      if (!longName) continue;
+      if (spec[longName].type === "string") {
+        const rest = chars.slice(j + 1);
+        flags[longName] = rest || (args[++i] ?? "");
+        break;
+      } else {
+        flags[longName] = true;
+      }
+    }
+  }
+  return { flags, positional };
+}
+export {
+  parseArgs as p
+};

package/dist/awk-DahiO6Jl.js

@@ -0,0 +1,170 @@
+import { r as resolve, V as VFSError } from "./index-GLjTMF7C.js";
+import { i as isBinaryMime, g as getMimeType } from "./mime-B5knsVEw.js";
+function parseAwkProgram(program) {
+  const rules = [];
+  let remaining = program.trim();
+  while (remaining.length > 0) {
+    remaining = remaining.trim();
+    if (remaining.length === 0) break;
+    let pattern = null;
+    let action = "";
+    if (remaining.startsWith("BEGIN")) {
+      pattern = "BEGIN";
+      remaining = remaining.slice(5).trim();
+    } else if (remaining.startsWith("END")) {
+      pattern = "END";
+      remaining = remaining.slice(3).trim();
+    } else if (remaining.startsWith("/")) {
+      const endSlash = remaining.indexOf("/", 1);
+      if (endSlash > 0) {
+        try {
+          pattern = new RegExp(remaining.slice(1, endSlash));
+        } catch {
+          pattern = null;
+        }
+        remaining = remaining.slice(endSlash + 1).trim();
+      }
+    }
+    if (remaining.startsWith("{")) {
+      let depth = 0;
+      let i = 0;
+      for (; i < remaining.length; i++) {
+        if (remaining[i] === "{") depth++;
+        else if (remaining[i] === "}") {
+          depth--;
+          if (depth === 0) break;
+        }
+      }
+      action = remaining.slice(1, i).trim();
+      remaining = remaining.slice(i + 1).trim();
+    } else if (pattern === null) {
+      action = remaining;
+      remaining = "";
+    }
+    rules.push({ pattern, action });
+  }
+  return rules;
+}
+function executeAction(action, fields, line, nr, nf, _fs, vars) {
+  const output = [];
+  const statements = action.split(";").map((s) => s.trim()).filter(Boolean);
+  for (const stmt of statements) {
+    if (stmt === "print" || stmt === "print $0") {
+      output.push(line);
+    } else if (stmt.startsWith("print ")) {
+      const exprStr = stmt.slice(6).trim();
+      const parts = exprStr.split(",").map((p) => p.trim());
+      const values = parts.map((p) => evalExpr(p, fields, line, nr, nf, vars));
+      output.push(values.join(" "));
+    }
+  }
+  return output.join("\n");
+}
+function evalExpr(expr, fields, line, nr, nf, vars) {
+  expr = expr.trim();
+  if (expr.startsWith('"') && expr.endsWith('"')) {
+    return expr.slice(1, -1).replace(/\\n/g, "\n").replace(/\\t/g, "	");
+  }
+  if (expr.startsWith("$")) {
+    const rest = expr.slice(1);
+    if (rest === "NF") {
+      return fields[nf - 1] || "";
+    }
+    const n = parseInt(rest, 10);
+    if (n === 0) return line;
+    return fields[n - 1] || "";
+  }
+  if (expr === "NR") return String(nr);
+  if (expr === "NF") return String(nf);
+  if (vars.has(expr)) return vars.get(expr);
+  return expr;
+}
+const command = async (ctx) => {
+  let fieldSep = /\s+/;
+  let fieldSepStr = " ";
+  let program = "";
+  const files = [];
+  for (let i = 0; i < ctx.args.length; i++) {
+    const arg = ctx.args[i];
+    if (arg === "-F" && i + 1 < ctx.args.length) {
+      fieldSepStr = ctx.args[++i];
+      fieldSep = new RegExp(fieldSepStr.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+    } else if (arg.startsWith("-F") && arg.length > 2) {
+      fieldSepStr = arg.slice(2);
+      fieldSep = new RegExp(fieldSepStr.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+    } else if (!program) {
+      program = arg;
+    } else {
+      files.push(arg);
+    }
+  }
+  if (!program) {
+    ctx.stderr.write("awk: missing program\n");
+    return 1;
+  }
+  let text = "";
+  if (files.length === 0) {
+    if (ctx.stdin) {
+      text = await ctx.stdin.readAll();
+    } else {
+      ctx.stderr.write("awk: missing file operand\n");
+      return 1;
+    }
+  } else {
+    for (const file of files) {
+      const path = resolve(ctx.cwd, file);
+      try {
+        ctx.vfs.stat(path);
+        if (isBinaryMime(getMimeType(path))) {
+          ctx.stderr.write(`awk: ${file}: binary file, skipping
+`);
+          continue;
+        }
+        text += ctx.vfs.readFileString(path);
+      } catch (e) {
+        if (e instanceof VFSError) {
+          ctx.stderr.write(`awk: ${file}: ${e.message}
+`);
+          return 1;
+        }
+        throw e;
+      }
+    }
+  }
+  const rules = parseAwkProgram(program);
+  const lines = text.replace(/\n$/, "").split("\n");
+  const vars = /* @__PURE__ */ new Map();
+  for (const rule of rules) {
+    if (rule.pattern === "BEGIN") {
+      const result = executeAction(rule.action, [], "", 0, 0, fieldSepStr, vars);
+      if (result) ctx.stdout.write(result + "\n");
+    }
+  }
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const fields = line.split(fieldSep).filter((f) => f !== "");
+    const nr = i + 1;
+    const nf = fields.length;
+    for (const rule of rules) {
+      if (rule.pattern === "BEGIN" || rule.pattern === "END") continue;
+      let matches = true;
+      if (rule.pattern instanceof RegExp) {
+        matches = rule.pattern.test(line);
+      }
+      if (matches) {
+        const result = executeAction(rule.action, fields, line, nr, nf, fieldSepStr, vars);
+        if (result) ctx.stdout.write(result + "\n");
+      }
+    }
+  }
+  for (const rule of rules) {
+    if (rule.pattern === "END") {
+      const result = executeAction(rule.action, [], "", lines.length, 0, fieldSepStr, vars);
+      if (result) ctx.stdout.write(result + "\n");
+    }
+  }
+  return 0;
+};
+export {
+  command as default
+};

package/dist/base64-Dj_AnQAH.js

@@ -0,0 +1,92 @@
+import { r as resolve, V as VFSError } from "./index-GLjTMF7C.js";
+function toBase64(data) {
+  let binary = "";
+  for (let i = 0; i < data.length; i++) {
+    binary += String.fromCharCode(data[i]);
+  }
+  return btoa(binary);
+}
+function fromBase64(str) {
+  try {
+    return atob(str.replace(/\s/g, ""));
+  } catch {
+    throw new Error("invalid input");
+  }
+}
+const command = async (ctx) => {
+  let decode = false;
+  let wrap = 76;
+  const files = [];
+  for (let i = 0; i < ctx.args.length; i++) {
+    const arg = ctx.args[i];
+    if (arg === "-d" || arg === "--decode") {
+      decode = true;
+    } else if (arg === "-w" && i + 1 < ctx.args.length) {
+      wrap = parseInt(ctx.args[++i], 10);
+    } else if (arg === "--wrap" && i + 1 < ctx.args.length) {
+      wrap = parseInt(ctx.args[++i], 10);
+    } else if (!arg.startsWith("-") || arg === "-") {
+      files.push(arg);
+    }
+  }
+  let input;
+  if (files.length === 1 && files[0] === "-") {
+    if (ctx.stdin) {
+      input = await ctx.stdin.readAll();
+    } else {
+      ctx.stderr.write("base64: missing input\n");
+      return 1;
+    }
+  } else if (files.length === 0) {
+    ctx.stderr.write(`Usage: base64 [-d] [-w COLS] [FILE]
+`);
+    ctx.stderr.write(`Encode or decode base64. Use '-' to read from stdin.
+`);
+    return 1;
+  } else {
+    const path = resolve(ctx.cwd, files[0]);
+    try {
+      if (decode) {
+        input = ctx.vfs.readFileString(path);
+      } else {
+        input = ctx.vfs.readFile(path);
+      }
+    } catch (e) {
+      if (e instanceof VFSError) {
+        ctx.stderr.write(`base64: ${files[0]}: ${e.message}
+`);
+        return 1;
+      }
+      throw e;
+    }
+  }
+  if (decode) {
+    try {
+      const text = typeof input === "string" ? input : new TextDecoder().decode(input);
+      ctx.stdout.write(fromBase64(text));
+    } catch {
+      ctx.stderr.write("base64: invalid input\n");
+      return 1;
+    }
+  } else {
+    let data;
+    if (typeof input === "string") {
+      data = new TextEncoder().encode(input);
+    } else {
+      data = input;
+    }
+    let encoded = toBase64(data);
+    if (wrap > 0) {
+      const wrapped = [];
+      for (let i = 0; i < encoded.length; i += wrap) {
+        wrapped.push(encoded.slice(i, i + wrap));
+      }
+      encoded = wrapped.join("\n");
+    }
+    ctx.stdout.write(encoded + "\n");
+  }
+  return 0;
+};
+export {
+  command as default
+};

package/dist/basename-D8sjWfzX.js

@@ -0,0 +1,14 @@
+import { b as basename } from "./index-GLjTMF7C.js";
+const command = async (ctx) => {
+  if (ctx.args.length === 0) {
+    ctx.stderr.write("basename: missing operand\n");
+    return 1;
+  }
+  const name = ctx.args[0];
+  const suffix = ctx.args[1];
+  ctx.stdout.write(basename(name, suffix) + "\n");
+  return 0;
+};
+export {
+  command as default
+};

package/dist/bc-CCuJi0IY.js

@@ -0,0 +1,230 @@
+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);
+function tokenize(input) {
+  const tokens = [];
+  let i = 0;
+  while (i < input.length) {
+    const ch = input[i];
+    if (ch === " " || ch === "	") {
+      i++;
+      continue;
+    }
+    if (ch === "\n") {
+      tokens.push({ type: "newline", value: "\n" });
+      i++;
+      continue;
+    }
+    if (ch >= "0" && ch <= "9" || ch === ".") {
+      let num = "";
+      while (i < input.length && (input[i] >= "0" && input[i] <= "9" || input[i] === ".")) {
+        num += input[i++];
+      }
+      tokens.push({ type: "number", value: num });
+      continue;
+    }
+    if (ch >= "a" && ch <= "z" || ch >= "A" && ch <= "Z" || ch === "_") {
+      let ident = "";
+      while (i < input.length && (input[i] >= "a" && input[i] <= "z" || input[i] >= "A" && input[i] <= "Z" || input[i] >= "0" && input[i] <= "9" || input[i] === "_")) {
+        ident += input[i++];
+      }
+      tokens.push({ type: "ident", value: ident });
+      continue;
+    }
+    if ("+-*/%^()=".includes(ch)) {
+      tokens.push({ type: ch, value: ch });
+      i++;
+      continue;
+    }
+    i++;
+  }
+  tokens.push({ type: "eof", value: "" });
+  return tokens;
+}
+class Parser {
+  constructor(tokens, vars, scale) {
+    __publicField(this, "tokens");
+    __publicField(this, "pos", 0);
+    __publicField(this, "vars", {});
+    __publicField(this, "scale", 0);
+    this.tokens = tokens;
+    this.vars = vars;
+    this.scale = scale;
+  }
+  getScale() {
+    return this.scale;
+  }
+  peek() {
+    return this.tokens[this.pos] || { type: "eof", value: "" };
+  }
+  advance() {
+    return this.tokens[this.pos++] || { type: "eof", value: "" };
+  }
+  expect(type) {
+    const tok = this.advance();
+    if (tok.type !== type) {
+      throw new Error(`expected ${type}, got ${tok.type}`);
+    }
+    return tok;
+  }
+  // expression = assignment
+  parseExpression() {
+    return this.parseAssignment();
+  }
+  // assignment = ident '=' assignment | additive
+  parseAssignment() {
+    if (this.peek().type === "ident" && this.pos + 1 < this.tokens.length && this.tokens[this.pos + 1].type === "=") {
+      const name = this.advance().value;
+      this.advance();
+      const value = this.parseAssignment();
+      if (name === "scale") {
+        this.scale = Math.floor(value);
+      } else {
+        this.vars[name] = value;
+      }
+      return value;
+    }
+    return this.parseAdditive();
+  }
+  // additive = multiplicative (('+' | '-') multiplicative)*
+  parseAdditive() {
+    let left = this.parseMultiplicative();
+    while (this.peek().type === "+" || this.peek().type === "-") {
+      const op = this.advance().type;
+      const right = this.parseMultiplicative();
+      left = op === "+" ? left + right : left - right;
+    }
+    return left;
+  }
+  // multiplicative = power (('*' | '/' | '%') power)*
+  parseMultiplicative() {
+    let left = this.parsePower();
+    while (this.peek().type === "*" || this.peek().type === "/" || this.peek().type === "%") {
+      const op = this.advance().type;
+      const right = this.parsePower();
+      if (op === "*") left = left * right;
+      else if (op === "/") {
+        if (right === 0) throw new Error("divide by zero");
+        left = left / right;
+      } else {
+        if (right === 0) throw new Error("divide by zero");
+        left = left % right;
+      }
+    }
+    return left;
+  }
+  // power = unary ('^' power)?  (right-associative)
+  parsePower() {
+    const base = this.parseUnary();
+    if (this.peek().type === "^") {
+      this.advance();
+      const exp = this.parsePower();
+      return Math.pow(base, exp);
+    }
+    return base;
+  }
+  // unary = '-' unary | primary
+  parseUnary() {
+    if (this.peek().type === "-") {
+      this.advance();
+      return -this.parseUnary();
+    }
+    return this.parsePrimary();
+  }
+  // primary = number | ident | ident '(' expr ')' | '(' expr ')'
+  parsePrimary() {
+    const tok = this.peek();
+    if (tok.type === "number") {
+      this.advance();
+      return parseFloat(tok.value);
+    }
+    if (tok.type === "ident") {
+      this.advance();
+      if (this.peek().type === "(") {
+        this.advance();
+        const arg = this.parseExpression();
+        this.expect(")");
+        if (tok.value === "sqrt") {
+          if (arg < 0) throw new Error("square root of negative number");
+          return Math.sqrt(arg);
+        }
+        if (tok.value === "length") return String(Math.floor(arg)).length;
+        throw new Error(`unknown function: ${tok.value}`);
+      }
+      if (tok.value === "scale") return this.scale;
+      return this.vars[tok.value] ?? 0;
+    }
+    if (tok.type === "(") {
+      this.advance();
+      const val = this.parseExpression();
+      this.expect(")");
+      return val;
+    }
+    throw new Error(`unexpected token: ${tok.type}`);
+  }
+}
+function formatResult(value, scale) {
+  if (scale === 0) {
+    const truncated = value < 0 ? Math.ceil(value) : Math.floor(value);
+    return String(truncated);
+  }
+  return value.toFixed(scale);
+}
+const command = async (ctx) => {
+  const vars = {};
+  let scale = 0;
+  const processLine = (line) => {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) return null;
+    if (trimmed === "quit") return "quit";
+    try {
+      const tokens = tokenize(trimmed);
+      const parser = new Parser(tokens, vars, scale);
+      const result = parser.parseExpression();
+      scale = parser.getScale();
+      return formatResult(result, scale);
+    } catch (e) {
+      return `error: ${e.message}`;
+    }
+  };
+  if (ctx.args.length >= 2 && ctx.args[0] === "-e") {
+    const expr = ctx.args.slice(1).join(" ");
+    const result = processLine(expr);
+    if (result !== null && result !== "quit") {
+      ctx.stdout.write(result + "\n");
+    }
+    return 0;
+  }
+  if (ctx.args.length > 0 && ctx.args[0] !== "-e") {
+    const path = ctx.args[0];
+    try {
+      const content = ctx.vfs.readFileString(path);
+      for (const line of content.split("\n")) {
+        const result = processLine(line);
+        if (result === "quit") return 0;
+        if (result !== null) {
+          ctx.stdout.write(result + "\n");
+        }
+      }
+      return 0;
+    } catch {
+      ctx.stderr.write(`bc: ${path}: No such file
+`);
+      return 1;
+    }
+  }
+  if (ctx.stdin) {
+    const content = await ctx.stdin.readAll();
+    for (const line of content.split("\n")) {
+      const result = processLine(line);
+      if (result === "quit") return 0;
+      if (result !== null) {
+        ctx.stdout.write(result + "\n");
+      }
+    }
+  }
+  return 0;
+};
+export {
+  command as default
+};

package/dist/browser-B0dadKCA.js

@@ -0,0 +1,43 @@
+import { l as getDefaultExportFromCjs } from "./index-GLjTMF7C.js";
+function _mergeNamespaces(n, m) {
+  for (var i = 0; i < m.length; i++) {
+    const e = m[i];
+    if (typeof e !== "string" && !Array.isArray(e)) {
+      for (const k in e) {
+        if (k !== "default" && !(k in n)) {
+          const d = Object.getOwnPropertyDescriptor(e, k);
+          if (d) {
+            Object.defineProperty(n, k, d.get ? d : {
+              enumerable: true,
+              get: function() {
+                return e[k];
+              }
+            });
+          }
+        }
+      }
+    }
+  }
+  return Object.freeze(n);
+}
+var browser$2;
+var hasRequiredBrowser;
+function requireBrowser() {
+  if (hasRequiredBrowser) return browser$2;
+  hasRequiredBrowser = 1;
+  browser$2 = function() {
+    throw new Error(
+      "ws does not work in the browser. Browser clients must use the native WebSocket object"
+    );
+  };
+  return browser$2;
+}
+var browserExports = requireBrowser();
+const browser = /* @__PURE__ */ getDefaultExportFromCjs(browserExports);
+const browser$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: browser
+}, [browserExports]);
+export {
+  browser$1 as b
+};

package/dist/cal-DQsLvArw.js

@@ -0,0 +1,85 @@
+const MONTH_NAMES = [
+  "January",
+  "February",
+  "March",
+  "April",
+  "May",
+  "June",
+  "July",
+  "August",
+  "September",
+  "October",
+  "November",
+  "December"
+];
+function renderMonth(year, month, highlightToday) {
+  const today = /* @__PURE__ */ new Date();
+  const isCurrentMonth = highlightToday && today.getFullYear() === year && today.getMonth() === month;
+  const todayDate = today.getDate();
+  const title = `${MONTH_NAMES[month]} ${year}`;
+  const header = "Su Mo Tu We Th Fr Sa";
+  const lines = [];
+  lines.push(title.padStart(Math.floor((20 + title.length) / 2)).padEnd(20));
+  lines.push(header);
+  const firstDay = new Date(year, month, 1).getDay();
+  const daysInMonth = new Date(year, month + 1, 0).getDate();
+  let line = "   ".repeat(firstDay);
+  let dayOfWeek = firstDay;
+  for (let day = 1; day <= daysInMonth; day++) {
+    const dayStr = String(day).padStart(2, " ");
+    if (isCurrentMonth && day === todayDate) {
+      line += `\x1B[7m${dayStr}\x1B[0m`;
+    } else {
+      line += dayStr;
+    }
+    dayOfWeek++;
+    if (dayOfWeek === 7 && day < daysInMonth) {
+      lines.push(line);
+      line = "";
+      dayOfWeek = 0;
+    } else if (day < daysInMonth) {
+      line += " ";
+    }
+  }
+  if (line.length > 0) {
+    lines.push(line);
+  }
+  return lines.join("\n") + "\n";
+}
+const command = async (ctx) => {
+  const today = /* @__PURE__ */ new Date();
+  const args = ctx.args.filter((a) => !a.startsWith("-"));
+  if (args.length === 0) {
+    ctx.stdout.write(renderMonth(today.getFullYear(), today.getMonth(), true));
+  } else if (args.length === 1) {
+    const val = parseInt(args[0], 10);
+    if (isNaN(val) || val < 1) {
+      ctx.stderr.write(`cal: invalid argument: ${args[0]}
+`);
+      return 1;
+    }
+    if (val > 12) {
+      const year = val;
+      for (let m = 0; m < 12; m++) {
+        ctx.stdout.write(renderMonth(year, m, today.getFullYear() === year));
+        if (m < 11) ctx.stdout.write("\n");
+      }
+    } else {
+      ctx.stdout.write(renderMonth(today.getFullYear(), val - 1, true));
+    }
+  } else {
+    const month = parseInt(args[0], 10);
+    const year = parseInt(args[1], 10);
+    if (isNaN(month) || month < 1 || month > 12 || isNaN(year) || year < 1) {
+      ctx.stderr.write(`cal: invalid arguments
+`);
+      return 1;
+    }
+    const highlightToday = today.getFullYear() === year && today.getMonth() === month - 1;
+    ctx.stdout.write(renderMonth(year, month - 1, highlightToday));
+  }
+  return 0;
+};
+export {
+  command as default
+};