shaderkit 0.0.2 → 0.1.1

package/dist/index.mjs

@@ -1,3 +1,457 @@
+const WGSL_KEYWORDS = [
+  // 5.2.6 Vector Types
+  "vec2",
+  "vec2i",
+  "vec2u",
+  "vec2f",
+  "vec2h",
+  "vec3",
+  "vec3i",
+  "vec3u",
+  "vec3f",
+  "vec3h",
+  "vec4",
+  "vec4i",
+  "vec4u",
+  "vec4f",
+  "vec4h",
+  // 5.2.7 Matrix Types
+  "mat2x2",
+  "mat2x2f",
+  "mat2x2h",
+  "mat2x3",
+  "mat2x3f",
+  "mat2x3h",
+  "mat2x4",
+  "mat2x4f",
+  "mat2x4h",
+  "mat3x2",
+  "mat3x2f",
+  "mat3x2h",
+  "mat3x3",
+  "mat3x3f",
+  "mat3x3h",
+  "mat3x4",
+  "mat3x4f",
+  "mat3x4h",
+  "mat4x2",
+  "mat4x2f",
+  "mat4x2h",
+  "mat4x3",
+  "mat4x3f",
+  "mat4x3h",
+  "mat4x4",
+  "mat4x4f",
+  "mat4x4h",
+  // 15.1.1 Type-defining Keywords
+  "array",
+  "atomic",
+  "bool",
+  "f32",
+  "f16",
+  "i32",
+  // 'mat2x2',
+  // 'mat2x3',
+  // 'mat2x4',
+  // 'mat3x2',
+  // 'mat3x3',
+  // 'mat3x4',
+  // 'mat4x2',
+  // 'mat4x3',
+  // 'mat4x4',
+  "ptr",
+  "sampler",
+  "sampler_comparison",
+  "texture_1d",
+  "texture_2d",
+  "texture_2d_array",
+  "texture_3d",
+  "texture_cube",
+  "texture_cube_array",
+  "texture_multisampled_2d",
+  "texture_storage_1d",
+  "texture_storage_2d",
+  "texture_storage_2d_array",
+  "texture_storage_3d",
+  "texture_depth_2d",
+  "texture_depth_2d_array",
+  "texture_depth_cube",
+  "texture_depth_cube_array",
+  "texture_depth_multisampled_2d",
+  "u32",
+  // 'vec2',
+  // 'vec3',
+  // 'vec4',
+  // 15.1.2 Other Keywords
+  "alias",
+  "bitcast",
+  "break",
+  "case",
+  "const",
+  "const_assert",
+  "continue",
+  "continuing",
+  "default",
+  "discard",
+  "else",
+  "enable",
+  "false",
+  "fn",
+  "for",
+  "if",
+  "let",
+  "loop",
+  "override",
+  "return",
+  "struct",
+  "switch",
+  "true",
+  "var",
+  "while",
+  // 15.2 Reserved Words
+  "Hullshader",
+  "NULL",
+  "Self",
+  "abstract",
+  "active",
+  "alignas",
+  "alignof",
+  "as",
+  "asm",
+  "asm_fragment",
+  "async",
+  "attribute",
+  "auto",
+  "await",
+  "become",
+  "bf16",
+  "binding_array",
+  "cast",
+  "catch",
+  "class",
+  "co_await",
+  "co_return",
+  "co_yield",
+  "coherent",
+  "column_major",
+  "common",
+  "compile",
+  "compile_fragment",
+  "concept",
+  "const_cast",
+  "consteval",
+  "constexpr",
+  "constinit",
+  "crate",
+  "debugger",
+  "decltype",
+  "delete",
+  "demote",
+  "demote_to_helper",
+  "do",
+  "dynamic_cast",
+  "enum",
+  "explicit",
+  "export",
+  "extends",
+  "extern",
+  "external",
+  "f64",
+  "fallthrough",
+  "filter",
+  "final",
+  "finally",
+  "friend",
+  "from",
+  "fxgroup",
+  "get",
+  "goto",
+  "groupshared",
+  "handle",
+  "highp",
+  "i16",
+  "i64",
+  "i8",
+  "impl",
+  "implements",
+  "import",
+  "inline",
+  "instanceof",
+  "interface",
+  "layout",
+  "lowp",
+  "macro",
+  "macro_rules",
+  "match",
+  "mediump",
+  "meta",
+  "mod",
+  "module",
+  "move",
+  "mut",
+  "mutable",
+  "namespace",
+  "new",
+  "nil",
+  "noexcept",
+  "noinline",
+  "nointerpolation",
+  "noperspective",
+  "null",
+  "nullptr",
+  "of",
+  "operator",
+  "package",
+  "packoffset",
+  "partition",
+  "pass",
+  "patch",
+  "pixelfragment",
+  "precise",
+  "precision",
+  "premerge",
+  "priv",
+  "protected",
+  "pub",
+  "public",
+  "quat",
+  "readonly",
+  "ref",
+  "regardless",
+  "register",
+  "reinterpret_cast",
+  "requires",
+  "resource",
+  "restrict",
+  "self",
+  "set",
+  "shared",
+  "sizeof",
+  "smooth",
+  "snorm",
+  "static",
+  "static_assert",
+  "static_cast",
+  "std",
+  "subroutine",
+  "super",
+  "target",
+  "template",
+  "this",
+  "thread_local",
+  "throw",
+  "trait",
+  "try",
+  "type",
+  "typedef",
+  "typeid",
+  "typename",
+  "typeof",
+  "u16",
+  "u64",
+  "u8",
+  "union",
+  "unless",
+  "unorm",
+  "unsafe",
+  "unsized",
+  "use",
+  "using",
+  "varying",
+  "virtual",
+  "volatile",
+  "wgsl",
+  "where",
+  "with",
+  "writeonly",
+  "yield",
+  // 15.4 Context-Dependent Name Tokens - Attributes
+  "align",
+  "binding",
+  "builtin",
+  "compute",
+  "const",
+  "fragment",
+  "group",
+  "id",
+  "interpolate",
+  "invariant",
+  "location",
+  "size",
+  "vertex",
+  "workgroup_size",
+  // 15.4 Context-Dependent Name Tokens - Interpolation Types
+  "perspective",
+  "linear",
+  "flat",
+  // 15.4 Context-Dependent Name Tokens - Interpolation Sampling
+  "center",
+  "centroid",
+  "sample",
+  // 15.4 Context-Dependent Name Tokens - Built-in Values
+  "vertex_index",
+  "instance_index",
+  "position",
+  "front_facing",
+  "frag_depth",
+  "local_invocation_id",
+  "local_invocation_index",
+  "global_invocation_id",
+  "workgroup_id",
+  "num_workgroups",
+  "sample_index",
+  "sample_mask",
+  // 15.4 Context-Dependent Name Tokens - Access Modes
+  "read",
+  "write",
+  "read_write",
+  // 15.4 Context-Dependent Name Tokens - Address Spaces
+  "function",
+  "private",
+  "workgroup",
+  "uniform",
+  "storage",
+  // 15.4 Context-Dependent Name Tokens - Texel Formats
+  "rgba8unorm",
+  "rgba8snorm",
+  "rgba8uint",
+  "rgba8sint",
+  "rgba16uint",
+  "rgba16sint",
+  "rgba16float",
+  "r32uint",
+  "r32sint",
+  "r32float",
+  "rg32uint",
+  "rg32sint",
+  "rg32float",
+  "rgba32uint",
+  "rgba32sint",
+  "rgba32float",
+  "bgra8unorm",
+  // 15.4 Context-Dependent Name Tokens - Extensions
+  "f16",
+  // v1 optional
+  // 17.1 Logical Built-in Functions
+  "all",
+  "any",
+  "select",
+  // 17.2 Array Built-in Functions
+  "arrayLength",
+  // 17.3 Numeric Built-in Functions
+  "abs",
+  "acos",
+  "acosh",
+  "asin",
+  "asinh",
+  "atan",
+  "atanh",
+  "atan2",
+  "ceil",
+  "clamp",
+  "cos",
+  "cosh",
+  "countLeadingZeros",
+  "countOneBits",
+  "countTrailingZeros",
+  "cross",
+  "degrees",
+  "determinant",
+  "distance",
+  "dot",
+  "exp",
+  "exp2",
+  "extractBits",
+  "faceForward",
+  "firstLeadingBit",
+  "firstTrailingBit",
+  "floor",
+  "fma",
+  "fract",
+  "frexp",
+  "insertBits",
+  "inverseSqrt",
+  "ldexp",
+  "length",
+  "log",
+  "log2",
+  "max",
+  "min",
+  "mix",
+  "modf",
+  "normalize",
+  "pow",
+  "quantizeToF16",
+  "radians",
+  "reflect",
+  "refract",
+  "reverseBits",
+  "round",
+  "saturate",
+  "sign",
+  "sin",
+  "sinh",
+  "smoothstep",
+  "sqrt",
+  "step",
+  "tan",
+  "tanh",
+  "transpose",
+  "trunc",
+  // 17.4 Derivative Built-in Functions
+  "dpdx",
+  "dpdxCoarse",
+  "dpdxFine",
+  "dpdy",
+  "dpdyCoarse",
+  "dpdyFine",
+  "fwidth",
+  "fwidthCoarse",
+  "fwidthFine",
+  // 17.5 Texture Built-in Functions
+  "textureDimensions",
+  "textureGather",
+  "textureGatherCompare",
+  "textureLoad",
+  "textureNumLayers",
+  "textureNumLevels",
+  "textureNumSamples",
+  "textureSample",
+  "textureSampleBias",
+  "textureSampleCompare",
+  "textureSampleCompareLevel",
+  "textureSampleGrad",
+  "textureSampleLevel",
+  "textureSampleBaseClampToEdge",
+  // 17.6 Atomic Built-in Functions
+  "atomicLoad",
+  "atomicStore",
+  "atomicAdd",
+  "atomicSub",
+  "atomicMax",
+  "atomicMin",
+  "atomicAnd",
+  "atomicOr",
+  "atomicXor",
+  "atomicExchange",
+  "atomicCompareExchangeWeak",
+  // 17.7 Data Packing Built-in Functions
+  "pack4x8snorm",
+  "pack4x8unorm",
+  "pack2x16snorm",
+  "pack2x16unorm",
+  "pack2x16float",
+  // 17.8 Data Unpacking Built-in Functions
+  "unpack4x8snorm",
+  "unpack4x8unorm",
+  "unpack2x16snorm",
+  "unpack2x16unorm",
+  "unpack2x16float",
+  // 17.9 Synchronization Built-in Functions
+  "storageBarrier",
+  "workgroupBarrier",
+  "workgroupUniformLoad"
+];
 const GLSL_KEYWORDS = [
   // 3.8 Keywords
   "const",
@@ -173,19 +627,19 @@ const GLSL_KEYWORDS = [
   "namespace",
   "using",
   // 3.5 Preprocessor
-  "#define",
-  "#undef",
-  "#if",
-  "#ifdef",
-  "#ifndef",
-  "#else",
-  "#elif",
-  "#endif",
-  "#error",
-  "#pragma",
-  "#extension",
-  "#version",
-  "#line",
+  "define",
+  "undef",
+  "if",
+  "ifdef",
+  "ifndef",
+  "else",
+  "elif",
+  "endif",
+  "error",
+  "pragma",
+  "extension",
+  "version",
+  "line",
   // 3.5 Preprocessor - Operators
   "defined",
   // 3.5 Preprocessor - Macros
@@ -316,7 +770,7 @@ const GLSL_KEYWORDS = [
   "dFdy",
   "fwidth",
   // Additional directives
-  "#include",
+  "include",
   // WEBGL_multi_draw https://registry.khronos.org/webgl/extensions/WEBGL_multi_draw
   "gl_DrawID",
   // vertex only
@@ -325,11 +779,11 @@ const GLSL_KEYWORDS = [
   "gl_ViewID_OVR",
   "GL_OVR_multiview2"
 ];
-const GLSL_SYMBOLS = [
-  // Preprocessor
+const SYMBOLS = [
+  // Preprocessor (GLSL)
   "#",
-  // Line continuation
-  "\\",
+  // Function arrow (WGSL)
+  "->",
   // Comments
   "//",
   "/*",
@@ -381,142 +835,129 @@ const GLSL_SYMBOLS = [
   "<<=",
   ">>="
 ];
+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) => ZERO <= c && c <= NINE;
+const isAlpha = (c) => (c &= ~32, A <= c && c <= Z);
+const isLine = (c) => c === LF || c === CR;
+const isSpace = (c) => isLine(c) || c === TAB || c === SPACE;
+const isNumber = (c) => isAlpha(c) || isDigit(c) || c === PLUS || c === MINUS || c === DOT;
+const isIdent = (c) => isAlpha(c) || isDigit(c) || c === UNDERSCORE;
 function tokenize(code, index = 0) {
-  var _a;
   const tokens = [];
+  const KEYWORDS = isWGSL(code) ? WGSL_KEYWORDS : GLSL_KEYWORDS;
   while (index < code.length) {
-    let char = code[index];
-    let value = "";
-    if (/\s/.test(char)) {
-      index++;
-      continue;
-    }
-    if (char === "#") {
-      let j = index;
-      while (code[j] !== "\n" && !/\/[\/\*]/.test(code[j] + code[j + 1]))
-        j++;
-      code = code.substring(0, j) + "\\" + code.substring(j);
-    }
-    while ((/\d/.test(char) ? /[\d\.\-\w]/ : /\w/).test(code[index]))
-      value += code[index++];
-    if (!value) {
-      value = char;
-      for (const symbol of GLSL_SYMBOLS) {
-        if (symbol.length > value.length && code.startsWith(symbol, index))
-          value = symbol;
-      }
-      index += value.length;
-    }
-    if (/\/[\/\*]/.test(value)) {
-      const isMultiline = value === "/*";
-      while (!value.endsWith(isMultiline ? "*/" : "\n"))
+    let value = code[index];
+    const char = code.charCodeAt(index++);
+    if (isSpace(char)) {
+      while (isSpace(code.charCodeAt(index)))
         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: "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 (/^(true|false)$/.test(value)) {
-      tokens.push({ type: "bool", value });
-    } else if (GLSL_KEYWORDS.includes(((_a = tokens[tokens.length - 1]) == null ? void 0 : _a.value) === "#" ? `#${value}` : value)) {
-      tokens.push({ type: "keyword", 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 {
-      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 });
     }
   }
   return tokens;
 }
-function minify(code, {
-  mangle = false,
-  mangleMap = /* @__PURE__ */ new Map(),
-  mangleExternals = false,
-  mangleProperties = false
-} = {}) {
-  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n;
+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|,)$/);
+function minify(code, { mangle = false, mangleMap = /* @__PURE__ */ new Map(), mangleExternals = false } = {}) {
+  var _a, _b, _c, _d, _e, _f, _g, _h;
+  code = code.replace(/(^\s*#[^\\]*?)(\n|\/[\/\*])/gm, "$1\\$2");
   const exclude = new Set(mangleMap.values());
-  const tokens = tokenize(code).filter((token) => token.type !== "comment");
+  const tokens = tokenize(code).filter((token) => token.type !== "whitespace" && token.type !== "comment");
   let mangleIndex = 0;
   let blockIndex = null;
-  let prefix = null;
   let minified = "";
   for (let i = 0; i < tokens.length; i++) {
     const token = tokens[i];
-    if (/keyword|identifier/.test(token.type)) {
-      if (/keyword|identifier/.test((_a = tokens[i - 1]) == null ? void 0 : _a.type))
-        minified += " ";
-      let key = token.value;
-      if (prefix) {
-        key = `${prefix}.${token.value}`;
-      } else if (((_b = tokens[i - 1]) == null ? void 0 : _b.value) === "." && ((_c = tokens[i - 2]) == null ? void 0 : _c.type) !== "symbol") {
-        key = `${(_d = tokens[i - 2]) == null ? void 0 : _d.value}.${token.value}`;
-      }
-      let renamed = mangleMap.get(key);
+    if (isWord(token.value) && isWord((_a = tokens[i - 1]) == null ? void 0 : _a.value))
+      minified += " ";
+    if (token.value === "{" && isName((_b = tokens[i - 1]) == null ? void 0 : _b.value))
+      blockIndex = i - 1;
+    else if (token.value === "}")
+      blockIndex = null;
+    if (isName(token.value)) {
+      let renamed = mangleMap.get(token.value);
       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((_e = tokens[i - 1]) == null ? void 0 : _e.type) || /}|,/.test((_f = tokens[i - 1]) == null ? void 0 : _f.value))
+        !renamed && // Skip struct properties
+        blockIndex == null && // Filter variable names
+        token.value !== "main" && (typeof mangle === "boolean" ? mangle : mangle(token, i, tokens)) && // Is declaration, reference, namespace, or comma-separated list
+        token.type === "identifier" && (isName((_c = tokens[i - 1]) == null ? void 0 : _c.value) || /}|,/.test((_d = tokens[i - 1]) == null ? void 0 : _d.value) || ((_e = tokens[i + 1]) == null ? void 0 : _e.value) === ":") && // Skip shader externals when disabled
+        (mangleExternals || !isStorage((_f = tokens[i - 1]) == null ? void 0 : _f.value) && !isStorage((_g = tokens[i - 2]) == null ? void 0 : _g.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((_g = tokens[blockIndex - 1]) == null ? void 0 : _g.value)
-          ) : (
-            // Struct header, fully specified uniform, or comma-separated list
-            mangleExternals || !/(uniform|in|out|attribute|varying|,)/.test((_h = tokens[i - 1]) == null ? void 0 : _h.value) && !/(uniform|in|out|attribute|varying)/.test((_i = tokens[i - 2]) == null ? void 0 : _i.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);
-            }
+        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);
-        }
-        if (((_j = tokens[i + 1]) == null ? void 0 : _j.value) === "{") {
-          let j = i;
-          while (tokens[j].value !== "}")
-            j++;
-          const suffix = tokens[j + 1].value;
-          if (suffix !== ";")
-            prefix = suffix;
-          blockIndex = i;
-        } else if (((_k = tokens[i + 2]) == null ? void 0 : _k.value) === "}") {
-          prefix = null;
-          blockIndex = null;
         }
+        mangleMap.set(token.value, renamed);
       }
       minified += renamed != null ? renamed : token.value;
-    } else if (token.value === "#") {
-      if (((_l = tokens[i - 1]) == null ? void 0 : _l.value) !== "\\")
-        minified += "\n";
-      while (tokens[i].value !== "\\") {
-        if ((tokens[i].type !== "symbol" || ((_m = tokens[i - 2]) == null ? void 0 : _m.value) === "#") && ((_n = tokens[i - 1]) == null ? void 0 : _n.type) !== "symbol")
-          minified += " ";
-        minified += tokens[i].value;
-        i++;
-      }
-      minified += "\n";
+      if (token.value === "include")
+        minified += " ";
     } else {
-      minified += token.value;
+      if (token.value === "#" && ((_h = tokens[i - 1]) == null ? void 0 : _h.value) !== "\\")
+        minified += "\n#";
+      else if (token.value === "\\")
+        minified += "\n";
+      else
+        minified += token.value;
     }
   }
   return minified.trim();
 }
 export {
   GLSL_KEYWORDS,
-  GLSL_SYMBOLS,
+  SYMBOLS,
+  WGSL_KEYWORDS,
   minify,
   tokenize
 };