vladx 1.2.3 → 1.2.5

package/DOCUMENTAZIONE.md

@@ -174,6 +174,61 @@ costante quadrato = (n) => n * n;
 stampa(quadrato(4)); // 16
 ```
 
+## 🏛️ Classi
+
+VladX supporta la programmazione orientata agli oggetti con classi.
+
+### Dichiarazione Classe
+```javascript
+classe Persona {
+    funzione costruttore(nome, eta) {
+        questo.nome = nome;
+        questo.eta = eta;
+    }
+
+    funzione saluta() {
+        stampa("Ciao, sono " + questo.nome);
+    }
+}
+```
+
+### Creazione Istanze
+Usa la parola chiave `nuovo` per creare un'istanza di una classe:
+```javascript
+variabile p = nuovo Persona("Mario", 25);
+p.saluta(); // "Ciao, sono Mario"
+```
+
+### Ereditarietà
+Le classi possono estendere altre classi usando `da`:
+```javascript
+classe Studente da Persona {
+    funzione costruttore(nome, eta, scuola) {
+        questo.nome = nome;
+        questo.eta = eta;
+        questo.scuola = scuola;
+    }
+
+    funzione studia() {
+        stampa(questo.nome + " studia alla " + questo.scuola);
+    }
+}
+```
+
+### Parola Chiave `questo`
+Usa `questo` per riferirti all'istanza corrente della classe:
+```javascript
+classe Contatore {
+    funzione costruttore() {
+        questo.valore = 0;
+    }
+
+    funzione incrementa() {
+        questo.valore++;
+    }
+}
+```
+
 ---
 
 ## 🧩 Moduli

package/README.md

@@ -63,6 +63,23 @@ funzione saluta(nome) {
 costante somma = (a, b) => a + b;
 ```
 
+### Classi
+```javascript
+classe Persona {
+    funzione costruttore(nome, eta) {
+        questo.nome = nome;
+        questo.eta = eta;
+    }
+
+    funzione saluta() {
+        stampa("Ciao, sono " + questo.nome);
+    }
+}
+
+variabile p = nuovo Persona("Mario", 25);
+p.saluta();
+```
+
 ### Gestione Errori (Try/Catch)
 ```javascript
 prova {

package/examples/test_classi.vx

@@ -0,0 +1,42 @@
+// Test delle classi in VladX
+
+classe Persona {
+    funzione costruttore(nome, eta) {
+        questo.nome = nome;
+        questo.eta = eta;
+    }
+
+    funzione saluta() {
+        stampa("Ciao, sono " + questo.nome + " e ho " + questo.eta + " anni");
+    }
+
+    funzione compieAnni() {
+        questo.eta++;
+        stampa(questo.nome + " ora ha " + questo.eta + " anni");
+    }
+}
+
+variabile p1 = nuovo Persona("Mario", 25);
+p1.saluta();
+p1.compieAnni();
+
+variabile p2 = nuovo Persona("Luigi", 30);
+p2.saluta();
+
+// Test con classe derivata (ereditarietà)
+classe Studente da Persona {
+    funzione costruttore(nome, eta, scuola) {
+        // Chiamata al costruttore padre (se supportato)
+        questo.nome = nome;
+        questo.eta = eta;
+        questo.scuola = scuola;
+    }
+
+    funzione studia() {
+        stampa(questo.nome + " studia alla " + questo.scuola);
+    }
+}
+
+variabile s1 = nuovo Studente("Anna", 20, "Università");
+s1.saluta();
+s1.studia();

package/examples/test_classi_semplice.vx

@@ -0,0 +1,15 @@
+// Test semplice delle classi
+
+classe Test {
+    funzione costruttore(nome) {
+        questo.nome = nome;
+    }
+
+    funzione saluta() {
+        stampa("Ciao " + questo.nome);
+    }
+}
+
+variabile t = nuovo Test("Mario");
+stampa("Istanza creata");
+t.saluta();

package/modules/logger/index.vx

@@ -0,0 +1,68 @@
+// vladx-logger - Logger per VladX
+//
+// API:
+//   - esporta funzione info(messaggio)
+//   - esporta funzione avviso(messaggio)
+//   - esporta funzione errore(messaggio)
+//   - esporta funzione debug(messaggio)
+//   - esporta funzione creaLogger(nome) -> oggetto con i 4 metodi sopra
+//
+// Ogni messaggio viene stampato con timestamp e livello.
+
+funzione _oraIso() {
+    variabile ms = Sistema.esegui("date -u +\"%Y-%m-%dT%H:%M:%SZ\"");
+    ritorna ms;
+}
+
+funzione _formattaMessaggio(livello, nome, messaggio) {
+    variabile prefissoNome = "";
+
+    se (nome && tipo(nome) === "string" && nome !== "") {
+        prefissoNome = "[" + nome + "] ";
+    }
+
+    ritorna "[" + _oraIso().trim() + "]" + "[" + livello + "] " + prefissoNome + messaggio;
+}
+
+funzione _logGenerico(livello, nome, messaggio) {
+    // Se il messaggio non è stringa, proviamo a convertirlo
+    se (tipo(messaggio) !== "string") {
+        messaggio = stringa(messaggio);
+    }
+    stampa(_formattaMessaggio(livello, nome, messaggio));
+}
+
+esporta funzione info(messaggio) {
+    _logGenerico("INFO", "", messaggio);
+}
+
+esporta funzione avviso(messaggio) {
+    _logGenerico("AVVISO", "", messaggio);
+}
+
+esporta funzione errore(messaggio) {
+    _logGenerico("ERRORE", "", messaggio);
+}
+
+esporta funzione debug(messaggio) {
+    _logGenerico("DEBUG", "", messaggio);
+}
+
+// Logger con nome (es. modulo, servizio, contesto)
+esporta funzione creaLogger(nome) {
+    ritorna {
+        info: (messaggio) => _logGenerico("INFO", nome, messaggio),
+        avviso: (messaggio) => _logGenerico("AVVISO", nome, messaggio),
+        errore: (messaggio) => _logGenerico("ERRORE", nome, messaggio),
+        debug: (messaggio) => _logGenerico("DEBUG", nome, messaggio)
+    };
+}
+
+// Esempio rapido se eseguito direttamente
+se (Sistema.argomenti && Sistema.argomenti.length > 0) {
+    variabile log = creaLogger("esempio-logger");
+    info("Logger globale attivo");
+    log.debug("Messaggio di debug");
+    log.info("Informazione di esempio");
+    log.errore("Errore di esempio");
+}

package/modules/logger/vladx-lock.json

@@ -0,0 +1,5 @@
+{
+  "lockfileVersion": 1,
+  "requires": true,
+  "dependencies": {}
+}

package/modules/logger/vladx.json

@@ -0,0 +1,18 @@
+{
+  "name": "vladx-logger",
+  "version": "1.0.0",
+  "description": "Logger semplice per VladX con livelli e prefissi",
+  "main": "index.vx",
+  "scripts": {
+    "start": "vladx index.vx",
+    "test": "vladx test.vx"
+  },
+  "keywords": [
+    "logger",
+    "logging",
+    "vladx"
+  ],
+  "author": "VladX Team",
+  "license": "MIT",
+  "dependencies": {}
+}

package/modules/stringhe/index.vx

@@ -0,0 +1,248 @@
+// vladx-stringhe - Utility per stringhe in VladX
+//
+// API principale (tutte esportate):
+//   - trim(testo)
+//   - minuscolo(testo)
+//   - maiuscolo(testo)
+//   - iniziaCon(testo, prefisso)
+//   - finisceCon(testo, suffisso)
+//   - contiene(testo, parte)
+//   - sostituisciTutto(testo, cerca, sostituisci)
+//   - slug(testo)
+//   - ripeti(testo, volte)
+//   - unisci(separatore, elementiArray)
+
+funzione _assicuratiStringa(valore) {
+    se (tipo(valore) === "string") {
+        ritorna valore;
+    }
+    ritorna stringa(valore);
+}
+
+esporta funzione trim(testo) {
+    testo = _assicuratiStringa(testo);
+
+    // rimuove spazi iniziali
+    mentre (lunghezza(testo) > 0 && (
+        testo[0] === " " ||
+        testo[0] === "\n" ||
+        testo[0] === "\t" ||
+        testo[0] === "\r"
+    )) {
+        testo = testo.substring(1);
+    }
+
+    // rimuove spazi finali
+    mentre (lunghezza(testo) > 0) {
+        variabile ultimo = testo[lunghezza(testo) - 1];
+        se (ultimo === " " || ultimo === "\n" || ultimo === "\t" || ultimo === "\r") {
+            testo = testo.substring(0, lunghezza(testo) - 1);
+        } altrimenti {
+            interrompi;
+        }
+    }
+
+    ritorna testo;
+}
+
+esporta funzione minuscolo(testo) {
+    testo = _assicuratiStringa(testo);
+    ritorna testo.toLowerCase();
+}
+
+esporta funzione maiuscolo(testo) {
+    testo = _assicuratiStringa(testo);
+    ritorna testo.toUpperCase();
+}
+
+esporta funzione iniziaCon(testo, prefisso) {
+    testo = _assicuratiStringa(testo);
+    prefisso = _assicuratiStringa(prefisso);
+
+    se (lunghezza(prefisso) > lunghezza(testo)) {
+        ritorna falso;
+    }
+
+    variabile i = 0;
+    mentre (i < lunghezza(prefisso)) {
+        se (testo[i] !== prefisso[i]) {
+            ritorna falso;
+        }
+        i++;
+    }
+
+    ritorna vero;
+}
+
+esporta funzione finisceCon(testo, suffisso) {
+    testo = _assicuratiStringa(testo);
+    suffisso = _assicuratiStringa(suffisso);
+
+    se (lunghezza(suffisso) > lunghezza(testo)) {
+        ritorna falso;
+    }
+
+    variabile offset = lunghezza(testo) - lunghezza(suffisso);
+    variabile i = 0;
+    mentre (i < lunghezza(suffisso)) {
+        se (testo[offset + i] !== suffisso[i]) {
+            ritorna falso;
+        }
+        i++;
+    }
+
+    ritorna vero;
+}
+
+esporta funzione contiene(testo, parte) {
+    testo = _assicuratiStringa(testo);
+    parte = _assicuratiStringa(parte);
+
+    se (lunghezza(parte) === 0) {
+        ritorna vero;
+    }
+
+    variabile i = 0;
+    mentre (i <= lunghezza(testo) - lunghezza(parte)) {
+        variabile j = 0;
+        variabile match = vero;
+
+        mentre (j < lunghezza(parte)) {
+            se (testo[i + j] !== parte[j]) {
+                match = falso;
+                interrompi;
+            }
+            j++;
+        }
+
+        se (match) {
+            ritorna vero;
+        }
+
+        i++;
+    }
+
+    ritorna falso;
+}
+
+esporta funzione sostituisciTutto(testo, cerca, sostituisci) {
+    testo = _assicuratiStringa(testo);
+    cerca = _assicuratiStringa(cerca);
+    sostituisci = _assicuratiStringa(sostituisci);
+
+    se (lunghezza(cerca) === 0) {
+        ritorna testo;
+    }
+
+    variabile risultato = "";
+    variabile i = 0;
+
+    mentre (i < lunghezza(testo)) {
+        variabile j = 0;
+        variabile match = vero;
+
+        mentre (j < lunghezza(cerca) && i + j < lunghezza(testo)) {
+            se (testo[i + j] !== cerca[j]) {
+                match = falso;
+                interrompi;
+            }
+            j++;
+        }
+
+        se (match && j === lunghezza(cerca)) {
+            risultato = risultato + sostituisci;
+            i = i + lunghezza(cerca);
+        } altrimenti {
+            risultato = risultato + testo[i];
+            i = i + 1;
+        }
+    }
+
+    ritorna risultato;
+}
+
+esporta funzione slug(testo) {
+    testo = _assicuratiStringa(testo);
+
+    // minuscolo
+    testo = testo.toLowerCase();
+
+    // sostituisci spazi con -
+    testo = sostituisciTutto(testo, " ", "-");
+
+    // rimuovi caratteri non alfanumerici (mantieni -)
+    variabile risultato = "";
+    variabile i = 0;
+    mentre (i < lunghezza(testo)) {
+        variabile c = testo[i];
+
+        se (
+            (c >= "a" && c <= "z") ||
+            (c >= "0" && c <= "9") ||
+            c === "-"
+        ) {
+            risultato = risultato + c;
+        }
+
+        i++;
+    }
+
+    // rimuovi eventuali -- doppi
+    mentre (contiene(risultato, "--")) {
+        risultato = sostituisciTutto(risultato, "--", "-");
+    }
+
+    // togli - iniziali e finali
+    risultato = trim(risultato);
+    mentre (lunghezza(risultato) > 0 && risultato[0] === "-") {
+        risultato = risultato.substring(1);
+    }
+    mentre (lunghezza(risultato) > 0 && risultato[lunghezza(risultato) - 1] === "-") {
+        risultato = risultato.substring(0, lunghezza(risultato) - 1);
+    }
+
+    ritorna risultato;
+}
+
+esporta funzione ripeti(testo, volte) {
+    testo = _assicuratiStringa(testo);
+    se (tipo(volte) !== "number" || volte <= 0) {
+        ritorna "";
+    }
+
+    variabile risultato = "";
+    variabile i = 0;
+    mentre (i < volte) {
+        risultato = risultato + testo;
+        i++;
+    }
+
+    ritorna risultato;
+}
+
+esporta funzione unisci(separatore, elementi) {
+    separatore = _assicuratiStringa(separatore);
+
+    se (!array(elementi)) {
+        ritorna "";
+    }
+
+    se (lunghezza(elementi) === 0) {
+        ritorna "";
+    }
+
+    variabile risultato = _assicuratiStringa(elementi[0]);
+    variabile i = 1;
+
+    mentre (i < lunghezza(elementi)) {
+        risultato = risultato + separatore + _assicuratiStringa(elementi[i]);
+        i++;
+    }
+
+    ritorna risultato;
+}
+
+// Esempio rapido se eseguito direttamente
+se (Sistema.argomenti && Sistema.argomenti.length > 0) {
+    stampa(slug("Ciao Mondo da VladX Stringhe!"));
+}

package/modules/stringhe/vladx-lock.json

@@ -0,0 +1,5 @@
+{
+  "lockfileVersion": 1,
+  "requires": true,
+  "dependencies": {}
+}

package/modules/stringhe/vladx.json

@@ -0,0 +1,19 @@
+{
+  "name": "vladx-stringhe",
+  "version": "1.0.0",
+  "description": "Utility per la manipolazione di stringhe in VladX",
+  "main": "index.vx",
+  "scripts": {
+    "start": "vladx index.vx",
+    "test": "vladx test.vx"
+  },
+  "keywords": [
+    "string",
+    "stringhe",
+    "vladx",
+    "utility"
+  ],
+  "author": "VladX Team",
+  "license": "MIT",
+  "dependencies": {}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vladx",
-  "version": "1.2.3",
+  "version": "1.2.5",
   "description": "VladX - Linguaggio di programmazione con sintassi italiana",
   "main": "src/index.js",
   "type": "commonjs",

package/src/interpreter/interpreter.js

@@ -116,6 +116,72 @@ class ArrowFunc {
     }
 }
 
+class VladXClass {
+    constructor(name, superclass, constructor, methods) {
+        this.name = name;
+        this.superclass = superclass;
+        this.constructor = constructor;
+        this.methods = methods;
+    }
+
+    findMethod(name) {
+        if (this.methods.has(name)) {
+            return this.methods.get(name);
+        }
+        if (this.superclass) {
+            return this.superclass.findMethod(name);
+        }
+        return null;
+    }
+}
+
+class VladXInstance {
+    constructor(klass) {
+        this.klass = klass;
+        this.fields = new Map();
+    }
+
+    get(name) {
+        if (this.fields.has(name)) {
+            return this.fields.get(name);
+        }
+        const method = this.klass.findMethod(name);
+        if (method) {
+            return new BoundMethod(method, this);
+        }
+        throw new Error(`Proprietà "${name}" non definita nella classe "${this.klass.name}"`);
+    }
+
+    set(name, value) {
+        this.fields.set(name, value);
+    }
+}
+
+class BoundMethod {
+    constructor(method, instance) {
+        this.method = method;
+        this.instance = instance;
+    }
+
+    call(interpreter, args) {
+        const env = new Environment(this.method.closure);
+        env.define('questo', this.instance);
+        for (let i = 0; i < this.method.declaration.params.length; i++) {
+            env.define(this.method.declaration.params[i], args[i] !== undefined ? args[i] : null);
+        }
+
+        try {
+            interpreter.executeBlock(this.method.declaration.body.body, env);
+        } catch (e) {
+            if (e instanceof ReturnValue) {
+                return e.value;
+            }
+            throw e;
+        }
+        return null;
+    }
+}
+
 const fs = require('fs');
 const path = require('path');
 const http = require('http');
@@ -288,6 +354,8 @@ class Interpreter {
                 return this.executeVariableDeclaration(node);
             case 'FunctionDeclaration':
                 return this.executeFunctionDeclaration(node);
+            case 'ClassDeclaration':
+                return this.executeClassDeclaration(node);
             case 'BlockStatement':
                 return this.executeBlock(node.body, new Environment(this.environment));
             case 'IfStatement':
@@ -329,6 +397,28 @@ class Interpreter {
         this.environment.define(node.name, func);
     }
 
+    executeClassDeclaration(node) {
+        let superclass = null;
+        if (node.superclass) {
+            const superclassValue = this.environment.get(node.superclass);
+            if (!(superclassValue instanceof VladXClass)) {
+                throw new Error(`"${node.superclass}" non è una classe`);
+            }
+            superclass = superclassValue;
+        }
+
+        const methods = new Map();
+        if (node.constructor) {
+            methods.set('costruttore', new VladXFunction(node.constructor, this.environment));
+        }
+        for (const method of node.methods) {
+            methods.set(method.name, new VladXFunction(method, this.environment));
+        }
+
+        const klass = new VladXClass(node.name, superclass, node.constructor, methods);
+        this.environment.define(node.name, klass);
+    }
+
     executeBlock(statements, env) {
         const previousEnv = this.environment;
         this.environment = env;
@@ -502,6 +592,8 @@ class Interpreter {
                 return null;
             case 'Identifier':
                 return this.environment.get(node.name);
+            case 'ThisExpression':
+                return this.environment.get('questo');
             case 'ArrayLiteral':
                 return node.elements.map(el => this.evaluate(el));
             case 'ObjectLiteral':
@@ -522,15 +614,31 @@ class Interpreter {
                 return this.evaluateUpdateExpression(node);
             case 'CallExpression':
                 return this.evaluateCallExpression(node);
+            case 'NewExpression':
+                return this.evaluateNewExpression(node);
             case 'MemberExpression':
                 return this.evaluateMemberExpression(node);
             case 'ArrowFunction':
                 return new ArrowFunc(node.params, node.body, this.environment);
+            case 'TemplateLiteral':
+                return this.evaluateTemplateLiteral(node);
             default:
                 throw new Error(`Tipo espressione sconosciuto: ${node.type}`);
         }
     }
 
+    evaluateTemplateLiteral(node) {
+        let result = node.quasis[0];
+
+        for (let i = 0; i < node.expressions.length; i++) {
+            const value = this.evaluate(node.expressions[i]);
+            result += this.stringify(value);
+            result += node.quasis[i + 1];
+        }
+
+        return result;
+    }
+
     evaluateBinaryExpression(node) {
         const left = this.evaluate(node.left);
         const right = this.evaluate(node.right);
@@ -592,7 +700,13 @@ class Interpreter {
             const prop = node.left.computed
                 ? this.evaluate(node.left.property)
                 : node.left.property.name;
-            obj[prop] = value;
+
+            // Handle class instances
+            if (obj instanceof VladXInstance) {
+                obj.set(prop, value);
+            } else {
+                obj[prop] = value;
+            }
         }
 
         return value;
@@ -620,6 +734,25 @@ class Interpreter {
         throw new Error(`"${node.callee.name || 'valore'}" non è una funzione`);
     }
 
+    evaluateNewExpression(node) {
+        const klass = this.evaluate(node.callee);
+
+        if (!(klass instanceof VladXClass)) {
+            throw new Error(`"${node.callee.name || 'valore'}" non è una classe`);
+        }
+
+        const instance = new VladXInstance(klass);
+        const constructor = klass.findMethod('costruttore');
+
+        if (constructor) {
+            const boundConstructor = new BoundMethod(constructor, instance);
+            const args = node.arguments.map(arg => this.evaluate(arg));
+            boundConstructor.call(this, args);
+        }
+
+        return instance;
+    }
+
     evaluateMemberExpression(node) {
         const obj = this.evaluate(node.object);
         if (obj === null || obj === undefined) {
@@ -643,6 +776,11 @@ class Interpreter {
             }
         }
 
+        // Handle class instances
+        if (obj instanceof VladXInstance) {
+            return obj.get(prop);
+        }
+
         return obj[prop];
     }
 
@@ -674,4 +812,4 @@ class Interpreter {
     }
 }
 
-module.exports = { Interpreter, Environment };
+module.exports = { Interpreter, Environment, VladXClass, VladXInstance };

package/src/lexer/lexer.js

@@ -25,6 +25,8 @@ class Lexer {
         this.current = 0;
         this.line = 1;
         this.column = 1;
+        this.braceDepth = 0;
+        this.templateStack = [];
     }
 
     peek() {
@@ -149,6 +151,70 @@ class Lexer {
         this.tokens.push(new Token(TokenType.STRINGA, value, startLine, startColumn));
     }
 
+    readTemplateString(isRestart) {
+        // If not restarting (fresh backtick), consume the backtick
+        if (!isRestart) {
+            this.advance();
+        }
+
+        let value = '';
+        const startLine = this.line;
+        const startColumn = this.column;
+
+        while (!this.isAtEnd()) {
+            // Check for end of template string
+            if (this.peek() === '`') {
+                this.advance(); // consume backtick
+                if (isRestart) {
+                    this.tokens.push(new Token(TokenType.TEMPLATE_FINE, value, startLine, startColumn));
+                } else {
+                    this.tokens.push(new Token(TokenType.TEMPLATE_COMPLETO, value, startLine, startColumn));
+                }
+                return;
+            }
+
+            // Check for start of interpolation
+            if (this.peek() === '$' && this.peekNext() === '{') {
+                this.advance(); // consume $
+                this.advance(); // consume {
+
+                if (isRestart) {
+                    this.tokens.push(new Token(TokenType.TEMPLATE_CENTRO, value, startLine, startColumn));
+                } else {
+                    this.tokens.push(new Token(TokenType.TEMPLATE_INIZIO, value, startLine, startColumn));
+                }
+
+                // Track brace depth for this interpolation
+                this.templateStack.push(this.braceDepth);
+                return;
+            }
+
+            // Handle escapes
+            if (this.peek() === '\\') {
+                this.advance();
+                if (this.isAtEnd()) break;
+
+                const escaped = this.peek();
+                switch (escaped) {
+                    case 'n': value += '\n'; break;
+                    case 't': value += '\t'; break;
+                    case 'r': value += '\r'; break;
+                    case '\\': value += '\\'; break;
+                    case '"': value += '"'; break;
+                    case "'": value += "'"; break;
+                    case '`': value += '`'; break;
+                    case '$': value += '$'; break;
+                    default: value += escaped;
+                }
+                this.advance();
+            } else {
+                value += this.advance();
+            }
+        }
+
+        throw new Error(`Template string non terminata alla riga ${startLine}`);
+    }
+
     readIdentifier() {
         const startColumn = this.column;
         let value = '';
@@ -182,8 +248,22 @@ class Lexer {
         switch (char) {
             case '(': this.addToken(TokenType.PARENTESI_APERTA, '('); break;
             case ')': this.addToken(TokenType.PARENTESI_CHIUSA, ')'); break;
-            case '{': this.addToken(TokenType.GRAFFA_APERTA, '{'); break;
-            case '}': this.addToken(TokenType.GRAFFA_CHIUSA, '}'); break;
+
+            case '{':
+                this.braceDepth++;
+                this.addToken(TokenType.GRAFFA_APERTA, '{');
+                break;
+
+            case '}':
+                if (this.templateStack.length > 0 && this.braceDepth === this.templateStack[this.templateStack.length - 1]) {
+                    this.templateStack.pop();
+                    this.readTemplateString(true);
+                } else {
+                    this.braceDepth--;
+                    this.addToken(TokenType.GRAFFA_CHIUSA, '}');
+                }
+                break;
+
             case '[': this.addToken(TokenType.QUADRA_APERTA, '['); break;
             case ']': this.addToken(TokenType.QUADRA_CHIUSA, ']'); break;
             case ',': this.addToken(TokenType.VIRGOLA, ','); break;
@@ -253,6 +333,12 @@ class Lexer {
                 this.readString(char);
                 break;
 
+            case '`':
+                this.current--;
+                this.column--;
+                this.readTemplateString(false);
+                break;
+
             default:
                 if (this.isDigit(char)) {
                     this.current--;

package/src/lexer/tokens.js

@@ -78,7 +78,13 @@ const TokenType = {
 
     // Special
     FINE: 'FINE',
-    SCONOSCIUTO: 'SCONOSCIUTO'
+    SCONOSCIUTO: 'SCONOSCIUTO',
+
+    // Template Strings
+    TEMPLATE_COMPLETO: 'TEMPLATE_COMPLETO', // `stringa`
+    TEMPLATE_INIZIO: 'TEMPLATE_INIZIO',     // `str${
+    TEMPLATE_CENTRO: 'TEMPLATE_CENTRO',     // }str${
+    TEMPLATE_FINE: 'TEMPLATE_FINE'          // }str`
 };
 
 const KEYWORDS = {

package/src/parser/ast.js

@@ -36,6 +36,30 @@ class FunctionDeclaration extends ASTNode {
     }
 }
 
+class ClassDeclaration extends ASTNode {
+    constructor(name, superclass, constructor, methods) {
+        super('ClassDeclaration');
+        this.name = name;
+        this.superclass = superclass;
+        this.constructor = constructor;
+        this.methods = methods;
+    }
+}
+
+class ThisExpression extends ASTNode {
+    constructor() {
+        super('ThisExpression');
+    }
+}
+
+class NewExpression extends ASTNode {
+    constructor(callee, args) {
+        super('NewExpression');
+        this.callee = callee;
+        this.arguments = args;
+    }
+}
+
 // === Statements ===
 class BlockStatement extends ASTNode {
     constructor(body) {
@@ -150,6 +174,14 @@ class StringLiteral extends ASTNode {
     }
 }
 
+class TemplateLiteral extends ASTNode {
+    constructor(quasis, expressions) {
+        super('TemplateLiteral');
+        this.quasis = quasis;
+        this.expressions = expressions;
+    }
+}
+
 class BooleanLiteral extends ASTNode {
     constructor(value) {
         super('BooleanLiteral');
@@ -284,6 +316,7 @@ module.exports = {
     Program,
     VariableDeclaration,
     FunctionDeclaration,
+    ClassDeclaration,
     BlockStatement,
     IfStatement,
     WhileStatement,
@@ -314,5 +347,8 @@ module.exports = {
     MemberExpression,
     ArrowFunction,
     UpdateExpression,
-    LogicalExpression
+    LogicalExpression,
+    ThisExpression,
+    NewExpression,
+    TemplateLiteral
 };

package/src/parser/parser.js

@@ -74,6 +74,7 @@ class Parser {
             if (this.match(TokenType.VARIABILE)) return this.variableDeclaration(false);
             if (this.match(TokenType.COSTANTE)) return this.variableDeclaration(true);
             if (this.match(TokenType.FUNZIONE)) return this.functionDeclaration();
+            if (this.match(TokenType.CLASSE)) return this.classDeclaration();
             return this.statement();
         } catch (error) {
             this.synchronize();
@@ -112,6 +113,10 @@ class Parser {
             const decl = this.functionDeclaration();
             return new AST.ExportNamedDeclaration(decl);
         }
+        if (this.match(TokenType.CLASSE)) {
+            const decl = this.classDeclaration();
+            return new AST.ExportNamedDeclaration(decl);
+        }
         if (this.match(TokenType.VARIABILE)) {
             const decl = this.variableDeclaration(false);
             return new AST.ExportNamedDeclaration(decl);
@@ -120,7 +125,7 @@ class Parser {
             const decl = this.variableDeclaration(true);
             return new AST.ExportNamedDeclaration(decl);
         }
-        throw new ParserError('Atteso funzione o variabile dopo "esporta"', this.peek());
+        throw new ParserError('Atteso funzione, classe o variabile dopo "esporta"', this.peek());
     }
 
     functionDeclaration() {
@@ -138,6 +143,54 @@ class Parser {
         return new AST.FunctionDeclaration(name, params, body);
     }
 
+    classDeclaration() {
+        // Il token CLASSE è già stato consumato se chiamato da exportDeclaration
+        // Ma se chiamato direttamente, dobbiamo consumarlo
+        if (!this.previous() || this.previous().type !== TokenType.CLASSE) {
+            if (this.check(TokenType.CLASSE)) {
+                this.advance();
+            }
+        }
+        const name = this.consume(TokenType.IDENTIFICATORE, 'Nome classe atteso').value;
+
+        let superclass = null;
+        if (this.match(TokenType.DA)) {
+            superclass = this.consume(TokenType.IDENTIFICATORE, 'Nome classe padre atteso').value;
+        }
+
+        this.consume(TokenType.GRAFFA_APERTA, 'Atteso "{" dopo nome classe');
+
+        let constructor = null;
+        const methods = [];
+
+        while (!this.check(TokenType.GRAFFA_CHIUSA) && !this.isAtEnd()) {
+            if (this.match(TokenType.FUNZIONE)) {
+                const funcName = this.consume(TokenType.IDENTIFICATORE, 'Nome metodo atteso').value;
+                this.consume(TokenType.PARENTESI_APERTA, 'Atteso "(" dopo nome metodo');
+                const params = [];
+                if (!this.check(TokenType.PARENTESI_CHIUSA)) {
+                    do {
+                        params.push(this.consume(TokenType.IDENTIFICATORE, 'Nome parametro atteso').value);
+                    } while (this.match(TokenType.VIRGOLA));
+                }
+                this.consume(TokenType.PARENTESI_CHIUSA, 'Atteso ")" dopo parametri');
+                this.consume(TokenType.GRAFFA_APERTA, 'Atteso "{" prima del corpo metodo');
+                const body = this.blockStatement();
+
+                if (funcName === 'costruttore') {
+                    constructor = new AST.FunctionDeclaration('costruttore', params, body);
+                } else {
+                    methods.push(new AST.FunctionDeclaration(funcName, params, body));
+                }
+            } else {
+                throw new ParserError('Atteso metodo nella classe', this.peek());
+            }
+        }
+
+        this.consume(TokenType.GRAFFA_CHIUSA, 'Atteso "}" alla fine della classe');
+        return new AST.ClassDeclaration(name, superclass, constructor, methods);
+    }
+
     statement() {
         if (this.match(TokenType.SE)) return this.ifStatement();
         if (this.match(TokenType.MENTRE)) return this.whileStatement();
@@ -414,6 +467,19 @@ class Parser {
         return expr;
     }
 
+    newExpression() {
+        const callee = this.consume(TokenType.IDENTIFICATORE, 'Nome classe atteso dopo "nuovo"').value;
+        this.consume(TokenType.PARENTESI_APERTA, 'Atteso "(" dopo nome classe');
+        const args = [];
+        if (!this.check(TokenType.PARENTESI_CHIUSA)) {
+            do {
+                args.push(this.expression());
+            } while (this.match(TokenType.VIRGOLA));
+        }
+        this.consume(TokenType.PARENTESI_CHIUSA, 'Atteso ")" dopo argomenti');
+        return new AST.NewExpression(new AST.Identifier(callee), args);
+    }
+
     finishCall(callee) {
         const args = [];
         if (!this.check(TokenType.PARENTESI_CHIUSA)) {
@@ -438,12 +504,40 @@ class Parser {
             return new AST.StringLiteral(this.previous().value);
         }
 
+        if (this.match(TokenType.TEMPLATE_COMPLETO)) {
+            return new AST.TemplateLiteral([this.previous().value], []);
+        }
+
+        if (this.match(TokenType.TEMPLATE_INIZIO)) {
+            const quasis = [this.previous().value];
+            const expressions = [];
+
+            while (true) {
+                expressions.push(this.expression());
+
+                if (this.match(TokenType.TEMPLATE_CENTRO)) {
+                    quasis.push(this.previous().value);
+                } else if (this.match(TokenType.TEMPLATE_FINE)) {
+                    quasis.push(this.previous().value);
+                    break;
+                } else {
+                    throw new ParserError('Atteso parte centrale o finale della template string', this.peek());
+                }
+            }
+
+            return new AST.TemplateLiteral(quasis, expressions);
+        }
+
+        if (this.match(TokenType.NUOVO)) {
+            return this.newExpression();
+        }
+
         if (this.match(TokenType.IDENTIFICATORE)) {
             return new AST.Identifier(this.previous().value);
         }
 
         if (this.match(TokenType.QUESTO)) {
-            return new AST.Identifier('questo');
+            return new AST.ThisExpression();
         }
 
         if (this.match(TokenType.QUADRA_APERTA)) {