@luma.gl/shaders 10.0.0-alpha.8 → 10.0.0-alpha.9

package/src/lib/shader-assembly/shader-assembly-types.ts

@@ -5,7 +5,7 @@
 import {type PlatformInfo} from './platform-info';
 import {type ShaderModule} from '../shader-module/shader-module';
 import {type ShaderHook} from './shader-hooks';
-import {type ShaderInjection} from './shader-injections';
+import {type ShaderInjection, type ResolvedShaderInjection} from './shader-injections';
 import {type AttributeShaderType} from '../../types';
 import {type ResolvedShaderPluginInterStageVariable} from '../shader-plugin';
 
@@ -45,13 +45,13 @@ export type AssembleShaderOptions = {
   /** GLSL only: Overrides to be injected. In WGSL these are supplied during Pipeline creation time */
   constants?: Record<string, number>;
   /** Per-call hooks, appended after registered assembler hooks; matching names override for this call. */
-  hookFunctions?: readonly (ShaderHook | string)[];
+  hookFunctions?: readonly ShaderHook[];
   /** Hook declarations contributed by resolved plugins. */
   pluginHooks?: readonly ShaderHook[];
   /** Code injections */
-  inject?: Record<string, string | ShaderInjection>;
+  inject?: readonly ShaderInjection[] | Record<string, string | ResolvedShaderInjection>;
   /** Ordered code injections contributed by ShaderPlugin descriptors. */
-  pluginInjections?: Record<string, ShaderInjection[]>;
+  pluginInjections?: Record<string, ResolvedShaderInjection[]>;
   /** Vertex inputs contributed by ShaderPlugin descriptors. */
   pluginVertexInputs?: Record<string, AttributeShaderType>;
   /** Inter-stage variables contributed by ShaderPlugin descriptors. */
@@ -81,13 +81,13 @@ export type AssembleStageOptions = {
   /** GLSL only: Overrides to be injected. In WGSL these are supplied during Pipeline creation time */
   constants?: Record<string, number>;
   /** Per-call hooks, appended after registered assembler hooks; matching names override for this call. */
-  hookFunctions?: readonly (ShaderHook | string)[];
+  hookFunctions?: readonly ShaderHook[];
   /** Hook declarations contributed by resolved plugins. */
   pluginHooks?: readonly ShaderHook[];
   /** Code injections */
-  inject?: Record<string, string | ShaderInjection>;
+  inject?: readonly ShaderInjection[] | Record<string, string | ResolvedShaderInjection>;
   /** Ordered code injections contributed by ShaderPlugin descriptors. */
-  pluginInjections?: Record<string, ShaderInjection[]>;
+  pluginInjections?: Record<string, ResolvedShaderInjection[]>;
   /** Vertex inputs contributed by ShaderPlugin descriptors. */
   pluginVertexInputs?: Record<string, AttributeShaderType>;
   /** Inter-stage variables contributed by ShaderPlugin descriptors. */

package/src/lib/shader-assembly/shader-hooks.ts

@@ -2,51 +2,57 @@
 // SPDX-License-Identifier: MIT
 // SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
 
-import type {ShaderInjection} from './shader-injections';
+import type {ResolvedShaderInjection} from './shader-injections';
 
-/**
- * The shader hook mechanism allows the application to create shaders
- * that can be automatically extended by the shader modules the application
- * includes.
- *
- * A shader hook function that shader modules can inject code into.
- * Shaders can call these functions, which will be no-ops by default.
- *
- * If a shader module injects code it will be executed upon the hook
- * function call.
- */
-export type ShaderHook = {
-  /** `vs:` or `fs:` followed by the name and arguments of the function, e.g. `vs:MYHOOK_func(inout vec4 value)`. Hook name without arguments
-  will also be used as the name of the shader hook */
-  hook: string;
-  /** Code always included at the beginning of a hook function */
+/** Language-specific source for a callable shader hook. */
+export type ShaderHookImplementation = {
+  /** Function parameters in the selected shader language, without parentheses. */
+  parameters: string;
+  /** Return type in this language. Omit for a hook that returns no value. */
+  returnType?: string;
+  /** Source included before injected code. */
   header?: string;
-  /** Code always included at the end of a hook function */
+  /** Source included after injected code. */
   footer?: string;
-  /** To Be Documented */
-  signature?: string;
 };
 
-/** Optional source included before or after every injection in a hook function. */
-export type ShaderHookOptions = Pick<ShaderHook, 'header' | 'footer'>;
+/** One logical extension point with independent GLSL and WGSL syntax. */
+export type ShaderHook = {
+  /** Function name shared by both shader languages. */
+  name: string;
+  /** Shader stage that owns the hook. */
+  stage: 'vertex' | 'fragment';
+  /** GLSL implementation. Omit to skip this hook during GLSL assembly. */
+  glsl?: ShaderHookImplementation;
+  /** WGSL implementation. Omit to skip this hook during WGSL assembly. */
+  wgsl?: ShaderHookImplementation;
+};
 
-/** Shader hook declarations grouped by shader stage. */
+/** Language-selected hook ready for source generation. */
+type ResolvedShaderHook = ShaderHookImplementation & {signature: string};
+
+/** Normalized shader hooks per shader */
 export type ShaderHookRegistry = {
-  vertex: Record<string, Required<ShaderHook>>;
-  fragment: Record<string, Required<ShaderHook>>;
+  /** Normalized shader hooks for vertex shader */
+  vertex: Record<string, ResolvedShaderHook>;
+  /** Normalized shader hooks for fragment shader */
+  fragment: Record<string, ResolvedShaderHook>;
 };
 
 /** Generate hook source code */
 export function getShaderHooks(
-  hookFunctions: Record<string, Required<ShaderHook>>,
-  hookInjections: Record<string, ShaderInjection[]>,
+  hookFunctions: Record<string, ResolvedShaderHook>,
+  hookInjections: Record<string, ResolvedShaderInjection[]>,
   shaderLanguage: 'glsl' | 'wgsl' = 'glsl'
 ): string {
   let result = '';
   for (const hookName in hookFunctions) {
     const hookFunction = hookFunctions[hookName];
-    const functionPrefix = shaderLanguage === 'wgsl' ? 'fn' : 'void';
-    result += `${functionPrefix} ${hookFunction.signature} {\n`;
+    const returnType = hookFunction.returnType || 'void';
+    const functionPrefix = shaderLanguage === 'wgsl' ? 'fn' : returnType;
+    const returnSuffix =
+      shaderLanguage === 'wgsl' && returnType !== 'void' ? ` -> ${returnType}` : '';
+    result += `${functionPrefix} ${hookFunction.signature}${returnSuffix} {\n`;
     if (hookFunction.header) {
       result += `  ${hookFunction.header}`;
     }
@@ -66,37 +72,33 @@ export function getShaderHooks(
   return result;
 }
 
-/**
- * Parse string based hook functions and split them per shader stage.
- * A later declaration of the same stage-prefixed hook name replaces an earlier one.
- */
+/** Select language syntax and merge compatible plugin declarations without mutating descriptors. */
 export function normalizeShaderHooks(
-  hookFunctions: readonly (ShaderHook | string)[],
+  hookFunctions: readonly ShaderHook[],
   pluginHooks: readonly ShaderHook[] = [],
-  language?: 'glsl' | 'wgsl'
+  language: 'glsl' | 'wgsl' = 'glsl'
 ): ShaderHookRegistry {
   const result: ShaderHookRegistry = {vertex: {}, fragment: {}};
-
-  for (const hookFunction of hookFunctions) {
-    const text = typeof hookFunction === 'string' ? hookFunction : hookFunction.hook;
-    const qualified = /^(glsl|wgsl):([\s\S]+)$/.exec(text);
-    if (qualified && qualified[1] !== language) continue;
-    addShaderHookToRegistry(
-      result,
-      qualified
-        ? typeof hookFunction === 'string'
-          ? qualified[2]
-          : {...hookFunction, hook: qualified[2]}
-        : hookFunction
-    );
+  for (const hook of hookFunctions) {
+    const implementation = hook[language];
+    if (implementation) {
+      const prefix = hook.stage === 'vertex' ? 'vs' : 'fs';
+      result[hook.stage][`${prefix}:${hook.name}`] = {
+        ...implementation,
+        signature: `${hook.name}(${implementation.parameters})`
+      };
+    }
   }
-
   for (const hook of pluginHooks) {
-    const normalized = normalizeShaderHooks([hook]);
+    const selected = normalizeShaderHooks([hook], [], language);
     for (const stage of ['vertex', 'fragment'] as const) {
-      for (const [name, declaration] of Object.entries(normalized[stage])) {
+      for (const [name, declaration] of Object.entries(selected[stage])) {
         const existing = result[stage][name];
-        if (existing && existing.signature !== declaration.signature) {
+        if (
+          existing &&
+          (existing.signature !== declaration.signature ||
+            (existing.returnType || 'void') !== (declaration.returnType || 'void'))
+        ) {
           throw new Error(`Conflicting ShaderPlugin hook ${name}`);
         }
         result[stage][name] = existing || declaration;
@@ -118,7 +120,7 @@ export function isShaderHookRegistered(registry: ShaderHookRegistry, hookName: s
  */
 export function validateShaderHookInjections(
   registry: ShaderHookRegistry,
-  hookInjections: Record<string, ShaderInjection[]>,
+  hookInjections: Record<string, ResolvedShaderInjection[]>,
   stage?: 'vertex' | 'fragment'
 ): void {
   const stagePrefix = stage === 'vertex' ? 'vs:' : stage === 'fragment' ? 'fs:' : null;
@@ -139,32 +141,3 @@ export function validateShaderHookInjections(
     }
   }
 }
-
-function addShaderHookToRegistry(
-  registry: ShaderHookRegistry,
-  hookFunction: ShaderHook | string
-): void {
-  const options: ShaderHookOptions = typeof hookFunction === 'string' ? {} : hookFunction;
-  const hook = (typeof hookFunction === 'string' ? hookFunction : hookFunction.hook).trim();
-  const stageSeparatorIndex = hook.indexOf(':');
-  const shaderStage = hook.slice(0, stageSeparatorIndex);
-  const signature = hook.slice(stageSeparatorIndex + 1);
-  const name = hook.split('(')[0].trim();
-  const normalizedHook: Required<ShaderHook> = {
-    hook: name,
-    signature,
-    header: options.header || '',
-    footer: options.footer || ''
-  };
-
-  switch (shaderStage) {
-    case 'vs':
-      registry.vertex[name] = normalizedHook;
-      break;
-    case 'fs':
-      registry.fragment[name] = normalizedHook;
-      break;
-    default:
-      throw new Error(shaderStage);
-  }
-}

package/src/lib/shader-assembly/shader-injections.ts

@@ -17,29 +17,71 @@ const fragments: string[] = [];
 
 export const DECLARATION_INJECT_MARKER = '__LUMA_INJECT_DECLARATIONS__';
 
-/**
- *
- */
+/** Language-specific source inserted at a named shader anchor or hook. */
 export type ShaderInjection = {
+  /** Shader stage receiving the injection. */
+  stage: 'vertex' | 'fragment';
+  /** Unqualified hook name or structural anchor such as #main-start. */
+  target: string;
+  /** GLSL source. Omit to skip this injection for GLSL assembly. */
+  glsl?: string;
+  /** WGSL source. Omit to skip this injection for WGSL assembly. */
+  wgsl?: string;
+  /** Relative order at the target; defaults to zero. */
+  order?: number;
+};
+
+/** Language-selected source and ordering used internally during shader assembly. */
+export type ResolvedShaderInjection = {
   /** Plugin responsible for this injection, when supplied by a ShaderPlugin. */
   pluginName?: string;
   injection: string;
   order: number;
 };
 
+/** Select language-specific injections while retaining repeated targets and declaration order. */
+export function resolveShaderInjections(
+  declarations: readonly ShaderInjection[],
+  language: 'glsl' | 'wgsl',
+  pluginName?: string
+): Record<string, ResolvedShaderInjection[]> {
+  const resolved: Record<string, ResolvedShaderInjection[]> = {};
+  for (const declaration of declarations) {
+    const source = declaration[language];
+    if (source === undefined) continue;
+    if (
+      (declaration.stage !== 'vertex' && declaration.stage !== 'fragment') ||
+      declaration.target.includes(':')
+    ) {
+      throw new Error('Shader injection targets require an explicit stage and unqualified target');
+    }
+    const target = `${declaration.stage === 'vertex' ? 'vs' : 'fs'}:${declaration.target}`;
+    if (!/^(vs|fs):(?:#(?:decl|main-start|main-end)|[A-Za-z_][A-Za-z0-9_]*)$/.test(target)) {
+      throw new Error(`Shader injection target "${target}" must be a named shader anchor or hook`);
+    }
+    resolved[target] ||= [];
+    resolved[target].push({
+      injection: source,
+      order: declaration.order ?? 0,
+      ...(pluginName ? {pluginName} : {})
+    });
+  }
+  return resolved;
+}
+
 /**
  *  ShaderInjections, parsed and split per shader
  */
 export type ShaderInjections = {
-  vertex: Record<string, ShaderInjection>;
-  fragment: Record<string, ShaderInjection>;
+  vertex: Record<string, ResolvedShaderInjection>;
+  fragment: Record<string, ResolvedShaderInjection>;
 };
 
 /**
  *
  */
 export function normalizeInjections(
-  injections: Record<string, string | ShaderInjection>
+  injections: Record<string, string | ResolvedShaderInjection>
 ): ShaderInjections {
   const result: ShaderInjections = {vertex: {}, fragment: {}};
 
@@ -84,7 +126,7 @@ function getHookStage(hook: string): 'vertex' | 'fragment' {
 export function injectShader(
   source: string,
   stage: 'vertex' | 'fragment',
-  inject: Record<string, ShaderInjection[]>,
+  inject: Record<string, ResolvedShaderInjection[]>,
   injectStandardStubs = false,
   language: 'glsl' | 'wgsl' = 'glsl',
   entryPoints: {vertex?: string; fragment?: string} = {}
@@ -93,7 +135,9 @@ export function injectShader(
 
   for (const key in inject) {
     const fragmentData = inject[key];
-    fragmentData.sort((a: ShaderInjection, b: ShaderInjection): number => a.order - b.order);
+    fragmentData.sort(
+      (a: ResolvedShaderInjection, b: ResolvedShaderInjection): number => a.order - b.order
+    );
     fragments.length = fragmentData.length;
     for (let i = 0, len = fragmentData.length; i < len; ++i) {
       fragments[i] = fragmentData[i].injection;

package/src/lib/shader-module/shader-module.ts

@@ -10,7 +10,7 @@ import {
   getValidatedProperties
 } from '../filters/prop-types';
 import type {ShaderModuleUniformValue, UniformTypes, UniformValue} from '../utils/uniform-types';
-import {ShaderInjection, normalizeInjections} from '../shader-assembly/shader-injections';
+import type {ResolvedShaderInjection} from '../shader-assembly/shader-injections';
 
 import type {ShaderBinding as Binding} from '../../types';
 
@@ -83,8 +83,6 @@ export type ShaderModule<
 
   /** Boolean or numeric preprocessor defines contributed by this shader module. */
   defines?: Record<string, boolean | number>;
-  /** Injections */
-  inject?: Record<string, string | {injection: string; order: number}>;
   dependencies?: ShaderModule<any, any>[];
   /** Information on deprecated properties */
   deprecations?: ShaderModuleDeprecation[];
@@ -93,10 +91,10 @@ export type ShaderModule<
   instance?: {
     propValidators?: Record<string, PropValidator>;
     parsedDeprecations: ShaderModuleDeprecation[];
-
+    /** Empty compatibility value for consumers using older shadertools assembly. */
     normalizedInjections: {
-      vertex: Record<string, ShaderInjection>;
-      fragment: Record<string, ShaderInjection>;
+      vertex: Record<string, ResolvedShaderInjection>;
+      fragment: Record<string, ResolvedShaderInjection>;
     };
   };
 };
@@ -123,16 +121,11 @@ export function initializeShaderModule(module: ShaderModule): void {
 
   initializeShaderModules(module.dependencies || []);
 
-  const {
-    propTypes = {},
-    deprecations = [],
-    // defines = {},
-    inject = {}
-  } = module;
+  const {propTypes = {}, deprecations = []} = module;
 
   const instance: Required<ShaderModule>['instance'] = {
-    normalizedInjections: normalizeInjections(inject),
-    parsedDeprecations: parseDeprecationDefinitions(deprecations)
+    parsedDeprecations: parseDeprecationDefinitions(deprecations),
+    normalizedInjections: {vertex: {}, fragment: {}}
   };
 
   if (propTypes) {

package/src/lib/shader-plugin.ts

@@ -3,47 +3,14 @@
 // SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
 
 import type {ShaderHook} from './shader-assembly/shader-hooks';
-import type {ShaderInjection} from './shader-assembly/shader-injections';
+import {
+  resolveShaderInjections,
+  type ShaderInjection,
+  type ResolvedShaderInjection
+} from './shader-assembly/shader-injections';
 import type {ShaderModule} from './shader-module/shader-module';
 import {shaderTypeDecoder, type AttributeShaderType} from '../types';
 
-/** Named shader anchor or hook target accepted by ShaderPlugin injections. */
-export type ShaderPluginInjectionTarget =
-  | 'vs:#decl'
-  | 'vs:#main-start'
-  | 'vs:#main-end'
-  | 'fs:#decl'
-  | 'fs:#main-start'
-  | 'fs:#main-end'
-  | `vs:${string}`
-  | `fs:${string}`;
-
-/** Explicit stage and unqualified target for plugin object declarations. */
-export type ShaderPluginTarget = {
-  /** Shader stage containing this extension point. */
-  stage: 'vertex' | 'fragment';
-  /** Unqualified hook name or structural anchor such as #main-start. */
-  target: string;
-};
-
-/** Hook function declared by a plugin, with parameter signatures per language. */
-export type ShaderPluginHook = ShaderPluginTarget & {
-  /** GLSL parameter list, including parentheses. */
-  glsl?: string;
-  /** WGSL parameter list, including parentheses. */
-  wgsl?: string;
-};
-
-/** Named shader source injection contributed by a ShaderPlugin. */
-export type ShaderPluginInjection = ShaderPluginTarget & {
-  /** GLSL source for this target. Omit to skip this injection when assembling GLSL. */
-  glsl?: string;
-  /** WGSL source for this target. Omit to skip this injection when assembling WGSL. */
-  wgsl?: string;
-  /** Relative injection order within the target. */
-  order?: number;
-};
-
 /** Portable interpolation modes for ShaderPlugin inter-stage variables. */
 export type ShaderPluginInterStageVariableInterpolation = 'smooth' | 'flat';
 
@@ -70,9 +37,9 @@ export type ShaderPlugin = {
   /** Boolean or numeric preprocessor defines added to shader assembly. */
   defines?: Record<string, boolean | number>;
   /** Named injections as explicit-stage objects or optionally language-qualified string keys. */
-  injections?: ShaderPluginInjection[] | Record<string, string>;
-  /** Callable extension points as explicit-stage objects or optionally language-qualified signatures. */
-  hooks?: (ShaderPluginHook | string)[];
+  injections?: ShaderInjection[] | Record<string, string>;
+  /** Callable extension points with a shared name and language-specific source. */
+  hooks?: ShaderHook[];
   /** Shader-facing vertex inputs added by this plugin. Buffer ownership remains with the caller. */
   vertexInputs?: Record<string, AttributeShaderType>;
   /** Values transported from the selected vertex entry point to the fragment entry point. */
@@ -88,16 +55,13 @@ export type ResolvedShaderPlugins = {
   /** Resolved boolean or numeric preprocessor defines. */
   defines: Record<string, boolean | number>;
   /** Resolved named code injections grouped by target. */
-  injections: Record<string, ShaderInjection[]>;
+  injections: Record<string, ResolvedShaderInjection[]>;
   /** Resolved shader-facing vertex inputs in plugin declaration order. */
   vertexInputs: Record<string, AttributeShaderType>;
   /** Resolved inter-stage variables in plugin declaration order. */
   interStageVariables: Record<string, ResolvedShaderPluginInterStageVariable>;
 };
 
-const SHADER_PLUGIN_INJECTION_TARGET_REGEX =
-  /^(vs|fs):(?:#(?:decl|main-start|main-end)|[A-Za-z_][\w-]*)$/;
-
 /** Resolve plugin interfaces and select injection source for one shader language. */
 export function resolveShaderPlugins(
   plugins: readonly ShaderPlugin[] = [],
@@ -198,29 +162,31 @@ function appendShaderPlugin(
   }
 
   for (const hook of plugin.hooks || []) {
-    const declarationSource =
-      typeof hook === 'string' ? selectShaderLanguage(hook, shaderLanguage) : undefined;
-    if (typeof hook === 'string' && declarationSource === undefined) continue;
-    const signature =
-      typeof hook === 'string'
-        ? declarationSource!.slice(declarationSource!.indexOf('('))
-        : hook[shaderLanguage];
-    if (signature === undefined) continue;
-    const target =
-      typeof hook === 'string' ? declarationSource!.split('(')[0] : getShaderPluginTarget(hook);
-    if (!/^(vs|fs):[A-Za-z_][A-Za-z0-9_]*$/.test(target) || !/^\([^]*\)$/.test(signature.trim())) {
+    const implementation = hook[shaderLanguage];
+    if (!implementation) continue;
+    const target = `${hook.stage === 'vertex' ? 'vs' : 'fs'}:${hook.name}`;
+    if (!/^(vs|fs):[A-Za-z_][A-Za-z0-9_]*$/.test(target)) {
       throw new Error(`Invalid ShaderPlugin hook ${target}`);
     }
-    const declaration = {hook: `${target}${signature.trim()}`};
-    const existing = resolved.hooks.find(value => value.hook.split('(')[0] === target);
-    if (existing && existing.hook !== declaration.hook) {
+    const existing = resolved.hooks.find(
+      value => value.stage === hook.stage && value.name === hook.name
+    );
+    const previous = existing?.[shaderLanguage];
+    if (
+      previous &&
+      (previous.parameters !== implementation.parameters ||
+        (previous.returnType || 'void') !== (implementation.returnType || 'void') ||
+        previous.header !== implementation.header ||
+        previous.footer !== implementation.footer)
+    ) {
       throw new Error(`Conflicting ShaderPlugin hook ${target}`);
     }
-    if (!existing) resolved.hooks.push(declaration);
+    if (!existing)
+      resolved.hooks.push({name: hook.name, stage: hook.stage, [shaderLanguage]: implementation});
   }
   const pluginInjections = Array.isArray(plugin.injections)
     ? plugin.injections
-    : Object.entries(plugin.injections || {}).flatMap(([key, source]): ShaderPluginInjection[] => {
+    : Object.entries(plugin.injections || {}).flatMap(([key, source]): ShaderInjection[] => {
         const target = selectShaderLanguage(key, shaderLanguage);
         if (target === undefined) return [];
         const [stage, ...name] = target.split(':');
@@ -234,20 +200,10 @@ function appendShaderPlugin(
           }
         ];
       });
-  for (const injection of pluginInjections) {
-    const source = injection[shaderLanguage];
-    if (source === undefined) continue;
-    const target = getShaderPluginTarget(injection);
-    assertNamedShaderPluginInjectionTarget(target);
-    if (!resolved.injections[target]) {
-      resolved.injections[target] = [];
-    }
-    const injections = resolved.injections[target];
-    injections.push({
-      pluginName: plugin.name,
-      injection: source,
-      order: injection.order ?? 0
-    });
+  const selectedInjections = resolveShaderInjections(pluginInjections, shaderLanguage, plugin.name);
+  for (const [target, injections] of Object.entries(selectedInjections)) {
+    resolved.injections[target] ||= [];
+    resolved.injections[target].push(...injections);
   }
 }
 
@@ -270,21 +226,6 @@ function normalizeShaderPluginInterStageVariable(
   return {type: varying.type, interpolation};
 }
 
-function assertNamedShaderPluginInjectionTarget(target: ShaderPluginInjectionTarget): void {
-  if (!SHADER_PLUGIN_INJECTION_TARGET_REGEX.test(target)) {
-    throw new Error(
-      `ShaderPlugin injection target "${target}" must be a named shader anchor or hook`
-    );
-  }
-}
-
-function getShaderPluginTarget(value: ShaderPluginTarget): ShaderPluginInjectionTarget {
-  if ((value.stage !== 'vertex' && value.stage !== 'fragment') || value.target.includes(':')) {
-    throw new Error('ShaderPlugin object targets require an explicit stage and unqualified target');
-  }
-  return `${value.stage === 'vertex' ? 'vs' : 'fs'}:${value.target}` as ShaderPluginInjectionTarget;
-}
-
 function selectShaderLanguage(value: string, language: 'glsl' | 'wgsl'): string | undefined {
   const match = /^(glsl|wgsl):([\s\S]+)$/.exec(value);
   return match ? (match[1] === language ? match[2] : undefined) : value;