attempt to account for parenthesis pairs in particle names

Author: admorris

src/decaylanguage/data/descriptor.lark

@@ -2,28 +2,30 @@
 //
 // Distributed under the 3-clause BSD license, see accompanying file LICENSE
 // or https://github.com/scikit-hep/decaylanguage for details.
+%import common.WS_INLINE
 
-start: decay
+start: _ws decay _ws
 
-decay: particle ARROW daughters
+decay: particle _ws ARROW _ws daughters
 
-daughters: daughter+
+daughters: daughter (_sep daughter)* _ws
 
 daughter: particle
         | sub_decay
 
-particle: PARTICLE
-
-sub_decay: LPAR decay RPAR
+particle: PHEAD psuffix*
+sub_decay: LPAR _ws decay RPAR
 
 // Terminals
-ARROW: "->"
+ARROW.2: "->"
 LPAR: "("
 RPAR: ")"
 
-// Particle names start with alphanumeric/underscore and can then include
-// common descriptor suffix symbols such as +, -, *, ', and ~.
-PARTICLE: /[A-Za-z0-9_][A-Za-z0-9_+*'~̄-]*/
+psuffix: PCHUNK | pgroup_paren
+pgroup_paren: "(" _ws PCHUNK _ws ")"
+
+PHEAD: /[A-Za-z0-9~][A-Za-z0-9\/\-+*_.'~]*/
+PCHUNK: /[A-Za-z0-9\/\-+*_.'~]+/
 
-%import common.WS
-%ignore WS
+_sep: WS_INLINE+
+_ws: WS_INLINE*

src/decaylanguage/decay/decay.py

@@ -772,16 +772,38 @@ def start(self, items: list[Any]) -> DecayChainDict:
         return typing.cast(DecayChainDict, items[0])
 
     def particle(self, items: list[Any]) -> str:
-        # particle: PARTICLE
-        return str(items[0])
+        # particle: PHEAD psuffix*
+        # Rebuild full particle name from head + suffixes
+        return "".join(self._item_text(i) for i in items if not self._is_ws(i))
+
+    def psuffix(self, items: list[Any]) -> str:
+        # psuffix: PCHUNK | pgroup_paren
+        # Return the only significant piece
+        for item in items:
+            if not self._is_ws(item):
+                return self._item_text(item)
+        return ""
+
+    def pgroup_paren(self, items: list[Any]) -> str:
+        # pgroup_paren: "(" _ws PCHUNK _ws ")"
+        inner = "".join(
+            self._item_text(i)
+            for i in items
+            if not self._is_ws(i) and not self._is_paren_token(i)
+        )
+        return f"({inner})"
 
     def daughter(self, items: list[Any]) -> str | DecayChainDict:
         # daughter: particle | sub_decay
         return typing.cast(str | DecayChainDict, items[0])
 
     def daughters(self, items: list[Any]) -> list[str | DecayChainDict]:
         # daughters: daughter+
-        return [item for item in items if isinstance(item, (str, dict))]
+        return [
+            item
+            for item in items
+            if not isinstance(item, Token) and isinstance(item, (str, dict))
+        ]
 
     def sub_decay(self, items: list[Any]) -> DecayChainDict:
         # sub_decay: LPAR decay RPAR
@@ -796,13 +818,13 @@ def decay(self, items: list[Any]) -> DecayChainDict:
         daughters: list[str | DecayChainDict] | None = None
 
         for item in items:
+            if isinstance(item, Token):
+                # Ignore punctuation and whitespace tokens.
+                continue
             if isinstance(item, str) and mother is None:
                 mother = item
             elif isinstance(item, list):
                 daughters = item
-            elif isinstance(item, Token):
-                # Ignore punctuation tokens such as ARROW.
-                continue
 
         if not mother or not daughters:
             raise ValueError(
@@ -817,6 +839,18 @@ def decay(self, items: list[Any]) -> DecayChainDict:
         }
         return {mother: [mode]}
 
+    @staticmethod
+    def _is_ws(item: Any) -> bool:
+        return isinstance(item, Token) and item.type == "WS_INLINE"
+
+    @staticmethod
+    def _is_paren_token(item: Any) -> bool:
+        return isinstance(item, Token) and item.type in {"LPAR", "RPAR"}
+
+    @staticmethod
+    def _item_text(item: Any) -> str:
+        return str(item.value) if isinstance(item, Token) else str(item)
+
 
 class DecayChain:
     """