shaderkit 0.0.2 → 0.1.1

package/src/minifier.ts

@@ -9,111 +9,78 @@ export interface MinifyOptions {
   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
 }
 
+const isWord = RegExp.prototype.test.bind(/^\w/)
+const isName = RegExp.prototype.test.bind(/^[A-Za-z]/)
+const isStorage = RegExp.prototype.test.bind(/^(uniform|in|out|attribute|varying|,)$/)
+
 /**
- * Minifies a string of GLSL code.
+ * Minifies a string of GLSL or WGSL code.
  */
 export function minify(
   code: string,
-  {
-    mangle = false,
-    mangleMap = new Map(),
-    mangleExternals = false,
-    mangleProperties = false,
-  }: Partial<MinifyOptions> = {},
+  { mangle = false, mangleMap = new Map(), mangleExternals = false }: Partial<MinifyOptions> = {},
 ): string {
+  // Escape newlines after directives, skip comments
+  code = code.replace(/(^\s*#[^\\]*?)(\n|\/[\/\*])/gm, '$1\\$2')
+
   const exclude = new Set<string>(mangleMap.values())
-  const tokens: Token[] = tokenize(code).filter((token) => token.type !== 'comment')
+  const tokens: Token[] = tokenize(code).filter((token) => token.type !== 'whitespace' && 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}`
-      }
+    // Pad alphanumeric tokens
+    if (isWord(token.value) && isWord(tokens[i - 1]?.value)) minified += ' '
+
+    // Mark enter/leave block-scope
+    if (token.value === '{' && isName(tokens[i - 1]?.value)) blockIndex = i - 1
+    else if (token.value === '}') blockIndex = null
 
-      // Mangle declarations and their references
-      let renamed = mangleMap.get(key)
+    // Mangle declarations and their references
+    if (isName(token.value)) {
+      let renamed = mangleMap.get(token.value)
       if (
         // no-op
         !renamed &&
+        // Skip struct properties
+        blockIndex == null &&
         // Filter variable names
-        key !== 'main' &&
+        token.value !== '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))
+        (isName(tokens[i - 1]?.value) || /}|,/.test(tokens[i - 1]?.value) || tokens[i + 1]?.value === ':') &&
+        // Skip shader externals when disabled
+        (mangleExternals || (!isStorage(tokens[i - 1]?.value) && !isStorage(tokens[i - 2]?.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++
+        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)
-            }
+          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
-        }
+        mangleMap.set(token.value, renamed)
       }
 
       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'
+      // three.js has a white-space sensitive RegExp
+      // https://github.com/mrdoob/three.js/blob/dev/src/renderers/webgl/WebGLProgram.js#L206
+      if (token.value === 'include') minified += ' '
     } else {
-      minified += token.value
+      if (token.value === '#' && tokens[i - 1]?.value !== '\\') minified += '\n#'
+      else if (token.value === '\\') minified += '\n'
+      else minified += token.value
     }
   }
 

package/src/tokenizer.ts

@@ -1,64 +1,73 @@
-import { GLSL_SYMBOLS, GLSL_KEYWORDS } from './constants'
+import { SYMBOLS, WGSL_KEYWORDS, GLSL_KEYWORDS } from './constants'
 
-export type TokenType = 'comment' | 'symbol' | 'bool' | 'float' | 'int' | 'uint' | 'identifier' | 'keyword'
+export type TokenType = 'whitespace' | 'comment' | 'symbol' | 'bool' | 'float' | 'int' | 'identifier' | 'keyword'
 
 export interface Token<T = TokenType, V = string> {
   type: T
   value: V
 }
 
+// Checks for WGSL-specific `fn foo(`, `var bar =`, and `let baz =`
+const isWGSL = RegExp.prototype.test.bind(/\bfn\s+\w+\s*\(|\b(var|let)\b/)
+
+const isFloat = RegExp.prototype.test.bind(/\.|[eEpP][-+]?\d|[fFhH]$/)
+const isBool = RegExp.prototype.test.bind(/^(true|false)$/)
+
+const ZERO = 48
+const NINE = 57
+const A = 65
+const Z = 90
+const LF = 10
+const CR = 13
+const TAB = 9
+const SPACE = 32
+const PLUS = 43
+const MINUS = 45
+const DOT = 46
+const UNDERSCORE = 95
+const SLASH = 47
+const STAR = 42
+
+const isDigit = (c: number) => ZERO <= c && c <= NINE
+const isAlpha = (c: number) => ((c &= ~32), A <= c && c <= Z)
+const isLine = (c: number) => c === LF || c === CR
+const isSpace = (c: number) => isLine(c) || c === TAB || c === SPACE
+const isNumber = (c: number) => isAlpha(c) || isDigit(c) || c === PLUS || c === MINUS || c === DOT
+const isIdent = (c: number) => isAlpha(c) || isDigit(c) || c === UNDERSCORE
+
 /**
- * Tokenizes a string of GLSL code.
+ * Tokenizes a string of GLSL or WGSL code.
  */
 export function tokenize(code: string, index: number = 0): Token[] {
   const tokens: Token[] = []
 
+  const KEYWORDS = isWGSL(code) ? WGSL_KEYWORDS : GLSL_KEYWORDS
   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++]
+    let value = code[index]
+    const char = code.charCodeAt(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 === '/*'
+    if (isSpace(char)) {
+      while (isSpace(code.charCodeAt(index))) value += code[index++]
+      tokens.push({ type: 'whitespace', value })
+    } else if (isDigit(char)) {
+      while (isNumber(code.charCodeAt(index))) value += code[index++]
+      if (isFloat(value)) tokens.push({ type: 'float', value })
+      else tokens.push({ type: 'int', value })
+    } else if (isAlpha(char)) {
+      while (isIdent(code.charCodeAt(index))) value += code[index++]
+      if (isBool(value)) tokens.push({ type: 'bool', value })
+      else if (KEYWORDS.includes(value)) tokens.push({ type: 'keyword', value })
+      else tokens.push({ type: 'identifier', value })
+    } else if (char === SLASH && (code.charCodeAt(index) === SLASH || code.charCodeAt(index) === STAR)) {
+      const isMultiline = code.charCodeAt(index) === STAR
       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]-?\d/.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 })
+      for (const symbol of SYMBOLS) {
+        if (symbol.length > value.length && code.startsWith(symbol, index - 1)) value = symbol
+      }
+      index += value.length - 1
+      tokens.push({ type: 'symbol', value })
     }
   }