starlight-cli 1.1.19 → 1.1.21

package/README.md

@@ -1,125 +1,339 @@
+# Starlight Language Guide
 
-# Starlight Programming Language 
+Welcome to **Starlight Language**, a simple and expressive server-side scripting programming language designed for clarity and flexibility.
 
-Starlight is a lightweight, developer-oriented programming language designed for **server-side scripting, automation, and general-purpose programming**. It combines a clean, readable syntax inspired by JavaScript and Python with powerful runtime features such as async/await, modules, and interactive I/O.
+This guide introduces the core concepts and syntax to help you start writing programs quickly.
 
- **Official Reference:**  
-https://starlight-programming-language.pages.dev/tutorials
 ---
-## Error Handling in Starlight
 
-Starlight is designed with **modern, developer-friendly error handling** that clearly explains what went wrong, where it happened, and how to fix it.
+## 1. Hello World
 
-###  Modern Diagnostic Style
+```sl
+sldeploy "Hello, world!"
+```
 
-Starlight errors follow the same diagnostic standards used by modern languages such as JavaScript, Rust, and Python:
+---
 
-- Clear error message
-- Exact **line and column number**
-- Source code preview
-- Visual caret (`^`) pointing to the error location
-- Helpful suggestions when possible
+## 2. Variables
 
-Example:
+Variables are declared using the `define` keyword.
 
+```sl
+define name = "Alice"
+define age = 20
 ```
 
-Unterminated block
-Did you forget to close the block with '}'?
-at line 5, column 0
+### Supported Value Types
+
+| Type    | Example              |
+| ------- | -------------------- |
+| Number  | `10`, `3.14`         |
+| String  | `"hello"`            |
+| Boolean | `true`, `false`      |
+| Array   | `[1, 2, 3]`          |
+| Object  | `{ "a": 1, "b": 2 }` |
+| Null    | `null`               |
+
+---
+
+## 3. Output
+
+Use `sldeploy` to print values:
 
+```sl
+sldeploy name
+sldeploy age
 ```
-^
+
+---
+
+## 4. Input
+
+Use `ask` to read user input:
+
+```sl
+define name = ask("Enter your name:")
+sldeploy "Hello " + name
 ```
 
-````
+---
+
+## 5. Operators
+
+### Arithmetic Operators
 
-This format makes debugging fast and intuitive, even for beginners.
+| Operator | Description    |
+| -------- | -------------- |
+| `+`      | Addition       |
+| `-`      | Subtraction    |
+| `*`      | Multiplication |
+| `/`      | Division       |
+| `%`      | Modulus        |
+
+Example:
+
+```sl
+define result = 10 + 5 * 2
+```
 
 ---
 
-### 🧠 Syntax Errors (Parser Errors)
+### Comparison Operators
+
+| Operator | Description           |
+| -------- | --------------------- |
+| `==`     | Equal                 |
+| `!=`     | Not equal             |
+| `<`      | Less than             |
+| `<=`     | Less than or equal    |
+| `>`      | Greater than          |
+| `>=`     | Greater than or equal |
+
+---
 
-Syntax errors are detected during parsing and reported before execution begins.
+### Logical Operators
 
-Features:
-- Precise location tracking
-- Friendly suggestions
-- No Node.js stack traces
-- Clean termination
+| Operator | Description     |
+| -------- | --------------- |
+| `AND`    | Logical AND     |
+| `OR`     | Logical OR      |
+| `??`     | Null coalescing |
 
 Example:
+
+```sl
+define x = null ?? 10
+```
+
+---
+
+## 6. Conditional Statements
+
+```sl
+if (age > 18) {
+    sldeploy "Adult"
+} else {
+    sldeploy "Minor"
+}
+```
+
+---
+
+## 7. Loops
+
+### While Loop
+
+```sl
+define i = 0
+
+while (i < 5) {
+    sldeploy i
+    i = i + 1
+}
+```
+
+---
+
+### For Loop
+
+```sl
+for (define i = 0; i < 5; i = i + 1) {
+    sldeploy i
+}
+```
+
+---
+
+### For-In Loop
+
+```sl
+define arr = [10, 20, 30]
+
+for x in arr {
+    sldeploy x
+}
+```
+
+---
+
+## 8. Functions
+
+### Function Declaration
+
 ```sl
-if true {
-  sldeploy("This block is never closed")
-````
+func add(a, b) {
+    return a + b
+}
+```
 
-Output:
+### Function Usage
 
+```sl
+define result = add(2, 3)
+sldeploy result
 ```
-Unterminated block
-Did you forget to close the block with '}'?
-  at line 2, column 0
 
-    ^
+---
+
+### Arrow Functions
+
+```sl
+define add = (a, b) => a + b
 ```
 
 ---
 
-### ⚙️ Runtime Errors (Evaluator Errors)
+## 9. Arrays
 
-Runtime errors occur during execution and include:
+```sl
+define arr = [1, 2, 3]
+
+sldeploy arr[0]
+```
 
-* Undefined variables
-* Invalid operations
-* Logical mistakes
+### Common Array Operations
 
-Starlight also provides **intelligent name suggestions**:
+| Function | Description         |
+| -------- | ------------------- |
+| `push`   | Add element         |
+| `pop`    | Remove last element |
 
+```sl
+push(arr, 4)
+pop(arr)
 ```
-Undefined variable: "scroe"
-Did you mean "score"?
-  at line 10, column 5
-      ^
+
+---
+
+## 10. Objects
+
+```sl
+define user = {
+    "name": "Alice",
+    "age": 20
+}
+
+sldeploy user.name
 ```
 
 ---
 
-### 🎨 Color-Coded Errors
+## 11. Slicing
+
+```sl
+define arr = [1, 2, 3, 4, 5]
 
-Errors are color-coded for clarity:
+sldeploy arr[1:4]
+sldeploy arr[0:5:2]
+```
 
-* **Red** – Fatal syntax or runtime errors
-* **Yellow** – Warnings or suggestions
-* **White** – Neutral information (source preview, pointers)
+### Slice Syntax
 
-This ensures errors are readable in all terminals.
+| Format             | Description        |
+| ------------------ | ------------------ |
+| `[start:end]`      | Basic slicing      |
+| `[start:end:step]` | Step-based slicing |
 
 ---
 
-###  Safe Execution Model
+## 12. Error Handling
 
-* Execution **stops immediately** on error
-* No uncaught exceptions
-* No JavaScript stack traces leaked
-* Clean exit behavior
+```sl
+do {
+    define x = y
+} track {
+    sldeploy "Error occurred"
+}
+```
 
-This keeps Starlight predictable and safe for learning and production use.
+---
+
+## 13. Imports
+
+```sl
+import math from "math"
+```
+
+### Supported Imports
+
+| Type            | Description           |
+| --------------- | --------------------- |
+| `.sl` files     | Local modules         |
+| Node.js modules | External dependencies |
 
 ---
 
-###  Summary
+## 14. Built-in Functions
 
-Starlight’s error handling is:
+Examples:
 
-* Modern
-* Precise
-* Beginner-friendly
-* Professional-grade
+```sl
+len([1,2,3])
+upper("hello")
+random(1, 10)
+```
+
+### Categories
+
+| Category | Examples         |
+| -------- | ---------------- |
+| String   | `upper`, `lower` |
+| Array    | `push`, `pop`    |
+| Math     | `random`         |
+| Utility  | `len`            |
+
+---
+
+## 15. Asynchronous Code
+
+```sl
+define data = await get("https://api.example.com")
+sldeploy data
+```
+
+---
+
+## 16. Object Construction
+
+```sl
+func Person(name) {
+    this.name = name
+}
+
+define p = new Person("Alice")
+sldeploy p.name
+```
+
+---
+
+## 17. Comments
 
-By using caret-based diagnostics and intelligent suggestions, Starlight provides a first-class developer experience from day one.
+```sl
+# This is a comment
+```
+
+---
 
+## 18. Language Notes
+
+| Behavior         | Description                       |
+| ---------------- | --------------------------------- |
+| Undefined values | Treated as `null`                 |
+| Function return  | Defaults to `null` if unspecified |
+| Data structures  | Dynamic (arrays and objects)      |
+| Error reporting  | Includes line and column details  |
+
+---
+
+## 19. Next Steps
+
+* Explore built-in functions
+* Write small programs
+* Review full syntax reference
+* Experiment with custom scripts
+
+---
 
+## Keywords
 
-## Author and Developer
-Dominex Macedon
+starlight language, scripting language, programming language tutorial, interpreter language, CLI scripting, custom language design

package/dist/index.js

@@ -10356,9 +10356,42 @@ async callFunction(fn, args, env, node = null) {
 
   throw new RuntimeError('Value is not callable', node, this.source);
 }
+createBaseProxy(instance, parentEntity) {
+  const evaluator = this;
+
+  return new Proxy({}, {
+    get(_, prop) {
+      const method = parentEntity.methods[prop];
+
+      if (!method) {
+        throw new RuntimeError(
+          `Base method '${prop}' not found`,
+          null,
+          evaluator.source
+        );
+      }
+
+      return async (...args) => {
+        const methodEnv = new Environment(parentEntity.env);
 
+        methodEnv.define('self', instance);
 
+        if (parentEntity.parent) {
+          methodEnv.define(
+            'base',
+            evaluator.createBaseProxy(instance, parentEntity.parent)
+          );
+        }
 
+        for (let i = 0; i < method.params.length; i++) {
+          methodEnv.define(method.params[i], args[i]);
+        }
+
+        return await evaluator.evaluate(method.body, methodEnv);
+      };
+    }
+  });
+}
 formatValue(value, seen = new Set()) {
   const color = __nccwpck_require__(55);
 
@@ -11028,6 +11061,19 @@ case 'SliceExpression':
     case 'Identifier': return env.get(node.name, node, this.source);
     case 'IfStatement': return await this.evalIf(node, env);
     case 'WhileStatement': return await this.evalWhile(node, env);
+    case 'EntityDeclaration':
+  return await this.evalEntity(node, env);
+
+case 'EntityInstantiation':
+  return await this.evalEntityNew(node, env);
+
+case 'SelfExpression':
+  return env.get('self', node, this.source);
+
+case 'InitMethod':
+  return node;
+case 'InheritsClause':
+  return await this.evalInherits(node, env);
     case 'ForStatement':
 case 'ForInStatement':
   return await this.evalFor(node, env);
@@ -11065,6 +11111,70 @@ case 'RaceClause':
     case 'NewExpression': {
   const callee = await this.evaluate(node.callee, env);
 
+  const args = [];
+  for (const a of node.arguments) {
+    args.push(await this.evaluate(a, env));
+  }
+ 
+  if (callee && callee.methods) {
+    const instance = {};
+ 
+     
+
+    const evaluator = this;
+
+    const entityEnv = new Environment(callee.env);
+    entityEnv.define('self', instance);
+ 
+    if (callee.parent) {
+      entityEnv.define(
+        'base',
+        this.createBaseProxy(instance, callee.parent)
+      );
+    }
+ 
+    if (callee.methods.init) {
+      const init = callee.methods.init;
+
+      for (let i = 0; i < init.params.length; i++) {
+        entityEnv.define(init.params[i], args[i]);
+      }
+
+      await evaluator.evaluate(init.body, entityEnv);
+    }
+ 
+    for (const key in callee.methods) {
+      if (key === 'init') continue;
+
+      instance[key] = async (...callArgs) => {
+        const methodEnv = new Environment(callee.env);
+
+        methodEnv.define('self', instance);
+
+        if (callee.parent) {
+          methodEnv.define(
+            'base',
+            evaluator.createBaseProxy(instance, callee.parent)
+          );
+        }
+
+        for (let i = 0; i < callee.methods[key].params.length; i++) {
+          methodEnv.define(
+            callee.methods[key].params[i],
+            callArgs[i]
+          );
+        }
+
+        return await evaluator.evaluate(
+          callee.methods[key].body,
+          methodEnv
+        );
+      };
+    }
+
+    return instance;
+  }
+ 
   if (typeof callee === 'object' && callee.body) {
     const evaluator = this;
 
@@ -11074,7 +11184,9 @@ case 'RaceClause':
 
       for (let i = 0; i < callee.params.length; i++) {
         const param = callee.params[i];
-        const paramName = typeof param === 'string' ? param : param.name;
+        const paramName =
+          typeof param === 'string' ? param : param.name;
+
         newEnv.define(paramName, args[i]);
       }
 
@@ -11084,18 +11196,17 @@ case 'RaceClause':
       })();
     };
 
-    const args = [];
-    for (const a of node.arguments) args.push(await this.evaluate(a, env));
     return await new Constructor(...args);
   }
-
-  // native JS constructor fallback
+ 
   if (typeof callee !== 'function') {
-    throw new RuntimeError('NewExpression callee is not a function', node, this.source);
+    throw new RuntimeError(
+      'NewExpression callee is not a function',
+      node,
+      this.source
+    );
   }
 
-  const args = [];
-  for (const a of node.arguments) args.push(await this.evaluate(a, env));
   return new callee(...args);
 }
 
@@ -11104,7 +11215,20 @@ case 'RaceClause':
 
   }
 }
+async evalInherits(node, env) {
+  const parent = await this.evaluate(node.parent, env);
 
+  if (!parent || !parent.methods) {
+    throw new RuntimeError(
+      'Invalid parent entity',
+      node,
+      this.source,
+      env
+    );
+  }
+
+  return parent;
+}
 async evalProgram(node, env) {
   let result = null;
   for (const stmt of node.body) {
@@ -11126,6 +11250,29 @@ async evalProgram(node, env) {
   }
   return result;
 }
+async evalEntity(node, env) {
+  const entity = {
+    name: node.name,
+    methods: {},
+    parent: null,
+    env
+  };
+
+  if (node.inherits) {
+    entity.parent = await this.evaluate(node.inherits, env);
+  }
+
+  for (const method of node.body) {
+    entity.methods[method.name] = {
+      params: method.params,
+      body: method.body,
+      env
+    };
+  }
+
+  env.define(node.name, entity);
+  return entity;
+}
 async evalSlice(node, env) {
   try {
     const arr = await this.evaluate(node.object, env);
@@ -12242,7 +12389,7 @@ class Lexer {
       'break', 'continue', 'func', 'return',
       'true', 'false', 'null',
       'ask', 'define', 'import', 'from', 'as',
-      'async', 'await', 'new', 'in', 'do', 'track', 'start', 'race', 'not', 'and', 'or'
+      'async', 'await', 'new', 'in', 'do', 'track', 'start', 'race', 'not', 'and', 'or', 'entity', 'self', 'inherits', 'init'
     ];
 }
 
@@ -12536,6 +12683,7 @@ class Parser {
       case 'IF': return this.ifStatement();
       case 'WHILE': return this.whileStatement();
       case 'FOR': return this.forStatement();
+      case 'ENTITY': return this.entityDeclaration();
       case 'DO': return this.doTrackStatement();
       case 'START': return this.startStatement();
       case 'BREAK': return this.breakStatement();
@@ -12603,7 +12751,103 @@ varDeclaration() {
     column: t.column 
   };
 }
+entityDeclaration() {
+  const t = this.current;
+  this.eat('ENTITY');
+
+  if (this.current.type !== 'IDENTIFIER') {
+    throw new ParseError(
+      "Expected entity name",
+      this.current,
+      this.source,
+      "Use: entity Car { ... }"
+    );
+  }
+
+  const name = this.current.value;
+  this.eat('IDENTIFIER');
+
+  let parent = null;
+
+  if (this.current.type === 'INHERITS') {
+    this.eat('INHERITS');
+
+    if (this.current.type !== 'IDENTIFIER') {
+      throw new ParseError(
+        "Expected parent entity name",
+        this.current,
+        this.source
+      );
+    }
+
+    parent = {
+      type: 'Identifier',
+      name: this.current.value
+    };
+
+    this.eat('IDENTIFIER');
+  }
+
+  this.eat('LBRACE');
+
+  const body = [];
+
+  while (this.current.type !== 'RBRACE') {
+    body.push(this.methodDefinition());
+  }
+
+  this.eat('RBRACE');
+
+  return {
+    type: 'EntityDeclaration',
+    name,
+    parent,
+    body,
+    line: t.line,
+    column: t.column
+  };
+}
+methodDefinition() {
+  if (this.current.type !== 'IDENTIFIER' && this.current.type !== 'INIT') {
+    throw new ParseError(
+      "Expected method name",
+      this.current,
+      this.source
+    );
+  }
+
+  const isInit = this.current.type === 'INIT';
+  const name = isInit ? 'init' : this.current.value;
+
+  this.eat(this.current.type);
 
+  this.eat('LPAREN');
+
+  const params = [];
+
+  if (this.current.type !== 'RPAREN') {
+    params.push(this.current.value);
+    this.eat('IDENTIFIER');
+
+    while (this.current.type === 'COMMA') {
+      this.eat('COMMA');
+      params.push(this.current.value);
+      this.eat('IDENTIFIER');
+    }
+  }
+
+  this.eat('RPAREN');
+
+  const body = this.block();
+
+  return {
+    type: 'MethodDefinition',
+    name,
+    params,
+    body,
+    isInit
+  };
+}
 startStatement() {
   const t = this.current; 
   this.eat('START');
@@ -13886,7 +14130,15 @@ arrowFunction(params) {
 
 primary() {
   const t = this.current;
+if (t.type === 'BASE') {
+  this.eat('BASE');
+  return { type: 'Identifier', name: 'base', line: t.line, column: t.column };
+}
 
+if (t.type === 'SELF') {
+  this.eat('SELF');
+  return { type: 'Identifier', name: 'self', line: t.line, column: t.column };
+}
   if (t.type === 'NUMBER') {
     this.eat('NUMBER');
     return { type: 'Literal', value: t.value, line: t.line, column: t.column };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "starlight-cli",
-  "version": "1.1.19",
+  "version": "1.1.21",
   "description": "Starlight Programming Language CLI",
   "bin": {
     "starlight": "index.js"

package/src/evaluator.js

@@ -146,9 +146,42 @@ async callFunction(fn, args, env, node = null) {
 
   throw new RuntimeError('Value is not callable', node, this.source);
 }
+createBaseProxy(instance, parentEntity) {
+  const evaluator = this;
 
+  return new Proxy({}, {
+    get(_, prop) {
+      const method = parentEntity.methods[prop];
 
+      if (!method) {
+        throw new RuntimeError(
+          `Base method '${prop}' not found`,
+          null,
+          evaluator.source
+        );
+      }
+
+      return async (...args) => {
+        const methodEnv = new Environment(parentEntity.env);
 
+        methodEnv.define('self', instance);
+
+        if (parentEntity.parent) {
+          methodEnv.define(
+            'base',
+            evaluator.createBaseProxy(instance, parentEntity.parent)
+          );
+        }
+
+        for (let i = 0; i < method.params.length; i++) {
+          methodEnv.define(method.params[i], args[i]);
+        }
+
+        return await evaluator.evaluate(method.body, methodEnv);
+      };
+    }
+  });
+}
 formatValue(value, seen = new Set()) {
   const color = require('starlight-color');
 
@@ -818,6 +851,19 @@ case 'SliceExpression':
     case 'Identifier': return env.get(node.name, node, this.source);
     case 'IfStatement': return await this.evalIf(node, env);
     case 'WhileStatement': return await this.evalWhile(node, env);
+    case 'EntityDeclaration':
+  return await this.evalEntity(node, env);
+
+case 'EntityInstantiation':
+  return await this.evalEntityNew(node, env);
+
+case 'SelfExpression':
+  return env.get('self', node, this.source);
+
+case 'InitMethod':
+  return node;
+case 'InheritsClause':
+  return await this.evalInherits(node, env);
     case 'ForStatement':
 case 'ForInStatement':
   return await this.evalFor(node, env);
@@ -855,6 +901,70 @@ case 'RaceClause':
     case 'NewExpression': {
   const callee = await this.evaluate(node.callee, env);
 
+  const args = [];
+  for (const a of node.arguments) {
+    args.push(await this.evaluate(a, env));
+  }
+ 
+  if (callee && callee.methods) {
+    const instance = {};
+ 
+     
+
+    const evaluator = this;
+
+    const entityEnv = new Environment(callee.env);
+    entityEnv.define('self', instance);
+ 
+    if (callee.parent) {
+      entityEnv.define(
+        'base',
+        this.createBaseProxy(instance, callee.parent)
+      );
+    }
+ 
+    if (callee.methods.init) {
+      const init = callee.methods.init;
+
+      for (let i = 0; i < init.params.length; i++) {
+        entityEnv.define(init.params[i], args[i]);
+      }
+
+      await evaluator.evaluate(init.body, entityEnv);
+    }
+ 
+    for (const key in callee.methods) {
+      if (key === 'init') continue;
+
+      instance[key] = async (...callArgs) => {
+        const methodEnv = new Environment(callee.env);
+
+        methodEnv.define('self', instance);
+
+        if (callee.parent) {
+          methodEnv.define(
+            'base',
+            evaluator.createBaseProxy(instance, callee.parent)
+          );
+        }
+
+        for (let i = 0; i < callee.methods[key].params.length; i++) {
+          methodEnv.define(
+            callee.methods[key].params[i],
+            callArgs[i]
+          );
+        }
+
+        return await evaluator.evaluate(
+          callee.methods[key].body,
+          methodEnv
+        );
+      };
+    }
+
+    return instance;
+  }
+ 
   if (typeof callee === 'object' && callee.body) {
     const evaluator = this;
 
@@ -864,7 +974,9 @@ case 'RaceClause':
 
       for (let i = 0; i < callee.params.length; i++) {
         const param = callee.params[i];
-        const paramName = typeof param === 'string' ? param : param.name;
+        const paramName =
+          typeof param === 'string' ? param : param.name;
+
         newEnv.define(paramName, args[i]);
       }
 
@@ -874,18 +986,17 @@ case 'RaceClause':
       })();
     };
 
-    const args = [];
-    for (const a of node.arguments) args.push(await this.evaluate(a, env));
     return await new Constructor(...args);
   }
-
-  // native JS constructor fallback
+ 
   if (typeof callee !== 'function') {
-    throw new RuntimeError('NewExpression callee is not a function', node, this.source);
+    throw new RuntimeError(
+      'NewExpression callee is not a function',
+      node,
+      this.source
+    );
   }
 
-  const args = [];
-  for (const a of node.arguments) args.push(await this.evaluate(a, env));
   return new callee(...args);
 }
 
@@ -894,7 +1005,20 @@ case 'RaceClause':
 
   }
 }
+async evalInherits(node, env) {
+  const parent = await this.evaluate(node.parent, env);
 
+  if (!parent || !parent.methods) {
+    throw new RuntimeError(
+      'Invalid parent entity',
+      node,
+      this.source,
+      env
+    );
+  }
+
+  return parent;
+}
 async evalProgram(node, env) {
   let result = null;
   for (const stmt of node.body) {
@@ -916,6 +1040,29 @@ async evalProgram(node, env) {
   }
   return result;
 }
+async evalEntity(node, env) {
+  const entity = {
+    name: node.name,
+    methods: {},
+    parent: null,
+    env
+  };
+
+  if (node.inherits) {
+    entity.parent = await this.evaluate(node.inherits, env);
+  }
+
+  for (const method of node.body) {
+    entity.methods[method.name] = {
+      params: method.params,
+      body: method.body,
+      env
+    };
+  }
+
+  env.define(node.name, entity);
+  return entity;
+}
 async evalSlice(node, env) {
   try {
     const arr = await this.evaluate(node.object, env);

package/src/lexer.js

@@ -28,7 +28,7 @@ class Lexer {
       'break', 'continue', 'func', 'return',
       'true', 'false', 'null',
       'ask', 'define', 'import', 'from', 'as',
-      'async', 'await', 'new', 'in', 'do', 'track', 'start', 'race', 'not', 'and', 'or'
+      'async', 'await', 'new', 'in', 'do', 'track', 'start', 'race', 'not', 'and', 'or', 'entity', 'self', 'inherits', 'init'
     ];
 }
 

package/src/parser.js

@@ -90,6 +90,7 @@ class Parser {
       case 'IF': return this.ifStatement();
       case 'WHILE': return this.whileStatement();
       case 'FOR': return this.forStatement();
+      case 'ENTITY': return this.entityDeclaration();
       case 'DO': return this.doTrackStatement();
       case 'START': return this.startStatement();
       case 'BREAK': return this.breakStatement();
@@ -157,7 +158,103 @@ varDeclaration() {
     column: t.column 
   };
 }
+entityDeclaration() {
+  const t = this.current;
+  this.eat('ENTITY');
+
+  if (this.current.type !== 'IDENTIFIER') {
+    throw new ParseError(
+      "Expected entity name",
+      this.current,
+      this.source,
+      "Use: entity Car { ... }"
+    );
+  }
+
+  const name = this.current.value;
+  this.eat('IDENTIFIER');
+
+  let parent = null;
+
+  if (this.current.type === 'INHERITS') {
+    this.eat('INHERITS');
+
+    if (this.current.type !== 'IDENTIFIER') {
+      throw new ParseError(
+        "Expected parent entity name",
+        this.current,
+        this.source
+      );
+    }
+
+    parent = {
+      type: 'Identifier',
+      name: this.current.value
+    };
+
+    this.eat('IDENTIFIER');
+  }
+
+  this.eat('LBRACE');
+
+  const body = [];
+
+  while (this.current.type !== 'RBRACE') {
+    body.push(this.methodDefinition());
+  }
+
+  this.eat('RBRACE');
+
+  return {
+    type: 'EntityDeclaration',
+    name,
+    parent,
+    body,
+    line: t.line,
+    column: t.column
+  };
+}
+methodDefinition() {
+  if (this.current.type !== 'IDENTIFIER' && this.current.type !== 'INIT') {
+    throw new ParseError(
+      "Expected method name",
+      this.current,
+      this.source
+    );
+  }
+
+  const isInit = this.current.type === 'INIT';
+  const name = isInit ? 'init' : this.current.value;
+
+  this.eat(this.current.type);
 
+  this.eat('LPAREN');
+
+  const params = [];
+
+  if (this.current.type !== 'RPAREN') {
+    params.push(this.current.value);
+    this.eat('IDENTIFIER');
+
+    while (this.current.type === 'COMMA') {
+      this.eat('COMMA');
+      params.push(this.current.value);
+      this.eat('IDENTIFIER');
+    }
+  }
+
+  this.eat('RPAREN');
+
+  const body = this.block();
+
+  return {
+    type: 'MethodDefinition',
+    name,
+    params,
+    body,
+    isInit
+  };
+}
 startStatement() {
   const t = this.current; 
   this.eat('START');
@@ -1440,7 +1537,15 @@ arrowFunction(params) {
 
 primary() {
   const t = this.current;
+if (t.type === 'BASE') {
+  this.eat('BASE');
+  return { type: 'Identifier', name: 'base', line: t.line, column: t.column };
+}
 
+if (t.type === 'SELF') {
+  this.eat('SELF');
+  return { type: 'Identifier', name: 'self', line: t.line, column: t.column };
+}
   if (t.type === 'NUMBER') {
     this.eat('NUMBER');
     return { type: 'Literal', value: t.value, line: t.line, column: t.column };