diff --git a/selector/src/commonMain/kotlin/li/songe/selector/data/CompareOperator.kt b/selector/src/commonMain/kotlin/li/songe/selector/data/CompareOperator.kt
index 3e48a25d..52868783 100644
--- a/selector/src/commonMain/kotlin/li/songe/selector/data/CompareOperator.kt
+++ b/selector/src/commonMain/kotlin/li/songe/selector/data/CompareOperator.kt
@@ -5,11 +5,14 @@ sealed class CompareOperator(val key: String) {
     abstract fun compare(left: Any?, right: Any?): Boolean
 
     companion object {
-        val allSubClasses = listOf(
-            Equal,
-            NotEqual,
-            Start, NotStart, Include, NotInclude, End, NotEnd, Less, LessEqual, More, MoreEqual
-        ).sortedBy { -it.key.length }
+        // https://stackoverflow.com/questions/47648689
+        val allSubClasses by lazy {
+            listOf(
+                Equal,
+                NotEqual,
+                Start, NotStart, Include, NotInclude, End, NotEnd, Less, LessEqual, More, MoreEqual
+            ).sortedBy { -it.key.length }
+        }
 
         // example
         // id="com.lptiyu.tanke:id/ab1"
@@ -24,7 +27,7 @@ sealed class CompareOperator(val key: String) {
         }
     }
 
-    object Equal : CompareOperator("=") {
+    data object Equal : CompareOperator("=") {
         override fun compare(left: Any?, right: Any?): Boolean {
             return if (left is CharSequence && right is CharSequence) {
                 left.contentReversedEquals(right)
@@ -34,65 +37,65 @@ sealed class CompareOperator(val key: String) {
         }
     }
 
-    object NotEqual : CompareOperator("!=") {
+    data object NotEqual : CompareOperator("!=") {
         override fun compare(left: Any?, right: Any?) = !Equal.compare(left, right)
     }
 
-    object Start : CompareOperator("^=") {
+    data object Start : CompareOperator("^=") {
         override fun compare(left: Any?, right: Any?): Boolean {
             return if (left is CharSequence && right is CharSequence) left.startsWith(right) else false
         }
     }
 
-    object NotStart : CompareOperator("!^=") {
+    data object NotStart : CompareOperator("!^=") {
         override fun compare(left: Any?, right: Any?): Boolean {
             return if (left is CharSequence && right is CharSequence) !left.startsWith(right) else false
         }
     }
 
-    object Include : CompareOperator("*=") {
+    data object Include : CompareOperator("*=") {
         override fun compare(left: Any?, right: Any?): Boolean {
             return if (left is CharSequence && right is CharSequence) left.contains(right) else false
         }
     }
 
-    object NotInclude : CompareOperator("!*=") {
+    data object NotInclude : CompareOperator("!*=") {
         override fun compare(left: Any?, right: Any?): Boolean {
             return if (left is CharSequence && right is CharSequence) !left.contains(right) else false
         }
     }
 
-    object End : CompareOperator("$=") {
+    data object End : CompareOperator("$=") {
         override fun compare(left: Any?, right: Any?): Boolean {
             return if (left is CharSequence && right is CharSequence) left.endsWith(right) else false
         }
     }
 
-    object NotEnd : CompareOperator("!$=") {
+    data object NotEnd : CompareOperator("!$=") {
         override fun compare(left: Any?, right: Any?): Boolean {
             return if (left is CharSequence && right is CharSequence) !left.endsWith(right) else false
         }
     }
 
-    object Less : CompareOperator("<") {
+    data object Less : CompareOperator("<") {
         override fun compare(left: Any?, right: Any?): Boolean {
             return if (left is Int && right is Int) left < right else false
         }
     }
 
-    object LessEqual : CompareOperator("<=") {
+    data object LessEqual : CompareOperator("<=") {
         override fun compare(left: Any?, right: Any?): Boolean {
             return if (left is Int && right is Int) left <= right else false
         }
     }
 
-    object More : CompareOperator(">") {
+    data object More : CompareOperator(">") {
         override fun compare(left: Any?, right: Any?): Boolean {
             return if (left is Int && right is Int) left > right else false
         }
     }
 
-    object MoreEqual : CompareOperator(">=") {
+    data object MoreEqual : CompareOperator(">=") {
         override fun compare(left: Any?, right: Any?): Boolean {
             return if (left is Int && right is Int) left >= right else false
         }
diff --git a/selector/src/commonMain/kotlin/li/songe/selector/data/ConnectOperator.kt b/selector/src/commonMain/kotlin/li/songe/selector/data/ConnectOperator.kt
index 184d8101..f280d110 100644
--- a/selector/src/commonMain/kotlin/li/songe/selector/data/ConnectOperator.kt
+++ b/selector/src/commonMain/kotlin/li/songe/selector/data/ConnectOperator.kt
@@ -8,15 +8,18 @@ sealed class ConnectOperator(val key: String) {
     abstract fun <T> traversal(node: T, transform: Transform<T>, offset: Int): T?
 
     companion object {
-        val allSubClasses = listOf(
-            BeforeBrother, AfterBrother, Ancestor, Child, Descendant
-        ).sortedBy { -it.key.length }
+        // https://stackoverflow.com/questions/47648689
+        val allSubClasses by lazy {
+            listOf(
+                BeforeBrother, AfterBrother, Ancestor, Child, Descendant
+            ).sortedBy { -it.key.length }
+        }
     }
 
     /**
      * A + B, 1,2,3,A,B,7,8
      */
-    object BeforeBrother : ConnectOperator("+") {
+    data object BeforeBrother : ConnectOperator("+") {
         override fun <T> traversal(node: T, transform: Transform<T>) =
             transform.getBeforeBrothers(node)
 
@@ -27,7 +30,7 @@ sealed class ConnectOperator(val key: String) {
     /**
      * A - B, 1,2,3,B,A,7,8
      */
-    object AfterBrother : ConnectOperator("-") {
+    data object AfterBrother : ConnectOperator("-") {
         override fun <T> traversal(node: T, transform: Transform<T>) =
             transform.getAfterBrothers(node)
 
@@ -38,7 +41,7 @@ sealed class ConnectOperator(val key: String) {
     /**
      * A > B, A is the ancestor of B
      */
-    object Ancestor : ConnectOperator(">") {
+    data object Ancestor : ConnectOperator(">") {
         override fun <T> traversal(node: T, transform: Transform<T>) = transform.getAncestors(node)
 
         override fun <T> traversal(node: T, transform: Transform<T>, offset: Int): T? =
@@ -48,7 +51,7 @@ sealed class ConnectOperator(val key: String) {
     /**
      * A < B, A is the child of B
      */
-    object Child : ConnectOperator("<") {
+    data object Child : ConnectOperator("<") {
         override fun <T> traversal(node: T, transform: Transform<T>) = transform.getChildren(node)
 
         override fun <T> traversal(node: T, transform: Transform<T>, offset: Int): T? =
@@ -58,7 +61,7 @@ sealed class ConnectOperator(val key: String) {
     /**
      * A << B, A is the descendant of B
      */
-    object Descendant : ConnectOperator("<<") {
+    data object Descendant : ConnectOperator("<<") {
         override fun <T> traversal(node: T, transform: Transform<T>) =
             transform.getDescendants(node)
 
diff --git a/selector/src/commonMain/kotlin/li/songe/selector/data/LogicalOperator.kt b/selector/src/commonMain/kotlin/li/songe/selector/data/LogicalOperator.kt
index e254cb3a..732f0200 100644
--- a/selector/src/commonMain/kotlin/li/songe/selector/data/LogicalOperator.kt
+++ b/selector/src/commonMain/kotlin/li/songe/selector/data/LogicalOperator.kt
@@ -4,9 +4,12 @@ import li.songe.selector.Transform
 
 sealed class LogicalOperator(val key: String) {
     companion object {
-        val allSubClasses = listOf(
-            AndOperator, OrOperator
-        ).sortedBy { -it.key.length }
+        // https://stackoverflow.com/questions/47648689
+        val allSubClasses by lazy {
+            listOf(
+                AndOperator, OrOperator
+            ).sortedBy { -it.key.length }
+        }
     }
 
     override fun toString() = key
@@ -17,7 +20,7 @@ sealed class LogicalOperator(val key: String) {
         right: Expression,
     ): Boolean
 
-    object AndOperator : LogicalOperator("&&") {
+    data object AndOperator : LogicalOperator("&&") {
         override fun <T> compare(
             node: T,
             transform: Transform<T>,
@@ -28,7 +31,7 @@ sealed class LogicalOperator(val key: String) {
         }
     }
 
-    object OrOperator : LogicalOperator("||") {
+    data object OrOperator : LogicalOperator("||") {
         override fun <T> compare(
             node: T,
             transform: Transform<T>,