interface Token {
  type: 'whitespace' | 'comment' | 'symbol' | 'bool' | 'float' | 'int' | 'identifier' | 'keyword'
  value: string
}

const minified: string = minify(code: string, {
  /** Whether to rename variables. Will call a MangleMatcher if specified. Default is `false`. */
  mangle: boolean | ((token: Token, index: number, tokens: Token[]) => boolean)
  /** A map to read and write renamed variables to when mangling. */
  mangleMap: Map<string, string>
  /** Whether to rename external variables such as uniforms or varyings. Default is `false`. */
  mangleExternals: boolean
})

const options = { mangle: true, mangleExternals: true, mangleMap: new Map() }

// #version 300 es\nin vec2 a;out vec2 b;void main(){b=a;}
minify(`#version 300 es\nin vec2 sstt;out vec2 c;void main(){c=sstt;}`, options)

// #version 300 es\nin vec2 b;out vec4 a[gl_MaxDrawBuffers];void main(){a[0]=b.sstt;}
minify(`#version 300 es\nin vec2 c;out vec4 data[gl_MaxDrawBuffers];void main(){data[0]=c.sstt;}`, options)

const ast: AST[] = parse(code: string)

const code: string = generate(ast: AST[], {
  target: 'GLSL' // | 'WGSL'
})

class Literal {
  value: string
}

class Identifier {
  value: string
}

class Type {
  name: string
  parameters: (Type | Literal | Identifier)[] | null
}

class VariableDeclaration {
  layout: Record<string, string | boolean> | null
  qualifiers: string[]
  kind: 'var' | 'let' | 'const' | null
  type: Type | Identifier
  declarations: VariableDeclarator[]
}

class VariableDeclarator {
  name: string
  value: AST | null
}

class StructDeclaration {
  name: string
  members: VariableDeclaration[]
}

class FunctionDeclaration {
  name: string
  type: Type | Identifier
  qualifiers: string[]
  args: VariableDeclaration[]
  body: BlockStatement | null
}

class UnaryExpression {
  operator: string
  left: AST | null
  right: AST | null
}

class BinaryExpression {
  operator: string
  left: AST
  right: AST
}

class TernaryExpression {
  test: AST
  consequent: AST
  alternate: AST
}

class CallExpression {
  callee: AST
  args: AST[]
}

class MemberExpression {
  object: AST
  property: AST
}

class ArrayExpression {
  type: Type
  members: AST[]
}

class BlockStatement {
  body: AST[]
}

class IfStatement {
  test: AST
  consequent: AST
  alternate: AST | null
}

class ForStatement {
  init: AST | null
  test: AST | null
  update: AST | null
  body: AST
}

class WhileStatement {
  test: AST
  body: AST
}

class DoWhileStatement {
  test: AST
  body: AST
}

class SwitchStatement {
  discriminant: AST
  cases: SwitchCase[]
}

class SwitchCase {
  test: AST | null
  consequent: AST[]
}

class ReturnStatement {
  argument: Literal | Identifier | UnaryExpression | null
}

class PreprocessorStatement {
  name: string
  value: AST[] | null
}

class PrecisionStatement {
  precision: 'lowp' | 'mediump' | 'highp'
  type: Type
}

class ContinueStatement {}

class BreakStatement {}

class DiscardStatement {}