Added support for WGSL

components.json

@@ -1523,6 +1523,10 @@
 			"alias": "webidl",
 			"owner": "RunDevelopment"
 		},
+		"wgsl": {
+			"title": "WGSL",
+			"owner": "Dr4gonthree"
+		},
 		"wiki": {
 			"title": "Wiki markup",
 			"require": "markup",

components/prism-wgsl.js

@@ -0,0 +1,94 @@
+Prism.languages.wgsl = {
+    'comment': {
+        pattern: /\/\/.*|\/\*[\s\S]*?(?:\*\/|$)/,
+        greedy: true,
+    },
+    'attributes': {
+        pattern: /(@)(?:(?:[_\p{XID_Start}][\p{XID_Continue}]+)|(?:[\p{XID_Start}]))/u,
+        lookbehind: true,
+        alias: 'symbol',
+    },
+    'functions': {
+        pattern: /\b(fn)\s+(?:(?:[_\p{XID_Start}][\p{XID_Continue}]+)|(?:[\p{XID_Start}]))(?=(?:\()|(?:<))/u,
+        lookbehind: true,
+        alias: 'function',
+        inside: {},
+    },
+    'keyword': [
+        { pattern: /\b(?:bitcast|block|break|case|continue|continuing|default|discard|else|elseif|enable|fallthrough|for|function|if|loop|private|read|read_write|return|storage|switch|uniform|workgroup|write)\b/ },
+        { pattern: /\b(?:asm|const|do|enum|handle|mat|premerge|regardless|typedef|unless|using|vec|void|while)\b/ },
+        { pattern: /\b(?:let|var)\b/ },
+        { pattern: /\b(?:type)\b/ },
+        { pattern: /\b(?:enum)\b/ },
+        { pattern: /\bfn\b/ },
+    ],
+    'function-calls': {
+        pattern: /(?:(?:[_\p{XID_Start}][\p{XID_Continue}]+)|(?:[\p{XID_Start}]))(?=\()/u,
+        alias: 'function',
+        inside: {},
+    },
+    'types': [
+        { pattern: /\b(?:bool|i32|u32|f32)\b/, alias: 'builtin' },
+        { pattern: /\b(?:i64|u64|f64)\b/, alias: 'builtin' },
+        { pattern: /\b(?:vec[2-4]|mat[2-4]x[2-4])\b/, alias: 'builtin' },
+        { pattern: /\b(?:atomic)\b/, alias: 'builtin' },
+        { pattern: /\b(?:array)\b/, alias: 'builtin' },
+        { pattern: /\b(?:override|ptr|sampler|sampler_comparison|staticAssert|struct)\b/, alias: 'builtin' },
+        { pattern: /\b(?:texture_1d|texture_2d|texture_2d_array|texture_3d|texture_cube|texture_cube_array|texture_multisampled_2d)\b/, alias: 'builtin' },
+        { pattern: /\b(?:texture_storage_1d|texture_storage_2d|texture_storage_2d_array|texture_storage_3d|texture_depth_2d)\b/, alias: 'builtin' },
+        { pattern: /\b(?:texture_depth_2d_array|texture_depth_cube|texture_depth_cube_array|texture_depth_multisampled_2d)\b/, alias: 'builtin' },
+        { pattern: /\b(?:[A-Z][A-Za-z0-9]*)\b/, alias: 'class-name' },
+    ],
+    'built-in-values': [
+        { pattern: /\b(?:vertex_index|instance_index|position)\b/, alias: 'namespace' },
+        { pattern: /\b(?:front_facing|frag_depth|sample_index|sample_mask)\b/, alias: 'namespace' },
+        { pattern: /\b(?:local_invocation_id|local_invocation_index|global_invocation_id|workgroup_id|num_workgroups)\b/, alias: 'namespace' },
+    ],
+    'bool-literal': {
+        pattern: /\b(?:true|false)\b/,
+        alias: 'boolean',
+    },
+    'hex-int-literal': [
+        { pattern: /\b0[xX][0-9a-fA-F]+[iu]?(?!(?:\.|p|P))\b/, alias:'number' },
+    ],
+    'hex-float-literal': [
+        { pattern: /0[xX][0-9a-fA-F]*\.[0-9a-fA-F]+(?:[pP](?:\+|-)?[0-9]+[fh]?)?/, alias:'number' },
+        { pattern: /0[xX][0-9a-fA-F]+\.[0-9a-fA-F]*(?:[pP](?:\+|-)?[0-9]+[fh]?)?/, alias:'number' },
+        { pattern: /0[xX][0-9a-fA-F]+[pP](?:\+|-)?[0-9]+[fh]?/, alias:'number' },
+    ],
+    'decimal-float-literal-a': [
+        { pattern: /[0-9]*\.[0-9]+(?:[eE](?:\+|-)?[0-9]+)?[fh]?/, alias:'number' },
+        { pattern: /[0-9]+\.[0-9]*(?:[eE](?:\+|-)?[0-9]+)?[fh]?/, alias:'number' },
+        { pattern: /[0-9]+[eE](?:\+|-)?[0-9]+[fh]?/, alias:'number' },
+    ],
+    'variables': {
+        pattern: /\b(?:(?:[_\p{XID_Start}][\p{XID_Continue}]+)|(?:[\p{XID_Start}]))\b/u,
+        alias: 'variable',
+    },
+    'decimal-float-literal-b': [
+        { pattern: /0[fh]/, alias:'number' },
+        { pattern: /[1-9][0-9]*[fh]/, alias:'number' },
+    ],
+    'int-literal': [
+        { pattern: /0[iu]?/, alias:'number' },
+        { pattern: /[1-9][0-9]*[iu]?/, alias:'number' },
+    ],
+    'operator': [
+        { pattern: /(?:\^|~|\||\|\||&&|<<|>>|!)(?!=)/ },
+        { pattern: /&(?![&=])/ },
+        { pattern: /(?:\+=|-=|\*=|\/=|%=|\^=|&=|\|=|<<=|>>=)/},
+        { pattern: /(?<![<>])=(?!=|>)/ },
+        { pattern: /(?:=(?:=)?(?!>)|!=|<=|(?<!=)>=)/ },
+        { pattern: /(?:(?:[+%]|(?:\*(?!\w)))(?!=))|(?:-(?!>))|(?:\/(?!\/))/ },
+        { pattern: /\.(?!\.)/ },
+        { pattern: /->/ },
+    ],
+    'punctuation': [
+        { pattern: /,/ },
+        { pattern: /[{}]/ },
+        { pattern: /[\(\)]/ },
+        { pattern: /;/ },
+        { pattern: /[\[\]]/ },
+        { pattern: /(?<!=)[<>]/ },
+    ],
+};

examples/prism-wgsl.html

@@ -0,0 +1,60 @@
+<h2>Full example</h2>
+<pre><code>// Vertex shader
+struct CameraUniform {
+    view_proj: mat4x4&lt;f32&gt;;
+};
+[[group(1), binding(0)]]
+var&lt;uniform&gt; camera: CameraUniform;
+
+struct InstanceInput {
+    [[location(5)]] model_matrix_0: vec4&lt;f32&gt;;
+    [[location(6)]] model_matrix_1: vec4&lt;f32&gt;;
+    [[location(7)]] model_matrix_2: vec4&lt;f32&gt;;
+    [[location(8)]] model_matrix_3: vec4&lt;f32&gt;;
+};
+
+struct VertexInput {
+    [[location(0)]] position: vec3&lt;f32&gt;; 
+    [[location(1)]] tex_coords: vec2&lt;f32&gt;;
+};
+
+struct VertexOutput {
+    [[builtin(position)]] clip_position: vec4&lt;f32&gt;;
+    [[location(0)]] tex_coords: vec2&lt;f32&gt;;
+};
+
+@vertex
+[[stage(vertex)]]
+fn vs_main(
+    model: VertexInput,
+    instance: InstanceInput,
+) -&gt; VertexOutput {
+    let model_matrix = mat4x4&lt;f32&gt;(
+        instance.model_matrix_0,
+        instance.model_matrix_1,
+        instance.model_matrix_2,
+        instance.model_matrix_3,
+    );
+
+    bool mybool1 = true;
+    bool mybool2 = false;
+
+    var out: VertexOutput;
+    out.tex_coords = model.tex_coords;
+    out.clip_position = camera.view_proj * model_matrix * vec4&lt;f32&gt;(model.position, 1.0);
+    return out;
+}
+
+// Fragment shader
+
+[[group(0), binding(0)]]
+var t_diffuse: texture_2d&lt;f32&gt;;
+[[group(0), binding(1)]]
+var s_diffuse: sampler;
+
+@fragment
+[[stage(fragment)]]
+fn fs_main(in: VertexOutput) -&gt; [[location(0)]] vec4&lt;f32&gt; {
+    return textureSample(t_diffuse, s_diffuse, in.tex_coords);
+}
+</code></pre>

plugins/show-language/prism-show-language.js

@@ -267,6 +267,7 @@
 		"wasm": "WebAssembly",
 		"web-idl": "Web IDL",
 		"webidl": "Web IDL",
+		"wgsl": "WGSL",
 		"wiki": "Wiki markup",
 		"wolfram": "Wolfram language",
 		"nb": "Mathematica Notebook",