@danielx/civet 0.5.66 → 0.5.67

package/dist/browser.js

@@ -444,11 +444,12 @@ ${input.slice(result.pos)}
         NonSuppressedTrailingMemberExpressions,
         CommaDelimiter,
         ArgumentList,
+        NonPipelineArgumentList,
         NestedArgumentList,
         NestedArgument,
-        InlineArgumentExpressions,
         SingleLineArgumentExpressions,
         ArgumentPart,
+        NonPipelineArgumentPart,
         BinaryOpExpression,
         BinaryOpRHS,
         RHS,
@@ -1491,7 +1492,7 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var ImplicitArguments$0 = $TS($S($E($S(TypeArguments, $N(ImplementsToken))), ApplicationStart, InsertOpenParen, $Q(_), ArgumentList, InsertCloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
+      var ImplicitArguments$0 = $TS($S($E($S(TypeArguments, $N(ImplementsToken))), ApplicationStart, InsertOpenParen, $Q(_), NonPipelineArgumentList, InsertCloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
         var ta = $1;
         var open = $3;
         var ws = $4;
@@ -1709,7 +1710,9 @@ ${input.slice(result.pos)}
         return module.insertTrimmingSpace($1, "");
       });
       var ArgumentList$2 = NestedArgumentList;
-      var ArgumentList$3 = InlineArgumentExpressions;
+      var ArgumentList$3 = $TS($S($Q(TrailingComment), ArgumentPart, $Q($S(CommaDelimiter, $Q(TrailingComment), ArgumentPart))), function($skip, $loc, $0, $1, $2, $3) {
+        return [...$1, $2, ...$3];
+      });
       function ArgumentList(state) {
         let eventData;
         if (state.events) {
@@ -1732,6 +1735,36 @@ ${input.slice(result.pos)}
           return result;
         }
       }
+      var NonPipelineArgumentList$0 = $S(NonPipelineArgumentPart, $P($S(CommaDelimiter, $C(NestedImplicitObjectLiteral, NestedArgumentList))));
+      var NonPipelineArgumentList$1 = $TS($S(NestedImplicitObjectLiteral), function($skip, $loc, $0, $1) {
+        return module.insertTrimmingSpace($1, "");
+      });
+      var NonPipelineArgumentList$2 = NestedArgumentList;
+      var NonPipelineArgumentList$3 = $TS($S($Q(TrailingComment), NonPipelineArgumentPart, $Q($S(CommaDelimiter, $Q(TrailingComment), NonPipelineArgumentPart))), function($skip, $loc, $0, $1, $2, $3) {
+        return [...$1, $2, ...$3];
+      });
+      function NonPipelineArgumentList(state) {
+        let eventData;
+        if (state.events) {
+          const result = state.events.enter?.("NonPipelineArgumentList", state);
+          if (result) {
+            if (result.cache)
+              return result.cache;
+            eventData = result.data;
+          }
+        }
+        if (state.tokenize) {
+          const result = $TOKEN("NonPipelineArgumentList", state, NonPipelineArgumentList$0(state) || NonPipelineArgumentList$1(state) || NonPipelineArgumentList$2(state) || NonPipelineArgumentList$3(state));
+          if (state.events)
+            state.events.exit?.("NonPipelineArgumentList", state, result, eventData);
+          return result;
+        } else {
+          const result = NonPipelineArgumentList$0(state) || NonPipelineArgumentList$1(state) || NonPipelineArgumentList$2(state) || NonPipelineArgumentList$3(state);
+          if (state.events)
+            state.events.exit?.("NonPipelineArgumentList", state, result, eventData);
+          return result;
+        }
+      }
       var NestedArgumentList$0 = $TS($S(PushIndent, $Q(NestedArgument), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
         var args = $2;
         if (args.length)
@@ -1783,13 +1816,11 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var InlineArgumentExpressions$0 = $TS($S($Q(TrailingComment), ArgumentPart, $Q($S(CommaDelimiter, $Q(TrailingComment), ArgumentPart))), function($skip, $loc, $0, $1, $2, $3) {
-        return [...$1, $2, ...$3];
-      });
-      function InlineArgumentExpressions(state) {
+      var SingleLineArgumentExpressions$0 = $S($Q(TrailingComment), ArgumentPart, $Q($S($Q(TrailingComment), Comma, $Q(TrailingComment), ArgumentPart)));
+      function SingleLineArgumentExpressions(state) {
         let eventData;
         if (state.events) {
-          const result = state.events.enter?.("InlineArgumentExpressions", state);
+          const result = state.events.enter?.("SingleLineArgumentExpressions", state);
           if (result) {
             if (result.cache)
               return result.cache;
@@ -1797,22 +1828,28 @@ ${input.slice(result.pos)}
           }
         }
         if (state.tokenize) {
-          const result = $TOKEN("InlineArgumentExpressions", state, InlineArgumentExpressions$0(state));
+          const result = $TOKEN("SingleLineArgumentExpressions", state, SingleLineArgumentExpressions$0(state));
           if (state.events)
-            state.events.exit?.("InlineArgumentExpressions", state, result, eventData);
+            state.events.exit?.("SingleLineArgumentExpressions", state, result, eventData);
           return result;
         } else {
-          const result = InlineArgumentExpressions$0(state);
+          const result = SingleLineArgumentExpressions$0(state);
           if (state.events)
-            state.events.exit?.("InlineArgumentExpressions", state, result, eventData);
+            state.events.exit?.("SingleLineArgumentExpressions", state, result, eventData);
           return result;
         }
       }
-      var SingleLineArgumentExpressions$0 = $S($Q(TrailingComment), ArgumentPart, $Q($S($Q(TrailingComment), Comma, $Q(TrailingComment), ArgumentPart)));
-      function SingleLineArgumentExpressions(state) {
+      var ArgumentPart$0 = $S(DotDotDot, ExtendedExpression);
+      var ArgumentPart$1 = $TS($S(ExtendedExpression, $E(DotDotDot)), function($skip, $loc, $0, $1, $2) {
+        if ($2) {
+          return [$2, $1];
+        }
+        return $1;
+      });
+      function ArgumentPart(state) {
         let eventData;
         if (state.events) {
-          const result = state.events.enter?.("SingleLineArgumentExpressions", state);
+          const result = state.events.enter?.("ArgumentPart", state);
           if (result) {
             if (result.cache)
               return result.cache;
@@ -1820,28 +1857,28 @@ ${input.slice(result.pos)}
           }
         }
         if (state.tokenize) {
-          const result = $TOKEN("SingleLineArgumentExpressions", state, SingleLineArgumentExpressions$0(state));
+          const result = $TOKEN("ArgumentPart", state, ArgumentPart$0(state) || ArgumentPart$1(state));
           if (state.events)
-            state.events.exit?.("SingleLineArgumentExpressions", state, result, eventData);
+            state.events.exit?.("ArgumentPart", state, result, eventData);
           return result;
         } else {
-          const result = SingleLineArgumentExpressions$0(state);
+          const result = ArgumentPart$0(state) || ArgumentPart$1(state);
           if (state.events)
-            state.events.exit?.("SingleLineArgumentExpressions", state, result, eventData);
+            state.events.exit?.("ArgumentPart", state, result, eventData);
           return result;
         }
       }
-      var ArgumentPart$0 = $S(DotDotDot, ExtendedExpression);
-      var ArgumentPart$1 = $TS($S(ExtendedExpression, $E(DotDotDot)), function($skip, $loc, $0, $1, $2) {
+      var NonPipelineArgumentPart$0 = $S(DotDotDot, NonPipelineExtendedExpression);
+      var NonPipelineArgumentPart$1 = $TS($S(NonPipelineExtendedExpression, $E(DotDotDot)), function($skip, $loc, $0, $1, $2) {
         if ($2) {
           return [$2, $1];
         }
         return $1;
       });
-      function ArgumentPart(state) {
+      function NonPipelineArgumentPart(state) {
         let eventData;
         if (state.events) {
-          const result = state.events.enter?.("ArgumentPart", state);
+          const result = state.events.enter?.("NonPipelineArgumentPart", state);
           if (result) {
             if (result.cache)
               return result.cache;
@@ -1849,14 +1886,14 @@ ${input.slice(result.pos)}
           }
         }
         if (state.tokenize) {
-          const result = $TOKEN("ArgumentPart", state, ArgumentPart$0(state) || ArgumentPart$1(state));
+          const result = $TOKEN("NonPipelineArgumentPart", state, NonPipelineArgumentPart$0(state) || NonPipelineArgumentPart$1(state));
           if (state.events)
-            state.events.exit?.("ArgumentPart", state, result, eventData);
+            state.events.exit?.("NonPipelineArgumentPart", state, result, eventData);
           return result;
         } else {
-          const result = ArgumentPart$0(state) || ArgumentPart$1(state);
+          const result = NonPipelineArgumentPart$0(state) || NonPipelineArgumentPart$1(state);
           if (state.events)
-            state.events.exit?.("ArgumentPart", state, result, eventData);
+            state.events.exit?.("NonPipelineArgumentPart", state, result, eventData);
           return result;
         }
       }
@@ -6286,17 +6323,8 @@ ${input.slice(result.pos)}
         const inclusive = range.token === "..";
         range.token = ",";
         if (s.type === "Literal" && e.type === "Literal") {
-          let start, end;
-          if (s.raw[0] === "'") {
-            start = s.raw.match(/^'(.*)'$/)[1];
-          } else {
-            start = JSON.parse(s.raw);
-          }
-          if (e.raw[0] === "'") {
-            end = e.raw.match(/^'(.*)'$/)[1];
-          } else {
-            end = JSON.parse(e.raw);
-          }
+          const start = module.literalValue(s);
+          const end = module.literalValue(e);
           if (typeof start !== typeof end) {
             throw new Error("Range start and end must be of the same type");
           }
@@ -6964,6 +6992,7 @@ ${input.slice(result.pos)}
         return $0.map(([prop, delim]) => {
           return {
             ...prop,
+            delim,
             children: [...prop.children, delim]
           };
         });
@@ -7042,7 +7071,8 @@ ${input.slice(result.pos)}
           type: "SpreadProperty",
           children: [ws, dots, exp],
           names: exp.names,
-          value: [dots, exp]
+          dots,
+          value: exp
         };
       });
       var PropertyDefinition$5 = $TS($S(__, CallExpression), function($skip, $loc, $0, $1, $2) {
@@ -15161,7 +15191,7 @@ ${input.slice(result.pos)}
               }
               break;
             case "SpreadProperty":
-              parts.push(["{", part.value, "}"]);
+              parts.push(["{", part.dots, part.value, "}"]);
               break;
             case "MethodDefinition":
               try {
@@ -18465,53 +18495,54 @@ ${input.slice(result.pos)}
           children: [" as const"]
         };
         module.prelude = [];
+        const preludeVar = "var ";
         const declareRef = {
           indexOf(indexOfRef) {
             const typeSuffix = {
               ts: true,
               children: [": <T>(this: T[], searchElement: T) => boolean"]
             };
-            module.prelude.push(["", ["const ", indexOfRef, typeSuffix, " = [].indexOf", module.asAny, ";\n"]]);
+            module.prelude.push(["", [preludeVar, indexOfRef, typeSuffix, " = [].indexOf", module.asAny, ";\n"]]);
           },
           hasProp(hasPropRef) {
             const typeSuffix = {
               ts: true,
               children: [": <T>(this: T, prop: keyof T) => boolean"]
             };
-            module.prelude.push(["", ["const ", hasPropRef, typeSuffix, " = {}.hasOwnProperty", module.asAny, ";\n"]]);
+            module.prelude.push(["", [preludeVar, hasPropRef, typeSuffix, " = {}.hasOwnProperty", module.asAny, ";\n"]]);
           },
           is(isRef) {
             const typeSuffix = {
               ts: true,
               children: [": { <B, A extends B> (a: A, b: B): b is A, <A, B> (a: A, b: B): a is A & B }"]
             };
-            module.prelude.push(["", ["const ", isRef, typeSuffix, " = Object.is", module.asAny, ";\n"]]);
+            module.prelude.push(["", [preludeVar, isRef, typeSuffix, " = Object.is", module.asAny, ";\n"]]);
           },
           modulo(moduloRef) {
             const typeSuffix = {
               ts: true,
               children: [": (a: number, b: number) => number"]
             };
-            module.prelude.push(["", ["const ", moduloRef, typeSuffix, " = (a, b) => (a % b + b) % b;", "\n"]]);
+            module.prelude.push(["", [preludeVar, moduloRef, typeSuffix, " = (a, b) => (a % b + b) % b;", "\n"]]);
           },
           xor(xorRef) {
             const typeSuffix = {
               ts: true,
               children: [": (a: unknown, b: unknown) => boolean"]
             };
-            module.prelude.push(["", ["const ", xorRef, typeSuffix, " = (a, b) => a && b ? false : a || b;", "\n"]]);
+            module.prelude.push(["", [preludeVar, xorRef, typeSuffix, " = (a, b) => a ? !b && a : b;", "\n"]]);
           },
           xnor(xnorRef) {
             const typeSuffix = {
               ts: true,
               children: [": (a: unknown, b: unknown) => boolean"]
             };
-            module.prelude.push(["", ["const ", xnorRef, typeSuffix, " = (a, b) => a || b ? a && b : true;", "\n"]]);
+            module.prelude.push(["", [preludeVar, xnorRef, typeSuffix, " = (a, b) => a ? b : !b || a;", "\n"]]);
           },
           returnSymbol(ref) {
             module.prelude.push({
               children: [
-                "const ",
+                preludeVar,
                 ref,
                 ` = Symbol("return")';
 `
@@ -18705,35 +18736,43 @@ ${input.slice(result.pos)}
               const prefix = children.slice(0, i).concat(glob.children[0]);
               const parts = [];
               for (const part of glob.object.content) {
-                if (part.type === "SpreadProperty") {
-                  throw new Error("Glob pattern cannot have ...spread property");
-                }
                 if (part.type === "MethodDefinition") {
                   throw new Error("Glob pattern cannot have method definition");
                 }
                 if (part.value && !["CallExpression", "MemberExpression", "Identifier"].includes(part.value.type)) {
                   throw new Error("Glob pattern must have call or member expression value");
                 }
-                const { name } = part;
                 let value = part.value ?? part.name;
                 const wValue = module.getTrimmingSpace(part.value);
                 value = prefix.concat(module.insertTrimmingSpace(value, ""));
                 if (wValue)
                   value.unshift(wValue);
-                parts.push({
-                  type: "Property",
-                  name,
-                  value,
-                  names: part.names,
-                  children: [
-                    module.isWhitespaceOrEmpty(part.children[0]) && part.children[0],
-                    name,
-                    module.isWhitespaceOrEmpty(part.children[2]) && part.children[2],
-                    part.children[3]?.token === ":" ? part.children[3] : ":",
+                if (part.type === "SpreadProperty") {
+                  parts.push({
+                    type: part.type,
                     value,
-                    part.children[part.children.length - 1]
-                  ]
-                });
+                    dots: part.dots,
+                    delim: part.delim,
+                    names: part.names,
+                    children: part.children.slice(0, 2).concat(value, part.delim)
+                  });
+                } else {
+                  parts.push({
+                    type: part.type,
+                    name: part.name,
+                    value,
+                    delim: part.delim,
+                    names: part.names,
+                    children: [
+                      module.isWhitespaceOrEmpty(part.children[0]) && part.children[0],
+                      part.name,
+                      module.isWhitespaceOrEmpty(part.children[2]) && part.children[2],
+                      part.children[3]?.token === ":" ? part.children[3] : ":",
+                      value,
+                      part.delim
+                    ]
+                  });
+                }
               }
               const object = {
                 type: "ObjectExpression",
@@ -18802,6 +18841,43 @@ ${input.slice(result.pos)}
             return { children };
           }
         };
+        module.literalValue = function(literal) {
+          let { raw } = literal;
+          switch (raw) {
+            case "null":
+              return null;
+            case "true":
+              return true;
+            case "false":
+              return false;
+          }
+          if (raw.startsWith('"') && raw.endsWith('"') || raw.startsWith("'") && raw.endsWith("'")) {
+            return raw.slice(1, -1);
+          }
+          const numeric = literal.children.find(
+            (child) => child.type === "NumericLiteral"
+          );
+          if (numeric) {
+            raw = raw.replace(/_/g, "");
+            const { token } = numeric;
+            if (token.endsWith("n")) {
+              return BigInt(raw.slice(0, -1));
+            } else if (token.match(/[\.eE]/)) {
+              return parseFloat(raw);
+            } else if (token.startsWith("0")) {
+              switch (token.charAt(1).toLowerCase()) {
+                case "x":
+                  return parseInt(raw.replace(/0[xX]/, ""), 16);
+                case "b":
+                  return parseInt(raw.replace(/0[bB]/, ""), 2);
+                case "o":
+                  return parseInt(raw.replace(/0[oO]/, ""), 8);
+              }
+            }
+            return parseInt(raw, 10);
+          }
+          throw new Error("Unrecognized literal " + JSON.stringify(literal));
+        };
         module.expressionizeIfClause = function(clause, b, e) {
           const children = clause.children.slice(1);
           children.push("?", b);

package/dist/main.js

@@ -443,11 +443,12 @@ ${input.slice(result.pos)}
       NonSuppressedTrailingMemberExpressions,
       CommaDelimiter,
       ArgumentList,
+      NonPipelineArgumentList,
       NestedArgumentList,
       NestedArgument,
-      InlineArgumentExpressions,
       SingleLineArgumentExpressions,
       ArgumentPart,
+      NonPipelineArgumentPart,
       BinaryOpExpression,
       BinaryOpRHS,
       RHS,
@@ -1490,7 +1491,7 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var ImplicitArguments$0 = $TS($S($E($S(TypeArguments, $N(ImplementsToken))), ApplicationStart, InsertOpenParen, $Q(_), ArgumentList, InsertCloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
+    var ImplicitArguments$0 = $TS($S($E($S(TypeArguments, $N(ImplementsToken))), ApplicationStart, InsertOpenParen, $Q(_), NonPipelineArgumentList, InsertCloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
       var ta = $1;
       var open = $3;
       var ws = $4;
@@ -1708,7 +1709,9 @@ ${input.slice(result.pos)}
       return module2.insertTrimmingSpace($1, "");
     });
     var ArgumentList$2 = NestedArgumentList;
-    var ArgumentList$3 = InlineArgumentExpressions;
+    var ArgumentList$3 = $TS($S($Q(TrailingComment), ArgumentPart, $Q($S(CommaDelimiter, $Q(TrailingComment), ArgumentPart))), function($skip, $loc, $0, $1, $2, $3) {
+      return [...$1, $2, ...$3];
+    });
     function ArgumentList(state) {
       let eventData;
       if (state.events) {
@@ -1731,6 +1734,36 @@ ${input.slice(result.pos)}
         return result;
       }
     }
+    var NonPipelineArgumentList$0 = $S(NonPipelineArgumentPart, $P($S(CommaDelimiter, $C(NestedImplicitObjectLiteral, NestedArgumentList))));
+    var NonPipelineArgumentList$1 = $TS($S(NestedImplicitObjectLiteral), function($skip, $loc, $0, $1) {
+      return module2.insertTrimmingSpace($1, "");
+    });
+    var NonPipelineArgumentList$2 = NestedArgumentList;
+    var NonPipelineArgumentList$3 = $TS($S($Q(TrailingComment), NonPipelineArgumentPart, $Q($S(CommaDelimiter, $Q(TrailingComment), NonPipelineArgumentPart))), function($skip, $loc, $0, $1, $2, $3) {
+      return [...$1, $2, ...$3];
+    });
+    function NonPipelineArgumentList(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("NonPipelineArgumentList", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("NonPipelineArgumentList", state, NonPipelineArgumentList$0(state) || NonPipelineArgumentList$1(state) || NonPipelineArgumentList$2(state) || NonPipelineArgumentList$3(state));
+        if (state.events)
+          state.events.exit?.("NonPipelineArgumentList", state, result, eventData);
+        return result;
+      } else {
+        const result = NonPipelineArgumentList$0(state) || NonPipelineArgumentList$1(state) || NonPipelineArgumentList$2(state) || NonPipelineArgumentList$3(state);
+        if (state.events)
+          state.events.exit?.("NonPipelineArgumentList", state, result, eventData);
+        return result;
+      }
+    }
     var NestedArgumentList$0 = $TS($S(PushIndent, $Q(NestedArgument), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
       var args = $2;
       if (args.length)
@@ -1782,13 +1815,11 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var InlineArgumentExpressions$0 = $TS($S($Q(TrailingComment), ArgumentPart, $Q($S(CommaDelimiter, $Q(TrailingComment), ArgumentPart))), function($skip, $loc, $0, $1, $2, $3) {
-      return [...$1, $2, ...$3];
-    });
-    function InlineArgumentExpressions(state) {
+    var SingleLineArgumentExpressions$0 = $S($Q(TrailingComment), ArgumentPart, $Q($S($Q(TrailingComment), Comma, $Q(TrailingComment), ArgumentPart)));
+    function SingleLineArgumentExpressions(state) {
       let eventData;
       if (state.events) {
-        const result = state.events.enter?.("InlineArgumentExpressions", state);
+        const result = state.events.enter?.("SingleLineArgumentExpressions", state);
         if (result) {
           if (result.cache)
             return result.cache;
@@ -1796,22 +1827,28 @@ ${input.slice(result.pos)}
         }
       }
       if (state.tokenize) {
-        const result = $TOKEN("InlineArgumentExpressions", state, InlineArgumentExpressions$0(state));
+        const result = $TOKEN("SingleLineArgumentExpressions", state, SingleLineArgumentExpressions$0(state));
         if (state.events)
-          state.events.exit?.("InlineArgumentExpressions", state, result, eventData);
+          state.events.exit?.("SingleLineArgumentExpressions", state, result, eventData);
         return result;
       } else {
-        const result = InlineArgumentExpressions$0(state);
+        const result = SingleLineArgumentExpressions$0(state);
         if (state.events)
-          state.events.exit?.("InlineArgumentExpressions", state, result, eventData);
+          state.events.exit?.("SingleLineArgumentExpressions", state, result, eventData);
         return result;
       }
     }
-    var SingleLineArgumentExpressions$0 = $S($Q(TrailingComment), ArgumentPart, $Q($S($Q(TrailingComment), Comma, $Q(TrailingComment), ArgumentPart)));
-    function SingleLineArgumentExpressions(state) {
+    var ArgumentPart$0 = $S(DotDotDot, ExtendedExpression);
+    var ArgumentPart$1 = $TS($S(ExtendedExpression, $E(DotDotDot)), function($skip, $loc, $0, $1, $2) {
+      if ($2) {
+        return [$2, $1];
+      }
+      return $1;
+    });
+    function ArgumentPart(state) {
       let eventData;
       if (state.events) {
-        const result = state.events.enter?.("SingleLineArgumentExpressions", state);
+        const result = state.events.enter?.("ArgumentPart", state);
         if (result) {
           if (result.cache)
             return result.cache;
@@ -1819,28 +1856,28 @@ ${input.slice(result.pos)}
         }
       }
       if (state.tokenize) {
-        const result = $TOKEN("SingleLineArgumentExpressions", state, SingleLineArgumentExpressions$0(state));
+        const result = $TOKEN("ArgumentPart", state, ArgumentPart$0(state) || ArgumentPart$1(state));
         if (state.events)
-          state.events.exit?.("SingleLineArgumentExpressions", state, result, eventData);
+          state.events.exit?.("ArgumentPart", state, result, eventData);
         return result;
       } else {
-        const result = SingleLineArgumentExpressions$0(state);
+        const result = ArgumentPart$0(state) || ArgumentPart$1(state);
         if (state.events)
-          state.events.exit?.("SingleLineArgumentExpressions", state, result, eventData);
+          state.events.exit?.("ArgumentPart", state, result, eventData);
         return result;
       }
     }
-    var ArgumentPart$0 = $S(DotDotDot, ExtendedExpression);
-    var ArgumentPart$1 = $TS($S(ExtendedExpression, $E(DotDotDot)), function($skip, $loc, $0, $1, $2) {
+    var NonPipelineArgumentPart$0 = $S(DotDotDot, NonPipelineExtendedExpression);
+    var NonPipelineArgumentPart$1 = $TS($S(NonPipelineExtendedExpression, $E(DotDotDot)), function($skip, $loc, $0, $1, $2) {
       if ($2) {
         return [$2, $1];
       }
       return $1;
     });
-    function ArgumentPart(state) {
+    function NonPipelineArgumentPart(state) {
       let eventData;
       if (state.events) {
-        const result = state.events.enter?.("ArgumentPart", state);
+        const result = state.events.enter?.("NonPipelineArgumentPart", state);
         if (result) {
           if (result.cache)
             return result.cache;
@@ -1848,14 +1885,14 @@ ${input.slice(result.pos)}
         }
       }
       if (state.tokenize) {
-        const result = $TOKEN("ArgumentPart", state, ArgumentPart$0(state) || ArgumentPart$1(state));
+        const result = $TOKEN("NonPipelineArgumentPart", state, NonPipelineArgumentPart$0(state) || NonPipelineArgumentPart$1(state));
         if (state.events)
-          state.events.exit?.("ArgumentPart", state, result, eventData);
+          state.events.exit?.("NonPipelineArgumentPart", state, result, eventData);
         return result;
       } else {
-        const result = ArgumentPart$0(state) || ArgumentPart$1(state);
+        const result = NonPipelineArgumentPart$0(state) || NonPipelineArgumentPart$1(state);
         if (state.events)
-          state.events.exit?.("ArgumentPart", state, result, eventData);
+          state.events.exit?.("NonPipelineArgumentPart", state, result, eventData);
         return result;
       }
     }
@@ -6285,17 +6322,8 @@ ${input.slice(result.pos)}
       const inclusive = range.token === "..";
       range.token = ",";
       if (s.type === "Literal" && e.type === "Literal") {
-        let start, end;
-        if (s.raw[0] === "'") {
-          start = s.raw.match(/^'(.*)'$/)[1];
-        } else {
-          start = JSON.parse(s.raw);
-        }
-        if (e.raw[0] === "'") {
-          end = e.raw.match(/^'(.*)'$/)[1];
-        } else {
-          end = JSON.parse(e.raw);
-        }
+        const start = module2.literalValue(s);
+        const end = module2.literalValue(e);
         if (typeof start !== typeof end) {
           throw new Error("Range start and end must be of the same type");
         }
@@ -6963,6 +6991,7 @@ ${input.slice(result.pos)}
       return $0.map(([prop, delim]) => {
         return {
           ...prop,
+          delim,
           children: [...prop.children, delim]
         };
       });
@@ -7041,7 +7070,8 @@ ${input.slice(result.pos)}
         type: "SpreadProperty",
         children: [ws, dots, exp],
         names: exp.names,
-        value: [dots, exp]
+        dots,
+        value: exp
       };
     });
     var PropertyDefinition$5 = $TS($S(__, CallExpression), function($skip, $loc, $0, $1, $2) {
@@ -15160,7 +15190,7 @@ ${input.slice(result.pos)}
             }
             break;
           case "SpreadProperty":
-            parts.push(["{", part.value, "}"]);
+            parts.push(["{", part.dots, part.value, "}"]);
             break;
           case "MethodDefinition":
             try {
@@ -18464,53 +18494,54 @@ ${input.slice(result.pos)}
         children: [" as const"]
       };
       module2.prelude = [];
+      const preludeVar = "var ";
       const declareRef = {
         indexOf(indexOfRef) {
           const typeSuffix = {
             ts: true,
             children: [": <T>(this: T[], searchElement: T) => boolean"]
           };
-          module2.prelude.push(["", ["const ", indexOfRef, typeSuffix, " = [].indexOf", module2.asAny, ";\n"]]);
+          module2.prelude.push(["", [preludeVar, indexOfRef, typeSuffix, " = [].indexOf", module2.asAny, ";\n"]]);
         },
         hasProp(hasPropRef) {
           const typeSuffix = {
             ts: true,
             children: [": <T>(this: T, prop: keyof T) => boolean"]
           };
-          module2.prelude.push(["", ["const ", hasPropRef, typeSuffix, " = {}.hasOwnProperty", module2.asAny, ";\n"]]);
+          module2.prelude.push(["", [preludeVar, hasPropRef, typeSuffix, " = {}.hasOwnProperty", module2.asAny, ";\n"]]);
         },
         is(isRef) {
           const typeSuffix = {
             ts: true,
             children: [": { <B, A extends B> (a: A, b: B): b is A, <A, B> (a: A, b: B): a is A & B }"]
           };
-          module2.prelude.push(["", ["const ", isRef, typeSuffix, " = Object.is", module2.asAny, ";\n"]]);
+          module2.prelude.push(["", [preludeVar, isRef, typeSuffix, " = Object.is", module2.asAny, ";\n"]]);
         },
         modulo(moduloRef) {
           const typeSuffix = {
             ts: true,
             children: [": (a: number, b: number) => number"]
           };
-          module2.prelude.push(["", ["const ", moduloRef, typeSuffix, " = (a, b) => (a % b + b) % b;", "\n"]]);
+          module2.prelude.push(["", [preludeVar, moduloRef, typeSuffix, " = (a, b) => (a % b + b) % b;", "\n"]]);
         },
         xor(xorRef) {
           const typeSuffix = {
             ts: true,
             children: [": (a: unknown, b: unknown) => boolean"]
           };
-          module2.prelude.push(["", ["const ", xorRef, typeSuffix, " = (a, b) => a && b ? false : a || b;", "\n"]]);
+          module2.prelude.push(["", [preludeVar, xorRef, typeSuffix, " = (a, b) => a ? !b && a : b;", "\n"]]);
         },
         xnor(xnorRef) {
           const typeSuffix = {
             ts: true,
             children: [": (a: unknown, b: unknown) => boolean"]
           };
-          module2.prelude.push(["", ["const ", xnorRef, typeSuffix, " = (a, b) => a || b ? a && b : true;", "\n"]]);
+          module2.prelude.push(["", [preludeVar, xnorRef, typeSuffix, " = (a, b) => a ? b : !b || a;", "\n"]]);
         },
         returnSymbol(ref) {
           module2.prelude.push({
             children: [
-              "const ",
+              preludeVar,
               ref,
               ` = Symbol("return")';
 `
@@ -18704,35 +18735,43 @@ ${input.slice(result.pos)}
             const prefix = children.slice(0, i).concat(glob.children[0]);
             const parts = [];
             for (const part of glob.object.content) {
-              if (part.type === "SpreadProperty") {
-                throw new Error("Glob pattern cannot have ...spread property");
-              }
               if (part.type === "MethodDefinition") {
                 throw new Error("Glob pattern cannot have method definition");
               }
               if (part.value && !["CallExpression", "MemberExpression", "Identifier"].includes(part.value.type)) {
                 throw new Error("Glob pattern must have call or member expression value");
               }
-              const { name } = part;
               let value = part.value ?? part.name;
               const wValue = module2.getTrimmingSpace(part.value);
               value = prefix.concat(module2.insertTrimmingSpace(value, ""));
               if (wValue)
                 value.unshift(wValue);
-              parts.push({
-                type: "Property",
-                name,
-                value,
-                names: part.names,
-                children: [
-                  module2.isWhitespaceOrEmpty(part.children[0]) && part.children[0],
-                  name,
-                  module2.isWhitespaceOrEmpty(part.children[2]) && part.children[2],
-                  part.children[3]?.token === ":" ? part.children[3] : ":",
+              if (part.type === "SpreadProperty") {
+                parts.push({
+                  type: part.type,
                   value,
-                  part.children[part.children.length - 1]
-                ]
-              });
+                  dots: part.dots,
+                  delim: part.delim,
+                  names: part.names,
+                  children: part.children.slice(0, 2).concat(value, part.delim)
+                });
+              } else {
+                parts.push({
+                  type: part.type,
+                  name: part.name,
+                  value,
+                  delim: part.delim,
+                  names: part.names,
+                  children: [
+                    module2.isWhitespaceOrEmpty(part.children[0]) && part.children[0],
+                    part.name,
+                    module2.isWhitespaceOrEmpty(part.children[2]) && part.children[2],
+                    part.children[3]?.token === ":" ? part.children[3] : ":",
+                    value,
+                    part.delim
+                  ]
+                });
+              }
             }
             const object = {
               type: "ObjectExpression",
@@ -18801,6 +18840,43 @@ ${input.slice(result.pos)}
           return { children };
         }
       };
+      module2.literalValue = function(literal) {
+        let { raw } = literal;
+        switch (raw) {
+          case "null":
+            return null;
+          case "true":
+            return true;
+          case "false":
+            return false;
+        }
+        if (raw.startsWith('"') && raw.endsWith('"') || raw.startsWith("'") && raw.endsWith("'")) {
+          return raw.slice(1, -1);
+        }
+        const numeric = literal.children.find(
+          (child) => child.type === "NumericLiteral"
+        );
+        if (numeric) {
+          raw = raw.replace(/_/g, "");
+          const { token } = numeric;
+          if (token.endsWith("n")) {
+            return BigInt(raw.slice(0, -1));
+          } else if (token.match(/[\.eE]/)) {
+            return parseFloat(raw);
+          } else if (token.startsWith("0")) {
+            switch (token.charAt(1).toLowerCase()) {
+              case "x":
+                return parseInt(raw.replace(/0[xX]/, ""), 16);
+              case "b":
+                return parseInt(raw.replace(/0[bB]/, ""), 2);
+              case "o":
+                return parseInt(raw.replace(/0[oO]/, ""), 8);
+            }
+          }
+          return parseInt(raw, 10);
+        }
+        throw new Error("Unrecognized literal " + JSON.stringify(literal));
+      };
       module2.expressionizeIfClause = function(clause, b, e) {
         const children = clause.children.slice(1);
         children.push("?", b);

package/dist/main.mjs

@@ -441,11 +441,12 @@ ${input.slice(result.pos)}
       NonSuppressedTrailingMemberExpressions,
       CommaDelimiter,
       ArgumentList,
+      NonPipelineArgumentList,
       NestedArgumentList,
       NestedArgument,
-      InlineArgumentExpressions,
       SingleLineArgumentExpressions,
       ArgumentPart,
+      NonPipelineArgumentPart,
       BinaryOpExpression,
       BinaryOpRHS,
       RHS,
@@ -1488,7 +1489,7 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var ImplicitArguments$0 = $TS($S($E($S(TypeArguments, $N(ImplementsToken))), ApplicationStart, InsertOpenParen, $Q(_), ArgumentList, InsertCloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
+    var ImplicitArguments$0 = $TS($S($E($S(TypeArguments, $N(ImplementsToken))), ApplicationStart, InsertOpenParen, $Q(_), NonPipelineArgumentList, InsertCloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
       var ta = $1;
       var open = $3;
       var ws = $4;
@@ -1706,7 +1707,9 @@ ${input.slice(result.pos)}
       return module.insertTrimmingSpace($1, "");
     });
     var ArgumentList$2 = NestedArgumentList;
-    var ArgumentList$3 = InlineArgumentExpressions;
+    var ArgumentList$3 = $TS($S($Q(TrailingComment), ArgumentPart, $Q($S(CommaDelimiter, $Q(TrailingComment), ArgumentPart))), function($skip, $loc, $0, $1, $2, $3) {
+      return [...$1, $2, ...$3];
+    });
     function ArgumentList(state) {
       let eventData;
       if (state.events) {
@@ -1729,6 +1732,36 @@ ${input.slice(result.pos)}
         return result;
       }
     }
+    var NonPipelineArgumentList$0 = $S(NonPipelineArgumentPart, $P($S(CommaDelimiter, $C(NestedImplicitObjectLiteral, NestedArgumentList))));
+    var NonPipelineArgumentList$1 = $TS($S(NestedImplicitObjectLiteral), function($skip, $loc, $0, $1) {
+      return module.insertTrimmingSpace($1, "");
+    });
+    var NonPipelineArgumentList$2 = NestedArgumentList;
+    var NonPipelineArgumentList$3 = $TS($S($Q(TrailingComment), NonPipelineArgumentPart, $Q($S(CommaDelimiter, $Q(TrailingComment), NonPipelineArgumentPart))), function($skip, $loc, $0, $1, $2, $3) {
+      return [...$1, $2, ...$3];
+    });
+    function NonPipelineArgumentList(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("NonPipelineArgumentList", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("NonPipelineArgumentList", state, NonPipelineArgumentList$0(state) || NonPipelineArgumentList$1(state) || NonPipelineArgumentList$2(state) || NonPipelineArgumentList$3(state));
+        if (state.events)
+          state.events.exit?.("NonPipelineArgumentList", state, result, eventData);
+        return result;
+      } else {
+        const result = NonPipelineArgumentList$0(state) || NonPipelineArgumentList$1(state) || NonPipelineArgumentList$2(state) || NonPipelineArgumentList$3(state);
+        if (state.events)
+          state.events.exit?.("NonPipelineArgumentList", state, result, eventData);
+        return result;
+      }
+    }
     var NestedArgumentList$0 = $TS($S(PushIndent, $Q(NestedArgument), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
       var args = $2;
       if (args.length)
@@ -1780,13 +1813,11 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var InlineArgumentExpressions$0 = $TS($S($Q(TrailingComment), ArgumentPart, $Q($S(CommaDelimiter, $Q(TrailingComment), ArgumentPart))), function($skip, $loc, $0, $1, $2, $3) {
-      return [...$1, $2, ...$3];
-    });
-    function InlineArgumentExpressions(state) {
+    var SingleLineArgumentExpressions$0 = $S($Q(TrailingComment), ArgumentPart, $Q($S($Q(TrailingComment), Comma, $Q(TrailingComment), ArgumentPart)));
+    function SingleLineArgumentExpressions(state) {
       let eventData;
       if (state.events) {
-        const result = state.events.enter?.("InlineArgumentExpressions", state);
+        const result = state.events.enter?.("SingleLineArgumentExpressions", state);
         if (result) {
           if (result.cache)
             return result.cache;
@@ -1794,22 +1825,28 @@ ${input.slice(result.pos)}
         }
       }
       if (state.tokenize) {
-        const result = $TOKEN("InlineArgumentExpressions", state, InlineArgumentExpressions$0(state));
+        const result = $TOKEN("SingleLineArgumentExpressions", state, SingleLineArgumentExpressions$0(state));
         if (state.events)
-          state.events.exit?.("InlineArgumentExpressions", state, result, eventData);
+          state.events.exit?.("SingleLineArgumentExpressions", state, result, eventData);
         return result;
       } else {
-        const result = InlineArgumentExpressions$0(state);
+        const result = SingleLineArgumentExpressions$0(state);
         if (state.events)
-          state.events.exit?.("InlineArgumentExpressions", state, result, eventData);
+          state.events.exit?.("SingleLineArgumentExpressions", state, result, eventData);
         return result;
       }
     }
-    var SingleLineArgumentExpressions$0 = $S($Q(TrailingComment), ArgumentPart, $Q($S($Q(TrailingComment), Comma, $Q(TrailingComment), ArgumentPart)));
-    function SingleLineArgumentExpressions(state) {
+    var ArgumentPart$0 = $S(DotDotDot, ExtendedExpression);
+    var ArgumentPart$1 = $TS($S(ExtendedExpression, $E(DotDotDot)), function($skip, $loc, $0, $1, $2) {
+      if ($2) {
+        return [$2, $1];
+      }
+      return $1;
+    });
+    function ArgumentPart(state) {
       let eventData;
       if (state.events) {
-        const result = state.events.enter?.("SingleLineArgumentExpressions", state);
+        const result = state.events.enter?.("ArgumentPart", state);
         if (result) {
           if (result.cache)
             return result.cache;
@@ -1817,28 +1854,28 @@ ${input.slice(result.pos)}
         }
       }
       if (state.tokenize) {
-        const result = $TOKEN("SingleLineArgumentExpressions", state, SingleLineArgumentExpressions$0(state));
+        const result = $TOKEN("ArgumentPart", state, ArgumentPart$0(state) || ArgumentPart$1(state));
         if (state.events)
-          state.events.exit?.("SingleLineArgumentExpressions", state, result, eventData);
+          state.events.exit?.("ArgumentPart", state, result, eventData);
         return result;
       } else {
-        const result = SingleLineArgumentExpressions$0(state);
+        const result = ArgumentPart$0(state) || ArgumentPart$1(state);
         if (state.events)
-          state.events.exit?.("SingleLineArgumentExpressions", state, result, eventData);
+          state.events.exit?.("ArgumentPart", state, result, eventData);
         return result;
       }
     }
-    var ArgumentPart$0 = $S(DotDotDot, ExtendedExpression);
-    var ArgumentPart$1 = $TS($S(ExtendedExpression, $E(DotDotDot)), function($skip, $loc, $0, $1, $2) {
+    var NonPipelineArgumentPart$0 = $S(DotDotDot, NonPipelineExtendedExpression);
+    var NonPipelineArgumentPart$1 = $TS($S(NonPipelineExtendedExpression, $E(DotDotDot)), function($skip, $loc, $0, $1, $2) {
       if ($2) {
         return [$2, $1];
       }
       return $1;
     });
-    function ArgumentPart(state) {
+    function NonPipelineArgumentPart(state) {
       let eventData;
       if (state.events) {
-        const result = state.events.enter?.("ArgumentPart", state);
+        const result = state.events.enter?.("NonPipelineArgumentPart", state);
         if (result) {
           if (result.cache)
             return result.cache;
@@ -1846,14 +1883,14 @@ ${input.slice(result.pos)}
         }
       }
       if (state.tokenize) {
-        const result = $TOKEN("ArgumentPart", state, ArgumentPart$0(state) || ArgumentPart$1(state));
+        const result = $TOKEN("NonPipelineArgumentPart", state, NonPipelineArgumentPart$0(state) || NonPipelineArgumentPart$1(state));
         if (state.events)
-          state.events.exit?.("ArgumentPart", state, result, eventData);
+          state.events.exit?.("NonPipelineArgumentPart", state, result, eventData);
         return result;
       } else {
-        const result = ArgumentPart$0(state) || ArgumentPart$1(state);
+        const result = NonPipelineArgumentPart$0(state) || NonPipelineArgumentPart$1(state);
         if (state.events)
-          state.events.exit?.("ArgumentPart", state, result, eventData);
+          state.events.exit?.("NonPipelineArgumentPart", state, result, eventData);
         return result;
       }
     }
@@ -6283,17 +6320,8 @@ ${input.slice(result.pos)}
       const inclusive = range.token === "..";
       range.token = ",";
       if (s.type === "Literal" && e.type === "Literal") {
-        let start, end;
-        if (s.raw[0] === "'") {
-          start = s.raw.match(/^'(.*)'$/)[1];
-        } else {
-          start = JSON.parse(s.raw);
-        }
-        if (e.raw[0] === "'") {
-          end = e.raw.match(/^'(.*)'$/)[1];
-        } else {
-          end = JSON.parse(e.raw);
-        }
+        const start = module.literalValue(s);
+        const end = module.literalValue(e);
         if (typeof start !== typeof end) {
           throw new Error("Range start and end must be of the same type");
         }
@@ -6961,6 +6989,7 @@ ${input.slice(result.pos)}
       return $0.map(([prop, delim]) => {
         return {
           ...prop,
+          delim,
           children: [...prop.children, delim]
         };
       });
@@ -7039,7 +7068,8 @@ ${input.slice(result.pos)}
         type: "SpreadProperty",
         children: [ws, dots, exp],
         names: exp.names,
-        value: [dots, exp]
+        dots,
+        value: exp
       };
     });
     var PropertyDefinition$5 = $TS($S(__, CallExpression), function($skip, $loc, $0, $1, $2) {
@@ -15158,7 +15188,7 @@ ${input.slice(result.pos)}
             }
             break;
           case "SpreadProperty":
-            parts.push(["{", part.value, "}"]);
+            parts.push(["{", part.dots, part.value, "}"]);
             break;
           case "MethodDefinition":
             try {
@@ -18462,53 +18492,54 @@ ${input.slice(result.pos)}
         children: [" as const"]
       };
       module.prelude = [];
+      const preludeVar = "var ";
       const declareRef = {
         indexOf(indexOfRef) {
           const typeSuffix = {
             ts: true,
             children: [": <T>(this: T[], searchElement: T) => boolean"]
           };
-          module.prelude.push(["", ["const ", indexOfRef, typeSuffix, " = [].indexOf", module.asAny, ";\n"]]);
+          module.prelude.push(["", [preludeVar, indexOfRef, typeSuffix, " = [].indexOf", module.asAny, ";\n"]]);
         },
         hasProp(hasPropRef) {
           const typeSuffix = {
             ts: true,
             children: [": <T>(this: T, prop: keyof T) => boolean"]
           };
-          module.prelude.push(["", ["const ", hasPropRef, typeSuffix, " = {}.hasOwnProperty", module.asAny, ";\n"]]);
+          module.prelude.push(["", [preludeVar, hasPropRef, typeSuffix, " = {}.hasOwnProperty", module.asAny, ";\n"]]);
         },
         is(isRef) {
           const typeSuffix = {
             ts: true,
             children: [": { <B, A extends B> (a: A, b: B): b is A, <A, B> (a: A, b: B): a is A & B }"]
           };
-          module.prelude.push(["", ["const ", isRef, typeSuffix, " = Object.is", module.asAny, ";\n"]]);
+          module.prelude.push(["", [preludeVar, isRef, typeSuffix, " = Object.is", module.asAny, ";\n"]]);
         },
         modulo(moduloRef) {
           const typeSuffix = {
             ts: true,
             children: [": (a: number, b: number) => number"]
           };
-          module.prelude.push(["", ["const ", moduloRef, typeSuffix, " = (a, b) => (a % b + b) % b;", "\n"]]);
+          module.prelude.push(["", [preludeVar, moduloRef, typeSuffix, " = (a, b) => (a % b + b) % b;", "\n"]]);
         },
         xor(xorRef) {
           const typeSuffix = {
             ts: true,
             children: [": (a: unknown, b: unknown) => boolean"]
           };
-          module.prelude.push(["", ["const ", xorRef, typeSuffix, " = (a, b) => a && b ? false : a || b;", "\n"]]);
+          module.prelude.push(["", [preludeVar, xorRef, typeSuffix, " = (a, b) => a ? !b && a : b;", "\n"]]);
         },
         xnor(xnorRef) {
           const typeSuffix = {
             ts: true,
             children: [": (a: unknown, b: unknown) => boolean"]
           };
-          module.prelude.push(["", ["const ", xnorRef, typeSuffix, " = (a, b) => a || b ? a && b : true;", "\n"]]);
+          module.prelude.push(["", [preludeVar, xnorRef, typeSuffix, " = (a, b) => a ? b : !b || a;", "\n"]]);
         },
         returnSymbol(ref) {
           module.prelude.push({
             children: [
-              "const ",
+              preludeVar,
               ref,
               ` = Symbol("return")';
 `
@@ -18702,35 +18733,43 @@ ${input.slice(result.pos)}
             const prefix = children.slice(0, i).concat(glob.children[0]);
             const parts = [];
             for (const part of glob.object.content) {
-              if (part.type === "SpreadProperty") {
-                throw new Error("Glob pattern cannot have ...spread property");
-              }
               if (part.type === "MethodDefinition") {
                 throw new Error("Glob pattern cannot have method definition");
               }
               if (part.value && !["CallExpression", "MemberExpression", "Identifier"].includes(part.value.type)) {
                 throw new Error("Glob pattern must have call or member expression value");
               }
-              const { name } = part;
               let value = part.value ?? part.name;
               const wValue = module.getTrimmingSpace(part.value);
               value = prefix.concat(module.insertTrimmingSpace(value, ""));
               if (wValue)
                 value.unshift(wValue);
-              parts.push({
-                type: "Property",
-                name,
-                value,
-                names: part.names,
-                children: [
-                  module.isWhitespaceOrEmpty(part.children[0]) && part.children[0],
-                  name,
-                  module.isWhitespaceOrEmpty(part.children[2]) && part.children[2],
-                  part.children[3]?.token === ":" ? part.children[3] : ":",
+              if (part.type === "SpreadProperty") {
+                parts.push({
+                  type: part.type,
                   value,
-                  part.children[part.children.length - 1]
-                ]
-              });
+                  dots: part.dots,
+                  delim: part.delim,
+                  names: part.names,
+                  children: part.children.slice(0, 2).concat(value, part.delim)
+                });
+              } else {
+                parts.push({
+                  type: part.type,
+                  name: part.name,
+                  value,
+                  delim: part.delim,
+                  names: part.names,
+                  children: [
+                    module.isWhitespaceOrEmpty(part.children[0]) && part.children[0],
+                    part.name,
+                    module.isWhitespaceOrEmpty(part.children[2]) && part.children[2],
+                    part.children[3]?.token === ":" ? part.children[3] : ":",
+                    value,
+                    part.delim
+                  ]
+                });
+              }
             }
             const object = {
               type: "ObjectExpression",
@@ -18799,6 +18838,43 @@ ${input.slice(result.pos)}
           return { children };
         }
       };
+      module.literalValue = function(literal) {
+        let { raw } = literal;
+        switch (raw) {
+          case "null":
+            return null;
+          case "true":
+            return true;
+          case "false":
+            return false;
+        }
+        if (raw.startsWith('"') && raw.endsWith('"') || raw.startsWith("'") && raw.endsWith("'")) {
+          return raw.slice(1, -1);
+        }
+        const numeric = literal.children.find(
+          (child) => child.type === "NumericLiteral"
+        );
+        if (numeric) {
+          raw = raw.replace(/_/g, "");
+          const { token } = numeric;
+          if (token.endsWith("n")) {
+            return BigInt(raw.slice(0, -1));
+          } else if (token.match(/[\.eE]/)) {
+            return parseFloat(raw);
+          } else if (token.startsWith("0")) {
+            switch (token.charAt(1).toLowerCase()) {
+              case "x":
+                return parseInt(raw.replace(/0[xX]/, ""), 16);
+              case "b":
+                return parseInt(raw.replace(/0[bB]/, ""), 2);
+              case "o":
+                return parseInt(raw.replace(/0[oO]/, ""), 8);
+            }
+          }
+          return parseInt(raw, 10);
+        }
+        throw new Error("Unrecognized literal " + JSON.stringify(literal));
+      };
       module.expressionizeIfClause = function(clause, b, e) {
         const children = clause.children.slice(1);
         children.push("?", b);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danielx/civet",
-  "version": "0.5.66",
+  "version": "0.5.67",
   "description": "CoffeeScript style syntax for TypeScript",
   "main": "dist/main.js",
   "module": "dist/main.mjs",