@soundscript/soundscript 0.1.12 → 0.1.15

package/project-transform/src/frontend/graphql_macro.js

@@ -0,0 +1,174 @@
+import { findTemplateQuasiAtPosition, findWordAtSourcePosition, formatTemplateLiteralWithInterpolationMarkers, keywordTokenSpans, parseMacroHelperCallExpression, } from './embedded_fragment_support.js';
+const GRAPHQL_KEYWORDS = [
+    'fragment',
+    'mutation',
+    'on',
+    'query',
+    'subscription',
+];
+const GRAPHQL_KEYWORD_SET = new Set(GRAPHQL_KEYWORDS);
+const GRAPHQL_COMPLETIONS = [
+    { detail: 'graphql keyword', label: 'query' },
+    { detail: 'graphql keyword', label: 'mutation' },
+    { detail: 'graphql keyword', label: 'subscription' },
+    { detail: 'graphql keyword', label: 'fragment' },
+    { detail: 'graphql keyword', label: 'on' },
+];
+const GRAPHQL_WORD_REGEX = /\b[A-Za-z_][A-Za-z0-9_]*\b/gu;
+function parseGraphqlInterpolationExpression(text, helperName) {
+    const helperCall = parseMacroHelperCallExpression(text, helperName, ['raw']);
+    if (!helperCall) {
+        return { kind: 'variable', expressionText: text };
+    }
+    return {
+        expressionText: helperCall.argumentText,
+        kind: 'raw',
+    };
+}
+function buildGraphqlQueryExpression(template, helperName) {
+    const textParts = [];
+    const variableEntries = [];
+    let variableIndex = 1;
+    textParts.push(JSON.stringify(template.quasis[0]?.text ?? ''));
+    for (let index = 0; index < template.expressions.length; index += 1) {
+        const interpolation = parseGraphqlInterpolationExpression(template.expressions[index].text(), helperName);
+        switch (interpolation.kind) {
+            case 'raw':
+                textParts.push(`String(${interpolation.expressionText})`);
+                break;
+            case 'variable': {
+                const variableName = `ss_graphql_${variableIndex}`;
+                textParts.push(JSON.stringify(`$${variableName}`));
+                variableEntries.push(`${JSON.stringify(variableName)}: ${interpolation.expressionText}`);
+                variableIndex += 1;
+                break;
+            }
+        }
+        textParts.push(JSON.stringify(template.quasis[index + 1]?.text ?? ''));
+    }
+    return {
+        queryExpression: textParts.filter((part) => part.length > 0).join(' + ') || '""',
+        variableEntries,
+    };
+}
+function graphqlHover(template, sourcePosition) {
+    const quasi = findTemplateQuasiAtPosition(template, sourcePosition);
+    if (!quasi) {
+        return null;
+    }
+    const word = findWordAtSourcePosition(quasi, sourcePosition, GRAPHQL_WORD_REGEX);
+    if (word && GRAPHQL_KEYWORD_SET.has(word.word)) {
+        return {
+            contents: `GraphQL keyword \`${word.word}\`.`,
+        };
+    }
+    return {
+        contents: 'Embedded GraphQL fragment. `${...}` expressions become GraphQL variable placeholders by default.',
+    };
+}
+function graphqlCompletions(template, sourcePosition) {
+    const quasi = findTemplateQuasiAtPosition(template, sourcePosition);
+    if (!quasi) {
+        return [];
+    }
+    const prefix = quasi.text
+        .slice(0, Math.max(0, sourcePosition - quasi.span.start))
+        .match(/[A-Za-z_]*$/u)?.[0] ?? '';
+    const loweredPrefix = prefix.toLowerCase();
+    return GRAPHQL_COMPLETIONS.filter((item) => loweredPrefix.length === 0 || item.label.toLowerCase().startsWith(loweredPrefix));
+}
+function pushGraphqlLine(lines, indentLevel, text) {
+    const normalized = text.trim();
+    if (normalized.length === 0) {
+        return;
+    }
+    if (indentLevel > 0 && normalized.includes(' ')) {
+        const firstWord = normalized.match(/^[A-Za-z_][A-Za-z0-9_]*/u)?.[0] ?? null;
+        if (firstWord &&
+            normalized[firstWord.length] === ' ' &&
+            !GRAPHQL_KEYWORD_SET.has(firstWord)) {
+            const remainder = normalized.slice(firstWord.length).trim();
+            lines.push(`${'  '.repeat(indentLevel)}${firstWord}`);
+            if (remainder.length > 0) {
+                lines.push(`${'  '.repeat(indentLevel)}${remainder}`);
+            }
+            return;
+        }
+    }
+    lines.push(`${'  '.repeat(indentLevel)}${normalized}`);
+}
+function formatGraphqlText(text) {
+    const compact = text
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line, index, lines) => line.length > 0 || (index > 0 && index < lines.length - 1))
+        .join(' ')
+        .replace(/\s+/gu, ' ')
+        .replace(/:\s*/gu, ': ')
+        .replace(/\s*([{}])\s*/gu, '$1')
+        .trim();
+    const lines = [];
+    let current = '';
+    let indentLevel = 0;
+    for (const char of compact) {
+        if (char === '{') {
+            const line = current.trim();
+            current = '';
+            pushGraphqlLine(lines, indentLevel, `${line}${line.length > 0 ? ' ' : ''}{`);
+            indentLevel += 1;
+            continue;
+        }
+        if (char === '}') {
+            pushGraphqlLine(lines, indentLevel, current);
+            current = '';
+            indentLevel = Math.max(0, indentLevel - 1);
+            lines.push(`${'  '.repeat(indentLevel)}}`);
+            continue;
+        }
+        current += char;
+    }
+    pushGraphqlLine(lines, indentLevel, current);
+    return lines.join('\n');
+}
+function formatGraphqlTemplateLiteral(template, helperName, formatExpression) {
+    return formatTemplateLiteralWithInterpolationMarkers(template, {
+        expressionTextForIndex(index) {
+            const interpolation = parseGraphqlInterpolationExpression(template.expressions[index].text(), helperName);
+            return interpolation.kind === 'variable'
+                ? template.expressions[index].text()
+                : `${helperName}.raw(${interpolation.expressionText})`;
+        },
+        formatCombinedText: formatGraphqlText,
+        formatExpression,
+        markerPrefix: '__SS_GRAPHQL_HOLE_',
+    });
+}
+function createGraphqlEmbeddedFragment(template, helperName) {
+    return {
+        completions(sourcePosition) {
+            return graphqlCompletions(template, sourcePosition);
+        },
+        format(ctx) {
+            return formatGraphqlTemplateLiteral(template, helperName, ctx.formatExpression);
+        },
+        hover(sourcePosition) {
+            return graphqlHover(template, sourcePosition);
+        },
+        language: 'graphql',
+        semanticTokens: keywordTokenSpans(template.quasis, GRAPHQL_WORD_REGEX, (word) => GRAPHQL_KEYWORD_SET.has(word)),
+        span: template.span,
+    };
+}
+export function graphqlFragments(ctx) {
+    const template = ctx.syntax.template(0);
+    return template ? [createGraphqlEmbeddedFragment(template, ctx.name)] : [];
+}
+export function expandGraphqlMacro(ctx) {
+    const template = ctx.syntax.template(0);
+    if (!template) {
+        ctx.error('graphql requires a template literal operand.');
+    }
+    const { queryExpression, variableEntries } = buildGraphqlQueryExpression(template, ctx.name);
+    const variablesExpression = variableEntries.length > 0 ? `{ ${variableEntries.join(', ')} }` : '{}';
+    return ctx.output.expr(ctx.quote.expr `({ query: ${queryExpression}, variables: ${variablesExpression} })`);
+}

package/project-transform/src/frontend/graphql_macro.ts

@@ -0,0 +1,253 @@
+import type {
+  MacroCompletionItem,
+  MacroContext,
+  MacroEmbeddedFragment,
+  MacroTemplateOperand,
+} from './macro_api.ts';
+import {
+  findTemplateQuasiAtPosition,
+  findWordAtSourcePosition,
+  formatTemplateLiteralWithInterpolationMarkers,
+  keywordTokenSpans,
+  parseMacroHelperCallExpression,
+} from './embedded_fragment_support.ts';
+
+const GRAPHQL_KEYWORDS = [
+  'fragment',
+  'mutation',
+  'on',
+  'query',
+  'subscription',
+] as const;
+
+const GRAPHQL_KEYWORD_SET = new Set(GRAPHQL_KEYWORDS);
+const GRAPHQL_COMPLETIONS: readonly MacroCompletionItem[] = [
+  { detail: 'graphql keyword', label: 'query' },
+  { detail: 'graphql keyword', label: 'mutation' },
+  { detail: 'graphql keyword', label: 'subscription' },
+  { detail: 'graphql keyword', label: 'fragment' },
+  { detail: 'graphql keyword', label: 'on' },
+] as const;
+
+const GRAPHQL_WORD_REGEX = /\b[A-Za-z_][A-Za-z0-9_]*\b/gu;
+
+type GraphqlInterpolation =
+  | { readonly expressionText: string; readonly kind: 'raw' }
+  | { readonly expressionText: string; readonly kind: 'variable' };
+
+function parseGraphqlInterpolationExpression(
+  text: string,
+  helperName: string,
+): GraphqlInterpolation {
+  const helperCall = parseMacroHelperCallExpression(text, helperName, ['raw']);
+  if (!helperCall) {
+    return { kind: 'variable', expressionText: text };
+  }
+
+  return {
+    expressionText: helperCall.argumentText,
+    kind: 'raw',
+  };
+}
+
+function buildGraphqlQueryExpression(
+  template: MacroTemplateOperand,
+  helperName: string,
+): { readonly queryExpression: string; readonly variableEntries: readonly string[] } {
+  const textParts: string[] = [];
+  const variableEntries: string[] = [];
+  let variableIndex = 1;
+
+  textParts.push(JSON.stringify(template.quasis[0]?.text ?? ''));
+  for (let index = 0; index < template.expressions.length; index += 1) {
+    const interpolation = parseGraphqlInterpolationExpression(
+      template.expressions[index]!.text(),
+      helperName,
+    );
+    switch (interpolation.kind) {
+      case 'raw':
+        textParts.push(`String(${interpolation.expressionText})`);
+        break;
+      case 'variable': {
+        const variableName = `ss_graphql_${variableIndex}`;
+        textParts.push(JSON.stringify(`$${variableName}`));
+        variableEntries.push(`${JSON.stringify(variableName)}: ${interpolation.expressionText}`);
+        variableIndex += 1;
+        break;
+      }
+    }
+
+    textParts.push(JSON.stringify(template.quasis[index + 1]?.text ?? ''));
+  }
+
+  return {
+    queryExpression: textParts.filter((part) => part.length > 0).join(' + ') || '""',
+    variableEntries,
+  };
+}
+
+function graphqlHover(
+  template: MacroTemplateOperand,
+  sourcePosition: number,
+): { readonly contents: string } | null {
+  const quasi = findTemplateQuasiAtPosition(template, sourcePosition);
+  if (!quasi) {
+    return null;
+  }
+
+  const word = findWordAtSourcePosition(quasi, sourcePosition, GRAPHQL_WORD_REGEX);
+  if (word && GRAPHQL_KEYWORD_SET.has(word.word as typeof GRAPHQL_KEYWORDS[number])) {
+    return {
+      contents: `GraphQL keyword \`${word.word}\`.`,
+    };
+  }
+
+  return {
+    contents: 'Embedded GraphQL fragment. `${...}` expressions become GraphQL variable placeholders by default.',
+  };
+}
+
+function graphqlCompletions(
+  template: MacroTemplateOperand,
+  sourcePosition: number,
+): readonly MacroCompletionItem[] {
+  const quasi = findTemplateQuasiAtPosition(template, sourcePosition);
+  if (!quasi) {
+    return [];
+  }
+
+  const prefix = quasi.text
+    .slice(0, Math.max(0, sourcePosition - quasi.span.start))
+    .match(/[A-Za-z_]*$/u)?.[0] ?? '';
+  const loweredPrefix = prefix.toLowerCase();
+  return GRAPHQL_COMPLETIONS.filter((item) =>
+    loweredPrefix.length === 0 || item.label.toLowerCase().startsWith(loweredPrefix)
+  );
+}
+
+function pushGraphqlLine(lines: string[], indentLevel: number, text: string): void {
+  const normalized = text.trim();
+  if (normalized.length === 0) {
+    return;
+  }
+
+  if (indentLevel > 0 && normalized.includes(' ')) {
+    const firstWord = normalized.match(/^[A-Za-z_][A-Za-z0-9_]*/u)?.[0] ?? null;
+    if (
+      firstWord &&
+      normalized[firstWord.length] === ' ' &&
+      !GRAPHQL_KEYWORD_SET.has(firstWord as typeof GRAPHQL_KEYWORDS[number])
+    ) {
+      const remainder = normalized.slice(firstWord.length).trim();
+      lines.push(`${'  '.repeat(indentLevel)}${firstWord}`);
+      if (remainder.length > 0) {
+        lines.push(`${'  '.repeat(indentLevel)}${remainder}`);
+      }
+      return;
+    }
+  }
+
+  lines.push(`${'  '.repeat(indentLevel)}${normalized}`);
+}
+
+function formatGraphqlText(text: string): string {
+  const compact = text
+    .split('\n')
+    .map((line) => line.trim())
+    .filter((line, index, lines) => line.length > 0 || (index > 0 && index < lines.length - 1))
+    .join(' ')
+    .replace(/\s+/gu, ' ')
+    .replace(/:\s*/gu, ': ')
+    .replace(/\s*([{}])\s*/gu, '$1')
+    .trim();
+
+  const lines: string[] = [];
+  let current = '';
+  let indentLevel = 0;
+
+  for (const char of compact) {
+    if (char === '{') {
+      const line = current.trim();
+      current = '';
+      pushGraphqlLine(lines, indentLevel, `${line}${line.length > 0 ? ' ' : ''}{`);
+      indentLevel += 1;
+      continue;
+    }
+
+    if (char === '}') {
+      pushGraphqlLine(lines, indentLevel, current);
+      current = '';
+      indentLevel = Math.max(0, indentLevel - 1);
+      lines.push(`${'  '.repeat(indentLevel)}}`);
+      continue;
+    }
+
+    current += char;
+  }
+
+  pushGraphqlLine(lines, indentLevel, current);
+  return lines.join('\n');
+}
+
+function formatGraphqlTemplateLiteral(
+  template: MacroTemplateOperand,
+  helperName: string,
+  formatExpression: (text: string) => string,
+): string {
+  return formatTemplateLiteralWithInterpolationMarkers(template, {
+    expressionTextForIndex(index) {
+      const interpolation = parseGraphqlInterpolationExpression(
+        template.expressions[index]!.text(),
+        helperName,
+      );
+      return interpolation.kind === 'variable'
+        ? template.expressions[index]!.text()
+        : `${helperName}.raw(${interpolation.expressionText})`;
+    },
+    formatCombinedText: formatGraphqlText,
+    formatExpression,
+    markerPrefix: '__SS_GRAPHQL_HOLE_',
+  });
+}
+
+function createGraphqlEmbeddedFragment(
+  template: MacroTemplateOperand,
+  helperName: string,
+): MacroEmbeddedFragment {
+  return {
+    completions(sourcePosition) {
+      return graphqlCompletions(template, sourcePosition);
+    },
+    format(ctx) {
+      return formatGraphqlTemplateLiteral(template, helperName, ctx.formatExpression);
+    },
+    hover(sourcePosition) {
+      return graphqlHover(template, sourcePosition);
+    },
+    language: 'graphql',
+    semanticTokens: keywordTokenSpans(
+      template.quasis,
+      GRAPHQL_WORD_REGEX,
+      (word) => GRAPHQL_KEYWORD_SET.has(word as typeof GRAPHQL_KEYWORDS[number]),
+    ),
+    span: template.span,
+  };
+}
+
+export function graphqlFragments(ctx: MacroContext): readonly MacroEmbeddedFragment[] {
+  const template = ctx.syntax.template(0);
+  return template ? [createGraphqlEmbeddedFragment(template, ctx.name)] : [];
+}
+
+export function expandGraphqlMacro(ctx: MacroContext) {
+  const template = ctx.syntax.template(0);
+  if (!template) {
+    ctx.error('graphql requires a template literal operand.');
+  }
+
+  const { queryExpression, variableEntries } = buildGraphqlQueryExpression(template, ctx.name);
+  const variablesExpression = variableEntries.length > 0 ? `{ ${variableEntries.join(', ')} }` : '{}';
+  return ctx.output.expr(
+    ctx.quote.expr`({ query: ${queryExpression}, variables: ${variablesExpression} })`,
+  );
+}

package/project-transform/src/frontend/hash_context.js

@@ -0,0 +1,83 @@
+import ts from 'typescript';
+function inClassBody(context) {
+    const frame = context.braceStack.at(-1);
+    return frame?.kind === 'class-body';
+}
+function isPrivateMemberDeclarationContext(context) {
+    if (!inClassBody(context)) {
+        return false;
+    }
+    switch (context.previousSignificantToken) {
+        case ts.SyntaxKind.OpenBraceToken:
+        case ts.SyntaxKind.CloseBraceToken:
+        case ts.SyntaxKind.SemicolonToken:
+        case ts.SyntaxKind.PublicKeyword:
+        case ts.SyntaxKind.PrivateKeyword:
+        case ts.SyntaxKind.ProtectedKeyword:
+        case ts.SyntaxKind.StaticKeyword:
+        case ts.SyntaxKind.ReadonlyKeyword:
+        case ts.SyntaxKind.OverrideKeyword:
+        case ts.SyntaxKind.AsyncKeyword:
+        case ts.SyntaxKind.GetKeyword:
+        case ts.SyntaxKind.SetKeyword:
+        case ts.SyntaxKind.AsteriskToken:
+            return true;
+        default:
+            return false;
+    }
+}
+function canStartExpressionOrStatement(context) {
+    const previousToken = context.previousSignificantToken;
+    switch (previousToken) {
+        case undefined:
+        case ts.SyntaxKind.OpenParenToken:
+        case ts.SyntaxKind.OpenBracketToken:
+        case ts.SyntaxKind.OpenBraceToken:
+        case ts.SyntaxKind.CommaToken:
+        case ts.SyntaxKind.SemicolonToken:
+        case ts.SyntaxKind.ColonToken:
+        case ts.SyntaxKind.EqualsToken:
+        case ts.SyntaxKind.EqualsGreaterThanToken:
+        case ts.SyntaxKind.ReturnKeyword:
+        case ts.SyntaxKind.ThrowKeyword:
+        case ts.SyntaxKind.QuestionToken:
+        case ts.SyntaxKind.BarToken:
+        case ts.SyntaxKind.BarBarToken:
+        case ts.SyntaxKind.AmpersandToken:
+        case ts.SyntaxKind.AmpersandAmpersandToken:
+        case ts.SyntaxKind.CaretToken:
+        case ts.SyntaxKind.PlusToken:
+        case ts.SyntaxKind.MinusToken:
+        case ts.SyntaxKind.AsteriskToken:
+        case ts.SyntaxKind.SlashToken:
+        case ts.SyntaxKind.PercentToken:
+        case ts.SyntaxKind.ExclamationToken:
+        case ts.SyntaxKind.TildeToken:
+        case ts.SyntaxKind.AwaitKeyword:
+        case ts.SyntaxKind.CaseKeyword:
+        case ts.SyntaxKind.OfKeyword:
+        case ts.SyntaxKind.InKeyword:
+        case ts.SyntaxKind.QuestionQuestionToken:
+            return true;
+        case ts.SyntaxKind.CloseBraceToken:
+            return context.hasLineBreakBeforeHash;
+        default:
+            return false;
+    }
+}
+export function classifyHashContext(context) {
+    if (context.insideParameterList &&
+        (context.previousSignificantToken === ts.SyntaxKind.OpenParenToken ||
+            context.previousSignificantToken === ts.SyntaxKind.CommaToken)) {
+        return { kind: 'invalid-hash', reason: 'illegal-context' };
+    }
+    if (context.previousSignificantToken === ts.SyntaxKind.DotToken ||
+        context.previousSignificantToken === ts.SyntaxKind.QuestionDotToken ||
+        isPrivateMemberDeclarationContext(context)) {
+        return { kind: 'private-name' };
+    }
+    if (canStartExpressionOrStatement(context)) {
+        return { kind: 'macro-start' };
+    }
+    return { kind: 'invalid-hash', reason: 'illegal-context' };
+}

package/project-transform/src/frontend/hash_context.ts

@@ -0,0 +1,113 @@
+import ts from 'typescript';
+
+type PreviousToken = ts.SyntaxKind | undefined;
+
+export interface BraceFrame {
+  kind: 'block' | 'class-body';
+}
+
+export interface HashContext {
+  braceStack: readonly BraceFrame[];
+  hasLineBreakBeforeHash: boolean;
+  insideParameterList: boolean;
+  previousSignificantToken: PreviousToken;
+}
+
+function inClassBody(context: HashContext): boolean {
+  const frame = context.braceStack.at(-1);
+  return frame?.kind === 'class-body';
+}
+
+function isPrivateMemberDeclarationContext(context: HashContext): boolean {
+  if (!inClassBody(context)) {
+    return false;
+  }
+
+  switch (context.previousSignificantToken) {
+    case ts.SyntaxKind.OpenBraceToken:
+    case ts.SyntaxKind.CloseBraceToken:
+    case ts.SyntaxKind.SemicolonToken:
+    case ts.SyntaxKind.PublicKeyword:
+    case ts.SyntaxKind.PrivateKeyword:
+    case ts.SyntaxKind.ProtectedKeyword:
+    case ts.SyntaxKind.StaticKeyword:
+    case ts.SyntaxKind.ReadonlyKeyword:
+    case ts.SyntaxKind.OverrideKeyword:
+    case ts.SyntaxKind.AsyncKeyword:
+    case ts.SyntaxKind.GetKeyword:
+    case ts.SyntaxKind.SetKeyword:
+    case ts.SyntaxKind.AsteriskToken:
+      return true;
+    default:
+      return false;
+  }
+}
+
+function canStartExpressionOrStatement(context: HashContext): boolean {
+  const previousToken = context.previousSignificantToken;
+  switch (previousToken) {
+    case undefined:
+    case ts.SyntaxKind.OpenParenToken:
+    case ts.SyntaxKind.OpenBracketToken:
+    case ts.SyntaxKind.OpenBraceToken:
+    case ts.SyntaxKind.CommaToken:
+    case ts.SyntaxKind.SemicolonToken:
+    case ts.SyntaxKind.ColonToken:
+    case ts.SyntaxKind.EqualsToken:
+    case ts.SyntaxKind.EqualsGreaterThanToken:
+    case ts.SyntaxKind.ReturnKeyword:
+    case ts.SyntaxKind.ThrowKeyword:
+    case ts.SyntaxKind.QuestionToken:
+    case ts.SyntaxKind.BarToken:
+    case ts.SyntaxKind.BarBarToken:
+    case ts.SyntaxKind.AmpersandToken:
+    case ts.SyntaxKind.AmpersandAmpersandToken:
+    case ts.SyntaxKind.CaretToken:
+    case ts.SyntaxKind.PlusToken:
+    case ts.SyntaxKind.MinusToken:
+    case ts.SyntaxKind.AsteriskToken:
+    case ts.SyntaxKind.SlashToken:
+    case ts.SyntaxKind.PercentToken:
+    case ts.SyntaxKind.ExclamationToken:
+    case ts.SyntaxKind.TildeToken:
+    case ts.SyntaxKind.AwaitKeyword:
+    case ts.SyntaxKind.CaseKeyword:
+    case ts.SyntaxKind.OfKeyword:
+    case ts.SyntaxKind.InKeyword:
+    case ts.SyntaxKind.QuestionQuestionToken:
+      return true;
+    case ts.SyntaxKind.CloseBraceToken:
+      return context.hasLineBreakBeforeHash;
+    default:
+      return false;
+  }
+}
+
+export type HashClassification =
+  | { kind: 'macro-start' }
+  | { kind: 'private-name' }
+  | { kind: 'invalid-hash'; reason: 'illegal-context' };
+
+export function classifyHashContext(context: HashContext): HashClassification {
+  if (
+    context.insideParameterList &&
+    (context.previousSignificantToken === ts.SyntaxKind.OpenParenToken ||
+      context.previousSignificantToken === ts.SyntaxKind.CommaToken)
+  ) {
+    return { kind: 'invalid-hash', reason: 'illegal-context' };
+  }
+
+  if (
+    context.previousSignificantToken === ts.SyntaxKind.DotToken ||
+    context.previousSignificantToken === ts.SyntaxKind.QuestionDotToken ||
+    isPrivateMemberDeclarationContext(context)
+  ) {
+    return { kind: 'private-name' };
+  }
+
+  if (canStartExpressionOrStatement(context)) {
+    return { kind: 'macro-start' };
+  }
+
+  return { kind: 'invalid-hash', reason: 'illegal-context' };
+}