@xnoxs/flux-lang 3.5.2 → 4.0.0

package/dist/flux.esm.js

@@ -1,5 +1,5 @@
 /*!
- * flux-lang v3.5.2
+ * flux-lang v4.0.0
  * Flux — A modern language that transpiles to JavaScript. Python-clean syntax, TypeScript-level safety, Rust-inspired pattern matching.
  * (c) 2026 Flux Lang Contributors
  * Released under the MIT License
@@ -35,6 +35,7 @@ var require_lexer = __commonJS({
       VAL: "VAL",
       FN: "FN",
       RETURN: "RETURN",
+      DECLARE: "DECLARE",
       // Keywords — control flow
       IF: "IF",
       ELSE: "ELSE",
@@ -171,6 +172,7 @@ var require_lexer = __commonJS({
       val: T.VAL,
       fn: T.FN,
       return: T.RETURN,
+      declare: T.DECLARE,
       if: T.IF,
       else: T.ELSE,
       for: T.FOR,
@@ -308,7 +310,17 @@ var require_lexer = __commonJS({
           if (this.ch() === "\\") {
             this.adv();
             const e = this.adv();
-            text += { n: "\n", t: "	", '"': '"', "'": "'", "\\": "\\", "{": "{", "}": "}" }[e] || "\\" + e;
+            if (e === "u") {
+              const hex = this.src.slice(this.pos, this.pos + 4);
+              this.pos += 4;
+              text += String.fromCharCode(parseInt(hex, 16));
+            } else if (e === "x") {
+              const hex = this.src.slice(this.pos, this.pos + 2);
+              this.pos += 2;
+              text += String.fromCharCode(parseInt(hex, 16));
+            } else {
+              text += { n: "\n", t: "	", r: "\r", '"': '"', "'": "'", "\\": "\\", "{": "{", "}": "}" }[e] || "\\" + e;
+            }
           } else if (this.ch() === "{") {
             parts.push({ type: "text", value: text });
             text = "";
@@ -503,7 +515,17 @@ var require_lexer = __commonJS({
               if (this.ch() === "\\") {
                 this.adv();
                 const e = this.adv();
-                s += { n: "\n", t: "	", r: "\r", "'": "'", "\\": "\\" }[e] || "\\" + e;
+                if (e === "u") {
+                  const hex = this.src.slice(this.pos, this.pos + 4);
+                  this.pos += 4;
+                  s += String.fromCharCode(parseInt(hex, 16));
+                } else if (e === "x") {
+                  const hex = this.src.slice(this.pos, this.pos + 2);
+                  this.pos += 2;
+                  s += String.fromCharCode(parseInt(hex, 16));
+                } else {
+                  s += { n: "\n", t: "	", r: "\r", "'": "'", "\\": "\\" }[e] || "\\" + e;
+                }
               } else {
                 s += this.adv();
               }
@@ -1026,6 +1048,8 @@ var require_parser = __commonJS({
             if (decorators.length) n.decorators = decorators;
             return n;
           }
+          case T.DECLARE:
+            return this.parseDeclareDecl();
           case T.IF:
             return this.parseIf();
           case T.FOR:
@@ -1496,6 +1520,48 @@ var require_parser = __commonJS({
         }
         this.err("Expected -> or : after function signature");
       }
+      // ── declare fn/val/var/class ───────────────────────────────────
+      parseDeclareDecl() {
+        const loc = this.eat(T.DECLARE);
+        const tok = this.peek();
+        if (tok.type === T.FN || tok.type === T.ASYNC) {
+          const isAsync = tok.type === T.ASYNC;
+          this.skip();
+          if (isAsync) this.eat(T.FN);
+          const KEYWORD_AS_NAME = /* @__PURE__ */ new Set([T.NEW, T.DELETE, T.FROM, T.AS, T.DEFAULT, T.IS, T.IN, T.TYPE]);
+          const name = this.check(T.IDENT) || KEYWORD_AS_NAME.has(this.peek().type) ? this.skip().value : null;
+          const params = this.parseParamList();
+          let retType = null;
+          if (this.check(T.ARROW)) {
+            this.pos++;
+            retType = this.parseTypeAnn();
+          } else if (this.check(T.COLON)) {
+            this.pos++;
+            retType = this.parseTypeAnn();
+          }
+          this.skipNewlines();
+          const decl = { type: "FnDecl", name, params, retType, body: [], inline: false, async: isAsync, loc: tok };
+          return { type: "DeclareDecl", decl, loc };
+        }
+        if (tok.type === T.VAL || tok.type === T.VAR) {
+          const kind = tok.type === T.VAR ? "var" : "val";
+          this.skip();
+          const name = this.eat(T.IDENT).value;
+          let typeAnn = null;
+          if (this.maybe(T.COLON)) typeAnn = this.parseTypeAnn();
+          this.skipNewlines();
+          const decl = { type: "VarDecl", kind, name, typeAnn, init: null, loc: tok };
+          return { type: "DeclareDecl", decl, loc };
+        }
+        if (tok.type === T.CLASS) {
+          this.skip();
+          const name = this.eat(T.IDENT).value;
+          this.skipNewlines();
+          const decl = { type: "ClassDecl", name, fields: [], methods: [], loc: tok };
+          return { type: "DeclareDecl", decl, loc };
+        }
+        this.err("Expected fn, async fn, val, var, or class after declare");
+      }
       // ── async fn ──────────────────────────────────────────────────
       parseAsyncFn() {
         this.eat(T.ASYNC);
@@ -2607,6 +2673,9 @@ function _fmt(v, s) {
             return this.genInterfaceDecl(node);
           case "EnumDecl":
             return this.genEnumDecl(node);
+          case "DeclareDecl":
+            return;
+          // ambient declaration — no JS output
           case "ExprStmt":
             return this.emit(this.genExpr(node.expr) + ";");
           default:
@@ -5609,6 +5678,20 @@ var require_type_checker = __commonJS({
             }
             break;
           }
+          case "DeclareDecl": {
+            const d = node.decl;
+            if (d.type === "FnDecl") {
+              const retType = d.retType ? parseAnnotation(d.retType) : null;
+              const paramTypes = d.params.map((p) => p.typeAnn ? parseAnnotation(p.typeAnn) : T_UNKNOWN);
+              if (d.name) env.set(d.name, T_FN(paramTypes, retType || T_UNKNOWN));
+            } else if (d.type === "VarDecl") {
+              const t = d.typeAnn ? parseAnnotation(d.typeAnn) : T_UNKNOWN;
+              env.set(d.name, t);
+            } else if (d.type === "ClassDecl") {
+              env.set(d.name, T_NAMED(d.name));
+            }
+            break;
+          }
           case "TypeDecl":
             for (const v of node.variants) {
               if (v.fields.length === 0) env.set(v.name, T_NAMED(node.name));