@terrazzo/parser 0.4.0 → 0.6.0

package/src/parse/validate.ts

@@ -87,19 +87,26 @@ function validateMembersAs(
   { filename, src, logger }: ValidateOptions,
 ) {
   const members = getObjMembers($value);
-  for (const property in properties) {
-    const { validator, required } = properties[property]!;
-    if (!members[property]) {
+  for (const [name, value] of Object.entries(properties)) {
+    const { validator, required } = value;
+    if (!members[name]) {
       if (required) {
-        logger.error({ message: `Missing required property "${property}"`, filename, node: $value, src });
+        logger.error({
+          group: 'parser',
+          label: 'validate',
+          message: `Missing required property "${name}"`,
+          filename,
+          node: $value,
+          src,
+        });
       }
       continue;
     }
-    const value = members[property];
-    if (isMaybeAlias(value)) {
-      validateAliasSyntax(value, node, { filename, src, logger });
+    const memberValue = members[name];
+    if (isMaybeAlias(memberValue)) {
+      validateAliasSyntax(memberValue, node, { filename, src, logger });
     } else {
-      validator(value, node, { filename, src, logger });
+      validator(memberValue, node, { filename, src, logger });
     }
   }
 }
@@ -107,14 +114,28 @@ function validateMembersAs(
 /** Verify an Alias $value is formatted correctly */
 export function validateAliasSyntax($value: ValueNode, _node: AnyNode, { filename, src, logger }: ValidateOptions) {
   if ($value.type !== 'String' || !isAlias($value.value)) {
-    logger.error({ message: `Invalid alias: ${print($value)}`, filename, node: $value, src });
+    logger.error({
+      group: 'parser',
+      label: 'validate',
+      message: `Invalid alias: ${print($value)}`,
+      filename,
+      node: $value,
+      src,
+    });
   }
 }
 
 /** Verify a Border token is valid */
 export function validateBorder($value: ValueNode, node: AnyNode, { filename, src, logger }: ValidateOptions) {
   if ($value.type !== 'Object') {
-    logger.error({ message: `Expected object, received ${$value.type}`, filename, node: $value, src });
+    logger.error({
+      group: 'parser',
+      label: 'validate',
+      message: `Expected object, received ${$value.type}`,
+      filename,
+      node: $value,
+      src,
+    });
   } else {
     validateMembersAs(
       $value,
@@ -131,6 +152,7 @@ export function validateBorder($value: ValueNode, node: AnyNode, { filename, src
 
 /** Verify a Color token is valid */
 export function validateColor($value: ValueNode, node: AnyNode, { filename, src, logger }: ValidateOptions) {
+  const baseMessage = { group: 'parser' as const, label: 'validate', filename, node: $value, src };
   if ($value.type === 'String') {
     // TODO: enable when object notation is finalized
     // logger.warn({
@@ -140,7 +162,7 @@ export function validateColor($value: ValueNode, node: AnyNode, { filename, src,
     //   src,
     // });
     if ($value.value === '') {
-      logger.error({ message: 'Expected color, received empty string', filename, node: $value, src });
+      logger.error({ ...baseMessage, message: 'Expected color, received empty string' });
     }
   } else if ($value.type === 'Object') {
     validateMembersAs(
@@ -149,10 +171,18 @@ export function validateColor($value: ValueNode, node: AnyNode, { filename, src,
         colorSpace: {
           validator: (v) => {
             if (v.type !== 'String') {
-              logger.error({ message: `Expected string, received ${print(v)}`, filename, node: v, src });
+              logger.error({
+                ...baseMessage,
+                message: `Expected string, received ${print(v)}`,
+                node: v,
+              });
             }
             if (!VALID_COLORSPACES.has((v as StringNode).value)) {
-              logger.error({ message: `Unsupported colorspace ${print(v)}`, filename, node: v, src });
+              logger.error({
+                ...baseMessage,
+                message: `Unsupported colorspace ${print(v)}`,
+                node: v,
+              });
             }
           },
           required: true,
@@ -160,23 +190,25 @@ export function validateColor($value: ValueNode, node: AnyNode, { filename, src,
         channels: {
           validator: (v) => {
             if (v.type !== 'Array') {
-              logger.error({ message: `Expected array, received ${print(v)}`, filename, node: v, src });
+              logger.error({
+                ...baseMessage,
+                message: `Expected array, received ${print(v)}`,
+                node: v,
+              });
             } else {
               if (v.elements?.length !== 3) {
                 logger.error({
+                  ...baseMessage,
                   message: `Expected 3 channels, received ${v.elements?.length ?? 0}`,
-                  filename,
                   node: v,
-                  src,
                 });
               }
               for (const element of v.elements) {
                 if (element.value.type !== 'Number') {
                   logger.error({
+                    ...baseMessage,
                     message: `Expected number, received ${print(element.value)}`,
-                    filename,
                     node: element,
-                    src,
                   });
                 }
               }
@@ -196,7 +228,11 @@ export function validateColor($value: ValueNode, node: AnyNode, { filename, src,
               v.value.length === 7 + 1 ||
               !/^#[a-f0-9]{3,8}$/i.test(v.value)
             ) {
-              logger.error({ message: `Invalid hex color ${print(v)}`, filename, node: v, src });
+              logger.error({
+                ...baseMessage,
+                message: `Invalid hex color ${print(v)}`,
+                node: v,
+              });
             }
           },
         },
@@ -206,30 +242,23 @@ export function validateColor($value: ValueNode, node: AnyNode, { filename, src,
       { filename, src, logger },
     );
   } else {
-    logger.error({ message: `Expected object, received ${$value.type}`, filename, node: $value, src });
+    logger.error({
+      ...baseMessage,
+      message: `Expected object, received ${$value.type}`,
+      node: $value,
+    });
   }
 }
 
 /** Verify a Cubic Bézier token is valid */
 export function validateCubicBezier($value: ValueNode, _node: AnyNode, { filename, src, logger }: ValidateOptions) {
+  const baseMessage = { group: 'parser' as const, label: 'validate', filename, node: $value, src };
   if ($value.type !== 'Array') {
-    logger.error({ message: `Expected array of strings, received ${print($value)}`, filename, node: $value, src });
-  } else if (
-    !$value.elements.every((e) => e.value.type === 'Number' || (e.value.type === 'String' && isAlias(e.value.value)))
-  ) {
-    logger.error({
-      message: 'Expected an array of 4 numbers, received some non-numbers',
-      filename,
-      node: $value,
-      src,
-    });
+    logger.error({ ...baseMessage, message: `Expected array of numbers, received ${print($value)}` });
+  } else if (!$value.elements.every((e) => e.value.type === 'Number')) {
+    logger.error({ ...baseMessage, message: 'Expected an array of 4 numbers, received some non-numbers' });
   } else if ($value.elements.length !== 4) {
-    logger.error({
-      message: `Expected an array of 4 numbers, received ${$value.elements.length}`,
-      filename,
-      node: $value,
-      src,
-    });
+    logger.error({ ...baseMessage, message: `Expected an array of 4 numbers, received ${$value.elements.length}` });
   }
 }
 
@@ -238,44 +267,50 @@ export function validateDimension($value: ValueNode, _node: AnyNode, { filename,
   if ($value.type === 'Number' && $value.value === 0) {
     return; // `0` is a valid number
   }
+
+  const baseMessage = { group: 'parser' as const, label: 'validate', filename, node: $value, src };
+
+  // Give priority to object notation because it’s a faster code path
   if ($value.type === 'Object') {
     const { value, unit } = getObjMembers($value);
     if (!value) {
-      logger.error({ message: 'Missing required property "value".', filename, node: $value, src });
+      logger.error({ ...baseMessage, message: 'Missing required property "value".' });
     }
     if (!unit) {
-      logger.error({ message: 'Missing required property "unit".', filename, node: $value, src });
+      logger.error({ ...baseMessage, message: 'Missing required property "unit".' });
     }
     if (value!.type !== 'Number') {
-      logger.error({ message: `Expected number, received ${value!.type}`, filename, node: value, src });
+      logger.error({
+        ...baseMessage,
+        message: `Expected number, received ${value!.type}`,
+        node: value,
+      });
     }
     if (!['px', 'em', 'rem'].includes((unit as StringNode).value)) {
       logger.error({
+        ...baseMessage,
         message: `Expected unit "px", "em", or "rem", received ${print(unit as StringNode)}`,
-        filename,
         node: unit,
-        src,
       });
     }
     return;
   }
+
   // Backwards compat: string
   if ($value.type !== 'String') {
-    logger.error({ message: `Expected string, received ${$value.type}`, filename, node: $value, src });
+    logger.error({ ...baseMessage, message: `Expected string, received ${$value.type}` });
   }
   const value = ($value as StringNode).value.match(/^-?[0-9.]+/)?.[0];
   const unit = ($value as StringNode).value.replace(value!, '');
   if (($value as StringNode).value === '') {
-    logger.error({ message: 'Expected dimension, received empty string', filename, node: $value, src });
+    logger.error({ ...baseMessage, message: 'Expected dimension, received empty string' });
   } else if (!['px', 'em', 'rem'].includes(unit)) {
     logger.error({
+      ...baseMessage,
       message: `Expected unit "px", "em", or "rem", received ${JSON.stringify(unit || ($value as StringNode).value)}`,
-      filename,
-      node: $value,
-      src,
     });
   } else if (!Number.isFinite(Number.parseFloat(value!))) {
-    logger.error({ message: `Expected dimension with units, received ${print($value)}`, filename, node: $value, src });
+    logger.error({ ...baseMessage, message: `Expected dimension with units, received ${print($value)}` });
   }
 }
 
@@ -284,106 +319,101 @@ export function validateDuration($value: ValueNode, _node: AnyNode, { filename,
   if ($value.type === 'Number' && $value.value === 0) {
     return; // `0` is a valid number
   }
+
+  const baseMessage = { group: 'parser' as const, label: 'validate', filename, node: $value, src };
+
+  // Give priority to object notation because it’s a faster code path
   if ($value.type === 'Object') {
     const { value, unit } = getObjMembers($value);
     if (!value) {
-      logger.error({ message: 'Missing required property "value".', filename, node: $value, src });
+      logger.error({ ...baseMessage, message: 'Missing required property "value".' });
     }
     if (!unit) {
-      logger.error({ message: 'Missing required property "unit".', filename, node: $value, src });
+      logger.error({ ...baseMessage, message: 'Missing required property "unit".' });
     }
     if (value?.type !== 'Number') {
-      logger.error({ message: `Expected number, received ${value?.type}`, filename, node: value, src });
+      logger.error({
+        ...baseMessage,
+        message: `Expected number, received ${value?.type}`,
+        node: value,
+      });
     }
     if (!['ms', 's'].includes((unit as StringNode).value)) {
-      logger.error({ message: `Expected unit "ms" or "s", received ${print(unit!)}`, filename, node: unit, src });
+      logger.error({
+        ...baseMessage,
+        message: `Expected unit "ms" or "s", received ${print(unit!)}`,
+        node: unit,
+      });
     }
     return;
   }
+
   // Backwards compat: string
   if ($value.type !== 'String') {
-    logger.error({ message: `Expected string, received ${$value.type}`, filename, node: $value, src });
+    logger.error({ ...baseMessage, message: `Expected string, received ${$value.type}` });
   }
   const value = ($value as StringNode).value.match(/^-?[0-9.]+/)?.[0]!;
   const unit = ($value as StringNode).value.replace(value, '');
   if (($value as StringNode).value === '') {
-    logger.error({ message: 'Expected duration, received empty string', filename, node: $value, src });
+    logger.error({ ...baseMessage, message: 'Expected duration, received empty string' });
   } else if (!['ms', 's'].includes(unit)) {
     logger.error({
+      ...baseMessage,
       message: `Expected unit "ms" or "s", received ${JSON.stringify(unit || ($value as StringNode).value)}`,
-      filename,
-      node: $value,
-      src,
     });
   } else if (!Number.isFinite(Number.parseFloat(value))) {
-    logger.error({ message: `Expected duration with units, received ${print($value)}`, filename, node: $value, src });
+    logger.error({ ...baseMessage, message: `Expected duration with units, received ${print($value)}` });
   }
 }
 
 /**  Verify a Font Family token is valid */
 export function validateFontFamily($value: ValueNode, _node: AnyNode, { filename, src, logger }: ValidateOptions) {
+  const baseMessage = { group: 'parser' as const, label: 'validate', filename, node: $value, src };
   if ($value.type !== 'String' && $value.type !== 'Array') {
-    logger.error({
-      message: `Expected string or array of strings, received ${$value.type}`,
-      filename,
-      node: $value,
-      src,
-    });
+    logger.error({ ...baseMessage, message: `Expected string or array of strings, received ${$value.type}` });
   }
   if ($value.type === 'String' && $value.value === '') {
-    logger.error({ message: 'Expected font family name, received empty string', filename, node: $value, src });
+    logger.error({ ...baseMessage, message: 'Expected font family name, received empty string' });
   }
   if ($value.type === 'Array' && !$value.elements.every((e) => e.value.type === 'String' && e.value.value !== '')) {
     logger.error({
+      ...baseMessage,
       message: 'Expected an array of strings, received some non-strings or empty strings',
-      filename,
-      node: $value,
-      src,
     });
   }
 }
 
 /** Verify a Font Weight token is valid */
 export function validateFontWeight($value: ValueNode, _node: AnyNode, { filename, src, logger }: ValidateOptions) {
+  const baseMessage = { group: 'parser' as const, label: 'validate', filename, node: $value, src };
   if ($value.type !== 'String' && $value.type !== 'Number') {
-    logger.error({
-      message: `Expected a font weight name or number 0–1000, received ${$value.type}`,
-      filename,
-      node: $value,
-      src,
-    });
+    logger.error({ ...baseMessage, message: `Expected a font weight name or number 0–1000, received ${$value.type}` });
   }
   if ($value.type === 'String' && !FONT_WEIGHT_VALUES.has($value.value)) {
     logger.error({
+      ...baseMessage,
       message: `Unknown font weight ${print($value)}. Expected one of: ${listFormat.format([...FONT_WEIGHT_VALUES])}.`,
-      filename,
-      node: $value,
-      src,
     });
   }
   if ($value.type === 'Number' && ($value.value < 0 || $value.value > 1000)) {
-    logger.error({ message: `Expected number 0–1000, received ${print($value)}`, filename, node: $value, src });
+    logger.error({ ...baseMessage, message: `Expected number 0–1000, received ${print($value)}` });
   }
 }
 
 /** Verify a Gradient token is valid */
 export function validateGradient($value: ValueNode, _node: AnyNode, { filename, src, logger }: ValidateOptions) {
+  const baseMessage = { group: 'parser' as const, label: 'validate', filename, node: $value, src };
+
   if ($value.type !== 'Array') {
-    logger.error({
-      message: `Expected array of gradient stops, received ${$value.type}`,
-      filename,
-      node: $value,
-      src,
-    });
+    logger.error({ ...baseMessage, message: `Expected array of gradient stops, received ${$value.type}` });
   } else {
     for (let i = 0; i < $value.elements.length; i++) {
       const element = $value.elements[i]!;
       if (element.value.type !== 'Object') {
         logger.error({
+          ...baseMessage,
           message: `Stop #${i + 1}: Expected gradient stop, received ${element.value.type}`,
-          filename,
           node: element,
-          src,
         });
         break;
       }
@@ -403,21 +433,42 @@ export function validateGradient($value: ValueNode, _node: AnyNode, { filename,
 /** Verify a Number token is valid */
 export function validateNumber($value: ValueNode, _node: AnyNode, { filename, src, logger }: ValidateOptions) {
   if ($value.type !== 'Number') {
-    logger.error({ message: `Expected number, received ${$value.type}`, filename, node: $value, src });
+    logger.error({
+      group: 'parser',
+      label: 'validate',
+      message: `Expected number, received ${$value.type}`,
+      filename,
+      node: $value,
+      src,
+    });
   }
 }
 
 /** Verify a Boolean token is valid */
 export function validateBoolean($value: ValueNode, _node: AnyNode, { filename, src, logger }: ValidateOptions) {
   if ($value.type !== 'Boolean') {
-    logger.error({ message: `Expected boolean, received ${$value.type}`, filename, node: $value, src });
+    logger.error({
+      group: 'parser',
+      label: 'validate',
+      message: `Expected boolean, received ${$value.type}`,
+      filename,
+      node: $value,
+      src,
+    });
   }
 }
 
 /** Verify a Shadow token’s value is valid */
 export function validateShadowLayer($value: ValueNode, node: AnyNode, { filename, src, logger }: ValidateOptions) {
   if ($value.type !== 'Object') {
-    logger.error({ message: `Expected Object, received ${$value.type}`, filename, node: $value, src });
+    logger.error({
+      group: 'parser',
+      label: 'validate',
+      message: `Expected Object, received ${$value.type}`,
+      filename,
+      node: $value,
+      src,
+    });
   } else {
     validateMembersAs(
       $value,
@@ -437,31 +488,33 @@ export function validateShadowLayer($value: ValueNode, node: AnyNode, { filename
 
 /** Verify a Stroke Style token is valid. */
 export function validateStrokeStyle($value: ValueNode, node: AnyNode, { filename, src, logger }: ValidateOptions) {
+  const baseMessage = { group: 'parser' as const, label: 'validate', filename, node: $value, src };
+
   // note: strokeStyle’s values are NOT aliasable (unless by string, but that breaks validations)
   if ($value.type === 'String') {
     if (!STROKE_STYLE_VALUES.has($value.value)) {
       logger.error({
+        ...baseMessage,
         message: `Unknown stroke style ${print($value)}. Expected one of: ${listFormat.format([
           ...STROKE_STYLE_VALUES,
         ])}.`,
-        filename,
-        node: $value,
-        src,
       });
     }
   } else if ($value.type === 'Object') {
     const strokeMembers = getObjMembers($value);
     for (const property of ['dashArray', 'lineCap']) {
       if (!strokeMembers[property]) {
-        logger.error({ message: `Missing required property "${property}"`, filename, node: $value, src });
+        logger.error({ ...baseMessage, message: `Missing required property "${property}"` });
       }
     }
     const { lineCap, dashArray } = strokeMembers;
     if (lineCap?.type !== 'String' || !STROKE_STYLE_LINE_CAP_VALUES.has(lineCap.value)) {
       logger.error({
+        ...baseMessage,
         message: `Unknown lineCap value ${print(lineCap!)}. Expected one of: ${listFormat.format([
           ...STROKE_STYLE_LINE_CAP_VALUES,
         ])}.`,
+        node,
       });
     }
     if (dashArray?.type === 'Array') {
@@ -474,25 +527,31 @@ export function validateStrokeStyle($value: ValueNode, node: AnyNode, { filename
           }
         } else {
           logger.error({
+            ...baseMessage,
             message: 'Expected array of strings, recieved some non-strings or empty strings.',
-            filename,
             node: element,
-            src,
           });
         }
       }
     } else {
-      logger.error({ message: `Expected array of strings, received ${dashArray!.type}`, filename, node: $value, src });
+      logger.error({ ...baseMessage, message: `Expected array of strings, received ${dashArray!.type}` });
     }
   } else {
-    logger.error({ message: `Expected string or object, received ${$value.type}`, filename, node: $value, src });
+    logger.error({ ...baseMessage, message: `Expected string or object, received ${$value.type}` });
   }
 }
 
 /** Verify a Transition token is valid */
 export function validateTransition($value: ValueNode, node: AnyNode, { filename, src, logger }: ValidateOptions) {
   if ($value.type !== 'Object') {
-    logger.error({ message: `Expected object, received ${$value.type}`, filename, node: $value, src });
+    logger.error({
+      group: 'parser',
+      label: 'validate',
+      message: `Expected object, received ${$value.type}`,
+      filename,
+      node: $value,
+      src,
+    });
   } else {
     validateMembersAs(
       $value,
@@ -513,15 +572,15 @@ export function validateTransition($value: ValueNode, node: AnyNode, { filename,
  * really helps in debug messages.
  */
 export function validateTokenMemberNode(node: MemberNode, { filename, src, logger }: ValidateOptions) {
+  const baseMessage = { group: 'parser' as const, label: 'validate', filename, node, src };
+
   if (node.type !== 'Member' && node.type !== 'Object') {
     logger.error({
+      ...baseMessage,
       message: `Expected Object, received ${JSON.stringify(
         // @ts-ignore Yes, TypeScript, this SHOULD be unexpected. This is why we’re validating.
         node.type,
       )}`,
-      filename,
-      node,
-      src,
     });
   }
 
@@ -530,7 +589,7 @@ export function validateTokenMemberNode(node: MemberNode, { filename, src, logge
   const $type = rootMembers.$type as StringNode;
 
   if (!$value) {
-    logger.error({ message: 'Token missing $value', filename, node, src });
+    logger.error({ ...baseMessage, message: 'Token missing $value' });
   }
   // If top-level value is a valid alias, this is valid (no need for $type)
   // ⚠️ Important: ALL Object and Array nodes below will need to check for aliases within!
@@ -540,7 +599,7 @@ export function validateTokenMemberNode(node: MemberNode, { filename, src, logge
   }
 
   if (!$type) {
-    logger.error({ message: 'Token missing $type', filename, node, src });
+    logger.error({ ...baseMessage, message: 'Token missing $type' });
   }
 
   switch ($type.value) {
@@ -581,10 +640,9 @@ export function validateTokenMemberNode(node: MemberNode, { filename, src, logge
         }
       } else {
         logger.error({
+          ...baseMessage,
           message: `Expected shadow object or array of shadow objects, received ${$value.type}`,
-          filename,
           node: $value,
-          src,
         });
       }
       break;
@@ -593,21 +651,37 @@ export function validateTokenMemberNode(node: MemberNode, { filename, src, logge
     // extensions
     case 'boolean': {
       if ($value.type !== 'Boolean') {
-        logger.error({ message: `Expected boolean, received ${$value.type}`, filename, node: $value, src });
+        logger.error({
+          ...baseMessage,
+          message: `Expected boolean, received ${$value.type}`,
+          node: $value,
+        });
       }
       break;
     }
     case 'link': {
       if ($value.type !== 'String') {
-        logger.error({ message: `Expected string, received ${$value.type}`, filename, node: $value, src });
+        logger.error({
+          ...baseMessage,
+          message: `Expected string, received ${$value.type}`,
+          node: $value,
+        });
       } else if ($value.value === '') {
-        logger.error({ message: 'Expected URL, received empty string', filename, node: $value, src });
+        logger.error({
+          ...baseMessage,
+          message: 'Expected URL, received empty string',
+          node: $value,
+        });
       }
       break;
     }
     case 'string': {
       if ($value.type !== 'String') {
-        logger.error({ message: `Expected string, received ${$value.type}`, filename, node: $value, src });
+        logger.error({
+          ...baseMessage,
+          message: `Expected string, received ${$value.type}`,
+          node: $value,
+        });
       }
       break;
     }
@@ -631,15 +705,18 @@ export function validateTokenMemberNode(node: MemberNode, { filename, src, logge
     }
     case 'typography': {
       if ($value.type !== 'Object') {
-        logger.error({ message: `Expected object, received ${$value.type}`, filename, node: $value, src });
+        logger.error({
+          ...baseMessage,
+          message: `Expected object, received ${$value.type}`,
+          node: $value,
+        });
         break;
       }
       if ($value.members.length === 0) {
         logger.error({
+          ...baseMessage,
           message: 'Empty typography token. Must contain at least 1 property.',
-          filename,
           node: $value,
-          src,
         });
       }
       validateMembersAs(
@@ -671,10 +748,17 @@ export interface ValidateTokenNodeOptions {
   $typeInheritance?: Record<string, Token['$type']>;
 }
 
+/**
+ * Validate does a little more than validate; it also converts to TokenNormalized
+ * and sets up the basic data structure. But aliases are unresolved, and we need
+ * a 2nd normalization pass afterward.
+ */
 export default function validateTokenNode(
   node: MemberNode,
   { config, filename, logger, parent, src, subpath, $typeInheritance }: ValidateTokenNodeOptions,
 ): TokenNormalized | undefined {
+  // const start = performance.now();
+
   // don’t validate $value
   if (subpath.includes('$value') || node.value.type !== 'Object') {
     return;
@@ -696,7 +780,14 @@ export default function validateTokenNode(
   const id = subpath.join('.');
 
   if (!subpath.includes('.$value') && members.value) {
-    logger.warn({ message: `Group ${id} has "value". Did you mean "$value"?`, filename, node, src });
+    logger.warn({
+      group: 'parser',
+      label: 'validate',
+      message: `Group ${id} has "value". Did you mean "$value"?`,
+      filename,
+      node,
+      src,
+    });
   }
 
   const extensions = members.$extensions ? getObjMembers(members.$extensions as ObjectNode) : undefined;
@@ -714,7 +805,7 @@ export default function validateTokenNode(
     }
   }
   if (parent$type && !members.$type) {
-    sourceNode.value = injectObjMembers(
+    injectObjMembers(
       // @ts-ignore
       sourceNode.value,
       [parent$type],
@@ -773,29 +864,25 @@ export default function validateTokenNode(
 
   // handle modes
   // note that circular refs are avoided here, such as not duplicating `modes`
-  const modeValues = extensions?.mode
-    ? getObjMembers(
-        // @ts-ignore
-        extensions.mode,
-      )
-    : {};
+  const modeValues = extensions?.mode ? getObjMembers(extensions.mode as any) : {};
   for (const mode of ['.', ...Object.keys(modeValues)]) {
+    const modeValue = mode === '.' ? token.$value : (evaluate((modeValues as any)[mode]) as any);
     token.mode[mode] = {
-      id: token.id,
-      // @ts-ignore
-      $type: token.$type,
-      // @ts-ignore
-      $value: mode === '.' ? token.$value : evaluate(modeValues[mode]),
+      $value: modeValue,
+      originalValue: modeValue,
       source: {
         loc: filename ? filename.href : undefined,
         // @ts-ignore
-        node: mode === '.' ? structuredClone(token.source.node) : modeValues[mode],
+        node: modeValues[mode],
       },
     };
-    if (token.$description) {
-      token.mode[mode]!.$description = token.$description;
-    }
   }
 
+  // logger.debug({
+  //   message: `${token.id}: validateTokenNode`,
+  //   group: 'parser', label: 'validate',
+  //   label: 'validate',
+  //   timing: performance.now() - start,
+  // });
   return token;
 }