Whilst this answer doesn't directly use Regular Expressions, I post this as an alternative solution to parsing what looks like GLSL code.

Regular Expressions and parsing programming languages

Generally attempting to parse anything considered a programming language using Regular Expressions is a bad plan. This is due to the complexity of the languages i.e. things like comments, variable scope, escaping characters, etc.

It's always best to use a parser built to parse the language. There are generally parsers available for many languages that create an AST.

Summary

• Use a parser built for the GLSL language to build an AST (Abstract Syntax Tree)
• Libraries used are glsl-tokenizer and glsl-parser
• The AST output object contains a scope property which contains a list of globals.
• Note that in the sample provided the function sat is also considered listed in the scope
• We filter this list looking for declaration lists with only float types.
• Note that the output AST globals variable includes line numbers and position of the globals found.

var tokenString = require('glsl-tokenizer/string');
var parseTokens = require('glsl-parser/direct')

const code = `
float aaa = 3.0;

float sat( float t ) {
  return clamp( t, 0.0, 1.0 );
}

float bbb = 3.0;

vec3 spectrum_offset( float t ) {
  float t0 = 3.0;
  return clamp( vec3( -t0, 1.0-abs(t0), t0), 0.0, 1.0);
}
`;
const tokens = tokenString(code);
const ast = parseTokens(tokens)

function filterObject(obj, callback) {
  return Object.fromEntries(Object.entries(obj).
    filter(([key, val]) => callback(val, key)));
}
                  
const globals = filterObject(ast.scope, x => (
    x.parent.type === 'decllist' &&
    x.parent.parent.token.data == "float"
));

return globals;

The output

You can view this code running here: https://runkit.com/deanmarktaylor/find-global-variables-in-glsl-code

Here is example output objects, note the line number and position which might be useful.

Further reading

If you are after doing more than just knowing where the variables are in the code and actually manipulating these found variables... Instead of manipulating the string of the found global float variables you might find it best use the AST, adjust it and then generate the code from the AST.