From d5604275a4f82cfe7b49ba99b9acf5998bde181b Mon Sep 17 00:00:00 2001
From: Asintoto <sommatoria0@gmail.com>
Date: Sat, 22 Nov 2025 10:45:22 +0100
Subject: [PATCH 1/7] decode to map

---
 .idea/gradle.xml                              |  2 +-
 .idea/misc.xml                                |  2 +-
 src/main/java/dev/toonformat/jtoon/JToon.java | 59 +++++++++++++++++++
 .../jtoon/JToonDecodeToMapTest.java           | 46 +++++++++++++++
 4 files changed, 107 insertions(+), 2 deletions(-)
 create mode 100644 src/test/java/dev/toonformat/jtoon/JToonDecodeToMapTest.java

diff --git a/.idea/gradle.xml b/.idea/gradle.xml
index 2a65317..f2c1963 100644
--- a/.idea/gradle.xml
+++ b/.idea/gradle.xml
@@ -5,7 +5,7 @@
     <option name="linkedExternalProjectsSettings">
       <GradleProjectSettings>
         <option name="externalProjectPath" value="$PROJECT_DIR$" />
-        <option name="gradleHome" value="" />
+        <option name="gradleJvm" value="17" />
         <option name="modules">
           <set>
             <option value="$PROJECT_DIR$" />
diff --git a/.idea/misc.xml b/.idea/misc.xml
index cab6417..ad08689 100644
--- a/.idea/misc.xml
+++ b/.idea/misc.xml
@@ -4,7 +4,7 @@
   <component name="FrameworkDetectionExcludesConfiguration">
     <file type="web" url="file://$PROJECT_DIR$" />
   </component>
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_17" project-jdk-name="graalvm-ce-25" project-jdk-type="JavaSDK">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_17" project-jdk-name="17" project-jdk-type="JavaSDK">
     <output url="file://$PROJECT_DIR$/out" />
   </component>
 </project>
\ No newline at end of file
diff --git a/src/main/java/dev/toonformat/jtoon/JToon.java b/src/main/java/dev/toonformat/jtoon/JToon.java
index 518de7f..3644669 100644
--- a/src/main/java/dev/toonformat/jtoon/JToon.java
+++ b/src/main/java/dev/toonformat/jtoon/JToon.java
@@ -5,6 +5,8 @@
 import dev.toonformat.jtoon.normalizer.JsonNormalizer;
 import tools.jackson.databind.JsonNode;
 
+import java.util.Map;
+
 /**
  * Main entry point for encoding and decoding TOON (Token-Oriented Object Notation) format.
  * Provides static methods to convert between Java objects, JSON strings, and TOON format.
@@ -118,6 +120,63 @@ public static Object decode(String toon, DecodeOptions options) {
         return ValueDecoder.decode(toon, options);
     }
 
+    /**
+     * Decodes a TOON-formatted string into a {@code Map<String, Object>} using default options.
+     *
+     * <p>
+     * This method is a convenience wrapper around
+     * {@link #decode(String)} and expects the decoded result to
+     * represent a TOON object. If the decoded value is {@code null} or a {@code String},
+     * an empty map is returned. No deep transformation is applied: the returned map
+     * directly reflects the structure produced by the decoder.
+     * </p>
+     *
+     * <p>
+     * The decoded value must be a {@code Map}; otherwise, a {@link ClassCastException}
+     * will occur due to the unchecked cast.
+     * </p>
+     *
+     * @param toon The TOON-formatted string to decode
+     * @return A {@code Map<String, Object>} representing the decoded TOON object, or an empty map if the
+     *         input decodes to {@code null} or a {@code String}
+     * @throws IllegalArgumentException if strict mode is enabled and the input is invalid
+     */
+    public static Map<String, Object> decodeToMap(String toon) {
+        return decodeToMap(toon, DecodeOptions.DEFAULT);
+    }
+
+    /**
+     * Decodes a TOON-formatted string into a {@code Map<String, Object>} using custom options.
+     *
+     * <p>
+     * This method is a convenience wrapper around
+     * {@link #decode(String, DecodeOptions)} and expects the decoded result to
+     * represent a TOON object. If the decoded value is {@code null} or a {@code String},
+     * an empty map is returned. No deep transformation is applied: the returned map
+     * directly reflects the structure produced by the decoder.
+     * </p>
+     *
+     * @param toon    The TOON-formatted string to decode
+     * @param options Decoding options (indentation, delimiters, strict mode)
+     * @return A {@code Map<String, Object>} representing the decoded TOON object, or an empty map if the
+     *         input decodes to {@code null} or a {@code String}
+     * @throws IllegalArgumentException if strict mode is enabled and the input is invalid
+     */
+
+    @SuppressWarnings("unchecked")
+    public static Map<String, Object> decodeToMap(String toon, DecodeOptions options) {
+        Object result = decode(toon, options);
+        if(result == null) {
+            return Map.of();
+        }
+
+        if(result instanceof String string) {
+            return Map.of();
+        }
+
+        return (Map<String, Object>) result;
+    }
+
     /**
      * Decodes a TOON-formatted string directly to a JSON string using default
      * options.
diff --git a/src/test/java/dev/toonformat/jtoon/JToonDecodeToMapTest.java b/src/test/java/dev/toonformat/jtoon/JToonDecodeToMapTest.java
new file mode 100644
index 0000000..a1e3284
--- /dev/null
+++ b/src/test/java/dev/toonformat/jtoon/JToonDecodeToMapTest.java
@@ -0,0 +1,46 @@
+package dev.toonformat.jtoon;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+@Tag("unit")
+public class JToonDecodeToMapTest {
+
+    @Test
+    @DisplayName("should return a Map<String, Object>")
+    void simpleMapDecode() {
+        String toon = """
+                    id: 123
+                    name: Ada
+                    active: true
+                    """;
+        Map<String, Object> map = JToon.decodeToMap(toon);
+        assertNotNull(map);
+        assertFalse(map.isEmpty());
+        assertNotNull(map.get("id"));
+        assertNotNull(map.get("name"));
+        assertNotNull(map.get("active"));
+    }
+
+    @Test
+    @DisplayName("if the given input is null an empty Map is returned")
+    void nullInput() {
+        Map<String, Object> map = JToon.decodeToMap(null);
+        assertNotNull(map);
+        assertTrue(map.isEmpty());
+    }
+
+    @Test
+    @DisplayName("if the given input is an invalid toon string, and empty Map is returned")
+    void nullResult() {
+        String toon = "This String is invalid";
+        Map<String, Object> map = JToon.decodeToMap(toon);
+        assertNotNull(map);
+        assertTrue(map.isEmpty());
+    }
+}

From f092b11b896687d91fbdf730cda818f855412472 Mon Sep 17 00:00:00 2001
From: Asintoto <sommatoria0@gmail.com>
Date: Sat, 22 Nov 2025 12:25:43 +0100
Subject: [PATCH 2/7] better comments

---
 src/main/java/dev/toonformat/jtoon/JToon.java | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/src/main/java/dev/toonformat/jtoon/JToon.java b/src/main/java/dev/toonformat/jtoon/JToon.java
index 3644669..06c2395 100644
--- a/src/main/java/dev/toonformat/jtoon/JToon.java
+++ b/src/main/java/dev/toonformat/jtoon/JToon.java
@@ -126,7 +126,7 @@ public static Object decode(String toon, DecodeOptions options) {
      * <p>
      * This method is a convenience wrapper around
      * {@link #decode(String)} and expects the decoded result to
-     * represent a TOON object. If the decoded value is {@code null} or a {@code String},
+     * represent a TOON object. If the decoded value is {@code null} or an invalid {@code String},
      * an empty map is returned. No deep transformation is applied: the returned map
      * directly reflects the structure produced by the decoder.
      * </p>
@@ -151,18 +151,22 @@ public static Map<String, Object> decodeToMap(String toon) {
      * <p>
      * This method is a convenience wrapper around
      * {@link #decode(String, DecodeOptions)} and expects the decoded result to
-     * represent a TOON object. If the decoded value is {@code null} or a {@code String},
+     * represent a TOON object. If the decoded value is {@code null} or an invalid {@code String},
      * an empty map is returned. No deep transformation is applied: the returned map
      * directly reflects the structure produced by the decoder.
      * </p>
      *
+     * <p>
+     * The decoded value must be a {@code Map}; otherwise, a {@link ClassCastException}
+     * will occur due to the unchecked cast.
+     * </p>
+     *
      * @param toon    The TOON-formatted string to decode
      * @param options Decoding options (indentation, delimiters, strict mode)
      * @return A {@code Map<String, Object>} representing the decoded TOON object, or an empty map if the
      *         input decodes to {@code null} or a {@code String}
      * @throws IllegalArgumentException if strict mode is enabled and the input is invalid
      */
-
     @SuppressWarnings("unchecked")
     public static Map<String, Object> decodeToMap(String toon, DecodeOptions options) {
         Object result = decode(toon, options);

From 7a75204106306b42c3e9c2b2e2ee1478d9113d89 Mon Sep 17 00:00:00 2001
From: Asintoto <sommatoria0@gmail.com>
Date: Sat, 22 Nov 2025 12:25:52 +0100
Subject: [PATCH 3/7] test cases

---
 .../dev/toonformat/jtoon/JToonDecodeToMapTest.java   | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/src/test/java/dev/toonformat/jtoon/JToonDecodeToMapTest.java b/src/test/java/dev/toonformat/jtoon/JToonDecodeToMapTest.java
index a1e3284..850315a 100644
--- a/src/test/java/dev/toonformat/jtoon/JToonDecodeToMapTest.java
+++ b/src/test/java/dev/toonformat/jtoon/JToonDecodeToMapTest.java
@@ -12,7 +12,7 @@
 public class JToonDecodeToMapTest {
 
     @Test
-    @DisplayName("should return a Map<String, Object>")
+    @DisplayName("should return a non-empty Map")
     void simpleMapDecode() {
         String toon = """
                     id: 123
@@ -20,15 +20,19 @@ void simpleMapDecode() {
                     active: true
                     """;
         Map<String, Object> map = JToon.decodeToMap(toon);
+
         assertNotNull(map);
         assertFalse(map.isEmpty());
         assertNotNull(map.get("id"));
         assertNotNull(map.get("name"));
         assertNotNull(map.get("active"));
+        assertEquals(123L, map.get("id"));
+        assertEquals("Ada", map.get("name"));
+        assertEquals(true, map.get("active"));
     }
 
     @Test
-    @DisplayName("if the given input is null an empty Map is returned")
+    @DisplayName("should return an empty Map for null input")
     void nullInput() {
         Map<String, Object> map = JToon.decodeToMap(null);
         assertNotNull(map);
@@ -36,8 +40,8 @@ void nullInput() {
     }
 
     @Test
-    @DisplayName("if the given input is an invalid toon string, and empty Map is returned")
-    void nullResult() {
+    @DisplayName("should return an empty Map for invalid TOON string")
+    void invalidInput() {
         String toon = "This String is invalid";
         Map<String, Object> map = JToon.decodeToMap(toon);
         assertNotNull(map);

From 0ac795f09b600502b5201d2a4956d44e3d6e9000 Mon Sep 17 00:00:00 2001
From: Asintoto <sommatoria0@gmail.com>
Date: Sat, 22 Nov 2025 12:41:05 +0100
Subject: [PATCH 4/7] updated README.md

---
 README.md | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 6ff48a7..9fe2d1b 100644
--- a/README.md
+++ b/README.md
@@ -272,7 +272,11 @@ System.out.println(JToon.encode(data, new EncodeOptions(2, Delimiter.PIPE, true)
 
 ### `JToon.decodeToJson(String toon, DecodeOptions options): String`
 
-Converts TOON-formatted strings back to Java objects or JSON.
+### `JToon.decodeToMap(String toon): Map<String, Object>`
+
+### `JToon.decodeToMap(String toon, DecodeOptions options): Map<String, Object>`
+
+Converts TOON-formatted strings back to Java objects, JSON or directly into Map<String, Object>.
 
 **Parameters:**
 
@@ -288,6 +292,8 @@ For `decode`: A Java object (`Map` for objects, `List` for arrays, primitives fo
 
 For `decodeToJson`: A JSON string representation
 
+For `decodeToMap`: A `Map` representing a Java object
+
 **Example:**
 
 ```java
@@ -304,6 +310,9 @@ Object result = JToon.decode(toon);
 
 // Decode directly to JSON string
 String json = JToon.decodeToJson(toon);
+
+// Decode directly to Map<String, Object> (no cast needed)
+Map<String, Object> map = JToon.decodeToMap(toon);
 ```
 
 #### Round-Trip Conversion

From e1570d78ed3bbb915d9c563cd41306f533d8d751 Mon Sep 17 00:00:00 2001
From: Asintoto <sommatoria0@gmail.com>
Date: Tue, 25 Nov 2025 18:44:42 +0100
Subject: [PATCH 5/7] check for non-map result

---
 src/main/java/dev/toonformat/jtoon/JToon.java  | 18 +++++++++---------
 .../toonformat/jtoon/JToonDecodeToMapTest.java | 14 ++++++++++++++
 2 files changed, 23 insertions(+), 9 deletions(-)

diff --git a/src/main/java/dev/toonformat/jtoon/JToon.java b/src/main/java/dev/toonformat/jtoon/JToon.java
index 06c2395..6405d33 100644
--- a/src/main/java/dev/toonformat/jtoon/JToon.java
+++ b/src/main/java/dev/toonformat/jtoon/JToon.java
@@ -146,25 +146,25 @@ public static Map<String, Object> decodeToMap(String toon) {
     }
 
     /**
-     * Decodes a TOON-formatted string into a {@code Map<String, Object>} using custom options.
+     * Decodes a TOON-formatted string into a {@code Map<String, Object>} using the provided options.
      *
      * <p>
      * This method is a convenience wrapper around
      * {@link #decode(String, DecodeOptions)} and expects the decoded result to
-     * represent a TOON object. If the decoded value is {@code null} or an invalid {@code String},
-     * an empty map is returned. No deep transformation is applied: the returned map
-     * directly reflects the structure produced by the decoder.
+     * represent a TOON object. If the decoded value is {@code null} or is not a
+     * {@code Map}, an empty map is returned. No deep transformation is applied:
+     * the returned map directly reflects the structure produced by the decoder.
      * </p>
      *
      * <p>
-     * The decoded value must be a {@code Map}; otherwise, a {@link ClassCastException}
-     * will occur due to the unchecked cast.
+     * The decoded value must be a {@code Map}; otherwise, this method returns an
+     * empty map instead of attempting an invalid cast.
      * </p>
      *
      * @param toon    The TOON-formatted string to decode
      * @param options Decoding options (indentation, delimiters, strict mode)
-     * @return A {@code Map<String, Object>} representing the decoded TOON object, or an empty map if the
-     *         input decodes to {@code null} or a {@code String}
+     * @return A {@code Map<String, Object>} representing the decoded TOON object, or an empty map
+     *         if the decoded value is {@code null} or not a {@code Map}
      * @throws IllegalArgumentException if strict mode is enabled and the input is invalid
      */
     @SuppressWarnings("unchecked")
@@ -174,7 +174,7 @@ public static Map<String, Object> decodeToMap(String toon, DecodeOptions options
             return Map.of();
         }
 
-        if(result instanceof String string) {
+        if(!(result instanceof Map)) {
             return Map.of();
         }
 
diff --git a/src/test/java/dev/toonformat/jtoon/JToonDecodeToMapTest.java b/src/test/java/dev/toonformat/jtoon/JToonDecodeToMapTest.java
index 850315a..7c8c632 100644
--- a/src/test/java/dev/toonformat/jtoon/JToonDecodeToMapTest.java
+++ b/src/test/java/dev/toonformat/jtoon/JToonDecodeToMapTest.java
@@ -47,4 +47,18 @@ void invalidInput() {
         assertNotNull(map);
         assertTrue(map.isEmpty());
     }
+
+    @Test
+    @DisplayName("should return an empty Map for a non-map result")
+    void notAMap() {
+        String toon = """
+                [3]{name,age,active}:
+                  Mark,31,true
+                  Adam,20,true
+                  Elly,45,false
+                """;
+        Map<String, Object> map = JToon.decodeToMap(toon);
+        assertNotNull(map);
+        assertTrue(map.isEmpty());
+    }
 }

From e90d0db2187ff2d736e4f8703a8a9e7dacc0d30c Mon Sep 17 00:00:00 2001
From: Asintoto <sommatoria0@gmail.com>
Date: Tue, 25 Nov 2025 20:57:54 +0100
Subject: [PATCH 6/7] moved decodeToMap rules to ValueDecoder

---
 src/main/java/dev/toonformat/jtoon/JToon.java | 12 +-----
 .../jtoon/decoder/ValueDecoder.java           | 37 +++++++++++++++++++
 2 files changed, 38 insertions(+), 11 deletions(-)

diff --git a/src/main/java/dev/toonformat/jtoon/JToon.java b/src/main/java/dev/toonformat/jtoon/JToon.java
index 6405d33..84df133 100644
--- a/src/main/java/dev/toonformat/jtoon/JToon.java
+++ b/src/main/java/dev/toonformat/jtoon/JToon.java
@@ -167,18 +167,8 @@ public static Map<String, Object> decodeToMap(String toon) {
      *         if the decoded value is {@code null} or not a {@code Map}
      * @throws IllegalArgumentException if strict mode is enabled and the input is invalid
      */
-    @SuppressWarnings("unchecked")
     public static Map<String, Object> decodeToMap(String toon, DecodeOptions options) {
-        Object result = decode(toon, options);
-        if(result == null) {
-            return Map.of();
-        }
-
-        if(!(result instanceof Map)) {
-            return Map.of();
-        }
-
-        return (Map<String, Object>) result;
+        return ValueDecoder.decodeToMap(toon, options);
     }
 
     /**
diff --git a/src/main/java/dev/toonformat/jtoon/decoder/ValueDecoder.java b/src/main/java/dev/toonformat/jtoon/decoder/ValueDecoder.java
index d954590..accb37e 100644
--- a/src/main/java/dev/toonformat/jtoon/decoder/ValueDecoder.java
+++ b/src/main/java/dev/toonformat/jtoon/decoder/ValueDecoder.java
@@ -120,6 +120,43 @@ public static String decodeToJson(String toon, DecodeOptions options) {
         }
     }
 
+    /**
+     * Decodes a TOON-formatted string into a {@code Map<String, Object>} using the
+     * provided decoding options.
+     *
+     * <p>
+     * This method is a convenience wrapper around {@link #decode(String, DecodeOptions)}
+     * and expects the decoded result to represent a TOON object. If the decoded
+     * value is {@code null} or is not a {@code Map}, an empty map is returned.
+     * No deep transformation is applied: the returned map reflects exactly the
+     * structure produced by the decoder.
+     * </p>
+     *
+     * <p>
+     * The decoded value must be a {@code Map}; if it is not, this method returns an
+     * empty map instead of attempting an invalid cast.
+     * </p>
+     *
+     * @param toon    The TOON-formatted string to decode
+     * @param options Decoding options (indentation, delimiters, strict mode)
+     * @return A {@code Map<String, Object>} representing the decoded TOON object,
+     *         or an empty map if the decoded value is {@code null} or not a {@code Map}
+     * @throws IllegalArgumentException if strict mode is enabled and the input is invalid
+     */
+    @SuppressWarnings("unchecked")
+    public static Map<String, Object> decodeToMap(String toon, DecodeOptions options) {
+        Object result = decode(toon, options);
+        if(result == null) {
+            return Map.of();
+        }
+
+        if(!(result instanceof Map)) {
+            return Map.of();
+        }
+
+        return (Map<String, Object>) result;
+    }
+
     /**
      * Inner parser class managing line-by-line parsing state.
      * Maintains currentLine index and uses recursive descent for nested structures.

From 937b51c86e157b65aa70d13fcb4feeda3c84bed4 Mon Sep 17 00:00:00 2001
From: Asintoto <sommatoria0@gmail.com>
Date: Tue, 25 Nov 2025 20:58:23 +0100
Subject: [PATCH 7/7] better test cases

---
 .../jtoon/JToonDecodeToMapTest.java           | 157 +++++++++++++-----
 1 file changed, 116 insertions(+), 41 deletions(-)

diff --git a/src/test/java/dev/toonformat/jtoon/JToonDecodeToMapTest.java b/src/test/java/dev/toonformat/jtoon/JToonDecodeToMapTest.java
index 7c8c632..c67c2fa 100644
--- a/src/test/java/dev/toonformat/jtoon/JToonDecodeToMapTest.java
+++ b/src/test/java/dev/toonformat/jtoon/JToonDecodeToMapTest.java
@@ -1,9 +1,11 @@
 package dev.toonformat.jtoon;
 
 import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Tag;
 import org.junit.jupiter.api.Test;
 
+import java.util.List;
 import java.util.Map;
 
 import static org.junit.jupiter.api.Assertions.*;
@@ -11,54 +13,127 @@
 @Tag("unit")
 public class JToonDecodeToMapTest {
 
-    @Test
-    @DisplayName("should return a non-empty Map")
-    void simpleMapDecode() {
-        String toon = """
+    @Nested
+    @DisplayName("Valid inputs")
+    class ValidInputs {
+
+        @Test
+        @DisplayName("should return a non-empty Map")
+        void simpleMapDecode() {
+            String toon = """
                     id: 123
                     name: Ada
                     active: true
                     """;
-        Map<String, Object> map = JToon.decodeToMap(toon);
-
-        assertNotNull(map);
-        assertFalse(map.isEmpty());
-        assertNotNull(map.get("id"));
-        assertNotNull(map.get("name"));
-        assertNotNull(map.get("active"));
-        assertEquals(123L, map.get("id"));
-        assertEquals("Ada", map.get("name"));
-        assertEquals(true, map.get("active"));
-    }
+            Map<String, Object> map = JToon.decodeToMap(toon);
 
-    @Test
-    @DisplayName("should return an empty Map for null input")
-    void nullInput() {
-        Map<String, Object> map = JToon.decodeToMap(null);
-        assertNotNull(map);
-        assertTrue(map.isEmpty());
+            assertNotNull(map);
+            assertFalse(map.isEmpty());
+            assertNotNull(map.get("id"));
+            assertNotNull(map.get("name"));
+            assertNotNull(map.get("active"));
+            assertEquals(123L, map.get("id"));
+            assertEquals("Ada", map.get("name"));
+            assertEquals(true, map.get("active"));
+        }
     }
 
-    @Test
-    @DisplayName("should return an empty Map for invalid TOON string")
-    void invalidInput() {
-        String toon = "This String is invalid";
-        Map<String, Object> map = JToon.decodeToMap(toon);
-        assertNotNull(map);
-        assertTrue(map.isEmpty());
+    @Nested
+    @DisplayName("Invalid or edge cases")
+    class InvalidInputs {
+
+        @Test
+        @DisplayName("should return an empty Map for null input")
+        void nullInput() {
+            Map<String, Object> map = JToon.decodeToMap(null);
+            assertNotNull(map);
+            assertTrue(map.isEmpty());
+        }
+
+        @Test
+        @DisplayName("should return an empty Map for empty input")
+        void emptyInput() {
+            Map<String, Object> map1 = JToon.decodeToMap("");
+            Map<String, Object> map2 = JToon.decodeToMap(" ");
+            assertNotNull(map1);
+            assertTrue(map1.isEmpty());
+            assertNotNull(map2);
+            assertTrue(map2.isEmpty());
+        }
+
+        @Test
+        @DisplayName("should return an empty Map for invalid TOON string")
+        void invalidInput() {
+            String toon = "This String is invalid";
+            Map<String, Object> map = JToon.decodeToMap(toon);
+            assertNotNull(map);
+            assertTrue(map.isEmpty());
+        }
+
+        @Test
+        @DisplayName("should return an empty map for primitive inputs")
+        void primitiveInputs() {
+            assertTrue(JToon.decodeToMap("123").isEmpty());
+            assertTrue(JToon.decodeToMap("12.34").isEmpty());
+            assertTrue(JToon.decodeToMap("\"Hello\"").isEmpty());
+            assertTrue(JToon.decodeToMap("true").isEmpty());
+        }
+
+        @Test
+        @DisplayName("should return an empty Map for a non-map result")
+        void notAMap() {
+            String toon = """
+                    [3]{name,age,active}:
+                      Mark,31,true
+                      Adam,20,true
+                      Elly,45,false
+                    """;
+            Map<String, Object> map = JToon.decodeToMap(toon);
+            assertNotNull(map);
+            assertTrue(map.isEmpty());
+        }
     }
 
-    @Test
-    @DisplayName("should return an empty Map for a non-map result")
-    void notAMap() {
-        String toon = """
-                [3]{name,age,active}:
-                  Mark,31,true
-                  Adam,20,true
-                  Elly,45,false
-                """;
-        Map<String, Object> map = JToon.decodeToMap(toon);
-        assertNotNull(map);
-        assertTrue(map.isEmpty());
+    @Nested
+    @DisplayName("Nested Objects")
+    class NestedObjects {
+
+        @Test
+        @DisplayName("should decode nested objects")
+        void nestedObjects() {
+            String toon = """
+                    user:
+                      id: 123
+                      contact:
+                        email: ada@example.com
+                        phone: "555-1234"
+                    """;
+            Map<String, Object> map = JToon.decodeToMap(toon);
+            @SuppressWarnings("unchecked")
+            Map<String, Object> user = (Map<String, Object>) map.get("user");
+            @SuppressWarnings("unchecked")
+            Map<String, Object> contact = (Map<String, Object>) user.get("contact");
+            assertEquals("ada@example.com", contact.get("email"));
+            assertEquals("555-1234", contact.get("phone"));
+        }
+
+        @Test
+        @DisplayName("should decode object with nested arrays")
+        void nestedArrays() {
+            String toon = """
+                    user:
+                      id: 123
+                      name: Ada
+                      tags[2]: dev,admin
+                    """;
+            Map<String, Object> map = JToon.decodeToMap(toon);
+            assertNotNull(map);
+            assertFalse(map.isEmpty());
+            @SuppressWarnings("unchecked")
+            Map<String, Object> user = (Map<String, Object>) map.get("user");
+            @SuppressWarnings("unchecked")
+            List<Object> tags = (List<Object>) user.get("tags");
+            assertEquals(2, tags.size());
+        }
     }
-}
+}
\ No newline at end of file