@luma.gl/shadertools 9.3.6 → 9.4.0-alpha.1

package/src/lib/shader-assembly/assemble-shaders.ts

@@ -18,6 +18,17 @@ import {ShaderHook, normalizeShaderHooks, getShaderHooks} from './shader-hooks';
 import {assert} from '../utils/assert';
 import {getShaderInfo} from '../glsl-utils/get-shader-info';
 import {getShaderBindingDebugRowsFromWGSL, type ShaderBindingDebugRow} from './wgsl-binding-debug';
+import {preprocess} from '../preprocessor/preprocessor';
+import type {AttributeShaderType} from '@luma.gl/core';
+import type {ResolvedShaderPluginVarying} from '../shader-plugin';
+import {
+  assembleShaderPluginVertexInputsWGSL,
+  getShaderPluginVertexInputDeclarationsGLSL
+} from './shader-plugin-vertex-inputs';
+import {
+  assembleShaderPluginVaryingsGLSL,
+  assembleShaderPluginVaryingsWGSL
+} from './shader-plugin-varyings';
 import {
   MODULE_WGSL_BINDING_DECLARATION_REGEXES,
   WGSL_BINDING_DECLARATION_REGEXES,
@@ -40,9 +51,7 @@ const FRAGMENT_SHADER_PROLOGUE = /* glsl */ `\
 precision highp float;
 `;
 
-/**
- * Options for `ShaderAssembler.assembleShaders()`
- */
+/** Props accepted by `ShaderAssembler` assembly methods. */
 export type AssembleShaderProps = AssembleShaderOptions & {
   platformInfo: PlatformInfo;
   /** WGSL: single shader source. */
@@ -53,6 +62,7 @@ export type AssembleShaderProps = AssembleShaderOptions & {
   fs?: string | null;
 };
 
+/** Shared shader assembly options. */
 export type AssembleShaderOptions = {
   /** information about the platform (which shader language & version, extensions etc.) */
   platformInfo: PlatformInfo;
@@ -60,14 +70,24 @@ export type AssembleShaderOptions = {
   id?: string;
   /** Modules to be injected */
   modules?: ShaderModule[];
-  /** Defines to be injected */
-  defines?: Record<string, boolean>;
+  /** Boolean or numeric preprocessor defines evaluated before shader assembly. */
+  defines?: Record<string, boolean | number>;
   /** GLSL only: Overrides to be injected. In WGSL these are supplied during Pipeline creation time */
   constants?: Record<string, number>;
   /** Hook functions */
   hookFunctions?: (ShaderHook | string)[];
   /** Code injections */
   inject?: Record<string, string | ShaderInjection>;
+  /** Ordered code injections contributed by ShaderPlugin descriptors. */
+  pluginInjections?: Record<string, ShaderInjection[]>;
+  /** Vertex inputs contributed by ShaderPlugin descriptors. */
+  pluginVertexInputs?: Record<string, AttributeShaderType>;
+  /** Cross-stage varyings contributed by ShaderPlugin descriptors. */
+  pluginVaryings?: Record<string, ResolvedShaderPluginVarying>;
+  /** WGSL vertex entry point selected by the render pipeline. */
+  vertexEntryPoint?: string;
+  /** WGSL fragment entry point selected by the render pipeline. */
+  fragmentEntryPoint?: string;
   /** Whether to inject prologue */
   prologue?: boolean;
   /** logger object */
@@ -82,14 +102,24 @@ type AssembleStageOptions = {
   stage: 'vertex' | 'fragment';
   /** Modules to be injected */
   modules: any[];
-  /** Defines to be injected */
-  defines?: Record<string, boolean>;
+  /** Boolean or numeric preprocessor defines evaluated before shader assembly. */
+  defines?: Record<string, boolean | number>;
   /** GLSL only: Overrides to be injected. In WGSL these are supplied during Pipeline creation time */
   constants?: Record<string, number>;
   /** Hook functions */
   hookFunctions?: (ShaderHook | string)[];
   /** Code injections */
   inject?: Record<string, string | ShaderInjection>;
+  /** Ordered code injections contributed by ShaderPlugin descriptors. */
+  pluginInjections?: Record<string, ShaderInjection[]>;
+  /** Vertex inputs contributed by ShaderPlugin descriptors. */
+  pluginVertexInputs?: Record<string, AttributeShaderType>;
+  /** Cross-stage varyings contributed by ShaderPlugin descriptors. */
+  pluginVaryings?: Record<string, ResolvedShaderPluginVarying>;
+  /** WGSL vertex entry point selected by the render pipeline. */
+  vertexEntryPoint?: string;
+  /** WGSL fragment entry point selected by the render pipeline. */
+  fragmentEntryPoint?: string;
   /** Whether to inject prologue */
   prologue?: boolean;
   /** logger object */
@@ -190,8 +220,14 @@ export function assembleShaderWGSL(
     stage,
     modules,
     // defines = {},
+    defines = {},
     hookFunctions = [],
     inject = {},
+    pluginInjections = {},
+    pluginVertexInputs = {},
+    pluginVaryings = {},
+    vertexEntryPoint = 'vertexMain',
+    fragmentEntryPoint = 'fragmentMain',
     log
   } = options;
 
@@ -200,7 +236,19 @@ export function assembleShaderWGSL(
   // const isVertex = type === 'vs';
   // const sourceLines = source.split('\n');
 
-  const coreSource = source;
+  const preprocessedSource = preprocess(source, {defines});
+  const pluginVertexInputAssembly = assembleShaderPluginVertexInputsWGSL(
+    preprocessedSource,
+    vertexEntryPoint,
+    pluginVertexInputs
+  );
+  const pluginVaryingAssembly = assembleShaderPluginVaryingsWGSL(
+    pluginVertexInputAssembly.source,
+    vertexEntryPoint,
+    fragmentEntryPoint,
+    pluginVaryings
+  );
+  const coreSource = pluginVaryingAssembly.source;
 
   // Combine Module and Application Defines
   // const allDefines = {};
@@ -230,6 +278,8 @@ export function assembleShaderWGSL(
   const declInjections: Record<string, ShaderInjection[]> = {};
   const mainInjections: Record<string, ShaderInjection[]> = {};
 
+  appendInjections(pluginInjections, hookInjections, declInjections, mainInjections);
+
   for (const key in inject) {
     const injection =
       typeof inject[key] === 'string' ? {injection: inject[key], order: 0} : inject[key];
@@ -251,6 +301,13 @@ export function assembleShaderWGSL(
       mainInjections[key] = [injection as any];
     }
   }
+  appendGeneratedVertexInputInjections(
+    pluginVertexInputAssembly.declarations,
+    pluginVertexInputAssembly.initialization,
+    declInjections,
+    mainInjections
+  );
+  appendGeneratedVaryingInjections(pluginVaryingAssembly, declInjections, mainInjections);
 
   // TODO - hack until shadertool modules support WebGPU
   const modulesToInject = modules;
@@ -261,7 +318,8 @@ export function assembleShaderWGSL(
   const reservedBindingKeysByGroup = reserveRegisteredModuleBindings(
     modulesToInject,
     options._bindingRegistry,
-    usedBindingsByGroup
+    usedBindingsByGroup,
+    defines
   );
   const bindingAssignments: WGSLBindingAssignment[] = [];
 
@@ -269,21 +327,20 @@ export function assembleShaderWGSL(
     if (log) {
       checkShaderModuleDeprecations(module, coreSource, log);
     }
-    const relocation = relocateWGSLModuleBindings(
-      getShaderModuleSource(module, 'wgsl', log),
-      module,
-      {
-        usedBindingsByGroup,
-        bindingRegistry: options._bindingRegistry,
-        reservedBindingKeysByGroup
-      }
-    );
+    const preprocessedModuleSource = preprocess(getShaderModuleSource(module, 'wgsl', log), {
+      defines
+    });
+    const relocation = relocateWGSLModuleBindings(preprocessedModuleSource, module, {
+      usedBindingsByGroup,
+      bindingRegistry: options._bindingRegistry,
+      reservedBindingKeysByGroup
+    });
     bindingAssignments.push(...relocation.bindingAssignments);
-    const moduleSource = relocation.source;
+    const relocatedModuleSource = relocation.source;
     // Add the module source, and a #define that declares it presence
-    assembledSource += moduleSource;
+    assembledSource += relocatedModuleSource;
 
-    const injections = module.injections?.[stage] || {};
+    const injections = getWGSLModuleInjections(module);
     for (const key in injections) {
       const match = /^(v|f)s:#([\w-]+)$/.exec(key);
       if (match) {
@@ -301,16 +358,26 @@ export function assembleShaderWGSL(
   // For injectShader
   assembledSource += INJECT_SHADER_DECLARATIONS;
 
-  assembledSource = injectShader(assembledSource, stage, declInjections);
+  assembledSource = injectShader(
+    assembledSource,
+    stage,
+    getWGSLDeclarationInjections(declInjections),
+    false,
+    'wgsl',
+    {vertex: vertexEntryPoint, fragment: fragmentEntryPoint}
+  );
 
-  assembledSource += getShaderHooks(hookFunctionMap[stage], hookInjections);
+  assembledSource += getWGSLShaderHooks(hookFunctionMap, hookInjections);
   assembledSource += formatWGSLBindingAssignmentComments(bindingAssignments);
 
   // Add the version directive and actual source of this shader
   assembledSource += applicationRelocation.source;
 
   // Apply any requested shader injections
-  assembledSource = injectShader(assembledSource, stage, mainInjections);
+  assembledSource = injectShader(assembledSource, stage, mainInjections, false, 'wgsl', {
+    vertex: vertexEntryPoint,
+    fragment: fragmentEntryPoint
+  });
 
   assertNoUnresolvedAutoBindings(assembledSource);
 
@@ -332,9 +399,12 @@ function assembleShaderGLSL(
     language?: 'glsl' | 'wgsl';
     stage: 'vertex' | 'fragment';
     modules: ShaderModule[];
-    defines?: Record<string, boolean>;
+    defines?: Record<string, boolean | number>;
     hookFunctions?: any[];
     inject?: Record<string, string | ShaderInjection>;
+    pluginInjections?: Record<string, ShaderInjection[]>;
+    pluginVertexInputs?: Record<string, AttributeShaderType>;
+    pluginVaryings?: Record<string, ResolvedShaderPluginVarying>;
     prologue?: boolean;
     log?: any;
   }
@@ -347,6 +417,9 @@ function assembleShaderGLSL(
     defines = {},
     hookFunctions = [],
     inject = {},
+    pluginInjections = {},
+    pluginVertexInputs = {},
+    pluginVaryings = {},
     prologue = true,
     log
   } = options;
@@ -404,6 +477,8 @@ ${getApplicationDefines(allDefines)}
   const declInjections: Record<string, ShaderInjection[]> = {};
   const mainInjections: Record<string, ShaderInjection[]> = {};
 
+  appendInjections(pluginInjections, hookInjections, declInjections, mainInjections);
+
   for (const key in inject) {
     const injection: ShaderInjection =
       typeof inject[key] === 'string' ? {injection: inject[key], order: 0} : inject[key];
@@ -425,6 +500,32 @@ ${getApplicationDefines(allDefines)}
       mainInjections[key] = [injection];
     }
   }
+  if (stage === 'vertex') {
+    const declarations = getShaderPluginVertexInputDeclarationsGLSL(coreSource, pluginVertexInputs);
+    if (declarations) {
+      declInjections['vs:#decl'] = declInjections['vs:#decl'] || [];
+      declInjections['vs:#decl'].push({
+        injection: declarations,
+        order: Number.MIN_SAFE_INTEGER
+      });
+    }
+  }
+  const pluginVaryingAssembly = assembleShaderPluginVaryingsGLSL(coreSource, stage, pluginVaryings);
+  if (pluginVaryingAssembly.declarations) {
+    const declarationTarget = stage === 'vertex' ? 'vs:#decl' : 'fs:#decl';
+    declInjections[declarationTarget] = declInjections[declarationTarget] || [];
+    declInjections[declarationTarget].push({
+      injection: pluginVaryingAssembly.declarations,
+      order: Number.MIN_SAFE_INTEGER
+    });
+  }
+  if (pluginVaryingAssembly.initialization) {
+    mainInjections['vs:#main-start'] = mainInjections['vs:#main-start'] || [];
+    mainInjections['vs:#main-start'].push({
+      injection: pluginVaryingAssembly.initialization,
+      order: Number.MIN_SAFE_INTEGER
+    });
+  }
 
   for (const module of modules) {
     if (log) {
@@ -496,6 +597,113 @@ export function assembleGetUniforms(modules: ShaderModule[]) {
   };
 }
 
+function appendInjections(
+  injections: Record<string, ShaderInjection[]>,
+  hookInjections: Record<string, ShaderInjection[]>,
+  declInjections: Record<string, ShaderInjection[]>,
+  mainInjections: Record<string, ShaderInjection[]>
+): void {
+  for (const key in injections) {
+    const match = /^(v|f)s:(#)?([\w-]+)$/.exec(key);
+    if (match) {
+      const hash = match[2];
+      const name = match[3];
+      const injectionType = hash
+        ? name === 'decl'
+          ? declInjections
+          : mainInjections
+        : hookInjections;
+      injectionType[key] = injectionType[key] || [];
+      injectionType[key].push(...injections[key]);
+    } else {
+      mainInjections[key] = mainInjections[key] || [];
+      mainInjections[key].push(...injections[key]);
+    }
+  }
+}
+
+function appendGeneratedVertexInputInjections(
+  declarations: string,
+  initialization: string,
+  declarationInjections: Record<string, ShaderInjection[]>,
+  mainInjections: Record<string, ShaderInjection[]>
+): void {
+  if (declarations) {
+    declarationInjections['vs:#decl'] = declarationInjections['vs:#decl'] || [];
+    declarationInjections['vs:#decl'].push({
+      injection: declarations,
+      order: Number.MIN_SAFE_INTEGER
+    });
+  }
+  if (initialization) {
+    mainInjections['vs:#main-start'] = mainInjections['vs:#main-start'] || [];
+    mainInjections['vs:#main-start'].push({
+      injection: initialization,
+      order: Number.MIN_SAFE_INTEGER
+    });
+  }
+}
+
+function appendGeneratedVaryingInjections(
+  assembly: {
+    declarations: string;
+    vertexInitialization: string;
+    fragmentInitialization: string;
+  },
+  declarationInjections: Record<string, ShaderInjection[]>,
+  mainInjections: Record<string, ShaderInjection[]>
+): void {
+  if (assembly.declarations) {
+    declarationInjections['vs:#decl'] = declarationInjections['vs:#decl'] || [];
+    declarationInjections['vs:#decl'].push({
+      injection: assembly.declarations,
+      order: Number.MIN_SAFE_INTEGER
+    });
+  }
+  if (assembly.vertexInitialization) {
+    mainInjections['vs:#main-start'] = mainInjections['vs:#main-start'] || [];
+    mainInjections['vs:#main-start'].push({
+      injection: assembly.vertexInitialization,
+      order: Number.MIN_SAFE_INTEGER
+    });
+  }
+  if (assembly.fragmentInitialization) {
+    mainInjections['fs:#main-start'] = mainInjections['fs:#main-start'] || [];
+    mainInjections['fs:#main-start'].push({
+      injection: assembly.fragmentInitialization,
+      order: Number.MIN_SAFE_INTEGER
+    });
+  }
+}
+
+function getWGSLModuleInjections(module: ShaderModule): Record<string, ShaderInjection> {
+  return {
+    ...(module.instance?.normalizedInjections.vertex || {}),
+    ...(module.instance?.normalizedInjections.fragment || {})
+  };
+}
+
+function getWGSLDeclarationInjections(
+  declarationInjections: Record<string, ShaderInjection[]>
+): Record<string, ShaderInjection[]> {
+  const unifiedDeclarations = [
+    ...(declarationInjections['vs:#decl'] || []),
+    ...(declarationInjections['fs:#decl'] || [])
+  ];
+
+  return unifiedDeclarations.length ? {'vs:#decl': unifiedDeclarations} : {};
+}
+
+function getWGSLShaderHooks(
+  hookFunctionMap: ReturnType<typeof normalizeShaderHooks>,
+  hookInjections: Record<string, ShaderInjection[]>
+): string {
+  return (
+    getShaderHooks(hookFunctionMap.vertex, hookInjections, 'wgsl') +
+    getShaderHooks(hookFunctionMap.fragment, hookInjections, 'wgsl')
+  );
+}
+
 /**
  * NOTE: Removed as id injection defeated caching of shaders
  * 
@@ -517,7 +725,7 @@ export function assembleGetUniforms(modules: ShaderModule[]) {
 */
 
 /** Generates application defines from an object of key value pairs */
-function getApplicationDefines(defines: Record<string, boolean> = {}): string {
+function getApplicationDefines(defines: Record<string, boolean | number> = {}): string {
   let sourceText = '';
   for (const define in defines) {
     const value = defines[define];
@@ -784,7 +992,8 @@ function relocateWGSLApplicationBindingMatch(
 function reserveRegisteredModuleBindings(
   modules: ShaderModule[],
   bindingRegistry: Map<string, number> | undefined,
-  usedBindingsByGroup: Map<number, Set<number>>
+  usedBindingsByGroup: Map<number, Set<number>>,
+  defines: Record<string, boolean | number>
 ): Map<number, Map<number, string>> {
   const reservedBindingKeysByGroup = new Map<number, Map<number, string>>();
   if (!bindingRegistry) {
@@ -792,7 +1001,7 @@ function reserveRegisteredModuleBindings(
   }
 
   for (const module of modules) {
-    for (const binding of getModuleWGSLBindingDeclarations(module)) {
+    for (const binding of getModuleWGSLBindingDeclarations(module, defines)) {
       const registryKey = getBindingRegistryKey(binding.group, module.name, binding.name);
       const location = bindingRegistry.get(registryKey);
       if (location !== undefined) {
@@ -843,9 +1052,12 @@ function claimReservedBindingLocation(
   return true;
 }
 
-function getModuleWGSLBindingDeclarations(module: ShaderModule): {name: string; group: number}[] {
+function getModuleWGSLBindingDeclarations(
+  module: ShaderModule,
+  defines: Record<string, boolean | number>
+): {name: string; group: number}[] {
   const declarations: {name: string; group: number}[] = [];
-  const moduleSource = module.source || '';
+  const moduleSource = preprocess(module.source || '', {defines});
 
   for (const match of getWGSLBindingDeclarationMatches(
     moduleSource,

package/src/lib/shader-assembly/platform-info.ts

@@ -16,6 +16,8 @@ export type PlatformInfo = {
   shaderLanguageVersion: 100 | 300;
   /** string identifying current GPU */
   gpu: string;
+  /** Device limits exposed to shader preprocessing decisions such as platform capability defines. */
+  limits?: Record<string, number | undefined>;
   /** Feature strings for feature detection */
   features: Set<string>;
 };

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

@@ -39,12 +39,14 @@ export type ShaderHooks = {
 /** Generate hook source code */
 export function getShaderHooks(
   hookFunctions: Record<string, ShaderHook>,
-  hookInjections: Record<string, ShaderInjection[]>
+  hookInjections: Record<string, ShaderInjection[]>,
+  shaderLanguage: 'glsl' | 'wgsl' = 'glsl'
 ): string {
   let result = '';
   for (const hookName in hookFunctions) {
     const hookFunction = hookFunctions[hookName];
-    result += `void ${hookFunction.signature} {\n`;
+    const functionPrefix = shaderLanguage === 'wgsl' ? 'fn' : 'void';
+    result += `${functionPrefix} ${hookFunction.signature} {\n`;
     if (hookFunction.header) {
       result += `  ${hookFunction.header}`;
     }
@@ -82,7 +84,9 @@ export function normalizeShaderHooks(hookFunctions: (string | ShaderHook)[]): Sh
       hook = hookFunction;
     }
     hook = hook.trim();
-    const [shaderStage, signature] = hook.split(':');
+    const stageSeparatorIndex = hook.indexOf(':');
+    const shaderStage = hook.slice(0, stageSeparatorIndex);
+    const signature = hook.slice(stageSeparatorIndex + 1);
     const name = hook.replace(/\(.+/, '');
     const normalizedHook: ShaderHook = Object.assign(opts, {signature});
     switch (shaderStage) {

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

@@ -83,7 +83,9 @@ export function injectShader(
   source: string,
   stage: 'vertex' | 'fragment',
   inject: Record<string, ShaderInjection[]>,
-  injectStandardStubs = false
+  injectStandardStubs = false,
+  language: 'glsl' | 'wgsl' = 'glsl',
+  entryPoints: {vertex?: string; fragment?: string} = {}
 ): string {
   const isVertex = stage === 'vertex';
 
@@ -98,38 +100,56 @@ export function injectShader(
     switch (key) {
       // declarations are injected before the main function
       case 'vs:#decl':
-        if (isVertex) {
+        if (language === 'wgsl' || isVertex) {
           source = source.replace(DECLARATION_INJECT_MARKER, fragmentString);
         }
         break;
       // inject code at the beginning of the main function
       case 'vs:#main-start':
-        if (isVertex) {
-          source = source.replace(REGEX_START_OF_MAIN, (match: string) => match + fragmentString);
+        if (language === 'wgsl' || isVertex) {
+          source =
+            language === 'wgsl'
+              ? injectWGSLStageMain(source, 'vertex', fragmentString, 'start', entryPoints.vertex)
+              : source.replace(REGEX_START_OF_MAIN, (match: string) => match + fragmentString);
         }
         break;
       // inject code at the end of main function
       case 'vs:#main-end':
-        if (isVertex) {
-          source = source.replace(REGEX_END_OF_MAIN, (match: string) => fragmentString + match);
+        if (language === 'wgsl' || isVertex) {
+          source =
+            language === 'wgsl'
+              ? injectWGSLStageMain(source, 'vertex', fragmentString, 'end', entryPoints.vertex)
+              : source.replace(REGEX_END_OF_MAIN, (match: string) => fragmentString + match);
         }
         break;
       // declarations are injected before the main function
       case 'fs:#decl':
-        if (!isVertex) {
+        if (language === 'wgsl' || !isVertex) {
           source = source.replace(DECLARATION_INJECT_MARKER, fragmentString);
         }
         break;
       // inject code at the beginning of the main function
       case 'fs:#main-start':
-        if (!isVertex) {
-          source = source.replace(REGEX_START_OF_MAIN, (match: string) => match + fragmentString);
+        if (language === 'wgsl' || !isVertex) {
+          source =
+            language === 'wgsl'
+              ? injectWGSLStageMain(
+                  source,
+                  'fragment',
+                  fragmentString,
+                  'start',
+                  entryPoints.fragment
+                )
+              : source.replace(REGEX_START_OF_MAIN, (match: string) => match + fragmentString);
         }
         break;
       // inject code at the end of main function
       case 'fs:#main-end':
-        if (!isVertex) {
-          source = source.replace(REGEX_END_OF_MAIN, (match: string) => fragmentString + match);
+        if (language === 'wgsl' || !isVertex) {
+          source =
+            language === 'wgsl'
+              ? injectWGSLStageMain(source, 'fragment', fragmentString, 'end', entryPoints.fragment)
+              : source.replace(REGEX_END_OF_MAIN, (match: string) => fragmentString + match);
         }
         break;
 
@@ -163,3 +183,68 @@ export function combineInjects(injects: any[]): Record<string, string> {
   });
   return result;
 }
+
+function injectWGSLStageMain(
+  source: string,
+  stage: 'vertex' | 'fragment',
+  fragmentString: string,
+  position: 'start' | 'end',
+  entryPoint?: string
+): string {
+  const bodyRange = getWGSLStageFunctionBodyRange(source, stage, entryPoint);
+  if (!bodyRange) {
+    return source;
+  }
+
+  if (position === 'start') {
+    const insertionIndex = bodyRange.openBraceIndex + 1;
+    return `${source.slice(0, insertionIndex)}\n${fragmentString}${source.slice(insertionIndex)}`;
+  }
+
+  return `${source.slice(0, bodyRange.closeBraceIndex)}${fragmentString}${source.slice(
+    bodyRange.closeBraceIndex
+  )}`;
+}
+
+function getWGSLStageFunctionBodyRange(
+  source: string,
+  stage: 'vertex' | 'fragment',
+  entryPoint?: string
+): {openBraceIndex: number; closeBraceIndex: number} | null {
+  const stageAttribute = stage === 'vertex' ? '@vertex' : '@fragment';
+  const stageIndex = source.indexOf(stageAttribute);
+  if (stageIndex < 0) {
+    return null;
+  }
+
+  const functionIndex = entryPoint
+    ? source.search(new RegExp(`\\bfn\\s+${escapeRegExp(entryPoint)}\\s*\\(`))
+    : source.indexOf('fn', stageIndex);
+  if (functionIndex < 0) {
+    return null;
+  }
+
+  const openBraceIndex = source.indexOf('{', functionIndex);
+  if (openBraceIndex < 0) {
+    return null;
+  }
+
+  let braceDepth = 0;
+  for (let index = openBraceIndex; index < source.length; index++) {
+    const character = source[index];
+    if (character === '{') {
+      braceDepth++;
+    } else if (character === '}') {
+      braceDepth--;
+      if (braceDepth === 0) {
+        return {openBraceIndex, closeBraceIndex: index};
+      }
+    }
+  }
+
+  return null;
+}
+
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}