@tsomaiatech/moxite 1.0.0

package/README.md

@@ -0,0 +1,61 @@
+# Moxite Template Engine
+
+Moxite is an extremely fast, structural, and strictly evaluated template engine designed to be completely **indestructible**.
+
+Drawing inspiration from modern control flows like Angular 19, Moxite enforces a separation of logic and presentation through a pristine, character-by-character parsed Abstract Syntax Tree (AST). It completely eliminates the use of fuzzy Regular Expressions for parsing, meaning it is impossible to crash the engine with malformed overlapping templates, escaped quotes, or structural injection attacks.
+
+## Why Moxite?
+
+Modern template engines (like Jinja, EJS, and Handlebars) rely heavily on Regular Expressions and have slowly mutated into sprawling, poorly-implemented programming languages that execute inline logic, define JSON objects inline, and succumb to context leaks.
+
+Moxite takes a diametrically opposed approach:
+1. **Zero Regex Parsing**: Every token is mapped through a strict, atomic Lexical State machine and evaluated via a recursive descent Parser.
+2. **Zero Inline Objects**: The Expression Lexer intentionally forbids array closures `[1, 2]` or object structures `{k: v}` to prevent Turing-complete bloat and force developers to construct their data in the core application logic (e.g. TypeScript/Java), not in the view layer.
+3. **Implicit Safe Navigation**: The engine automatically protects against `null` or `undefined` property access without throwing exceptions, turning `{{ user.profile.name }}` into an implicit `{{ user?.profile?.name }}`.
+4. **Absolute Polyglot Isolation**: Moxite's domain syntax (`@` and `{{ }}`) will perfectly isolate itself even when overlapping natively with 10 other template engines or syntaxes in the exact same file (C# Razor, PHP, Bash, JSON-LD, etc.).
+
+## Syntax Outline
+
+### Interpolation & Implicit Chaining
+```mx
+Hello, {{ user.name }}!
+Implicit Safe Output: {{ user.deep.missing.path.shouldNotCrash }}
+```
+
+### Conditionals (`@if`)
+```mx
+@if (user.isAdmin)
+  Welcome Administrator.
+@else if (user.isGuest === "yes")
+  Welcome Guest.
+@else
+  Welcome User.
+@endif
+```
+
+### Loops (`@for`)
+```mx
+@for (item of items)
+  Item: {{ item.name }}
+@endfor
+```
+
+### Immutable Block Scoping (`@const`)
+```mx
+@const greeting = "Hello"
+@const role = user.role
+
+{{ greeting }}, you are a {{ role }}
+```
+
+### Pipes (`|`)
+Pipes allow you to pass values through pure formatting functions registered in the evaluation context.
+```mx
+{{ user.name | upper }}
+{{ total | currency: "USD" }}
+```
+
+## Structure
+
+- `src/`: Contains the pure TypeScript reference implementation of the strict Lexer, AST Parser, and Evaluator (`template-engine.ts`).
+- `idea-plugin/`: An independent Gradle project containing the IntelliJ IDEA plugin. Utilizing Grammar-Kit and JFlex, it tokenizes `.mx` files with the exact deterministic boundary rules as the TypeScript engine, providing native JetBrains syntax highlighting and completion.

package/idea-plugin/build.gradle.kts

@@ -0,0 +1,60 @@
+plugins {
+    id("java")
+    id("org.jetbrains.intellij") version "1.17.4"
+    id("org.jetbrains.grammarkit") version "2022.3.2.2"
+}
+
+group = project.properties["pluginGroup"] as String
+version = project.properties["pluginVersion"] as String
+
+repositories {
+    mavenCentral()
+}
+
+// Configure Gradle IntelliJ Plugin
+// Read more: https://plugins.jetbrains.com/docs/intellij/tools-gradle-intellij-plugin.html
+intellij {
+    pluginName.set(project.properties["pluginName"] as String)
+    version.set(project.properties["platformVersion"] as String)
+    type.set(project.properties["platformType"] as String)
+
+    // Plugin Dependencies. Uses `java` plugin.
+    plugins.set(listOf("com.intellij.java"))
+}
+
+tasks {
+    // Set the JVM compatibility versions
+    withType<JavaCompile> {
+        sourceCompatibility = project.properties["javaVersion"] as String
+        targetCompatibility = project.properties["javaVersion"] as String
+    }
+
+    patchPluginXml {
+        sinceBuild.set(project.properties["pluginSinceBuild"] as String)
+        untilBuild.set(project.properties["pluginUntilBuild"] as String)
+    }
+
+    signPlugin {
+        certificateChain.set(System.getenv("CERTIFICATE_CHAIN"))
+        privateKey.set(System.getenv("PRIVATE_KEY"))
+        password.set(System.getenv("PRIVATE_KEY_PASSWORD"))
+    }
+
+    publishPlugin {
+        token.set(System.getenv("PUBLISH_TOKEN"))
+    }
+}
+
+sourceSets {
+    main {
+        java.srcDirs("src/main/java", "src/main/gen")
+    }
+}
+
+// Ensure the generate sources directories exist
+val generateLexer = tasks.named("generateLexer")
+val generateParser = tasks.named("generateParser")
+
+tasks.withType<JavaCompile> {
+    dependsOn(generateLexer, generateParser)
+}

package/idea-plugin/gradle.properties

@@ -0,0 +1,14 @@
+pluginGroup = "tech.tsomaia.moxite"
+pluginName = "Moxite Template Support"
+pluginVersion = "1.0.0"
+
+# Supported IDE versions
+pluginSinceBuild = "231"
+pluginUntilBuild = "241.*"
+
+# IntelliJ Platform Properties
+platformType = "IC"
+platformVersion = "2023.1.5"
+
+# Java language level
+javaVersion = "17"

package/idea-plugin/settings.gradle.kts

@@ -0,0 +1 @@
+rootProject.name = "moxite-idea"

package/idea-plugin/src/main/flex/Moxite.flex

@@ -0,0 +1,101 @@
+package tech.tsomaia.moxite.idea.lexer;
+
+import com.intellij.lexer.FlexLexer;
+import com.intellij.psi.tree.IElementType;
+import tech.tsomaia.moxite.idea.psi.MoxiteTypes;
+import com.intellij.psi.TokenType;
+
+%%
+
+%class _MoxiteLexer
+%implements FlexLexer
+%unicode
+%function advance
+%type IElementType
+%eof{  return;
+%eof}
+
+// Token definitions
+WHITE_SPACE=[\ \n\r\t]+
+IDENTIFIER=[a-zA-Z_$][a-zA-Z0-9_$]*
+NUMBER=[0-9]+(\.[0-9]+)?
+STRING=\"[^\"]*\"|'[^']*'
+
+%state IN_TAG_ARGS
+%state IN_INTERPOLATION
+
+%%
+
+// When in standard TEXT mode, we look for { { or @
+<YYINITIAL> {
+  "{{" { yybegin(IN_INTERPOLATION); return MoxiteTypes.INTERP_START; }
+
+  "@if" / [^a-zA-Z0-9_$] { yybegin(IN_TAG_ARGS); return MoxiteTypes.TAG_IF; }
+  "@else if" / [^a-zA-Z0-9_$] { yybegin(IN_TAG_ARGS); return MoxiteTypes.TAG_ELSE_IF; }
+  "@else" / [^a-zA-Z0-9_$] { return MoxiteTypes.TAG_ELSE; }
+  "@endif" / [^a-zA-Z0-9_$] { return MoxiteTypes.TAG_ENDIF; }
+  
+  "@for" / [^a-zA-Z0-9_$] { yybegin(IN_TAG_ARGS); return MoxiteTypes.TAG_FOR; }
+  "@endfor" / [^a-zA-Z0-9_$] { return MoxiteTypes.TAG_ENDFOR; }
+  
+  "@const" / [^a-zA-Z0-9_$] { yybegin(IN_TAG_ARGS); return MoxiteTypes.TAG_CONST; }
+
+  // Anything else is just text
+  [^\{@]+ { return MoxiteTypes.TEXT; }
+  "{"     { return MoxiteTypes.TEXT; }
+  "@"     { return MoxiteTypes.TEXT; }
+}
+
+// When inside parentheses of a loop or condition
+<IN_TAG_ARGS> {
+  {WHITE_SPACE} { return TokenType.WHITE_SPACE; }
+  ")" { yybegin(YYINITIAL); return MoxiteTypes.RPAREN; }
+  "(" { return MoxiteTypes.LPAREN; }
+  "[" { return MoxiteTypes.LBRACKET; }
+  "]" { return MoxiteTypes.RBRACKET; }
+  "." { return MoxiteTypes.DOT; }
+  "," { return MoxiteTypes.COMMA; }
+  ":" { return MoxiteTypes.COLON; }
+  "|" { return MoxiteTypes.PIPE; }
+  "=" { return MoxiteTypes.EQ; }
+  
+  "==="|!=="|=="|"!=" { return MoxiteTypes.EQUALITY_OP; }
+  "<="|">="|"<"|">" { return MoxiteTypes.COMPARE_OP; }
+  
+  "of" { return MoxiteTypes.IDENTIFIER; } // Handled structurally in BNF
+  {IDENTIFIER} { return MoxiteTypes.IDENTIFIER; }
+  {NUMBER} { return MoxiteTypes.NUMBER; }
+  {STRING} { return MoxiteTypes.STRING; }
+
+  // Fallback for weird characters that are technically invalid but shouldn't crash the lexer
+  . { return TokenType.BAD_CHARACTER; }
+  
+  // Handle unexpected newline to exit state if unclosed
+  \n { yybegin(YYINITIAL); return TokenType.WHITE_SPACE; }
+}
+
+<IN_INTERPOLATION> {
+  {WHITE_SPACE} { return TokenType.WHITE_SPACE; }
+  "}}" { yybegin(YYINITIAL); return MoxiteTypes.INTERP_END; }
+  
+  "(" { return MoxiteTypes.LPAREN; }
+  ")" { return MoxiteTypes.RPAREN; }
+  "[" { return MoxiteTypes.LBRACKET; }
+  "]" { return MoxiteTypes.RBRACKET; }
+  "." { return MoxiteTypes.DOT; }
+  "," { return MoxiteTypes.COMMA; }
+  ":" { return MoxiteTypes.COLON; }
+  "|" { return MoxiteTypes.PIPE; }
+  "=" { return MoxiteTypes.EQ; }
+  
+  "==="|!=="|=="|"!=" { return MoxiteTypes.EQUALITY_OP; }
+  "<="|">="|"<"|">" { return MoxiteTypes.COMPARE_OP; }
+  
+  {IDENTIFIER} { return MoxiteTypes.IDENTIFIER; }
+  {NUMBER} { return MoxiteTypes.NUMBER; }
+  {STRING} { return MoxiteTypes.STRING; }
+
+  . { return TokenType.BAD_CHARACTER; }
+}
+
+[^] { return TokenType.BAD_CHARACTER; }

package/idea-plugin/src/main/grammar/Moxite.bnf

@@ -0,0 +1,79 @@
+{
+  parserClass="tech.tsomaia.moxite.idea.parser.MoxiteParser"
+  parserUtilClass="tech.tsomaia.moxite.idea.parser.MoxiteParserUtil"
+
+  extends="com.intellij.extapi.psi.ASTWrapperPsiElement"
+
+  psiClassPrefix="Moxite"
+  psiImplClassSuffix="Impl"
+  psiPackage="tech.tsomaia.moxite.idea.psi"
+  psiImplPackage="tech.tsomaia.moxite.idea.psi.impl"
+
+  elementTypeHolderClass="tech.tsomaia.moxite.idea.psi.MoxiteTypes"
+  elementTypeClass="tech.tsomaia.moxite.idea.psi.MoxiteElementType"
+  tokenTypeClass="tech.tsomaia.moxite.idea.psi.MoxiteTokenType"
+
+  tokens = [
+    // These will be returned by the JFlex Lexer
+    TEXT="TEXT"
+    INTERP_START="{{"
+    INTERP_END="}}"
+    
+    TAG_IF="@if"
+    TAG_ELSE_IF="@else if"
+    TAG_ELSE="@else"
+    TAG_ENDIF="@endif"
+    
+    TAG_FOR="@for"
+    TAG_ENDFOR="@endfor"
+    
+    TAG_CONST="@const"
+    
+    LPAREN="("
+    RPAREN=")"
+    LBRACKET="["
+    RBRACKET="]"
+    DOT="."
+    COMMA=","
+    COLON=":"
+    PIPE="|"
+    EQ="="
+    
+    EQUALITY_OP="regexp:(===|!==|==|!=)"
+    COMPARE_OP="regexp:(<|>|<=|>=)"
+    
+    IDENTIFIER="regexp:[a-zA-Z_$][a-zA-Z0-9_$]*"
+    NUMBER="regexp:[0-9]+(\.[0-9]+)?"
+    STRING="regexp:\"[^\"]*\"|'[^']*'"
+  ]
+}
+
+moxiteFile ::= item_*
+
+private item_ ::= ( textBlock | interpolation | ifBlock | forBlock | constBlock )
+
+textBlock ::= TEXT
+
+interpolation ::= INTERP_START expression INTERP_END
+
+ifBlock ::= ifStatement elseIfStatement* elseStatement? TAG_ENDIF
+ifStatement ::= TAG_IF LPAREN expression RPAREN item_*
+elseIfStatement ::= TAG_ELSE_IF LPAREN expression RPAREN item_*
+elseStatement ::= TAG_ELSE item_*
+
+forBlock ::= TAG_FOR LPAREN IDENTIFIER IDENTIFIER /* 'of' */ expression RPAREN item_* TAG_ENDFOR
+
+constBlock ::= TAG_CONST IDENTIFIER EQ expression
+
+// Expression rules simplified for highlighting
+expression ::= pipeExpression
+
+pipeExpression ::= equalityExpression (PIPE IDENTIFIER (COLON equalityExpression (COMMA equalityExpression)* )? )*
+
+equalityExpression ::= compareExpression (EQUALITY_OP compareExpression)*
+
+compareExpression ::= primaryExpression (COMPARE_OP primaryExpression)*
+
+primaryExpression ::= baseExpression ( DOT IDENTIFIER | LBRACKET pipeExpression RBRACKET )*
+
+baseExpression ::= STRING | NUMBER | IDENTIFIER | LPAREN pipeExpression RPAREN

package/idea-plugin/src/main/java/tech/tsomaia/moxite/idea/MoxiteFileType.java

@@ -0,0 +1,39 @@
+package tech.tsomaia.moxite.idea;
+
+import com.intellij.openapi.fileTypes.LanguageFileType;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import javax.swing.*;
+
+public class MoxiteFileType extends LanguageFileType {
+    public static final MoxiteFileType INSTANCE = new MoxiteFileType();
+
+    private MoxiteFileType() {
+        super(MoxiteLanguage.INSTANCE);
+    }
+
+    @NotNull
+    @Override
+    public String getName() {
+        return "Moxite Template";
+    }
+
+    @NotNull
+    @Override
+    public String getDescription() {
+        return "Moxite template logic format";
+    }
+
+    @NotNull
+    @Override
+    public String getDefaultExtension() {
+        return "mx";
+    }
+
+    @Nullable
+    @Override
+    public Icon getIcon() {
+        return MoxiteIcons.FILE;
+    }
+}

package/idea-plugin/src/main/java/tech/tsomaia/moxite/idea/MoxiteIcons.java

@@ -0,0 +1,9 @@
+package tech.tsomaia.moxite.idea;
+
+import com.intellij.openapi.util.IconLoader;
+
+import javax.swing.*;
+
+public class MoxiteIcons {
+    public static final Icon FILE = IconLoader.getIcon("/icons/moxite.png", MoxiteIcons.class);
+}

package/idea-plugin/src/main/java/tech/tsomaia/moxite/idea/MoxiteLanguage.java

@@ -0,0 +1,11 @@
+package tech.tsomaia.moxite.idea;
+
+import com.intellij.lang.Language;
+
+public class MoxiteLanguage extends Language {
+    public static final MoxiteLanguage INSTANCE = new MoxiteLanguage();
+
+    private MoxiteLanguage() {
+        super("Moxite");
+    }
+}

package/idea-plugin/src/main/java/tech/tsomaia/moxite/idea/MoxiteParserDefinition.java

@@ -0,0 +1,77 @@
+package tech.tsomaia.moxite.idea;
+
+import com.intellij.lang.ASTNode;
+import com.intellij.lang.ParserDefinition;
+import com.intellij.lang.PsiParser;
+import com.intellij.lexer.Lexer;
+import com.intellij.openapi.project.Project;
+import com.intellij.psi.FileViewProvider;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiFile;
+import com.intellij.psi.TokenType;
+import com.intellij.psi.tree.IFileElementType;
+import com.intellij.psi.tree.TokenSet;
+import org.jetbrains.annotations.NotNull;
+import tech.tsomaia.moxite.idea.lexer.MoxiteLexerAdapter;
+import tech.tsomaia.moxite.idea.parser.MoxiteParser;
+import tech.tsomaia.moxite.idea.psi.MoxiteFile;
+import tech.tsomaia.moxite.idea.psi.MoxiteTypes;
+
+public class MoxiteParserDefinition implements ParserDefinition {
+
+    public static final IFileElementType FILE = new IFileElementType(MoxiteLanguage.INSTANCE);
+
+    @NotNull
+    @Override
+    public Lexer createLexer(Project project) {
+        return new MoxiteLexerAdapter();
+    }
+
+    @NotNull
+    @Override
+    public TokenSet getWhitespaceTokens() {
+        return TokenSet.create(TokenType.WHITE_SPACE);
+    }
+
+    @NotNull
+    @Override
+    public TokenSet getCommentTokens() {
+        return TokenSet.EMPTY; // no comments in this language yet
+    }
+
+    @NotNull
+    @Override
+    public TokenSet getStringLiteralElements() {
+        return TokenSet.create(MoxiteTypes.STRING);
+    }
+
+    @NotNull
+    @Override
+    public PsiParser createParser(Project project) {
+        return new MoxiteParser();
+    }
+
+    @NotNull
+    @Override
+    public IFileElementType getFileNodeType() {
+        return FILE;
+    }
+
+    @NotNull
+    @Override
+    public PsiFile createFile(@NotNull FileViewProvider viewProvider) {
+        return new MoxiteFile(viewProvider);
+    }
+
+    @NotNull
+    @Override
+    public SpaceRequirements spaceExistenceTypeBetweenTokens(ASTNode left, ASTNode right) {
+        return SpaceRequirements.MAY;
+    }
+
+    @NotNull
+    @Override
+    public PsiElement createElement(ASTNode node) {
+        return tech.tsomaia.moxite.idea.psi.MoxiteTypes.Factory.createElement(node);
+    }
+}

package/idea-plugin/src/main/java/tech/tsomaia/moxite/idea/MoxiteSyntaxHighlighter.java

@@ -0,0 +1,82 @@
+package tech.tsomaia.moxite.idea;
+
+import com.intellij.lexer.Lexer;
+import com.intellij.openapi.editor.DefaultLanguageHighlighterColors;
+import com.intellij.openapi.editor.colors.TextAttributesKey;
+import com.intellij.openapi.fileTypes.SyntaxHighlighterBase;
+import com.intellij.psi.tree.IElementType;
+import org.jetbrains.annotations.NotNull;
+import tech.tsomaia.moxite.idea.lexer.MoxiteLexerAdapter;
+import tech.tsomaia.moxite.idea.psi.MoxiteTypes;
+
+import static com.intellij.openapi.editor.colors.TextAttributesKey.createTextAttributesKey;
+
+public class MoxiteSyntaxHighlighter extends SyntaxHighlighterBase {
+
+    public static final TextAttributesKey KEYWORD =
+            createTextAttributesKey("RELAY_KEYWORD", DefaultLanguageHighlighterColors.KEYWORD);
+    public static final TextAttributesKey STRING =
+            createTextAttributesKey("RELAY_STRING", DefaultLanguageHighlighterColors.STRING);
+    public static final TextAttributesKey NUMBER =
+            createTextAttributesKey("RELAY_NUMBER", DefaultLanguageHighlighterColors.NUMBER);
+    public static final TextAttributesKey IDENTIFIER =
+            createTextAttributesKey("RELAY_IDENTIFIER", DefaultLanguageHighlighterColors.IDENTIFIER);
+    public static final TextAttributesKey BRACES =
+            createTextAttributesKey("RELAY_BRACES", DefaultLanguageHighlighterColors.BRACES);
+    public static final TextAttributesKey OPERATOR =
+            createTextAttributesKey("RELAY_OPERATOR", DefaultLanguageHighlighterColors.OPERATION_SIGN);
+
+    private static final TextAttributesKey[] KEYWORD_KEYS = new TextAttributesKey[]{KEYWORD};
+    private static final TextAttributesKey[] STRING_KEYS = new TextAttributesKey[]{STRING};
+    private static final TextAttributesKey[] NUMBER_KEYS = new TextAttributesKey[]{NUMBER};
+    private static final TextAttributesKey[] IDENTIFIER_KEYS = new TextAttributesKey[]{IDENTIFIER};
+    private static final TextAttributesKey[] BRACES_KEYS = new TextAttributesKey[]{BRACES};
+    private static final TextAttributesKey[] OPERATOR_KEYS = new TextAttributesKey[]{OPERATOR};
+    private static final TextAttributesKey[] EMPTY_KEYS = new TextAttributesKey[0];
+
+    @NotNull
+    @Override
+    public Lexer getHighlightingLexer() {
+        return new MoxiteLexerAdapter();
+    }
+
+    @NotNull
+    @Override
+    public TextAttributesKey[] getTokenHighlights(IElementType tokenType) {
+        if (tokenType.equals(MoxiteTypes.TAG_IF) ||
+            tokenType.equals(MoxiteTypes.TAG_ELSE_IF) ||
+            tokenType.equals(MoxiteTypes.TAG_ELSE) ||
+            tokenType.equals(MoxiteTypes.TAG_ENDIF) ||
+            tokenType.equals(MoxiteTypes.TAG_FOR) ||
+            tokenType.equals(MoxiteTypes.TAG_ENDFOR) ||
+            tokenType.equals(MoxiteTypes.TAG_CONST)) {
+            return KEYWORD_KEYS;
+        }
+        
+        if (tokenType.equals(MoxiteTypes.INTERP_START) ||
+            tokenType.equals(MoxiteTypes.INTERP_END)) {
+            return BRACES_KEYS;
+        }
+
+        if (tokenType.equals(MoxiteTypes.STRING)) {
+            return STRING_KEYS;
+        }
+
+        if (tokenType.equals(MoxiteTypes.NUMBER)) {
+            return NUMBER_KEYS;
+        }
+
+        if (tokenType.equals(MoxiteTypes.IDENTIFIER)) {
+            return IDENTIFIER_KEYS;
+        }
+
+        if (tokenType.equals(MoxiteTypes.EQUALITY_OP) ||
+            tokenType.equals(MoxiteTypes.COMPARE_OP) ||
+            tokenType.equals(MoxiteTypes.EQ) ||
+            tokenType.equals(MoxiteTypes.PIPE)) {
+            return OPERATOR_KEYS;
+        }
+
+        return EMPTY_KEYS;
+    }
+}

package/idea-plugin/src/main/java/tech/tsomaia/moxite/idea/MoxiteSyntaxHighlighterFactory.java

@@ -0,0 +1,16 @@
+package tech.tsomaia.moxite.idea;
+
+import com.intellij.openapi.fileTypes.SyntaxHighlighter;
+import com.intellij.openapi.fileTypes.SyntaxHighlighterFactory;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.vfs.VirtualFile;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+public class MoxiteSyntaxHighlighterFactory extends SyntaxHighlighterFactory {
+    @NotNull
+    @Override
+    public SyntaxHighlighter getSyntaxHighlighter(@Nullable Project project, @Nullable VirtualFile virtualFile) {
+        return new MoxiteSyntaxHighlighter();
+    }
+}

package/idea-plugin/src/main/java/tech/tsomaia/moxite/idea/lexer/MoxiteLexerAdapter.java

@@ -0,0 +1,9 @@
+package tech.tsomaia.moxite.idea.lexer;
+
+import com.intellij.lexer.FlexAdapter;
+
+public class MoxiteLexerAdapter extends FlexAdapter {
+    public MoxiteLexerAdapter() {
+        super(new _MoxiteLexer(null));
+    }
+}

package/idea-plugin/src/main/java/tech/tsomaia/moxite/idea/parser/MoxiteParserUtil.java

@@ -0,0 +1,6 @@
+package tech.tsomaia.moxite.idea.parser;
+
+import com.intellij.lang.parser.GeneratedParserUtilBase;
+
+public class MoxiteParserUtil extends GeneratedParserUtilBase {
+}

package/idea-plugin/src/main/java/tech/tsomaia/moxite/idea/psi/MoxiteElementType.java

@@ -0,0 +1,12 @@
+package tech.tsomaia.moxite.idea.psi;
+
+import com.intellij.psi.tree.IElementType;
+import org.jetbrains.annotations.NonNls;
+import org.jetbrains.annotations.NotNull;
+import tech.tsomaia.moxite.idea.MoxiteLanguage;
+
+public class MoxiteElementType extends IElementType {
+    public MoxiteElementType(@NotNull @NonNls String debugName) {
+        super(debugName, MoxiteLanguage.INSTANCE);
+    }
+}

package/idea-plugin/src/main/java/tech/tsomaia/moxite/idea/psi/MoxiteFile.java

@@ -0,0 +1,25 @@
+package tech.tsomaia.moxite.idea.psi;
+
+import com.intellij.extapi.psi.PsiFileBase;
+import com.intellij.openapi.fileTypes.FileType;
+import com.intellij.psi.FileViewProvider;
+import org.jetbrains.annotations.NotNull;
+import tech.tsomaia.moxite.idea.MoxiteFileType;
+import tech.tsomaia.moxite.idea.MoxiteLanguage;
+
+public class MoxiteFile extends PsiFileBase {
+    public MoxiteFile(@NotNull FileViewProvider viewProvider) {
+        super(viewProvider, MoxiteLanguage.INSTANCE);
+    }
+
+    @NotNull
+    @Override
+    public FileType getFileType() {
+        return MoxiteFileType.INSTANCE;
+    }
+
+    @Override
+    public String toString() {
+        return "Moxite File";
+    }
+}

package/idea-plugin/src/main/java/tech/tsomaia/moxite/idea/psi/MoxiteTokenType.java

@@ -0,0 +1,17 @@
+package tech.tsomaia.moxite.idea.psi;
+
+import com.intellij.psi.tree.IElementType;
+import org.jetbrains.annotations.NonNls;
+import org.jetbrains.annotations.NotNull;
+import tech.tsomaia.moxite.idea.MoxiteLanguage;
+
+public class MoxiteTokenType extends IElementType {
+    public MoxiteTokenType(@NotNull @NonNls String debugName) {
+        super(debugName, MoxiteLanguage.INSTANCE);
+    }
+
+    @Override
+    public String toString() {
+        return "MoxiteTokenType." + super.toString();
+    }
+}

package/idea-plugin/src/main/resources/META-INF/plugin.xml

@@ -0,0 +1,32 @@
+<idea-plugin>
+    <id>tech.tsomaia.moxite.idea</id>
+    <name>Moxite Template Support</name>
+    <vendor email="admin@tsomaia.tech" url="https://tsomaia.tech">Tornike Tsomaia</vendor>
+
+    <description><![CDATA[
+      Provides language support for the Moxite Template Engine.
+      Includes full syntax highlighting, lexing, and semantic parsing for .mx files.
+    ]]></description>
+
+    <!-- please see https://plugins.jetbrains.com/docs/intellij/plugin-compatibility.html
+         on how to target different products -->
+    <depends>com.intellij.modules.platform</depends>
+
+    <extensions defaultExtensionNs="com.intellij">
+        <fileType
+            name="Moxite Template"
+            implementationClass="tech.tsomaia.moxite.idea.MoxiteFileType"
+            fieldName="INSTANCE"
+            language="Moxite"
+            extensions="mx"
+        />
+        <lang.parserDefinition
+            language="Moxite"
+            implementationClass="tech.tsomaia.moxite.idea.MoxiteParserDefinition"
+        />
+        <lang.syntaxHighlighterFactory
+            language="Moxite"
+            implementationClass="tech.tsomaia.moxite.idea.MoxiteSyntaxHighlighterFactory"
+        />
+    </extensions>
+</idea-plugin>