@terrazzo/parser 0.4.0 → 0.6.0

package/dist/parse/validate.js

@@ -60,33 +60,54 @@ function isMaybeAlias(node) {
 /** Assert object members match given types */
 function validateMembersAs($value, properties, node, { filename, src, logger }) {
     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 });
         }
     }
 }
 /** Verify an Alias $value is formatted correctly */
 export function validateAliasSyntax($value, _node, { filename, src, logger }) {
     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, node, { filename, src, logger }) {
     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, {
@@ -98,6 +119,7 @@ export function validateBorder($value, node, { filename, src, logger }) {
 }
 /** Verify a Color token is valid */
 export function validateColor($value, node, { filename, src, logger }) {
+    const baseMessage = { group: 'parser', label: 'validate', filename, node: $value, src };
     if ($value.type === 'String') {
         // TODO: enable when object notation is finalized
         // logger.warn({
@@ -107,7 +129,7 @@ export function validateColor($value, node, { filename, src, logger }) {
         //   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') {
@@ -115,10 +137,18 @@ export function validateColor($value, node, { filename, src, logger }) {
             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.value)) {
-                        logger.error({ message: `Unsupported colorspace ${print(v)}`, filename, node: v, src });
+                        logger.error({
+                            ...baseMessage,
+                            message: `Unsupported colorspace ${print(v)}`,
+                            node: v,
+                        });
                     }
                 },
                 required: true,
@@ -126,24 +156,26 @@ export function validateColor($value, node, { filename, src, logger }) {
             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,
                                 });
                             }
                         }
@@ -161,7 +193,11 @@ export function validateColor($value, node, { filename, src, logger }) {
                         v.value.length === 5 + 1 ||
                         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,
+                        });
                     }
                 },
             },
@@ -169,29 +205,24 @@ export function validateColor($value, node, { filename, src, logger }) {
         }, node, { 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, _node, { filename, src, logger }) {
+    const baseMessage = { group: 'parser', label: 'validate', filename, node: $value, src };
     if ($value.type !== 'Array') {
-        logger.error({ message: `Expected array of strings, received ${print($value)}`, 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' || (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,
-        });
+    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}` });
     }
 }
 /** Verify a Dimension token is valid */
@@ -199,46 +230,49 @@ export function validateDimension($value, _node, { filename, src, logger }) {
     if ($value.type === 'Number' && $value.value === 0) {
         return; // `0` is a valid number
     }
+    const baseMessage = { group: 'parser', 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.value)) {
             logger.error({
+                ...baseMessage,
                 message: `Expected unit "px", "em", or "rem", received ${print(unit)}`,
-                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.value.match(/^-?[0-9.]+/)?.[0];
     const unit = $value.value.replace(value, '');
     if ($value.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.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)}` });
     }
 }
 /** Verify a Duration token is valid */
@@ -246,106 +280,97 @@ export function validateDuration($value, _node, { filename, src, logger }) {
     if ($value.type === 'Number' && $value.value === 0) {
         return; // `0` is a valid number
     }
+    const baseMessage = { group: 'parser', 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.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.value.match(/^-?[0-9.]+/)?.[0];
     const unit = $value.value.replace(value, '');
     if ($value.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.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, _node, { filename, src, logger }) {
+    const baseMessage = { group: 'parser', 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, _node, { filename, src, logger }) {
+    const baseMessage = { group: 'parser', 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, _node, { filename, src, logger }) {
+    const baseMessage = { group: 'parser', 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;
             }
@@ -359,19 +384,40 @@ export function validateGradient($value, _node, { filename, src, logger }) {
 /** Verify a Number token is valid */
 export function validateNumber($value, _node, { filename, src, logger }) {
     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, _node, { filename, src, logger }) {
     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, node, { filename, src, logger }) {
     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, {
@@ -386,16 +432,15 @@ export function validateShadowLayer($value, node, { filename, src, logger }) {
 }
 /** Verify a Stroke Style token is valid. */
 export function validateStrokeStyle($value, node, { filename, src, logger }) {
+    const baseMessage = { group: 'parser', 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,
             });
         }
     }
@@ -403,15 +448,17 @@ export function validateStrokeStyle($value, node, { filename, src, logger }) {
         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') {
@@ -426,26 +473,32 @@ export function validateStrokeStyle($value, node, { filename, src, logger }) {
                 }
                 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, node, { filename, src, logger }) {
     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, {
@@ -461,21 +514,20 @@ export function validateTransition($value, node, { filename, src, logger }) {
  * really helps in debug messages.
  */
 export function validateTokenMemberNode(node, { filename, src, logger }) {
+    const baseMessage = { group: 'parser', 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,
         });
     }
     const rootMembers = node.value.type === 'Object' ? getObjMembers(node.value) : {};
     const $value = rootMembers.$value;
     const $type = rootMembers.$type;
     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!
@@ -484,7 +536,7 @@ export function validateTokenMemberNode(node, { filename, src, logger }) {
         return;
     }
     if (!$type) {
-        logger.error({ message: 'Token missing $type', filename, node, src });
+        logger.error({ ...baseMessage, message: 'Token missing $type' });
     }
     switch ($type.value) {
         case 'color': {
@@ -526,10 +578,9 @@ export function validateTokenMemberNode(node, { filename, src, logger }) {
             }
             else {
                 logger.error({
+                    ...baseMessage,
                     message: `Expected shadow object or array of shadow objects, received ${$value.type}`,
-                    filename,
                     node: $value,
-                    src,
                 });
             }
             break;
@@ -537,22 +588,38 @@ export function validateTokenMemberNode(node, { filename, src, logger }) {
         // 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;
         }
@@ -575,15 +642,18 @@ export function validateTokenMemberNode(node, { filename, src, logger }) {
         }
         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($value, {
@@ -598,7 +668,13 @@ export function validateTokenMemberNode(node, { filename, src, logger }) {
         }
     }
 }
+/**
+ * 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, { config, filename, logger, parent, src, subpath, $typeInheritance }) {
+    // const start = performance.now();
     // don’t validate $value
     if (subpath.includes('$value') || node.value.type !== 'Object') {
         return;
@@ -615,7 +691,14 @@ export default function validateTokenNode(node, { config, filename, logger, pare
     }
     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) : undefined;
     const sourceNode = structuredClone(node);
@@ -631,7 +714,7 @@ export default function validateTokenNode(node, { config, filename, logger, pare
         }
     }
     if (parent$type && !members.$type) {
-        sourceNode.value = injectObjMembers(
+        injectObjMembers(
         // @ts-ignore
         sourceNode.value, [parent$type]);
     }
@@ -683,28 +766,25 @@ export default function validateTokenNode(node, { config, filename, logger, pare
     }
     // 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) : {};
     for (const mode of ['.', ...Object.keys(modeValues)]) {
+        const modeValue = mode === '.' ? token.$value : evaluate(modeValues[mode]);
         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;
 }
 //# sourceMappingURL=validate.js.map