shaderkit 0.0.0 → 0.0.1

package/src/constants.ts

@@ -0,0 +1,411 @@
+// https://registry.khronos.org/OpenGL/specs/es/3.0/GLSL_ES_Specification_3.00.pdf
+// NOTE: restrictions from 5.25-5.26 apply https://registry.khronos.org/webgl/specs/latest/2.0
+export const GLSL_KEYWORDS = [
+  // 3.8 Keywords
+  'const',
+  'uniform',
+  'layout',
+  'centroid',
+  'flat',
+  'smooth',
+  'break',
+  'continue',
+  'do',
+  'for',
+  'while',
+  'switch',
+  'case',
+  'default',
+  'if',
+  'else',
+  'in',
+  'out',
+  'inout',
+  'float',
+  'int',
+  'void',
+  'bool',
+  'true',
+  'false',
+  'invariant',
+  'discard',
+  'return',
+  'mat2',
+  'mat3',
+  'mat4',
+  'mat2x2',
+  'mat2x3',
+  'mat2x4',
+  'mat3x2',
+  'mat3x3',
+  'mat3x4',
+  'mat4x2',
+  'mat4x3',
+  'mat4x4',
+  'vec2',
+  'vec3',
+  'vec4',
+  'ivec2',
+  'ivec3',
+  'ivec4',
+  'bvec2',
+  'bvec3',
+  'bvec4',
+  'uint',
+  'uvec2',
+  'uvec3',
+  'uvec4',
+  'lowp',
+  'mediump',
+  'highp',
+  'precision',
+  'sampler2D',
+  'sampler3D',
+  'samplerCube',
+  'sampler2DShadow',
+  'samplerCubeShadow',
+  'sampler2DArray',
+  'sampler2DArrayShadow',
+  'isampler2D',
+  'isampler3D',
+  'isamplerCube',
+  'isampler2DArray',
+  'usampler2D',
+  'usampler3D',
+  'usamplerCube',
+  'usampler2DArray',
+  'struct',
+
+  // 3.8 Keywords - Reserved for future use
+  'attribute',
+  'varying',
+  'coherent',
+  'volatile',
+  'restrict',
+  'readonly',
+  'writeonly',
+  'resource',
+  'atomic_uint',
+  'noperspective',
+  'patch',
+  'sample',
+  'subroutine',
+  'common',
+  'partition',
+  'active',
+  'asm',
+  'class',
+  'union',
+  'enum',
+  'typedef',
+  'template',
+  'this',
+  'goto',
+  'inline',
+  'noinline',
+  'volatile',
+  'public',
+  'static',
+  'extern',
+  'external',
+  'interface',
+  'long',
+  'short',
+  'double',
+  'half',
+  'fixed',
+  'unsigned',
+  'superp',
+  'input',
+  'output',
+  'hvec2',
+  'hvec3',
+  'hvec4',
+  'dvec2',
+  'dvec3',
+  'dvec4',
+  'fvec2',
+  'fvec3',
+  'fvec4',
+  'sampler3DRect',
+  'filter',
+  'image1D',
+  'image2D',
+  'image3D',
+  'imageCube',
+  'iimage1D',
+  'iimage2D',
+  'iimage3D',
+  'iimageCube',
+  'uimage1D',
+  'uimage2D',
+  'uimage3D',
+  'uimageCube',
+  'image1DArray',
+  'image2DArray',
+  'iimage1DArray',
+  'iimage2DArray',
+  'uimage1DArray',
+  'uimage2DArray',
+  'imageBuffer',
+  'iimageBuffer',
+  'uimageBuffer',
+  'sampler1D',
+  'sampler1DShadow',
+  'sampler1DArray',
+  'sampler1DArrayShadow',
+  'isampler1D',
+  'isampler1DArray',
+  'usampler1D',
+  'usampler1DArray',
+  'sampler2DRect',
+  'sampler2DRectShadow',
+  'isampler2DRect',
+  'usampler2DRect',
+  'samplerBuffer',
+  'isamplerBuffer',
+  'usamplerBuffer',
+  'sampler2DMS',
+  'isampler2DMS',
+  'usampler2DMS',
+  'sampler2DMSArray',
+  'isampler2DMSArray',
+  'usampler2DMSArray',
+  'sizeof',
+  'cast',
+  'namespace',
+  'using',
+
+  // 3.5 Preprocessor
+  '#define',
+  '#undef',
+  '#if',
+  '#ifdef',
+  '#ifndef',
+  '#else',
+  '#elif',
+  '#endif',
+  '#error',
+  '#pragma',
+  '#extension',
+  '#version',
+  '#line',
+
+  // 3.5 Preprocessor - Operators
+  'defined',
+
+  // 3.5 Preprocessor - Macros
+  '__LINE__',
+  '__FILE__',
+  '__VERSION__',
+  'GL_ES',
+
+  // 7.1 Vertex Shader Special Variables
+  'gl_VertexID',
+  'gl_InstanceID',
+  'gl_Position',
+  'gl_PointSize',
+
+  // 7.2 Fragment Shader Special Variables
+  'gl_FragCoord',
+  'gl_FrontFacing',
+  'gl_FragDepth',
+  'gl_PointCoord',
+
+  // 7.3 Built-in Constants
+  'gl_MaxVertexAttribs',
+  'gl_MaxVertexUniformVectors',
+  'gl_MaxVertexOutputVectors',
+  'gl_MaxFragmentInputVectors',
+  'gl_MaxVertexTextureImageUnits',
+  'gl_MaxCombinedTextureImageUnits',
+  'gl_MaxTextureImageUnits',
+  'gl_MaxFragmentUniformVectors',
+  'gl_MaxDrawBuffers',
+  'gl_MinProgramTexelOffset',
+  'gl_MaxProgramTexelOffset',
+
+  // 7.4 Built-in Uniform State
+  'gl_DepthRangeParameters',
+  'gl_DepthRange',
+
+  // 8.1 Angle and Trigonometry Functions
+  'radians',
+  'degrees',
+  'sin',
+  'cos',
+  'tan',
+  'asin',
+  'acos',
+  'atan',
+  'sinh',
+  'cosh',
+  'tanh',
+  'asinh',
+  'acosh',
+  'atanh',
+
+  // 8.2 Exponential Functions
+  'pow',
+  'exp',
+  'log',
+  'exp2',
+  'log2',
+  'sqrt',
+  'inversesqrt',
+
+  // 8.3 Common Functions
+  'abs',
+  'sign',
+  'floor',
+  'trunc',
+  'round',
+  'roundEven',
+  'ceil',
+  'fract',
+  'mod',
+  'modf',
+  'min',
+  'max',
+  'clamp',
+  'mix',
+  'step',
+  'smoothstep',
+  'isnan',
+  'isinf',
+  'floatBitsToInt',
+  'floatBitsToUint',
+  'intBitsToFloat',
+  'uintBitsToFloat',
+
+  // 8.4 Floating-Point Pack and Unpack Functions
+  'packSnorm2x16',
+  'unpackSnorm2x16',
+  'packUnorm2x16',
+  'unpackUnorm2x16',
+  'packHalf2x16',
+  'unpackHalf2x16',
+
+  // 8.5 Geometric Functions
+  'length',
+  'distance',
+  'dot',
+  'cross',
+  'normalize',
+  'faceforward',
+  'reflect',
+  'refract',
+  'matrixCompMult',
+  'outerProduct',
+  'transpose',
+  'determinant',
+  'inverse',
+
+  // 8.7 Vector Relational Functions
+  'lessThan',
+  'lessThanEqual',
+  'greaterThan',
+  'greaterThanEqual',
+  'equal',
+  'notEqual',
+  'any',
+  'all',
+  'not',
+
+  // 8.8 Texture Lookup Functions
+  'textureSize',
+  'texture',
+  'textureProj',
+  'textureLod',
+  'textureOffset',
+  'texelFetch',
+  'texelFetchOffset',
+  'textureProjOffset',
+  'textureLodOffset',
+  'textureProjLod',
+  'textureProjLodOffset',
+  'textureGrad',
+  'textureGradOffset',
+  'textureProjGrad',
+  'textureProjGradOffset',
+
+  // 8.9 Fragment Processing Functions
+  'dFdx',
+  'dFdy',
+  'fwidth',
+
+  // Additional directives
+  '#include',
+
+  // WEBGL_multi_draw https://registry.khronos.org/webgl/extensions/WEBGL_multi_draw
+  'gl_DrawID', // vertex only
+
+  // OVR_multiview2 https://registry.khronos.org/webgl/extensions/OVR_multiview2
+  // OCULUS_multiview https://github.com/KhronosGroup/WebGL/issues/2912
+  'gl_ViewID_OVR',
+  'GL_OVR_multiview2',
+]
+
+// 3.2 Character Set, 5.1 Operators
+export const GLSL_SYMBOLS = [
+  // Preprocessor
+  '#',
+
+  // Line continuation
+  '\\',
+
+  // Comments
+  '//',
+  '/*',
+  '*/',
+
+  // Punctuation
+  '.',
+  ',',
+  ';',
+  '{',
+  '}',
+  '(',
+  ')',
+  '[',
+  ']',
+
+  // Comparison
+  '?',
+  ':',
+  '<',
+  '>',
+  '<=',
+  '>=',
+  '&&',
+  '||',
+
+  // Modifier
+  '~',
+  '=',
+  '!',
+  '+',
+  '-',
+  '/',
+  '&',
+  '|',
+  '^',
+  '%',
+  '<<',
+  '>>',
+
+  // Operators
+  '++',
+  '--',
+  '==',
+  '!=',
+  '+=',
+  '-=',
+  '/=',
+  '&=',
+  '|=',
+  '^=',
+  '%=',
+  '<<=',
+  '>>=',
+]

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from './constants'
+export * from './minifier'
+export * from './tokenizer'

package/src/minifier.ts

@@ -0,0 +1,121 @@
+import { type Token, tokenize } from './tokenizer'
+
+export type MangleMatcher = (token: Token, index: number, tokens: Token[]) => boolean
+
+export interface MinifyOptions {
+  /** Whether to rename variables. Will call a {@link MangleMatcher} if specified. Default is `false`. */
+  mangle: boolean | MangleMatcher
+  /** 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
+  /** Whether to rename properties in structs or uniform buffers. Default is `false`. */
+  mangleProperties: boolean
+}
+
+/**
+ * Minifies a string of GLSL code.
+ */
+export function minify(
+  code: string,
+  {
+    mangle = false,
+    mangleMap = new Map(),
+    mangleExternals = false,
+    mangleProperties = false,
+  }: Partial<MinifyOptions> = {},
+): string {
+  const exclude = new Set<string>(mangleMap.values())
+  const tokens: Token[] = tokenize(code).filter((token) => token.type !== 'comment')
+
+  let mangleIndex: number = 0
+  let blockIndex: number | null = null
+  let prefix: string | null = null
+  let minified: string = ''
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i]
+    if (/keyword|identifier/.test(token.type)) {
+      if (/keyword|identifier/.test(tokens[i - 1]?.type)) minified += ' '
+
+      // Resolve nested keys from members or accessors
+      let key = token.value
+      if (prefix) {
+        key = `${prefix}.${token.value}`
+      } else if (tokens[i - 1]?.value === '.' && tokens[i - 2]?.type !== 'symbol') {
+        key = `${tokens[i - 2]?.value}.${token.value}`
+      }
+
+      // Mangle declarations and their references
+      let renamed = mangleMap.get(key)
+      if (
+        // no-op
+        !renamed &&
+        // Filter variable names
+        key !== 'main' &&
+        (typeof mangle === 'boolean' ? mangle : mangle(token, i, tokens)) &&
+        // Is declaration, reference, namespace, or comma-separated list
+        token.type === 'identifier' &&
+        (/keyword|identifier/.test(tokens[i - 1]?.type) || /}|,/.test(tokens[i - 1]?.value))
+      ) {
+        if (
+          // Skip struct properties when specified
+          (!prefix || mangleProperties) &&
+          // Skip shader externals when disabled
+          (blockIndex != null
+            ? // Struct member
+              (mangleExternals && mangleProperties) ||
+              !/(struct|uniform|in|out|attribute|varying)/.test(tokens[blockIndex - 1]?.value)
+            : // Struct header, fully specified uniform, or comma-separated list
+              mangleExternals ||
+              (!/(uniform|in|out|attribute|varying|,)/.test(tokens[i - 1]?.value) &&
+                !/(uniform|in|out|attribute|varying)/.test(tokens[i - 2]?.value)))
+        ) {
+          while (!renamed || exclude.has(renamed)) {
+            renamed = ''
+            mangleIndex++
+
+            let j = mangleIndex
+            while (j > 0) {
+              renamed = String.fromCharCode(97 + ((j % 26) - 1)) + renamed
+              j = Math.floor(j / 26)
+            }
+          }
+
+          mangleMap.set(key, renamed)
+        }
+
+        // Start or stop capturing namespaces, prefer UBO suffix if specified.
+        // If UBOs don't specify a suffix, their inner declarations are global
+        if (tokens[i + 1]?.value === '{') {
+          let j = i
+          while (tokens[j].value !== '}') j++
+          const suffix = tokens[j + 1].value
+          if (suffix !== ';') prefix = suffix
+          blockIndex = i
+        } else if (tokens[i + 2]?.value === '}') {
+          prefix = null
+          blockIndex = null
+        }
+      }
+
+      minified += renamed ?? token.value
+    } else if (token.value === '#') {
+      // Don't pad consecutive directives
+      if (tokens[i - 1]?.value !== '\\') minified += '\n'
+
+      // Join preprocessor directives
+      while (tokens[i].value !== '\\') {
+        if ((tokens[i].type !== 'symbol' || tokens[i - 2]?.value === '#') && tokens[i - 1]?.type !== 'symbol')
+          minified += ' '
+        minified += tokens[i].value
+        i++
+      }
+
+      minified += '\n'
+    } else {
+      minified += token.value
+    }
+  }
+
+  return minified.trim()
+}

package/src/tokenizer.ts

@@ -0,0 +1,66 @@
+import { GLSL_SYMBOLS, GLSL_KEYWORDS } from './constants'
+
+export type TokenType = 'comment' | 'symbol' | 'bool' | 'float' | 'int' | 'uint' | 'identifier' | 'keyword'
+
+export interface Token<T = TokenType, V = string> {
+  type: T
+  value: V
+}
+
+/**
+ * Tokenizes a string of GLSL code.
+ */
+export function tokenize(code: string, index: number = 0): Token[] {
+  const tokens: Token[] = []
+
+  while (index < code.length) {
+    let char = code[index]
+    let value = ''
+
+    // Skip whitespace
+    if (/\s/.test(char)) {
+      index++
+      continue
+    }
+
+    // Escape newlines after directives, skip comments
+    if (char === '#') {
+      let j = index
+      while (code[j] !== '\n' && !/\/[\/\*]/.test(code[j] + code[j + 1])) j++
+      code = code.substring(0, j) + '\\' + code.substring(j)
+    }
+
+    // Parse values and identifiers
+    while ((/\d/.test(char) ? /[\d\.\-\w]/ : /\w/).test(code[index])) value += code[index++]
+
+    // Parse symbols, combine if able
+    if (!value) {
+      value = char
+      for (const symbol of GLSL_SYMBOLS) {
+        if (symbol.length > value.length && code.startsWith(symbol, index)) value = symbol
+      }
+      index += value.length
+    }
+
+    // Label and add token
+    if (/\/[\/\*]/.test(value)) {
+      const isMultiline = value === '/*'
+      while (!value.endsWith(isMultiline ? '*/' : '\n')) value += code[index++]
+      tokens.push({ type: 'comment', value })
+    } else if (!/\w/.test(char)) {
+      tokens.push({ type: 'symbol', value })
+    } else if (/\d/.test(char)) {
+      if (/[uU]/.test(value)) tokens.push({ type: 'uint', value })
+      else if (/[\.eE]/.test(value)) tokens.push({ type: 'float', value })
+      else tokens.push({ type: 'int', value })
+    } else if (/true|false/.test(value)) {
+      tokens.push({ type: 'bool', value })
+    } else if (GLSL_KEYWORDS.includes(tokens[tokens.length - 1]?.value === '#' ? `#${value}` : value)) {
+      tokens.push({ type: 'keyword', value })
+    } else {
+      tokens.push({ type: 'identifier', value })
+    }
+  }
+
+  return tokens
+}