driftjs-compiler 0.0.4 → 0.0.6

package/tests/parser.test.ts

@@ -1,302 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { DriftLexer } from '../src/lexer.js';
-import { DriftParser } from '../src/parser.js';
-import {
-  ASTNodeType,
-  ElementNode,
-  DriftParserError,
-  DriftLexerError,
-  TokenType,
-  Token,
-  TextNode,
-} from '../types/index.js';
-
-describe('DriftParser', () => {
-  it('parses empty templates', () => {
-    const parser = new DriftParser(new DriftLexer(''));
-    const ast = parser.parse();
-
-    expect(ast.type).toBe(ASTNodeType.Program);
-    expect(ast.body).toEqual([]);
-  });
-
-  it('lets the parser drive token consumption lazily', () => {
-    const lexer = new DriftLexer('<div><span>Hello</span></div>');
-    const parser = new DriftParser(lexer);
-
-    expect(lexer.getEmittedTokenCount()).toBe(0);
-
-    const ast = parser.parse();
-
-    expect(ast.body).toHaveLength(1);
-    expect(lexer.getEmittedTokenCount()).toBeGreaterThan(0);
-  });
-
-  it('parses deeply nested element structures', () => {
-    const parser = new DriftParser(
-      new DriftLexer('<div><main><article><section><p>{text}</p></section></article></main></div>')
-    );
-    const ast = parser.parse();
-
-    expect(ast.body.length).toBe(1);
-    let current = ast.body[0] as ElementNode;
-    expect(current.tagName).toBe('div');
-
-    current = current.children[0] as ElementNode;
-    expect(current.tagName).toBe('main');
-
-    current = current.children[0] as ElementNode;
-    expect(current.tagName).toBe('article');
-
-    current = current.children[0] as ElementNode;
-    expect(current.tagName).toBe('section');
-
-    current = current.children[0] as ElementNode;
-    expect(current.tagName).toBe('p');
-    expect(current.children[0]?.type).toBe(ASTNodeType.Interpolation);
-  });
-
-  it('parses multiple root-level elements, text, and comments', () => {
-    const parser = new DriftParser(
-      new DriftLexer('<!-- Root 1 --><div>One</div><!-- Root 2 --><span>Two</span>')
-    );
-    const ast = parser.parse();
-
-    expect(ast.body.length).toBe(4);
-    expect(ast.body[0]?.type).toBe(ASTNodeType.Comment);
-    expect(ast.body[1]?.type).toBe(ASTNodeType.Element);
-    expect(ast.body[2]?.type).toBe(ASTNodeType.Comment);
-    expect(ast.body[3]?.type).toBe(ASTNodeType.Element);
-  });
-
-  it('parses attributes of mixed kinds', () => {
-    const parser = new DriftParser(
-      new DriftLexer('<input type="checkbox" checked id="terms" data-bind={isBound} />')
-    );
-    const ast = parser.parse();
-
-    const inputNode = ast.body[0] as ElementNode;
-    expect(inputNode.isSelfClosing).toBe(true);
-    expect(inputNode.attributes.length).toBe(4);
-    expect(inputNode.attributes[0]).toMatchObject({ name: 'type', value: 'checkbox' });
-    expect(inputNode.attributes[1]).toMatchObject({ name: 'checked', value: null });
-    expect(inputNode.attributes[2]).toMatchObject({ name: 'id', value: 'terms' });
-    expect(inputNode.attributes[3]?.name).toBe('data-bind');
-    expect(typeof inputNode.attributes[3]?.value).toBe('object');
-  });
-
-  it('parses script tag content as a raw text child', () => {
-    const parser = new DriftParser(
-      new DriftLexer('<script>if (a < b) { console.log("ok"); }</script>')
-    );
-    const ast = parser.parse();
-
-    const scriptElement = ast.body[0] as ElementNode;
-    expect(scriptElement.tagName).toBe('script');
-    expect(scriptElement.children.length).toBe(1);
-    const scriptText = scriptElement.children[0] as TextNode;
-    expect(scriptText.type).toBe(ASTNodeType.Text);
-    expect(scriptText.content).toBe('if (a < b) { console.log("ok"); }');
-  });
-
-  it('parses complex JS interpolations into raw expression strings', () => {
-    const parser = new DriftParser(
-      new DriftLexer('<div>{ isTrue ? "yes" : "no" }</div><span>{ (x) => x * 2 }</span><p>{ user?.name ?? "Guest" }</p>')
-    );
-    const ast = parser.parse();
-
-    const div = ast.body[0] as ElementNode;
-    const divInterpolation = div.children[0] as any;
-    expect(divInterpolation.type).toBe(ASTNodeType.Interpolation);
-    expect(divInterpolation.expression).toBe(' isTrue ? "yes" : "no" ');
-
-    const span = ast.body[1] as ElementNode;
-    const spanInterpolation = span.children[0] as any;
-    expect(spanInterpolation.expression).toBe(' (x) => x * 2 ');
-  });
-
-  it('parses interpolated attribute values as raw expression strings', () => {
-    const parser = new DriftParser(
-      new DriftLexer('<button onclick={ (e) => handleClick(e) } />')
-    );
-    const ast = parser.parse();
-
-    const button = ast.body[0] as ElementNode;
-    const attr = button.attributes[0];
-    expect(attr?.name).toBe('onclick');
-
-    const interpolationValue = attr?.value as any;
-    expect(interpolationValue.type).toBe(ASTNodeType.Interpolation);
-    expect(interpolationValue.expression).toBe(' (e) => handleClick(e) ');
-  });
-
-  it('throws when an unexpected closing tag appears at the top level', () => {
-    const parser = new DriftParser(new DriftLexer('</div>'));
-    expect(() => parser.parse()).toThrow(DriftParserError);
-  });
-
-  it('throws when an attribute value is missing after =', () => {
-    const parser = new DriftParser(new DriftLexer('<div class=></div>'));
-    expect(() => parser.parse()).toThrow(DriftLexerError);
-  });
-
-  it('throws on mismatched nested closing tags', () => {
-    const parser = new DriftParser(new DriftLexer('<div><span>Content</div></span>'));
-    expect(() => parser.parse()).toThrow(DriftParserError);
-  });
-
-  it('throws when the closing bracket is missing in a manual token stream', () => {
-    const dummyLoc = { line: 1, column: 1, offset: 0 };
-    const tokens: Token[] = [
-      { type: TokenType.TagOpen, value: '<', loc: { start: dummyLoc, end: dummyLoc } },
-      { type: TokenType.Identifier, value: 'div', loc: { start: dummyLoc, end: dummyLoc } },
-      { type: TokenType.Text, value: 'Hello', loc: { start: dummyLoc, end: dummyLoc } },
-      { type: TokenType.EOF, value: '', loc: { start: dummyLoc, end: dummyLoc } },
-    ];
-
-    const parser = new DriftParser(tokens);
-    expect(() => parser.parse()).toThrow(DriftParserError);
-  });
-
-  it('parses @if, @else if, and @else directives cleanly', () => {
-    const parser = new DriftParser(
-      new DriftLexer('@if isLoggedIn { <span>Welcome back</span> } @else if isGuest { <span>Welcome guest</span> } @else { <span>Please log in</span> }')
-    );
-    const ast = parser.parse();
-
-    expect(ast.body).toHaveLength(1);
-    const ifNode = ast.body[0] as any;
-    expect(ifNode.type).toBe(ASTNodeType.If);
-    expect(ifNode.test).toBe('isLoggedIn');
-    const firstSpan = ifNode.consequent.find((n: any) => n.type === ASTNodeType.Element);
-    expect(firstSpan.tagName).toBe('span');
-
-    // Alternate is nested IfNode for @else if
-    const elseIfNode = ifNode.alternate as any;
-    expect(elseIfNode.type).toBe(ASTNodeType.If);
-    expect(elseIfNode.test).toBe('isGuest');
-
-    // Else branch is array of nodes in alternate of nested IfNode
-    expect(Array.isArray(elseIfNode.alternate)).toBe(true);
-    const elseSpan = elseIfNode.alternate.find((n: any) => n.type === ASTNodeType.Element);
-    expect(elseSpan.tagName).toBe('span');
-  });
-
-  it('parses @for directives cleanly', () => {
-    const parser = new DriftParser(
-      new DriftLexer('@for (item, index) in items { <li>{item}</li> }')
-    );
-    const ast = parser.parse();
-
-    expect(ast.body).toHaveLength(1);
-    const forNode = ast.body[0] as any;
-    expect(forNode.type).toBe(ASTNodeType.For);
-    expect(forNode.item).toBe('item');
-    expect(forNode.index).toBe('index');
-    expect(forNode.iterable).toBe('items');
-    const forLi = forNode.body.find((n: any) => n.type === ASTNodeType.Element);
-    expect(forLi.tagName).toBe('li');
-  });
-
-  it('parses @for directive without index with index set to null', () => {
-    const parser = new DriftParser(
-      new DriftLexer('@for item in items { <li>{item}</li> }')
-    );
-    const ast = parser.parse();
-
-    const forNode = ast.body[0] as any;
-    expect(forNode.item).toBe('item');
-    expect(forNode.index).toBeNull();
-  });
-
-  it('parses @switch, @case, and @default directives cleanly', () => {
-    const parser = new DriftParser(
-      new DriftLexer('@switch userRole { @case "admin" { <p>Admin</p> } @case "user" { <p>User</p> } @default { <p>Unknown</p> } }')
-    );
-    const ast = parser.parse();
-
-    expect(ast.body).toHaveLength(1);
-    const switchNode = ast.body[0] as any;
-    expect(switchNode.type).toBe(ASTNodeType.Switch);
-    expect(switchNode.discriminant).toBe('userRole');
-    expect(switchNode.cases).toHaveLength(3);
-    expect(switchNode.cases[0].expression).toBe('"admin"');
-    expect(switchNode.cases[1].expression).toBe('"user"');
-    expect(switchNode.cases[2].expression).toBeNull();
-  });
-
-  it('parses deeply nested mixed control flows (nested @if inside @for inside @switch)', () => {
-    const input = `
-      @switch status {
-        @case "active" {
-          @for (item, idx) in list {
-            @if item.isVisible {
-              <div>{idx}: {item.title}</div>
-            }
-          }
-        }
-        @default {
-          <p>No active items</p>
-        }
-      }
-    `;
-    const parser = new DriftParser(new DriftLexer(input));
-    const ast = parser.parse();
-
-    const switchNode = ast.body.find((n: any) => n.type === ASTNodeType.Switch) as any;
-    expect(switchNode).toBeDefined();
-    expect(switchNode.type).toBe(ASTNodeType.Switch);
-    expect(switchNode.discriminant).toBe('status');
-
-    const activeCase = switchNode.cases[0];
-    const forNode = activeCase.body.find((n: any) => n.type === ASTNodeType.For);
-    expect(forNode.item).toBe('item');
-    expect(forNode.index).toBe('idx');
-
-    const ifNode = forNode.body.find((n: any) => n.type === ASTNodeType.If);
-    expect(ifNode.test).toBe('item.isVisible');
-  });
-
-  it('throws on unclosed directive blocks', () => {
-    const parser = new DriftParser(new DriftLexer('@if isLoggedIn { <div>Hello</div>'));
-    expect(() => parser.parse()).toThrow(DriftParserError);
-  });
-
-  it('throws on invalid @for header syntax missing in keyword', () => {
-    const parser = new DriftParser(new DriftLexer('@for item items { <li>{item}</li> }'));
-    expect(() => parser.parse()).toThrow(DriftParserError);
-  });
-
-  it('throws on invalid content inside @switch blocks that is not @case or @default', () => {
-    const parser = new DriftParser(new DriftLexer('@switch mode { <div>invalid direct child</div> }'));
-    expect(() => parser.parse()).toThrow(DriftParserError);
-  });
-
-  it('automatically parses HTML void elements as self-closing without requiring explicit closing tags', () => {
-    const parser = new DriftParser(
-      new DriftLexer('<div><input type="text"><img src="test.jpg"><br><hr></div>')
-    );
-    const ast = parser.parse();
-
-    expect(ast.body).toHaveLength(1);
-    const divNode = ast.body[0] as any;
-    expect(divNode.tagName).toBe('div');
-    expect(divNode.children).toHaveLength(4);
-
-    const inputNode = divNode.children[0];
-    expect(inputNode.tagName).toBe('input');
-    expect(inputNode.isSelfClosing).toBe(true);
-
-    const imgNode = divNode.children[1];
-    expect(imgNode.tagName).toBe('img');
-    expect(imgNode.isSelfClosing).toBe(true);
-
-    const brNode = divNode.children[2];
-    expect(brNode.tagName).toBe('br');
-    expect(brNode.isSelfClosing).toBe(true);
-
-    const hrNode = divNode.children[3];
-    expect(hrNode.tagName).toBe('hr');
-    expect(hrNode.isSelfClosing).toBe(true);
-  });
-});

package/tests/transformer.test.ts

@@ -1,110 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { DriftLexer } from '../src/lexer.js';
-import { DriftParser } from '../src/parser.js';
-import { DriftTransformer } from '../src/transformer.js';
-import { ASTNodeType, ElementNode, TextNode, InterpolationNode } from '../types/index.js';
-
-describe('DriftTransformer', () => {
-  it('should strip redundant whitespace and newline text nodes between elements', () => {
-    const input = `
-      <div>
-        <span>Hello</span>
-      </div>
-    `;
-    const lexer = new DriftLexer(input);
-    const parser = new DriftParser(lexer);
-    const rawAst = parser.parse();
-
-    const transformer = new DriftTransformer(rawAst);
-    const transformedAst = transformer.transform();
-
-    // Top-level body should contain only 1 ElementNode (div), whitespace TextNodes removed
-    expect(transformedAst.body.length).toBe(1);
-    const div = transformedAst.body[0] as ElementNode;
-    expect(div.tagName).toBe('div');
-
-    // div.children should contain only 1 ElementNode (span), whitespace TextNodes removed
-    expect(div.children.length).toBe(1);
-    const span = div.children[0] as ElementNode;
-    expect(span.tagName).toBe('span');
-    expect((span.children[0] as TextNode).content).toBe('Hello');
-  });
-
-  it('should transform raw interpolation strings into Acorn JS AST nodes', () => {
-    const input = '<h1>{ user.name }</h1>';
-    const lexer = new DriftLexer(input);
-    const parser = new DriftParser(lexer);
-    const rawAst = parser.parse();
-
-    const transformer = new DriftTransformer(rawAst);
-    const transformedAst = transformer.transform();
-
-    const h1 = transformedAst.body[0] as ElementNode;
-    const interp = h1.children[0] as InterpolationNode;
-    expect(interp.type).toBe(ASTNodeType.Interpolation);
-
-    const expr = interp.expression as any;
-    expect(expr.type).toBe('MemberExpression');
-    expect(expr.object.name).toBe('user');
-    expect(expr.property.name).toBe('name');
-  });
-
-  it('should transform script tag text child into stripped Acorn JS statement AST', () => {
-    const input = '<script>let count = 0;</script>';
-    const lexer = new DriftLexer(input);
-    const parser = new DriftParser(lexer);
-    const rawAst = parser.parse();
-
-    const transformer = new DriftTransformer(rawAst);
-    const transformedAst = transformer.transform();
-
-    const script = transformedAst.body[0] as ElementNode;
-    expect(script.tagName).toBe('script');
-
-    const scriptTextNode = script.children[0] as TextNode;
-    const jsContent = scriptTextNode.content as any;
-    expect(jsContent.type).toBe('VariableDeclaration');
-    expect(jsContent.kind).toBe('let');
-    expect(jsContent.declarations[0].id.name).toBe('count');
-  });
-
-  it('should enrich nested directive expressions (If, For, Switch) into Acorn JS AST nodes', () => {
-    const input = `
-      @switch user.getRole() {
-        @case "admin" {
-          @for item in store.getItems(10) {
-            @if item.price > 100 {
-              <span>{ item.name }</span>
-            }
-          }
-        }
-      }
-    `;
-    const lexer = new DriftLexer(input);
-    const parser = new DriftParser(lexer);
-    const rawAst = parser.parse();
-
-    const transformer = new DriftTransformer(rawAst);
-    const transformedAst = transformer.transform();
-
-    const switchIfNode = transformedAst.body[0] as any;
-    expect(switchIfNode.type).toBe(ASTNodeType.If);
-    expect(switchIfNode.test.type).toBe('BinaryExpression');
-
-    const forNode = switchIfNode.consequent.find((n: any) => n.type === ASTNodeType.For);
-    expect(forNode.iterable.type).toBe('CallExpression');
-
-    const ifNode = forNode.body.find((n: any) => n.type === ASTNodeType.If);
-    expect(ifNode.test.type).toBe('BinaryExpression');
-  });
-
-  it('should throw DriftParserError when an invalid JS syntax expression is encountered in an interpolation', () => {
-    const input = '<div>{ 1 + * 2 }</div>';
-    const lexer = new DriftLexer(input);
-    const parser = new DriftParser(lexer);
-    const rawAst = parser.parse();
-
-    const transformer = new DriftTransformer(rawAst);
-    expect(() => transformer.transform()).toThrow();
-  });
-});

package/tsconfig.json

@@ -1,8 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "outDir": "./dist",
-    "rootDir": "."
-  },
-  "include": ["src/**/*", "types/**/*"]
-}

package/types/ast.ts

@@ -1,88 +0,0 @@
-import type { Node as AcornNode } from 'acorn';
-import type { SourceRange } from './token.js';
-
-/**
- * AST Node Types supported by DriftParser.
- */
-export const ASTNodeType = {
-  Program: 'Program',
-  Element: 'Element',
-  Text: 'Text',
-  Interpolation: 'Interpolation',
-  Attribute: 'Attribute',
-  Comment: 'Comment',
-  If: 'If',
-  For: 'For',
-  Switch: 'Switch',
-} as const;
-
-export type ASTNodeType = typeof ASTNodeType[keyof typeof ASTNodeType];
-
-export interface BaseASTNode {
-  readonly type: ASTNodeType;
-  readonly loc: SourceRange;
-}
-
-export interface AttributeNode extends BaseASTNode {
-  readonly type: typeof ASTNodeType.Attribute;
-  readonly name: string;
-  readonly value: string | InterpolationNode | null;
-}
-
-export interface InterpolationNode extends BaseASTNode {
-  readonly type: typeof ASTNodeType.Interpolation;
-  readonly expression: string | AcornNode;
-}
-
-export interface TextNode extends BaseASTNode {
-  readonly type: typeof ASTNodeType.Text;
-  readonly content: string | AcornNode | readonly AcornNode[];
-}
-
-export interface CommentNode extends BaseASTNode {
-  readonly type: typeof ASTNodeType.Comment;
-  readonly content: string;
-}
-
-export interface IfNode extends BaseASTNode {
-  readonly type: typeof ASTNodeType.If;
-  readonly test: string | AcornNode;
-  readonly consequent: readonly TemplateChildNode[];
-  readonly alternate: readonly TemplateChildNode[] | IfNode | null;
-}
-
-export interface ForNode extends BaseASTNode {
-  readonly type: typeof ASTNodeType.For;
-  readonly item: string;
-  readonly index: string | null;
-  readonly iterable: string | AcornNode;
-  readonly key?: string | AcornNode | null;
-  readonly body: readonly TemplateChildNode[];
-}
-
-export interface CaseBranch {
-  readonly expression: string | AcornNode | null; // null for default
-  readonly body: readonly TemplateChildNode[];
-  readonly loc: SourceRange;
-}
-
-export interface SwitchNode extends BaseASTNode {
-  readonly type: typeof ASTNodeType.Switch;
-  readonly discriminant: string | AcornNode;
-  readonly cases: readonly CaseBranch[];
-}
-
-export interface ElementNode extends BaseASTNode {
-  readonly type: typeof ASTNodeType.Element;
-  readonly tagName: string;
-  readonly attributes: readonly AttributeNode[];
-  readonly children: readonly TemplateChildNode[];
-  readonly isSelfClosing: boolean;
-}
-
-export type TemplateChildNode = ElementNode | TextNode | InterpolationNode | CommentNode | IfNode | ForNode | SwitchNode;
-
-export interface ProgramNode extends BaseASTNode {
-  readonly type: typeof ASTNodeType.Program;
-  readonly body: readonly TemplateChildNode[];
-}

package/types/error.ts

@@ -1,29 +0,0 @@
-/**
- * Custom error class for lexing errors.
- */
-export class DriftLexerError extends Error {
-  constructor(
-    message: string,
-    public readonly line: number,
-    public readonly column: number,
-    public readonly offset: number,
-  ) {
-    super(`LexerError [${line}:${column}]: ${message}`);
-    this.name = 'DriftLexerError';
-  }
-}
-
-/**
- * Custom error class for parsing errors.
- */
-export class DriftParserError extends Error {
-  constructor(
-    message: string,
-    public readonly line: number,
-    public readonly column: number,
-    public readonly offset: number,
-  ) {
-    super(`ParserError [${line}:${column}]: ${message}`);
-    this.name = 'DriftParserError';
-  }
-}

package/types/index.ts

@@ -1,6 +0,0 @@
-export * from './token.js';
-export * from './lexer-state.js';
-export * from './ast.js';
-export * from './error.js';
-export * from './opcodes.js';
-

package/types/lexer-state.ts

@@ -1,118 +0,0 @@
-export const LexerStateKind = {
-  Data: 'Data',
-  TagOpen: 'TagOpen',
-  EndTagOpen: 'EndTagOpen',
-  BeforeAttributeName: 'BeforeAttributeName',
-  AttributeName: 'AttributeName',
-  AfterAttributeName: 'AfterAttributeName',
-  BeforeAttributeValue: 'BeforeAttributeValue',
-  AttributeValueQuoted: 'AttributeValueQuoted',
-  AttributeValueInterpolation: 'AttributeValueInterpolation',
-  Comment: 'Comment',
-  Interpolation: 'Interpolation',
-  RawText: 'RawText',
-  EOF: 'EOF',
-} as const;
-
-export type LexerStateKind = typeof LexerStateKind[keyof typeof LexerStateKind];
-
-export type RawTextTagName = 'script' | 'style';
-export type LexerInterpolationContext = 'content' | 'attribute';
-export type AttributeQuote = '"' | "'";
-
-interface BaseLexerState {
-  readonly kind: LexerStateKind;
-}
-
-export interface DataLexerState extends BaseLexerState {
-  readonly kind: typeof LexerStateKind.Data;
-}
-
-export interface TagOpenLexerState extends BaseLexerState {
-  readonly kind: typeof LexerStateKind.TagOpen;
-}
-
-export interface EndTagOpenLexerState extends BaseLexerState {
-  readonly kind: typeof LexerStateKind.EndTagOpen;
-}
-
-export interface BeforeAttributeNameLexerState extends BaseLexerState {
-  readonly kind: typeof LexerStateKind.BeforeAttributeName;
-  readonly tagName: string;
-  readonly isClosingTag: boolean;
-  readonly entersRawText: boolean;
-}
-
-export interface AttributeNameLexerState extends BaseLexerState {
-  readonly kind: typeof LexerStateKind.AttributeName;
-  readonly tagName: string;
-  readonly attributeName: string | null;
-}
-
-export interface AfterAttributeNameLexerState extends BaseLexerState {
-  readonly kind: typeof LexerStateKind.AfterAttributeName;
-  readonly tagName: string;
-  readonly attributeName: string;
-}
-
-export interface BeforeAttributeValueLexerState extends BaseLexerState {
-  readonly kind: typeof LexerStateKind.BeforeAttributeValue;
-  readonly tagName: string;
-  readonly attributeName: string;
-}
-
-export interface AttributeValueQuotedLexerState extends BaseLexerState {
-  readonly kind: typeof LexerStateKind.AttributeValueQuoted;
-  readonly tagName: string;
-  readonly attributeName: string;
-  readonly quote: AttributeQuote;
-}
-
-export interface AttributeValueInterpolationLexerState extends BaseLexerState {
-  readonly kind: typeof LexerStateKind.AttributeValueInterpolation;
-  readonly tagName: string;
-  readonly attributeName: string;
-}
-
-export interface CommentLexerState extends BaseLexerState {
-  readonly kind: typeof LexerStateKind.Comment;
-}
-
-export interface InterpolationLexerState extends BaseLexerState {
-  readonly kind: typeof LexerStateKind.Interpolation;
-  readonly context: LexerInterpolationContext;
-  readonly tagName: string | null;
-}
-
-export interface RawTextLexerState extends BaseLexerState {
-  readonly kind: typeof LexerStateKind.RawText;
-  readonly tagName: RawTextTagName;
-}
-
-export interface EOFLexerState extends BaseLexerState {
-  readonly kind: typeof LexerStateKind.EOF;
-}
-
-export type DriftLexerState =
-  | DataLexerState
-  | TagOpenLexerState
-  | EndTagOpenLexerState
-  | BeforeAttributeNameLexerState
-  | AttributeNameLexerState
-  | AfterAttributeNameLexerState
-  | BeforeAttributeValueLexerState
-  | AttributeValueQuotedLexerState
-  | AttributeValueInterpolationLexerState
-  | CommentLexerState
-  | InterpolationLexerState
-  | RawTextLexerState
-  | EOFLexerState;
-
-export interface LexerStateTransition {
-  readonly to: LexerStateKind;
-  readonly when: string;
-  readonly emits: string;
-}
-
-
-