@galacean/engine-shader-compiler 2.0.0-alpha.31

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@galacean/engine-shader-compiler",
+  "version": "2.0.0-alpha.31",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "repository": {
+    "url": "https://github.com/galacean/engine.git"
+  },
+  "license": "MIT",
+  "main": "dist/main.js",
+  "module": "dist/module.js",
+  "browser": "dist/browser.min.js",
+  "debug": "src/index.ts",
+  "types": "types/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/module.js",
+      "require": "./dist/main.js",
+      "types": "./types/index.d.ts"
+    },
+    "./bundler/rollup": {
+      "import": "./dist/bundler/rollup.js",
+      "require": "./dist/bundler/rollup.cjs.js",
+      "types": "./types/bundler/rollup.d.ts"
+    },
+    "./verbose": {
+      "import": "./dist/module.verbose.js",
+      "require": "./dist/main.verbose.js",
+      "types": "./types/index.d.ts"
+    },
+    "./src/*": "./src/*.ts",
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "shader-compiler-precompile": "./dist/bundler/cli.js"
+  },
+  "umd": {
+    "name": "Galacean.ShaderCompiler",
+    "globals": {
+      "@galacean/engine-math": "Galacean",
+      "@galacean/engine-core": "Galacean"
+    }
+  },
+  "files": [
+    "dist/**/*",
+    "types/**/*",
+    "verbose/package.json"
+  ],
+  "dependencies": {
+    "@rollup/pluginutils": "^5.0.0",
+    "@galacean/engine-core": "2.0.0-alpha.31",
+    "@galacean/engine-math": "2.0.0-alpha.31"
+  },
+  "devDependencies": {
+    "@galacean/engine-design": "2.0.0-alpha.31"
+  },
+  "scripts": {
+    "build": "rollup -c rollup.config.js && chmod +x dist/bundler/cli.js",
+    "b:types": "tsc"
+  }
+}

package/types/GSError.d.ts

@@ -0,0 +1,16 @@
+import { ShaderPosition } from "./common/ShaderPosition";
+import { ShaderRange } from "./common/ShaderRange";
+export declare class GSError extends Error {
+    readonly location: ShaderRange | ShaderPosition;
+    readonly source: string;
+    readonly file?: string;
+    static wrappingLineCount: number;
+    constructor(name: GSErrorName, message: string, location: ShaderRange | ShaderPosition, source: string, file?: string);
+    toString(): string;
+}
+export declare enum GSErrorName {
+    PreprocessorError = "PreprocessorError",
+    CompilationError = "CompilationError",
+    ScannerError = "ScannerError",
+    CompilationWarn = "CompilationWarning"
+}

package/types/ParserUtils.d.ts

@@ -0,0 +1,26 @@
+import { GalaceanDataType } from "./common";
+import { TreeNode } from "./parser/AST";
+import { GrammarSymbol, NoneTerminal } from "./parser/GrammarSymbol";
+export declare class ParserUtils {
+    static unwrapNodeByType<T = TreeNode>(node: TreeNode, type: NoneTerminal): T | undefined;
+    /**
+     * Parse a function-macro parameter-list lexeme (`"(a, b, c)"`) into its parameter
+     * names. An empty list `"()"` yields `[]`. Leading/trailing whitespace around each
+     * name is trimmed. Empty entries from consecutive commas are filtered out.
+     */
+    static parseMacroParamList(lexeme: string): string[];
+    /**
+     * Return the lexeme of `expr` when it is (transitively) a single bare identifier
+     * wrapped in primary/postfix expression nodes, e.g. `o` → "o". Returns null for
+     * compound expressions (`o.x`, `foo(..)`, `arr[0]`, …). Useful for callers that
+     * want to apply a substitution rule only at the root of an expression, never on
+     * swizzles or nested member access.
+     */
+    static extractDirectIdentLexeme(expr: TreeNode): string | null;
+    /**
+     * Check if type `tb` is compatible with type `ta`.
+     */
+    static typeCompatible(ta: GalaceanDataType, tb: GalaceanDataType | undefined): boolean;
+    static toString(sm: GrammarSymbol): string;
+    static isTerminal(sm: GrammarSymbol): boolean;
+}

package/types/Preprocessor.d.ts

@@ -0,0 +1,33 @@
+import type { ASTNode } from "./parser/AST";
+import type { BranchSignature } from "./common/BaseToken";
+export type IncludeMap = {
+    readonly [includeName: string]: string | undefined;
+};
+export type ChunkOutputCache = Map<string, string>;
+/**
+ * Record for a single `#define` directive. `valueAst` is set for expression
+ * macros (joined into the AST pipeline); opaque macros leave it undefined and
+ * are emitted verbatim to the GLSL driver.
+ */
+export interface MacroDefineInfo {
+    isFunction: boolean;
+    name: string;
+    params: string[];
+    valueAst?: ASTNode.AssignmentExpression;
+    /** Leading identifier of the value (`#define F foo` → `foo`, `#define F foo(a)`
+     *  → `foo`), or empty for literals / operator expressions. Drives symbol-table
+     *  lookup at macro call sites. */
+    referenceName: string;
+    /** Branch signature at the point of registration. The same `#define` repeated
+     *  in different `#ifdef` branches produces multiple entries with different
+     *  signatures; call sites filter to those visible from their own position. */
+    branch: BranchSignature;
+}
+export interface MacroDefineList {
+    [macroName: string]: MacroDefineInfo[];
+}
+export declare class Preprocessor {
+    private static readonly _includeReg;
+    static parse(source: string, basePathForIncludeKey: string, includeMap: IncludeMap, chunkOutputCache: ChunkOutputCache): string;
+    private static _replace;
+}

package/types/ShaderCompiler.d.ts

@@ -0,0 +1,21 @@
+import { ShaderLanguage } from "@galacean/engine-core";
+import type { IPrecompiledShader, IShaderSource } from "@galacean/engine-design";
+import type { IShaderProgramSource } from "@galacean/engine-design/types/shader-compiler/IShaderProgramSource";
+import { ShaderPosition, ShaderRange } from "./common";
+import { IncludeMap } from "./Preprocessor";
+export declare class ShaderCompiler {
+    private static _parser;
+    private static _shaderPositionPool;
+    private static _shaderRangePool;
+    static _processingPassText?: string;
+    private _includeMap;
+    private readonly _chunkOutputCache;
+    /** Replace the `#include` lookup table and clear the derived chunk cache. */
+    _setIncludeMap(includeMap: IncludeMap): void;
+    static createPosition(index: number, line?: number, column?: number): ShaderPosition;
+    static createRange(start: ShaderPosition, end: ShaderPosition): ShaderRange;
+    _parseShaderSource(sourceCode: string): IShaderSource;
+    _parseShaderPass(source: string, vertexEntry: string, fragmentEntry: string, backend: ShaderLanguage, basePathForIncludeKey: string): IShaderProgramSource | undefined;
+    _precompile(sourceCode: string, platformTarget: ShaderLanguage, basePathForIncludeKey: string): IPrecompiledShader;
+    private _serializeRenderStates;
+}

package/types/ShaderCompilerUtils.d.ts

@@ -0,0 +1,10 @@
+import { ClearableObjectPool, type IPoolElement } from "@galacean/engine-core";
+import { GSErrorName } from "./GSError";
+import { ShaderRange } from "./common/ShaderRange";
+import { ShaderPosition } from "./common/ShaderPosition";
+export declare class ShaderCompilerUtils {
+    private static _shaderCompilerObjectPoolSet;
+    static createObjectPool<T extends IPoolElement>(type: new () => T): ClearableObjectPool<T>;
+    static clearAllShaderCompilerObjectPool(): void;
+    static createGSError(message: string, errorName: GSErrorName, source: string, location: ShaderRange | ShaderPosition, file?: string): Error | undefined;
+}

package/types/ShaderInstructionEncoder.d.ts

@@ -0,0 +1 @@
+export type { ShaderInstruction } from "@galacean/engine-design";

package/types/TempArray.d.ts

@@ -0,0 +1,5 @@
+import type { IPoolElement } from "@galacean/engine-core";
+export declare class TempArray<T> implements IPoolElement {
+    array: Array<T>;
+    dispose(): void;
+}

package/types/bundler/cli.d.ts

@@ -0,0 +1 @@
+export {};

package/types/bundler/precompile.d.ts

@@ -0,0 +1,25 @@
+/** Normalize to forward slashes (Windows uses `\`; downstream regex/keys assume `/`). */
+export declare function normalizePath(p: string): string;
+export interface PrecompileOptions {
+    /** Absolute or relative path to the directory containing `.shader` sources. */
+    input: string;
+    /** Absolute or relative path to the directory where `.shaderc` outputs are written. */
+    output: string;
+    /** Remove `.shaderc` files whose `.shader` source no longer exists, and prune empty dirs. */
+    clean?: boolean;
+    /** Watch the input dir and re-run incrementally on `.shader` / `.glsl` changes. */
+    watch?: boolean;
+    /** Compile only this file (path may be relative to cwd). Skips full scan + cleanup. */
+    only?: string;
+    /** Generate `<output>/index.ts` aggregating every `.shaderc` file. */
+    emitIndex?: boolean;
+    /** Generate raw-source indexes: `<input>/index.ts` (.shader) + sibling `ShaderLibrary/index.ts` (.glsl). */
+    emitSources?: boolean;
+    /** Optional shader platform target passed through to `_precompile`. Defaults to `0`. */
+    platformTarget?: number;
+}
+export declare function precompile(options: PrecompileOptions): Promise<void>;
+export declare function runFull(options: Omit<PrecompileOptions, "watch">): Promise<{
+    failed: number;
+}>;
+export declare function startWatcher(options: Omit<PrecompileOptions, "watch" | "only">): Promise<void>;

package/types/bundler/rollup.d.ts

@@ -0,0 +1,41 @@
+import type { Plugin } from "rollup";
+export interface ShaderPrecompileOptions {
+    /** Directory containing `.shader` source files. */
+    input: string;
+    /** Directory where `.shaderc` outputs are written. */
+    output: string;
+    /** Remove `.shaderc` whose source no longer exists. Default `true`. */
+    clean?: boolean;
+    /** Emit an aggregated `<output>/index.ts`. Default `true`. */
+    emitIndex?: boolean;
+    /** Emit raw-source indexes (`.shader` + `.glsl`) into the input tree. */
+    emitSources?: boolean;
+    /** Shader platform target. Default `0`. */
+    platformTarget?: number;
+}
+export interface ShaderPluginOptions {
+    /**
+     * Override the default include pattern. The plugin always matches `.glsl`,
+     * `.shader`, and `.shaderc` extensions; this option exists for advanced
+     * cases where the host bundler needs to gate by additional path constraints.
+     * Returning `false` skips a file.
+     */
+    filter?: (id: string) => boolean;
+    /**
+     * When set, the plugin runs an initial full precompile in `buildStart` and,
+     * in watch mode, starts a background file watcher that incrementally
+     * regenerates `.shaderc` outputs when `.shader` / `.glsl` files change.
+     * Without this option the plugin only does file-extension transforms —
+     * pre-compile must be triggered separately via the `shader-precompile` CLI.
+     */
+    precompile?: ShaderPrecompileOptions;
+}
+/**
+ * Rollup plugin that transforms shader assets into JS modules.
+ *
+ * - Always: transforms `.glsl` / `.shader` / `.shaderc` files.
+ * - When `precompile` option is set: runs a full precompile in buildStart and,
+ *   in watch mode, starts a background watcher that mirrors `.shader` source
+ *   changes into `.shaderc` outputs and refreshes the aggregated index.
+ */
+export declare function shaderCompiler(options?: ShaderPluginOptions): Plugin;

package/types/codeGen/CodeGenVisitor.d.ts

@@ -0,0 +1 @@
+export {};

package/types/codeGen/GLES100.d.ts

@@ -0,0 +1,12 @@
+import { ASTNode } from "../parser/AST";
+import { StructProp } from "../parser/types";
+import { GLESVisitor } from "./GLESVisitor";
+export declare class GLES100Visitor extends GLESVisitor {
+    private static _singleton;
+    static getVisitor(): GLES100Visitor;
+    getAttributeProp(prop: StructProp): string;
+    getVaryingProp(prop: StructProp): string;
+    getMRTProp(): string;
+    visitPostfixExpression(node: ASTNode.PostfixExpression): string;
+    visitJumpStatement(node: ASTNode.JumpStatement): string;
+}

package/types/codeGen/GLES300.d.ts

@@ -0,0 +1,20 @@
+import { ASTNode } from "../parser/AST";
+import { ShaderData } from "../parser/ShaderInfo";
+import { StructProp } from "../parser/types";
+import { GLESVisitor } from "./GLESVisitor";
+import { ICodeSegment } from "./types";
+export declare class GLES300Visitor extends GLESVisitor {
+    private static _singleton;
+    static getVisitor(): GLES300Visitor;
+    private _otherCodeArray;
+    private _fragColorVariableRegistered;
+    reset(): void;
+    getOtherGlobal(data: ShaderData, out: ICodeSegment[]): void;
+    getAttributeProp(prop: StructProp): string;
+    getVaryingProp(prop: StructProp): string;
+    getMRTProp(prop: StructProp): string;
+    visitFunctionIdentifier(node: ASTNode.FunctionIdentifier): string;
+    visitVariableIdentifier(node: ASTNode.VariableIdentifier): string;
+    visitJumpStatement(node: ASTNode.JumpStatement): string;
+    private _registerFragColorVariable;
+}

package/types/codeGen/GLESVisitor.d.ts

@@ -0,0 +1 @@
+export {};

package/types/codeGen/VisitorContext.d.ts

@@ -0,0 +1,2 @@
+/** Role of a struct type in the shader compiler's IO flattening. */
+export type StructRole = "varying" | "attribute" | "mrt";

package/types/codeGen/index.d.ts

@@ -0,0 +1,3 @@
+export { GLES100Visitor } from "./GLES100";
+export { GLES300Visitor } from "./GLES300";
+export { CodeGenVisitor } from "./CodeGenVisitor";

package/types/codeGen/types.d.ts

@@ -0,0 +1,12 @@
+import type { IShaderSource } from "@galacean/engine-design";
+export type IRenderState = [
+    /** Constant RenderState. */
+    Record<number, boolean | string | number | any>,
+    /** Variable RenderState. */
+    Record<number, string>
+];
+export type ITag = IShaderSource["subShaders"][number]["tags"];
+export type ICodeSegment = {
+    text: string;
+    index: number;
+};

package/types/common/BaseLexer.d.ts

@@ -0,0 +1,2 @@
+import { BaseToken } from "./BaseToken";
+export type OnToken = (token: BaseToken, scanner: BaseLexer) => void;

package/types/common/BaseToken.d.ts

@@ -0,0 +1,35 @@
+import { ShaderRange, ShaderPosition } from ".";
+import type { IPoolElement } from "@galacean/engine-core";
+/**
+ * One condition in a branch signature: `defined: true` for `#ifdef X` (the
+ * branch is active when `X` is defined), `defined: false` for `#ifndef X` /
+ * after `#else` (active when `X` is undefined).
+ */
+export interface BranchConstraint {
+    name: string;
+    defined: boolean;
+}
+/**
+ * Snapshot of the `#ifdef`/`#ifndef`/`#else` stack at a source position. An
+ * empty signature means unconditional (top-level). Constraints are conjunctive:
+ * the position is active iff every constraint holds. Produced by the Lexer
+ * (the sole branch-stack maintainer) and stamped onto every emitted token +
+ * every registered `MacroDefineInfo`.
+ */
+export type BranchSignature = readonly BranchConstraint[];
+export declare const EMPTY_BRANCH: BranchSignature;
+export declare class BaseToken<T extends number = number> implements IPoolElement {
+    static pool: import("@galacean/engine-core").ClearableObjectPool<BaseToken<number>>;
+    type: T;
+    lexeme: string;
+    location: ShaderRange;
+    /** Branch signature snapshot at the point this token was emitted. Empty
+     *  signature (default) means top-level / unconditional. The Lexer tags
+     *  every token; downstream code (AST nodes built from tokens) can read
+     *  the field directly to know which `#ifdef` branch they're inside. */
+    branch: BranchSignature;
+    set(type: T, lexeme: string, start?: ShaderPosition): any;
+    set(type: T, lexeme: string, location?: ShaderRange): any;
+    dispose(): void;
+}
+export declare const EOF: BaseToken<number>;

package/types/common/IBaseSymbol.d.ts

@@ -0,0 +1,5 @@
+export interface IBaseSymbol {
+    isInMacroBranch: boolean;
+    readonly ident: string;
+    equal(other: IBaseSymbol): boolean;
+}

package/types/common/ShaderPosition.d.ts

@@ -0,0 +1,8 @@
+import type { IPoolElement } from "@galacean/engine-core";
+export declare class ShaderPosition implements IPoolElement {
+    index: number;
+    line: number;
+    column: number;
+    set(index: number, line: number, column: number): void;
+    dispose(): void;
+}

package/types/common/ShaderRange.d.ts

@@ -0,0 +1,8 @@
+import type { IPoolElement } from "@galacean/engine-core";
+import { ShaderPosition } from "./ShaderPosition";
+export declare class ShaderRange implements IPoolElement {
+    start: ShaderPosition;
+    end: ShaderPosition;
+    set(start: ShaderPosition, end: ShaderPosition): void;
+    dispose(): void;
+}

package/types/common/SymbolTable.d.ts

@@ -0,0 +1,9 @@
+import { IBaseSymbol } from "./IBaseSymbol";
+export declare class SymbolTable<T extends IBaseSymbol> {
+    private _table;
+    insert(symbol: T, isInMacroBranch?: boolean): void;
+    getSymbol(symbol: T, includeMacro?: boolean): T | undefined;
+    getSymbols(symbol: T, includeMacro: boolean, out: T[]): T[];
+    /** Iterate every registered symbol. Order within a name bucket is insertion order. */
+    forEach(callback: (symbol: T) => void): void;
+}

package/types/common/SymbolTableStack.d.ts

@@ -0,0 +1,13 @@
+import { IBaseSymbol } from "./IBaseSymbol";
+import { SymbolTable } from "./SymbolTable";
+export declare class SymbolTableStack<S extends IBaseSymbol, T extends SymbolTable<S>> {
+    stack: T[];
+    get scope(): T;
+    get isInMacroBranch(): boolean;
+    pushScope(scope: T): void;
+    clear(): void;
+    popScope(): T | undefined;
+    insert(symbol: S): void;
+    lookup(symbol: S, includeMacro?: boolean): S | undefined;
+    lookupAll(symbol: S, includeMacro: boolean, out: S[]): S[];
+}

package/types/common/enums/Keyword.d.ts

@@ -0,0 +1,124 @@
+export declare enum Keyword {
+    CONST = 0,
+    BOOL = 1,
+    FLOAT = 2,
+    DOUBLE = 3,
+    INT = 4,
+    UINT = 5,
+    BREAK = 6,
+    CONTINUE = 7,
+    DO = 8,
+    ELSE = 9,
+    FOR = 10,
+    IF = 11,
+    WHILE = 12,
+    DISCARD = 13,
+    RETURN = 14,
+    BVEC2 = 15,
+    BVEC3 = 16,
+    BVEC4 = 17,
+    IVEC2 = 18,
+    IVEC3 = 19,
+    IVEC4 = 20,
+    UVEC2 = 21,
+    UVEC3 = 22,
+    UVEC4 = 23,
+    VEC2 = 24,
+    VEC3 = 25,
+    VEC4 = 26,
+    VEC4_ARRAY = 27,
+    MAT2 = 28,
+    MAT3 = 29,
+    MAT4 = 30,
+    MAT2X3 = 31,
+    MAT2X4 = 32,
+    MAT3X2 = 33,
+    MAT3X4 = 34,
+    MAT4X2 = 35,
+    MAT4X3 = 36,
+    IN = 37,
+    OUT = 38,
+    INOUT = 39,
+    CENTROID = 40,
+    SAMPLER2D = 41,
+    SAMPLER3D = 42,
+    SAMPLER_CUBE = 43,
+    SAMPLER2D_SHADOW = 44,
+    SAMPLER_CUBE_SHADOW = 45,
+    SAMPLER2D_ARRAY = 46,
+    SAMPLER2D_ARRAY_SHADOW = 47,
+    I_SAMPLER2D = 48,
+    I_SAMPLER3D = 49,
+    I_SAMPLER_CUBE = 50,
+    I_SAMPLER2D_ARRAY = 51,
+    U_SAMPLER2D = 52,
+    U_SAMPLER3D = 53,
+    U_SAMPLER_CUBE = 54,
+    U_SAMPLER2D_ARRAY = 55,
+    STRUCT = 56,
+    LAYOUT = 57,
+    LOCATION = 58,
+    VOID = 59,
+    PRECISION = 60,
+    PRECISE = 61,
+    HIGHP = 62,
+    MEDIUMP = 63,
+    LOWP = 64,
+    INVARIANT = 65,
+    SMOOTH = 66,
+    FLAT = 67,
+    NOPERSPECTIVE = 68,
+    True = 69,
+    False = 70,
+    LeftBrace = 71,
+    RightBrace = 72,
+    Equal = 73,
+    BitwiseOr = 74,
+    GSRenderQueueType = 75,
+    GSBlendState = 76,
+    GSDepthState = 77,
+    GSStencilState = 78,
+    GSRasterState = 79,
+    GSEditorProperties = 80,
+    GSEditorMacros = 81,
+    GSEditor = 82,
+    GSTags = 83,
+    GSVertexShader = 84,
+    GSFragmentShader = 85,
+    GSSubShader = 86,
+    GSPass = 87,
+    GSBlendFactor = 88,
+    GSBlendOperation = 89,
+    GSBool = 90,
+    GSNumber = 91,
+    GSColor = 92,
+    GSCompareFunction = 93,
+    GSStencilOperation = 94,
+    GSCullMode = 95,
+    GSColorWriteMask = 96,
+    GSUsePass = 97,
+    MACRO_IF = 98,
+    MACRO_IFDEF = 99,
+    MACRO_IFNDEF = 100,
+    MACRO_ELSE = 101,
+    MACRO_ELIF = 102,
+    MACRO_ENDIF = 103,
+    MACRO_UNDEF = 104,
+    /** Legacy opaque `#define` token — whole directive packed into one lexeme. Retained
+     *  for macros whose value can't be parsed as a GLSL expression (type aliases,
+     *  qualifier aliases, partial-syntax macros). Expression-style macros instead emit
+     *  `MACRO_DEFINE` + ID + value tokens + `MACRO_DEFINE_END`. */
+    MACRO_DEFINE_EXPRESSION = 105,
+    MACRO_CONDITIONAL_EXPRESSION = 106,
+    MACRO_CALL = 107,
+    /** `#define` directive head for expression-style macros. */
+    MACRO_DEFINE = 108,
+    /** Terminates a `MACRO_DEFINE` directive at end-of-line. */
+    MACRO_DEFINE_END = 109,
+    /** `(params)` block for a function-like `#define`. The lexer captures the entire
+     *  parenthesized parameter list as one opaque token so the macro-define CFG rule
+     *  doesn't need its own parameter-list production (which would conflict with
+     *  function_call_parameter_list under LALR(1)). The AST consumer parses the
+     *  lexeme to recover the individual parameter names. */
+    MACRO_DEFINE_PARAMS = 110
+}

package/types/common/enums/ShaderStage.d.ts

@@ -0,0 +1,5 @@
+export declare enum EShaderStage {
+    VERTEX = 0,
+    FRAGMENT = 1,
+    ALL = 2
+}

package/types/common/index.d.ts

@@ -0,0 +1,5 @@
+import { ShaderRange } from "./ShaderRange";
+import { ShaderPosition } from "./ShaderPosition";
+export { ShaderRange, ShaderPosition };
+export * from "./types";
+export * from "./enums/Keyword";

package/types/common/types.d.ts

@@ -0,0 +1,101 @@
+import { Keyword } from "./enums/Keyword";
+export declare enum ETokenType {
+    ID = 1000,
+    FLOAT_CONSTANT = 1001,
+    INT_CONSTANT = 1002,
+    STRING_CONST = 1003,
+    /** << */
+    LEFT_OP = 1004,
+    /** \>> */
+    RIGHT_OP = 1005,
+    /** ++ */
+    INC_OP = 1006,
+    /** -- */
+    DEC_OP = 1007,
+    /** <= */
+    LE_OP = 1008,
+    /** \>= */
+    GE_OP = 1009,
+    /** == */
+    EQ_OP = 1010,
+    /** != */
+    NE_OP = 1011,
+    /** && */
+    AND_OP = 1012,
+    /** || */
+    OR_OP = 1013,
+    /** ^^ */
+    XOR_OP = 1014,
+    /** *= */
+    MUL_ASSIGN = 1015,
+    /** /= */
+    DIV_ASSIGN = 1016,
+    /** += */
+    ADD_ASSIGN = 1017,
+    /** -= */
+    SUB_ASSIGN = 1018,
+    /** %= */
+    MOD_ASSIGN = 1019,
+    /** <<= */
+    LEFT_ASSIGN = 1020,
+    /** >>= */
+    RIGHT_ASSIGN = 1021,
+    /** &= */
+    AND_ASSIGN = 1022,
+    /** ^= */
+    XOR_ASSIGN = 1023,
+    /** |= */
+    OR_ASSIGN = 1024,
+    /** ( */
+    LEFT_PAREN = 1025,
+    /** ) */
+    RIGHT_PAREN = 1026,
+    /** [ */
+    LEFT_BRACKET = 1027,
+    /** ] */
+    RIGHT_BRACKET = 1028,
+    /** { */
+    LEFT_BRACE = 1029,
+    /** } */
+    RIGHT_BRACE = 1030,
+    /** . */
+    DOT = 1031,
+    /** , */
+    COMMA = 1032,
+    COLON = 1033,
+    /** = */
+    EQUAL = 1034,
+    /** ; */
+    SEMICOLON = 1035,
+    /** ! */
+    BANG = 1036,
+    /** \- */
+    DASH = 1037,
+    /** ~ */
+    TILDE = 1038,
+    PLUS = 1039,
+    /** \* */
+    STAR = 1040,
+    /** / */
+    SLASH = 1041,
+    /** % */
+    PERCENT = 1042,
+    /** < */
+    LEFT_ANGLE = 1043,
+    /** \> */
+    RIGHT_ANGLE = 1044,
+    VERTICAL_BAR = 1045,
+    /** ^ */
+    CARET = 1046,
+    /** & */
+    AMPERSAND = 1047,
+    /** ? */
+    QUESTION = 1048,
+    NotWord = 1049,
+    /** ε */
+    EPSILON = 1998,
+    EOF = 1999
+}
+export declare const TypeAny = 3000;
+export type GalaceanDataType = Keyword.VOID | Keyword.FLOAT | Keyword.BOOL | Keyword.INT | Keyword.UINT | Keyword.VEC2 | Keyword.VEC3 | Keyword.VEC4 | Keyword.BVEC2 | Keyword.BVEC3 | Keyword.BVEC4 | Keyword.IVEC2 | Keyword.IVEC3 | Keyword.IVEC4 | Keyword.UVEC2 | Keyword.UVEC3 | Keyword.UVEC4 | Keyword.MAT2 | Keyword.MAT3 | Keyword.MAT4 | Keyword.MAT2X3 | Keyword.MAT2X4 | Keyword.MAT3X2 | Keyword.MAT3X4 | Keyword.MAT4X2 | Keyword.MAT4X3 | Keyword.SAMPLER2D | Keyword.SAMPLER3D | Keyword.SAMPLER_CUBE | Keyword.SAMPLER2D_SHADOW | Keyword.SAMPLER_CUBE_SHADOW | Keyword.SAMPLER2D_ARRAY | Keyword.SAMPLER2D_ARRAY_SHADOW | Keyword.I_SAMPLER2D | Keyword.I_SAMPLER3D | Keyword.I_SAMPLER_CUBE | Keyword.I_SAMPLER2D_ARRAY | Keyword.U_SAMPLER2D | Keyword.U_SAMPLER3D | Keyword.U_SAMPLER_CUBE | Keyword.U_SAMPLER2D_ARRAY | Keyword.VEC4_ARRAY | typeof TypeAny | string;
+export type TokenType = ETokenType | Keyword;

package/types/index.d.ts

@@ -0,0 +1,3 @@
+export { ShaderCompiler } from "./ShaderCompiler";
+export * from "./GSError";
+export declare const version = "__buildVersion";

package/types/lalr/CFG.d.ts

@@ -0,0 +1,5 @@
+import { Grammar } from "../parser/Grammar";
+import SemanticAnalyzer from "../parser/SemanticAnalyzer";
+declare const createGrammar: () => Grammar;
+declare const addTranslationRule: (sa: SemanticAnalyzer) => void;
+export { addTranslationRule, createGrammar };