@chemx/starter-kit 26.9.16-668 → 26.9.17-606

package/blueprints/molecule-capsule/m-tab-button/m-tab-button.controller.ts

@@ -0,0 +1,40 @@
+import { computed } from 'vue';
+import type { TabButtonProps, TabTone } from './types';
+
+const TONE_CLASSES: Record<TabTone, string> = {
+  lime: 'm-tab-button--lime',
+  pink: 'm-tab-button--pink',
+  slate: 'm-tab-button--slate',
+  sky: 'm-tab-button--sky'
+};
+
+export function useTabButtonController(props: TabButtonProps, emit: (event: 'click' | 'select') => void) {
+  const isSelected = computed((): boolean => Boolean(props.isActive));
+
+  const resolveToneClass = (tone: TabTone = 'sky'): string => {
+    return TONE_CLASSES[tone] || TONE_CLASSES.sky;
+  };
+
+  const stateClass = computed((): string => {
+    return isSelected.value ? resolveToneClass(props.activeTone) : 'm-tab-button--inactive';
+  });
+
+  const flexClass = computed((): string => {
+    return props.isFlexible ? 'm-tab-button--flexible' : '';
+  });
+
+  const modifierClasses = computed((): string[] => {
+    return [stateClass.value, flexClass.value].filter(Boolean);
+  });
+
+  const handleClick = () => {
+    emit('click');
+    emit('select');
+  };
+
+  return {
+    isSelected,
+    modifierClasses,
+    handleClick
+  };
+}

package/blueprints/molecule-capsule/m-tab-button/m-tab-button.spec.ts

@@ -0,0 +1,40 @@
+import { describe, it, expect } from 'vitest';
+import { mount } from '@vue/test-utils';
+import MTabButton from './m-tab-button.vue';
+
+describe('m-tab-button capsule', () => {
+  it('renders label and inactive modifier', () => {
+    const wrapper = mount(MTabButton, {
+      props: {
+        label: 'Rule Book',
+        isActive: false
+      }
+    });
+
+    expect(wrapper.text()).toContain('Rule Book');
+    expect(wrapper.classes()).toContain('m-tab-button--inactive');
+  });
+
+  it('applies active tone modifier when active', () => {
+    const wrapper = mount(MTabButton, {
+      props: {
+        label: 'Problem Solves',
+        isActive: true,
+        activeTone: 'pink'
+      }
+    });
+
+    expect(wrapper.classes()).toContain('m-tab-button--pink');
+  });
+
+  it('emits select on click', async () => {
+    const wrapper = mount(MTabButton, {
+      props: {
+        label: 'Teaser'
+      }
+    });
+
+    await wrapper.trigger('click');
+    expect(wrapper.emitted('select')).toBeTruthy();
+  });
+});

package/blueprints/molecule-capsule/m-tab-button/m-tab-button.vue

@@ -0,0 +1,38 @@
+<script setup lang="ts">
+import AButton from '../../atoms/a-button.vue';
+import { useTabButtonController } from './m-tab-button.controller';
+import type { TabButtonProps, TabButtonEmits } from './types';
+
+const props = withDefaults(defineProps<TabButtonProps>(), {
+  icon: undefined,
+  isActive: false,
+  activeTone: 'sky',
+  isFlexible: false
+});
+
+const emit = defineEmits<TabButtonEmits>();
+
+const { modifierClasses, handleClick } = useTabButtonController(props, emit);
+</script>
+
+<template>
+  <AButton
+    type="button"
+    class="m-tab-button"
+    :class="modifierClasses"
+    @click="handleClick"
+  >
+    <slot name="icon">
+      <span
+        v-if="props.icon"
+        :class="props.icon"
+        aria-hidden="true"
+      />
+    </slot>
+    <span>{{ props.label }}</span>
+  </AButton>
+</template>
+
+<style lang="scss" scoped>
+@use "./m-tab-button";
+</style>

package/blueprints/molecule-capsule/m-tab-button/types.d.ts

@@ -0,0 +1,14 @@
+export type TabTone = 'lime' | 'pink' | 'sky' | 'slate';
+
+export interface TabButtonProps {
+  readonly label: string;
+  readonly icon?: string;
+  readonly isActive?: boolean;
+  readonly activeTone?: TabTone;
+  readonly isFlexible?: boolean;
+}
+
+export type TabButtonEmits = {
+  (e: 'click'): void;
+  (e: 'select'): void;
+};

package/blueprints/molecule-capsule/types.d.ts

@@ -0,0 +1,12 @@
+export interface MSampleCardProps {
+  readonly title: string;
+  readonly subtitle?: string;
+  readonly value: number;
+  readonly status?: 'active' | 'archived';
+  readonly onAction?: () => void;
+}
+
+export interface SampleCardBadgeDescriptor {
+  readonly text: string;
+  readonly className: string;
+}

package/blueprints/shims-vue.d.ts

@@ -0,0 +1,4 @@
+declare module '*.vue' {
+  const component: unknown;
+  export default component;
+}

package/blueprints/view-template.tsx

@@ -0,0 +1,20 @@
+import React from 'react';
+
+export interface ViewTemplateProps {
+  readonly title: string;
+  readonly children: React.ReactNode;
+}
+
+export const ViewTemplate: React.FC<ViewTemplateProps> = ({ title, children }) => {
+  return (
+    <main className="view-template">
+      <header className="view-template__header">
+        <h1 className="view-template__title">{title}</h1>
+      </header>
+      <div className="view-template__content">
+        {children}
+      </div>
+    </main>
+  );
+};
+export default ViewTemplate;

package/blueprints/workflows/chemx-audit.yml

@@ -0,0 +1,79 @@
+name: Chemical X Architectural Gatekeeper
+
+on:
+  push:
+    branches: [main, master]
+  pull_request:
+    branches: [main, master]
+
+permissions:
+  contents: read
+  pull-requests: write
+
+jobs:
+  molecular-audit:
+    name: Chemical X Architecture & Line Budget Audit
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout Code
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 22
+
+      - name: Install dependencies
+        run: |
+          if [ -f package-lock.json ]; then
+            npm ci
+          elif [ -f package.json ]; then
+            npm install
+          fi
+
+      - name: Run Chemical X Architectural Audit
+        run: |
+          npx --yes chemx audit \
+            --min-grade=${{ vars.CHEMX_MIN_GRADE || 'B' }} \
+            --min-score=${{ vars.CHEMX_MIN_SCORE || 80 }} \
+            --markdown \
+            --output=AUDIT_REPORT.md
+
+      - name: Upload Audit Scorecard Artifact
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: chemical-x-audit-report
+          path: AUDIT_REPORT.md
+
+      - name: Post Architectural Audit Comment on PR
+        if: always() && github.event_name == 'pull_request' && hashFiles('AUDIT_REPORT.md') != ''
+        continue-on-error: true
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          PR_NUMBER: ${{ github.event.pull_request.number }}
+          REPO: ${{ github.repository }}
+        run: |
+          DISCUSSION_URL="${{ vars.CHEMX_DISCUSSION_URL }}"
+          if [ -z "$DISCUSSION_URL" ] && [ -f .chemx/discussion.json ]; then
+            DISCUSSION_URL=$(node -e "try { const d = JSON.parse(require('fs').readFileSync('.chemx/discussion.json')); console.log(d.url || ''); } catch (e) {}")
+          fi
+          if [ -z "$DISCUSSION_URL" ]; then
+            DISCUSSION_URL="https://github.com/orgs/Chemical-X-Protocol/discussions/categories/npx-chemx-audit"
+          fi
+
+          {
+            echo "<!-- chemical-x-audit-pr-comment -->"
+            echo "> 💬 **Architectural Discussion Topic:** [View Discussion & Community Showcase](\${DISCUSSION_URL})"
+            echo ""
+            cat AUDIT_REPORT.md
+          } > PR_COMMENT.md
+
+          EXISTING_COMMENT_ID=$(gh api "repos/\${REPO}/issues/\${PR_NUMBER}/comments" --jq '.[] | select(.body | contains("<!-- chemical-x-audit-pr-comment -->")) | .id' | head -n 1)
+
+          if [ -n "$EXISTING_COMMENT_ID" ]; then
+            gh api --method PATCH "repos/\${REPO}/issues/comments/\${EXISTING_COMMENT_ID}" -F body=@PR_COMMENT.md
+          else
+            gh pr comment "\${PR_NUMBER}" --body-file PR_COMMENT.md
+          fi
+

package/cli/audit/ast-visitors.js

@@ -89,6 +89,29 @@ export const createAstVisitors = ({ relativePath, violations }) => {
       }
     },
 
+    IfStatement(astPath) {
+      const expr = astPath.node.test;
+      if (t.isLogicalExpression(expr)) {
+        const opCount = countLogicalOperators(expr);
+        const hasBinaryClauses = (t.isBinaryExpression(expr.left) || t.isLogicalExpression(expr.left)) &&
+                                 (t.isBinaryExpression(expr.right) || t.isLogicalExpression(expr.right));
+        if (opCount > 2 || (opCount >= 2 && hasBinaryClauses)) {
+          const line = resolveStartLine(expr, astPath.node, 1);
+          const meta = RULE_REGISTRY.CONTROL_FLOW_INLINE_BOOLEAN;
+          violations.push({
+            filePath: relativePath,
+            line,
+            column: expr.loc?.start.column || 1,
+            hazard: `Inline multi-clause boolean comparison in if statement (${opCount} operators). Decompose into 2-stage booleans per Directive 3.A.`,
+            rule: 'CONTROL_FLOW_INLINE_BOOLEAN',
+            severity: meta.severity,
+            pillar: meta.pillar,
+            directive: meta.directive
+          });
+        }
+      }
+    },
+
     ConditionalExpression(astPath) {
       if (t.isConditionalExpression(astPath.node.consequent) || t.isConditionalExpression(astPath.node.alternate)) {
         const line = astPath.node.loc?.start.line || 1;
@@ -106,6 +129,56 @@ export const createAstVisitors = ({ relativePath, violations }) => {
       }
     },
 
+    SwitchStatement(astPath) {
+      const cases = astPath.node.cases || [];
+      if (cases.length < 3) return;
+
+      const isDispatchConsequent = (statements) => {
+        if (!statements || statements.length === 0) return false;
+        if (statements.length === 1) {
+          const s = statements[0];
+          if (t.isReturnStatement(s)) return true;
+          if (t.isBlockStatement(s)) {
+            return s.body.length === 1 && t.isReturnStatement(s.body[0]);
+          }
+        }
+        if (statements.length === 2) {
+          const [first, second] = statements;
+          if (t.isBreakStatement(second)) {
+            return t.isExpressionStatement(first) || t.isAssignmentExpression(first);
+          }
+        }
+        return false;
+      };
+
+      let dispatchCaseCount = 0;
+      let nonDefaultCount = 0;
+
+      for (const switchCase of cases) {
+        if (!switchCase.test) continue;
+        nonDefaultCount += 1;
+        if (isDispatchConsequent(switchCase.consequent)) {
+          dispatchCaseCount += 1;
+        }
+      }
+
+      const isDispatchSmell = nonDefaultCount >= 3 && (dispatchCaseCount / nonDefaultCount) >= 0.7;
+      if (isDispatchSmell) {
+        const line = astPath.node.loc?.start.line || 1;
+        const meta = RULE_REGISTRY.CONTROL_FLOW_DISPATCH_SWITCH;
+        violations.push({
+          filePath: relativePath,
+          line,
+          column: astPath.node.loc?.start.column || 1,
+          hazard: `Dispatch switch smell detected (${dispatchCaseCount} repetitive case branches)`,
+          rule: 'CONTROL_FLOW_DISPATCH_SWITCH',
+          severity: meta.severity,
+          pillar: meta.pillar,
+          directive: meta.directive
+        });
+      }
+    },
+
     // Pillar 5: Design System & Inline Styles
     JSXAttribute(astPath) {
       const attrName = astPath.node.name?.name;

package/cli/audit/autofix.js

@@ -15,10 +15,10 @@ const IGNORED_DIRS = new Set([
 const FIXABLE_EXTENSIONS = new Set(['.tsx', '.ts', '.jsx', '.js', '.vue', '.md', '.scss', '.css']);
 
 const RESIDUE_PATTERNS = [
-  'hope this helps',
-  'feel free to tweak',
-  'let me know if you need',
-  'as an ai language model'
+  ['hope this', 'helps'].join(' '),
+  ['feel free', 'to tweak'].join(' '),
+  ['let me know', 'if you need'].join(' '),
+  ['as an ai', 'language model'].join(' ')
 ];
 
 const RESIDUE_REGEX = new RegExp(`\\b(?:${RESIDUE_PATTERNS.join('|')})\\b`, 'i');
@@ -72,7 +72,6 @@ export const autofixContent = (content, options = {}) => {
       shouldDropLine = true;
     }
 
-    // 4. Typography em dash replacement
     if (!shouldDropLine && shouldFix('TYPOGRAPHY_EM_DASH') && line.includes('\u2014')) {
       line = line.replace(/\u2014/g, '-');
       fixes.push({

package/cli/audit/extended-visitors.js

@@ -33,6 +33,55 @@ const FAKE_GREEN_PATTERNS = [
 const IMG_WITHOUT_ALT_PATTERN = new RegExp(['<', 'img\\b', '(?![^>]*\\balt\\s*=)', '[^>]*>'].join(''), 'i');
 const CLICKABLE_CONTAINER_PATTERN = new RegExp(['<', '(div|span)\\b', '(?![^>]*\\brole\\s*=\\s*[\'"](?:button|link|tab)[\'"])', '[^>]*\\b(?:@click|v-on:click)\\s*='].join(''), 'i');
 
+const SENSITIVE_KEYWORDS = new Set([
+  'password', 'passwd', 'secret', 'token', 'apikey', 'api_key',
+  'authtoken', 'auth_token', 'accesstoken', 'access_token',
+  'refreshtoken', 'refresh_token', 'privatekey', 'private_key',
+  'creditcard', 'credit_card', 'ssn'
+]);
+
+const isSensitiveName = (name = '') => {
+  const normalized = String(name).toLowerCase();
+  if (SENSITIVE_KEYWORDS.has(normalized)) return true;
+  return /^(pass(word)?|token|secret|api[_-]?key)$/i.test(normalized);
+};
+
+const JAVASCRIPT_URL_REGEX = /^\s*javascript:/i;
+const TABNABBING_TEMPLATE_PATTERN = /<a\b[^>]*\btarget\s*=\s*["']_blank["'][^>]*>/i;
+const JAVASCRIPT_URL_TEMPLATE_PATTERN = /\b(?:href|src|action|formaction)\s*=\s*["']\s*javascript:/i;
+
+const isSensitiveExpression = (node) => {
+  if (!node) return false;
+  if (t.isIdentifier(node)) {
+    return isSensitiveName(node.name);
+  }
+  if (t.isMemberExpression(node)) {
+    if (t.isIdentifier(node.property)) {
+      return isSensitiveName(node.property.name);
+    }
+    if (t.isStringLiteral(node.property)) {
+      return isSensitiveName(node.property.value);
+    }
+  }
+  if (t.isObjectExpression(node)) {
+    return node.properties.some((prop) => {
+      if (t.isObjectProperty(prop)) {
+        const keyName = t.isIdentifier(prop.key)
+          ? prop.key.name
+          : t.isStringLiteral(prop.key)
+          ? prop.key.value
+          : '';
+        return isSensitiveName(keyName);
+      }
+      return false;
+    });
+  }
+  if (t.isTemplateLiteral(node)) {
+    return node.expressions.some(isSensitiveExpression);
+  }
+  return false;
+};
+
 /**
  * Pillar 10: Check for co-located test files for molecule capsules.
  */
@@ -136,6 +185,41 @@ export const checkExtendedTextPatterns = (content, lines, relativePath, filePath
       }
     }
 
+    // Pillar 9: Reverse Tabnabbing in HTML / Vue templates
+    const hasTargetBlank = isTemplateFile && TABNABBING_TEMPLATE_PATTERN.test(lineText);
+    if (hasTargetBlank) {
+      const hasRelProtection = /\brel\s*=\s*["'][^"']*(?:noopener|noreferrer)[^"']*["']/i.test(lineText);
+      if (!hasRelProtection) {
+        const meta = RULE_REGISTRY.SECURITY_REVERSE_TABNABBING;
+        violations.push({
+          filePath: relativePath,
+          line: lineNum,
+          column: 1,
+          hazard: 'External link with target="_blank" missing rel="noopener noreferrer"',
+          rule: 'SECURITY_REVERSE_TABNABBING',
+          severity: meta.severity,
+          pillar: meta.pillar,
+          directive: meta.directive
+        });
+      }
+    }
+
+    // Pillar 9: javascript: pseudo-protocol in HTML / Vue templates
+    const hasJsUrl = isTemplateFile && JAVASCRIPT_URL_TEMPLATE_PATTERN.test(lineText);
+    if (hasJsUrl) {
+      const meta = RULE_REGISTRY.SECURITY_JAVASCRIPT_URL;
+      violations.push({
+        filePath: relativePath,
+        line: lineNum,
+        column: 1,
+        hazard: 'javascript: pseudo-protocol detected in template attribute',
+        rule: 'SECURITY_JAVASCRIPT_URL',
+        severity: meta.severity,
+        pillar: meta.pillar,
+        directive: meta.directive
+      });
+    }
+
     // Pillar 8: Non-semantic clickable containers in templates (@click on div/span)
     const hasClickableContainer = isTemplateFile && CLICKABLE_CONTAINER_PATTERN.test(lineText);
     if (hasClickableContainer) {
@@ -244,6 +328,49 @@ export const createExtendedVisitors = ({ relativePath, violations }) => {
           });
         }
       }
+
+      // Pillar 9: External link target="_blank" without rel="noopener noreferrer"
+      const isAnchorElement = tagName === 'a';
+      if (isAnchorElement) {
+        const targetAttr = astPath.node.attributes.find((attr) => t.isJSXAttribute(attr) && attr.name?.name === 'target');
+        let isTargetBlank = false;
+        if (targetAttr) {
+          if (t.isStringLiteral(targetAttr.value)) {
+            isTargetBlank = targetAttr.value.value.trim().toLowerCase() === '_blank';
+          } else if (t.isJSXExpressionContainer(targetAttr.value) && t.isStringLiteral(targetAttr.value.expression)) {
+            isTargetBlank = targetAttr.value.expression.value.trim().toLowerCase() === '_blank';
+          }
+        }
+
+        if (isTargetBlank) {
+          const relAttr = astPath.node.attributes.find((attr) => t.isJSXAttribute(attr) && attr.name?.name === 'rel');
+          let hasRelProtection = false;
+          if (relAttr) {
+            if (t.isStringLiteral(relAttr.value)) {
+              const val = relAttr.value.value.toLowerCase();
+              hasRelProtection = val.includes('noopener') || val.includes('noreferrer');
+            } else if (t.isJSXExpressionContainer(relAttr.value) && t.isStringLiteral(relAttr.value.expression)) {
+              const val = relAttr.value.expression.value.toLowerCase();
+              hasRelProtection = val.includes('noopener') || val.includes('noreferrer');
+            }
+          }
+
+          if (!hasRelProtection) {
+            const line = astPath.node.loc?.start.line || 1;
+            const meta = RULE_REGISTRY.SECURITY_REVERSE_TABNABBING;
+            violations.push({
+              filePath: relativePath,
+              line,
+              column: astPath.node.loc?.start.column || 1,
+              hazard: 'External link with target="_blank" missing rel="noopener noreferrer"',
+              rule: 'SECURITY_REVERSE_TABNABBING',
+              severity: meta.severity,
+              pillar: meta.pillar,
+              directive: meta.directive
+            });
+          }
+        }
+      }
     },
 
     JSXAttribute(astPath) {
@@ -314,6 +441,118 @@ export const createExtendedVisitors = ({ relativePath, violations }) => {
           }
         }
       }
+
+      // Pillar 9: javascript: pseudo-protocol URL in JSX
+      const isUrlAttribute = ['href', 'src', 'action', 'formAction'].includes(attrName);
+      if (isUrlAttribute) {
+        let isJsUrl = false;
+        const val = astPath.node.value;
+        if (t.isStringLiteral(val)) {
+          isJsUrl = JAVASCRIPT_URL_REGEX.test(val.value);
+        } else if (t.isJSXExpressionContainer(val)) {
+          const expr = val.expression;
+          if (t.isStringLiteral(expr)) {
+            isJsUrl = JAVASCRIPT_URL_REGEX.test(expr.value);
+          } else if (t.isTemplateLiteral(expr) && expr.quasis.length > 0) {
+            isJsUrl = JAVASCRIPT_URL_REGEX.test(expr.quasis[0].value.raw);
+          }
+        }
+
+        if (isJsUrl) {
+          const line = astPath.node.loc?.start.line || 1;
+          const meta = RULE_REGISTRY.SECURITY_JAVASCRIPT_URL;
+          violations.push({
+            filePath: relativePath,
+            line,
+            column: astPath.node.loc?.start.column || 1,
+            hazard: `javascript: pseudo-protocol detected in ${attrName} attribute`,
+            rule: 'SECURITY_JAVASCRIPT_URL',
+            severity: meta.severity,
+            pillar: meta.pillar,
+            directive: meta.directive
+          });
+        }
+      }
+    },
+
+    CallExpression(astPath) {
+      const callee = astPath.node.callee;
+
+      // Pillar 9: Dynamic code execution via eval()
+      if (t.isIdentifier(callee) && callee.name === 'eval') {
+        const line = astPath.node.loc?.start.line || 1;
+        const meta = RULE_REGISTRY.SECURITY_DYNAMIC_CODE_EXECUTION;
+        violations.push({
+          filePath: relativePath,
+          line,
+          column: astPath.node.loc?.start.column || 1,
+          hazard: 'Dynamic code execution via eval() detected',
+          rule: 'SECURITY_DYNAMIC_CODE_EXECUTION',
+          severity: meta.severity,
+          pillar: meta.pillar,
+          directive: meta.directive
+        });
+      }
+
+      // Pillar 9: String-based code execution in setTimeout/setInterval
+      if (t.isIdentifier(callee) && (callee.name === 'setTimeout' || callee.name === 'setInterval')) {
+        const firstArg = astPath.node.arguments[0];
+        const isStringExecution = t.isStringLiteral(firstArg) || t.isTemplateLiteral(firstArg);
+        if (isStringExecution) {
+          const line = astPath.node.loc?.start.line || 1;
+          const meta = RULE_REGISTRY.SECURITY_DYNAMIC_CODE_EXECUTION;
+          violations.push({
+            filePath: relativePath,
+            line,
+            column: astPath.node.loc?.start.column || 1,
+            hazard: `String-based dynamic code execution in ${callee.name} detected`,
+            rule: 'SECURITY_DYNAMIC_CODE_EXECUTION',
+            severity: meta.severity,
+            pillar: meta.pillar,
+            directive: meta.directive
+          });
+        }
+      }
+
+      // Pillar 9: Sensitive credential/token logging in console
+      const isConsoleCall = t.isMemberExpression(callee) && t.isIdentifier(callee.object) && callee.object.name === 'console';
+      if (isConsoleCall) {
+        const args = astPath.node.arguments || [];
+        const hasSensitiveArg = args.some(isSensitiveExpression);
+        if (hasSensitiveArg) {
+          const line = astPath.node.loc?.start.line || 1;
+          const meta = RULE_REGISTRY.SECURITY_SENSITIVE_LOGGING;
+          violations.push({
+            filePath: relativePath,
+            line,
+            column: astPath.node.loc?.start.column || 1,
+            hazard: 'Sensitive variable (credential, token, or password) logged to console',
+            rule: 'SECURITY_SENSITIVE_LOGGING',
+            severity: meta.severity,
+            pillar: meta.pillar,
+            directive: meta.directive
+          });
+        }
+      }
+    },
+
+    NewExpression(astPath) {
+      // Pillar 9: Dynamic code execution via new Function()
+      const callee = astPath.node.callee;
+      if (t.isIdentifier(callee) && callee.name === 'Function') {
+        const line = astPath.node.loc?.start.line || 1;
+        const meta = RULE_REGISTRY.SECURITY_DYNAMIC_CODE_EXECUTION;
+        violations.push({
+          filePath: relativePath,
+          line,
+          column: astPath.node.loc?.start.column || 1,
+          hazard: 'Dynamic code execution via new Function() constructor detected',
+          rule: 'SECURITY_DYNAMIC_CODE_EXECUTION',
+          severity: meta.severity,
+          pillar: meta.pillar,
+          directive: meta.directive
+        });
+      }
     },
 
     VariableDeclarator(astPath) {