littlewing 0.1.0 → 0.2.0

package/dist/index.d.ts

@@ -107,6 +107,17 @@ interface Assignment {
 	value: ASTNode;
 }
 /**
+* Type guard functions for discriminated union narrowing
+*/
+declare function isNumberLiteral(node: ASTNode): node is NumberLiteral;
+declare function isStringLiteral(node: ASTNode): node is StringLiteral;
+declare function isIdentifier(node: ASTNode): node is Identifier;
+declare function isBinaryOp(node: ASTNode): node is BinaryOp;
+declare function isUnaryOp(node: ASTNode): node is UnaryOp;
+declare function isFunctionCall(node: ASTNode): node is FunctionCall;
+declare function isAssignment(node: ASTNode): node is Assignment;
+declare function isProgram(node: ASTNode): node is Program;
+/**
 * Builder functions for creating AST nodes manually
 */
 /**
@@ -357,4 +368,4 @@ declare class Parser {
 * Parse source code string into AST
 */
 declare function parseSource(source: string): ASTNode;
-export { parseSource, execute, defaultContext, exports_ast as ast, TokenType, Token, RuntimeValue, Parser, Lexer, Executor, ExecutionContext, ASTNode };
+export { parseSource, isUnaryOp, isStringLiteral, isProgram, isNumberLiteral, isIdentifier, isFunctionCall, isBinaryOp, isAssignment, execute, defaultContext, exports_ast as ast, TokenType, Token, RuntimeValue, Parser, Lexer, Executor, ExecutionContext, ASTNode };

package/dist/index.js

@@ -132,6 +132,30 @@ var TokenType;
   TokenType2["COMMA"] = "COMMA";
   TokenType2["EOF"] = "EOF";
 })(TokenType ||= {});
+function isNumberLiteral(node) {
+  return node.type === "NumberLiteral";
+}
+function isStringLiteral(node) {
+  return node.type === "StringLiteral";
+}
+function isIdentifier(node) {
+  return node.type === "Identifier";
+}
+function isBinaryOp(node) {
+  return node.type === "BinaryOp";
+}
+function isUnaryOp(node) {
+  return node.type === "UnaryOp";
+}
+function isFunctionCall(node) {
+  return node.type === "FunctionCall";
+}
+function isAssignment(node) {
+  return node.type === "Assignment";
+}
+function isProgram(node) {
+  return node.type === "Program";
+}
 
 // src/lexer.ts
 class Lexer {
@@ -496,26 +520,23 @@ class Executor {
     this.variables = new Map(Object.entries(context.variables || {}));
   }
   execute(node) {
-    switch (node.type) {
-      case "Program":
-        return this.executeProgram(node);
-      case "NumberLiteral":
-        return this.executeNumberLiteral(node);
-      case "StringLiteral":
-        return this.executeStringLiteral(node);
-      case "Identifier":
-        return this.executeIdentifier(node);
-      case "BinaryOp":
-        return this.executeBinaryOp(node);
-      case "UnaryOp":
-        return this.executeUnaryOp(node);
-      case "FunctionCall":
-        return this.executeFunctionCall(node);
-      case "Assignment":
-        return this.executeAssignment(node);
-      default:
-        throw new Error(`Unknown node type`);
-    }
+    if (isProgram(node))
+      return this.executeProgram(node);
+    if (isNumberLiteral(node))
+      return this.executeNumberLiteral(node);
+    if (isStringLiteral(node))
+      return this.executeStringLiteral(node);
+    if (isIdentifier(node))
+      return this.executeIdentifier(node);
+    if (isBinaryOp(node))
+      return this.executeBinaryOp(node);
+    if (isUnaryOp(node))
+      return this.executeUnaryOp(node);
+    if (isFunctionCall(node))
+      return this.executeFunctionCall(node);
+    if (isAssignment(node))
+      return this.executeAssignment(node);
+    throw new Error(`Unknown node type`);
   }
   executeProgram(node) {
     let result;
@@ -663,6 +684,14 @@ function execute(source, context) {
 }
 export {
   parseSource,
+  isUnaryOp,
+  isStringLiteral,
+  isProgram,
+  isNumberLiteral,
+  isIdentifier,
+  isFunctionCall,
+  isBinaryOp,
+  isAssignment,
   execute,
   defaultContext,
   exports_ast as ast,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "littlewing",
-	"version": "0.1.0",
+	"version": "0.2.0",
 	"description": "A minimal, high-performance arithmetic expression language with lexer, parser, and executor. Optimized for browsers with zero dependencies and type-safe execution.",
 	"keywords": [
 		"arithmetic",