omlish 0.0.0.dev484__py3-none-any.whl → 0.0.0.dev493__py3-none-any.whl

omlish/specs/jmespath/_dataclasses.py

@@ -25,27 +25,35 @@ def _register(**kwargs):
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('node',)), EqPlan(fields=('node',)), FrozenPlan(fields=('node',), allow_dynamic_du"
-        "nder_attrs=False), HashPlan(action='add', fields=('node',), cache=False), InitPlan(fields=(InitPlan.Field(name"
-        "='node', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_factory=None, init=True, ove"
-        "rride=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None),), self_param='self',"
-        " std_params=('node',), kw_only_params=(), frozen=True, slots=False, post_init_params=None, init_fns=(), valida"
-        "te_fns=()), ReprPlan(fields=(ReprPlan.Field(name='node', kw_only=False, fn=None),), id=False, terse=False, def"
-        "ault_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('left', 'right')), EqPlan(fields=('left', 'right')), FrozenPlan(fields=('left', 'r"
+        "ight'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('left', 'right'), cache=False), Init"
+        "Plan(fields=(InitPlan.Field(name='left', annotation=OpRef(name='init.fields.0.annotation'), default=None, defa"
+        "ult_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_"
+        "type=None), InitPlan.Field(name='right', annotation=OpRef(name='init.fields.1.annotation'), default=None, defa"
+        "ult_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_"
+        "type=None)), self_param='self', std_params=('left', 'right'), kw_only_params=(), frozen=True, slots=False, pos"
+        "t_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='left', kw_only=False,"
+        " fn=None), ReprPlan.Field(name='right', kw_only=False, fn=None)), id=False, terse=False, default_fn=None)))"
     ),
-    plan_repr_sha1='04121723da73369a153101f1c1cd7d127fdcfad7',
+    plan_repr_sha1='683a8fba51ac0aaee8d49314879ce436e8ee2d3b',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
+        '__dataclass__init__fields__1__annotation',
     ),
     cls_names=(
-        ('omlish.specs.jmespath', 'Flatten'),
+        ('omlish.specs.jmespath', 'AndExpression'),
+        ('omlish.specs.jmespath', 'OrExpression'),
+        ('omlish.specs.jmespath', 'Pipe'),
+        ('omlish.specs.jmespath', 'Projection'),
+        ('omlish.specs.jmespath', 'ValueProjection'),
     ),
 )
-def _process_dataclass__04121723da73369a153101f1c1cd7d127fdcfad7():
+def _process_dataclass__683a8fba51ac0aaee8d49314879ce436e8ee2d3b():
     def _process_dataclass(
         *,
         __dataclass__cls,
         __dataclass__init__fields__0__annotation,
+        __dataclass__init__fields__1__annotation,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -64,7 +72,8 @@ def _process_dataclass__04121723da73369a153101f1c1cd7d127fdcfad7():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                node=self.node,
+                left=self.left,
+                right=self.right,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -78,7 +87,8 @@ def _process_dataclass__04121723da73369a153101f1c1cd7d127fdcfad7():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self.node == other.node
+                self.left == other.left and
+                self.right == other.right
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -87,7 +97,8 @@ def _process_dataclass__04121723da73369a153101f1c1cd7d127fdcfad7():
         setattr(__dataclass__cls, '__eq__', __eq__)
 
         __dataclass___setattr_frozen_fields = {
-            'node',
+            'left',
+            'right',
         }
 
         def __setattr__(self, name, value):
@@ -104,7 +115,8 @@ def _process_dataclass__04121723da73369a153101f1c1cd7d127fdcfad7():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'node',
+            'left',
+            'right',
         }
 
         def __delattr__(self, name):
@@ -122,7 +134,8 @@ def _process_dataclass__04121723da73369a153101f1c1cd7d127fdcfad7():
 
         def __hash__(self):
             return hash((
-                self.node,
+                self.left,
+                self.right,
             ))
 
         __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
@@ -130,9 +143,11 @@ def _process_dataclass__04121723da73369a153101f1c1cd7d127fdcfad7():
 
         def __init__(
             self,
-            node: __dataclass__init__fields__0__annotation,
+            left: __dataclass__init__fields__0__annotation,
+            right: __dataclass__init__fields__1__annotation,
         ) -> __dataclass__None:
-            __dataclass__object_setattr(self, 'node', node)
+            __dataclass__object_setattr(self, 'left', left)
+            __dataclass__object_setattr(self, 'right', right)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -142,7 +157,8 @@ def _process_dataclass__04121723da73369a153101f1c1cd7d127fdcfad7():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"node={self.node!r}")
+            parts.append(f"left={self.left!r}")
+            parts.append(f"right={self.right!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -159,30 +175,31 @@ def _process_dataclass__04121723da73369a153101f1c1cd7d127fdcfad7():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('name', 'first', 'second')), EqPlan(fields=('name', 'first', 'second')), FrozenPla"
-        "n(fields=('name', 'first', 'second'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('name'"
-        ", 'first', 'second'), cache=False), InitPlan(fields=(InitPlan.Field(name='name', annotation=OpRef(name='init.f"
-        "ields.0.annotation'), default=None, default_factory=None, init=True, override=False, field_type=FieldType.INST"
-        "ANCE, coerce=None, validate=None, check_type=None), InitPlan.Field(name='first', annotation=OpRef(name='init.f"
-        "ields.1.annotation'), default=None, default_factory=None, init=True, override=False, field_type=FieldType.INST"
-        "ANCE, coerce=None, validate=None, check_type=None), InitPlan.Field(name='second', annotation=OpRef(name='init."
-        "fields.2.annotation'), default=None, default_factory=None, init=True, override=False, field_type=FieldType.INS"
-        "TANCE, coerce=None, validate=None, check_type=None)), self_param='self', std_params=('name', 'first', 'second'"
-        "), kw_only_params=(), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_fns=()), ReprPlan"
-        "(fields=(ReprPlan.Field(name='name', kw_only=False, fn=None), ReprPlan.Field(name='first', kw_only=False, fn=N"
-        "one), ReprPlan.Field(name='second', kw_only=False, fn=None)), id=False, terse=False, default_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('operator', 'left', 'right')), EqPlan(fields=('operator', 'left', 'right')), Froze"
+        "nPlan(fields=('operator', 'left', 'right'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=("
+        "'operator', 'left', 'right'), cache=False), InitPlan(fields=(InitPlan.Field(name='operator', annotation=OpRef("
+        "name='init.fields.0.annotation'), default=None, default_factory=None, init=True, override=False, field_type=Fi"
+        "eldType.INSTANCE, coerce=None, validate=None, check_type=None), InitPlan.Field(name='left', annotation=OpRef(n"
+        "ame='init.fields.1.annotation'), default=None, default_factory=None, init=True, override=False, field_type=Fie"
+        "ldType.INSTANCE, coerce=None, validate=None, check_type=None), InitPlan.Field(name='right', annotation=OpRef(n"
+        "ame='init.fields.2.annotation'), default=None, default_factory=None, init=True, override=False, field_type=Fie"
+        "ldType.INSTANCE, coerce=None, validate=None, check_type=None)), self_param='self', std_params=('operator', 'le"
+        "ft', 'right'), kw_only_params=(), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_fns=("
+        ")), ReprPlan(fields=(ReprPlan.Field(name='operator', kw_only=False, fn=None), ReprPlan.Field(name='left', kw_o"
+        "nly=False, fn=None), ReprPlan.Field(name='right', kw_only=False, fn=None)), id=False, terse=False, default_fn="
+        "None)))"
     ),
-    plan_repr_sha1='17f73a891c5ca759d782b4a50d841d4e19830e44',
+    plan_repr_sha1='9ad32a9de77661d138040ae8b9ef479f313da67b',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
         '__dataclass__init__fields__1__annotation',
         '__dataclass__init__fields__2__annotation',
     ),
     cls_names=(
-        ('omlish.specs.jmespath', 'Comparator'),
+        ('omlish.specs.jmespath', 'Arithmetic'),
     ),
 )
-def _process_dataclass__17f73a891c5ca759d782b4a50d841d4e19830e44():
+def _process_dataclass__9ad32a9de77661d138040ae8b9ef479f313da67b():
     def _process_dataclass(
         *,
         __dataclass__cls,
@@ -207,9 +224,9 @@ def _process_dataclass__17f73a891c5ca759d782b4a50d841d4e19830e44():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                name=self.name,
-                first=self.first,
-                second=self.second,
+                operator=self.operator,
+                left=self.left,
+                right=self.right,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -223,9 +240,9 @@ def _process_dataclass__17f73a891c5ca759d782b4a50d841d4e19830e44():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self.name == other.name and
-                self.first == other.first and
-                self.second == other.second
+                self.operator == other.operator and
+                self.left == other.left and
+                self.right == other.right
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -234,9 +251,9 @@ def _process_dataclass__17f73a891c5ca759d782b4a50d841d4e19830e44():
         setattr(__dataclass__cls, '__eq__', __eq__)
 
         __dataclass___setattr_frozen_fields = {
-            'name',
-            'first',
-            'second',
+            'operator',
+            'left',
+            'right',
         }
 
         def __setattr__(self, name, value):
@@ -253,9 +270,9 @@ def _process_dataclass__17f73a891c5ca759d782b4a50d841d4e19830e44():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'name',
-            'first',
-            'second',
+            'operator',
+            'left',
+            'right',
         }
 
         def __delattr__(self, name):
@@ -273,9 +290,9 @@ def _process_dataclass__17f73a891c5ca759d782b4a50d841d4e19830e44():
 
         def __hash__(self):
             return hash((
-                self.name,
-                self.first,
-                self.second,
+                self.operator,
+                self.left,
+                self.right,
             ))
 
         __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
@@ -283,13 +300,13 @@ def _process_dataclass__17f73a891c5ca759d782b4a50d841d4e19830e44():
 
         def __init__(
             self,
-            name: __dataclass__init__fields__0__annotation,
-            first: __dataclass__init__fields__1__annotation,
-            second: __dataclass__init__fields__2__annotation,
+            operator: __dataclass__init__fields__0__annotation,
+            left: __dataclass__init__fields__1__annotation,
+            right: __dataclass__init__fields__2__annotation,
         ) -> __dataclass__None:
-            __dataclass__object_setattr(self, 'name', name)
-            __dataclass__object_setattr(self, 'first', first)
-            __dataclass__object_setattr(self, 'second', second)
+            __dataclass__object_setattr(self, 'operator', operator)
+            __dataclass__object_setattr(self, 'left', left)
+            __dataclass__object_setattr(self, 'right', right)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -299,9 +316,9 @@ def _process_dataclass__17f73a891c5ca759d782b4a50d841d4e19830e44():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"name={self.name!r}")
-            parts.append(f"first={self.first!r}")
-            parts.append(f"second={self.second!r}")
+            parts.append(f"operator={self.operator!r}")
+            parts.append(f"left={self.left!r}")
+            parts.append(f"right={self.right!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -318,27 +335,32 @@ def _process_dataclass__17f73a891c5ca759d782b4a50d841d4e19830e44():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('expr',)), EqPlan(fields=('expr',)), FrozenPlan(fields=('expr',), allow_dynamic_du"
-        "nder_attrs=False), HashPlan(action='add', fields=('expr',), cache=False), InitPlan(fields=(InitPlan.Field(name"
-        "='expr', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_factory=None, init=True, ove"
-        "rride=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None),), self_param='self',"
-        " std_params=('expr',), kw_only_params=(), frozen=True, slots=False, post_init_params=None, init_fns=(), valida"
-        "te_fns=()), ReprPlan(fields=(ReprPlan.Field(name='expr', kw_only=False, fn=None),), id=False, terse=False, def"
-        "ault_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('operator', 'expression')), EqPlan(fields=('operator', 'expression')), FrozenPlan("
+        "fields=('operator', 'expression'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('operator"
+        "', 'expression'), cache=False), InitPlan(fields=(InitPlan.Field(name='operator', annotation=OpRef(name='init.f"
+        "ields.0.annotation'), default=None, default_factory=None, init=True, override=False, field_type=FieldType.INST"
+        "ANCE, coerce=None, validate=None, check_type=None), InitPlan.Field(name='expression', annotation=OpRef(name='i"
+        "nit.fields.1.annotation'), default=None, default_factory=None, init=True, override=False, field_type=FieldType"
+        ".INSTANCE, coerce=None, validate=None, check_type=None)), self_param='self', std_params=('operator', 'expressi"
+        "on'), kw_only_params=(), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_fns=()), ReprP"
+        "lan(fields=(ReprPlan.Field(name='operator', kw_only=False, fn=None), ReprPlan.Field(name='expression', kw_only"
+        "=False, fn=None)), id=False, terse=False, default_fn=None)))"
     ),
-    plan_repr_sha1='40ccd63db7a447b608d0875571d487f96ef3af93',
+    plan_repr_sha1='cdb3249bff15c580f8a8beab3e47937e31fe71a0',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
+        '__dataclass__init__fields__1__annotation',
     ),
     cls_names=(
-        ('omlish.specs.jmespath', 'NotExpression'),
+        ('omlish.specs.jmespath', 'ArithmeticUnary'),
     ),
 )
-def _process_dataclass__40ccd63db7a447b608d0875571d487f96ef3af93():
+def _process_dataclass__cdb3249bff15c580f8a8beab3e47937e31fe71a0():
     def _process_dataclass(
         *,
         __dataclass__cls,
         __dataclass__init__fields__0__annotation,
+        __dataclass__init__fields__1__annotation,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -357,7 +379,8 @@ def _process_dataclass__40ccd63db7a447b608d0875571d487f96ef3af93():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                expr=self.expr,
+                operator=self.operator,
+                expression=self.expression,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -371,7 +394,8 @@ def _process_dataclass__40ccd63db7a447b608d0875571d487f96ef3af93():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self.expr == other.expr
+                self.operator == other.operator and
+                self.expression == other.expression
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -380,7 +404,8 @@ def _process_dataclass__40ccd63db7a447b608d0875571d487f96ef3af93():
         setattr(__dataclass__cls, '__eq__', __eq__)
 
         __dataclass___setattr_frozen_fields = {
-            'expr',
+            'operator',
+            'expression',
         }
 
         def __setattr__(self, name, value):
@@ -397,7 +422,8 @@ def _process_dataclass__40ccd63db7a447b608d0875571d487f96ef3af93():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'expr',
+            'operator',
+            'expression',
         }
 
         def __delattr__(self, name):
@@ -415,7 +441,8 @@ def _process_dataclass__40ccd63db7a447b608d0875571d487f96ef3af93():
 
         def __hash__(self):
             return hash((
-                self.expr,
+                self.operator,
+                self.expression,
             ))
 
         __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
@@ -423,9 +450,11 @@ def _process_dataclass__40ccd63db7a447b608d0875571d487f96ef3af93():
 
         def __init__(
             self,
-            expr: __dataclass__init__fields__0__annotation,
+            operator: __dataclass__init__fields__0__annotation,
+            expression: __dataclass__init__fields__1__annotation,
         ) -> __dataclass__None:
-            __dataclass__object_setattr(self, 'expr', expr)
+            __dataclass__object_setattr(self, 'operator', operator)
+            __dataclass__object_setattr(self, 'expression', expression)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -435,7 +464,8 @@ def _process_dataclass__40ccd63db7a447b608d0875571d487f96ef3af93():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"expr={self.expr!r}")
+            parts.append(f"operator={self.operator!r}")
+            parts.append(f"expression={self.expression!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -452,26 +482,26 @@ def _process_dataclass__40ccd63db7a447b608d0875571d487f96ef3af93():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('name', 'args')), EqPlan(fields=('name', 'args')), FrozenPlan(fields=('name', 'arg"
-        "s'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('name', 'args'), cache=False), InitPlan"
+        "Plans(tup=(CopyPlan(fields=('name', 'expr')), EqPlan(fields=('name', 'expr')), FrozenPlan(fields=('name', 'exp"
+        "r'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('name', 'expr'), cache=False), InitPlan"
         "(fields=(InitPlan.Field(name='name', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_"
         "factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type"
-        "=None), InitPlan.Field(name='args', annotation=OpRef(name='init.fields.1.annotation'), default=None, default_f"
+        "=None), InitPlan.Field(name='expr', annotation=OpRef(name='init.fields.1.annotation'), default=None, default_f"
         "actory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type="
-        "None)), self_param='self', std_params=('name', 'args'), kw_only_params=(), frozen=True, slots=False, post_init"
+        "None)), self_param='self', std_params=('name', 'expr'), kw_only_params=(), frozen=True, slots=False, post_init"
         "_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='name', kw_only=False, fn=No"
-        "ne), ReprPlan.Field(name='args', kw_only=False, fn=None)), id=False, terse=False, default_fn=None)))"
+        "ne), ReprPlan.Field(name='expr', kw_only=False, fn=None)), id=False, terse=False, default_fn=None)))"
     ),
-    plan_repr_sha1='46b21a57c7f935afb031452a3d30815129505ec6',
+    plan_repr_sha1='fb46b9fb75089de970d1b8ccffb404d02368804a',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
         '__dataclass__init__fields__1__annotation',
     ),
     cls_names=(
-        ('omlish.specs.jmespath', 'FunctionExpression'),
+        ('omlish.specs.jmespath', 'Assign'),
     ),
 )
-def _process_dataclass__46b21a57c7f935afb031452a3d30815129505ec6():
+def _process_dataclass__fb46b9fb75089de970d1b8ccffb404d02368804a():
     def _process_dataclass(
         *,
         __dataclass__cls,
@@ -496,7 +526,7 @@ def _process_dataclass__46b21a57c7f935afb031452a3d30815129505ec6():
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
                 name=self.name,
-                args=self.args,
+                expr=self.expr,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -511,7 +541,7 @@ def _process_dataclass__46b21a57c7f935afb031452a3d30815129505ec6():
                 return NotImplemented
             return (
                 self.name == other.name and
-                self.args == other.args
+                self.expr == other.expr
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -521,7 +551,7 @@ def _process_dataclass__46b21a57c7f935afb031452a3d30815129505ec6():
 
         __dataclass___setattr_frozen_fields = {
             'name',
-            'args',
+            'expr',
         }
 
         def __setattr__(self, name, value):
@@ -539,7 +569,7 @@ def _process_dataclass__46b21a57c7f935afb031452a3d30815129505ec6():
 
         __dataclass___delattr_frozen_fields = {
             'name',
-            'args',
+            'expr',
         }
 
         def __delattr__(self, name):
@@ -558,7 +588,7 @@ def _process_dataclass__46b21a57c7f935afb031452a3d30815129505ec6():
         def __hash__(self):
             return hash((
                 self.name,
-                self.args,
+                self.expr,
             ))
 
         __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
@@ -567,10 +597,10 @@ def _process_dataclass__46b21a57c7f935afb031452a3d30815129505ec6():
         def __init__(
             self,
             name: __dataclass__init__fields__0__annotation,
-            args: __dataclass__init__fields__1__annotation,
+            expr: __dataclass__init__fields__1__annotation,
         ) -> __dataclass__None:
             __dataclass__object_setattr(self, 'name', name)
-            __dataclass__object_setattr(self, 'args', args)
+            __dataclass__object_setattr(self, 'expr', expr)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -581,7 +611,7 @@ def _process_dataclass__46b21a57c7f935afb031452a3d30815129505ec6():
         def __repr__(self):
             parts = []
             parts.append(f"name={self.name!r}")
-            parts.append(f"args={self.args!r}")
+            parts.append(f"expr={self.expr!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -598,27 +628,36 @@ def _process_dataclass__46b21a57c7f935afb031452a3d30815129505ec6():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('index',)), EqPlan(fields=('index',)), FrozenPlan(fields=('index',), allow_dynamic"
-        "_dunder_attrs=False), HashPlan(action='add', fields=('index',), cache=False), InitPlan(fields=(InitPlan.Field("
-        "name='index', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_factory=None, init=True"
-        ", override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None),), self_param='s"
-        "elf', std_params=('index',), kw_only_params=(), frozen=True, slots=False, post_init_params=None, init_fns=(), "
-        "validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='index', kw_only=False, fn=None),), id=False, terse=Fal"
-        "se, default_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('name', 'first', 'second')), EqPlan(fields=('name', 'first', 'second')), FrozenPla"
+        "n(fields=('name', 'first', 'second'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('name'"
+        ", 'first', 'second'), cache=False), InitPlan(fields=(InitPlan.Field(name='name', annotation=OpRef(name='init.f"
+        "ields.0.annotation'), default=None, default_factory=None, init=True, override=False, field_type=FieldType.INST"
+        "ANCE, coerce=None, validate=None, check_type=None), InitPlan.Field(name='first', annotation=OpRef(name='init.f"
+        "ields.1.annotation'), default=None, default_factory=None, init=True, override=False, field_type=FieldType.INST"
+        "ANCE, coerce=None, validate=None, check_type=None), InitPlan.Field(name='second', annotation=OpRef(name='init."
+        "fields.2.annotation'), default=None, default_factory=None, init=True, override=False, field_type=FieldType.INS"
+        "TANCE, coerce=None, validate=None, check_type=None)), self_param='self', std_params=('name', 'first', 'second'"
+        "), kw_only_params=(), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_fns=()), ReprPlan"
+        "(fields=(ReprPlan.Field(name='name', kw_only=False, fn=None), ReprPlan.Field(name='first', kw_only=False, fn=N"
+        "one), ReprPlan.Field(name='second', kw_only=False, fn=None)), id=False, terse=False, default_fn=None)))"
     ),
-    plan_repr_sha1='58d0143ed6bbec74538c3af1d493d5b4f36423f2',
+    plan_repr_sha1='17f73a891c5ca759d782b4a50d841d4e19830e44',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
+        '__dataclass__init__fields__1__annotation',
+        '__dataclass__init__fields__2__annotation',
     ),
     cls_names=(
-        ('omlish.specs.jmespath', 'Index'),
+        ('omlish.specs.jmespath', 'Comparator'),
     ),
 )
-def _process_dataclass__58d0143ed6bbec74538c3af1d493d5b4f36423f2():
+def _process_dataclass__17f73a891c5ca759d782b4a50d841d4e19830e44():
     def _process_dataclass(
         *,
         __dataclass__cls,
         __dataclass__init__fields__0__annotation,
+        __dataclass__init__fields__1__annotation,
+        __dataclass__init__fields__2__annotation,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -637,7 +676,9 @@ def _process_dataclass__58d0143ed6bbec74538c3af1d493d5b4f36423f2():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                index=self.index,
+                name=self.name,
+                first=self.first,
+                second=self.second,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -651,7 +692,9 @@ def _process_dataclass__58d0143ed6bbec74538c3af1d493d5b4f36423f2():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self.index == other.index
+                self.name == other.name and
+                self.first == other.first and
+                self.second == other.second
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -660,7 +703,9 @@ def _process_dataclass__58d0143ed6bbec74538c3af1d493d5b4f36423f2():
         setattr(__dataclass__cls, '__eq__', __eq__)
 
         __dataclass___setattr_frozen_fields = {
-            'index',
+            'name',
+            'first',
+            'second',
         }
 
         def __setattr__(self, name, value):
@@ -677,9 +722,11 @@ def _process_dataclass__58d0143ed6bbec74538c3af1d493d5b4f36423f2():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'index',
-        }
-
+            'name',
+            'first',
+            'second',
+        }
+
         def __delattr__(self, name):
             if (
                 type(self) is __dataclass__cls
@@ -695,7 +742,9 @@ def _process_dataclass__58d0143ed6bbec74538c3af1d493d5b4f36423f2():
 
         def __hash__(self):
             return hash((
-                self.index,
+                self.name,
+                self.first,
+                self.second,
             ))
 
         __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
@@ -703,9 +752,13 @@ def _process_dataclass__58d0143ed6bbec74538c3af1d493d5b4f36423f2():
 
         def __init__(
             self,
-            index: __dataclass__init__fields__0__annotation,
+            name: __dataclass__init__fields__0__annotation,
+            first: __dataclass__init__fields__1__annotation,
+            second: __dataclass__init__fields__2__annotation,
         ) -> __dataclass__None:
-            __dataclass__object_setattr(self, 'index', index)
+            __dataclass__object_setattr(self, 'name', name)
+            __dataclass__object_setattr(self, 'first', first)
+            __dataclass__object_setattr(self, 'second', second)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -715,7 +768,9 @@ def _process_dataclass__58d0143ed6bbec74538c3af1d493d5b4f36423f2():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"index={self.index!r}")
+            parts.append(f"name={self.name!r}")
+            parts.append(f"first={self.first!r}")
+            parts.append(f"second={self.second!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -732,32 +787,25 @@ def _process_dataclass__58d0143ed6bbec74538c3af1d493d5b4f36423f2():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('key_name', 'node')), EqPlan(fields=('key_name', 'node')), FrozenPlan(fields=('key"
-        "_name', 'node'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('key_name', 'node'), cache="
-        "False), InitPlan(fields=(InitPlan.Field(name='key_name', annotation=OpRef(name='init.fields.0.annotation'), de"
-        "fault=None, default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, valid"
-        "ate=None, check_type=None), InitPlan.Field(name='node', annotation=OpRef(name='init.fields.1.annotation'), def"
-        "ault=None, default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, valida"
-        "te=None, check_type=None)), self_param='self', std_params=('key_name', 'node'), kw_only_params=(), frozen=True"
-        ", slots=False, post_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='key"
-        "_name', kw_only=False, fn=None), ReprPlan.Field(name='node', kw_only=False, fn=None)), id=False, terse=False, "
-        "default_fn=None)))"
-    ),
-    plan_repr_sha1='5c98f4baa29dbd0603b7dae82100421eaccc16c1',
-    op_ref_idents=(
-        '__dataclass__init__fields__0__annotation',
-        '__dataclass__init__fields__1__annotation',
+        "Plans(tup=(CopyPlan(fields=()), EqPlan(fields=()), FrozenPlan(fields=(), allow_dynamic_dunder_attrs=False), Ha"
+        "shPlan(action='add', fields=(), cache=False), InitPlan(fields=(), self_param='self', std_params=(), kw_only_pa"
+        "rams=(), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(), i"
+        "d=False, terse=False, default_fn=None)))"
     ),
+    plan_repr_sha1='e1f7edfe11f2b721d6a656c46e698fedc95461bb',
+    op_ref_idents=(),
     cls_names=(
-        ('omlish.specs.jmespath', 'KeyValPair'),
+        ('omlish.specs.jmespath', 'CurrentNode'),
+        ('omlish.specs.jmespath', 'Identity'),
+        ('omlish.specs.jmespath', 'LeafNode'),
+        ('omlish.specs.jmespath', 'Node'),
+        ('omlish.specs.jmespath', 'RootNode'),
     ),
 )
-def _process_dataclass__5c98f4baa29dbd0603b7dae82100421eaccc16c1():
+def _process_dataclass__e1f7edfe11f2b721d6a656c46e698fedc95461bb():
     def _process_dataclass(
         *,
         __dataclass__cls,
-        __dataclass__init__fields__0__annotation,
-        __dataclass__init__fields__1__annotation,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -775,10 +823,7 @@ def _process_dataclass__5c98f4baa29dbd0603b7dae82100421eaccc16c1():
         def __copy__(self):
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
-            return __dataclass__cls(  # noqa
-                key_name=self.key_name,
-                node=self.node,
-            )
+            return __dataclass__cls()  # noqa
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
         if '__copy__' in __dataclass__cls.__dict__:
@@ -790,25 +835,16 @@ def _process_dataclass__5c98f4baa29dbd0603b7dae82100421eaccc16c1():
                 return True
             if self.__class__ is not other.__class__:
                 return NotImplemented
-            return (
-                self.key_name == other.key_name and
-                self.node == other.node
-            )
+            return True
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
         if '__eq__' in __dataclass__cls.__dict__:
             raise __dataclass__TypeError(f"Cannot overwrite attribute __eq__ in class {__dataclass__cls.__name__}")
         setattr(__dataclass__cls, '__eq__', __eq__)
 
-        __dataclass___setattr_frozen_fields = {
-            'key_name',
-            'node',
-        }
-
         def __setattr__(self, name, value):
             if (
                 type(self) is __dataclass__cls
-                 or name in __dataclass___setattr_frozen_fields
             ):
                 raise __dataclass__FrozenInstanceError(f"cannot assign to field {name!r}")
             super(__dataclass__cls, self).__setattr__(name, value)
@@ -818,15 +854,9 @@ def _process_dataclass__5c98f4baa29dbd0603b7dae82100421eaccc16c1():
             raise __dataclass__TypeError(f"Cannot overwrite attribute __setattr__ in class {__dataclass__cls.__name__}")
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
-        __dataclass___delattr_frozen_fields = {
-            'key_name',
-            'node',
-        }
-
         def __delattr__(self, name):
             if (
                 type(self) is __dataclass__cls
-                 or name in __dataclass___delattr_frozen_fields
             ):
                 raise __dataclass__FrozenInstanceError(f"cannot delete field {name!r}")
             super(__dataclass__cls, self).__delattr__(name)
@@ -837,21 +867,15 @@ def _process_dataclass__5c98f4baa29dbd0603b7dae82100421eaccc16c1():
         setattr(__dataclass__cls, '__delattr__', __delattr__)
 
         def __hash__(self):
-            return hash((
-                self.key_name,
-                self.node,
-            ))
+            return hash(())
 
         __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
         setattr(__dataclass__cls, '__hash__', __hash__)
 
         def __init__(
             self,
-            key_name: __dataclass__init__fields__0__annotation,
-            node: __dataclass__init__fields__1__annotation,
         ) -> __dataclass__None:
-            __dataclass__object_setattr(self, 'key_name', key_name)
-            __dataclass__object_setattr(self, 'node', node)
+            pass
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -861,8 +885,6 @@ def _process_dataclass__5c98f4baa29dbd0603b7dae82100421eaccc16c1():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"key_name={self.key_name!r}")
-            parts.append(f"node={self.node!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -879,35 +901,27 @@ def _process_dataclass__5c98f4baa29dbd0603b7dae82100421eaccc16c1():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('left', 'right')), EqPlan(fields=('left', 'right')), FrozenPlan(fields=('left', 'r"
-        "ight'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('left', 'right'), cache=False), Init"
-        "Plan(fields=(InitPlan.Field(name='left', annotation=OpRef(name='init.fields.0.annotation'), default=None, defa"
-        "ult_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_"
-        "type=None), InitPlan.Field(name='right', annotation=OpRef(name='init.fields.1.annotation'), default=None, defa"
-        "ult_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_"
-        "type=None)), self_param='self', std_params=('left', 'right'), kw_only_params=(), frozen=True, slots=False, pos"
-        "t_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='left', kw_only=False,"
-        " fn=None), ReprPlan.Field(name='right', kw_only=False, fn=None)), id=False, terse=False, default_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('expression',)), EqPlan(fields=('expression',)), FrozenPlan(fields=('expression',)"
+        ", allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('expression',), cache=False), InitPlan(fie"
+        "lds=(InitPlan.Field(name='expression', annotation=OpRef(name='init.fields.0.annotation'), default=None, defaul"
+        "t_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_ty"
+        "pe=None),), self_param='self', std_params=('expression',), kw_only_params=(), frozen=True, slots=False, post_i"
+        "nit_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='expression', kw_only=Fal"
+        "se, fn=None),), id=False, terse=False, default_fn=None)))"
     ),
-    plan_repr_sha1='683a8fba51ac0aaee8d49314879ce436e8ee2d3b',
+    plan_repr_sha1='88b2bcfae28e19661d346bbf4c87a846e786b0ea',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
-        '__dataclass__init__fields__1__annotation',
     ),
     cls_names=(
-        ('omlish.specs.jmespath', 'AndExpression'),
-        ('omlish.specs.jmespath', 'OrExpression'),
-        ('omlish.specs.jmespath', 'Pipe'),
-        ('omlish.specs.jmespath', 'Projection'),
-        ('omlish.specs.jmespath', 'ValueProjection'),
+        ('omlish.specs.jmespath', 'Expref'),
     ),
 )
-def _process_dataclass__683a8fba51ac0aaee8d49314879ce436e8ee2d3b():
+def _process_dataclass__88b2bcfae28e19661d346bbf4c87a846e786b0ea():
     def _process_dataclass(
         *,
         __dataclass__cls,
         __dataclass__init__fields__0__annotation,
-        __dataclass__init__fields__1__annotation,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -926,8 +940,7 @@ def _process_dataclass__683a8fba51ac0aaee8d49314879ce436e8ee2d3b():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                left=self.left,
-                right=self.right,
+                expression=self.expression,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -941,8 +954,7 @@ def _process_dataclass__683a8fba51ac0aaee8d49314879ce436e8ee2d3b():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self.left == other.left and
-                self.right == other.right
+                self.expression == other.expression
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -951,8 +963,7 @@ def _process_dataclass__683a8fba51ac0aaee8d49314879ce436e8ee2d3b():
         setattr(__dataclass__cls, '__eq__', __eq__)
 
         __dataclass___setattr_frozen_fields = {
-            'left',
-            'right',
+            'expression',
         }
 
         def __setattr__(self, name, value):
@@ -969,8 +980,7 @@ def _process_dataclass__683a8fba51ac0aaee8d49314879ce436e8ee2d3b():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'left',
-            'right',
+            'expression',
         }
 
         def __delattr__(self, name):
@@ -988,8 +998,7 @@ def _process_dataclass__683a8fba51ac0aaee8d49314879ce436e8ee2d3b():
 
         def __hash__(self):
             return hash((
-                self.left,
-                self.right,
+                self.expression,
             ))
 
         __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
@@ -997,11 +1006,9 @@ def _process_dataclass__683a8fba51ac0aaee8d49314879ce436e8ee2d3b():
 
         def __init__(
             self,
-            left: __dataclass__init__fields__0__annotation,
-            right: __dataclass__init__fields__1__annotation,
+            expression: __dataclass__init__fields__0__annotation,
         ) -> __dataclass__None:
-            __dataclass__object_setattr(self, 'left', left)
-            __dataclass__object_setattr(self, 'right', right)
+            __dataclass__object_setattr(self, 'expression', expression)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -1011,8 +1018,7 @@ def _process_dataclass__683a8fba51ac0aaee8d49314879ce436e8ee2d3b():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"left={self.left!r}")
-            parts.append(f"right={self.right!r}")
+            parts.append(f"expression={self.expression!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -1029,23 +1035,24 @@ def _process_dataclass__683a8fba51ac0aaee8d49314879ce436e8ee2d3b():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('literal_value',)), EqPlan(fields=('literal_value',)), FrozenPlan(fields=('literal"
-        "_value',), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('literal_value',), cache=False), "
-        "InitPlan(fields=(InitPlan.Field(name='literal_value', annotation=OpRef(name='init.fields.0.annotation'), defau"
-        "lt=None, default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate"
-        "=None, check_type=None),), self_param='self', std_params=('literal_value',), kw_only_params=(), frozen=True, s"
-        "lots=False, post_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='litera"
-        "l_value', kw_only=False, fn=None),), id=False, terse=False, default_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('name',)), EqPlan(fields=('name',)), FrozenPlan(fields=('name',), allow_dynamic_du"
+        "nder_attrs=False), HashPlan(action='add', fields=('name',), cache=False), InitPlan(fields=(InitPlan.Field(name"
+        "='name', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_factory=None, init=True, ove"
+        "rride=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None),), self_param='self',"
+        " std_params=('name',), kw_only_params=(), frozen=True, slots=False, post_init_params=None, init_fns=(), valida"
+        "te_fns=()), ReprPlan(fields=(ReprPlan.Field(name='name', kw_only=False, fn=None),), id=False, terse=False, def"
+        "ault_fn=None)))"
     ),
-    plan_repr_sha1='84f3ffbf073b3ca8957fd80ce73aa63d4e81555d',
+    plan_repr_sha1='a8c678a92ec79b6aa505feedefe70ee7fef92ccd',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
     ),
     cls_names=(
-        ('omlish.specs.jmespath', 'Literal'),
+        ('omlish.specs.jmespath', 'Field'),
+        ('omlish.specs.jmespath', 'VariableRef'),
     ),
 )
-def _process_dataclass__84f3ffbf073b3ca8957fd80ce73aa63d4e81555d():
+def _process_dataclass__a8c678a92ec79b6aa505feedefe70ee7fef92ccd():
     def _process_dataclass(
         *,
         __dataclass__cls,
@@ -1068,7 +1075,7 @@ def _process_dataclass__84f3ffbf073b3ca8957fd80ce73aa63d4e81555d():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                literal_value=self.literal_value,
+                name=self.name,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -1082,7 +1089,7 @@ def _process_dataclass__84f3ffbf073b3ca8957fd80ce73aa63d4e81555d():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self.literal_value == other.literal_value
+                self.name == other.name
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -1091,7 +1098,7 @@ def _process_dataclass__84f3ffbf073b3ca8957fd80ce73aa63d4e81555d():
         setattr(__dataclass__cls, '__eq__', __eq__)
 
         __dataclass___setattr_frozen_fields = {
-            'literal_value',
+            'name',
         }
 
         def __setattr__(self, name, value):
@@ -1108,7 +1115,7 @@ def _process_dataclass__84f3ffbf073b3ca8957fd80ce73aa63d4e81555d():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'literal_value',
+            'name',
         }
 
         def __delattr__(self, name):
@@ -1126,7 +1133,7 @@ def _process_dataclass__84f3ffbf073b3ca8957fd80ce73aa63d4e81555d():
 
         def __hash__(self):
             return hash((
-                self.literal_value,
+                self.name,
             ))
 
         __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
@@ -1134,9 +1141,9 @@ def _process_dataclass__84f3ffbf073b3ca8957fd80ce73aa63d4e81555d():
 
         def __init__(
             self,
-            literal_value: __dataclass__init__fields__0__annotation,
+            name: __dataclass__init__fields__0__annotation,
         ) -> __dataclass__None:
-            __dataclass__object_setattr(self, 'literal_value', literal_value)
+            __dataclass__object_setattr(self, 'name', name)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -1146,7 +1153,7 @@ def _process_dataclass__84f3ffbf073b3ca8957fd80ce73aa63d4e81555d():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"literal_value={self.literal_value!r}")
+            parts.append(f"name={self.name!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -1163,27 +1170,37 @@ def _process_dataclass__84f3ffbf073b3ca8957fd80ce73aa63d4e81555d():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('expression',)), EqPlan(fields=('expression',)), FrozenPlan(fields=('expression',)"
-        ", allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('expression',), cache=False), InitPlan(fie"
-        "lds=(InitPlan.Field(name='expression', annotation=OpRef(name='init.fields.0.annotation'), default=None, defaul"
-        "t_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_ty"
-        "pe=None),), self_param='self', std_params=('expression',), kw_only_params=(), frozen=True, slots=False, post_i"
-        "nit_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='expression', kw_only=Fal"
-        "se, fn=None),), id=False, terse=False, default_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('left', 'right', 'comparator')), EqPlan(fields=('left', 'right', 'comparator')), F"
+        "rozenPlan(fields=('left', 'right', 'comparator'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fi"
+        "elds=('left', 'right', 'comparator'), cache=False), InitPlan(fields=(InitPlan.Field(name='left', annotation=Op"
+        "Ref(name='init.fields.0.annotation'), default=None, default_factory=None, init=True, override=False, field_typ"
+        "e=FieldType.INSTANCE, coerce=None, validate=None, check_type=None), InitPlan.Field(name='right', annotation=Op"
+        "Ref(name='init.fields.1.annotation'), default=None, default_factory=None, init=True, override=False, field_typ"
+        "e=FieldType.INSTANCE, coerce=None, validate=None, check_type=None), InitPlan.Field(name='comparator', annotati"
+        "on=OpRef(name='init.fields.2.annotation'), default=None, default_factory=None, init=True, override=False, fiel"
+        "d_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None)), self_param='self', std_params=('left"
+        "', 'right', 'comparator'), kw_only_params=(), frozen=True, slots=False, post_init_params=None, init_fns=(), va"
+        "lidate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='left', kw_only=False, fn=None), ReprPlan.Field(name='rig"
+        "ht', kw_only=False, fn=None), ReprPlan.Field(name='comparator', kw_only=False, fn=None)), id=False, terse=Fals"
+        "e, default_fn=None)))"
     ),
-    plan_repr_sha1='88b2bcfae28e19661d346bbf4c87a846e786b0ea',
+    plan_repr_sha1='ee40fd21fce658ecb8d6c4a236c24880e69abc90',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
+        '__dataclass__init__fields__1__annotation',
+        '__dataclass__init__fields__2__annotation',
     ),
     cls_names=(
-        ('omlish.specs.jmespath', 'Expref'),
+        ('omlish.specs.jmespath', 'FilterProjection'),
     ),
 )
-def _process_dataclass__88b2bcfae28e19661d346bbf4c87a846e786b0ea():
+def _process_dataclass__ee40fd21fce658ecb8d6c4a236c24880e69abc90():
     def _process_dataclass(
         *,
         __dataclass__cls,
         __dataclass__init__fields__0__annotation,
+        __dataclass__init__fields__1__annotation,
+        __dataclass__init__fields__2__annotation,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -1202,7 +1219,9 @@ def _process_dataclass__88b2bcfae28e19661d346bbf4c87a846e786b0ea():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                expression=self.expression,
+                left=self.left,
+                right=self.right,
+                comparator=self.comparator,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -1216,7 +1235,9 @@ def _process_dataclass__88b2bcfae28e19661d346bbf4c87a846e786b0ea():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self.expression == other.expression
+                self.left == other.left and
+                self.right == other.right and
+                self.comparator == other.comparator
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -1225,7 +1246,9 @@ def _process_dataclass__88b2bcfae28e19661d346bbf4c87a846e786b0ea():
         setattr(__dataclass__cls, '__eq__', __eq__)
 
         __dataclass___setattr_frozen_fields = {
-            'expression',
+            'left',
+            'right',
+            'comparator',
         }
 
         def __setattr__(self, name, value):
@@ -1242,7 +1265,9 @@ def _process_dataclass__88b2bcfae28e19661d346bbf4c87a846e786b0ea():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'expression',
+            'left',
+            'right',
+            'comparator',
         }
 
         def __delattr__(self, name):
@@ -1260,7 +1285,9 @@ def _process_dataclass__88b2bcfae28e19661d346bbf4c87a846e786b0ea():
 
         def __hash__(self):
             return hash((
-                self.expression,
+                self.left,
+                self.right,
+                self.comparator,
             ))
 
         __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
@@ -1268,9 +1295,13 @@ def _process_dataclass__88b2bcfae28e19661d346bbf4c87a846e786b0ea():
 
         def __init__(
             self,
-            expression: __dataclass__init__fields__0__annotation,
+            left: __dataclass__init__fields__0__annotation,
+            right: __dataclass__init__fields__1__annotation,
+            comparator: __dataclass__init__fields__2__annotation,
         ) -> __dataclass__None:
-            __dataclass__object_setattr(self, 'expression', expression)
+            __dataclass__object_setattr(self, 'left', left)
+            __dataclass__object_setattr(self, 'right', right)
+            __dataclass__object_setattr(self, 'comparator', comparator)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -1280,7 +1311,9 @@ def _process_dataclass__88b2bcfae28e19661d346bbf4c87a846e786b0ea():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"expression={self.expression!r}")
+            parts.append(f"left={self.left!r}")
+            parts.append(f"right={self.right!r}")
+            parts.append(f"comparator={self.comparator!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -1297,25 +1330,23 @@ def _process_dataclass__88b2bcfae28e19661d346bbf4c87a846e786b0ea():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('nodes',)), EqPlan(fields=('nodes',)), FrozenPlan(fields=('nodes',), allow_dynamic"
-        "_dunder_attrs=False), HashPlan(action='add', fields=('nodes',), cache=False), InitPlan(fields=(InitPlan.Field("
-        "name='nodes', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_factory=None, init=True"
-        ", override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None),), self_param='s"
-        "elf', std_params=('nodes',), kw_only_params=(), frozen=True, slots=False, post_init_params=None, init_fns=(), "
-        "validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='nodes', kw_only=False, fn=None),), id=False, terse=Fal"
-        "se, default_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('node',)), EqPlan(fields=('node',)), FrozenPlan(fields=('node',), allow_dynamic_du"
+        "nder_attrs=False), HashPlan(action='add', fields=('node',), cache=False), InitPlan(fields=(InitPlan.Field(name"
+        "='node', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_factory=None, init=True, ove"
+        "rride=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None),), self_param='self',"
+        " std_params=('node',), kw_only_params=(), frozen=True, slots=False, post_init_params=None, init_fns=(), valida"
+        "te_fns=()), ReprPlan(fields=(ReprPlan.Field(name='node', kw_only=False, fn=None),), id=False, terse=False, def"
+        "ault_fn=None)))"
     ),
-    plan_repr_sha1='95a04b516e507c6ca7803679cc697feffd03c2fe',
+    plan_repr_sha1='04121723da73369a153101f1c1cd7d127fdcfad7',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
     ),
     cls_names=(
-        ('omlish.specs.jmespath', 'IndexExpression'),
-        ('omlish.specs.jmespath', 'MultiSelectDict'),
-        ('omlish.specs.jmespath', 'MultiSelectList'),
+        ('omlish.specs.jmespath', 'Flatten'),
     ),
 )
-def _process_dataclass__95a04b516e507c6ca7803679cc697feffd03c2fe():
+def _process_dataclass__04121723da73369a153101f1c1cd7d127fdcfad7():
     def _process_dataclass(
         *,
         __dataclass__cls,
@@ -1338,7 +1369,7 @@ def _process_dataclass__95a04b516e507c6ca7803679cc697feffd03c2fe():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                nodes=self.nodes,
+                node=self.node,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -1352,7 +1383,7 @@ def _process_dataclass__95a04b516e507c6ca7803679cc697feffd03c2fe():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self.nodes == other.nodes
+                self.node == other.node
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -1361,7 +1392,7 @@ def _process_dataclass__95a04b516e507c6ca7803679cc697feffd03c2fe():
         setattr(__dataclass__cls, '__eq__', __eq__)
 
         __dataclass___setattr_frozen_fields = {
-            'nodes',
+            'node',
         }
 
         def __setattr__(self, name, value):
@@ -1378,7 +1409,7 @@ def _process_dataclass__95a04b516e507c6ca7803679cc697feffd03c2fe():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'nodes',
+            'node',
         }
 
         def __delattr__(self, name):
@@ -1396,7 +1427,7 @@ def _process_dataclass__95a04b516e507c6ca7803679cc697feffd03c2fe():
 
         def __hash__(self):
             return hash((
-                self.nodes,
+                self.node,
             ))
 
         __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
@@ -1404,9 +1435,9 @@ def _process_dataclass__95a04b516e507c6ca7803679cc697feffd03c2fe():
 
         def __init__(
             self,
-            nodes: __dataclass__init__fields__0__annotation,
+            node: __dataclass__init__fields__0__annotation,
         ) -> __dataclass__None:
-            __dataclass__object_setattr(self, 'nodes', nodes)
+            __dataclass__object_setattr(self, 'node', node)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -1416,7 +1447,7 @@ def _process_dataclass__95a04b516e507c6ca7803679cc697feffd03c2fe():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"nodes={self.nodes!r}")
+            parts.append(f"node={self.node!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -1433,37 +1464,31 @@ def _process_dataclass__95a04b516e507c6ca7803679cc697feffd03c2fe():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('operator', 'left', 'right')), EqPlan(fields=('operator', 'left', 'right')), Froze"
-        "nPlan(fields=('operator', 'left', 'right'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=("
-        "'operator', 'left', 'right'), cache=False), InitPlan(fields=(InitPlan.Field(name='operator', annotation=OpRef("
-        "name='init.fields.0.annotation'), default=None, default_factory=None, init=True, override=False, field_type=Fi"
-        "eldType.INSTANCE, coerce=None, validate=None, check_type=None), InitPlan.Field(name='left', annotation=OpRef(n"
-        "ame='init.fields.1.annotation'), default=None, default_factory=None, init=True, override=False, field_type=Fie"
-        "ldType.INSTANCE, coerce=None, validate=None, check_type=None), InitPlan.Field(name='right', annotation=OpRef(n"
-        "ame='init.fields.2.annotation'), default=None, default_factory=None, init=True, override=False, field_type=Fie"
-        "ldType.INSTANCE, coerce=None, validate=None, check_type=None)), self_param='self', std_params=('operator', 'le"
-        "ft', 'right'), kw_only_params=(), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_fns=("
-        ")), ReprPlan(fields=(ReprPlan.Field(name='operator', kw_only=False, fn=None), ReprPlan.Field(name='left', kw_o"
-        "nly=False, fn=None), ReprPlan.Field(name='right', kw_only=False, fn=None)), id=False, terse=False, default_fn="
-        "None)))"
+        "Plans(tup=(CopyPlan(fields=('name', 'args')), EqPlan(fields=('name', 'args')), FrozenPlan(fields=('name', 'arg"
+        "s'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('name', 'args'), cache=False), InitPlan"
+        "(fields=(InitPlan.Field(name='name', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_"
+        "factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type"
+        "=None), InitPlan.Field(name='args', annotation=OpRef(name='init.fields.1.annotation'), default=None, default_f"
+        "actory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type="
+        "None)), self_param='self', std_params=('name', 'args'), kw_only_params=(), frozen=True, slots=False, post_init"
+        "_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='name', kw_only=False, fn=No"
+        "ne), ReprPlan.Field(name='args', kw_only=False, fn=None)), id=False, terse=False, default_fn=None)))"
     ),
-    plan_repr_sha1='9ad32a9de77661d138040ae8b9ef479f313da67b',
+    plan_repr_sha1='46b21a57c7f935afb031452a3d30815129505ec6',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
         '__dataclass__init__fields__1__annotation',
-        '__dataclass__init__fields__2__annotation',
     ),
     cls_names=(
-        ('omlish.specs.jmespath', 'Arithmetic'),
+        ('omlish.specs.jmespath', 'FunctionExpression'),
     ),
 )
-def _process_dataclass__9ad32a9de77661d138040ae8b9ef479f313da67b():
+def _process_dataclass__46b21a57c7f935afb031452a3d30815129505ec6():
     def _process_dataclass(
         *,
         __dataclass__cls,
         __dataclass__init__fields__0__annotation,
         __dataclass__init__fields__1__annotation,
-        __dataclass__init__fields__2__annotation,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -1482,9 +1507,8 @@ def _process_dataclass__9ad32a9de77661d138040ae8b9ef479f313da67b():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                operator=self.operator,
-                left=self.left,
-                right=self.right,
+                name=self.name,
+                args=self.args,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -1498,9 +1522,8 @@ def _process_dataclass__9ad32a9de77661d138040ae8b9ef479f313da67b():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self.operator == other.operator and
-                self.left == other.left and
-                self.right == other.right
+                self.name == other.name and
+                self.args == other.args
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -1509,9 +1532,8 @@ def _process_dataclass__9ad32a9de77661d138040ae8b9ef479f313da67b():
         setattr(__dataclass__cls, '__eq__', __eq__)
 
         __dataclass___setattr_frozen_fields = {
-            'operator',
-            'left',
-            'right',
+            'name',
+            'args',
         }
 
         def __setattr__(self, name, value):
@@ -1528,9 +1550,8 @@ def _process_dataclass__9ad32a9de77661d138040ae8b9ef479f313da67b():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'operator',
-            'left',
-            'right',
+            'name',
+            'args',
         }
 
         def __delattr__(self, name):
@@ -1548,9 +1569,8 @@ def _process_dataclass__9ad32a9de77661d138040ae8b9ef479f313da67b():
 
         def __hash__(self):
             return hash((
-                self.operator,
-                self.left,
-                self.right,
+                self.name,
+                self.args,
             ))
 
         __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
@@ -1558,13 +1578,11 @@ def _process_dataclass__9ad32a9de77661d138040ae8b9ef479f313da67b():
 
         def __init__(
             self,
-            operator: __dataclass__init__fields__0__annotation,
-            left: __dataclass__init__fields__1__annotation,
-            right: __dataclass__init__fields__2__annotation,
+            name: __dataclass__init__fields__0__annotation,
+            args: __dataclass__init__fields__1__annotation,
         ) -> __dataclass__None:
-            __dataclass__object_setattr(self, 'operator', operator)
-            __dataclass__object_setattr(self, 'left', left)
-            __dataclass__object_setattr(self, 'right', right)
+            __dataclass__object_setattr(self, 'name', name)
+            __dataclass__object_setattr(self, 'args', args)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -1574,9 +1592,8 @@ def _process_dataclass__9ad32a9de77661d138040ae8b9ef479f313da67b():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"operator={self.operator!r}")
-            parts.append(f"left={self.left!r}")
-            parts.append(f"right={self.right!r}")
+            parts.append(f"name={self.name!r}")
+            parts.append(f"args={self.args!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -1593,24 +1610,23 @@ def _process_dataclass__9ad32a9de77661d138040ae8b9ef479f313da67b():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('name',)), EqPlan(fields=('name',)), FrozenPlan(fields=('name',), allow_dynamic_du"
-        "nder_attrs=False), HashPlan(action='add', fields=('name',), cache=False), InitPlan(fields=(InitPlan.Field(name"
-        "='name', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_factory=None, init=True, ove"
-        "rride=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None),), self_param='self',"
-        " std_params=('name',), kw_only_params=(), frozen=True, slots=False, post_init_params=None, init_fns=(), valida"
-        "te_fns=()), ReprPlan(fields=(ReprPlan.Field(name='name', kw_only=False, fn=None),), id=False, terse=False, def"
-        "ault_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('index',)), EqPlan(fields=('index',)), FrozenPlan(fields=('index',), allow_dynamic"
+        "_dunder_attrs=False), HashPlan(action='add', fields=('index',), cache=False), InitPlan(fields=(InitPlan.Field("
+        "name='index', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_factory=None, init=True"
+        ", override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None),), self_param='s"
+        "elf', std_params=('index',), kw_only_params=(), frozen=True, slots=False, post_init_params=None, init_fns=(), "
+        "validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='index', kw_only=False, fn=None),), id=False, terse=Fal"
+        "se, default_fn=None)))"
     ),
-    plan_repr_sha1='a8c678a92ec79b6aa505feedefe70ee7fef92ccd',
+    plan_repr_sha1='58d0143ed6bbec74538c3af1d493d5b4f36423f2',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
     ),
     cls_names=(
-        ('omlish.specs.jmespath', 'Field'),
-        ('omlish.specs.jmespath', 'VariableRef'),
+        ('omlish.specs.jmespath', 'Index'),
     ),
 )
-def _process_dataclass__a8c678a92ec79b6aa505feedefe70ee7fef92ccd():
+def _process_dataclass__58d0143ed6bbec74538c3af1d493d5b4f36423f2():
     def _process_dataclass(
         *,
         __dataclass__cls,
@@ -1633,7 +1649,7 @@ def _process_dataclass__a8c678a92ec79b6aa505feedefe70ee7fef92ccd():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                name=self.name,
+                index=self.index,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -1647,7 +1663,7 @@ def _process_dataclass__a8c678a92ec79b6aa505feedefe70ee7fef92ccd():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self.name == other.name
+                self.index == other.index
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -1656,7 +1672,7 @@ def _process_dataclass__a8c678a92ec79b6aa505feedefe70ee7fef92ccd():
         setattr(__dataclass__cls, '__eq__', __eq__)
 
         __dataclass___setattr_frozen_fields = {
-            'name',
+            'index',
         }
 
         def __setattr__(self, name, value):
@@ -1673,7 +1689,7 @@ def _process_dataclass__a8c678a92ec79b6aa505feedefe70ee7fef92ccd():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'name',
+            'index',
         }
 
         def __delattr__(self, name):
@@ -1691,7 +1707,7 @@ def _process_dataclass__a8c678a92ec79b6aa505feedefe70ee7fef92ccd():
 
         def __hash__(self):
             return hash((
-                self.name,
+                self.index,
             ))
 
         __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
@@ -1699,9 +1715,9 @@ def _process_dataclass__a8c678a92ec79b6aa505feedefe70ee7fef92ccd():
 
         def __init__(
             self,
-            name: __dataclass__init__fields__0__annotation,
+            index: __dataclass__init__fields__0__annotation,
         ) -> __dataclass__None:
-            __dataclass__object_setattr(self, 'name', name)
+            __dataclass__object_setattr(self, 'index', index)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -1711,7 +1727,7 @@ def _process_dataclass__a8c678a92ec79b6aa505feedefe70ee7fef92ccd():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"name={self.name!r}")
+            parts.append(f"index={self.index!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -1728,36 +1744,29 @@ def _process_dataclass__a8c678a92ec79b6aa505feedefe70ee7fef92ccd():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('start', 'end', 'step')), EqPlan(fields=('start', 'end', 'step')), FrozenPlan(fiel"
-        "ds=('start', 'end', 'step'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('start', 'end',"
-        " 'step'), cache=False), InitPlan(fields=(InitPlan.Field(name='start', annotation=OpRef(name='init.fields.0.ann"
-        "otation'), default=None, default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerc"
-        "e=None, validate=None, check_type=None), InitPlan.Field(name='end', annotation=OpRef(name='init.fields.1.annot"
-        "ation'), default=None, default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce="
-        "None, validate=None, check_type=None), InitPlan.Field(name='step', annotation=OpRef(name='init.fields.2.annota"
-        "tion'), default=None, default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=N"
-        "one, validate=None, check_type=None)), self_param='self', std_params=('start', 'end', 'step'), kw_only_params="
-        "(), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan."
-        "Field(name='start', kw_only=False, fn=None), ReprPlan.Field(name='end', kw_only=False, fn=None), ReprPlan.Fiel"
-        "d(name='step', kw_only=False, fn=None)), id=False, terse=False, default_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('nodes',)), EqPlan(fields=('nodes',)), FrozenPlan(fields=('nodes',), allow_dynamic"
+        "_dunder_attrs=False), HashPlan(action='add', fields=('nodes',), cache=False), InitPlan(fields=(InitPlan.Field("
+        "name='nodes', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_factory=None, init=True"
+        ", override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None),), self_param='s"
+        "elf', std_params=('nodes',), kw_only_params=(), frozen=True, slots=False, post_init_params=None, init_fns=(), "
+        "validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='nodes', kw_only=False, fn=None),), id=False, terse=Fal"
+        "se, default_fn=None)))"
     ),
-    plan_repr_sha1='b32606cc73be16bf4f754945264efc4ebda65099',
+    plan_repr_sha1='95a04b516e507c6ca7803679cc697feffd03c2fe',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
-        '__dataclass__init__fields__1__annotation',
-        '__dataclass__init__fields__2__annotation',
     ),
     cls_names=(
-        ('omlish.specs.jmespath', 'Slice'),
+        ('omlish.specs.jmespath', 'IndexExpression'),
+        ('omlish.specs.jmespath', 'MultiSelectDict'),
+        ('omlish.specs.jmespath', 'MultiSelectList'),
     ),
 )
-def _process_dataclass__b32606cc73be16bf4f754945264efc4ebda65099():
+def _process_dataclass__95a04b516e507c6ca7803679cc697feffd03c2fe():
     def _process_dataclass(
         *,
         __dataclass__cls,
         __dataclass__init__fields__0__annotation,
-        __dataclass__init__fields__1__annotation,
-        __dataclass__init__fields__2__annotation,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -1776,9 +1785,7 @@ def _process_dataclass__b32606cc73be16bf4f754945264efc4ebda65099():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                start=self.start,
-                end=self.end,
-                step=self.step,
+                nodes=self.nodes,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -1792,9 +1799,7 @@ def _process_dataclass__b32606cc73be16bf4f754945264efc4ebda65099():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self.start == other.start and
-                self.end == other.end and
-                self.step == other.step
+                self.nodes == other.nodes
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -1803,9 +1808,7 @@ def _process_dataclass__b32606cc73be16bf4f754945264efc4ebda65099():
         setattr(__dataclass__cls, '__eq__', __eq__)
 
         __dataclass___setattr_frozen_fields = {
-            'start',
-            'end',
-            'step',
+            'nodes',
         }
 
         def __setattr__(self, name, value):
@@ -1822,9 +1825,7 @@ def _process_dataclass__b32606cc73be16bf4f754945264efc4ebda65099():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'start',
-            'end',
-            'step',
+            'nodes',
         }
 
         def __delattr__(self, name):
@@ -1842,9 +1843,7 @@ def _process_dataclass__b32606cc73be16bf4f754945264efc4ebda65099():
 
         def __hash__(self):
             return hash((
-                self.start,
-                self.end,
-                self.step,
+                self.nodes,
             ))
 
         __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
@@ -1852,13 +1851,9 @@ def _process_dataclass__b32606cc73be16bf4f754945264efc4ebda65099():
 
         def __init__(
             self,
-            start: __dataclass__init__fields__0__annotation,
-            end: __dataclass__init__fields__1__annotation,
-            step: __dataclass__init__fields__2__annotation,
+            nodes: __dataclass__init__fields__0__annotation,
         ) -> __dataclass__None:
-            __dataclass__object_setattr(self, 'start', start)
-            __dataclass__object_setattr(self, 'end', end)
-            __dataclass__object_setattr(self, 'step', step)
+            __dataclass__object_setattr(self, 'nodes', nodes)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -1868,9 +1863,7 @@ def _process_dataclass__b32606cc73be16bf4f754945264efc4ebda65099():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"start={self.start!r}")
-            parts.append(f"end={self.end!r}")
-            parts.append(f"step={self.step!r}")
+            parts.append(f"nodes={self.nodes!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -1887,27 +1880,27 @@ def _process_dataclass__b32606cc73be16bf4f754945264efc4ebda65099():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('bindings', 'expr')), EqPlan(fields=('bindings', 'expr')), FrozenPlan(fields=('bin"
-        "dings', 'expr'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('bindings', 'expr'), cache="
-        "False), InitPlan(fields=(InitPlan.Field(name='bindings', annotation=OpRef(name='init.fields.0.annotation'), de"
+        "Plans(tup=(CopyPlan(fields=('key_name', 'node')), EqPlan(fields=('key_name', 'node')), FrozenPlan(fields=('key"
+        "_name', 'node'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('key_name', 'node'), cache="
+        "False), InitPlan(fields=(InitPlan.Field(name='key_name', annotation=OpRef(name='init.fields.0.annotation'), de"
         "fault=None, default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, valid"
-        "ate=None, check_type=None), InitPlan.Field(name='expr', annotation=OpRef(name='init.fields.1.annotation'), def"
+        "ate=None, check_type=None), InitPlan.Field(name='node', annotation=OpRef(name='init.fields.1.annotation'), def"
         "ault=None, default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, valida"
-        "te=None, check_type=None)), self_param='self', std_params=('bindings', 'expr'), kw_only_params=(), frozen=True"
-        ", slots=False, post_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='bin"
-        "dings', kw_only=False, fn=None), ReprPlan.Field(name='expr', kw_only=False, fn=None)), id=False, terse=False, "
+        "te=None, check_type=None)), self_param='self', std_params=('key_name', 'node'), kw_only_params=(), frozen=True"
+        ", slots=False, post_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='key"
+        "_name', kw_only=False, fn=None), ReprPlan.Field(name='node', kw_only=False, fn=None)), id=False, terse=False, "
         "default_fn=None)))"
     ),
-    plan_repr_sha1='c8a250c76298910f7bf4f1d857d2754886ebd5c1',
+    plan_repr_sha1='5c98f4baa29dbd0603b7dae82100421eaccc16c1',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
         '__dataclass__init__fields__1__annotation',
     ),
     cls_names=(
-        ('omlish.specs.jmespath', 'LetExpression'),
+        ('omlish.specs.jmespath', 'KeyValPair'),
     ),
 )
-def _process_dataclass__c8a250c76298910f7bf4f1d857d2754886ebd5c1():
+def _process_dataclass__5c98f4baa29dbd0603b7dae82100421eaccc16c1():
     def _process_dataclass(
         *,
         __dataclass__cls,
@@ -1931,8 +1924,8 @@ def _process_dataclass__c8a250c76298910f7bf4f1d857d2754886ebd5c1():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                bindings=self.bindings,
-                expr=self.expr,
+                key_name=self.key_name,
+                node=self.node,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -1946,8 +1939,8 @@ def _process_dataclass__c8a250c76298910f7bf4f1d857d2754886ebd5c1():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self.bindings == other.bindings and
-                self.expr == other.expr
+                self.key_name == other.key_name and
+                self.node == other.node
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -1956,8 +1949,8 @@ def _process_dataclass__c8a250c76298910f7bf4f1d857d2754886ebd5c1():
         setattr(__dataclass__cls, '__eq__', __eq__)
 
         __dataclass___setattr_frozen_fields = {
-            'bindings',
-            'expr',
+            'key_name',
+            'node',
         }
 
         def __setattr__(self, name, value):
@@ -1974,8 +1967,8 @@ def _process_dataclass__c8a250c76298910f7bf4f1d857d2754886ebd5c1():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'bindings',
-            'expr',
+            'key_name',
+            'node',
         }
 
         def __delattr__(self, name):
@@ -1993,8 +1986,8 @@ def _process_dataclass__c8a250c76298910f7bf4f1d857d2754886ebd5c1():
 
         def __hash__(self):
             return hash((
-                self.bindings,
-                self.expr,
+                self.key_name,
+                self.node,
             ))
 
         __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
@@ -2002,11 +1995,11 @@ def _process_dataclass__c8a250c76298910f7bf4f1d857d2754886ebd5c1():
 
         def __init__(
             self,
-            bindings: __dataclass__init__fields__0__annotation,
-            expr: __dataclass__init__fields__1__annotation,
+            key_name: __dataclass__init__fields__0__annotation,
+            node: __dataclass__init__fields__1__annotation,
         ) -> __dataclass__None:
-            __dataclass__object_setattr(self, 'bindings', bindings)
-            __dataclass__object_setattr(self, 'expr', expr)
+            __dataclass__object_setattr(self, 'key_name', key_name)
+            __dataclass__object_setattr(self, 'node', node)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -2016,8 +2009,8 @@ def _process_dataclass__c8a250c76298910f7bf4f1d857d2754886ebd5c1():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"bindings={self.bindings!r}")
-            parts.append(f"expr={self.expr!r}")
+            parts.append(f"key_name={self.key_name!r}")
+            parts.append(f"node={self.node!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -2034,27 +2027,27 @@ def _process_dataclass__c8a250c76298910f7bf4f1d857d2754886ebd5c1():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('operator', 'expression')), EqPlan(fields=('operator', 'expression')), FrozenPlan("
-        "fields=('operator', 'expression'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('operator"
-        "', 'expression'), cache=False), InitPlan(fields=(InitPlan.Field(name='operator', annotation=OpRef(name='init.f"
-        "ields.0.annotation'), default=None, default_factory=None, init=True, override=False, field_type=FieldType.INST"
-        "ANCE, coerce=None, validate=None, check_type=None), InitPlan.Field(name='expression', annotation=OpRef(name='i"
-        "nit.fields.1.annotation'), default=None, default_factory=None, init=True, override=False, field_type=FieldType"
-        ".INSTANCE, coerce=None, validate=None, check_type=None)), self_param='self', std_params=('operator', 'expressi"
-        "on'), kw_only_params=(), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_fns=()), ReprP"
-        "lan(fields=(ReprPlan.Field(name='operator', kw_only=False, fn=None), ReprPlan.Field(name='expression', kw_only"
-        "=False, fn=None)), id=False, terse=False, default_fn=None)))"
-    ),
-    plan_repr_sha1='cdb3249bff15c580f8a8beab3e47937e31fe71a0',
-    op_ref_idents=(
-        '__dataclass__init__fields__0__annotation',
-        '__dataclass__init__fields__1__annotation',
+        "Plans(tup=(CopyPlan(fields=('bindings', 'expr')), EqPlan(fields=('bindings', 'expr')), FrozenPlan(fields=('bin"
+        "dings', 'expr'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('bindings', 'expr'), cache="
+        "False), InitPlan(fields=(InitPlan.Field(name='bindings', annotation=OpRef(name='init.fields.0.annotation'), de"
+        "fault=None, default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, valid"
+        "ate=None, check_type=None), InitPlan.Field(name='expr', annotation=OpRef(name='init.fields.1.annotation'), def"
+        "ault=None, default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, valida"
+        "te=None, check_type=None)), self_param='self', std_params=('bindings', 'expr'), kw_only_params=(), frozen=True"
+        ", slots=False, post_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='bin"
+        "dings', kw_only=False, fn=None), ReprPlan.Field(name='expr', kw_only=False, fn=None)), id=False, terse=False, "
+        "default_fn=None)))"
+    ),
+    plan_repr_sha1='c8a250c76298910f7bf4f1d857d2754886ebd5c1',
+    op_ref_idents=(
+        '__dataclass__init__fields__0__annotation',
+        '__dataclass__init__fields__1__annotation',
     ),
     cls_names=(
-        ('omlish.specs.jmespath', 'ArithmeticUnary'),
+        ('omlish.specs.jmespath', 'LetExpression'),
     ),
 )
-def _process_dataclass__cdb3249bff15c580f8a8beab3e47937e31fe71a0():
+def _process_dataclass__c8a250c76298910f7bf4f1d857d2754886ebd5c1():
     def _process_dataclass(
         *,
         __dataclass__cls,
@@ -2078,8 +2071,8 @@ def _process_dataclass__cdb3249bff15c580f8a8beab3e47937e31fe71a0():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                operator=self.operator,
-                expression=self.expression,
+                bindings=self.bindings,
+                expr=self.expr,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -2093,8 +2086,8 @@ def _process_dataclass__cdb3249bff15c580f8a8beab3e47937e31fe71a0():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self.operator == other.operator and
-                self.expression == other.expression
+                self.bindings == other.bindings and
+                self.expr == other.expr
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -2103,8 +2096,8 @@ def _process_dataclass__cdb3249bff15c580f8a8beab3e47937e31fe71a0():
         setattr(__dataclass__cls, '__eq__', __eq__)
 
         __dataclass___setattr_frozen_fields = {
-            'operator',
-            'expression',
+            'bindings',
+            'expr',
         }
 
         def __setattr__(self, name, value):
@@ -2121,8 +2114,8 @@ def _process_dataclass__cdb3249bff15c580f8a8beab3e47937e31fe71a0():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'operator',
-            'expression',
+            'bindings',
+            'expr',
         }
 
         def __delattr__(self, name):
@@ -2140,8 +2133,8 @@ def _process_dataclass__cdb3249bff15c580f8a8beab3e47937e31fe71a0():
 
         def __hash__(self):
             return hash((
-                self.operator,
-                self.expression,
+                self.bindings,
+                self.expr,
             ))
 
         __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
@@ -2149,11 +2142,11 @@ def _process_dataclass__cdb3249bff15c580f8a8beab3e47937e31fe71a0():
 
         def __init__(
             self,
-            operator: __dataclass__init__fields__0__annotation,
-            expression: __dataclass__init__fields__1__annotation,
+            bindings: __dataclass__init__fields__0__annotation,
+            expr: __dataclass__init__fields__1__annotation,
         ) -> __dataclass__None:
-            __dataclass__object_setattr(self, 'operator', operator)
-            __dataclass__object_setattr(self, 'expression', expression)
+            __dataclass__object_setattr(self, 'bindings', bindings)
+            __dataclass__object_setattr(self, 'expr', expr)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -2163,8 +2156,8 @@ def _process_dataclass__cdb3249bff15c580f8a8beab3e47937e31fe71a0():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"operator={self.operator!r}")
-            parts.append(f"expression={self.expression!r}")
+            parts.append(f"bindings={self.bindings!r}")
+            parts.append(f"expr={self.expr!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -2181,23 +2174,23 @@ def _process_dataclass__cdb3249bff15c580f8a8beab3e47937e31fe71a0():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('children_nodes',)), EqPlan(fields=('children_nodes',)), FrozenPlan(fields=('child"
-        "ren_nodes',), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('children_nodes',), cache=Fals"
-        "e), InitPlan(fields=(InitPlan.Field(name='children_nodes', annotation=OpRef(name='init.fields.0.annotation'), "
-        "default=None, default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, val"
-        "idate=None, check_type=None),), self_param='self', std_params=('children_nodes',), kw_only_params=(), frozen=T"
-        "rue, slots=False, post_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='"
-        "children_nodes', kw_only=False, fn=None),), id=False, terse=False, default_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('literal_value',)), EqPlan(fields=('literal_value',)), FrozenPlan(fields=('literal"
+        "_value',), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('literal_value',), cache=False), "
+        "InitPlan(fields=(InitPlan.Field(name='literal_value', annotation=OpRef(name='init.fields.0.annotation'), defau"
+        "lt=None, default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate"
+        "=None, check_type=None),), self_param='self', std_params=('literal_value',), kw_only_params=(), frozen=True, s"
+        "lots=False, post_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='litera"
+        "l_value', kw_only=False, fn=None),), id=False, terse=False, default_fn=None)))"
     ),
-    plan_repr_sha1='d958b10b4f15409b30504a103e6c94dfe8c47b9d',
+    plan_repr_sha1='84f3ffbf073b3ca8957fd80ce73aa63d4e81555d',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
     ),
     cls_names=(
-        ('omlish.specs.jmespath', 'Subexpression'),
+        ('omlish.specs.jmespath', 'Literal'),
     ),
 )
-def _process_dataclass__d958b10b4f15409b30504a103e6c94dfe8c47b9d():
+def _process_dataclass__84f3ffbf073b3ca8957fd80ce73aa63d4e81555d():
     def _process_dataclass(
         *,
         __dataclass__cls,
@@ -2220,7 +2213,7 @@ def _process_dataclass__d958b10b4f15409b30504a103e6c94dfe8c47b9d():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                children_nodes=self.children_nodes,
+                literal_value=self.literal_value,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -2234,7 +2227,7 @@ def _process_dataclass__d958b10b4f15409b30504a103e6c94dfe8c47b9d():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self.children_nodes == other.children_nodes
+                self.literal_value == other.literal_value
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -2243,7 +2236,7 @@ def _process_dataclass__d958b10b4f15409b30504a103e6c94dfe8c47b9d():
         setattr(__dataclass__cls, '__eq__', __eq__)
 
         __dataclass___setattr_frozen_fields = {
-            'children_nodes',
+            'literal_value',
         }
 
         def __setattr__(self, name, value):
@@ -2260,7 +2253,7 @@ def _process_dataclass__d958b10b4f15409b30504a103e6c94dfe8c47b9d():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'children_nodes',
+            'literal_value',
         }
 
         def __delattr__(self, name):
@@ -2278,7 +2271,7 @@ def _process_dataclass__d958b10b4f15409b30504a103e6c94dfe8c47b9d():
 
         def __hash__(self):
             return hash((
-                self.children_nodes,
+                self.literal_value,
             ))
 
         __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
@@ -2286,9 +2279,9 @@ def _process_dataclass__d958b10b4f15409b30504a103e6c94dfe8c47b9d():
 
         def __init__(
             self,
-            children_nodes: __dataclass__init__fields__0__annotation,
+            literal_value: __dataclass__init__fields__0__annotation,
         ) -> __dataclass__None:
-            __dataclass__object_setattr(self, 'children_nodes', children_nodes)
+            __dataclass__object_setattr(self, 'literal_value', literal_value)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -2298,7 +2291,7 @@ def _process_dataclass__d958b10b4f15409b30504a103e6c94dfe8c47b9d():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"children_nodes={self.children_nodes!r}")
+            parts.append(f"literal_value={self.literal_value!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -2315,25 +2308,27 @@ def _process_dataclass__d958b10b4f15409b30504a103e6c94dfe8c47b9d():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=()), EqPlan(fields=()), FrozenPlan(fields=(), allow_dynamic_dunder_attrs=False), Ha"
-        "shPlan(action='add', fields=(), cache=False), InitPlan(fields=(), self_param='self', std_params=(), kw_only_pa"
-        "rams=(), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(), i"
-        "d=False, terse=False, default_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('expr',)), EqPlan(fields=('expr',)), FrozenPlan(fields=('expr',), allow_dynamic_du"
+        "nder_attrs=False), HashPlan(action='add', fields=('expr',), cache=False), InitPlan(fields=(InitPlan.Field(name"
+        "='expr', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_factory=None, init=True, ove"
+        "rride=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None),), self_param='self',"
+        " std_params=('expr',), kw_only_params=(), frozen=True, slots=False, post_init_params=None, init_fns=(), valida"
+        "te_fns=()), ReprPlan(fields=(ReprPlan.Field(name='expr', kw_only=False, fn=None),), id=False, terse=False, def"
+        "ault_fn=None)))"
+    ),
+    plan_repr_sha1='40ccd63db7a447b608d0875571d487f96ef3af93',
+    op_ref_idents=(
+        '__dataclass__init__fields__0__annotation',
     ),
-    plan_repr_sha1='e1f7edfe11f2b721d6a656c46e698fedc95461bb',
-    op_ref_idents=(),
     cls_names=(
-        ('omlish.specs.jmespath', 'CurrentNode'),
-        ('omlish.specs.jmespath', 'Identity'),
-        ('omlish.specs.jmespath', 'LeafNode'),
-        ('omlish.specs.jmespath', 'Node'),
-        ('omlish.specs.jmespath', 'RootNode'),
+        ('omlish.specs.jmespath', 'NotExpression'),
     ),
 )
-def _process_dataclass__e1f7edfe11f2b721d6a656c46e698fedc95461bb():
+def _process_dataclass__40ccd63db7a447b608d0875571d487f96ef3af93():
     def _process_dataclass(
         *,
         __dataclass__cls,
+        __dataclass__init__fields__0__annotation,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -2351,7 +2346,9 @@ def _process_dataclass__e1f7edfe11f2b721d6a656c46e698fedc95461bb():
         def __copy__(self):
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
-            return __dataclass__cls()  # noqa
+            return __dataclass__cls(  # noqa
+                expr=self.expr,
+            )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
         if '__copy__' in __dataclass__cls.__dict__:
@@ -2363,16 +2360,23 @@ def _process_dataclass__e1f7edfe11f2b721d6a656c46e698fedc95461bb():
                 return True
             if self.__class__ is not other.__class__:
                 return NotImplemented
-            return True
+            return (
+                self.expr == other.expr
+            )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
         if '__eq__' in __dataclass__cls.__dict__:
             raise __dataclass__TypeError(f"Cannot overwrite attribute __eq__ in class {__dataclass__cls.__name__}")
         setattr(__dataclass__cls, '__eq__', __eq__)
 
+        __dataclass___setattr_frozen_fields = {
+            'expr',
+        }
+
         def __setattr__(self, name, value):
             if (
                 type(self) is __dataclass__cls
+                 or name in __dataclass___setattr_frozen_fields
             ):
                 raise __dataclass__FrozenInstanceError(f"cannot assign to field {name!r}")
             super(__dataclass__cls, self).__setattr__(name, value)
@@ -2382,9 +2386,14 @@ def _process_dataclass__e1f7edfe11f2b721d6a656c46e698fedc95461bb():
             raise __dataclass__TypeError(f"Cannot overwrite attribute __setattr__ in class {__dataclass__cls.__name__}")
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
+        __dataclass___delattr_frozen_fields = {
+            'expr',
+        }
+
         def __delattr__(self, name):
             if (
                 type(self) is __dataclass__cls
+                 or name in __dataclass___delattr_frozen_fields
             ):
                 raise __dataclass__FrozenInstanceError(f"cannot delete field {name!r}")
             super(__dataclass__cls, self).__delattr__(name)
@@ -2395,15 +2404,18 @@ def _process_dataclass__e1f7edfe11f2b721d6a656c46e698fedc95461bb():
         setattr(__dataclass__cls, '__delattr__', __delattr__)
 
         def __hash__(self):
-            return hash(())
+            return hash((
+                self.expr,
+            ))
 
         __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
         setattr(__dataclass__cls, '__hash__', __hash__)
 
         def __init__(
             self,
+            expr: __dataclass__init__fields__0__annotation,
         ) -> __dataclass__None:
-            pass
+            __dataclass__object_setattr(self, 'expr', expr)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -2413,6 +2425,7 @@ def _process_dataclass__e1f7edfe11f2b721d6a656c46e698fedc95461bb():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
+            parts.append(f"expr={self.expr!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -2429,31 +2442,30 @@ def _process_dataclass__e1f7edfe11f2b721d6a656c46e698fedc95461bb():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('left', 'right', 'comparator')), EqPlan(fields=('left', 'right', 'comparator')), F"
-        "rozenPlan(fields=('left', 'right', 'comparator'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fi"
-        "elds=('left', 'right', 'comparator'), cache=False), InitPlan(fields=(InitPlan.Field(name='left', annotation=Op"
-        "Ref(name='init.fields.0.annotation'), default=None, default_factory=None, init=True, override=False, field_typ"
-        "e=FieldType.INSTANCE, coerce=None, validate=None, check_type=None), InitPlan.Field(name='right', annotation=Op"
-        "Ref(name='init.fields.1.annotation'), default=None, default_factory=None, init=True, override=False, field_typ"
-        "e=FieldType.INSTANCE, coerce=None, validate=None, check_type=None), InitPlan.Field(name='comparator', annotati"
-        "on=OpRef(name='init.fields.2.annotation'), default=None, default_factory=None, init=True, override=False, fiel"
-        "d_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None)), self_param='self', std_params=('left"
-        "', 'right', 'comparator'), kw_only_params=(), frozen=True, slots=False, post_init_params=None, init_fns=(), va"
-        "lidate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='left', kw_only=False, fn=None), ReprPlan.Field(name='rig"
-        "ht', kw_only=False, fn=None), ReprPlan.Field(name='comparator', kw_only=False, fn=None)), id=False, terse=Fals"
-        "e, default_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('start', 'end', 'step')), EqPlan(fields=('start', 'end', 'step')), FrozenPlan(fiel"
+        "ds=('start', 'end', 'step'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('start', 'end',"
+        " 'step'), cache=False), InitPlan(fields=(InitPlan.Field(name='start', annotation=OpRef(name='init.fields.0.ann"
+        "otation'), default=None, default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerc"
+        "e=None, validate=None, check_type=None), InitPlan.Field(name='end', annotation=OpRef(name='init.fields.1.annot"
+        "ation'), default=None, default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce="
+        "None, validate=None, check_type=None), InitPlan.Field(name='step', annotation=OpRef(name='init.fields.2.annota"
+        "tion'), default=None, default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=N"
+        "one, validate=None, check_type=None)), self_param='self', std_params=('start', 'end', 'step'), kw_only_params="
+        "(), frozen=True, slots=False, post_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan."
+        "Field(name='start', kw_only=False, fn=None), ReprPlan.Field(name='end', kw_only=False, fn=None), ReprPlan.Fiel"
+        "d(name='step', kw_only=False, fn=None)), id=False, terse=False, default_fn=None)))"
     ),
-    plan_repr_sha1='ee40fd21fce658ecb8d6c4a236c24880e69abc90',
+    plan_repr_sha1='b32606cc73be16bf4f754945264efc4ebda65099',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
         '__dataclass__init__fields__1__annotation',
         '__dataclass__init__fields__2__annotation',
     ),
     cls_names=(
-        ('omlish.specs.jmespath', 'FilterProjection'),
+        ('omlish.specs.jmespath', 'Slice'),
     ),
 )
-def _process_dataclass__ee40fd21fce658ecb8d6c4a236c24880e69abc90():
+def _process_dataclass__b32606cc73be16bf4f754945264efc4ebda65099():
     def _process_dataclass(
         *,
         __dataclass__cls,
@@ -2478,9 +2490,9 @@ def _process_dataclass__ee40fd21fce658ecb8d6c4a236c24880e69abc90():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                left=self.left,
-                right=self.right,
-                comparator=self.comparator,
+                start=self.start,
+                end=self.end,
+                step=self.step,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -2494,9 +2506,9 @@ def _process_dataclass__ee40fd21fce658ecb8d6c4a236c24880e69abc90():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self.left == other.left and
-                self.right == other.right and
-                self.comparator == other.comparator
+                self.start == other.start and
+                self.end == other.end and
+                self.step == other.step
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -2505,9 +2517,9 @@ def _process_dataclass__ee40fd21fce658ecb8d6c4a236c24880e69abc90():
         setattr(__dataclass__cls, '__eq__', __eq__)
 
         __dataclass___setattr_frozen_fields = {
-            'left',
-            'right',
-            'comparator',
+            'start',
+            'end',
+            'step',
         }
 
         def __setattr__(self, name, value):
@@ -2524,9 +2536,9 @@ def _process_dataclass__ee40fd21fce658ecb8d6c4a236c24880e69abc90():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'left',
-            'right',
-            'comparator',
+            'start',
+            'end',
+            'step',
         }
 
         def __delattr__(self, name):
@@ -2544,9 +2556,9 @@ def _process_dataclass__ee40fd21fce658ecb8d6c4a236c24880e69abc90():
 
         def __hash__(self):
             return hash((
-                self.left,
-                self.right,
-                self.comparator,
+                self.start,
+                self.end,
+                self.step,
             ))
 
         __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
@@ -2554,13 +2566,13 @@ def _process_dataclass__ee40fd21fce658ecb8d6c4a236c24880e69abc90():
 
         def __init__(
             self,
-            left: __dataclass__init__fields__0__annotation,
-            right: __dataclass__init__fields__1__annotation,
-            comparator: __dataclass__init__fields__2__annotation,
+            start: __dataclass__init__fields__0__annotation,
+            end: __dataclass__init__fields__1__annotation,
+            step: __dataclass__init__fields__2__annotation,
         ) -> __dataclass__None:
-            __dataclass__object_setattr(self, 'left', left)
-            __dataclass__object_setattr(self, 'right', right)
-            __dataclass__object_setattr(self, 'comparator', comparator)
+            __dataclass__object_setattr(self, 'start', start)
+            __dataclass__object_setattr(self, 'end', end)
+            __dataclass__object_setattr(self, 'step', step)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -2570,9 +2582,9 @@ def _process_dataclass__ee40fd21fce658ecb8d6c4a236c24880e69abc90():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"left={self.left!r}")
-            parts.append(f"right={self.right!r}")
-            parts.append(f"comparator={self.comparator!r}")
+            parts.append(f"start={self.start!r}")
+            parts.append(f"end={self.end!r}")
+            parts.append(f"step={self.step!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -2589,37 +2601,27 @@ def _process_dataclass__ee40fd21fce658ecb8d6c4a236c24880e69abc90():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('condition', 'if_truthy', 'if_falsy')), EqPlan(fields=('condition', 'if_truthy', '"
-        "if_falsy')), FrozenPlan(fields=('condition', 'if_truthy', 'if_falsy'), allow_dynamic_dunder_attrs=False), Hash"
-        "Plan(action='add', fields=('condition', 'if_truthy', 'if_falsy'), cache=False), InitPlan(fields=(InitPlan.Fiel"
-        "d(name='condition', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_factory=None, ini"
-        "t=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None), InitPlan."
-        "Field(name='if_truthy', annotation=OpRef(name='init.fields.1.annotation'), default=None, default_factory=None,"
-        " init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None), InitP"
-        "lan.Field(name='if_falsy', annotation=OpRef(name='init.fields.2.annotation'), default=None, default_factory=No"
-        "ne, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None)), s"
-        "elf_param='self', std_params=('condition', 'if_truthy', 'if_falsy'), kw_only_params=(), frozen=True, slots=Fal"
-        "se, post_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='condition', kw"
-        "_only=False, fn=None), ReprPlan.Field(name='if_truthy', kw_only=False, fn=None), ReprPlan.Field(name='if_falsy"
-        "', kw_only=False, fn=None)), id=False, terse=False, default_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('children_nodes',)), EqPlan(fields=('children_nodes',)), FrozenPlan(fields=('child"
+        "ren_nodes',), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('children_nodes',), cache=Fals"
+        "e), InitPlan(fields=(InitPlan.Field(name='children_nodes', annotation=OpRef(name='init.fields.0.annotation'), "
+        "default=None, default_factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, val"
+        "idate=None, check_type=None),), self_param='self', std_params=('children_nodes',), kw_only_params=(), frozen=T"
+        "rue, slots=False, post_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='"
+        "children_nodes', kw_only=False, fn=None),), id=False, terse=False, default_fn=None)))"
     ),
-    plan_repr_sha1='f81e930fc657b10385e84befd8ddeba424da3fc1',
+    plan_repr_sha1='d958b10b4f15409b30504a103e6c94dfe8c47b9d',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
-        '__dataclass__init__fields__1__annotation',
-        '__dataclass__init__fields__2__annotation',
     ),
     cls_names=(
-        ('omlish.specs.jmespath', 'TernaryOperator'),
+        ('omlish.specs.jmespath', 'Subexpression'),
     ),
 )
-def _process_dataclass__f81e930fc657b10385e84befd8ddeba424da3fc1():
+def _process_dataclass__d958b10b4f15409b30504a103e6c94dfe8c47b9d():
     def _process_dataclass(
         *,
         __dataclass__cls,
         __dataclass__init__fields__0__annotation,
-        __dataclass__init__fields__1__annotation,
-        __dataclass__init__fields__2__annotation,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -2638,9 +2640,7 @@ def _process_dataclass__f81e930fc657b10385e84befd8ddeba424da3fc1():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                condition=self.condition,
-                if_truthy=self.if_truthy,
-                if_falsy=self.if_falsy,
+                children_nodes=self.children_nodes,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -2654,9 +2654,7 @@ def _process_dataclass__f81e930fc657b10385e84befd8ddeba424da3fc1():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self.condition == other.condition and
-                self.if_truthy == other.if_truthy and
-                self.if_falsy == other.if_falsy
+                self.children_nodes == other.children_nodes
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -2665,9 +2663,7 @@ def _process_dataclass__f81e930fc657b10385e84befd8ddeba424da3fc1():
         setattr(__dataclass__cls, '__eq__', __eq__)
 
         __dataclass___setattr_frozen_fields = {
-            'condition',
-            'if_truthy',
-            'if_falsy',
+            'children_nodes',
         }
 
         def __setattr__(self, name, value):
@@ -2684,9 +2680,7 @@ def _process_dataclass__f81e930fc657b10385e84befd8ddeba424da3fc1():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'condition',
-            'if_truthy',
-            'if_falsy',
+            'children_nodes',
         }
 
         def __delattr__(self, name):
@@ -2704,9 +2698,7 @@ def _process_dataclass__f81e930fc657b10385e84befd8ddeba424da3fc1():
 
         def __hash__(self):
             return hash((
-                self.condition,
-                self.if_truthy,
-                self.if_falsy,
+                self.children_nodes,
             ))
 
         __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
@@ -2714,13 +2706,9 @@ def _process_dataclass__f81e930fc657b10385e84befd8ddeba424da3fc1():
 
         def __init__(
             self,
-            condition: __dataclass__init__fields__0__annotation,
-            if_truthy: __dataclass__init__fields__1__annotation,
-            if_falsy: __dataclass__init__fields__2__annotation,
+            children_nodes: __dataclass__init__fields__0__annotation,
         ) -> __dataclass__None:
-            __dataclass__object_setattr(self, 'condition', condition)
-            __dataclass__object_setattr(self, 'if_truthy', if_truthy)
-            __dataclass__object_setattr(self, 'if_falsy', if_falsy)
+            __dataclass__object_setattr(self, 'children_nodes', children_nodes)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -2730,9 +2718,7 @@ def _process_dataclass__f81e930fc657b10385e84befd8ddeba424da3fc1():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"condition={self.condition!r}")
-            parts.append(f"if_truthy={self.if_truthy!r}")
-            parts.append(f"if_falsy={self.if_falsy!r}")
+            parts.append(f"children_nodes={self.children_nodes!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"
@@ -2749,31 +2735,37 @@ def _process_dataclass__f81e930fc657b10385e84befd8ddeba424da3fc1():
 
 @_register(
     plan_repr=(
-        "Plans(tup=(CopyPlan(fields=('name', 'expr')), EqPlan(fields=('name', 'expr')), FrozenPlan(fields=('name', 'exp"
-        "r'), allow_dynamic_dunder_attrs=False), HashPlan(action='add', fields=('name', 'expr'), cache=False), InitPlan"
-        "(fields=(InitPlan.Field(name='name', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_"
-        "factory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type"
-        "=None), InitPlan.Field(name='expr', annotation=OpRef(name='init.fields.1.annotation'), default=None, default_f"
-        "actory=None, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type="
-        "None)), self_param='self', std_params=('name', 'expr'), kw_only_params=(), frozen=True, slots=False, post_init"
-        "_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='name', kw_only=False, fn=No"
-        "ne), ReprPlan.Field(name='expr', kw_only=False, fn=None)), id=False, terse=False, default_fn=None)))"
+        "Plans(tup=(CopyPlan(fields=('condition', 'if_truthy', 'if_falsy')), EqPlan(fields=('condition', 'if_truthy', '"
+        "if_falsy')), FrozenPlan(fields=('condition', 'if_truthy', 'if_falsy'), allow_dynamic_dunder_attrs=False), Hash"
+        "Plan(action='add', fields=('condition', 'if_truthy', 'if_falsy'), cache=False), InitPlan(fields=(InitPlan.Fiel"
+        "d(name='condition', annotation=OpRef(name='init.fields.0.annotation'), default=None, default_factory=None, ini"
+        "t=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None), InitPlan."
+        "Field(name='if_truthy', annotation=OpRef(name='init.fields.1.annotation'), default=None, default_factory=None,"
+        " init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None), InitP"
+        "lan.Field(name='if_falsy', annotation=OpRef(name='init.fields.2.annotation'), default=None, default_factory=No"
+        "ne, init=True, override=False, field_type=FieldType.INSTANCE, coerce=None, validate=None, check_type=None)), s"
+        "elf_param='self', std_params=('condition', 'if_truthy', 'if_falsy'), kw_only_params=(), frozen=True, slots=Fal"
+        "se, post_init_params=None, init_fns=(), validate_fns=()), ReprPlan(fields=(ReprPlan.Field(name='condition', kw"
+        "_only=False, fn=None), ReprPlan.Field(name='if_truthy', kw_only=False, fn=None), ReprPlan.Field(name='if_falsy"
+        "', kw_only=False, fn=None)), id=False, terse=False, default_fn=None)))"
     ),
-    plan_repr_sha1='fb46b9fb75089de970d1b8ccffb404d02368804a',
+    plan_repr_sha1='f81e930fc657b10385e84befd8ddeba424da3fc1',
     op_ref_idents=(
         '__dataclass__init__fields__0__annotation',
         '__dataclass__init__fields__1__annotation',
+        '__dataclass__init__fields__2__annotation',
     ),
     cls_names=(
-        ('omlish.specs.jmespath', 'Assign'),
+        ('omlish.specs.jmespath', 'TernaryOperator'),
     ),
 )
-def _process_dataclass__fb46b9fb75089de970d1b8ccffb404d02368804a():
+def _process_dataclass__f81e930fc657b10385e84befd8ddeba424da3fc1():
     def _process_dataclass(
         *,
         __dataclass__cls,
         __dataclass__init__fields__0__annotation,
         __dataclass__init__fields__1__annotation,
+        __dataclass__init__fields__2__annotation,
         __dataclass__FieldFnValidationError,  # noqa
         __dataclass__FieldTypeValidationError,  # noqa
         __dataclass__FnValidationError,  # noqa
@@ -2792,8 +2784,9 @@ def _process_dataclass__fb46b9fb75089de970d1b8ccffb404d02368804a():
             if self.__class__ is not __dataclass__cls:
                 raise TypeError(self)
             return __dataclass__cls(  # noqa
-                name=self.name,
-                expr=self.expr,
+                condition=self.condition,
+                if_truthy=self.if_truthy,
+                if_falsy=self.if_falsy,
             )
 
         __copy__.__qualname__ = f"{__dataclass__cls.__qualname__}.__copy__"
@@ -2807,8 +2800,9 @@ def _process_dataclass__fb46b9fb75089de970d1b8ccffb404d02368804a():
             if self.__class__ is not other.__class__:
                 return NotImplemented
             return (
-                self.name == other.name and
-                self.expr == other.expr
+                self.condition == other.condition and
+                self.if_truthy == other.if_truthy and
+                self.if_falsy == other.if_falsy
             )
 
         __eq__.__qualname__ = f"{__dataclass__cls.__qualname__}.__eq__"
@@ -2817,8 +2811,9 @@ def _process_dataclass__fb46b9fb75089de970d1b8ccffb404d02368804a():
         setattr(__dataclass__cls, '__eq__', __eq__)
 
         __dataclass___setattr_frozen_fields = {
-            'name',
-            'expr',
+            'condition',
+            'if_truthy',
+            'if_falsy',
         }
 
         def __setattr__(self, name, value):
@@ -2835,8 +2830,9 @@ def _process_dataclass__fb46b9fb75089de970d1b8ccffb404d02368804a():
         setattr(__dataclass__cls, '__setattr__', __setattr__)
 
         __dataclass___delattr_frozen_fields = {
-            'name',
-            'expr',
+            'condition',
+            'if_truthy',
+            'if_falsy',
         }
 
         def __delattr__(self, name):
@@ -2854,8 +2850,9 @@ def _process_dataclass__fb46b9fb75089de970d1b8ccffb404d02368804a():
 
         def __hash__(self):
             return hash((
-                self.name,
-                self.expr,
+                self.condition,
+                self.if_truthy,
+                self.if_falsy,
             ))
 
         __hash__.__qualname__ = f"{__dataclass__cls.__qualname__}.__hash__"
@@ -2863,11 +2860,13 @@ def _process_dataclass__fb46b9fb75089de970d1b8ccffb404d02368804a():
 
         def __init__(
             self,
-            name: __dataclass__init__fields__0__annotation,
-            expr: __dataclass__init__fields__1__annotation,
+            condition: __dataclass__init__fields__0__annotation,
+            if_truthy: __dataclass__init__fields__1__annotation,
+            if_falsy: __dataclass__init__fields__2__annotation,
         ) -> __dataclass__None:
-            __dataclass__object_setattr(self, 'name', name)
-            __dataclass__object_setattr(self, 'expr', expr)
+            __dataclass__object_setattr(self, 'condition', condition)
+            __dataclass__object_setattr(self, 'if_truthy', if_truthy)
+            __dataclass__object_setattr(self, 'if_falsy', if_falsy)
 
         __init__.__qualname__ = f"{__dataclass__cls.__qualname__}.__init__"
         if '__init__' in __dataclass__cls.__dict__:
@@ -2877,8 +2876,9 @@ def _process_dataclass__fb46b9fb75089de970d1b8ccffb404d02368804a():
         @__dataclass___recursive_repr()
         def __repr__(self):
             parts = []
-            parts.append(f"name={self.name!r}")
-            parts.append(f"expr={self.expr!r}")
+            parts.append(f"condition={self.condition!r}")
+            parts.append(f"if_truthy={self.if_truthy!r}")
+            parts.append(f"if_falsy={self.if_falsy!r}")
             return (
                 f"{self.__class__.__qualname__}("
                 f"{', '.join(parts)}"