voodoojs 0.7.0 → 0.10.1

package/dist/socket.cjs

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 /**
- * Voodoo.js v0.7.0
+ * Voodoo.js v0.10.1
  * JavaScript feels like magic.
  * (c) 2026 Voodoo.js contributors. MIT License.
  */
@@ -413,6 +413,14 @@ Expression: ${expression}` : message);
   }
 };
 var SPREAD = /* @__PURE__ */ Symbol("spread");
+var ReturnSignal = class {
+  constructor(value) {
+    __publicField(this, "value", value);
+  }
+};
+function unwrap(value) {
+  return value instanceof ReturnSignal ? value.value : value;
+}
 var BLOCKED_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
 function chaveBloqueada(key) {
   return typeof key === "string" && BLOCKED_KEYS.has(key);
@@ -458,6 +466,19 @@ function evaluate(node, scope) {
       );
       return obj[key];
     }
+    case "new": {
+      const target2 = evaluate(node.callee, scope);
+      if (typeof target2 !== "function") {
+        throw new VoodooRuntimeError(
+          `Cannot construct ${stringify(target2)}: it is not a constructor`
+        );
+      }
+      if (target2 === Function) {
+        throw new VoodooRuntimeError("Cannot construct Function: expressions never compile code");
+      }
+      const args = evalArgs(node.args, scope);
+      return Reflect.construct(target2, args);
+    }
     case "call": {
       let thisArg;
       let fn;
@@ -505,6 +526,19 @@ function evaluate(node, scope) {
     }
     case "unary": {
       if (node.op === "...") return { [SPREAD]: evaluate(node.a, scope) };
+      if (node.op === "delete") {
+        if (node.a.t !== "member") {
+          throw new VoodooRuntimeError(
+            "delete needs a property, as in `delete user.name` or `delete list[0]`"
+          );
+        }
+        const owner = evaluate(node.a.o, scope);
+        if (owner == null) return true;
+        const key = checkKey(
+          node.a.computed ? evaluate(node.a.p, scope) : node.a.p.v
+        );
+        return delete owner[key];
+      }
       if (node.op === "typeof") {
         if (node.a.t === "id") {
           if (chaveBloqueada(node.a.n)) return "undefined";
@@ -522,6 +556,8 @@ function evaluate(node, scope) {
           return -v;
         case "+":
           return +v;
+        case "~":
+          return ~v;
         case "void":
           return void 0;
       }
@@ -569,6 +605,23 @@ function evaluate(node, scope) {
           return l in r;
         case "instanceof":
           return l instanceof r;
+        // The bitwise operators coerce through ToInt32, and `>>>` through
+        // ToUint32, which is why the two shifts disagree for negatives:
+        // `-1 >> 0` is -1 and `-1 >>> 0` is 4294967295. Applying the JavaScript
+        // operator directly gets that for free; hand-rolling the coercion is
+        // how an implementation ends up subtly wrong on exactly those cases.
+        case "&":
+          return l & r;
+        case "|":
+          return l | r;
+        case "^":
+          return l ^ r;
+        case "<<":
+          return l << r;
+        case ">>":
+          return l >> r;
+        case ">>>":
+          return l >>> r;
       }
       throw new VoodooRuntimeError(`Unsupported operator: ${node.op}`);
     }
@@ -626,21 +679,16 @@ function evaluate(node, scope) {
       const methodParams = node.params;
       const methodBody = node.body;
       return function(...args) {
-        const vars = {};
-        for (let i = 0; i < methodParams.length; i++) vars[methodParams[i]] = args[i];
+        const vars = bindParams(methodParams, args, scope);
         const owner = this;
         const base = owner !== null && typeof owner === "object" ? scope.child(owner) : scope;
-        return evaluate(methodBody, base.child(vars));
+        return unwrap(evaluate(methodBody, base.child(vars)));
       };
     }
     case "arrow": {
       const params = node.params;
       const body = node.body;
-      return (...args) => {
-        const vars = {};
-        for (let i = 0; i < params.length; i++) vars[params[i]] = args[i];
-        return evaluate(body, scope.child(vars));
-      };
+      return (...args) => unwrap(evaluate(body, scope.child(bindParams(params, args, scope))));
     }
     case "obj": {
       const out = {};
@@ -678,14 +726,65 @@ function evaluate(node, scope) {
       }
       return out;
     }
+    case "return":
+      return new ReturnSignal(node.a ? evaluate(node.a, scope) : void 0);
     case "seq": {
       let last;
-      for (const stmt of node.body) last = evaluate(stmt, scope);
+      for (const stmt of node.body) {
+        last = evaluate(stmt, scope);
+        if (last instanceof ReturnSignal) return last;
+      }
       return last;
     }
   }
   throw new VoodooRuntimeError(`Unknown node: ${node.t}`);
 }
+function bindParam(param, value, vars, scope) {
+  if (param.kind === "rest") {
+    vars[param.name] = value;
+    return;
+  }
+  if (param.def !== void 0 && value === void 0) {
+    value = evaluate(param.def, scope.child(vars));
+  }
+  if (param.kind === "id") {
+    vars[param.name] = value;
+    return;
+  }
+  if (param.kind === "obj") {
+    if (value == null) {
+      throw new VoodooRuntimeError(
+        `Cannot destructure ${value === null ? "null" : "undefined"}`
+      );
+    }
+    const taken = /* @__PURE__ */ new Set();
+    for (const { key, value: inner } of param.props) {
+      taken.add(key);
+      bindParam(inner, value[checkKey(key)], vars, scope);
+    }
+    if (param.rest) {
+      const rest = {};
+      for (const key of Object.keys(value)) {
+        if (!taken.has(key)) rest[key] = value[key];
+      }
+      vars[param.rest] = rest;
+    }
+    return;
+  }
+  const items = Array.isArray(value) ? value : Array.from(value);
+  param.elements.forEach((element, index) => {
+    if (element) bindParam(element, items[index], vars, scope);
+  });
+  if (param.rest) vars[param.rest] = items.slice(param.elements.length);
+}
+function bindParams(params, args, scope) {
+  const vars = {};
+  for (let i = 0; i < params.length; i++) {
+    const param = params[i];
+    bindParam(param, param.kind === "rest" ? args.slice(i) : args[i], vars, scope);
+  }
+  return vars;
+}
 function evalArgs(args, scope) {
   const out = [];
   for (const arg of args) {
@@ -758,6 +857,7 @@ var PUNCTUATORS = [
   "!==",
   "**=",
   "...",
+  ">>>",
   "<<=",
   ">>=",
   "&&=",
@@ -780,6 +880,11 @@ var PUNCTUATORS = [
   "*=",
   "/=",
   "%=",
+  "&=",
+  "|=",
+  "^=",
+  "<<",
+  ">>",
   "+",
   "-",
   "*",
@@ -789,6 +894,10 @@ var PUNCTUATORS = [
   "<",
   ">",
   "=",
+  "&",
+  "|",
+  "^",
+  "~",
   "(",
   ")",
   "[",
@@ -852,6 +961,10 @@ function tokenize(source) {
         raw = "0b";
         i += 2;
         while (i < len && /[01_]/.test(source[i])) raw += source[i++];
+      } else if (ch === "0" && (source[i + 1] === "o" || source[i + 1] === "O")) {
+        raw = "0o";
+        i += 2;
+        while (i < len && /[0-7_]/.test(source[i])) raw += source[i++];
       } else {
         while (i < len && /[0-9_]/.test(source[i])) raw += source[i++];
         if (source[i] === ".") {
@@ -1008,25 +1121,31 @@ var BINARY_PRECEDENCE = {
   "??": 1,
   "||": 2,
   "&&": 3,
-  "==": 6,
-  "!=": 6,
-  "===": 6,
-  "!==": 6,
-  "<": 7,
-  ">": 7,
-  "<=": 7,
-  ">=": 7,
-  in: 7,
-  instanceof: 7,
-  "+": 9,
-  "-": 9,
-  "*": 10,
-  "/": 10,
-  "%": 10,
-  "**": 11
+  "|": 4,
+  "^": 5,
+  "&": 6,
+  "==": 7,
+  "!=": 7,
+  "===": 7,
+  "!==": 7,
+  "<": 8,
+  ">": 8,
+  "<=": 8,
+  ">=": 8,
+  in: 8,
+  instanceof: 8,
+  "<<": 9,
+  ">>": 9,
+  ">>>": 9,
+  "+": 10,
+  "-": 10,
+  "*": 11,
+  "/": 11,
+  "%": 11,
+  "**": 12
 };
 var ASSIGN_OPS = /* @__PURE__ */ new Set(["=", "+=", "-=", "*=", "/=", "%=", "**=", "&&=", "||=", "??="]);
-var UNARY_OPS = /* @__PURE__ */ new Set(["!", "-", "+", "typeof", "void"]);
+var UNARY_OPS = /* @__PURE__ */ new Set(["!", "-", "+", "~", "typeof", "void", "delete"]);
 var LITERALS = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create(null), {
   true: true,
   false: false,
@@ -1108,6 +1227,13 @@ var Parser = class {
    * language is an expression.
    */
   parseStatement() {
+    if (this.peek().type === "ident" && this.peek().value === "return") {
+      this.next();
+      if (this.isPunct(";") || this.isPunct(",") || this.isPunct("}") || this.peek().type === "eof") {
+        return { t: "return", a: null };
+      }
+      return { t: "return", a: this.parseExpression() };
+    }
     if (this.peek().type === "ident" && this.peek().value === "if" && this.isPunct("(", 1)) {
       this.next();
       this.expect("(");
@@ -1161,7 +1287,7 @@ var Parser = class {
     if (this.peek().type === "ident" && this.isPunct("=>", 1)) {
       const param = this.next().value;
       this.next();
-      return { t: "arrow", params: [param], body: this.parseArrowBody() };
+      return { t: "arrow", params: [{ kind: "id", name: param }], body: this.parseArrowBody() };
     }
     if (this.isPunct("(")) {
       const arrow = this.tryParseParenArrow();
@@ -1198,19 +1324,108 @@ var Parser = class {
     const after = this.tokens[i + 1];
     if (!after || after.type !== "punct" || after.value !== "=>") return null;
     this.next();
+    let params;
+    try {
+      params = this.parseParamList();
+    } catch {
+      this.pos = start;
+      return null;
+    }
+    this.expect("=>");
+    return { t: "arrow", params, body: this.parseArrowBody() };
+  }
+  /** Parameters up to the closing parenthesis, which it consumes. */
+  parseParamList() {
     const params = [];
     while (!this.isPunct(")")) {
-      const t = this.next();
-      if (t.type !== "ident") {
-        this.pos = start;
-        return null;
-      }
-      params.push(t.value);
+      params.push(this.parseParam());
       if (this.isPunct(",")) this.next();
+      else break;
     }
     this.expect(")");
-    this.expect("=>");
-    return { t: "arrow", params, body: this.parseArrowBody() };
+    return params;
+  }
+  /**
+   * One binding: `x`, `x = 1`, `...xs`, `{ a, b: c = 2 }`, `[a, , b]`.
+   *
+   * Recursive, so a pattern nests to any depth the way JavaScript's does.
+   */
+  parseParam() {
+    if (this.isPunct("...")) {
+      this.next();
+      const name = this.next();
+      if (name.type !== "ident") {
+        throw new VoodooSyntaxError("Expected a name after ...", this.source, name.start);
+      }
+      return { kind: "rest", name: name.value };
+    }
+    let param;
+    if (this.isPunct("{")) {
+      this.next();
+      const props = [];
+      let rest;
+      while (!this.isPunct("}")) {
+        if (this.isPunct("...")) {
+          this.next();
+          const name = this.next();
+          if (name.type !== "ident") {
+            throw new VoodooSyntaxError("Expected a name after ...", this.source, name.start);
+          }
+          rest = name.value;
+        } else {
+          const key = this.next();
+          if (key.type !== "ident" && key.type !== "str") {
+            throw new VoodooSyntaxError("Expected a property name", this.source, key.start);
+          }
+          const value = this.isPunct(":") ? (this.next(), this.parseParam()) : { kind: "id", name: key.value };
+          if (this.isPunct("=")) {
+            this.next();
+            value.def = this.parseAssignment();
+          }
+          props.push({ key: String(key.value), value });
+        }
+        if (this.isPunct(",")) this.next();
+        else break;
+      }
+      this.expect("}");
+      param = { kind: "obj", props, rest };
+    } else if (this.isPunct("[")) {
+      this.next();
+      const elements = [];
+      let rest;
+      while (!this.isPunct("]")) {
+        if (this.isPunct(",")) {
+          this.next();
+          elements.push(null);
+          continue;
+        }
+        if (this.isPunct("...")) {
+          this.next();
+          const name = this.next();
+          if (name.type !== "ident") {
+            throw new VoodooSyntaxError("Expected a name after ...", this.source, name.start);
+          }
+          rest = name.value;
+        } else {
+          elements.push(this.parseParam());
+        }
+        if (this.isPunct(",")) this.next();
+        else break;
+      }
+      this.expect("]");
+      param = { kind: "arr", elements, rest };
+    } else {
+      const name = this.next();
+      if (name.type !== "ident") {
+        throw new VoodooSyntaxError("Expected a parameter name", this.source, name.start);
+      }
+      param = { kind: "id", name: name.value };
+    }
+    if (this.isPunct("=")) {
+      this.next();
+      param.def = this.parseAssignment();
+    }
+    return param;
   }
   parseConditional() {
     const test = this.parseBinary(0);
@@ -1270,8 +1485,57 @@ var Parser = class {
     }
     return expr;
   }
+  /**
+   * `new X`, `new X(a, b)`, and `new a.b.C(x)`.
+   *
+   * `new` did not exist here, in the lexer, or in the interpreter. So
+   * `new Date(0)` lexed as the identifier `new` followed by `Date(0)`, the
+   * parser dropped the dangling identifier, and what ran was `Date(0)`. Called
+   * without `new`, `Date` returns a STRING of the current time, so
+   * `new Date(0)` produced today's date as text, `new Date(0) instanceof Date`
+   * was false, and `new Date(0).getTime()` failed with "getTime is not a
+   * function". Three wrong answers, none of them an error.
+   *
+   * The callee is parsed as a member chain WITHOUT consuming a call, because in
+   * JavaScript the argument list binds to the `new`: `new a.b.C(x)` constructs
+   * `a.b.C` with `x`, and never calls `a.b.C(x)` and constructs the result. The
+   * trailing `(` is then read here, and anything after it, such as
+   * `new Date(0).getTime()`, is left to the ordinary member loop below.
+   */
+  parseNew() {
+    this.next();
+    const callee = this.parseMemberOnly(this.parsePrimary());
+    const args = this.isPunct("(") ? this.parseArguments() : [];
+    return { t: "new", callee, args };
+  }
+  /**
+   * Member access only: `.x`, `?.x` and `[x]`, stopping at a call.
+   *
+   * Used for a `new` callee, where the argument list belongs to the `new`
+   * rather than to the expression it is constructing.
+   */
+  parseMemberOnly(start) {
+    let expr = start;
+    for (; ; ) {
+      if (this.isPunct(".")) {
+        this.next();
+        const prop = this.next();
+        if (prop.type !== "ident") {
+          throw new VoodooSyntaxError("Invalid property name", this.source, prop.start);
+        }
+        expr = { t: "member", o: expr, p: { t: "lit", v: prop.value }, computed: false, opt: false };
+      } else if (this.isPunct("[")) {
+        this.next();
+        const p = this.parseExpression();
+        this.expect("]");
+        expr = { t: "member", o: expr, p, computed: true, opt: false };
+      } else {
+        return expr;
+      }
+    }
+  }
   parseCallMember() {
-    let expr = this.parsePrimary();
+    let expr = this.isIdent("new") ? this.parseNew() : this.parsePrimary();
     for (; ; ) {
       if (this.isPunct(".")) {
         this.next();
@@ -1336,16 +1600,7 @@ var Parser = class {
       this.next();
       if (this.peek().type === "ident") this.next();
       this.expect("(");
-      const params = [];
-      while (!this.isPunct(")")) {
-        const param = this.next();
-        if (param.type !== "ident") {
-          throw new VoodooSyntaxError("Expected a parameter name", this.source, param.start);
-        }
-        params.push(param.value);
-        if (this.isPunct(",")) this.next();
-      }
-      this.expect(")");
+      const params = this.parseParamList();
       return { t: "arrow", params, body: this.parseArrowBody() };
     }
     if (t.type === "num" || t.type === "str") {
@@ -1450,16 +1705,7 @@ var Parser = class {
           props.push({ key, value: this.parseAssignment() });
         } else if (this.isPunct("(")) {
           this.next();
-          const params = [];
-          while (!this.isPunct(")")) {
-            const param = this.next();
-            if (param.type !== "ident") {
-              throw new VoodooSyntaxError("Expected a parameter name", this.source, param.start);
-            }
-            params.push(param.value);
-            if (this.isPunct(",")) this.next();
-          }
-          this.expect(")");
+          const params = this.parseParamList();
           props.push({ key, value: { t: "method", params, body: this.parseArrowBody() } });
         } else {
           props.push({ key, value: { t: "id", n: key } });

package/dist/socket.js

@@ -1,14 +1,14 @@
-import { socketSupported, createSocket, socket } from './chunk-QO3I7VLJ.js';
-export { ENGINE, SIO, createSocket, decodeEngine, decodeSocketIo, encodeSocketIo, engineURL, resolveSocketURL, socket, socketSupported } from './chunk-QO3I7VLJ.js';
-import { evaluateIn, readAttr } from './chunk-JB2YYNK6.js';
-import { reactive } from './chunk-4T2UIPWX.js';
-import { warnAlias } from './chunk-CYN6VLMD.js';
-import { parseDuration } from './chunk-ZIWLQZZL.js';
-import { defineDirective, PRIORITY, config } from './chunk-MMLUK37L.js';
-import './chunk-YOZTHZS2.js';
+import { socketSupported, createSocket, socket } from './chunk-5D7TM3GL.js';
+export { ENGINE, SIO, createSocket, decodeEngine, decodeSocketIo, encodeSocketIo, engineURL, resolveSocketURL, socket, socketSupported } from './chunk-5D7TM3GL.js';
+import { evaluateIn, readAttr } from './chunk-5E3UZREN.js';
+import { reactive } from './chunk-246ZC2JD.js';
+import { warnAlias } from './chunk-RREZZ4FB.js';
+import { parseDuration } from './chunk-F3Z3HMZR.js';
+import { defineDirective, PRIORITY, config } from './chunk-D4DNTWIS.js';
+import './chunk-2UST7MKN.js';
 
 /**
- * Voodoo.js v0.7.0
+ * Voodoo.js v0.10.1
  * JavaScript feels like magic.
  * (c) 2026 Voodoo.js contributors. MIT License.
  */

package/dist/style-BSEVBI4K.js

@@ -0,0 +1,5 @@
+export { BASE_TOKENS, ensureTokens, injectStyle } from './chunk-KQRWQPD6.js';
+import './chunk-D4DNTWIS.js';
+import './chunk-2UST7MKN.js';
+//# sourceMappingURL=style-BSEVBI4K.js.map
+//# sourceMappingURL=style-BSEVBI4K.js.map

package/dist/utils.cjs

@@ -1,7 +1,7 @@
 'use strict';
 
 /**
- * Voodoo.js v0.7.0
+ * Voodoo.js v0.10.1
  * JavaScript feels like magic.
  * (c) 2026 Voodoo.js contributors. MIT License.
  */

package/dist/utils.js

@@ -1,4 +1,4 @@
-export { capitalize, chunk, clone, debounce, device, escapeHtml, formatCurrency, formatDate, formatFileSize, formatNumber, formatPercent, get, groupBy, isBrowser, matchesMedia, memoize, merge, once, parseDuration, random, relativeTime, sample, set, setFormatDefaults, sleep, slugify, sortBy, stripTags, throttle, titleCase, truncate, uid, unique, uuid } from './chunk-ZIWLQZZL.js';
-import './chunk-YOZTHZS2.js';
+export { capitalize, chunk, clone, debounce, device, escapeHtml, formatCurrency, formatDate, formatFileSize, formatNumber, formatPercent, get, groupBy, isBrowser, matchesMedia, memoize, merge, once, parseDuration, random, relativeTime, sample, set, setFormatDefaults, sleep, slugify, sortBy, stripTags, throttle, titleCase, truncate, uid, unique, uuid } from './chunk-F3Z3HMZR.js';
+import './chunk-2UST7MKN.js';
 //# sourceMappingURL=utils.js.map
 //# sourceMappingURL=utils.js.map