@galacean/engine-shader-compiler 0.0.0-experimental-2.0-spine.0

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@galacean/engine-shader-compiler",
+  "version": "0.0.0-experimental-2.0-spine.0",
+  "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": "./bundler/rollup.js",
+      "require": "./bundler/rollup.cjs.js",
+      "types": "./types/bundler/rollup.d.ts"
+    },
+    "./bundler/precompile": {
+      "import": "./bundler/precompile.js",
+      "require": "./bundler/precompile.cjs.js",
+      "types": "./types/bundler/precompile.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": "./bundler/cli.js"
+  },
+  "umd": {
+    "name": "Galacean.ShaderCompiler",
+    "globals": {
+      "@galacean/engine-math": "Galacean",
+      "@galacean/engine-core": "Galacean"
+    }
+  },
+  "files": [
+    "dist/**/*",
+    "bundler/**/*",
+    "types/**/*",
+    "verbose/package.json"
+  ],
+  "dependencies": {
+    "@rollup/pluginutils": "^5.0.0",
+    "@galacean/engine-math": "0.0.0-experimental-2.0-spine.0",
+    "@galacean/engine-core": "0.0.0-experimental-2.0-spine.0"
+  },
+  "devDependencies": {
+    "@galacean/engine-design": "0.0.0-experimental-2.0-spine.0"
+  },
+  "scripts": {
+    "build": "rollup -c rollup.config.js && node -e \"require('fs').chmodSync('bundler/cli.js', 0o755)\"",
+    "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,39 @@
+import { GalaceanDataType } from "./common";
+import { ASTNode, 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[];
+    /**
+     * Walk single-child precedence-chain wrappers down to a `VariableIdentifier`,
+     * returning the leaf node (or `undefined` for any compound expression).
+     *
+     * `allowParens` chooses between two callers' needs:
+     *   - `true` — descend through `( expression )` form, so `(v)` resolves to
+     *     `v`. Use when the caller substitutes at the expression root
+     *     (aliasing, renaming); user-written parens carry no extra meaning.
+     *   - `false` — any 3-child `PrimaryExpression` aborts; `(v)` stays
+     *     compound. Use when the caller treats the unwrapped node as a single
+     *     token (IO-struct arg drop, alias detection); user-written parens
+     *     must not collapse.
+     */
+    static unwrapBareIdentifier(node: TreeNode, options: {
+        allowParens: boolean;
+    }): ASTNode.VariableIdentifier | undefined;
+    /**
+     * Lexeme variant of `unwrapBareIdentifier({ allowParens: true })` for callers
+     * that already work with strings. Returns `null` for compound expressions.
+     */
+    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,30 @@
+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>;
+export interface MacroDefineInfo {
+    isFunction: boolean;
+    params: string[];
+    /** Value AST. Set when the replacement list parses as `expression` (which
+     *  includes comma-separated lists per C99 §6.10.3); absent for the GLSL ES
+     *  3.00 §3.4 opaque cases the grammar can't reduce (empty, type-alias keyword,
+     *  trailing punctuation, unbalanced bracket, trailing operator). Identifier
+     *  references inside are collected by `MacroCallSymbol._collectIdentifierRefs`
+     *  walking this subtree. */
+    valueAst?: ASTNode.Expression;
+    /** Whitespace-normalized directive text. Dedup key against re-includes in
+     *  the same branch; differing values produce different keys. */
+    dedupKey: string;
+    /** `#ifdef` branch at registration time; call sites filter to visible entries. */
+    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;
+}

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";