diff --git a/CHANGELOG.md b/CHANGELOG.md
index 71dff4e..dc34cea 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,18 @@
 
 ## [Unreleased]
 
+### Changed
+
+- Reworked the lexer and parser to be more generic, which should make it a bit easier to support future changes to the
+  Structurizr DSL
+- Syntax highlighting is now mostly annotator based instead of lexer based
+
+### Added
+
+- Matching curly braces are now highlighted in the editor
+- Code can now be commented with the "Comment with line/block comment" commands
+- Code is automatically indented correctly while editing
+
 ## [0.2.1] - 2023-03-31
 
 ### Changed
diff --git a/README.md b/README.md
index 1d60c1c..190af29 100644
--- a/README.md
+++ b/README.md
@@ -34,6 +34,8 @@ using [Simon Brown](https://twitter.com/simonbrown)'s [C4 model](https://c4model
 * Basic syntax highlighting for the Structurizr DSL language. Files with the `.dsl` extension are considered to be
   Structurizr DSL files.
 * Automatically indent and normalize spacing with IntelliJ's "Reformat Code" command.
+* Automatically indent new code while typing
+* Comment code using the "Comment with line/block comment" commands
 * More to come! Please refer to the [TODO section](https://github.com/dirkgroot/structurizr-dsl-intellij-plugin#todo) of
   the README for a list of features that will likely be added.
 
@@ -42,9 +44,8 @@ using [Simon Brown](https://twitter.com/simonbrown)'s [C4 model](https://c4model
 - For now, arguments of statements are all treated as (un)quoted strings, so "true", "false", integers, (un)quoted text
   will all get the same syntax highlighting.
 - The following blocks are treated as property blocks, containing (un)quoted string pairs:
-  - branding
-  - terminology
-  - configuration
+  - perspectives
+  - properties
   - users
 - All arguments of view declarations are highlighted as (un)quoted strings. Correct highlighting of these arguments will
   most likely be implemented using
@@ -68,11 +69,11 @@ Search for "Structurizr" in the marketplace, and install the plugin. Please refe
 
 ### Features
 
-- ☑️ syntax highlighting
+- ✅ syntax highlighting
   - ✅ token based
-  - 🔳 annotator based
+  - ✅ annotator based
 - ✅ reformat code
-- 🔳 auto indentation
+- ✅ auto indentation
 - 🔳 go to definition
 - 🔳 rename refactoring for identifiers
 - 🔳 code validation
diff --git a/build.gradle.kts b/build.gradle.kts
index 7165c0a..855535a 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -49,6 +49,7 @@ koverReport {
 sourceSets["main"].java.srcDirs("src/main/gen")
 
 dependencies {
+    testImplementation(kotlin("test"))
     testImplementation("io.kotest:kotest-runner-junit5:5.6.2")
     testImplementation("io.kotest:kotest-assertions-core:5.6.2")
     testImplementation("com.willowtreeapps.assertk:assertk-jvm:0.25")
diff --git a/gradle.properties b/gradle.properties
index 3049315..e34df1d 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -4,7 +4,7 @@ pluginGroup = nl.dirkgroot.structurizr-dsl-plugin
 pluginName = Structurizr DSL Language Support
 pluginRepositoryUrl = https://github.com/dirkgroot/structurizr-dsl-intellij-plugin
 # SemVer format -> https://semver.org
-pluginVersion = 0.2.2
+pluginVersion = 0.3.1
 
 # Supported build number ranges and IntelliJ Platform versions -> https://plugins.jetbrains.com/docs/intellij/build-number-ranges.html
 pluginSinceBuild = 223
diff --git a/src/main/gen/nl/dirkgroot/structurizr/dsl/StructurizrDSLParser.java b/src/main/gen/nl/dirkgroot/structurizr/dsl/StructurizrDSLParser.java
index 5363ffd..2c34e76 100644
--- a/src/main/gen/nl/dirkgroot/structurizr/dsl/StructurizrDSLParser.java
+++ b/src/main/gen/nl/dirkgroot/structurizr/dsl/StructurizrDSLParser.java
@@ -21,7 +21,7 @@ public ASTNode parse(IElementType t, PsiBuilder b) {
 
   public void parseLight(IElementType t, PsiBuilder b) {
     boolean r;
-    b = adapt_builder_(t, b, this, null);
+    b = adapt_builder_(t, b, this, EXTENDS_SETS_);
     Marker m = enter_section_(b, 0, _COLLAPSE_, null);
     r = parse_root_(t, b);
     exit_section_(b, 0, m, t, r, true, TRUE_CONDITION);
@@ -35,311 +35,319 @@ static boolean parse_root_(IElementType t, PsiBuilder b, int l) {
     return structurizrDSLFile(b, l + 1);
   }
 
+  public static final TokenSet[] EXTENDS_SETS_ = new TokenSet[] {
+    create_token_set_(ANIMATION_STATEMENT, BLOCK_COMMENT_STATEMENT, BLOCK_STATEMENT, EXPLICIT_RELATIONSHIP_STATEMENT,
+      IDENTIFIER_ASSIGNMENT_STATEMENT, IDENTIFIER_REFERENCES_STATEMENT, IMPLICIT_RELATIONSHIP_STATEMENT, LINE_COMMENT_STATEMENT,
+      PROPERTIES_STATEMENT, SCRIPT_STATEMENT, SINGLE_LINE_STATEMENT),
+  };
+
   /* ********************************************************** */
-  // text
-  public static boolean argument(PsiBuilder b, int l) {
-    if (!recursion_guard_(b, l, "argument")) return false;
-    if (!nextTokenIs(b, "<argument>", QUOTED_TEXT, UNQUOTED_TEXT)) return false;
+  // 'animation'
+  public static boolean animationKeyword(PsiBuilder b, int l) {
+    if (!recursion_guard_(b, l, "animationKeyword")) return false;
     boolean r;
-    Marker m = enter_section_(b, l, _NONE_, ARGUMENT, "<argument>");
-    r = text(b, l + 1);
+    Marker m = enter_section_(b, l, _NONE_, ANIMATION_KEYWORD, "<animation keyword>");
+    r = consumeToken(b, "animation");
     exit_section_(b, l, m, r, false, null);
     return r;
   }
 
   /* ********************************************************** */
-  // identifierAssignment? keywordWithArguments '{' CRLF statement* '}' lf_eof
-  public static boolean blockStatement(PsiBuilder b, int l) {
-    if (!recursion_guard_(b, l, "blockStatement")) return false;
+  // animationKeyword '{' CRLF (identifierReferencesStatement | lineCommentStatement | blockCommentStatement)* '}' lf_eof
+  public static boolean animationStatement(PsiBuilder b, int l) {
+    if (!recursion_guard_(b, l, "animationStatement")) return false;
     boolean r;
-    Marker m = enter_section_(b, l, _NONE_, BLOCK_STATEMENT, "<block statement>");
-    r = blockStatement_0(b, l + 1);
-    r = r && keywordWithArguments(b, l + 1);
+    Marker m = enter_section_(b, l, _NONE_, ANIMATION_STATEMENT, "<animation statement>");
+    r = animationKeyword(b, l + 1);
     r = r && consumeTokens(b, 0, BRACE1, CRLF);
-    r = r && blockStatement_4(b, l + 1);
+    r = r && animationStatement_3(b, l + 1);
     r = r && consumeToken(b, BRACE2);
     r = r && lf_eof(b, l + 1);
     exit_section_(b, l, m, r, false, null);
     return r;
   }
 
-  // identifierAssignment?
-  private static boolean blockStatement_0(PsiBuilder b, int l) {
-    if (!recursion_guard_(b, l, "blockStatement_0")) return false;
-    identifierAssignment(b, l + 1);
-    return true;
-  }
-
-  // statement*
-  private static boolean blockStatement_4(PsiBuilder b, int l) {
-    if (!recursion_guard_(b, l, "blockStatement_4")) return false;
+  // (identifierReferencesStatement | lineCommentStatement | blockCommentStatement)*
+  private static boolean animationStatement_3(PsiBuilder b, int l) {
+    if (!recursion_guard_(b, l, "animationStatement_3")) return false;
     while (true) {
       int c = current_position_(b);
-      if (!statement(b, l + 1)) break;
-      if (!empty_element_parsed_guard_(b, "blockStatement_4", c)) break;
+      if (!animationStatement_3_0(b, l + 1)) break;
+      if (!empty_element_parsed_guard_(b, "animationStatement_3", c)) break;
     }
     return true;
   }
 
-  /* ********************************************************** */
-  // singleLineStatement | blockStatement | propertyBlockStatement | CRLF
-  static boolean elementDefinition(PsiBuilder b, int l) {
-    if (!recursion_guard_(b, l, "elementDefinition")) return false;
+  // identifierReferencesStatement | lineCommentStatement | blockCommentStatement
+  private static boolean animationStatement_3_0(PsiBuilder b, int l) {
+    if (!recursion_guard_(b, l, "animationStatement_3_0")) return false;
     boolean r;
-    r = singleLineStatement(b, l + 1);
-    if (!r) r = blockStatement(b, l + 1);
-    if (!r) r = propertyBlockStatement(b, l + 1);
-    if (!r) r = consumeToken(b, CRLF);
+    r = identifierReferencesStatement(b, l + 1);
+    if (!r) r = lineCommentStatement(b, l + 1);
+    if (!r) r = blockCommentStatement(b, l + 1);
     return r;
   }
 
   /* ********************************************************** */
-  // identifierName '->' identifierName argument*
-  public static boolean explicitRelationship(PsiBuilder b, int l) {
-    if (!recursion_guard_(b, l, "explicitRelationship")) return false;
-    if (!nextTokenIs(b, IDENTIFIER)) return false;
+  // text
+  public static boolean argument(PsiBuilder b, int l) {
+    if (!recursion_guard_(b, l, "argument")) return false;
+    if (!nextTokenIs(b, "<argument>", QUOTED_TEXT, UNQUOTED_TEXT)) return false;
     boolean r;
-    Marker m = enter_section_(b);
-    r = identifierName(b, l + 1);
-    r = r && consumeToken(b, RELATIONSHIP_KEYWORD);
-    r = r && identifierName(b, l + 1);
-    r = r && explicitRelationship_3(b, l + 1);
-    exit_section_(b, m, EXPLICIT_RELATIONSHIP, r);
+    Marker m = enter_section_(b, l, _NONE_, ARGUMENT, "<argument>");
+    r = text(b, l + 1);
+    exit_section_(b, l, m, r, false, null);
     return r;
   }
 
-  // argument*
-  private static boolean explicitRelationship_3(PsiBuilder b, int l) {
-    if (!recursion_guard_(b, l, "explicitRelationship_3")) return false;
+  /* ********************************************************** */
+  // '{' CRLF expr* '}'
+  public static boolean block(PsiBuilder b, int l) {
+    if (!recursion_guard_(b, l, "block")) return false;
+    boolean r, p;
+    Marker m = enter_section_(b, l, _NONE_, BLOCK, "<block>");
+    r = consumeTokens(b, 1, BRACE1, CRLF);
+    p = r; // pin = 1
+    r = r && report_error_(b, block_2(b, l + 1));
+    r = p && consumeToken(b, BRACE2) && r;
+    exit_section_(b, l, m, r, p, StructurizrDSLParser::blockRecover);
+    return r || p;
+  }
+
+  // expr*
+  private static boolean block_2(PsiBuilder b, int l) {
+    if (!recursion_guard_(b, l, "block_2")) return false;
     while (true) {
       int c = current_position_(b);
-      if (!argument(b, l + 1)) break;
-      if (!empty_element_parsed_guard_(b, "explicitRelationship_3", c)) break;
+      if (!expr(b, l + 1)) break;
+      if (!empty_element_parsed_guard_(b, "block_2", c)) break;
     }
     return true;
   }
 
   /* ********************************************************** */
-  // identifierName '='
-  static boolean identifierAssignment(PsiBuilder b, int l) {
-    if (!recursion_guard_(b, l, "identifierAssignment")) return false;
-    if (!nextTokenIs(b, IDENTIFIER)) return false;
+  // BLOCK_COMMENT lf_eof
+  public static boolean blockCommentStatement(PsiBuilder b, int l) {
+    if (!recursion_guard_(b, l, "blockCommentStatement")) return false;
+    if (!nextTokenIs(b, BLOCK_COMMENT)) return false;
     boolean r;
     Marker m = enter_section_(b);
-    r = identifierName(b, l + 1);
-    r = r && consumeToken(b, EQUALS);
-    exit_section_(b, m, null, r);
+    r = consumeToken(b, BLOCK_COMMENT);
+    r = r && lf_eof(b, l + 1);
+    exit_section_(b, m, BLOCK_COMMENT_STATEMENT, r);
     return r;
   }
 
   /* ********************************************************** */
-  // IDENTIFIER
-  public static boolean identifierName(PsiBuilder b, int l) {
-    if (!recursion_guard_(b, l, "identifierName")) return false;
-    if (!nextTokenIs(b, IDENTIFIER)) return false;
+  // !(text | lf_eof)
+  static boolean blockRecover(PsiBuilder b, int l) {
+    if (!recursion_guard_(b, l, "blockRecover")) return false;
     boolean r;
-    Marker m = enter_section_(b);
-    r = consumeToken(b, IDENTIFIER);
-    exit_section_(b, m, IDENTIFIER_NAME, r);
+    Marker m = enter_section_(b, l, _NOT_);
+    r = !blockRecover_0(b, l + 1);
+    exit_section_(b, l, m, r, false, null);
+    return r;
+  }
+
+  // text | lf_eof
+  private static boolean blockRecover_0(PsiBuilder b, int l) {
+    if (!recursion_guard_(b, l, "blockRecover_0")) return false;
+    boolean r;
+    r = text(b, l + 1);
+    if (!r) r = lf_eof(b, l + 1);
     return r;
   }
 
   /* ********************************************************** */
-  // identifierName+ lf_eof
-  public static boolean identifierReferences(PsiBuilder b, int l) {
-    if (!recursion_guard_(b, l, "identifierReferences")) return false;
-    if (!nextTokenIs(b, IDENTIFIER)) return false;
+  // keyword argument* block lf_eof
+  public static boolean blockStatement(PsiBuilder b, int l) {
+    if (!recursion_guard_(b, l, "blockStatement")) return false;
+    if (!nextTokenIs(b, UNQUOTED_TEXT)) return false;
     boolean r;
     Marker m = enter_section_(b);
-    r = identifierReferences_0(b, l + 1);
+    r = keyword(b, l + 1);
+    r = r && blockStatement_1(b, l + 1);
+    r = r && block(b, l + 1);
     r = r && lf_eof(b, l + 1);
-    exit_section_(b, m, IDENTIFIER_REFERENCES, r);
+    exit_section_(b, m, BLOCK_STATEMENT, r);
     return r;
   }
 
-  // identifierName+
-  private static boolean identifierReferences_0(PsiBuilder b, int l) {
-    if (!recursion_guard_(b, l, "identifierReferences_0")) return false;
-    boolean r;
-    Marker m = enter_section_(b);
-    r = identifierName(b, l + 1);
-    while (r) {
+  // argument*
+  private static boolean blockStatement_1(PsiBuilder b, int l) {
+    if (!recursion_guard_(b, l, "blockStatement_1")) return false;
+    while (true) {
       int c = current_position_(b);
-      if (!identifierName(b, l + 1)) break;
-      if (!empty_element_parsed_guard_(b, "identifierReferences_0", c)) break;
+      if (!argument(b, l + 1)) break;
+      if (!empty_element_parsed_guard_(b, "blockStatement_1", c)) break;
     }
-    exit_section_(b, m, null, r);
-    return r;
+    return true;
   }
 
   /* ********************************************************** */
-  // '->' identifierName argument*
-  public static boolean implicitRelationship(PsiBuilder b, int l) {
-    if (!recursion_guard_(b, l, "implicitRelationship")) return false;
-    if (!nextTokenIs(b, RELATIONSHIP_KEYWORD)) return false;
+  // relationshipSource relationshipKeyword relationshipDestination argument* block? lf_eof
+  public static boolean explicitRelationshipStatement(PsiBuilder b, int l) {
+    if (!recursion_guard_(b, l, "explicitRelationshipStatement")) return false;
+    if (!nextTokenIs(b, UNQUOTED_TEXT)) return false;
     boolean r;
     Marker m = enter_section_(b);
-    r = consumeToken(b, RELATIONSHIP_KEYWORD);
-    r = r && identifierName(b, l + 1);
-    r = r && implicitRelationship_2(b, l + 1);
-    exit_section_(b, m, IMPLICIT_RELATIONSHIP, r);
+    r = relationshipSource(b, l + 1);
+    r = r && relationshipKeyword(b, l + 1);
+    r = r && relationshipDestination(b, l + 1);
+    r = r && explicitRelationshipStatement_3(b, l + 1);
+    r = r && explicitRelationshipStatement_4(b, l + 1);
+    r = r && lf_eof(b, l + 1);
+    exit_section_(b, m, EXPLICIT_RELATIONSHIP_STATEMENT, r);
     return r;
   }
 
   // argument*
-  private static boolean implicitRelationship_2(PsiBuilder b, int l) {
-    if (!recursion_guard_(b, l, "implicitRelationship_2")) return false;
+  private static boolean explicitRelationshipStatement_3(PsiBuilder b, int l) {
+    if (!recursion_guard_(b, l, "explicitRelationshipStatement_3")) return false;
     while (true) {
       int c = current_position_(b);
       if (!argument(b, l + 1)) break;
-      if (!empty_element_parsed_guard_(b, "implicitRelationship_2", c)) break;
+      if (!empty_element_parsed_guard_(b, "explicitRelationshipStatement_3", c)) break;
     }
     return true;
   }
 
+  // block?
+  private static boolean explicitRelationshipStatement_4(PsiBuilder b, int l) {
+    if (!recursion_guard_(b, l, "explicitRelationshipStatement_4")) return false;
+    block(b, l + 1);
+    return true;
+  }
+
   /* ********************************************************** */
-  // text
-  public static boolean key(PsiBuilder b, int l) {
-    if (!recursion_guard_(b, l, "key")) return false;
-    if (!nextTokenIs(b, "<key>", QUOTED_TEXT, UNQUOTED_TEXT)) return false;
+  // scriptStatement
+  //             | explicitRelationshipStatement
+  //             | implicitRelationshipStatement
+  //             | animationStatement
+  //             | propertiesStatement
+  //             | identifierAssignmentStatement
+  //             | blockStatement
+  //             | singleLineStatement
+  //             | lineCommentStatement
+  //             | blockCommentStatement
+  static boolean expr(PsiBuilder b, int l) {
+    if (!recursion_guard_(b, l, "expr")) return false;
     boolean r;
-    Marker m = enter_section_(b, l, _NONE_, KEY, "<key>");
-    r = text(b, l + 1);
-    exit_section_(b, l, m, r, false, null);
+    r = scriptStatement(b, l + 1);
+    if (!r) r = explicitRelationshipStatement(b, l + 1);
+    if (!r) r = implicitRelationshipStatement(b, l + 1);
+    if (!r) r = animationStatement(b, l + 1);
+    if (!r) r = propertiesStatement(b, l + 1);
+    if (!r) r = identifierAssignmentStatement(b, l + 1);
+    if (!r) r = blockStatement(b, l + 1);
+    if (!r) r = singleLineStatement(b, l + 1);
+    if (!r) r = lineCommentStatement(b, l + 1);
+    if (!r) r = blockCommentStatement(b, l + 1);
     return r;
   }
 
   /* ********************************************************** */
-  // key value CRLF
-  public static boolean keyValuePair(PsiBuilder b, int l) {
-    if (!recursion_guard_(b, l, "keyValuePair")) return false;
-    if (!nextTokenIs(b, "<key value pair>", QUOTED_TEXT, UNQUOTED_TEXT)) return false;
-    boolean r;
-    Marker m = enter_section_(b, l, _NONE_, KEY_VALUE_PAIR, "<key value pair>");
-    r = key(b, l + 1);
-    r = r && value(b, l + 1);
-    r = r && consumeToken(b, CRLF);
-    exit_section_(b, l, m, r, false, null);
+  // identifierReference '=' (blockStatement | singleLineStatement)
+  public static boolean identifierAssignmentStatement(PsiBuilder b, int l) {
+    if (!recursion_guard_(b, l, "identifierAssignmentStatement")) return false;
+    if (!nextTokenIs(b, UNQUOTED_TEXT)) return false;
+    boolean r;
+    Marker m = enter_section_(b);
+    r = identifierReference(b, l + 1);
+    r = r && consumeToken(b, EQUALS);
+    r = r && identifierAssignmentStatement_2(b, l + 1);
+    exit_section_(b, m, IDENTIFIER_ASSIGNMENT_STATEMENT, r);
+    return r;
+  }
+
+  // blockStatement | singleLineStatement
+  private static boolean identifierAssignmentStatement_2(PsiBuilder b, int l) {
+    if (!recursion_guard_(b, l, "identifierAssignmentStatement_2")) return false;
+    boolean r;
+    r = blockStatement(b, l + 1);
+    if (!r) r = singleLineStatement(b, l + 1);
     return r;
   }
 
   /* ********************************************************** */
-  // '!adrs' | 'animation' | 'autoLayout' | 'background' | 'border' | 'color' | 'colour' | 'component' |
-  //             '!constant' | 'containerInstance' | 'container' | 'custom' | 'deploymentEnvironment' | 'deploymentGroup' |
-  //             'deployment' | 'deploymentNode' | 'description' | '!docs' | 'dynamic' | 'element' | 'enterprise' |
-  //             'exclude' | 'extends' | 'filtered' | 'fontSize' | 'group' | 'healthCheck' | 'height' | 'icon' |
-  //             '!identifiers' | '!impliedRelationships' | 'include' | '!include' | 'infrastructureNode' | 'instances' |
-  //             'metadata' | 'model' | 'opacity' | 'person' | 'perspectives' | '!plugin' | 'position' | '!ref' | '->' |
-  //             'routing' | '!script' | 'shape' | 'softwareSystemInstance' | 'softwareSystem' | 'stroke' | 'strokeWidth' |
-  //             'style' | 'styles' | 'systemContext' | 'systemLandscape' | 'tags' | 'technology' | 'theme' | 'thickness' |
-  //             'title' | 'url' | 'views' | 'width' | 'workspace'
-  public static boolean keyword(PsiBuilder b, int l) {
-    if (!recursion_guard_(b, l, "keyword")) return false;
+  // UNQUOTED_TEXT
+  public static boolean identifierReference(PsiBuilder b, int l) {
+    if (!recursion_guard_(b, l, "identifierReference")) return false;
+    if (!nextTokenIs(b, UNQUOTED_TEXT)) return false;
+    boolean r;
+    Marker m = enter_section_(b);
+    r = consumeToken(b, UNQUOTED_TEXT);
+    exit_section_(b, m, IDENTIFIER_REFERENCE, r);
+    return r;
+  }
+
+  /* ********************************************************** */
+  // identifierReference* CRLF
+  public static boolean identifierReferencesStatement(PsiBuilder b, int l) {
+    if (!recursion_guard_(b, l, "identifierReferencesStatement")) return false;
+    if (!nextTokenIs(b, "<identifier references statement>", CRLF, UNQUOTED_TEXT)) return false;
     boolean r;
-    Marker m = enter_section_(b, l, _NONE_, KEYWORD, "<keyword>");
-    r = consumeToken(b, ADRS_KEYWORD);
-    if (!r) r = consumeToken(b, ANIMATION_KEYWORD);
-    if (!r) r = consumeToken(b, AUTO_LAYOUT_KEYWORD);
-    if (!r) r = consumeToken(b, BACKGROUND_KEYWORD);
-    if (!r) r = consumeToken(b, BORDER_KEYWORD);
-    if (!r) r = consumeToken(b, COLOR_KEYWORD);
-    if (!r) r = consumeToken(b, COLOUR_KEYWORD);
-    if (!r) r = consumeToken(b, COMPONENT_KEYWORD);
-    if (!r) r = consumeToken(b, CONSTANT_KEYWORD);
-    if (!r) r = consumeToken(b, CONTAINER_INSTANCE);
-    if (!r) r = consumeToken(b, CONTAINER_KEYWORD);
-    if (!r) r = consumeToken(b, CUSTOM_KEYWORD);
-    if (!r) r = consumeToken(b, DEPLOYMENT_ENVIRONMENT_KEYWORD);
-    if (!r) r = consumeToken(b, DEPLOYMENT_GROUP_KEYWORD);
-    if (!r) r = consumeToken(b, DEPLOYMENT_KEYWORD);
-    if (!r) r = consumeToken(b, DEPLOYMENT_NODE_KEYWORD);
-    if (!r) r = consumeToken(b, DESCRIPTION_KEYWORD);
-    if (!r) r = consumeToken(b, DOCS_KEYWORD);
-    if (!r) r = consumeToken(b, DYNAMIC_KEYWORD);
-    if (!r) r = consumeToken(b, ELEMENT_KEYWORD);
-    if (!r) r = consumeToken(b, ENTERPRISE_KEYWORD);
-    if (!r) r = consumeToken(b, EXCLUDE_ELEMENT_KEYWORD);
-    if (!r) r = consumeToken(b, EXTENDS_KEYWORD);
-    if (!r) r = consumeToken(b, FILTERED_KEYWORD);
-    if (!r) r = consumeToken(b, FONTSIZE_KEYWORD);
-    if (!r) r = consumeToken(b, GROUP_KEYWORD);
-    if (!r) r = consumeToken(b, HEALTH_CHECK_KEYWORD);
-    if (!r) r = consumeToken(b, HEIGHT_KEYWORD);
-    if (!r) r = consumeToken(b, ICON_KEYWORD);
-    if (!r) r = consumeToken(b, IDENTIFIERS_KEYWORD);
-    if (!r) r = consumeToken(b, IMPLIED_RELATIONSHIPS_KEYWORD);
-    if (!r) r = consumeToken(b, INCLUDE_ELEMENT_KEYWORD);
-    if (!r) r = consumeToken(b, INCLUDE_FILE_KEYWORD);
-    if (!r) r = consumeToken(b, INFRASTRUCTURE_NODE_KEYWORD);
-    if (!r) r = consumeToken(b, INSTANCES_KEYWORD);
-    if (!r) r = consumeToken(b, METADATA_KEYWORD);
-    if (!r) r = consumeToken(b, MODEL_KEYWORD);
-    if (!r) r = consumeToken(b, OPACITY_KEYWORD);
-    if (!r) r = consumeToken(b, PERSON_KEYWORD);
-    if (!r) r = consumeToken(b, PERSPECTIVES_KEYWORD);
-    if (!r) r = consumeToken(b, PLUGIN_KEYWORD);
-    if (!r) r = consumeToken(b, POSITION_KEYWORD);
-    if (!r) r = consumeToken(b, REF_KEYWORD);
-    if (!r) r = consumeToken(b, RELATIONSHIP_KEYWORD);
-    if (!r) r = consumeToken(b, ROUTING_KEYWORD);
-    if (!r) r = consumeToken(b, SCRIPT_KEYWORD);
-    if (!r) r = consumeToken(b, SHAPE_KEYWORD);
-    if (!r) r = consumeToken(b, SOFTWARE_SYSTEM_INSTANCE_KEYWORD);
-    if (!r) r = consumeToken(b, SOFTWARE_SYSTEM_KEYWORD);
-    if (!r) r = consumeToken(b, STROKE_KEYWORD);
-    if (!r) r = consumeToken(b, STROKEWIDTH_KEYWORD);
-    if (!r) r = consumeToken(b, STYLE_KEYWORD);
-    if (!r) r = consumeToken(b, STYLES_KEYWORD);
-    if (!r) r = consumeToken(b, SYSTEM_CONTEXT_KEYWORD);
-    if (!r) r = consumeToken(b, SYSTEM_LANDSCAPE_KEYWORD);
-    if (!r) r = consumeToken(b, TAGS_KEYWORD);
-    if (!r) r = consumeToken(b, TECHNOLOGY_KEYWORD);
-    if (!r) r = consumeToken(b, THEME_KEYWORD);
-    if (!r) r = consumeToken(b, THICKNESS_KEYWORD);
-    if (!r) r = consumeToken(b, TITLE_KEYWORD);
-    if (!r) r = consumeToken(b, URL_KEYWORD);
-    if (!r) r = consumeToken(b, VIEWS_KEYWORD);
-    if (!r) r = consumeToken(b, WIDTH_KEYWORD);
-    if (!r) r = consumeToken(b, WORKSPACE_KEYWORD);
+    Marker m = enter_section_(b, l, _NONE_, IDENTIFIER_REFERENCES_STATEMENT, "<identifier references statement>");
+    r = identifierReferencesStatement_0(b, l + 1);
+    r = r && consumeToken(b, CRLF);
     exit_section_(b, l, m, r, false, null);
     return r;
   }
 
+  // identifierReference*
+  private static boolean identifierReferencesStatement_0(PsiBuilder b, int l) {
+    if (!recursion_guard_(b, l, "identifierReferencesStatement_0")) return false;
+    while (true) {
+      int c = current_position_(b);
+      if (!identifierReference(b, l + 1)) break;
+      if (!empty_element_parsed_guard_(b, "identifierReferencesStatement_0", c)) break;
+    }
+    return true;
+  }
+
   /* ********************************************************** */
-  // keyword argument*
-  static boolean keywordWithArguments(PsiBuilder b, int l) {
-    if (!recursion_guard_(b, l, "keywordWithArguments")) return false;
+  // relationshipKeyword relationshipDestination argument* block? lf_eof
+  public static boolean implicitRelationshipStatement(PsiBuilder b, int l) {
+    if (!recursion_guard_(b, l, "implicitRelationshipStatement")) return false;
+    if (!nextTokenIs(b, ARROW)) return false;
     boolean r;
     Marker m = enter_section_(b);
-    r = keyword(b, l + 1);
-    r = r && keywordWithArguments_1(b, l + 1);
-    exit_section_(b, m, null, r);
+    r = relationshipKeyword(b, l + 1);
+    r = r && relationshipDestination(b, l + 1);
+    r = r && implicitRelationshipStatement_2(b, l + 1);
+    r = r && implicitRelationshipStatement_3(b, l + 1);
+    r = r && lf_eof(b, l + 1);
+    exit_section_(b, m, IMPLICIT_RELATIONSHIP_STATEMENT, r);
     return r;
   }
 
   // argument*
-  private static boolean keywordWithArguments_1(PsiBuilder b, int l) {
-    if (!recursion_guard_(b, l, "keywordWithArguments_1")) return false;
+  private static boolean implicitRelationshipStatement_2(PsiBuilder b, int l) {
+    if (!recursion_guard_(b, l, "implicitRelationshipStatement_2")) return false;
     while (true) {
       int c = current_position_(b);
       if (!argument(b, l + 1)) break;
-      if (!empty_element_parsed_guard_(b, "keywordWithArguments_1", c)) break;
+      if (!empty_element_parsed_guard_(b, "implicitRelationshipStatement_2", c)) break;
     }
     return true;
   }
 
+  // block?
+  private static boolean implicitRelationshipStatement_3(PsiBuilder b, int l) {
+    if (!recursion_guard_(b, l, "implicitRelationshipStatement_3")) return false;
+    block(b, l + 1);
+    return true;
+  }
+
   /* ********************************************************** */
-  // 'branding' | 'configuration' | 'properties' | 'terminology' | 'users'
-  public static boolean keywordWithPropertyBlock(PsiBuilder b, int l) {
-    if (!recursion_guard_(b, l, "keywordWithPropertyBlock")) return false;
-    boolean r;
-    Marker m = enter_section_(b, l, _NONE_, KEYWORD_WITH_PROPERTY_BLOCK, "<keyword with property block>");
-    r = consumeToken(b, BRANDING_KEYWORD);
-    if (!r) r = consumeToken(b, CONFIGURATION_KEYWORD);
-    if (!r) r = consumeToken(b, PROPERTIES_KEYWORD);
-    if (!r) r = consumeToken(b, TERMINOLOGY_KEYWORD);
-    if (!r) r = consumeToken(b, USERS_KEYWORD);
-    exit_section_(b, l, m, r, false, null);
+  // UNQUOTED_TEXT
+  public static boolean keyword(PsiBuilder b, int l) {
+    if (!recursion_guard_(b, l, "keyword")) return false;
+    if (!nextTokenIs(b, UNQUOTED_TEXT)) return false;
+    boolean r;
+    Marker m = enter_section_(b);
+    r = consumeToken(b, UNQUOTED_TEXT);
+    exit_section_(b, m, KEYWORD, r);
     return r;
   }
 
@@ -356,114 +364,223 @@ static boolean lf_eof(PsiBuilder b, int l) {
   }
 
   /* ********************************************************** */
-  // keywordWithPropertyBlock '{' CRLF keyValuePair* '}'
-  public static boolean propertyBlockStatement(PsiBuilder b, int l) {
-    if (!recursion_guard_(b, l, "propertyBlockStatement")) return false;
+  // LINE_COMMENT lf_eof
+  public static boolean lineCommentStatement(PsiBuilder b, int l) {
+    if (!recursion_guard_(b, l, "lineCommentStatement")) return false;
+    if (!nextTokenIs(b, LINE_COMMENT)) return false;
     boolean r;
-    Marker m = enter_section_(b, l, _NONE_, PROPERTY_BLOCK_STATEMENT, "<property block statement>");
-    r = keywordWithPropertyBlock(b, l + 1);
-    r = r && consumeTokens(b, 0, BRACE1, CRLF);
-    r = r && propertyBlockStatement_3(b, l + 1);
+    Marker m = enter_section_(b);
+    r = consumeToken(b, LINE_COMMENT);
+    r = r && lf_eof(b, l + 1);
+    exit_section_(b, m, LINE_COMMENT_STATEMENT, r);
+    return r;
+  }
+
+  /* ********************************************************** */
+  // '{' CRLF propertyDefinition* '}'
+  public static boolean propertiesBlock(PsiBuilder b, int l) {
+    if (!recursion_guard_(b, l, "propertiesBlock")) return false;
+    if (!nextTokenIs(b, BRACE1)) return false;
+    boolean r;
+    Marker m = enter_section_(b);
+    r = consumeTokens(b, 0, BRACE1, CRLF);
+    r = r && propertiesBlock_2(b, l + 1);
     r = r && consumeToken(b, BRACE2);
-    exit_section_(b, l, m, r, false, null);
+    exit_section_(b, m, PROPERTIES_BLOCK, r);
     return r;
   }
 
-  // keyValuePair*
-  private static boolean propertyBlockStatement_3(PsiBuilder b, int l) {
-    if (!recursion_guard_(b, l, "propertyBlockStatement_3")) return false;
+  // propertyDefinition*
+  private static boolean propertiesBlock_2(PsiBuilder b, int l) {
+    if (!recursion_guard_(b, l, "propertiesBlock_2")) return false;
     while (true) {
       int c = current_position_(b);
-      if (!keyValuePair(b, l + 1)) break;
-      if (!empty_element_parsed_guard_(b, "propertyBlockStatement_3", c)) break;
+      if (!propertyDefinition(b, l + 1)) break;
+      if (!empty_element_parsed_guard_(b, "propertiesBlock_2", c)) break;
     }
     return true;
   }
 
   /* ********************************************************** */
-  // '!script' argument* '{' scriptContents '}'
-  public static boolean scriptBlock(PsiBuilder b, int l) {
-    if (!recursion_guard_(b, l, "scriptBlock")) return false;
-    if (!nextTokenIs(b, SCRIPT_KEYWORD)) return false;
+  // 'perspectives' | 'properties' | 'users'
+  public static boolean propertiesKeyword(PsiBuilder b, int l) {
+    if (!recursion_guard_(b, l, "propertiesKeyword")) return false;
+    boolean r;
+    Marker m = enter_section_(b, l, _NONE_, PROPERTIES_KEYWORD, "<properties keyword>");
+    r = consumeToken(b, "perspectives");
+    if (!r) r = consumeToken(b, "properties");
+    if (!r) r = consumeToken(b, "users");
+    exit_section_(b, l, m, r, false, null);
+    return r;
+  }
+
+  /* ********************************************************** */
+  // propertiesKeyword propertiesBlock lf_eof
+  public static boolean propertiesStatement(PsiBuilder b, int l) {
+    if (!recursion_guard_(b, l, "propertiesStatement")) return false;
+    boolean r;
+    Marker m = enter_section_(b, l, _NONE_, PROPERTIES_STATEMENT, "<properties statement>");
+    r = propertiesKeyword(b, l + 1);
+    r = r && propertiesBlock(b, l + 1);
+    r = r && lf_eof(b, l + 1);
+    exit_section_(b, l, m, r, false, null);
+    return r;
+  }
+
+  /* ********************************************************** */
+  // propertyKey propertyValue CRLF
+  public static boolean propertyDefinition(PsiBuilder b, int l) {
+    if (!recursion_guard_(b, l, "propertyDefinition")) return false;
+    if (!nextTokenIs(b, "<property definition>", QUOTED_TEXT, UNQUOTED_TEXT)) return false;
+    boolean r;
+    Marker m = enter_section_(b, l, _NONE_, PROPERTY_DEFINITION, "<property definition>");
+    r = propertyKey(b, l + 1);
+    r = r && propertyValue(b, l + 1);
+    r = r && consumeToken(b, CRLF);
+    exit_section_(b, l, m, r, false, null);
+    return r;
+  }
+
+  /* ********************************************************** */
+  // text
+  public static boolean propertyKey(PsiBuilder b, int l) {
+    if (!recursion_guard_(b, l, "propertyKey")) return false;
+    if (!nextTokenIs(b, "<property key>", QUOTED_TEXT, UNQUOTED_TEXT)) return false;
+    boolean r;
+    Marker m = enter_section_(b, l, _NONE_, PROPERTY_KEY, "<property key>");
+    r = text(b, l + 1);
+    exit_section_(b, l, m, r, false, null);
+    return r;
+  }
+
+  /* ********************************************************** */
+  // text
+  public static boolean propertyValue(PsiBuilder b, int l) {
+    if (!recursion_guard_(b, l, "propertyValue")) return false;
+    if (!nextTokenIs(b, "<property value>", QUOTED_TEXT, UNQUOTED_TEXT)) return false;
+    boolean r;
+    Marker m = enter_section_(b, l, _NONE_, PROPERTY_VALUE, "<property value>");
+    r = text(b, l + 1);
+    exit_section_(b, l, m, r, false, null);
+    return r;
+  }
+
+  /* ********************************************************** */
+  // UNQUOTED_TEXT
+  public static boolean relationshipDestination(PsiBuilder b, int l) {
+    if (!recursion_guard_(b, l, "relationshipDestination")) return false;
+    if (!nextTokenIs(b, UNQUOTED_TEXT)) return false;
     boolean r;
     Marker m = enter_section_(b);
-    r = consumeToken(b, SCRIPT_KEYWORD);
-    r = r && scriptBlock_1(b, l + 1);
-    r = r && consumeToken(b, BRACE1);
-    r = r && scriptContents(b, l + 1);
-    r = r && consumeToken(b, BRACE2);
-    exit_section_(b, m, SCRIPT_BLOCK, r);
+    r = consumeToken(b, UNQUOTED_TEXT);
+    exit_section_(b, m, RELATIONSHIP_DESTINATION, r);
     return r;
   }
 
-  // argument*
-  private static boolean scriptBlock_1(PsiBuilder b, int l) {
-    if (!recursion_guard_(b, l, "scriptBlock_1")) return false;
-    while (true) {
-      int c = current_position_(b);
-      if (!argument(b, l + 1)) break;
-      if (!empty_element_parsed_guard_(b, "scriptBlock_1", c)) break;
-    }
-    return true;
+  /* ********************************************************** */
+  // ARROW
+  public static boolean relationshipKeyword(PsiBuilder b, int l) {
+    if (!recursion_guard_(b, l, "relationshipKeyword")) return false;
+    if (!nextTokenIs(b, ARROW)) return false;
+    boolean r;
+    Marker m = enter_section_(b);
+    r = consumeToken(b, ARROW);
+    exit_section_(b, m, RELATIONSHIP_KEYWORD, r);
+    return r;
   }
 
   /* ********************************************************** */
-  // SCRIPT_TEXT+
-  public static boolean scriptContents(PsiBuilder b, int l) {
-    if (!recursion_guard_(b, l, "scriptContents")) return false;
-    if (!nextTokenIs(b, SCRIPT_TEXT)) return false;
+  // UNQUOTED_TEXT
+  public static boolean relationshipSource(PsiBuilder b, int l) {
+    if (!recursion_guard_(b, l, "relationshipSource")) return false;
+    if (!nextTokenIs(b, UNQUOTED_TEXT)) return false;
     boolean r;
     Marker m = enter_section_(b);
-    r = consumeToken(b, SCRIPT_TEXT);
-    while (r) {
-      int c = current_position_(b);
-      if (!consumeToken(b, SCRIPT_TEXT)) break;
-      if (!empty_element_parsed_guard_(b, "scriptContents", c)) break;
-    }
-    exit_section_(b, m, SCRIPT_CONTENTS, r);
+    r = consumeToken(b, UNQUOTED_TEXT);
+    exit_section_(b, m, RELATIONSHIP_SOURCE, r);
     return r;
   }
 
   /* ********************************************************** */
-  // identifierAssignment? keywordWithArguments lf_eof
-  public static boolean singleLineStatement(PsiBuilder b, int l) {
-    if (!recursion_guard_(b, l, "singleLineStatement")) return false;
+  // '{' SCRIPT_TEXT '}'
+  public static boolean scriptBlock(PsiBuilder b, int l) {
+    if (!recursion_guard_(b, l, "scriptBlock")) return false;
+    if (!nextTokenIs(b, BRACE1)) return false;
+    boolean r;
+    Marker m = enter_section_(b);
+    r = consumeTokens(b, 0, BRACE1, SCRIPT_TEXT, BRACE2);
+    exit_section_(b, m, SCRIPT_BLOCK, r);
+    return r;
+  }
+
+  /* ********************************************************** */
+  // '!script'
+  public static boolean scriptKeyword(PsiBuilder b, int l) {
+    if (!recursion_guard_(b, l, "scriptKeyword")) return false;
+    boolean r;
+    Marker m = enter_section_(b, l, _NONE_, SCRIPT_KEYWORD, "<script keyword>");
+    r = consumeToken(b, "!script");
+    exit_section_(b, l, m, r, false, null);
+    return r;
+  }
+
+  /* ********************************************************** */
+  // scriptKeyword argument* scriptBlock lf_eof
+  public static boolean scriptStatement(PsiBuilder b, int l) {
+    if (!recursion_guard_(b, l, "scriptStatement")) return false;
     boolean r;
-    Marker m = enter_section_(b, l, _NONE_, SINGLE_LINE_STATEMENT, "<single line statement>");
-    r = singleLineStatement_0(b, l + 1);
-    r = r && keywordWithArguments(b, l + 1);
+    Marker m = enter_section_(b, l, _NONE_, SCRIPT_STATEMENT, "<script statement>");
+    r = scriptKeyword(b, l + 1);
+    r = r && scriptStatement_1(b, l + 1);
+    r = r && scriptBlock(b, l + 1);
     r = r && lf_eof(b, l + 1);
     exit_section_(b, l, m, r, false, null);
     return r;
   }
 
-  // identifierAssignment?
-  private static boolean singleLineStatement_0(PsiBuilder b, int l) {
-    if (!recursion_guard_(b, l, "singleLineStatement_0")) return false;
-    identifierAssignment(b, l + 1);
+  // argument*
+  private static boolean scriptStatement_1(PsiBuilder b, int l) {
+    if (!recursion_guard_(b, l, "scriptStatement_1")) return false;
+    while (true) {
+      int c = current_position_(b);
+      if (!argument(b, l + 1)) break;
+      if (!empty_element_parsed_guard_(b, "scriptStatement_1", c)) break;
+    }
     return true;
   }
 
   /* ********************************************************** */
-  // elementDefinition | scriptBlock | explicitRelationship | implicitRelationship | identifierReferences
-  static boolean statement(PsiBuilder b, int l) {
-    if (!recursion_guard_(b, l, "statement")) return false;
+  // keyword argument* lf_eof
+  public static boolean singleLineStatement(PsiBuilder b, int l) {
+    if (!recursion_guard_(b, l, "singleLineStatement")) return false;
+    if (!nextTokenIs(b, UNQUOTED_TEXT)) return false;
     boolean r;
-    r = elementDefinition(b, l + 1);
-    if (!r) r = scriptBlock(b, l + 1);
-    if (!r) r = explicitRelationship(b, l + 1);
-    if (!r) r = implicitRelationship(b, l + 1);
-    if (!r) r = identifierReferences(b, l + 1);
+    Marker m = enter_section_(b);
+    r = keyword(b, l + 1);
+    r = r && singleLineStatement_1(b, l + 1);
+    r = r && lf_eof(b, l + 1);
+    exit_section_(b, m, SINGLE_LINE_STATEMENT, r);
     return r;
   }
 
+  // argument*
+  private static boolean singleLineStatement_1(PsiBuilder b, int l) {
+    if (!recursion_guard_(b, l, "singleLineStatement_1")) return false;
+    while (true) {
+      int c = current_position_(b);
+      if (!argument(b, l + 1)) break;
+      if (!empty_element_parsed_guard_(b, "singleLineStatement_1", c)) break;
+    }
+    return true;
+  }
+
   /* ********************************************************** */
-  // statement*
+  // expr*
   static boolean structurizrDSLFile(PsiBuilder b, int l) {
     if (!recursion_guard_(b, l, "structurizrDSLFile")) return false;
     while (true) {
       int c = current_position_(b);
-      if (!statement(b, l + 1)) break;
+      if (!expr(b, l + 1)) break;
       if (!empty_element_parsed_guard_(b, "structurizrDSLFile", c)) break;
     }
     return true;
@@ -480,16 +597,4 @@ static boolean text(PsiBuilder b, int l) {
     return r;
   }
 
-  /* ********************************************************** */
-  // text
-  public static boolean value(PsiBuilder b, int l) {
-    if (!recursion_guard_(b, l, "value")) return false;
-    if (!nextTokenIs(b, "<value>", QUOTED_TEXT, UNQUOTED_TEXT)) return false;
-    boolean r;
-    Marker m = enter_section_(b, l, _NONE_, VALUE, "<value>");
-    r = text(b, l + 1);
-    exit_section_(b, l, m, r, false, null);
-    return r;
-  }
-
 }
diff --git a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDScriptContents.java b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDAnimationKeyword.java
similarity index 78%
rename from src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDScriptContents.java
rename to src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDAnimationKeyword.java
index 3fb79c5..43ece88 100644
--- a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDScriptContents.java
+++ b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDAnimationKeyword.java
@@ -5,6 +5,6 @@
 import org.jetbrains.annotations.*;
 import com.intellij.psi.PsiElement;
 
-public interface SDScriptContents extends PsiElement {
+public interface SDAnimationKeyword extends PsiElement {
 
 }
diff --git a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDAnimationStatement.java b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDAnimationStatement.java
new file mode 100644
index 0000000..29034fc
--- /dev/null
+++ b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDAnimationStatement.java
@@ -0,0 +1,16 @@
+// This is a generated file. Not intended for manual editing.
+package nl.dirkgroot.structurizr.dsl.psi;
+
+import java.util.List;
+import org.jetbrains.annotations.*;
+import com.intellij.psi.PsiElement;
+
+public interface SDAnimationStatement extends SDStatement {
+
+  @NotNull
+  SDAnimationKeyword getAnimationKeyword();
+
+  @NotNull
+  List<SDStatement> getStatementList();
+
+}
diff --git a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDBlock.java b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDBlock.java
new file mode 100644
index 0000000..2ca2086
--- /dev/null
+++ b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDBlock.java
@@ -0,0 +1,13 @@
+// This is a generated file. Not intended for manual editing.
+package nl.dirkgroot.structurizr.dsl.psi;
+
+import java.util.List;
+import org.jetbrains.annotations.*;
+import com.intellij.psi.PsiElement;
+
+public interface SDBlock extends PsiElement {
+
+  @NotNull
+  List<SDStatement> getStatementList();
+
+}
diff --git a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDBlockCommentStatement.java b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDBlockCommentStatement.java
new file mode 100644
index 0000000..9340b64
--- /dev/null
+++ b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDBlockCommentStatement.java
@@ -0,0 +1,10 @@
+// This is a generated file. Not intended for manual editing.
+package nl.dirkgroot.structurizr.dsl.psi;
+
+import java.util.List;
+import org.jetbrains.annotations.*;
+import com.intellij.psi.PsiElement;
+
+public interface SDBlockCommentStatement extends SDStatement {
+
+}
diff --git a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDBlockStatement.java b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDBlockStatement.java
index 0e9fb18..0298748 100644
--- a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDBlockStatement.java
+++ b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDBlockStatement.java
@@ -5,36 +5,15 @@
 import org.jetbrains.annotations.*;
 import com.intellij.psi.PsiElement;
 
-public interface SDBlockStatement extends PsiElement {
+public interface SDBlockStatement extends SDStatement {
 
   @NotNull
   List<SDArgument> getArgumentList();
 
   @NotNull
-  List<SDBlockStatement> getBlockStatementList();
-
-  @NotNull
-  List<SDExplicitRelationship> getExplicitRelationshipList();
-
-  @Nullable
-  SDIdentifierName getIdentifierName();
-
-  @NotNull
-  List<SDIdentifierReferences> getIdentifierReferencesList();
-
-  @NotNull
-  List<SDImplicitRelationship> getImplicitRelationshipList();
+  SDBlock getBlock();
 
   @NotNull
   SDKeyword getKeyword();
 
-  @NotNull
-  List<SDPropertyBlockStatement> getPropertyBlockStatementList();
-
-  @NotNull
-  List<SDScriptBlock> getScriptBlockList();
-
-  @NotNull
-  List<SDSingleLineStatement> getSingleLineStatementList();
-
 }
diff --git a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDExplicitRelationshipStatement.java b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDExplicitRelationshipStatement.java
new file mode 100644
index 0000000..505b54e
--- /dev/null
+++ b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDExplicitRelationshipStatement.java
@@ -0,0 +1,25 @@
+// This is a generated file. Not intended for manual editing.
+package nl.dirkgroot.structurizr.dsl.psi;
+
+import java.util.List;
+import org.jetbrains.annotations.*;
+import com.intellij.psi.PsiElement;
+
+public interface SDExplicitRelationshipStatement extends SDStatement {
+
+  @NotNull
+  List<SDArgument> getArgumentList();
+
+  @Nullable
+  SDBlock getBlock();
+
+  @NotNull
+  SDRelationshipDestination getRelationshipDestination();
+
+  @NotNull
+  SDRelationshipKeyword getRelationshipKeyword();
+
+  @NotNull
+  SDRelationshipSource getRelationshipSource();
+
+}
diff --git a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDKeyValuePair.java b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDIdentifierAssignmentStatement.java
similarity index 64%
rename from src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDKeyValuePair.java
rename to src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDIdentifierAssignmentStatement.java
index 381a749..a612e67 100644
--- a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDKeyValuePair.java
+++ b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDIdentifierAssignmentStatement.java
@@ -5,12 +5,9 @@
 import org.jetbrains.annotations.*;
 import com.intellij.psi.PsiElement;
 
-public interface SDKeyValuePair extends PsiElement {
+public interface SDIdentifierAssignmentStatement extends SDStatement {
 
   @NotNull
-  SDKey getKey();
-
-  @NotNull
-  SDValue getValue();
+  SDIdentifierReference getIdentifierReference();
 
 }
diff --git a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDIdentifierReference.java b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDIdentifierReference.java
new file mode 100644
index 0000000..7633da1
--- /dev/null
+++ b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDIdentifierReference.java
@@ -0,0 +1,10 @@
+// This is a generated file. Not intended for manual editing.
+package nl.dirkgroot.structurizr.dsl.psi;
+
+import java.util.List;
+import org.jetbrains.annotations.*;
+import com.intellij.psi.PsiElement;
+
+public interface SDIdentifierReference extends PsiElement {
+
+}
diff --git a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDIdentifierReferencesStatement.java b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDIdentifierReferencesStatement.java
new file mode 100644
index 0000000..d9c71e9
--- /dev/null
+++ b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDIdentifierReferencesStatement.java
@@ -0,0 +1,13 @@
+// This is a generated file. Not intended for manual editing.
+package nl.dirkgroot.structurizr.dsl.psi;
+
+import java.util.List;
+import org.jetbrains.annotations.*;
+import com.intellij.psi.PsiElement;
+
+public interface SDIdentifierReferencesStatement extends SDStatement {
+
+  @NotNull
+  List<SDIdentifierReference> getIdentifierReferenceList();
+
+}
diff --git a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDImplicitRelationshipStatement.java b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDImplicitRelationshipStatement.java
new file mode 100644
index 0000000..8799606
--- /dev/null
+++ b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDImplicitRelationshipStatement.java
@@ -0,0 +1,22 @@
+// This is a generated file. Not intended for manual editing.
+package nl.dirkgroot.structurizr.dsl.psi;
+
+import java.util.List;
+import org.jetbrains.annotations.*;
+import com.intellij.psi.PsiElement;
+
+public interface SDImplicitRelationshipStatement extends SDStatement {
+
+  @NotNull
+  List<SDArgument> getArgumentList();
+
+  @Nullable
+  SDBlock getBlock();
+
+  @NotNull
+  SDRelationshipDestination getRelationshipDestination();
+
+  @NotNull
+  SDRelationshipKeyword getRelationshipKeyword();
+
+}
diff --git a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDLineCommentStatement.java b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDLineCommentStatement.java
new file mode 100644
index 0000000..f6635ed
--- /dev/null
+++ b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDLineCommentStatement.java
@@ -0,0 +1,10 @@
+// This is a generated file. Not intended for manual editing.
+package nl.dirkgroot.structurizr.dsl.psi;
+
+import java.util.List;
+import org.jetbrains.annotations.*;
+import com.intellij.psi.PsiElement;
+
+public interface SDLineCommentStatement extends SDStatement {
+
+}
diff --git a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDIdentifierReferences.java b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDPropertiesBlock.java
similarity index 65%
rename from src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDIdentifierReferences.java
rename to src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDPropertiesBlock.java
index 199b07d..43eb2eb 100644
--- a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDIdentifierReferences.java
+++ b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDPropertiesBlock.java
@@ -5,9 +5,9 @@
 import org.jetbrains.annotations.*;
 import com.intellij.psi.PsiElement;
 
-public interface SDIdentifierReferences extends PsiElement {
+public interface SDPropertiesBlock extends PsiElement {
 
   @NotNull
-  List<SDIdentifierName> getIdentifierNameList();
+  List<SDPropertyDefinition> getPropertyDefinitionList();
 
 }
diff --git a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDPropertiesKeyword.java b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDPropertiesKeyword.java
new file mode 100644
index 0000000..9bbe203
--- /dev/null
+++ b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDPropertiesKeyword.java
@@ -0,0 +1,10 @@
+// This is a generated file. Not intended for manual editing.
+package nl.dirkgroot.structurizr.dsl.psi;
+
+import java.util.List;
+import org.jetbrains.annotations.*;
+import com.intellij.psi.PsiElement;
+
+public interface SDPropertiesKeyword extends PsiElement {
+
+}
diff --git a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDPropertyBlockStatement.java b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDPropertiesStatement.java
similarity index 57%
rename from src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDPropertyBlockStatement.java
rename to src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDPropertiesStatement.java
index 95576b6..badfa36 100644
--- a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDPropertyBlockStatement.java
+++ b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDPropertiesStatement.java
@@ -5,12 +5,12 @@
 import org.jetbrains.annotations.*;
 import com.intellij.psi.PsiElement;
 
-public interface SDPropertyBlockStatement extends PsiElement {
+public interface SDPropertiesStatement extends SDStatement {
 
   @NotNull
-  List<SDKeyValuePair> getKeyValuePairList();
+  SDPropertiesBlock getPropertiesBlock();
 
   @NotNull
-  SDKeywordWithPropertyBlock getKeywordWithPropertyBlock();
+  SDPropertiesKeyword getPropertiesKeyword();
 
 }
diff --git a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDImplicitRelationship.java b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDPropertyDefinition.java
similarity index 62%
rename from src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDImplicitRelationship.java
rename to src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDPropertyDefinition.java
index 0724fed..1bf562a 100644
--- a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDImplicitRelationship.java
+++ b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDPropertyDefinition.java
@@ -5,12 +5,12 @@
 import org.jetbrains.annotations.*;
 import com.intellij.psi.PsiElement;
 
-public interface SDImplicitRelationship extends PsiElement {
+public interface SDPropertyDefinition extends PsiElement {
 
   @NotNull
-  List<SDArgument> getArgumentList();
+  SDPropertyKey getPropertyKey();
 
   @NotNull
-  SDIdentifierName getIdentifierName();
+  SDPropertyValue getPropertyValue();
 
 }
diff --git a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDKey.java b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDPropertyKey.java
similarity index 79%
rename from src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDKey.java
rename to src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDPropertyKey.java
index 3d2ff27..8ca0aa5 100644
--- a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDKey.java
+++ b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDPropertyKey.java
@@ -5,6 +5,6 @@
 import org.jetbrains.annotations.*;
 import com.intellij.psi.PsiElement;
 
-public interface SDKey extends PsiElement {
+public interface SDPropertyKey extends PsiElement {
 
 }
diff --git a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDValue.java b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDPropertyValue.java
similarity index 79%
rename from src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDValue.java
rename to src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDPropertyValue.java
index 87d6d5b..30edca2 100644
--- a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDValue.java
+++ b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDPropertyValue.java
@@ -5,6 +5,6 @@
 import org.jetbrains.annotations.*;
 import com.intellij.psi.PsiElement;
 
-public interface SDValue extends PsiElement {
+public interface SDPropertyValue extends PsiElement {
 
 }
diff --git a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDRelationshipDestination.java b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDRelationshipDestination.java
new file mode 100644
index 0000000..b739d33
--- /dev/null
+++ b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDRelationshipDestination.java
@@ -0,0 +1,10 @@
+// This is a generated file. Not intended for manual editing.
+package nl.dirkgroot.structurizr.dsl.psi;
+
+import java.util.List;
+import org.jetbrains.annotations.*;
+import com.intellij.psi.PsiElement;
+
+public interface SDRelationshipDestination extends PsiElement {
+
+}
diff --git a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDRelationshipKeyword.java b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDRelationshipKeyword.java
new file mode 100644
index 0000000..b803b7c
--- /dev/null
+++ b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDRelationshipKeyword.java
@@ -0,0 +1,10 @@
+// This is a generated file. Not intended for manual editing.
+package nl.dirkgroot.structurizr.dsl.psi;
+
+import java.util.List;
+import org.jetbrains.annotations.*;
+import com.intellij.psi.PsiElement;
+
+public interface SDRelationshipKeyword extends PsiElement {
+
+}
diff --git a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDRelationshipSource.java b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDRelationshipSource.java
new file mode 100644
index 0000000..0a6dab9
--- /dev/null
+++ b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDRelationshipSource.java
@@ -0,0 +1,10 @@
+// This is a generated file. Not intended for manual editing.
+package nl.dirkgroot.structurizr.dsl.psi;
+
+import java.util.List;
+import org.jetbrains.annotations.*;
+import com.intellij.psi.PsiElement;
+
+public interface SDRelationshipSource extends PsiElement {
+
+}
diff --git a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDScriptBlock.java b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDScriptBlock.java
index 6b2590c..9cf6ad0 100644
--- a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDScriptBlock.java
+++ b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDScriptBlock.java
@@ -7,10 +7,4 @@
 
 public interface SDScriptBlock extends PsiElement {
 
-  @NotNull
-  List<SDArgument> getArgumentList();
-
-  @NotNull
-  SDScriptContents getScriptContents();
-
 }
diff --git a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDIdentifierName.java b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDScriptKeyword.java
similarity index 78%
rename from src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDIdentifierName.java
rename to src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDScriptKeyword.java
index 1a58f56..d2526c2 100644
--- a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDIdentifierName.java
+++ b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDScriptKeyword.java
@@ -5,6 +5,6 @@
 import org.jetbrains.annotations.*;
 import com.intellij.psi.PsiElement;
 
-public interface SDIdentifierName extends PsiElement {
+public interface SDScriptKeyword extends PsiElement {
 
 }
diff --git a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDExplicitRelationship.java b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDScriptStatement.java
similarity index 65%
rename from src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDExplicitRelationship.java
rename to src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDScriptStatement.java
index 8e3686f..1c95346 100644
--- a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDExplicitRelationship.java
+++ b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDScriptStatement.java
@@ -5,12 +5,15 @@
 import org.jetbrains.annotations.*;
 import com.intellij.psi.PsiElement;
 
-public interface SDExplicitRelationship extends PsiElement {
+public interface SDScriptStatement extends SDStatement {
 
   @NotNull
   List<SDArgument> getArgumentList();
 
   @NotNull
-  List<SDIdentifierName> getIdentifierNameList();
+  SDScriptBlock getScriptBlock();
+
+  @NotNull
+  SDScriptKeyword getScriptKeyword();
 
 }
diff --git a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDSingleLineStatement.java b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDSingleLineStatement.java
index 4a85eca..ed9b035 100644
--- a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDSingleLineStatement.java
+++ b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDSingleLineStatement.java
@@ -5,14 +5,11 @@
 import org.jetbrains.annotations.*;
 import com.intellij.psi.PsiElement;
 
-public interface SDSingleLineStatement extends PsiElement {
+public interface SDSingleLineStatement extends SDStatement {
 
   @NotNull
   List<SDArgument> getArgumentList();
 
-  @Nullable
-  SDIdentifierName getIdentifierName();
-
   @NotNull
   SDKeyword getKeyword();
 
diff --git a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDKeywordWithPropertyBlock.java b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDStatement.java
similarity index 69%
rename from src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDKeywordWithPropertyBlock.java
rename to src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDStatement.java
index 41ac6de..c4b0b7b 100644
--- a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDKeywordWithPropertyBlock.java
+++ b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDStatement.java
@@ -5,6 +5,9 @@
 import org.jetbrains.annotations.*;
 import com.intellij.psi.PsiElement;
 
-public interface SDKeywordWithPropertyBlock extends PsiElement {
+public interface SDStatement extends PsiElement {
+
+  @NotNull
+  SDStatement getStatement();
 
 }
diff --git a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDTypes.java b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDTypes.java
index ba0a91d..16426da 100644
--- a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDTypes.java
+++ b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDTypes.java
@@ -8,150 +8,125 @@
 
 public interface SDTypes {
 
+  IElementType ANIMATION_KEYWORD = new SDElement("ANIMATION_KEYWORD");
+  IElementType ANIMATION_STATEMENT = new SDElement("ANIMATION_STATEMENT");
   IElementType ARGUMENT = new SDElement("ARGUMENT");
+  IElementType BLOCK = new SDElement("BLOCK");
+  IElementType BLOCK_COMMENT_STATEMENT = new SDElement("BLOCK_COMMENT_STATEMENT");
   IElementType BLOCK_STATEMENT = new SDElement("BLOCK_STATEMENT");
-  IElementType EXPLICIT_RELATIONSHIP = new SDElement("EXPLICIT_RELATIONSHIP");
-  IElementType IDENTIFIER_NAME = new SDElement("IDENTIFIER_NAME");
-  IElementType IDENTIFIER_REFERENCES = new SDElement("IDENTIFIER_REFERENCES");
-  IElementType IMPLICIT_RELATIONSHIP = new SDElement("IMPLICIT_RELATIONSHIP");
-  IElementType KEY = new SDElement("KEY");
+  IElementType EXPLICIT_RELATIONSHIP_STATEMENT = new SDElement("EXPLICIT_RELATIONSHIP_STATEMENT");
+  IElementType IDENTIFIER_ASSIGNMENT_STATEMENT = new SDElement("IDENTIFIER_ASSIGNMENT_STATEMENT");
+  IElementType IDENTIFIER_REFERENCE = new SDElement("IDENTIFIER_REFERENCE");
+  IElementType IDENTIFIER_REFERENCES_STATEMENT = new SDElement("IDENTIFIER_REFERENCES_STATEMENT");
+  IElementType IMPLICIT_RELATIONSHIP_STATEMENT = new SDElement("IMPLICIT_RELATIONSHIP_STATEMENT");
   IElementType KEYWORD = new SDElement("KEYWORD");
-  IElementType KEYWORD_WITH_PROPERTY_BLOCK = new SDElement("KEYWORD_WITH_PROPERTY_BLOCK");
-  IElementType KEY_VALUE_PAIR = new SDElement("KEY_VALUE_PAIR");
-  IElementType PROPERTY_BLOCK_STATEMENT = new SDElement("PROPERTY_BLOCK_STATEMENT");
+  IElementType LINE_COMMENT_STATEMENT = new SDElement("LINE_COMMENT_STATEMENT");
+  IElementType PROPERTIES_BLOCK = new SDElement("PROPERTIES_BLOCK");
+  IElementType PROPERTIES_KEYWORD = new SDElement("PROPERTIES_KEYWORD");
+  IElementType PROPERTIES_STATEMENT = new SDElement("PROPERTIES_STATEMENT");
+  IElementType PROPERTY_DEFINITION = new SDElement("PROPERTY_DEFINITION");
+  IElementType PROPERTY_KEY = new SDElement("PROPERTY_KEY");
+  IElementType PROPERTY_VALUE = new SDElement("PROPERTY_VALUE");
+  IElementType RELATIONSHIP_DESTINATION = new SDElement("RELATIONSHIP_DESTINATION");
+  IElementType RELATIONSHIP_KEYWORD = new SDElement("RELATIONSHIP_KEYWORD");
+  IElementType RELATIONSHIP_SOURCE = new SDElement("RELATIONSHIP_SOURCE");
   IElementType SCRIPT_BLOCK = new SDElement("SCRIPT_BLOCK");
-  IElementType SCRIPT_CONTENTS = new SDElement("SCRIPT_CONTENTS");
+  IElementType SCRIPT_KEYWORD = new SDElement("SCRIPT_KEYWORD");
+  IElementType SCRIPT_STATEMENT = new SDElement("SCRIPT_STATEMENT");
   IElementType SINGLE_LINE_STATEMENT = new SDElement("SINGLE_LINE_STATEMENT");
-  IElementType VALUE = new SDElement("VALUE");
 
-  IElementType ADRS_KEYWORD = new SDToken("!adrs");
-  IElementType ANIMATION_KEYWORD = new SDToken("animation");
-  IElementType AUTO_LAYOUT_KEYWORD = new SDToken("autoLayout");
-  IElementType BACKGROUND_KEYWORD = new SDToken("background");
-  IElementType BLOCK_COMMENT = new SDToken("block_comment");
-  IElementType BORDER_KEYWORD = new SDToken("border");
+  IElementType ARROW = new SDToken("ARROW");
+  IElementType BLOCK_COMMENT = new SDToken("BLOCK_COMMENT");
   IElementType BRACE1 = new SDToken("{");
   IElementType BRACE2 = new SDToken("}");
-  IElementType BRANDING_KEYWORD = new SDToken("branding");
-  IElementType COLOR_KEYWORD = new SDToken("color");
-  IElementType COLOUR_KEYWORD = new SDToken("colour");
-  IElementType COMPONENT_KEYWORD = new SDToken("component");
-  IElementType CONFIGURATION_KEYWORD = new SDToken("configuration");
-  IElementType CONSTANT_KEYWORD = new SDToken("!constant");
-  IElementType CONTAINER_INSTANCE = new SDToken("containerInstance");
-  IElementType CONTAINER_KEYWORD = new SDToken("container");
   IElementType CRLF = new SDToken("CRLF");
-  IElementType CUSTOM_KEYWORD = new SDToken("custom");
-  IElementType DEPLOYMENT_ENVIRONMENT_KEYWORD = new SDToken("deploymentEnvironment");
-  IElementType DEPLOYMENT_GROUP_KEYWORD = new SDToken("deploymentGroup");
-  IElementType DEPLOYMENT_KEYWORD = new SDToken("deployment");
-  IElementType DEPLOYMENT_NODE_KEYWORD = new SDToken("deploymentNode");
-  IElementType DESCRIPTION_KEYWORD = new SDToken("description");
-  IElementType DOCS_KEYWORD = new SDToken("!docs");
-  IElementType DYNAMIC_KEYWORD = new SDToken("dynamic");
-  IElementType ELEMENT_KEYWORD = new SDToken("element");
-  IElementType ENTERPRISE_KEYWORD = new SDToken("enterprise");
   IElementType EQUALS = new SDToken("=");
-  IElementType EXCLUDE_ELEMENT_KEYWORD = new SDToken("exclude");
-  IElementType EXTENDS_KEYWORD = new SDToken("extends");
-  IElementType FILTERED_KEYWORD = new SDToken("filtered");
-  IElementType FONTSIZE_KEYWORD = new SDToken("fontSize");
-  IElementType GROUP_KEYWORD = new SDToken("group");
-  IElementType HEALTH_CHECK_KEYWORD = new SDToken("healthCheck");
-  IElementType HEIGHT_KEYWORD = new SDToken("height");
-  IElementType ICON_KEYWORD = new SDToken("icon");
-  IElementType IDENTIFIER = new SDToken("IDENTIFIER");
-  IElementType IDENTIFIERS_KEYWORD = new SDToken("!identifiers");
-  IElementType IMPLIED_RELATIONSHIPS_KEYWORD = new SDToken("!impliedRelationships");
-  IElementType INCLUDE_ELEMENT_KEYWORD = new SDToken("include");
-  IElementType INCLUDE_FILE_KEYWORD = new SDToken("!include");
-  IElementType INFRASTRUCTURE_NODE_KEYWORD = new SDToken("infrastructureNode");
-  IElementType INSTANCES_KEYWORD = new SDToken("instances");
-  IElementType LINE_COMMENT = new SDToken("line_comment");
-  IElementType METADATA_KEYWORD = new SDToken("metadata");
-  IElementType MODEL_KEYWORD = new SDToken("model");
-  IElementType OPACITY_KEYWORD = new SDToken("opacity");
-  IElementType PERSON_KEYWORD = new SDToken("person");
-  IElementType PERSPECTIVES_KEYWORD = new SDToken("perspectives");
-  IElementType PLUGIN_KEYWORD = new SDToken("!plugin");
-  IElementType POSITION_KEYWORD = new SDToken("position");
-  IElementType PROPERTIES_KEYWORD = new SDToken("properties");
+  IElementType LINE_COMMENT = new SDToken("LINE_COMMENT");
   IElementType QUOTED_TEXT = new SDToken("QUOTED_TEXT");
-  IElementType REF_KEYWORD = new SDToken("!ref");
-  IElementType RELATIONSHIP_KEYWORD = new SDToken("->");
-  IElementType ROUTING_KEYWORD = new SDToken("routing");
-  IElementType SCRIPT_KEYWORD = new SDToken("!script");
   IElementType SCRIPT_TEXT = new SDToken("SCRIPT_TEXT");
-  IElementType SHAPE_KEYWORD = new SDToken("shape");
-  IElementType SOFTWARE_SYSTEM_INSTANCE_KEYWORD = new SDToken("softwareSystemInstance");
-  IElementType SOFTWARE_SYSTEM_KEYWORD = new SDToken("softwareSystem");
-  IElementType STROKEWIDTH_KEYWORD = new SDToken("strokeWidth");
-  IElementType STROKE_KEYWORD = new SDToken("stroke");
-  IElementType STYLES_KEYWORD = new SDToken("styles");
-  IElementType STYLE_KEYWORD = new SDToken("style");
-  IElementType SYSTEM_CONTEXT_KEYWORD = new SDToken("systemContext");
-  IElementType SYSTEM_LANDSCAPE_KEYWORD = new SDToken("systemLandscape");
-  IElementType TAGS_KEYWORD = new SDToken("tags");
-  IElementType TECHNOLOGY_KEYWORD = new SDToken("technology");
-  IElementType TERMINOLOGY_KEYWORD = new SDToken("terminology");
-  IElementType THEME_KEYWORD = new SDToken("theme");
-  IElementType THICKNESS_KEYWORD = new SDToken("thickness");
-  IElementType TITLE_KEYWORD = new SDToken("title");
   IElementType UNQUOTED_TEXT = new SDToken("UNQUOTED_TEXT");
-  IElementType URL_KEYWORD = new SDToken("url");
-  IElementType USERS_KEYWORD = new SDToken("users");
-  IElementType VIEWS_KEYWORD = new SDToken("views");
-  IElementType WIDTH_KEYWORD = new SDToken("width");
-  IElementType WORKSPACE_KEYWORD = new SDToken("workspace");
 
   class Factory {
     public static PsiElement createElement(ASTNode node) {
       IElementType type = node.getElementType();
-      if (type == ARGUMENT) {
+      if (type == ANIMATION_KEYWORD) {
+        return new SDAnimationKeywordImpl(node);
+      }
+      else if (type == ANIMATION_STATEMENT) {
+        return new SDAnimationStatementImpl(node);
+      }
+      else if (type == ARGUMENT) {
         return new SDArgumentImpl(node);
       }
+      else if (type == BLOCK) {
+        return new SDBlockImpl(node);
+      }
+      else if (type == BLOCK_COMMENT_STATEMENT) {
+        return new SDBlockCommentStatementImpl(node);
+      }
       else if (type == BLOCK_STATEMENT) {
         return new SDBlockStatementImpl(node);
       }
-      else if (type == EXPLICIT_RELATIONSHIP) {
-        return new SDExplicitRelationshipImpl(node);
+      else if (type == EXPLICIT_RELATIONSHIP_STATEMENT) {
+        return new SDExplicitRelationshipStatementImpl(node);
       }
-      else if (type == IDENTIFIER_NAME) {
-        return new SDIdentifierNameImpl(node);
+      else if (type == IDENTIFIER_ASSIGNMENT_STATEMENT) {
+        return new SDIdentifierAssignmentStatementImpl(node);
       }
-      else if (type == IDENTIFIER_REFERENCES) {
-        return new SDIdentifierReferencesImpl(node);
+      else if (type == IDENTIFIER_REFERENCE) {
+        return new SDIdentifierReferenceImpl(node);
       }
-      else if (type == IMPLICIT_RELATIONSHIP) {
-        return new SDImplicitRelationshipImpl(node);
+      else if (type == IDENTIFIER_REFERENCES_STATEMENT) {
+        return new SDIdentifierReferencesStatementImpl(node);
       }
-      else if (type == KEY) {
-        return new SDKeyImpl(node);
+      else if (type == IMPLICIT_RELATIONSHIP_STATEMENT) {
+        return new SDImplicitRelationshipStatementImpl(node);
       }
       else if (type == KEYWORD) {
         return new SDKeywordImpl(node);
       }
-      else if (type == KEYWORD_WITH_PROPERTY_BLOCK) {
-        return new SDKeywordWithPropertyBlockImpl(node);
+      else if (type == LINE_COMMENT_STATEMENT) {
+        return new SDLineCommentStatementImpl(node);
+      }
+      else if (type == PROPERTIES_BLOCK) {
+        return new SDPropertiesBlockImpl(node);
+      }
+      else if (type == PROPERTIES_KEYWORD) {
+        return new SDPropertiesKeywordImpl(node);
+      }
+      else if (type == PROPERTIES_STATEMENT) {
+        return new SDPropertiesStatementImpl(node);
       }
-      else if (type == KEY_VALUE_PAIR) {
-        return new SDKeyValuePairImpl(node);
+      else if (type == PROPERTY_DEFINITION) {
+        return new SDPropertyDefinitionImpl(node);
       }
-      else if (type == PROPERTY_BLOCK_STATEMENT) {
-        return new SDPropertyBlockStatementImpl(node);
+      else if (type == PROPERTY_KEY) {
+        return new SDPropertyKeyImpl(node);
+      }
+      else if (type == PROPERTY_VALUE) {
+        return new SDPropertyValueImpl(node);
+      }
+      else if (type == RELATIONSHIP_DESTINATION) {
+        return new SDRelationshipDestinationImpl(node);
+      }
+      else if (type == RELATIONSHIP_KEYWORD) {
+        return new SDRelationshipKeywordImpl(node);
+      }
+      else if (type == RELATIONSHIP_SOURCE) {
+        return new SDRelationshipSourceImpl(node);
       }
       else if (type == SCRIPT_BLOCK) {
         return new SDScriptBlockImpl(node);
       }
-      else if (type == SCRIPT_CONTENTS) {
-        return new SDScriptContentsImpl(node);
+      else if (type == SCRIPT_KEYWORD) {
+        return new SDScriptKeywordImpl(node);
+      }
+      else if (type == SCRIPT_STATEMENT) {
+        return new SDScriptStatementImpl(node);
       }
       else if (type == SINGLE_LINE_STATEMENT) {
         return new SDSingleLineStatementImpl(node);
       }
-      else if (type == VALUE) {
-        return new SDValueImpl(node);
-      }
       throw new AssertionError("Unknown element type: " + type);
     }
   }
diff --git a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDVisitor.java b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDVisitor.java
index f86882f..76e337c 100644
--- a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDVisitor.java
+++ b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/SDVisitor.java
@@ -7,47 +7,91 @@
 
 public class SDVisitor extends PsiElementVisitor {
 
+  public void visitAnimationKeyword(@NotNull SDAnimationKeyword o) {
+    visitPsiElement(o);
+  }
+
+  public void visitAnimationStatement(@NotNull SDAnimationStatement o) {
+    visitStatement(o);
+  }
+
   public void visitArgument(@NotNull SDArgument o) {
     visitPsiElement(o);
   }
 
+  public void visitBlock(@NotNull SDBlock o) {
+    visitPsiElement(o);
+  }
+
+  public void visitBlockCommentStatement(@NotNull SDBlockCommentStatement o) {
+    visitStatement(o);
+  }
+
   public void visitBlockStatement(@NotNull SDBlockStatement o) {
+    visitStatement(o);
+  }
+
+  public void visitExplicitRelationshipStatement(@NotNull SDExplicitRelationshipStatement o) {
+    visitStatement(o);
+  }
+
+  public void visitIdentifierAssignmentStatement(@NotNull SDIdentifierAssignmentStatement o) {
+    visitStatement(o);
+  }
+
+  public void visitIdentifierReference(@NotNull SDIdentifierReference o) {
     visitPsiElement(o);
   }
 
-  public void visitExplicitRelationship(@NotNull SDExplicitRelationship o) {
+  public void visitIdentifierReferencesStatement(@NotNull SDIdentifierReferencesStatement o) {
+    visitStatement(o);
+  }
+
+  public void visitImplicitRelationshipStatement(@NotNull SDImplicitRelationshipStatement o) {
+    visitStatement(o);
+  }
+
+  public void visitKeyword(@NotNull SDKeyword o) {
     visitPsiElement(o);
   }
 
-  public void visitIdentifierName(@NotNull SDIdentifierName o) {
+  public void visitLineCommentStatement(@NotNull SDLineCommentStatement o) {
+    visitStatement(o);
+  }
+
+  public void visitPropertiesBlock(@NotNull SDPropertiesBlock o) {
     visitPsiElement(o);
   }
 
-  public void visitIdentifierReferences(@NotNull SDIdentifierReferences o) {
+  public void visitPropertiesKeyword(@NotNull SDPropertiesKeyword o) {
     visitPsiElement(o);
   }
 
-  public void visitImplicitRelationship(@NotNull SDImplicitRelationship o) {
+  public void visitPropertiesStatement(@NotNull SDPropertiesStatement o) {
+    visitStatement(o);
+  }
+
+  public void visitPropertyDefinition(@NotNull SDPropertyDefinition o) {
     visitPsiElement(o);
   }
 
-  public void visitKey(@NotNull SDKey o) {
+  public void visitPropertyKey(@NotNull SDPropertyKey o) {
     visitPsiElement(o);
   }
 
-  public void visitKeyValuePair(@NotNull SDKeyValuePair o) {
+  public void visitPropertyValue(@NotNull SDPropertyValue o) {
     visitPsiElement(o);
   }
 
-  public void visitKeyword(@NotNull SDKeyword o) {
+  public void visitRelationshipDestination(@NotNull SDRelationshipDestination o) {
     visitPsiElement(o);
   }
 
-  public void visitKeywordWithPropertyBlock(@NotNull SDKeywordWithPropertyBlock o) {
+  public void visitRelationshipKeyword(@NotNull SDRelationshipKeyword o) {
     visitPsiElement(o);
   }
 
-  public void visitPropertyBlockStatement(@NotNull SDPropertyBlockStatement o) {
+  public void visitRelationshipSource(@NotNull SDRelationshipSource o) {
     visitPsiElement(o);
   }
 
@@ -55,15 +99,19 @@ public void visitScriptBlock(@NotNull SDScriptBlock o) {
     visitPsiElement(o);
   }
 
-  public void visitScriptContents(@NotNull SDScriptContents o) {
+  public void visitScriptKeyword(@NotNull SDScriptKeyword o) {
     visitPsiElement(o);
   }
 
+  public void visitScriptStatement(@NotNull SDScriptStatement o) {
+    visitStatement(o);
+  }
+
   public void visitSingleLineStatement(@NotNull SDSingleLineStatement o) {
-    visitPsiElement(o);
+    visitStatement(o);
   }
 
-  public void visitValue(@NotNull SDValue o) {
+  public void visitStatement(@NotNull SDStatement o) {
     visitPsiElement(o);
   }
 
diff --git a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDScriptContentsImpl.java b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDAnimationKeywordImpl.java
similarity index 79%
rename from src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDScriptContentsImpl.java
rename to src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDAnimationKeywordImpl.java
index ea4db26..4a54c9e 100644
--- a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDScriptContentsImpl.java
+++ b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDAnimationKeywordImpl.java
@@ -11,14 +11,14 @@
 import com.intellij.extapi.psi.ASTWrapperPsiElement;
 import nl.dirkgroot.structurizr.dsl.psi.*;
 
-public class SDScriptContentsImpl extends ASTWrapperPsiElement implements SDScriptContents {
+public class SDAnimationKeywordImpl extends ASTWrapperPsiElement implements SDAnimationKeyword {
 
-  public SDScriptContentsImpl(@NotNull ASTNode node) {
+  public SDAnimationKeywordImpl(@NotNull ASTNode node) {
     super(node);
   }
 
   public void accept(@NotNull SDVisitor visitor) {
-    visitor.visitScriptContents(this);
+    visitor.visitAnimationKeyword(this);
   }
 
   @Override
diff --git a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDAnimationStatementImpl.java b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDAnimationStatementImpl.java
new file mode 100644
index 0000000..08d88e0
--- /dev/null
+++ b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDAnimationStatementImpl.java
@@ -0,0 +1,42 @@
+// This is a generated file. Not intended for manual editing.
+package nl.dirkgroot.structurizr.dsl.psi.impl;
+
+import java.util.List;
+import org.jetbrains.annotations.*;
+import com.intellij.lang.ASTNode;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiElementVisitor;
+import com.intellij.psi.util.PsiTreeUtil;
+import static nl.dirkgroot.structurizr.dsl.psi.SDTypes.*;
+import nl.dirkgroot.structurizr.dsl.psi.*;
+
+public class SDAnimationStatementImpl extends SDStatementImpl implements SDAnimationStatement {
+
+  public SDAnimationStatementImpl(@NotNull ASTNode node) {
+    super(node);
+  }
+
+  @Override
+  public void accept(@NotNull SDVisitor visitor) {
+    visitor.visitAnimationStatement(this);
+  }
+
+  @Override
+  public void accept(@NotNull PsiElementVisitor visitor) {
+    if (visitor instanceof SDVisitor) accept((SDVisitor)visitor);
+    else super.accept(visitor);
+  }
+
+  @Override
+  @NotNull
+  public SDAnimationKeyword getAnimationKeyword() {
+    return findNotNullChildByClass(SDAnimationKeyword.class);
+  }
+
+  @Override
+  @NotNull
+  public List<SDStatement> getStatementList() {
+    return PsiTreeUtil.getChildrenOfTypeAsList(this, SDStatement.class);
+  }
+
+}
diff --git a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDBlockCommentStatementImpl.java b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDBlockCommentStatementImpl.java
new file mode 100644
index 0000000..d037305
--- /dev/null
+++ b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDBlockCommentStatementImpl.java
@@ -0,0 +1,30 @@
+// This is a generated file. Not intended for manual editing.
+package nl.dirkgroot.structurizr.dsl.psi.impl;
+
+import java.util.List;
+import org.jetbrains.annotations.*;
+import com.intellij.lang.ASTNode;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiElementVisitor;
+import com.intellij.psi.util.PsiTreeUtil;
+import static nl.dirkgroot.structurizr.dsl.psi.SDTypes.*;
+import nl.dirkgroot.structurizr.dsl.psi.*;
+
+public class SDBlockCommentStatementImpl extends SDStatementImpl implements SDBlockCommentStatement {
+
+  public SDBlockCommentStatementImpl(@NotNull ASTNode node) {
+    super(node);
+  }
+
+  @Override
+  public void accept(@NotNull SDVisitor visitor) {
+    visitor.visitBlockCommentStatement(this);
+  }
+
+  @Override
+  public void accept(@NotNull PsiElementVisitor visitor) {
+    if (visitor instanceof SDVisitor) accept((SDVisitor)visitor);
+    else super.accept(visitor);
+  }
+
+}
diff --git a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDBlockImpl.java b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDBlockImpl.java
new file mode 100644
index 0000000..7425f23
--- /dev/null
+++ b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDBlockImpl.java
@@ -0,0 +1,36 @@
+// This is a generated file. Not intended for manual editing.
+package nl.dirkgroot.structurizr.dsl.psi.impl;
+
+import java.util.List;
+import org.jetbrains.annotations.*;
+import com.intellij.lang.ASTNode;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiElementVisitor;
+import com.intellij.psi.util.PsiTreeUtil;
+import static nl.dirkgroot.structurizr.dsl.psi.SDTypes.*;
+import com.intellij.extapi.psi.ASTWrapperPsiElement;
+import nl.dirkgroot.structurizr.dsl.psi.*;
+
+public class SDBlockImpl extends ASTWrapperPsiElement implements SDBlock {
+
+  public SDBlockImpl(@NotNull ASTNode node) {
+    super(node);
+  }
+
+  public void accept(@NotNull SDVisitor visitor) {
+    visitor.visitBlock(this);
+  }
+
+  @Override
+  public void accept(@NotNull PsiElementVisitor visitor) {
+    if (visitor instanceof SDVisitor) accept((SDVisitor)visitor);
+    else super.accept(visitor);
+  }
+
+  @Override
+  @NotNull
+  public List<SDStatement> getStatementList() {
+    return PsiTreeUtil.getChildrenOfTypeAsList(this, SDStatement.class);
+  }
+
+}
diff --git a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDBlockStatementImpl.java b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDBlockStatementImpl.java
index 985ce61..b9735d9 100644
--- a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDBlockStatementImpl.java
+++ b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDBlockStatementImpl.java
@@ -8,15 +8,15 @@
 import com.intellij.psi.PsiElementVisitor;
 import com.intellij.psi.util.PsiTreeUtil;
 import static nl.dirkgroot.structurizr.dsl.psi.SDTypes.*;
-import com.intellij.extapi.psi.ASTWrapperPsiElement;
 import nl.dirkgroot.structurizr.dsl.psi.*;
 
-public class SDBlockStatementImpl extends ASTWrapperPsiElement implements SDBlockStatement {
+public class SDBlockStatementImpl extends SDStatementImpl implements SDBlockStatement {
 
   public SDBlockStatementImpl(@NotNull ASTNode node) {
     super(node);
   }
 
+  @Override
   public void accept(@NotNull SDVisitor visitor) {
     visitor.visitBlockStatement(this);
   }
@@ -35,32 +35,8 @@ public List<SDArgument> getArgumentList() {
 
   @Override
   @NotNull
-  public List<SDBlockStatement> getBlockStatementList() {
-    return PsiTreeUtil.getChildrenOfTypeAsList(this, SDBlockStatement.class);
-  }
-
-  @Override
-  @NotNull
-  public List<SDExplicitRelationship> getExplicitRelationshipList() {
-    return PsiTreeUtil.getChildrenOfTypeAsList(this, SDExplicitRelationship.class);
-  }
-
-  @Override
-  @Nullable
-  public SDIdentifierName getIdentifierName() {
-    return findChildByClass(SDIdentifierName.class);
-  }
-
-  @Override
-  @NotNull
-  public List<SDIdentifierReferences> getIdentifierReferencesList() {
-    return PsiTreeUtil.getChildrenOfTypeAsList(this, SDIdentifierReferences.class);
-  }
-
-  @Override
-  @NotNull
-  public List<SDImplicitRelationship> getImplicitRelationshipList() {
-    return PsiTreeUtil.getChildrenOfTypeAsList(this, SDImplicitRelationship.class);
+  public SDBlock getBlock() {
+    return findNotNullChildByClass(SDBlock.class);
   }
 
   @Override
@@ -69,22 +45,4 @@ public SDKeyword getKeyword() {
     return findNotNullChildByClass(SDKeyword.class);
   }
 
-  @Override
-  @NotNull
-  public List<SDPropertyBlockStatement> getPropertyBlockStatementList() {
-    return PsiTreeUtil.getChildrenOfTypeAsList(this, SDPropertyBlockStatement.class);
-  }
-
-  @Override
-  @NotNull
-  public List<SDScriptBlock> getScriptBlockList() {
-    return PsiTreeUtil.getChildrenOfTypeAsList(this, SDScriptBlock.class);
-  }
-
-  @Override
-  @NotNull
-  public List<SDSingleLineStatement> getSingleLineStatementList() {
-    return PsiTreeUtil.getChildrenOfTypeAsList(this, SDSingleLineStatement.class);
-  }
-
 }
diff --git a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDExplicitRelationshipStatementImpl.java b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDExplicitRelationshipStatementImpl.java
new file mode 100644
index 0000000..c0707ed
--- /dev/null
+++ b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDExplicitRelationshipStatementImpl.java
@@ -0,0 +1,60 @@
+// This is a generated file. Not intended for manual editing.
+package nl.dirkgroot.structurizr.dsl.psi.impl;
+
+import java.util.List;
+import org.jetbrains.annotations.*;
+import com.intellij.lang.ASTNode;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiElementVisitor;
+import com.intellij.psi.util.PsiTreeUtil;
+import static nl.dirkgroot.structurizr.dsl.psi.SDTypes.*;
+import nl.dirkgroot.structurizr.dsl.psi.*;
+
+public class SDExplicitRelationshipStatementImpl extends SDStatementImpl implements SDExplicitRelationshipStatement {
+
+  public SDExplicitRelationshipStatementImpl(@NotNull ASTNode node) {
+    super(node);
+  }
+
+  @Override
+  public void accept(@NotNull SDVisitor visitor) {
+    visitor.visitExplicitRelationshipStatement(this);
+  }
+
+  @Override
+  public void accept(@NotNull PsiElementVisitor visitor) {
+    if (visitor instanceof SDVisitor) accept((SDVisitor)visitor);
+    else super.accept(visitor);
+  }
+
+  @Override
+  @NotNull
+  public List<SDArgument> getArgumentList() {
+    return PsiTreeUtil.getChildrenOfTypeAsList(this, SDArgument.class);
+  }
+
+  @Override
+  @Nullable
+  public SDBlock getBlock() {
+    return findChildByClass(SDBlock.class);
+  }
+
+  @Override
+  @NotNull
+  public SDRelationshipDestination getRelationshipDestination() {
+    return findNotNullChildByClass(SDRelationshipDestination.class);
+  }
+
+  @Override
+  @NotNull
+  public SDRelationshipKeyword getRelationshipKeyword() {
+    return findNotNullChildByClass(SDRelationshipKeyword.class);
+  }
+
+  @Override
+  @NotNull
+  public SDRelationshipSource getRelationshipSource() {
+    return findNotNullChildByClass(SDRelationshipSource.class);
+  }
+
+}
diff --git a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDIdentifierAssignmentStatementImpl.java b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDIdentifierAssignmentStatementImpl.java
new file mode 100644
index 0000000..2a741cf
--- /dev/null
+++ b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDIdentifierAssignmentStatementImpl.java
@@ -0,0 +1,36 @@
+// This is a generated file. Not intended for manual editing.
+package nl.dirkgroot.structurizr.dsl.psi.impl;
+
+import java.util.List;
+import org.jetbrains.annotations.*;
+import com.intellij.lang.ASTNode;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiElementVisitor;
+import com.intellij.psi.util.PsiTreeUtil;
+import static nl.dirkgroot.structurizr.dsl.psi.SDTypes.*;
+import nl.dirkgroot.structurizr.dsl.psi.*;
+
+public class SDIdentifierAssignmentStatementImpl extends SDStatementImpl implements SDIdentifierAssignmentStatement {
+
+  public SDIdentifierAssignmentStatementImpl(@NotNull ASTNode node) {
+    super(node);
+  }
+
+  @Override
+  public void accept(@NotNull SDVisitor visitor) {
+    visitor.visitIdentifierAssignmentStatement(this);
+  }
+
+  @Override
+  public void accept(@NotNull PsiElementVisitor visitor) {
+    if (visitor instanceof SDVisitor) accept((SDVisitor)visitor);
+    else super.accept(visitor);
+  }
+
+  @Override
+  @NotNull
+  public SDIdentifierReference getIdentifierReference() {
+    return findNotNullChildByClass(SDIdentifierReference.class);
+  }
+
+}
diff --git a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDIdentifierReferenceImpl.java b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDIdentifierReferenceImpl.java
new file mode 100644
index 0000000..042751a
--- /dev/null
+++ b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDIdentifierReferenceImpl.java
@@ -0,0 +1,30 @@
+// This is a generated file. Not intended for manual editing.
+package nl.dirkgroot.structurizr.dsl.psi.impl;
+
+import java.util.List;
+import org.jetbrains.annotations.*;
+import com.intellij.lang.ASTNode;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiElementVisitor;
+import com.intellij.psi.util.PsiTreeUtil;
+import static nl.dirkgroot.structurizr.dsl.psi.SDTypes.*;
+import com.intellij.extapi.psi.ASTWrapperPsiElement;
+import nl.dirkgroot.structurizr.dsl.psi.*;
+
+public class SDIdentifierReferenceImpl extends ASTWrapperPsiElement implements SDIdentifierReference {
+
+  public SDIdentifierReferenceImpl(@NotNull ASTNode node) {
+    super(node);
+  }
+
+  public void accept(@NotNull SDVisitor visitor) {
+    visitor.visitIdentifierReference(this);
+  }
+
+  @Override
+  public void accept(@NotNull PsiElementVisitor visitor) {
+    if (visitor instanceof SDVisitor) accept((SDVisitor)visitor);
+    else super.accept(visitor);
+  }
+
+}
diff --git a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDIdentifierReferencesImpl.java b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDIdentifierReferencesStatementImpl.java
similarity index 69%
rename from src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDIdentifierReferencesImpl.java
rename to src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDIdentifierReferencesStatementImpl.java
index 0e24d5f..ab002cc 100644
--- a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDIdentifierReferencesImpl.java
+++ b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDIdentifierReferencesStatementImpl.java
@@ -8,17 +8,17 @@
 import com.intellij.psi.PsiElementVisitor;
 import com.intellij.psi.util.PsiTreeUtil;
 import static nl.dirkgroot.structurizr.dsl.psi.SDTypes.*;
-import com.intellij.extapi.psi.ASTWrapperPsiElement;
 import nl.dirkgroot.structurizr.dsl.psi.*;
 
-public class SDIdentifierReferencesImpl extends ASTWrapperPsiElement implements SDIdentifierReferences {
+public class SDIdentifierReferencesStatementImpl extends SDStatementImpl implements SDIdentifierReferencesStatement {
 
-  public SDIdentifierReferencesImpl(@NotNull ASTNode node) {
+  public SDIdentifierReferencesStatementImpl(@NotNull ASTNode node) {
     super(node);
   }
 
+  @Override
   public void accept(@NotNull SDVisitor visitor) {
-    visitor.visitIdentifierReferences(this);
+    visitor.visitIdentifierReferencesStatement(this);
   }
 
   @Override
@@ -29,8 +29,8 @@ public void accept(@NotNull PsiElementVisitor visitor) {
 
   @Override
   @NotNull
-  public List<SDIdentifierName> getIdentifierNameList() {
-    return PsiTreeUtil.getChildrenOfTypeAsList(this, SDIdentifierName.class);
+  public List<SDIdentifierReference> getIdentifierReferenceList() {
+    return PsiTreeUtil.getChildrenOfTypeAsList(this, SDIdentifierReference.class);
   }
 
 }
diff --git a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDImplicitRelationshipStatementImpl.java b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDImplicitRelationshipStatementImpl.java
new file mode 100644
index 0000000..7d1216f
--- /dev/null
+++ b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDImplicitRelationshipStatementImpl.java
@@ -0,0 +1,54 @@
+// This is a generated file. Not intended for manual editing.
+package nl.dirkgroot.structurizr.dsl.psi.impl;
+
+import java.util.List;
+import org.jetbrains.annotations.*;
+import com.intellij.lang.ASTNode;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiElementVisitor;
+import com.intellij.psi.util.PsiTreeUtil;
+import static nl.dirkgroot.structurizr.dsl.psi.SDTypes.*;
+import nl.dirkgroot.structurizr.dsl.psi.*;
+
+public class SDImplicitRelationshipStatementImpl extends SDStatementImpl implements SDImplicitRelationshipStatement {
+
+  public SDImplicitRelationshipStatementImpl(@NotNull ASTNode node) {
+    super(node);
+  }
+
+  @Override
+  public void accept(@NotNull SDVisitor visitor) {
+    visitor.visitImplicitRelationshipStatement(this);
+  }
+
+  @Override
+  public void accept(@NotNull PsiElementVisitor visitor) {
+    if (visitor instanceof SDVisitor) accept((SDVisitor)visitor);
+    else super.accept(visitor);
+  }
+
+  @Override
+  @NotNull
+  public List<SDArgument> getArgumentList() {
+    return PsiTreeUtil.getChildrenOfTypeAsList(this, SDArgument.class);
+  }
+
+  @Override
+  @Nullable
+  public SDBlock getBlock() {
+    return findChildByClass(SDBlock.class);
+  }
+
+  @Override
+  @NotNull
+  public SDRelationshipDestination getRelationshipDestination() {
+    return findNotNullChildByClass(SDRelationshipDestination.class);
+  }
+
+  @Override
+  @NotNull
+  public SDRelationshipKeyword getRelationshipKeyword() {
+    return findNotNullChildByClass(SDRelationshipKeyword.class);
+  }
+
+}
diff --git a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDLineCommentStatementImpl.java b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDLineCommentStatementImpl.java
new file mode 100644
index 0000000..4b7605c
--- /dev/null
+++ b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDLineCommentStatementImpl.java
@@ -0,0 +1,30 @@
+// This is a generated file. Not intended for manual editing.
+package nl.dirkgroot.structurizr.dsl.psi.impl;
+
+import java.util.List;
+import org.jetbrains.annotations.*;
+import com.intellij.lang.ASTNode;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiElementVisitor;
+import com.intellij.psi.util.PsiTreeUtil;
+import static nl.dirkgroot.structurizr.dsl.psi.SDTypes.*;
+import nl.dirkgroot.structurizr.dsl.psi.*;
+
+public class SDLineCommentStatementImpl extends SDStatementImpl implements SDLineCommentStatement {
+
+  public SDLineCommentStatementImpl(@NotNull ASTNode node) {
+    super(node);
+  }
+
+  @Override
+  public void accept(@NotNull SDVisitor visitor) {
+    visitor.visitLineCommentStatement(this);
+  }
+
+  @Override
+  public void accept(@NotNull PsiElementVisitor visitor) {
+    if (visitor instanceof SDVisitor) accept((SDVisitor)visitor);
+    else super.accept(visitor);
+  }
+
+}
diff --git a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDKeyValuePairImpl.java b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDPropertiesBlockImpl.java
similarity index 67%
rename from src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDKeyValuePairImpl.java
rename to src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDPropertiesBlockImpl.java
index f835594..a255b3c 100644
--- a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDKeyValuePairImpl.java
+++ b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDPropertiesBlockImpl.java
@@ -11,14 +11,14 @@
 import com.intellij.extapi.psi.ASTWrapperPsiElement;
 import nl.dirkgroot.structurizr.dsl.psi.*;
 
-public class SDKeyValuePairImpl extends ASTWrapperPsiElement implements SDKeyValuePair {
+public class SDPropertiesBlockImpl extends ASTWrapperPsiElement implements SDPropertiesBlock {
 
-  public SDKeyValuePairImpl(@NotNull ASTNode node) {
+  public SDPropertiesBlockImpl(@NotNull ASTNode node) {
     super(node);
   }
 
   public void accept(@NotNull SDVisitor visitor) {
-    visitor.visitKeyValuePair(this);
+    visitor.visitPropertiesBlock(this);
   }
 
   @Override
@@ -29,14 +29,8 @@ public void accept(@NotNull PsiElementVisitor visitor) {
 
   @Override
   @NotNull
-  public SDKey getKey() {
-    return findNotNullChildByClass(SDKey.class);
-  }
-
-  @Override
-  @NotNull
-  public SDValue getValue() {
-    return findNotNullChildByClass(SDValue.class);
+  public List<SDPropertyDefinition> getPropertyDefinitionList() {
+    return PsiTreeUtil.getChildrenOfTypeAsList(this, SDPropertyDefinition.class);
   }
 
 }
diff --git a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDPropertiesKeywordImpl.java b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDPropertiesKeywordImpl.java
new file mode 100644
index 0000000..c358fa5
--- /dev/null
+++ b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDPropertiesKeywordImpl.java
@@ -0,0 +1,30 @@
+// This is a generated file. Not intended for manual editing.
+package nl.dirkgroot.structurizr.dsl.psi.impl;
+
+import java.util.List;
+import org.jetbrains.annotations.*;
+import com.intellij.lang.ASTNode;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiElementVisitor;
+import com.intellij.psi.util.PsiTreeUtil;
+import static nl.dirkgroot.structurizr.dsl.psi.SDTypes.*;
+import com.intellij.extapi.psi.ASTWrapperPsiElement;
+import nl.dirkgroot.structurizr.dsl.psi.*;
+
+public class SDPropertiesKeywordImpl extends ASTWrapperPsiElement implements SDPropertiesKeyword {
+
+  public SDPropertiesKeywordImpl(@NotNull ASTNode node) {
+    super(node);
+  }
+
+  public void accept(@NotNull SDVisitor visitor) {
+    visitor.visitPropertiesKeyword(this);
+  }
+
+  @Override
+  public void accept(@NotNull PsiElementVisitor visitor) {
+    if (visitor instanceof SDVisitor) accept((SDVisitor)visitor);
+    else super.accept(visitor);
+  }
+
+}
diff --git a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDPropertiesStatementImpl.java b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDPropertiesStatementImpl.java
new file mode 100644
index 0000000..e067b2b
--- /dev/null
+++ b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDPropertiesStatementImpl.java
@@ -0,0 +1,42 @@
+// This is a generated file. Not intended for manual editing.
+package nl.dirkgroot.structurizr.dsl.psi.impl;
+
+import java.util.List;
+import org.jetbrains.annotations.*;
+import com.intellij.lang.ASTNode;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiElementVisitor;
+import com.intellij.psi.util.PsiTreeUtil;
+import static nl.dirkgroot.structurizr.dsl.psi.SDTypes.*;
+import nl.dirkgroot.structurizr.dsl.psi.*;
+
+public class SDPropertiesStatementImpl extends SDStatementImpl implements SDPropertiesStatement {
+
+  public SDPropertiesStatementImpl(@NotNull ASTNode node) {
+    super(node);
+  }
+
+  @Override
+  public void accept(@NotNull SDVisitor visitor) {
+    visitor.visitPropertiesStatement(this);
+  }
+
+  @Override
+  public void accept(@NotNull PsiElementVisitor visitor) {
+    if (visitor instanceof SDVisitor) accept((SDVisitor)visitor);
+    else super.accept(visitor);
+  }
+
+  @Override
+  @NotNull
+  public SDPropertiesBlock getPropertiesBlock() {
+    return findNotNullChildByClass(SDPropertiesBlock.class);
+  }
+
+  @Override
+  @NotNull
+  public SDPropertiesKeyword getPropertiesKeyword() {
+    return findNotNullChildByClass(SDPropertiesKeyword.class);
+  }
+
+}
diff --git a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDPropertyBlockStatementImpl.java b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDPropertyBlockStatementImpl.java
deleted file mode 100644
index 66644e3..0000000
--- a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDPropertyBlockStatementImpl.java
+++ /dev/null
@@ -1,42 +0,0 @@
-// This is a generated file. Not intended for manual editing.
-package nl.dirkgroot.structurizr.dsl.psi.impl;
-
-import java.util.List;
-import org.jetbrains.annotations.*;
-import com.intellij.lang.ASTNode;
-import com.intellij.psi.PsiElement;
-import com.intellij.psi.PsiElementVisitor;
-import com.intellij.psi.util.PsiTreeUtil;
-import static nl.dirkgroot.structurizr.dsl.psi.SDTypes.*;
-import com.intellij.extapi.psi.ASTWrapperPsiElement;
-import nl.dirkgroot.structurizr.dsl.psi.*;
-
-public class SDPropertyBlockStatementImpl extends ASTWrapperPsiElement implements SDPropertyBlockStatement {
-
-  public SDPropertyBlockStatementImpl(@NotNull ASTNode node) {
-    super(node);
-  }
-
-  public void accept(@NotNull SDVisitor visitor) {
-    visitor.visitPropertyBlockStatement(this);
-  }
-
-  @Override
-  public void accept(@NotNull PsiElementVisitor visitor) {
-    if (visitor instanceof SDVisitor) accept((SDVisitor)visitor);
-    else super.accept(visitor);
-  }
-
-  @Override
-  @NotNull
-  public List<SDKeyValuePair> getKeyValuePairList() {
-    return PsiTreeUtil.getChildrenOfTypeAsList(this, SDKeyValuePair.class);
-  }
-
-  @Override
-  @NotNull
-  public SDKeywordWithPropertyBlock getKeywordWithPropertyBlock() {
-    return findNotNullChildByClass(SDKeywordWithPropertyBlock.class);
-  }
-
-}
diff --git a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDImplicitRelationshipImpl.java b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDPropertyDefinitionImpl.java
similarity index 64%
rename from src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDImplicitRelationshipImpl.java
rename to src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDPropertyDefinitionImpl.java
index 077cd41..5dbaf4d 100644
--- a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDImplicitRelationshipImpl.java
+++ b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDPropertyDefinitionImpl.java
@@ -11,14 +11,14 @@
 import com.intellij.extapi.psi.ASTWrapperPsiElement;
 import nl.dirkgroot.structurizr.dsl.psi.*;
 
-public class SDImplicitRelationshipImpl extends ASTWrapperPsiElement implements SDImplicitRelationship {
+public class SDPropertyDefinitionImpl extends ASTWrapperPsiElement implements SDPropertyDefinition {
 
-  public SDImplicitRelationshipImpl(@NotNull ASTNode node) {
+  public SDPropertyDefinitionImpl(@NotNull ASTNode node) {
     super(node);
   }
 
   public void accept(@NotNull SDVisitor visitor) {
-    visitor.visitImplicitRelationship(this);
+    visitor.visitPropertyDefinition(this);
   }
 
   @Override
@@ -29,14 +29,14 @@ public void accept(@NotNull PsiElementVisitor visitor) {
 
   @Override
   @NotNull
-  public List<SDArgument> getArgumentList() {
-    return PsiTreeUtil.getChildrenOfTypeAsList(this, SDArgument.class);
+  public SDPropertyKey getPropertyKey() {
+    return findNotNullChildByClass(SDPropertyKey.class);
   }
 
   @Override
   @NotNull
-  public SDIdentifierName getIdentifierName() {
-    return findNotNullChildByClass(SDIdentifierName.class);
+  public SDPropertyValue getPropertyValue() {
+    return findNotNullChildByClass(SDPropertyValue.class);
   }
 
 }
diff --git a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDKeyImpl.java b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDPropertyKeyImpl.java
similarity index 80%
rename from src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDKeyImpl.java
rename to src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDPropertyKeyImpl.java
index 10f6c99..944a2fd 100644
--- a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDKeyImpl.java
+++ b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDPropertyKeyImpl.java
@@ -11,14 +11,14 @@
 import com.intellij.extapi.psi.ASTWrapperPsiElement;
 import nl.dirkgroot.structurizr.dsl.psi.*;
 
-public class SDKeyImpl extends ASTWrapperPsiElement implements SDKey {
+public class SDPropertyKeyImpl extends ASTWrapperPsiElement implements SDPropertyKey {
 
-  public SDKeyImpl(@NotNull ASTNode node) {
+  public SDPropertyKeyImpl(@NotNull ASTNode node) {
     super(node);
   }
 
   public void accept(@NotNull SDVisitor visitor) {
-    visitor.visitKey(this);
+    visitor.visitPropertyKey(this);
   }
 
   @Override
diff --git a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDValueImpl.java b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDPropertyValueImpl.java
similarity index 80%
rename from src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDValueImpl.java
rename to src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDPropertyValueImpl.java
index de39d40..1e0aec5 100644
--- a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDValueImpl.java
+++ b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDPropertyValueImpl.java
@@ -11,14 +11,14 @@
 import com.intellij.extapi.psi.ASTWrapperPsiElement;
 import nl.dirkgroot.structurizr.dsl.psi.*;
 
-public class SDValueImpl extends ASTWrapperPsiElement implements SDValue {
+public class SDPropertyValueImpl extends ASTWrapperPsiElement implements SDPropertyValue {
 
-  public SDValueImpl(@NotNull ASTNode node) {
+  public SDPropertyValueImpl(@NotNull ASTNode node) {
     super(node);
   }
 
   public void accept(@NotNull SDVisitor visitor) {
-    visitor.visitValue(this);
+    visitor.visitPropertyValue(this);
   }
 
   @Override
diff --git a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDRelationshipDestinationImpl.java b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDRelationshipDestinationImpl.java
new file mode 100644
index 0000000..9202b21
--- /dev/null
+++ b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDRelationshipDestinationImpl.java
@@ -0,0 +1,30 @@
+// This is a generated file. Not intended for manual editing.
+package nl.dirkgroot.structurizr.dsl.psi.impl;
+
+import java.util.List;
+import org.jetbrains.annotations.*;
+import com.intellij.lang.ASTNode;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiElementVisitor;
+import com.intellij.psi.util.PsiTreeUtil;
+import static nl.dirkgroot.structurizr.dsl.psi.SDTypes.*;
+import com.intellij.extapi.psi.ASTWrapperPsiElement;
+import nl.dirkgroot.structurizr.dsl.psi.*;
+
+public class SDRelationshipDestinationImpl extends ASTWrapperPsiElement implements SDRelationshipDestination {
+
+  public SDRelationshipDestinationImpl(@NotNull ASTNode node) {
+    super(node);
+  }
+
+  public void accept(@NotNull SDVisitor visitor) {
+    visitor.visitRelationshipDestination(this);
+  }
+
+  @Override
+  public void accept(@NotNull PsiElementVisitor visitor) {
+    if (visitor instanceof SDVisitor) accept((SDVisitor)visitor);
+    else super.accept(visitor);
+  }
+
+}
diff --git a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDRelationshipKeywordImpl.java b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDRelationshipKeywordImpl.java
new file mode 100644
index 0000000..869b8e8
--- /dev/null
+++ b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDRelationshipKeywordImpl.java
@@ -0,0 +1,30 @@
+// This is a generated file. Not intended for manual editing.
+package nl.dirkgroot.structurizr.dsl.psi.impl;
+
+import java.util.List;
+import org.jetbrains.annotations.*;
+import com.intellij.lang.ASTNode;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiElementVisitor;
+import com.intellij.psi.util.PsiTreeUtil;
+import static nl.dirkgroot.structurizr.dsl.psi.SDTypes.*;
+import com.intellij.extapi.psi.ASTWrapperPsiElement;
+import nl.dirkgroot.structurizr.dsl.psi.*;
+
+public class SDRelationshipKeywordImpl extends ASTWrapperPsiElement implements SDRelationshipKeyword {
+
+  public SDRelationshipKeywordImpl(@NotNull ASTNode node) {
+    super(node);
+  }
+
+  public void accept(@NotNull SDVisitor visitor) {
+    visitor.visitRelationshipKeyword(this);
+  }
+
+  @Override
+  public void accept(@NotNull PsiElementVisitor visitor) {
+    if (visitor instanceof SDVisitor) accept((SDVisitor)visitor);
+    else super.accept(visitor);
+  }
+
+}
diff --git a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDRelationshipSourceImpl.java b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDRelationshipSourceImpl.java
new file mode 100644
index 0000000..459e7a1
--- /dev/null
+++ b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDRelationshipSourceImpl.java
@@ -0,0 +1,30 @@
+// This is a generated file. Not intended for manual editing.
+package nl.dirkgroot.structurizr.dsl.psi.impl;
+
+import java.util.List;
+import org.jetbrains.annotations.*;
+import com.intellij.lang.ASTNode;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiElementVisitor;
+import com.intellij.psi.util.PsiTreeUtil;
+import static nl.dirkgroot.structurizr.dsl.psi.SDTypes.*;
+import com.intellij.extapi.psi.ASTWrapperPsiElement;
+import nl.dirkgroot.structurizr.dsl.psi.*;
+
+public class SDRelationshipSourceImpl extends ASTWrapperPsiElement implements SDRelationshipSource {
+
+  public SDRelationshipSourceImpl(@NotNull ASTNode node) {
+    super(node);
+  }
+
+  public void accept(@NotNull SDVisitor visitor) {
+    visitor.visitRelationshipSource(this);
+  }
+
+  @Override
+  public void accept(@NotNull PsiElementVisitor visitor) {
+    if (visitor instanceof SDVisitor) accept((SDVisitor)visitor);
+    else super.accept(visitor);
+  }
+
+}
diff --git a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDScriptBlockImpl.java b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDScriptBlockImpl.java
index 8cd28a3..1d79465 100644
--- a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDScriptBlockImpl.java
+++ b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDScriptBlockImpl.java
@@ -27,16 +27,4 @@ public void accept(@NotNull PsiElementVisitor visitor) {
     else super.accept(visitor);
   }
 
-  @Override
-  @NotNull
-  public List<SDArgument> getArgumentList() {
-    return PsiTreeUtil.getChildrenOfTypeAsList(this, SDArgument.class);
-  }
-
-  @Override
-  @NotNull
-  public SDScriptContents getScriptContents() {
-    return findNotNullChildByClass(SDScriptContents.class);
-  }
-
 }
diff --git a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDIdentifierNameImpl.java b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDScriptKeywordImpl.java
similarity index 79%
rename from src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDIdentifierNameImpl.java
rename to src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDScriptKeywordImpl.java
index 6063834..eec7a7e 100644
--- a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDIdentifierNameImpl.java
+++ b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDScriptKeywordImpl.java
@@ -11,14 +11,14 @@
 import com.intellij.extapi.psi.ASTWrapperPsiElement;
 import nl.dirkgroot.structurizr.dsl.psi.*;
 
-public class SDIdentifierNameImpl extends ASTWrapperPsiElement implements SDIdentifierName {
+public class SDScriptKeywordImpl extends ASTWrapperPsiElement implements SDScriptKeyword {
 
-  public SDIdentifierNameImpl(@NotNull ASTNode node) {
+  public SDScriptKeywordImpl(@NotNull ASTNode node) {
     super(node);
   }
 
   public void accept(@NotNull SDVisitor visitor) {
-    visitor.visitIdentifierName(this);
+    visitor.visitScriptKeyword(this);
   }
 
   @Override
diff --git a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDExplicitRelationshipImpl.java b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDScriptStatementImpl.java
similarity index 66%
rename from src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDExplicitRelationshipImpl.java
rename to src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDScriptStatementImpl.java
index 142fc54..d05dfdc 100644
--- a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDExplicitRelationshipImpl.java
+++ b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDScriptStatementImpl.java
@@ -8,17 +8,17 @@
 import com.intellij.psi.PsiElementVisitor;
 import com.intellij.psi.util.PsiTreeUtil;
 import static nl.dirkgroot.structurizr.dsl.psi.SDTypes.*;
-import com.intellij.extapi.psi.ASTWrapperPsiElement;
 import nl.dirkgroot.structurizr.dsl.psi.*;
 
-public class SDExplicitRelationshipImpl extends ASTWrapperPsiElement implements SDExplicitRelationship {
+public class SDScriptStatementImpl extends SDStatementImpl implements SDScriptStatement {
 
-  public SDExplicitRelationshipImpl(@NotNull ASTNode node) {
+  public SDScriptStatementImpl(@NotNull ASTNode node) {
     super(node);
   }
 
+  @Override
   public void accept(@NotNull SDVisitor visitor) {
-    visitor.visitExplicitRelationship(this);
+    visitor.visitScriptStatement(this);
   }
 
   @Override
@@ -35,8 +35,14 @@ public List<SDArgument> getArgumentList() {
 
   @Override
   @NotNull
-  public List<SDIdentifierName> getIdentifierNameList() {
-    return PsiTreeUtil.getChildrenOfTypeAsList(this, SDIdentifierName.class);
+  public SDScriptBlock getScriptBlock() {
+    return findNotNullChildByClass(SDScriptBlock.class);
+  }
+
+  @Override
+  @NotNull
+  public SDScriptKeyword getScriptKeyword() {
+    return findNotNullChildByClass(SDScriptKeyword.class);
   }
 
 }
diff --git a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDSingleLineStatementImpl.java b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDSingleLineStatementImpl.java
index 1c7e233..b72448c 100644
--- a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDSingleLineStatementImpl.java
+++ b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDSingleLineStatementImpl.java
@@ -8,15 +8,15 @@
 import com.intellij.psi.PsiElementVisitor;
 import com.intellij.psi.util.PsiTreeUtil;
 import static nl.dirkgroot.structurizr.dsl.psi.SDTypes.*;
-import com.intellij.extapi.psi.ASTWrapperPsiElement;
 import nl.dirkgroot.structurizr.dsl.psi.*;
 
-public class SDSingleLineStatementImpl extends ASTWrapperPsiElement implements SDSingleLineStatement {
+public class SDSingleLineStatementImpl extends SDStatementImpl implements SDSingleLineStatement {
 
   public SDSingleLineStatementImpl(@NotNull ASTNode node) {
     super(node);
   }
 
+  @Override
   public void accept(@NotNull SDVisitor visitor) {
     visitor.visitSingleLineStatement(this);
   }
@@ -33,12 +33,6 @@ public List<SDArgument> getArgumentList() {
     return PsiTreeUtil.getChildrenOfTypeAsList(this, SDArgument.class);
   }
 
-  @Override
-  @Nullable
-  public SDIdentifierName getIdentifierName() {
-    return findChildByClass(SDIdentifierName.class);
-  }
-
   @Override
   @NotNull
   public SDKeyword getKeyword() {
diff --git a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDKeywordWithPropertyBlockImpl.java b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDStatementImpl.java
similarity index 71%
rename from src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDKeywordWithPropertyBlockImpl.java
rename to src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDStatementImpl.java
index 45476da..05ef48d 100644
--- a/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDKeywordWithPropertyBlockImpl.java
+++ b/src/main/gen/nl/dirkgroot/structurizr/dsl/psi/impl/SDStatementImpl.java
@@ -11,14 +11,14 @@
 import com.intellij.extapi.psi.ASTWrapperPsiElement;
 import nl.dirkgroot.structurizr.dsl.psi.*;
 
-public class SDKeywordWithPropertyBlockImpl extends ASTWrapperPsiElement implements SDKeywordWithPropertyBlock {
+public class SDStatementImpl extends ASTWrapperPsiElement implements SDStatement {
 
-  public SDKeywordWithPropertyBlockImpl(@NotNull ASTNode node) {
+  public SDStatementImpl(@NotNull ASTNode node) {
     super(node);
   }
 
   public void accept(@NotNull SDVisitor visitor) {
-    visitor.visitKeywordWithPropertyBlock(this);
+    visitor.visitStatement(this);
   }
 
   @Override
@@ -27,4 +27,10 @@ public void accept(@NotNull PsiElementVisitor visitor) {
     else super.accept(visitor);
   }
 
+  @Override
+  @NotNull
+  public SDStatement getStatement() {
+    return findNotNullChildByClass(SDStatement.class);
+  }
+
 }
diff --git a/src/main/grammar/StructurizrDSL.bnf b/src/main/grammar/StructurizrDSL.bnf
index 92e483a..1e61013 100644
--- a/src/main/grammar/StructurizrDSL.bnf
+++ b/src/main/grammar/StructurizrDSL.bnf
@@ -22,125 +22,67 @@
         brace2='}'
         equals='='
 
-        adrs_keyword='!adrs'
-        animation_keyword='animation'
-        auto_layout_keyword='autoLayout'
-        background_keyword='background'
-        border_keyword='border'
-        branding_keyword='branding'
-        color_keyword='color'
-        colour_keyword='colour'
-        component_keyword='component'
-        configuration_keyword='configuration'
-        constant_keyword='!constant'
-        container_instance='containerInstance'
-        container_keyword='container'
-        custom_keyword='custom'
-        deployment_environment_keyword='deploymentEnvironment'
-        deployment_group_keyword='deploymentGroup'
-        deployment_keyword='deployment'
-        deployment_node_keyword='deploymentNode'
-        description_keyword='description'
-        docs_keyword='!docs'
-        dynamic_keyword='dynamic'
-        element_keyword='element'
-        enterprise_keyword='enterprise'
-        exclude_element_keyword='exclude'
-        extends_keyword='extends'
-        filtered_keyword='filtered'
-        fontsize_keyword='fontSize'
-        group_keyword='group'
-        health_check_keyword='healthCheck'
-        height_keyword='height'
-        icon_keyword='icon'
-        identifiers_keyword='!identifiers'
-        implied_relationships_keyword='!impliedRelationships'
-        include_element_keyword='include'
-        include_file_keyword='!include'
-        infrastructure_node_keyword='infrastructureNode'
-        instances_keyword='instances'
-        metadata_keyword='metadata'
-        model_keyword='model'
-        opacity_keyword='opacity'
-        person_keyword='person'
-        perspectives_keyword='perspectives'
-        plugin_keyword='!plugin'
-        position_keyword='position'
-        properties_keyword='properties'
-        ref_keyword='!ref'
-        relationship_keyword='->'
-        routing_keyword='routing'
-        script_keyword='!script'
-        shape_keyword='shape'
-        software_system_instance_keyword='softwareSystemInstance'
-        software_system_keyword='softwareSystem'
-        stroke_keyword='stroke'
-        strokewidth_keyword='strokeWidth'
-        style_keyword='style'
-        styles_keyword='styles'
-        system_context_keyword='systemContext'
-        system_landscape_keyword='systemLandscape'
-        tags_keyword='tags'
-        technology_keyword='technology'
-        terminology_keyword='terminology'
-        theme_keyword='theme'
-        thickness_keyword='thickness'
-        title_keyword='title'
-        url_keyword='url'
-        users_keyword='users'
-        views_keyword='views'
-        width_keyword='width'
-        workspace_keyword='workspace'
-
         quoted_text='regexp:"[^"\r\n]*"'
         unquoted_text='regexp:[^\s"\r\n]+'
-
-        identifier='regexp:[a-zA-Z_0-9]+'
-
-        script_text='script_text'
     ]
-}
-
-structurizrDSLFile ::= statement*
-
-private statement ::= elementDefinition | scriptBlock | explicitRelationship | implicitRelationship | identifierReferences
-
-private elementDefinition ::= singleLineStatement | blockStatement | propertyBlockStatement | CRLF
-
-singleLineStatement ::= identifierAssignment? keywordWithArguments lf_eof
-blockStatement ::= identifierAssignment? keywordWithArguments '{' CRLF statement* '}' lf_eof
 
-private identifierAssignment ::= identifierName '='
-
-propertyBlockStatement ::= keywordWithPropertyBlock '{' CRLF keyValuePair* '}'
-keyValuePair ::= key value CRLF
-key ::= text
-value ::= text
-
-scriptBlock ::= '!script' argument* '{' scriptContents '}'
-scriptContents ::= SCRIPT_TEXT+
-
-explicitRelationship ::= identifierName '->' identifierName argument*
-implicitRelationship ::= '->' identifierName argument*
-
-identifierReferences ::= identifierName+ lf_eof
-
-private keywordWithArguments ::= keyword argument*
+    extends(".*Statement")=statement
+}
 
-keyword ::= '!adrs' | 'animation' | 'autoLayout' | 'background' | 'border' | 'color' | 'colour' | 'component' |
-            '!constant' | 'containerInstance' | 'container' | 'custom' | 'deploymentEnvironment' | 'deploymentGroup' |
-            'deployment' | 'deploymentNode' | 'description' | '!docs' | 'dynamic' | 'element' | 'enterprise' |
-            'exclude' | 'extends' | 'filtered' | 'fontSize' | 'group' | 'healthCheck' | 'height' | 'icon' |
-            '!identifiers' | '!impliedRelationships' | 'include' | '!include' | 'infrastructureNode' | 'instances' |
-            'metadata' | 'model' | 'opacity' | 'person' | 'perspectives' | '!plugin' | 'position' | '!ref' | '->' |
-            'routing' | '!script' | 'shape' | 'softwareSystemInstance' | 'softwareSystem' | 'stroke' | 'strokeWidth' |
-            'style' | 'styles' | 'systemContext' | 'systemLandscape' | 'tags' | 'technology' | 'theme' | 'thickness' |
-            'title' | 'url' | 'views' | 'width' | 'workspace'
+structurizrDSLFile ::= expr*
+
+private expr ::=
+            scriptStatement
+            | explicitRelationshipStatement
+            | implicitRelationshipStatement
+            | animationStatement
+            | propertiesStatement
+            | identifierAssignmentStatement
+            | blockStatement
+            | singleLineStatement
+            | lineCommentStatement
+            | blockCommentStatement
+
+fake statement ::= expr
+
+explicitRelationshipStatement ::= relationshipSource relationshipKeyword relationshipDestination argument* block? lf_eof
+implicitRelationshipStatement ::= relationshipKeyword relationshipDestination argument* block? lf_eof
+relationshipSource ::= UNQUOTED_TEXT
+relationshipKeyword ::= ARROW
+relationshipDestination ::= UNQUOTED_TEXT
+
+animationStatement ::= animationKeyword '{' CRLF (identifierReferencesStatement | lineCommentStatement | blockCommentStatement)* '}' lf_eof
+animationKeyword ::= 'animation'
+identifierReferencesStatement ::= identifierReference* CRLF
+
+lineCommentStatement ::= LINE_COMMENT lf_eof
+blockCommentStatement ::= BLOCK_COMMENT lf_eof
+
+scriptStatement ::= scriptKeyword argument* scriptBlock lf_eof
+scriptKeyword ::= '!script'
+scriptBlock ::= '{' SCRIPT_TEXT '}'
+
+propertiesStatement ::= propertiesKeyword propertiesBlock lf_eof
+propertiesKeyword ::= 'perspectives' | 'properties' | 'users'
+propertiesBlock ::= '{' CRLF propertyDefinition* '}'
+propertyDefinition ::= propertyKey propertyValue CRLF
+propertyKey ::= text
+propertyValue ::= text
+
+identifierAssignmentStatement ::= identifierReference '=' (blockStatement | singleLineStatement)
+identifierReference ::= UNQUOTED_TEXT
+
+blockStatement ::= keyword argument* block lf_eof
+block ::= '{' CRLF expr* '}' {
+    pin=1
+    recoverWhile=blockRecover
+}
+private blockRecover ::= !(text | lf_eof)
 
-keywordWithPropertyBlock ::= 'branding' | 'configuration' | 'properties' | 'terminology' | 'users'
+singleLineStatement ::= keyword argument* lf_eof
 
+keyword ::= UNQUOTED_TEXT
 argument ::= text
-identifierName ::= IDENTIFIER
 
 private text ::= QUOTED_TEXT | UNQUOTED_TEXT
 private lf_eof ::= CRLF | <<eof>>
diff --git a/src/main/grammar/StructurizrDSL.flex b/src/main/grammar/StructurizrDSL.flex
index b65f167..ac92318 100644
--- a/src/main/grammar/StructurizrDSL.flex
+++ b/src/main/grammar/StructurizrDSL.flex
@@ -36,19 +36,15 @@ import static nl.dirkgroot.structurizr.dsl.psi.SDTypes.*;
 %type IElementType
 %unicode
 
-%state EXPECT_ARGUMENTS
-%state EXPECT_PROPERTIES
-%state EXPECT_REL_DESTINATION
-%state EXPECT_SCRIPT
+%state EXPECT_NON_COMMENT
 %state EXPECT_SCRIPT_ARGUMENTS
+%state EXPECT_SCRIPT
 
 CRLF=\r|\n|\r\n
 WHITE_SPACE=[\ \t\f]+
-EMPTY_LINE={WHITE_SPACE}* {CRLF}
 
 QUOTED_TEXT=\" [^\"\r\n]* \"?
-UNQUOTED_TEXT=[^\s\"\r\n]+
-IDENTIFIER=[a-zA-Z_0-9\\.]+
+UNQUOTED_TEXT=[^\s\"\r\n{}]+
 
 LINE_COMMENT=("//"|"#") [^\r\n]*
 BLOCK_COMMENT="/*" ( ([^"*"]|[\r\n])* ("*"+ [^"*""/"] )? )* ("*" | "*"+"/")?
@@ -57,119 +53,30 @@ SCRIPT_TEXT=[^\r\n{}]+
 
 %%
 
-<YYINITIAL,EXPECT_PROPERTIES,EXPECT_REL_DESTINATION,EXPECT_ARGUMENTS,EXPECT_SCRIPT_ARGUMENTS> {
-{WHITE_SPACE}      { return WHITE_SPACE; }
-}
-
-<YYINITIAL,EXPECT_PROPERTIES> {
-^{EMPTY_LINE}      { return WHITE_SPACE; }
-{BLOCK_COMMENT}    { return BLOCK_COMMENT; }
-{LINE_COMMENT}     { return LINE_COMMENT; }
+<YYINITIAL,EXPECT_NON_COMMENT,EXPECT_SCRIPT_ARGUMENTS> {
+{WHITE_SPACE}            { return WHITE_SPACE; }
+^{WHITE_SPACE}? {CRLF}   { return WHITE_SPACE; }
 }
 
 <YYINITIAL> {
-{CRLF}                   { return CRLF; }
+{BLOCK_COMMENT}          { return BLOCK_COMMENT; }
+{LINE_COMMENT}           { return LINE_COMMENT; }
+
+[^]                      { yypushback(yytext().length()); yybegin(EXPECT_NON_COMMENT); }
+}
 
+<EXPECT_NON_COMMENT> {
 "{"                      { return BRACE1; }
 "}"                      { return BRACE2; }
 "="                      { return EQUALS; }
+"->"                     { return ARROW; }
 
-"!adrs"                  { yybegin(EXPECT_ARGUMENTS); return ADRS_KEYWORD; }
-"!constant"              { yybegin(EXPECT_ARGUMENTS); return CONSTANT_KEYWORD; }
-"!docs"                  { yybegin(EXPECT_ARGUMENTS); return DOCS_KEYWORD; }
-"!identifiers"           { yybegin(EXPECT_ARGUMENTS); return IDENTIFIERS_KEYWORD; }
-"!impliedRelationships"  { yybegin(EXPECT_ARGUMENTS); return IMPLIED_RELATIONSHIPS_KEYWORD; }
-"!include"               { yybegin(EXPECT_ARGUMENTS); return INCLUDE_FILE_KEYWORD; }
-"!plugin"                { yybegin(EXPECT_ARGUMENTS); return PLUGIN_KEYWORD; }
-"!ref"                   { yybegin(EXPECT_ARGUMENTS); return REF_KEYWORD; }
-"!script"                { yybegin(EXPECT_SCRIPT_ARGUMENTS); return SCRIPT_KEYWORD; }
-"->"                     { yybegin(EXPECT_REL_DESTINATION); return RELATIONSHIP_KEYWORD; }
-"animation"              { yybegin(EXPECT_ARGUMENTS); return ANIMATION_KEYWORD; }
-"autoLayout"             { yybegin(EXPECT_ARGUMENTS); return AUTO_LAYOUT_KEYWORD; }
-"background"             { yybegin(EXPECT_ARGUMENTS); return BACKGROUND_KEYWORD; }
-"border"                 { yybegin(EXPECT_ARGUMENTS); return BORDER_KEYWORD; }
-"branding"               { yybegin(EXPECT_PROPERTIES); return BRANDING_KEYWORD; }
-"color"                  { yybegin(EXPECT_ARGUMENTS); return COLOR_KEYWORD; }
-"colour"                 { yybegin(EXPECT_ARGUMENTS); return COLOUR_KEYWORD; }
-"component"              { yybegin(EXPECT_ARGUMENTS); return COMPONENT_KEYWORD; }
-"configuration"          { yybegin(EXPECT_PROPERTIES); return CONFIGURATION_KEYWORD; }
-"container"              { yybegin(EXPECT_ARGUMENTS); return CONTAINER_KEYWORD; }
-"containerInstance"      { yybegin(EXPECT_ARGUMENTS); return CONTAINER_INSTANCE; }
-"custom"                 { yybegin(EXPECT_ARGUMENTS); return CUSTOM_KEYWORD; }
-"deployment"             { yybegin(EXPECT_ARGUMENTS); return DEPLOYMENT_KEYWORD; }
-"deploymentEnvironment"  { yybegin(EXPECT_ARGUMENTS); return DEPLOYMENT_ENVIRONMENT_KEYWORD; }
-"deploymentGroup"        { yybegin(EXPECT_ARGUMENTS); return DEPLOYMENT_GROUP_KEYWORD; }
-"deploymentNode"         { yybegin(EXPECT_ARGUMENTS); return DEPLOYMENT_NODE_KEYWORD; }
-"description"            { yybegin(EXPECT_ARGUMENTS); return DESCRIPTION_KEYWORD; }
-"dynamic"                { yybegin(EXPECT_ARGUMENTS); return DYNAMIC_KEYWORD; }
-"element"                { yybegin(EXPECT_ARGUMENTS); return ELEMENT_KEYWORD; }
-"enterprise"             { yybegin(EXPECT_ARGUMENTS); return ENTERPRISE_KEYWORD; }
-"exclude"                { yybegin(EXPECT_ARGUMENTS); return EXCLUDE_ELEMENT_KEYWORD; }
-"extends"                { yybegin(EXPECT_ARGUMENTS); return EXTENDS_KEYWORD; }
-"filtered"               { yybegin(EXPECT_ARGUMENTS); return FILTERED_KEYWORD; }
-"fontSize"               { yybegin(EXPECT_ARGUMENTS); return FONTSIZE_KEYWORD; }
-"group"                  { yybegin(EXPECT_ARGUMENTS); return GROUP_KEYWORD; }
-"healthCheck"            { yybegin(EXPECT_ARGUMENTS); return HEALTH_CHECK_KEYWORD; }
-"height"                 { yybegin(EXPECT_ARGUMENTS); return HEIGHT_KEYWORD; }
-"icon"                   { yybegin(EXPECT_ARGUMENTS); return ICON_KEYWORD; }
-"include"                { yybegin(EXPECT_ARGUMENTS); return INCLUDE_ELEMENT_KEYWORD; }
-"infrastructureNode"     { yybegin(EXPECT_ARGUMENTS); return INFRASTRUCTURE_NODE_KEYWORD; }
-"instances"              { yybegin(EXPECT_ARGUMENTS); return INSTANCES_KEYWORD; }
-"metadata"               { yybegin(EXPECT_ARGUMENTS); return METADATA_KEYWORD; }
-"model"                  { yybegin(EXPECT_ARGUMENTS); return MODEL_KEYWORD; }
-"opacity"                { yybegin(EXPECT_ARGUMENTS); return OPACITY_KEYWORD; }
-"person"                 { yybegin(EXPECT_ARGUMENTS); return PERSON_KEYWORD; }
-"perspectives"           { yybegin(EXPECT_ARGUMENTS); return PERSPECTIVES_KEYWORD; }
-"position"               { yybegin(EXPECT_ARGUMENTS); return POSITION_KEYWORD; }
-"properties"             { yybegin(EXPECT_PROPERTIES); return PROPERTIES_KEYWORD; }
-"routing"                { yybegin(EXPECT_ARGUMENTS); return ROUTING_KEYWORD; }
-"shape"                  { yybegin(EXPECT_ARGUMENTS); return SHAPE_KEYWORD; }
-"softwareSystem"         { yybegin(EXPECT_ARGUMENTS); return SOFTWARE_SYSTEM_KEYWORD; }
-"softwareSystemInstance" { yybegin(EXPECT_ARGUMENTS); return SOFTWARE_SYSTEM_INSTANCE_KEYWORD; }
-"stroke"                 { yybegin(EXPECT_ARGUMENTS); return STROKE_KEYWORD; }
-"strokeWidth"            { yybegin(EXPECT_ARGUMENTS); return STROKEWIDTH_KEYWORD; }
-"style"                  { yybegin(EXPECT_ARGUMENTS); return STYLE_KEYWORD; }
-"styles"                 { yybegin(EXPECT_ARGUMENTS); return STYLES_KEYWORD; }
-"systemContext"          { yybegin(EXPECT_ARGUMENTS); return SYSTEM_CONTEXT_KEYWORD; }
-"systemLandscape"        { yybegin(EXPECT_ARGUMENTS); return SYSTEM_LANDSCAPE_KEYWORD; }
-"tags"                   { yybegin(EXPECT_ARGUMENTS); return TAGS_KEYWORD; }
-"technology"             { yybegin(EXPECT_ARGUMENTS); return TECHNOLOGY_KEYWORD; }
-"terminology"            { yybegin(EXPECT_PROPERTIES); return TERMINOLOGY_KEYWORD; }
-"theme"                  { yybegin(EXPECT_ARGUMENTS); return THEME_KEYWORD; }
-"thickness"              { yybegin(EXPECT_ARGUMENTS); return THICKNESS_KEYWORD; }
-"title"                  { yybegin(EXPECT_ARGUMENTS); return TITLE_KEYWORD; }
-"url"                    { yybegin(EXPECT_ARGUMENTS); return URL_KEYWORD; }
-"users"                  { yybegin(EXPECT_PROPERTIES); return USERS_KEYWORD; }
-"views"                  { yybegin(EXPECT_ARGUMENTS); return VIEWS_KEYWORD; }
-"width"                  { yybegin(EXPECT_ARGUMENTS); return WIDTH_KEYWORD; }
-"workspace"              { yybegin(EXPECT_ARGUMENTS); return WORKSPACE_KEYWORD; }
-
-{IDENTIFIER}             { return IDENTIFIER; }
-
-[^]                      { return BAD_CHARACTER; }
-}
-
-<EXPECT_REL_DESTINATION> {
-{IDENTIFIER}       { yybegin(EXPECT_ARGUMENTS); return IDENTIFIER; }
-[^]                { yybegin(YYINITIAL); yypushback(yytext().length()); }
-}
-
-<EXPECT_ARGUMENTS> {
-"{"                { yybegin(YYINITIAL); yypushback(yytext().length()); }
+"!script"                { yybegin(EXPECT_SCRIPT_ARGUMENTS); return UNQUOTED_TEXT; }
 
-{QUOTED_TEXT}      { return QUOTED_TEXT; }
-{UNQUOTED_TEXT}    { return UNQUOTED_TEXT; }
+{QUOTED_TEXT}            { return QUOTED_TEXT; }
+{UNQUOTED_TEXT}          { return UNQUOTED_TEXT; }
 
-[^]                { yybegin(YYINITIAL); yypushback(yytext().length()); }
-}
-
-<EXPECT_PROPERTIES> {
-"{"                { return BRACE1; }
-"}"                { yybegin(YYINITIAL); return BRACE2; }
-{CRLF}             { return CRLF; }
-
-{QUOTED_TEXT}      { return QUOTED_TEXT; }
-{UNQUOTED_TEXT}    { return UNQUOTED_TEXT; }
+{CRLF}                   { yybegin(YYINITIAL); return CRLF; }
 }
 
 <EXPECT_SCRIPT_ARGUMENTS> {
@@ -180,17 +87,17 @@ SCRIPT_TEXT=[^\r\n{}]+
 }
 
 <EXPECT_SCRIPT> {
-"{"                { braces++; return SCRIPT_TEXT; }
+"{"                { braces++; }
 "}"                {
                      if (braces == 0) {
                          endScript();
-                         return BRACE2;
+                         yypushback(1);
+                         return SCRIPT_TEXT;
                      }
                      braces--;
-                     return SCRIPT_TEXT;
                    }
-{CRLF}             { return SCRIPT_TEXT; }
-{SCRIPT_TEXT}      { return SCRIPT_TEXT; }
+{CRLF}             { }
+{SCRIPT_TEXT}      { }
 }
 
-[^]                { return BAD_CHARACTER; }
+[^]                      { return BAD_CHARACTER; }
diff --git a/src/main/kotlin/nl/dirkgroot/structurizr/dsl/lang/SDBlock.kt b/src/main/kotlin/nl/dirkgroot/structurizr/dsl/lang/SDBlock.kt
index 1291f92..fece7cb 100644
--- a/src/main/kotlin/nl/dirkgroot/structurizr/dsl/lang/SDBlock.kt
+++ b/src/main/kotlin/nl/dirkgroot/structurizr/dsl/lang/SDBlock.kt
@@ -5,31 +5,34 @@ import com.intellij.lang.ASTNode
 import com.intellij.psi.TokenType.WHITE_SPACE
 import com.intellij.psi.formatter.common.AbstractBlock
 import com.intellij.psi.tree.TokenSet
+import nl.dirkgroot.structurizr.dsl.psi.SDStatement
 import nl.dirkgroot.structurizr.dsl.psi.SDTypes.*
 
 class SDBlock(
     node: ASTNode,
-    private val spacingBuilder: SpacingBuilder,
-    private val indent: Indent = Indent.getNoneIndent(),
     wrap: Wrap = Wrap.createWrap(WrapType.NONE, false),
-    alignment: Alignment = Alignment.createAlignment()
+    alignment: Alignment? = null,
+    private val spacingBuilder: SpacingBuilder,
+    private val indent: Indent = Indent.getNoneIndent()
 ) : AbstractBlock(node, wrap, alignment) {
-    override fun buildChildren(): MutableList<Block> {
-        val result = mutableListOf<Block>()
-        var child = myNode.firstChildNode
-        while (child != null) {
-            if (child.elementType != WHITE_SPACE && child.elementType != CRLF) {
-                val indent = if (child.elementType in INDENT_TOKEN_TYPES && myNode.treeParent != null)
-                    Indent.getNormalIndent(true)
-                else
-                    Indent.getNoneIndent()
-                val block = SDBlock(child, spacingBuilder, indent)
-                result.add(block)
-            }
-            child = child.treeNext
-        }
-        return result
-    }
+    override fun buildChildren() =
+        if (myNode.elementType == SCRIPT_BLOCK)
+            emptyList()
+        else
+            generateSequence(myNode.firstChildNode) { it.treeNext }
+                .mapNotNull { child ->
+                    if (child.elementType != WHITE_SPACE && child.elementType != CRLF)
+                        SDBlock(child, spacingBuilder = spacingBuilder, indent = calculateIndent(child))
+                    else
+                        null
+                }
+                .toList()
+
+    private fun calculateIndent(child: ASTNode) =
+        if ((child.elementType in INDENT_TOKEN_TYPES || child.psi is SDStatement) && myNode.treeParent != null)
+            Indent.getNormalIndent()
+        else
+            Indent.getNoneIndent()
 
     override fun getIndent() = indent
 
@@ -37,18 +40,13 @@ class SDBlock(
 
     override fun isLeaf() = myNode.firstChildNode == null
 
+    override fun getChildAttributes(newChildIndex: Int) =
+        if (myNode.elementType in INDENT_TOKEN_TYPES || myNode.psi is SDStatement)
+            ChildAttributes(Indent.getNormalIndent(), null)
+        else
+            ChildAttributes(Indent.getNoneIndent(), null)
+
     companion object {
-        private val INDENT_TOKEN_TYPES = TokenSet.create(
-            BLOCK_COMMENT,
-            BLOCK_STATEMENT,
-            EXPLICIT_RELATIONSHIP,
-            IDENTIFIER_REFERENCES,
-            IMPLICIT_RELATIONSHIP,
-            KEY_VALUE_PAIR,
-            LINE_COMMENT,
-            PROPERTY_BLOCK_STATEMENT,
-            SCRIPT_BLOCK,
-            SINGLE_LINE_STATEMENT,
-        )
+        private val INDENT_TOKEN_TYPES = TokenSet.create(PROPERTIES_BLOCK, BLOCK, PROPERTY_DEFINITION)
     }
 }
diff --git a/src/main/kotlin/nl/dirkgroot/structurizr/dsl/lang/SDBraceMatcher.kt b/src/main/kotlin/nl/dirkgroot/structurizr/dsl/lang/SDBraceMatcher.kt
new file mode 100644
index 0000000..f8dde0d
--- /dev/null
+++ b/src/main/kotlin/nl/dirkgroot/structurizr/dsl/lang/SDBraceMatcher.kt
@@ -0,0 +1,15 @@
+package nl.dirkgroot.structurizr.dsl.lang
+
+import com.intellij.lang.BracePair
+import com.intellij.lang.PairedBraceMatcher
+import com.intellij.psi.PsiFile
+import com.intellij.psi.tree.IElementType
+import nl.dirkgroot.structurizr.dsl.psi.SDTypes
+
+class SDBraceMatcher : PairedBraceMatcher {
+    override fun getPairs() = arrayOf(BracePair(SDTypes.BRACE1, SDTypes.BRACE2, true))
+
+    override fun isPairedBracesAllowedBeforeType(lbraceType: IElementType, contextType: IElementType?) = true
+
+    override fun getCodeConstructStart(file: PsiFile, openingBraceOffset: Int) = openingBraceOffset
+}
diff --git a/src/main/kotlin/nl/dirkgroot/structurizr/dsl/lang/SDCommenter.kt b/src/main/kotlin/nl/dirkgroot/structurizr/dsl/lang/SDCommenter.kt
new file mode 100644
index 0000000..c160955
--- /dev/null
+++ b/src/main/kotlin/nl/dirkgroot/structurizr/dsl/lang/SDCommenter.kt
@@ -0,0 +1,15 @@
+package nl.dirkgroot.structurizr.dsl.lang
+
+import com.intellij.lang.Commenter
+
+class SDCommenter : Commenter {
+    override fun getLineCommentPrefix() = "//"
+
+    override fun getBlockCommentPrefix() = "/*"
+
+    override fun getBlockCommentSuffix() = "*/"
+
+    override fun getCommentedBlockCommentPrefix() = null
+
+    override fun getCommentedBlockCommentSuffix() = null
+}
diff --git a/src/main/kotlin/nl/dirkgroot/structurizr/dsl/lang/SDFormattingModelBuilder.kt b/src/main/kotlin/nl/dirkgroot/structurizr/dsl/lang/SDFormattingModelBuilder.kt
index 08294e7..8422f77 100644
--- a/src/main/kotlin/nl/dirkgroot/structurizr/dsl/lang/SDFormattingModelBuilder.kt
+++ b/src/main/kotlin/nl/dirkgroot/structurizr/dsl/lang/SDFormattingModelBuilder.kt
@@ -9,15 +9,18 @@ class SDFormattingModelBuilder : FormattingModelBuilder {
     override fun createModel(formattingContext: FormattingContext): FormattingModel =
         FormattingModelProvider.createFormattingModelForPsiFile(
             formattingContext.containingFile,
-            SDBlock(formattingContext.node, createSpacingBuilder(formattingContext.codeStyleSettings)),
+            SDBlock(formattingContext.node, spacingBuilder = createSpacingBuilder(formattingContext.codeStyleSettings)),
             formattingContext.codeStyleSettings
         )
 
     private fun createSpacingBuilder(codeStyleSettings: CodeStyleSettings) =
         SpacingBuilder(codeStyleSettings, StructurizrDSLLanguage)
+            .before(SDTypes.LINE_COMMENT).none()
+            .before(SDTypes.BLOCK).spaces(1)
+            .before(SDTypes.PROPERTIES_BLOCK).spaces(1)
+            .before(SDTypes.PROPERTY_KEY).spaces(1)
+            .before(SDTypes.PROPERTY_VALUE).spaces(1)
+            .around(SDTypes.RELATIONSHIP_KEYWORD).spaces(1)
             .around(SDTypes.EQUALS).spaces(1)
-            .around(SDTypes.IDENTIFIER_NAME).spaces(1)
             .before(SDTypes.ARGUMENT).spaces(1)
-            .before(SDTypes.BRACE1).spaces(1)
-            .between(SDTypes.KEY, SDTypes.VALUE).spaces(1)
 }
diff --git a/src/main/kotlin/nl/dirkgroot/structurizr/dsl/lang/StructurizrDSLParserDefinition.kt b/src/main/kotlin/nl/dirkgroot/structurizr/dsl/lang/StructurizrDSLParserDefinition.kt
index 21d803f..014b2f0 100644
--- a/src/main/kotlin/nl/dirkgroot/structurizr/dsl/lang/StructurizrDSLParserDefinition.kt
+++ b/src/main/kotlin/nl/dirkgroot/structurizr/dsl/lang/StructurizrDSLParserDefinition.kt
@@ -16,7 +16,6 @@ import nl.dirkgroot.structurizr.dsl.psi.SDTypes
 class StructurizrDSLParserDefinition : ParserDefinition {
     companion object {
         val WHITE_SPACES = TokenSet.create(TokenType.WHITE_SPACE)
-        val COMMENTS = TokenSet.create(SDTypes.LINE_COMMENT, SDTypes.BLOCK_COMMENT)
 
         val FILE = IFileElementType(StructurizrDSLLanguage)
     }
@@ -25,7 +24,7 @@ class StructurizrDSLParserDefinition : ParserDefinition {
 
     override fun getWhitespaceTokens() = WHITE_SPACES
 
-    override fun getCommentTokens() = COMMENTS
+    override fun getCommentTokens(): TokenSet = TokenSet.EMPTY
 
     override fun getStringLiteralElements(): TokenSet = TokenSet.EMPTY
 
diff --git a/src/main/kotlin/nl/dirkgroot/structurizr/dsl/syntax/SDHighlightingAnnotator.kt b/src/main/kotlin/nl/dirkgroot/structurizr/dsl/syntax/SDHighlightingAnnotator.kt
new file mode 100644
index 0000000..a3b6cd7
--- /dev/null
+++ b/src/main/kotlin/nl/dirkgroot/structurizr/dsl/syntax/SDHighlightingAnnotator.kt
@@ -0,0 +1,30 @@
+package nl.dirkgroot.structurizr.dsl.syntax
+
+import com.intellij.lang.annotation.AnnotationHolder
+import com.intellij.lang.annotation.Annotator
+import com.intellij.lang.annotation.HighlightSeverity
+import com.intellij.openapi.editor.DefaultLanguageHighlighterColors.*
+import com.intellij.openapi.editor.colors.EditorColors
+import com.intellij.openapi.editor.colors.TextAttributesKey
+import com.intellij.psi.PsiElement
+import nl.dirkgroot.structurizr.dsl.psi.*
+
+class SDHighlightingAnnotator : Annotator {
+    override fun annotate(element: PsiElement, holder: AnnotationHolder) {
+        when (element) {
+            is SDKeyword, is SDPropertiesKeyword, is SDScriptKeyword, is SDRelationshipKeyword, is SDAnimationKeyword ->
+                holder.createAnnotation(KEYWORD)
+
+            is SDArgument, is SDPropertyKey, is SDPropertyValue -> holder.createAnnotation(STRING)
+            is SDScriptBlock -> holder.createAnnotation(EditorColors.INJECTED_LANGUAGE_FRAGMENT)
+            is SDIdentifierReference, is SDRelationshipSource, is SDRelationshipDestination ->
+                holder.createAnnotation(IDENTIFIER)
+        }
+    }
+
+    private fun AnnotationHolder.createAnnotation(textAttributesKey: TextAttributesKey) {
+        newSilentAnnotation(HighlightSeverity.INFORMATION)
+            .textAttributes(textAttributesKey)
+            .create()
+    }
+}
diff --git a/src/main/kotlin/nl/dirkgroot/structurizr/dsl/syntax/StructurizrDSLSyntaxHighlighter.kt b/src/main/kotlin/nl/dirkgroot/structurizr/dsl/syntax/StructurizrDSLSyntaxHighlighter.kt
index 55e9628..9c4074b 100644
--- a/src/main/kotlin/nl/dirkgroot/structurizr/dsl/syntax/StructurizrDSLSyntaxHighlighter.kt
+++ b/src/main/kotlin/nl/dirkgroot/structurizr/dsl/syntax/StructurizrDSLSyntaxHighlighter.kt
@@ -2,15 +2,14 @@ package nl.dirkgroot.structurizr.dsl.syntax
 
 import com.intellij.openapi.editor.DefaultLanguageHighlighterColors
 import com.intellij.openapi.editor.HighlighterColors
-import com.intellij.openapi.editor.colors.EditorColors
 import com.intellij.openapi.editor.colors.TextAttributesKey
 import com.intellij.openapi.editor.colors.TextAttributesKey.createTextAttributesKey
 import com.intellij.openapi.fileTypes.SyntaxHighlighterBase
 import com.intellij.psi.TokenType
 import com.intellij.psi.tree.IElementType
-import com.intellij.psi.tree.TokenSet
 import nl.dirkgroot.structurizr.dsl.lang.SDLexerAdapter
-import nl.dirkgroot.structurizr.dsl.psi.SDTypes.*
+import nl.dirkgroot.structurizr.dsl.psi.SDTypes.BLOCK_COMMENT
+import nl.dirkgroot.structurizr.dsl.psi.SDTypes.LINE_COMMENT
 
 class StructurizrDSLSyntaxHighlighter : SyntaxHighlighterBase() {
     override fun getHighlightingLexer() = SDLexerAdapter()
@@ -21,102 +20,17 @@ class StructurizrDSLSyntaxHighlighter : SyntaxHighlighterBase() {
         private val BLOCK_COMMENT_KEY = createTextAttributesKey(
             "STRUCTURIZR_DSL_BLOCK_COMMENT", DefaultLanguageHighlighterColors.BLOCK_COMMENT
         )
-        private val KEYWORD_KEY = createTextAttributesKey(
-            "STRUCTURIZR_DSL_KEYWORD", DefaultLanguageHighlighterColors.KEYWORD
-        )
         private val LINE_COMMENT_KEY = createTextAttributesKey(
             "STRUCTURIZR_DSL_LINE_COMMENT", DefaultLanguageHighlighterColors.LINE_COMMENT
         )
-        private val TEXT_KEY = createTextAttributesKey(
-            "STRUCTURIZR_DSL_TEXT", DefaultLanguageHighlighterColors.STRING
-        )
         private val BAD_CHARACTER_KEY = createTextAttributesKey(
             "STRUCTURIZR_BAD_CHARACTER", HighlighterColors.BAD_CHARACTER
         )
-        private val INJECTED_CODE_KEY = createTextAttributesKey(
-            "STRUCTURIZR_INJECTED_CODE", EditorColors.INJECTED_LANGUAGE_FRAGMENT
-        )
-
-        private val KEYWORD_TOKENS = TokenSet.create(
-            ADRS_KEYWORD,
-            ANIMATION_KEYWORD,
-            AUTO_LAYOUT_KEYWORD,
-            BACKGROUND_KEYWORD,
-            BORDER_KEYWORD,
-            BRANDING_KEYWORD,
-            COLOR_KEYWORD,
-            COLOUR_KEYWORD,
-            COMPONENT_KEYWORD,
-            CONFIGURATION_KEYWORD,
-            CONSTANT_KEYWORD,
-            CONTAINER_INSTANCE,
-            CONTAINER_KEYWORD,
-            CUSTOM_KEYWORD,
-            DEPLOYMENT_ENVIRONMENT_KEYWORD,
-            DEPLOYMENT_GROUP_KEYWORD,
-            DEPLOYMENT_KEYWORD,
-            DEPLOYMENT_NODE_KEYWORD,
-            DESCRIPTION_KEYWORD,
-            DOCS_KEYWORD,
-            DYNAMIC_KEYWORD,
-            ELEMENT_KEYWORD,
-            ENTERPRISE_KEYWORD,
-            EXCLUDE_ELEMENT_KEYWORD,
-            EXTENDS_KEYWORD,
-            FILTERED_KEYWORD,
-            FONTSIZE_KEYWORD,
-            GROUP_KEYWORD,
-            HEALTH_CHECK_KEYWORD,
-            HEIGHT_KEYWORD,
-            ICON_KEYWORD,
-            IDENTIFIERS_KEYWORD,
-            IMPLIED_RELATIONSHIPS_KEYWORD,
-            INCLUDE_ELEMENT_KEYWORD,
-            INCLUDE_FILE_KEYWORD,
-            INFRASTRUCTURE_NODE_KEYWORD,
-            INSTANCES_KEYWORD,
-            METADATA_KEYWORD,
-            MODEL_KEYWORD,
-            OPACITY_KEYWORD,
-            PERSON_KEYWORD,
-            PERSPECTIVES_KEYWORD,
-            PLUGIN_KEYWORD,
-            POSITION_KEYWORD,
-            PROPERTIES_KEYWORD,
-            REF_KEYWORD,
-            RELATIONSHIP_KEYWORD,
-            ROUTING_KEYWORD,
-            SCRIPT_KEYWORD,
-            SHAPE_KEYWORD,
-            SOFTWARE_SYSTEM_INSTANCE_KEYWORD,
-            SOFTWARE_SYSTEM_KEYWORD,
-            STROKE_KEYWORD,
-            STROKEWIDTH_KEYWORD,
-            STYLE_KEYWORD,
-            STYLES_KEYWORD,
-            SYSTEM_CONTEXT_KEYWORD,
-            SYSTEM_LANDSCAPE_KEYWORD,
-            TAGS_KEYWORD,
-            TECHNOLOGY_KEYWORD,
-            TERMINOLOGY_KEYWORD,
-            THEME_KEYWORD,
-            THICKNESS_KEYWORD,
-            TITLE_KEYWORD,
-            URL_KEYWORD,
-            USERS_KEYWORD,
-            VIEWS_KEYWORD,
-            WIDTH_KEYWORD,
-            WORKSPACE_KEYWORD,
-        )
-        private val TEXT_TOKENS = TokenSet.create(QUOTED_TEXT, UNQUOTED_TEXT)
 
         private val MAP = buildMap {
             fillMap(this, LINE_COMMENT_KEY, LINE_COMMENT)
             fillMap(this, BLOCK_COMMENT_KEY, BLOCK_COMMENT)
-            fillMap(this, TEXT_TOKENS, TEXT_KEY)
-            fillMap(this, KEYWORD_TOKENS, KEYWORD_KEY)
             fillMap(this, BAD_CHARACTER_KEY, TokenType.BAD_CHARACTER)
-            fillMap(this, INJECTED_CODE_KEY, SCRIPT_TEXT)
         }
     }
 }
diff --git a/src/main/resources/META-INF/plugin.xml b/src/main/resources/META-INF/plugin.xml
index 125747a..87d2293 100644
--- a/src/main/resources/META-INF/plugin.xml
+++ b/src/main/resources/META-INF/plugin.xml
@@ -17,6 +17,12 @@
                                implementationClass="nl.dirkgroot.structurizr.dsl.lang.StructurizrDSLParserDefinition"/>
         <lang.formatter language="StructurizrDSL"
                         implementationClass="nl.dirkgroot.structurizr.dsl.lang.SDFormattingModelBuilder"/>
+        <lang.braceMatcher language="StructurizrDSL"
+                           implementationClass="nl.dirkgroot.structurizr.dsl.lang.SDBraceMatcher"/>
+        <annotator language="StructurizrDSL"
+                   implementationClass="nl.dirkgroot.structurizr.dsl.syntax.SDHighlightingAnnotator"/>
+        <lang.commenter language="StructurizrDSL"
+                        implementationClass="nl.dirkgroot.structurizr.dsl.lang.SDCommenter"/>
     </extensions>
 
     <actions>
diff --git a/src/test/kotlin/nl/dirkgroot/structurizr/dsl/editing/AutoIndentationTest.kt b/src/test/kotlin/nl/dirkgroot/structurizr/dsl/editing/AutoIndentationTest.kt
new file mode 100644
index 0000000..b725cc9
--- /dev/null
+++ b/src/test/kotlin/nl/dirkgroot/structurizr/dsl/editing/AutoIndentationTest.kt
@@ -0,0 +1,83 @@
+package nl.dirkgroot.structurizr.dsl.editing
+
+import nl.dirkgroot.structurizr.dsl.support.StructurizrDSLCodeInsightTest
+import org.junit.jupiter.api.Test
+
+class AutoIndentationTest : StructurizrDSLCodeInsightTest() {
+    @Test
+    fun `on a new block`() {
+        checkEditor(
+            """
+                workspace <caret>
+            """.trimIndent(),
+            "{\n",
+            """
+                workspace {
+                    <caret>
+                }
+            """.trimIndent()
+        )
+    }
+
+    @Test
+    fun `on an existing empty block`() {
+        checkEditor(
+            """
+                workspace {<caret>
+                }
+            """.trimIndent(),
+            "\n",
+            """
+                workspace {
+                    <caret>
+                }
+            """.trimIndent()
+        )
+    }
+
+    @Test
+    fun `on an existing non-empty block`() {
+        checkEditor(
+            """
+                workspace {<caret>
+                    model {
+                    }
+                }
+            """.trimIndent(),
+            "\n",
+            """
+                workspace {
+                    <caret>
+                    model {
+                    }
+                }
+            """.trimIndent()
+        )
+    }
+
+    @Test
+    fun `inside an existing non-empty block`() {
+        checkEditor(
+            """
+                workspace {
+                    model {
+                    }<caret>
+                }
+            """.trimIndent(),
+            "\n",
+            """
+                workspace {
+                    model {
+                    }
+                    <caret>
+                }
+            """.trimIndent()
+        )
+    }
+
+    private fun checkEditor(initialState: String, type: String, expectedState: String) {
+        fixture.configureByText("test.dsl", initialState)
+        fixture.type(type)
+        fixture.checkResult(expectedState)
+    }
+}
diff --git a/src/test/kotlin/nl/dirkgroot/structurizr/dsl/editing/CommenterTest.kt b/src/test/kotlin/nl/dirkgroot/structurizr/dsl/editing/CommenterTest.kt
new file mode 100644
index 0000000..c1cb2e3
--- /dev/null
+++ b/src/test/kotlin/nl/dirkgroot/structurizr/dsl/editing/CommenterTest.kt
@@ -0,0 +1,44 @@
+package nl.dirkgroot.structurizr.dsl.editing
+
+import com.intellij.codeInsight.actions.MultiCaretCodeInsightAction
+import com.intellij.codeInsight.generation.actions.CommentByBlockCommentAction
+import com.intellij.codeInsight.generation.actions.CommentByLineCommentAction
+import nl.dirkgroot.structurizr.dsl.support.StructurizrDSLCodeInsightTest
+import org.junit.jupiter.api.Test
+
+class CommenterTest : StructurizrDSLCodeInsightTest() {
+    @Test
+    fun `single line comment`() {
+        checkCommentByLineComment(
+            "<caret>softwareSystem name",
+            "//softwareSystem name",
+            CommentByLineCommentAction()
+        )
+    }
+
+    @Test
+    fun `block comment`() {
+        checkCommentByLineComment(
+            """
+                <selection>softwareSystem name1
+                softwareSystem name2</selection>
+                softwareSystem name3
+            """.trimIndent(),
+            """
+                /*softwareSystem name1
+                softwareSystem name2*/
+                softwareSystem name3
+            """.trimIndent(),
+            CommentByBlockCommentAction()
+        )
+    }
+
+    private fun checkCommentByLineComment(
+        initialState: String, expectedState: String,
+        action: MultiCaretCodeInsightAction
+    ) {
+        fixture.configureByText("test.dsl", initialState)
+        action.actionPerformedImpl(project, fixture.editor)
+        fixture.checkResult(expectedState)
+    }
+}
diff --git a/src/test/kotlin/nl/dirkgroot/structurizr/dsl/editing/HighlightingAnnotatorTest.kt b/src/test/kotlin/nl/dirkgroot/structurizr/dsl/editing/HighlightingAnnotatorTest.kt
new file mode 100644
index 0000000..a00e94b
--- /dev/null
+++ b/src/test/kotlin/nl/dirkgroot/structurizr/dsl/editing/HighlightingAnnotatorTest.kt
@@ -0,0 +1,103 @@
+package nl.dirkgroot.structurizr.dsl.editing
+
+import nl.dirkgroot.structurizr.dsl.support.StructurizrDSLCodeInsightTest
+import org.junit.jupiter.api.Test
+
+class HighlightingAnnotatorTest : StructurizrDSLCodeInsightTest() {
+    @Test
+    fun `generic keyword`() {
+        checkHighlighting("${asKeyword("softwareSystem")} name")
+    }
+
+    @Test
+    fun `properties keyword`() {
+        checkHighlighting(
+            """
+                ${asKeyword("properties")} {
+                }
+            """.trimIndent()
+        )
+    }
+
+    @Test
+    fun `script keyword`() {
+        checkHighlighting(
+            """
+                ${asKeyword("!script")} kotlin {
+                }
+            """.trimIndent()
+        )
+    }
+
+    @Test
+    fun `script contents`() {
+        checkHighlighting(
+            """
+                !script kotlin ${highlight("{\nsome kotlin code\n}", "INJECTED_LANGUAGE_FRAGMENT")}
+            """.trimIndent()
+        )
+    }
+
+    @Test
+    fun `relationship keyword`() {
+        checkHighlighting("a ${asKeyword("->")} b uses")
+    }
+
+    @Test
+    fun `animation keyword`() {
+        checkHighlighting(
+            """
+                ${asKeyword("animation")} {
+                }
+            """.trimIndent()
+        )
+    }
+
+    @Test
+    fun arguments() {
+        checkHighlighting("container ${asString("unquoted")} ${asString("\"quoted\"")}")
+    }
+
+    @Test
+    fun `property definitions`() {
+        checkHighlighting(
+            """
+                properties {
+                    ${asString("key1")} ${asString("value1")}   
+                    ${asString("\"key 2\"")} ${asString("value2")}   
+                    ${asString("key3")} ${asString("\"value 3\"")}   
+                    ${asString("\"key 4\"")} ${asString("\"value 4\"")}   
+                }
+            """.trimIndent()
+        )
+    }
+
+    @Test
+    fun `relationship identifiers`() {
+        checkHighlighting(
+            """
+                -> ${asIdentifier("destination")} uses
+                ${asIdentifier("source")} -> ${asIdentifier("destination")} uses
+            """.trimIndent()
+        )
+    }
+
+    @Test
+    fun `identifier definition`() {
+        checkHighlighting("${asIdentifier("someId")} = container name")
+    }
+
+    private fun checkHighlighting(code: String) {
+        fixture.configureByText("test.dsl", code)
+        fixture.checkHighlighting(false, true, false, true)
+    }
+
+    private fun asKeyword(keyword: String) = highlight(keyword, "DEFAULT_KEYWORD")
+
+    private fun asString(string: String) = highlight(string, "DEFAULT_STRING")
+
+    private fun asIdentifier(identifier: String) = highlight(identifier, "DEFAULT_IDENTIFIER")
+
+    private fun highlight(keyword: String, textAttributesKey: String) =
+        """<info descr="null" textAttributesKey="$textAttributesKey">$keyword</info>"""
+}
diff --git a/src/test/kotlin/nl/dirkgroot/structurizr/dsl/editing/formatter/SpacingTest.kt b/src/test/kotlin/nl/dirkgroot/structurizr/dsl/editing/formatter/SpacingTest.kt
index e1ac762..8b4610b 100644
--- a/src/test/kotlin/nl/dirkgroot/structurizr/dsl/editing/formatter/SpacingTest.kt
+++ b/src/test/kotlin/nl/dirkgroot/structurizr/dsl/editing/formatter/SpacingTest.kt
@@ -33,7 +33,7 @@ class SpacingTest : FormatterTest() {
     fun `identifier assignment`() {
         assertFormattingResult(
             """
-                a=softwareSystem system
+                a   =   softwareSystem system
             """.trimIndent(),
             """
                 a = softwareSystem system
diff --git a/src/test/kotlin/nl/dirkgroot/structurizr/dsl/lexer/AllKeywords.kt b/src/test/kotlin/nl/dirkgroot/structurizr/dsl/lexer/AllKeywords.kt
index 8b8da25..4eb06f6 100644
--- a/src/test/kotlin/nl/dirkgroot/structurizr/dsl/lexer/AllKeywords.kt
+++ b/src/test/kotlin/nl/dirkgroot/structurizr/dsl/lexer/AllKeywords.kt
@@ -4,76 +4,76 @@ import com.intellij.psi.tree.IElementType
 import nl.dirkgroot.structurizr.dsl.psi.SDTypes.*
 
 val KEYWORDS_WITH_BLOCKS = listOf(
-    "!adrs" to ADRS_KEYWORD,
-    "!constant" to CONSTANT_KEYWORD,
-    "!docs" to DOCS_KEYWORD,
-    "!identifiers" to IDENTIFIERS_KEYWORD,
-    "!impliedRelationships" to IMPLIED_RELATIONSHIPS_KEYWORD,
-    "!include" to INCLUDE_FILE_KEYWORD,
-    "!plugin" to PLUGIN_KEYWORD,
-    "!ref" to REF_KEYWORD,
-    "animation" to ANIMATION_KEYWORD,
-    "autoLayout" to AUTO_LAYOUT_KEYWORD,
-    "background" to BACKGROUND_KEYWORD,
-    "border" to BORDER_KEYWORD,
-    "color" to COLOR_KEYWORD,
-    "colour" to COLOUR_KEYWORD,
-    "component" to COMPONENT_KEYWORD,
-    "container" to CONTAINER_KEYWORD,
-    "containerInstance" to CONTAINER_INSTANCE,
-    "custom" to CUSTOM_KEYWORD,
-    "deployment" to DEPLOYMENT_KEYWORD,
-    "deploymentEnvironment" to DEPLOYMENT_ENVIRONMENT_KEYWORD,
-    "deploymentGroup" to DEPLOYMENT_GROUP_KEYWORD,
-    "deploymentNode" to DEPLOYMENT_NODE_KEYWORD,
-    "description" to DESCRIPTION_KEYWORD,
-    "dynamic" to DYNAMIC_KEYWORD,
-    "element" to ELEMENT_KEYWORD,
-    "enterprise" to ENTERPRISE_KEYWORD,
-    "exclude" to EXCLUDE_ELEMENT_KEYWORD,
-    "extends" to EXTENDS_KEYWORD,
-    "filtered" to FILTERED_KEYWORD,
-    "fontSize" to FONTSIZE_KEYWORD,
-    "group" to GROUP_KEYWORD,
-    "healthCheck" to HEALTH_CHECK_KEYWORD,
-    "height" to HEIGHT_KEYWORD,
-    "icon" to ICON_KEYWORD,
-    "include" to INCLUDE_ELEMENT_KEYWORD,
-    "infrastructureNode" to INFRASTRUCTURE_NODE_KEYWORD,
-    "instances" to INSTANCES_KEYWORD,
-    "metadata" to METADATA_KEYWORD,
-    "model" to MODEL_KEYWORD,
-    "opacity" to OPACITY_KEYWORD,
-    "person" to PERSON_KEYWORD,
-    "perspectives" to PERSPECTIVES_KEYWORD,
-    "position" to POSITION_KEYWORD,
-    "routing" to ROUTING_KEYWORD,
-    "shape" to SHAPE_KEYWORD,
-    "softwareSystem" to SOFTWARE_SYSTEM_KEYWORD,
-    "softwareSystemInstance" to SOFTWARE_SYSTEM_INSTANCE_KEYWORD,
-    "stroke" to STROKE_KEYWORD,
-    "strokeWidth" to STROKEWIDTH_KEYWORD,
-    "style" to STYLE_KEYWORD,
-    "styles" to STYLES_KEYWORD,
-    "systemContext" to SYSTEM_CONTEXT_KEYWORD,
-    "systemLandscape" to SYSTEM_LANDSCAPE_KEYWORD,
-    "tags" to TAGS_KEYWORD,
-    "technology" to TECHNOLOGY_KEYWORD,
-    "theme" to THEME_KEYWORD,
-    "thickness" to THICKNESS_KEYWORD,
-    "title" to TITLE_KEYWORD,
-    "url" to URL_KEYWORD,
-    "views" to VIEWS_KEYWORD,
-    "width" to WIDTH_KEYWORD,
-    "workspace" to WORKSPACE_KEYWORD,
+    "!adrs" to UNQUOTED_TEXT,
+    "!constant" to UNQUOTED_TEXT,
+    "!docs" to UNQUOTED_TEXT,
+    "!identifiers" to UNQUOTED_TEXT,
+    "!impliedRelationships" to UNQUOTED_TEXT,
+    "!include" to UNQUOTED_TEXT,
+    "!plugin" to UNQUOTED_TEXT,
+    "!ref" to UNQUOTED_TEXT,
+    "autoLayout" to UNQUOTED_TEXT,
+    "background" to UNQUOTED_TEXT,
+    "border" to UNQUOTED_TEXT,
+    "branding" to UNQUOTED_TEXT,
+    "color" to UNQUOTED_TEXT,
+    "colour" to UNQUOTED_TEXT,
+    "component" to UNQUOTED_TEXT,
+    "configuration" to UNQUOTED_TEXT,
+    "container" to UNQUOTED_TEXT,
+    "containerInstance" to UNQUOTED_TEXT,
+    "custom" to UNQUOTED_TEXT,
+    "deployment" to UNQUOTED_TEXT,
+    "deploymentEnvironment" to UNQUOTED_TEXT,
+    "deploymentGroup" to UNQUOTED_TEXT,
+    "deploymentNode" to UNQUOTED_TEXT,
+    "description" to UNQUOTED_TEXT,
+    "dynamic" to UNQUOTED_TEXT,
+    "element" to UNQUOTED_TEXT,
+    "enterprise" to UNQUOTED_TEXT,
+    "exclude" to UNQUOTED_TEXT,
+    "extends" to UNQUOTED_TEXT,
+    "filtered" to UNQUOTED_TEXT,
+    "fontSize" to UNQUOTED_TEXT,
+    "group" to UNQUOTED_TEXT,
+    "healthCheck" to UNQUOTED_TEXT,
+    "height" to UNQUOTED_TEXT,
+    "icon" to UNQUOTED_TEXT,
+    "include" to UNQUOTED_TEXT,
+    "infrastructureNode" to UNQUOTED_TEXT,
+    "instances" to UNQUOTED_TEXT,
+    "metadata" to UNQUOTED_TEXT,
+    "model" to UNQUOTED_TEXT,
+    "opacity" to UNQUOTED_TEXT,
+    "person" to UNQUOTED_TEXT,
+    "position" to UNQUOTED_TEXT,
+    "routing" to UNQUOTED_TEXT,
+    "shape" to UNQUOTED_TEXT,
+    "softwareSystem" to UNQUOTED_TEXT,
+    "softwareSystemInstance" to UNQUOTED_TEXT,
+    "stroke" to UNQUOTED_TEXT,
+    "strokeWidth" to UNQUOTED_TEXT,
+    "style" to UNQUOTED_TEXT,
+    "styles" to UNQUOTED_TEXT,
+    "systemContext" to UNQUOTED_TEXT,
+    "systemLandscape" to UNQUOTED_TEXT,
+    "tags" to UNQUOTED_TEXT,
+    "technology" to UNQUOTED_TEXT,
+    "terminology" to UNQUOTED_TEXT,
+    "theme" to UNQUOTED_TEXT,
+    "thickness" to UNQUOTED_TEXT,
+    "title" to UNQUOTED_TEXT,
+    "url" to UNQUOTED_TEXT,
+    "views" to UNQUOTED_TEXT,
+    "width" to UNQUOTED_TEXT,
+    "workspace" to UNQUOTED_TEXT,
 )
 
 val KEYWORDS_WITH_PROPERTY_BLOCKS = listOf<Pair<String, IElementType>>(
-    "branding" to BRANDING_KEYWORD,
-    "configuration" to CONFIGURATION_KEYWORD,
-    "properties" to PROPERTIES_KEYWORD,
-    "terminology" to TERMINOLOGY_KEYWORD,
-    "users" to USERS_KEYWORD,
+    "perspectives" to UNQUOTED_TEXT,
+    "properties" to UNQUOTED_TEXT,
+    "users" to UNQUOTED_TEXT,
 )
 
-val KEYWORDS = KEYWORDS_WITH_BLOCKS + KEYWORDS_WITH_PROPERTY_BLOCKS + listOf("!script" to SCRIPT_KEYWORD)
+val KEYWORDS = KEYWORDS_WITH_BLOCKS + KEYWORDS_WITH_PROPERTY_BLOCKS +
+    listOf("!script" to UNQUOTED_TEXT, "animation" to UNQUOTED_TEXT)
diff --git a/src/test/kotlin/nl/dirkgroot/structurizr/dsl/lexer/CaseInsensitiveTest.kt b/src/test/kotlin/nl/dirkgroot/structurizr/dsl/lexer/CaseInsensitiveTest.kt
index 8936ab4..b7f65a5 100644
--- a/src/test/kotlin/nl/dirkgroot/structurizr/dsl/lexer/CaseInsensitiveTest.kt
+++ b/src/test/kotlin/nl/dirkgroot/structurizr/dsl/lexer/CaseInsensitiveTest.kt
@@ -2,11 +2,11 @@ package nl.dirkgroot.structurizr.dsl.lexer
 
 import io.kotest.core.spec.style.StringSpec
 import io.kotest.matchers.collections.shouldContainExactly
-import nl.dirkgroot.structurizr.dsl.psi.SDTypes.WORKSPACE_KEYWORD
+import nl.dirkgroot.structurizr.dsl.psi.SDTypes.UNQUOTED_TEXT
 import nl.dirkgroot.structurizr.dsl.support.tokenize
 
 class CaseInsensitiveTest : StringSpec({
     "lexer is case insensitive" {
-        "WoRKSpacE".tokenize() shouldContainExactly listOf(WORKSPACE_KEYWORD to "WoRKSpacE")
+        "WoRKSpacE".tokenize() shouldContainExactly listOf(UNQUOTED_TEXT to "WoRKSpacE")
     }
 })
diff --git a/src/test/kotlin/nl/dirkgroot/structurizr/dsl/lexer/CommentsTest.kt b/src/test/kotlin/nl/dirkgroot/structurizr/dsl/lexer/CommentsTest.kt
index 3ebabae..cc8bb79 100644
--- a/src/test/kotlin/nl/dirkgroot/structurizr/dsl/lexer/CommentsTest.kt
+++ b/src/test/kotlin/nl/dirkgroot/structurizr/dsl/lexer/CommentsTest.kt
@@ -20,7 +20,7 @@ class CommentsTest : StringSpec({
 
     "line comment after other tokens" {
         "description text // comment\n".tokenize() shouldContainExactly listOf(
-            DESCRIPTION_KEYWORD to "description",
+            UNQUOTED_TEXT to "description",
             WHITE_SPACE to " ",
             UNQUOTED_TEXT to "text",
             WHITE_SPACE to " ",
@@ -41,7 +41,7 @@ class CommentsTest : StringSpec({
 
     "block comment between other tokens" {
         "description /* */ text".tokenize() shouldContainExactly listOf(
-            DESCRIPTION_KEYWORD to "description",
+            UNQUOTED_TEXT to "description",
             WHITE_SPACE to " ",
             UNQUOTED_TEXT to "/*",
             WHITE_SPACE to " ",
@@ -56,7 +56,7 @@ class CommentsTest : StringSpec({
             description text /* */
             description
         """.trimIndent().tokenize() shouldContainExactly listOf(
-            DESCRIPTION_KEYWORD to "description",
+            UNQUOTED_TEXT to "description",
             WHITE_SPACE to " ",
             UNQUOTED_TEXT to "text",
             WHITE_SPACE to " ",
@@ -64,7 +64,7 @@ class CommentsTest : StringSpec({
             WHITE_SPACE to " ",
             UNQUOTED_TEXT to "*/",
             CRLF to "\n",
-            DESCRIPTION_KEYWORD to "description"
+            UNQUOTED_TEXT to "description"
         )
     }
 
diff --git a/src/test/kotlin/nl/dirkgroot/structurizr/dsl/lexer/HierarchicalIdentifiersTest.kt b/src/test/kotlin/nl/dirkgroot/structurizr/dsl/lexer/HierarchicalIdentifiersTest.kt
index 4f83aa2..95e8f22 100644
--- a/src/test/kotlin/nl/dirkgroot/structurizr/dsl/lexer/HierarchicalIdentifiersTest.kt
+++ b/src/test/kotlin/nl/dirkgroot/structurizr/dsl/lexer/HierarchicalIdentifiersTest.kt
@@ -9,17 +9,17 @@ import nl.dirkgroot.structurizr.dsl.support.tokenize
 class HierarchicalIdentifiersTest : StringSpec({
     "one level" {
         "identifier1.child".tokenize() shouldContainExactly listOf(
-            IDENTIFIER to "identifier1.child"
+            UNQUOTED_TEXT to "identifier1.child"
         )
     }
 
     "as relationship destination" {
         "system1.frontend -> system2.backend description".tokenize() shouldContainExactly listOf(
-            IDENTIFIER to "system1.frontend",
+            UNQUOTED_TEXT to "system1.frontend",
             WHITE_SPACE to " ",
-            RELATIONSHIP_KEYWORD to "->",
+            ARROW to "->",
             WHITE_SPACE to " ",
-            IDENTIFIER to "system2.backend",
+            UNQUOTED_TEXT to "system2.backend",
             WHITE_SPACE to " ",
             UNQUOTED_TEXT to "description"
         )
diff --git a/src/test/kotlin/nl/dirkgroot/structurizr/dsl/lexer/IdentifierTest.kt b/src/test/kotlin/nl/dirkgroot/structurizr/dsl/lexer/IdentifierTest.kt
index 4d08e27..b73cfb0 100644
--- a/src/test/kotlin/nl/dirkgroot/structurizr/dsl/lexer/IdentifierTest.kt
+++ b/src/test/kotlin/nl/dirkgroot/structurizr/dsl/lexer/IdentifierTest.kt
@@ -8,16 +8,16 @@ import nl.dirkgroot.structurizr.dsl.support.tokenize
 
 class IdentifierTest : StringSpec({
     "valid individual token" {
-        "valid_identifier".tokenize() shouldContainExactly listOf(IDENTIFIER to "valid_identifier")
+        "valid_identifier".tokenize() shouldContainExactly listOf(UNQUOTED_TEXT to "valid_identifier")
     }
 
     "identifier assignment" {
         "valid_identifier = softwareSystem name".tokenize() shouldContainExactly listOf(
-            IDENTIFIER to "valid_identifier",
+            UNQUOTED_TEXT to "valid_identifier",
             WHITE_SPACE to " ",
             EQUALS to "=",
             WHITE_SPACE to " ",
-            SOFTWARE_SYSTEM_KEYWORD to "softwareSystem",
+            UNQUOTED_TEXT to "softwareSystem",
             WHITE_SPACE to " ",
             UNQUOTED_TEXT to "name",
         )
diff --git a/src/test/kotlin/nl/dirkgroot/structurizr/dsl/lexer/KeywordsTest.kt b/src/test/kotlin/nl/dirkgroot/structurizr/dsl/lexer/KeywordsTest.kt
index 6ac5be1..8b8ac64 100644
--- a/src/test/kotlin/nl/dirkgroot/structurizr/dsl/lexer/KeywordsTest.kt
+++ b/src/test/kotlin/nl/dirkgroot/structurizr/dsl/lexer/KeywordsTest.kt
@@ -55,7 +55,7 @@ class KeywordsTest : FunSpec({
                 BRACE1 to "{",
                 CRLF to "\n",
                 WHITE_SPACE to "    ",
-                DESCRIPTION_KEYWORD to "description",
+                UNQUOTED_TEXT to "description",
                 WHITE_SPACE to " ",
                 UNQUOTED_TEXT to "description2",
                 CRLF to "\n",
@@ -115,7 +115,11 @@ class KeywordsTest : FunSpec({
                 WHITE_SPACE to " ",
                 UNQUOTED_TEXT to "value",
                 WHITE_SPACE to " ",
-                LINE_COMMENT to "// line comment",
+                UNQUOTED_TEXT to "//",
+                WHITE_SPACE to " ",
+                UNQUOTED_TEXT to "line",
+                WHITE_SPACE to " ",
+                UNQUOTED_TEXT to "comment",
                 CRLF to "\n",
                 BRACE2 to "}",
             )
@@ -143,12 +147,24 @@ class KeywordsTest : FunSpec({
                 WHITE_SPACE to " ",
                 UNQUOTED_TEXT to "value",
                 WHITE_SPACE to " ",
-                BLOCK_COMMENT to "/* block comment */",
+                UNQUOTED_TEXT to "/*",
+                WHITE_SPACE to " ",
+                UNQUOTED_TEXT to "block",
+                WHITE_SPACE to " ",
+                UNQUOTED_TEXT to "comment",
+                WHITE_SPACE to " ",
+                UNQUOTED_TEXT to "*/",
                 CRLF to "\n",
                 WHITE_SPACE to "    ",
                 UNQUOTED_TEXT to "name",
                 WHITE_SPACE to " ",
-                BLOCK_COMMENT to "/* block comment */",
+                UNQUOTED_TEXT to "/*",
+                WHITE_SPACE to " ",
+                UNQUOTED_TEXT to "block",
+                WHITE_SPACE to " ",
+                UNQUOTED_TEXT to "comment",
+                WHITE_SPACE to " ",
+                UNQUOTED_TEXT to "*/",
                 WHITE_SPACE to " ",
                 UNQUOTED_TEXT to "value",
                 CRLF to "\n",
diff --git a/src/test/kotlin/nl/dirkgroot/structurizr/dsl/lexer/MeaningfulLineTerminatorsTest.kt b/src/test/kotlin/nl/dirkgroot/structurizr/dsl/lexer/MeaningfulLineTerminatorsTest.kt
index 94d240a..18d99fa 100644
--- a/src/test/kotlin/nl/dirkgroot/structurizr/dsl/lexer/MeaningfulLineTerminatorsTest.kt
+++ b/src/test/kotlin/nl/dirkgroot/structurizr/dsl/lexer/MeaningfulLineTerminatorsTest.kt
@@ -9,7 +9,7 @@ import nl.dirkgroot.structurizr.dsl.support.tokenize
 class MeaningfulLineTerminatorsTest : StringSpec({
     "carriage return" {
         "description text\r".tokenize() shouldContainExactly listOf(
-            DESCRIPTION_KEYWORD to "description",
+            UNQUOTED_TEXT to "description",
             WHITE_SPACE to " ",
             UNQUOTED_TEXT to "text",
             CRLF to "\r"
@@ -18,7 +18,7 @@ class MeaningfulLineTerminatorsTest : StringSpec({
 
     "line feed" {
         "description text\n".tokenize() shouldContainExactly listOf(
-            DESCRIPTION_KEYWORD to "description",
+            UNQUOTED_TEXT to "description",
             WHITE_SPACE to " ",
             UNQUOTED_TEXT to "text",
             CRLF to "\n"
@@ -27,7 +27,7 @@ class MeaningfulLineTerminatorsTest : StringSpec({
 
     "carriage return + line feed" {
         "description text\r\n".tokenize() shouldContainExactly listOf(
-            DESCRIPTION_KEYWORD to "description",
+            UNQUOTED_TEXT to "description",
             WHITE_SPACE to (" "),
             UNQUOTED_TEXT to "text",
             CRLF to "\r\n"
diff --git a/src/test/kotlin/nl/dirkgroot/structurizr/dsl/lexer/PropertiesTest.kt b/src/test/kotlin/nl/dirkgroot/structurizr/dsl/lexer/PropertiesTest.kt
index a7ab4ca..bb320de 100644
--- a/src/test/kotlin/nl/dirkgroot/structurizr/dsl/lexer/PropertiesTest.kt
+++ b/src/test/kotlin/nl/dirkgroot/structurizr/dsl/lexer/PropertiesTest.kt
@@ -15,7 +15,7 @@ class PropertiesTest : StringSpec({
                 properties description
             }
         """.trimIndent().tokenize() shouldContainExactly listOf(
-            PROPERTIES_KEYWORD to "properties",
+            UNQUOTED_TEXT to "properties",
             WHITE_SPACE to " ",
             BRACE1 to "{",
             CRLF to "\n",
@@ -45,7 +45,7 @@ class PropertiesTest : StringSpec({
                 name value // line comment
             }
         """.trimIndent().tokenize() shouldContainExactly listOf(
-            PROPERTIES_KEYWORD to "properties",
+            UNQUOTED_TEXT to "properties",
             WHITE_SPACE to " ",
             BRACE1 to "{",
             CRLF to "\n",
@@ -57,7 +57,11 @@ class PropertiesTest : StringSpec({
             WHITE_SPACE to " ",
             UNQUOTED_TEXT to "value",
             WHITE_SPACE to " ",
-            LINE_COMMENT to "// line comment",
+            UNQUOTED_TEXT to "//",
+            WHITE_SPACE to " ",
+            UNQUOTED_TEXT to "line",
+            WHITE_SPACE to " ",
+            UNQUOTED_TEXT to "comment",
             CRLF to "\n",
             BRACE2 to "}",
         )
@@ -73,7 +77,7 @@ class PropertiesTest : StringSpec({
                    comment */
             }
         """.trimIndent().tokenize() shouldContainExactly listOf(
-            PROPERTIES_KEYWORD to "properties",
+            UNQUOTED_TEXT to "properties",
             WHITE_SPACE to " ",
             BRACE1 to "{",
             CRLF to "\n",
@@ -85,12 +89,24 @@ class PropertiesTest : StringSpec({
             WHITE_SPACE to " ",
             UNQUOTED_TEXT to "value",
             WHITE_SPACE to " ",
-            BLOCK_COMMENT to "/* block comment */",
+            UNQUOTED_TEXT to "/*",
+            WHITE_SPACE to " ",
+            UNQUOTED_TEXT to "block",
+            WHITE_SPACE to " ",
+            UNQUOTED_TEXT to "comment",
+            WHITE_SPACE to " ",
+            UNQUOTED_TEXT to "*/",
             CRLF to "\n",
             WHITE_SPACE to "    ",
             UNQUOTED_TEXT to "name",
             WHITE_SPACE to " ",
-            BLOCK_COMMENT to "/* block comment */",
+            UNQUOTED_TEXT to "/*",
+            WHITE_SPACE to " ",
+            UNQUOTED_TEXT to "block",
+            WHITE_SPACE to " ",
+            UNQUOTED_TEXT to "comment",
+            WHITE_SPACE to " ",
+            UNQUOTED_TEXT to "*/",
             WHITE_SPACE to " ",
             UNQUOTED_TEXT to "value",
             CRLF to "\n",
diff --git a/src/test/kotlin/nl/dirkgroot/structurizr/dsl/lexer/RelationshipTest.kt b/src/test/kotlin/nl/dirkgroot/structurizr/dsl/lexer/RelationshipTest.kt
index daff57d..4092389 100644
--- a/src/test/kotlin/nl/dirkgroot/structurizr/dsl/lexer/RelationshipTest.kt
+++ b/src/test/kotlin/nl/dirkgroot/structurizr/dsl/lexer/RelationshipTest.kt
@@ -3,18 +3,18 @@ package nl.dirkgroot.structurizr.dsl.lexer
 import com.intellij.psi.TokenType.WHITE_SPACE
 import io.kotest.core.spec.style.StringSpec
 import io.kotest.matchers.collections.shouldContainExactly
-import nl.dirkgroot.structurizr.dsl.psi.SDTypes.IDENTIFIER
-import nl.dirkgroot.structurizr.dsl.psi.SDTypes.RELATIONSHIP_KEYWORD
+import nl.dirkgroot.structurizr.dsl.psi.SDTypes.ARROW
+import nl.dirkgroot.structurizr.dsl.psi.SDTypes.UNQUOTED_TEXT
 import nl.dirkgroot.structurizr.dsl.support.tokenize
 
 class RelationshipTest : StringSpec({
     "basic form" {
         "system1 -> system2".tokenize() shouldContainExactly listOf(
-            IDENTIFIER to "system1",
+            UNQUOTED_TEXT to "system1",
             WHITE_SPACE to " ",
-            RELATIONSHIP_KEYWORD to "->",
+            ARROW to "->",
             WHITE_SPACE to " ",
-            IDENTIFIER to "system2",
+            UNQUOTED_TEXT to "system2",
         )
     }
 })
diff --git a/src/test/kotlin/nl/dirkgroot/structurizr/dsl/lexer/ScriptBlockTest.kt b/src/test/kotlin/nl/dirkgroot/structurizr/dsl/lexer/ScriptBlockTest.kt
index 1758511..6047610 100644
--- a/src/test/kotlin/nl/dirkgroot/structurizr/dsl/lexer/ScriptBlockTest.kt
+++ b/src/test/kotlin/nl/dirkgroot/structurizr/dsl/lexer/ScriptBlockTest.kt
@@ -9,7 +9,7 @@ import nl.dirkgroot.structurizr.dsl.support.tokenize
 class ScriptBlockTest : StringSpec({
     "arguments, no block" {
         "!script kotlin arg2 arg3".tokenize() shouldContainExactly listOf(
-            SCRIPT_KEYWORD to "!script",
+            UNQUOTED_TEXT to "!script",
             WHITE_SPACE to " ",
             UNQUOTED_TEXT to "kotlin",
             WHITE_SPACE to " ",
@@ -25,12 +25,10 @@ class ScriptBlockTest : StringSpec({
                 some arbitrary code
             }
         """.trimIndent().tokenize() shouldContainExactly listOf(
-            SCRIPT_KEYWORD to "!script",
+            UNQUOTED_TEXT to "!script",
             WHITE_SPACE to " ",
             BRACE1 to "{",
-            SCRIPT_TEXT to "\n",
-            SCRIPT_TEXT to "    some arbitrary code",
-            SCRIPT_TEXT to "\n",
+            SCRIPT_TEXT to "\n    some arbitrary code\n",
             BRACE2 to "}"
         )
     }
@@ -41,14 +39,12 @@ class ScriptBlockTest : StringSpec({
                 some arbitrary code
             }
         """.trimIndent().tokenize() shouldContainExactly listOf(
-            SCRIPT_KEYWORD to "!script",
+            UNQUOTED_TEXT to "!script",
             WHITE_SPACE to " ",
             UNQUOTED_TEXT to "kotlin",
             WHITE_SPACE to " ",
             BRACE1 to "{",
-            SCRIPT_TEXT to "\n",
-            SCRIPT_TEXT to "    some arbitrary code",
-            SCRIPT_TEXT to "\n",
+            SCRIPT_TEXT to "\n    some arbitrary code\n",
             BRACE2 to "}"
         )
     }
@@ -60,13 +56,10 @@ class ScriptBlockTest : StringSpec({
             |    }
         """.trimMargin().tokenize() shouldContainExactly listOf(
             WHITE_SPACE to "    ",
-            SCRIPT_KEYWORD to "!script",
+            UNQUOTED_TEXT to "!script",
             WHITE_SPACE to " ",
             BRACE1 to "{",
-            SCRIPT_TEXT to "\n",
-            SCRIPT_TEXT to "        some arbitrary code",
-            SCRIPT_TEXT to "\n",
-            SCRIPT_TEXT to "    ",
+            SCRIPT_TEXT to "\n        some arbitrary code\n    ",
             BRACE2 to "}"
         )
     }
diff --git a/src/test/kotlin/nl/dirkgroot/structurizr/dsl/lexer/TextTest.kt b/src/test/kotlin/nl/dirkgroot/structurizr/dsl/lexer/TextTest.kt
index b7d6b4a..1955197 100644
--- a/src/test/kotlin/nl/dirkgroot/structurizr/dsl/lexer/TextTest.kt
+++ b/src/test/kotlin/nl/dirkgroot/structurizr/dsl/lexer/TextTest.kt
@@ -9,7 +9,7 @@ import nl.dirkgroot.structurizr.dsl.support.tokenize
 class TextTest : StringSpec({
     "unquoted text" {
         "description unquoted text words".tokenize() shouldContainExactly listOf(
-            DESCRIPTION_KEYWORD to "description",
+            UNQUOTED_TEXT to "description",
             WHITE_SPACE to " ",
             UNQUOTED_TEXT to "unquoted",
             WHITE_SPACE to " ",
@@ -21,7 +21,7 @@ class TextTest : StringSpec({
 
     "quoted text" {
         "description \"unquoted text words\"".tokenize() shouldContainExactly listOf(
-            DESCRIPTION_KEYWORD to "description",
+            UNQUOTED_TEXT to "description",
             WHITE_SPACE to " ",
             QUOTED_TEXT to "\"unquoted text words\"",
         )
@@ -29,7 +29,7 @@ class TextTest : StringSpec({
 
     "quoted text without closing quotes" {
         "description \"unquoted text words".tokenize() shouldContainExactly listOf(
-            DESCRIPTION_KEYWORD to "description",
+            UNQUOTED_TEXT to "description",
             WHITE_SPACE to " ",
             QUOTED_TEXT to "\"unquoted text words",
         )
@@ -37,7 +37,7 @@ class TextTest : StringSpec({
 
     "quoted text without closing quotes and crlf" {
         "description \"unquoted text words\n".tokenize() shouldContainExactly listOf(
-            DESCRIPTION_KEYWORD to "description",
+            UNQUOTED_TEXT to "description",
             WHITE_SPACE to " ",
             QUOTED_TEXT to "\"unquoted text words",
             CRLF to "\n"
diff --git a/src/test/kotlin/nl/dirkgroot/structurizr/dsl/parser/AnimationTest.kt b/src/test/kotlin/nl/dirkgroot/structurizr/dsl/parser/AnimationTest.kt
new file mode 100644
index 0000000..2d8ba12
--- /dev/null
+++ b/src/test/kotlin/nl/dirkgroot/structurizr/dsl/parser/AnimationTest.kt
@@ -0,0 +1,65 @@
+package nl.dirkgroot.structurizr.dsl.parser
+
+import nl.dirkgroot.structurizr.dsl.support.StructurizrDSLCodeInsightTest
+import org.junit.jupiter.api.Test
+
+class AnimationTest : StructurizrDSLCodeInsightTest() {
+    @Test
+    fun `single identifier reference on one line`() {
+        assertPsiTree(
+            """
+                animation {
+                    someIdentifier
+                }
+            """.trimIndent(),
+            """
+                AnimationStatement
+                    AnimationKeyword animation
+                    IdentifierReferencesStatement
+                        IdentifierReference someIdentifier
+            """.trimIndent()
+        )
+    }
+
+    @Test
+    fun `multiple identifier references on one line`() {
+        assertPsiTree(
+            """
+                animation {
+                    someIdentifier1 someIdentifier2
+                }
+            """.trimIndent(),
+            """
+                AnimationStatement
+                    AnimationKeyword animation
+                    IdentifierReferencesStatement
+                        IdentifierReference someIdentifier1
+                        IdentifierReference someIdentifier2
+            """.trimIndent()
+        )
+    }
+
+    @Test
+    fun `multiple lines with identifier references`() {
+        assertPsiTree(
+            """
+                animation {
+                    someIdentifier1 someIdentifier2
+                    someIdentifier3
+                    someIdentifier4
+                }
+            """.trimIndent(),
+            """
+                AnimationStatement
+                    AnimationKeyword animation
+                    IdentifierReferencesStatement
+                        IdentifierReference someIdentifier1
+                        IdentifierReference someIdentifier2
+                    IdentifierReferencesStatement
+                        IdentifierReference someIdentifier3
+                    IdentifierReferencesStatement
+                        IdentifierReference someIdentifier4
+            """.trimIndent()
+        )
+    }
+}
diff --git a/src/test/kotlin/nl/dirkgroot/structurizr/dsl/parser/ElementsWithBlocksOfElementsTest.kt b/src/test/kotlin/nl/dirkgroot/structurizr/dsl/parser/ElementsWithBlocksOfElementsTest.kt
index c52889a..20454ea 100644
--- a/src/test/kotlin/nl/dirkgroot/structurizr/dsl/parser/ElementsWithBlocksOfElementsTest.kt
+++ b/src/test/kotlin/nl/dirkgroot/structurizr/dsl/parser/ElementsWithBlocksOfElementsTest.kt
@@ -17,6 +17,7 @@ class ElementsWithBlocksOfElementsTest : StructurizrDSLCodeInsightTest() {
                 """
                     BlockStatement
                         Keyword $keyword
+                        Block {\n}
                 """.trimIndent()
             )
         }
@@ -35,6 +36,7 @@ class ElementsWithBlocksOfElementsTest : StructurizrDSLCodeInsightTest() {
                 """
                     BlockStatement
                         Keyword $keyword
+                        Block {\n\n\n}
                 """.trimIndent()
             )
         }
@@ -53,9 +55,10 @@ class ElementsWithBlocksOfElementsTest : StructurizrDSLCodeInsightTest() {
                 """
                     BlockStatement
                         Keyword $keyword
-                        SingleLineStatement
-                            Keyword $elementKeyword
-                            Argument arg1
+                        Block
+                            SingleLineStatement
+                                Keyword $elementKeyword
+                                Argument arg1
                 """.trimIndent()
             )
         }
@@ -77,15 +80,16 @@ class ElementsWithBlocksOfElementsTest : StructurizrDSLCodeInsightTest() {
                 """
                     BlockStatement
                         Keyword $keyword
-                        SingleLineStatement
-                            Keyword $elementKeyword
-                            Argument arg1
-                        SingleLineStatement
-                            Keyword $elementKeyword
-                            Argument arg2
-                        SingleLineStatement
-                            Keyword $elementKeyword
-                            Argument arg3
+                        Block
+                            SingleLineStatement
+                                Keyword $elementKeyword
+                                Argument arg1
+                            SingleLineStatement
+                                Keyword $elementKeyword
+                                Argument arg2
+                            SingleLineStatement
+                                Keyword $elementKeyword
+                                Argument arg3
                 """.trimIndent()
             )
         }
@@ -107,12 +111,15 @@ class ElementsWithBlocksOfElementsTest : StructurizrDSLCodeInsightTest() {
                 """
                     BlockStatement
                         Keyword $keyword
-                        BlockStatement
-                            Keyword $elementKeyword
-                            Argument arg1
-                        BlockStatement
-                            Keyword $elementKeyword
-                            Argument arg2
+                        Block
+                            BlockStatement
+                                Keyword $elementKeyword
+                                Argument arg1
+                                Block {\n    }
+                            BlockStatement
+                                Keyword $elementKeyword
+                                Argument arg2
+                                Block {\n    }
                 """.trimIndent()
             )
         }
diff --git a/src/test/kotlin/nl/dirkgroot/structurizr/dsl/parser/ElementsWithPropertyBlocksTest.kt b/src/test/kotlin/nl/dirkgroot/structurizr/dsl/parser/ElementsWithPropertyBlocksTest.kt
index ceea916..6e8ab2d 100644
--- a/src/test/kotlin/nl/dirkgroot/structurizr/dsl/parser/ElementsWithPropertyBlocksTest.kt
+++ b/src/test/kotlin/nl/dirkgroot/structurizr/dsl/parser/ElementsWithPropertyBlocksTest.kt
@@ -15,8 +15,9 @@ class ElementsWithPropertyBlocksTest : StructurizrDSLCodeInsightTest() {
                     }
                 """.trimIndent(),
                 """
-                    PropertyBlockStatement
-                        KeywordWithPropertyBlock $keyword
+                    PropertiesStatement
+                        PropertiesKeyword $keyword
+                        PropertiesBlock {\n}
                 """.trimIndent()
             )
         }
@@ -34,8 +35,9 @@ class ElementsWithPropertyBlocksTest : StructurizrDSLCodeInsightTest() {
                     }
                 """.trimIndent(),
                 """
-                    PropertyBlockStatement
-                        KeywordWithPropertyBlock $keyword
+                    PropertiesStatement
+                        PropertiesKeyword $keyword
+                        PropertiesBlock {\n\n\n\n}
                 """.trimIndent()
             )
         }
@@ -51,11 +53,12 @@ class ElementsWithPropertyBlocksTest : StructurizrDSLCodeInsightTest() {
                     }
                 """.trimIndent(),
                 """
-                    PropertyBlockStatement
-                        KeywordWithPropertyBlock $keyword
-                        KeyValuePair
-                            Key key
-                            Value value
+                    PropertiesStatement
+                        PropertiesKeyword $keyword
+                        PropertiesBlock
+                            PropertyDefinition
+                                PropertyKey key
+                                PropertyValue value
                 """.trimIndent()
             )
         }
@@ -74,20 +77,21 @@ class ElementsWithPropertyBlocksTest : StructurizrDSLCodeInsightTest() {
                     }
                 """.trimIndent(),
                 """
-                    PropertyBlockStatement
-                        KeywordWithPropertyBlock $keyword
-                        KeyValuePair
-                            Key key1
-                            Value value1
-                        KeyValuePair
-                            Key key2
-                            Value "value 2"
-                        KeyValuePair
-                            Key "key 3"
-                            Value value3
-                        KeyValuePair
-                            Key "key 4"
-                            Value "value 4"
+                    PropertiesStatement
+                        PropertiesKeyword $keyword
+                        PropertiesBlock
+                            PropertyDefinition
+                                PropertyKey key1
+                                PropertyValue value1
+                            PropertyDefinition
+                                PropertyKey key2
+                                PropertyValue "value 2"
+                            PropertyDefinition
+                                PropertyKey "key 3"
+                                PropertyValue value3
+                            PropertyDefinition
+                                PropertyKey "key 4"
+                                PropertyValue "value 4"
                 """.trimIndent()
             )
         }
diff --git a/src/test/kotlin/nl/dirkgroot/structurizr/dsl/parser/IdentifierAssignmentTest.kt b/src/test/kotlin/nl/dirkgroot/structurizr/dsl/parser/IdentifierAssignmentTest.kt
index d783297..516439a 100644
--- a/src/test/kotlin/nl/dirkgroot/structurizr/dsl/parser/IdentifierAssignmentTest.kt
+++ b/src/test/kotlin/nl/dirkgroot/structurizr/dsl/parser/IdentifierAssignmentTest.kt
@@ -10,12 +10,13 @@ class IdentifierAssignmentTest : StructurizrDSLCodeInsightTest() {
     fun `identifier assignment to single line element`() = KEYWORDS.map { (keyword, _) ->
         dynamicTest(keyword) {
             assertPsiTree(
-                """identifier = softwareSystem blaat""",
+                """identifier = $keyword blaat""",
                 """
-                    SingleLineStatement
-                        IdentifierName identifier
-                        Keyword softwareSystem
-                        Argument blaat
+                    IdentifierAssignmentStatement
+                        IdentifierReference identifier
+                        SingleLineStatement
+                            Keyword $keyword
+                            Argument blaat
                 """.trimIndent()
             )
         }
@@ -31,13 +32,15 @@ class IdentifierAssignmentTest : StructurizrDSLCodeInsightTest() {
                     }
                 """.trimIndent(),
                 """
-                    BlockStatement
-                        IdentifierName identifier
-                        Keyword softwareSystem
-                        Argument blaat
-                        SingleLineStatement
-                            Keyword container
-                            Argument containerName
+                    IdentifierAssignmentStatement
+                        IdentifierReference identifier
+                        BlockStatement
+                            Keyword softwareSystem
+                            Argument blaat
+                            Block
+                                SingleLineStatement
+                                    Keyword container
+                                    Argument containerName
                  """.trimIndent()
             )
         }
@@ -55,10 +58,12 @@ class IdentifierAssignmentTest : StructurizrDSLCodeInsightTest() {
                 """
                     BlockStatement
                         Keyword model
-                        SingleLineStatement
-                            IdentifierName identifier
-                            Keyword softwareSystem
-                            Argument name
+                        Block
+                            IdentifierAssignmentStatement
+                                IdentifierReference identifier
+                                SingleLineStatement
+                                    Keyword softwareSystem
+                                    Argument name
                 """.trimIndent()
             )
         }
diff --git a/src/test/kotlin/nl/dirkgroot/structurizr/dsl/parser/LineWithIdentifierReferencesTest.kt b/src/test/kotlin/nl/dirkgroot/structurizr/dsl/parser/LineWithIdentifierReferencesTest.kt
deleted file mode 100644
index 0f66d4d..0000000
--- a/src/test/kotlin/nl/dirkgroot/structurizr/dsl/parser/LineWithIdentifierReferencesTest.kt
+++ /dev/null
@@ -1,53 +0,0 @@
-package nl.dirkgroot.structurizr.dsl.parser
-
-import nl.dirkgroot.structurizr.dsl.support.StructurizrDSLCodeInsightTest
-import org.junit.jupiter.api.Test
-
-class LineWithIdentifierReferencesTest : StructurizrDSLCodeInsightTest() {
-    @Test
-    fun `single identifier reference on one line`() {
-        assertPsiTree(
-            """
-                someIdentifier
-            """.trimIndent(),
-            """
-                IdentifierReferences
-                    IdentifierName someIdentifier
-            """.trimIndent()
-        )
-    }
-
-    @Test
-    fun `multiple identifier references on one line`() {
-        assertPsiTree(
-            """
-                someIdentifier1 someIdentifier2
-            """.trimIndent(),
-            """
-                IdentifierReferences
-                    IdentifierName someIdentifier1
-                    IdentifierName someIdentifier2
-            """.trimIndent()
-        )
-    }
-
-    @Test
-    fun `multiple lines with identifier references`() {
-        assertPsiTree(
-            """
-                someIdentifier1 someIdentifier2
-                someIdentifier3
-                someIdentifier4
-            """.trimIndent(),
-            """
-                IdentifierReferences
-                    IdentifierName someIdentifier1
-                    IdentifierName someIdentifier2
-                IdentifierReferences
-                    IdentifierName someIdentifier3
-                IdentifierReferences
-                    IdentifierName someIdentifier4
-            """.trimIndent()
-        )
-    }
-}
diff --git a/src/test/kotlin/nl/dirkgroot/structurizr/dsl/parser/NonCodeElementsTest.kt b/src/test/kotlin/nl/dirkgroot/structurizr/dsl/parser/NonCodeElementsTest.kt
index 156a498..9b99747 100644
--- a/src/test/kotlin/nl/dirkgroot/structurizr/dsl/parser/NonCodeElementsTest.kt
+++ b/src/test/kotlin/nl/dirkgroot/structurizr/dsl/parser/NonCodeElementsTest.kt
@@ -22,7 +22,12 @@ class NonCodeElementsTest : StructurizrDSLCodeInsightTest() {
 
     @Test
     fun `line comment`() {
-        assertPsiTree("// comment", "PsiComment // comment")
+        assertPsiTree(
+            "// comment",
+            """
+                LineCommentStatement // comment
+            """.trimIndent()
+        )
     }
 
     @Test
@@ -33,9 +38,8 @@ class NonCodeElementsTest : StructurizrDSLCodeInsightTest() {
                 // another comment
             """.trimIndent(),
             """
-                PsiComment // comment
-                LeafPsiElement \n
-                PsiComment // another comment
+                LineCommentStatement // comment\n
+                LineCommentStatement // another comment
             """.trimIndent()
         )
     }
@@ -45,8 +49,7 @@ class NonCodeElementsTest : StructurizrDSLCodeInsightTest() {
         assertPsiTree(
             "// comment\n",
             """
-                PsiComment // comment
-                LeafPsiElement \n
+                LineCommentStatement // comment\n
             """.trimIndent()
         )
     }
@@ -55,7 +58,9 @@ class NonCodeElementsTest : StructurizrDSLCodeInsightTest() {
     fun `block comment single line`() {
         assertPsiTree(
             "/* block comment */",
-            "PsiComment /* block comment */"
+            """
+                BlockCommentStatement /* block comment */
+            """.trimIndent()
         )
     }
 
@@ -66,7 +71,9 @@ class NonCodeElementsTest : StructurizrDSLCodeInsightTest() {
                 /* block
                    comment */
             """.trimIndent(),
-            """PsiComment /* block\n   comment */"""
+            """
+                BlockCommentStatement /* block\n   comment */
+            """.trimIndent()
         )
     }
 }
diff --git a/src/test/kotlin/nl/dirkgroot/structurizr/dsl/parser/RelationshipTest.kt b/src/test/kotlin/nl/dirkgroot/structurizr/dsl/parser/RelationshipTest.kt
index 9e5dfc0..7116ffc 100644
--- a/src/test/kotlin/nl/dirkgroot/structurizr/dsl/parser/RelationshipTest.kt
+++ b/src/test/kotlin/nl/dirkgroot/structurizr/dsl/parser/RelationshipTest.kt
@@ -9,9 +9,10 @@ class RelationshipTest : StructurizrDSLCodeInsightTest() {
         assertPsiTree(
             """a -> b""",
             """
-                ExplicitRelationship
-                    IdentifierName a
-                    IdentifierName b
+                ExplicitRelationshipStatement
+                    RelationshipSource a
+                    RelationshipKeyword ->
+                    RelationshipDestination b
             """.trimIndent()
         )
     }
@@ -21,8 +22,9 @@ class RelationshipTest : StructurizrDSLCodeInsightTest() {
         assertPsiTree(
             """-> b""",
             """
-                ImplicitRelationship
-                    IdentifierName b
+                ImplicitRelationshipStatement
+                    RelationshipKeyword ->
+                    RelationshipDestination b
             """.trimIndent()
         )
     }
@@ -32,25 +34,62 @@ class RelationshipTest : StructurizrDSLCodeInsightTest() {
         assertPsiTree(
             """a -> b arg1 arg2""",
             """
-                ExplicitRelationship
-                    IdentifierName a
-                    IdentifierName b
+                ExplicitRelationshipStatement
+                    RelationshipSource a
+                    RelationshipKeyword ->
+                    RelationshipDestination b
                     Argument arg1
                     Argument arg2
             """.trimIndent()
         )
     }
 
+    @Test
+    fun `explicit relationship with block`() {
+        assertPsiTree(
+            """
+                a -> b arg1 {
+                }
+            """.trimIndent(),
+            """
+                ExplicitRelationshipStatement
+                    RelationshipSource a
+                    RelationshipKeyword ->
+                    RelationshipDestination b
+                    Argument arg1
+                    Block {\n}
+            """.trimIndent()
+        )
+    }
+
     @Test
     fun `implicit with arguments`() {
         assertPsiTree(
             """-> b arg1 arg2""",
             """
-                ImplicitRelationship
-                    IdentifierName b
+                ImplicitRelationshipStatement
+                    RelationshipKeyword ->
+                    RelationshipDestination b
                     Argument arg1
                     Argument arg2
             """.trimIndent()
         )
     }
+
+    @Test
+    fun `implicit relationship with block`() {
+        assertPsiTree(
+            """
+                -> b arg1 {
+                }
+            """.trimIndent(),
+            """
+                ImplicitRelationshipStatement
+                    RelationshipKeyword ->
+                    RelationshipDestination b
+                    Argument arg1
+                    Block {\n}
+            """.trimIndent()
+        )
+    }
 }
diff --git a/src/test/kotlin/nl/dirkgroot/structurizr/dsl/parser/ScriptBlockTest.kt b/src/test/kotlin/nl/dirkgroot/structurizr/dsl/parser/ScriptBlockTest.kt
index da7d050..cd1f42c 100644
--- a/src/test/kotlin/nl/dirkgroot/structurizr/dsl/parser/ScriptBlockTest.kt
+++ b/src/test/kotlin/nl/dirkgroot/structurizr/dsl/parser/ScriptBlockTest.kt
@@ -12,8 +12,9 @@ class ScriptBlockTest : StructurizrDSLCodeInsightTest() {
                 }
             """.trimIndent(),
             """
-                ScriptBlock
-                    ScriptContents \n
+                ScriptStatement
+                    ScriptKeyword !script
+                    ScriptBlock {\n}
             """.trimIndent()
         )
     }
@@ -26,10 +27,11 @@ class ScriptBlockTest : StructurizrDSLCodeInsightTest() {
                 }
             """.trimIndent(),
             """
-                ScriptBlock
+                ScriptStatement
+                    ScriptKeyword !script
                     Argument kotlin
                     Argument arg2
-                    ScriptContents \n
+                    ScriptBlock {\n}
             """.trimIndent()
         )
     }
@@ -44,9 +46,10 @@ class ScriptBlockTest : StructurizrDSLCodeInsightTest() {
                 }
             """.trimIndent(),
             """
-                ScriptBlock
+                ScriptStatement
+                    ScriptKeyword !script
                     Argument kotlin
-                    ScriptContents \n    println("Hello World...")\n    println("...from a script block")\n
+                    ScriptBlock {\n    println("Hello World...")\n    println("...from a script block")\n}
             """.trimIndent()
         )
     }