text: (function (Prism) {
  
  	var keyword = /\b(?:alignas|alignof|asm|auto|bool|break|case|catch|char|char8_t|char16_t|char32_t|class|compl|concept|const|consteval|constexpr|constinit|const_cast|continue|co_await|co_return|co_yield|decltype|default|delete|do|double|dynamic_cast|else|enum|explicit|export|extern|final|float|for|friend|goto|if|import|inline|int|int8_t|int16_t|int32_t|int64_t|uint8_t|uint16_t|uint32_t|uint64_t|long|module|mutable|namespace|new|noexcept|nullptr|operator|override|private|protected|public|register|reinterpret_cast|requires|return|short|signed|sizeof|static|static_assert|static_cast|struct|switch|template|this|thread_local|throw|try|typedef|typeid|typename|union|unsigned|using|virtual|void|volatile|wchar_t|while)\b/;
  	var modName = /\b(?!<keyword>)\w+(?:\s*\.\s*\w+)*\b/.source.replace(/<keyword>/g, function () { return keyword.source; });
  
  	Prism.languages.cpp = Prism.languages.extend('c', {
  		'class-name': [
  			{
  				pattern: RegExp(/(\b(?:class|concept|enum|struct|typename)\s+)(?!<keyword>)\w+/.source
  					.replace(/<keyword>/g, function () { return keyword.source; })),
  				lookbehind: true
  			},
  			// This is intended to capture the class name of method implementations like:
  			//   void foo::bar() const {}
  			// However! The `foo` in the above example could also be a namespace, so we only capture the class name if
  			// it starts with an uppercase letter. This approximation should give decent results.
  			/\b[A-Z]\w*(?=\s*::\s*\w+\s*\()/,
  			// This will capture the class name before destructors like:
  			//   Foo::~Foo() {}
  			/\b[A-Z_]\w*(?=\s*::\s*~\w+\s*\()/i,
  			// This also intends to capture the class name of method implementations but here the class has template
  			// parameters, so it can't be a namespace (until C++ adds generic namespaces).
  			/\b\w+(?=\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>\s*::\s*\w+\s*\()/
  		],
  		'keyword': keyword,
  		'number': {
  			pattern: /(?:\b0b[01']+|\b0x(?:[\da-f']+(?:\.[\da-f']*)?|\.[\da-f']+)(?:p[+-]?[\d']+)?|(?:\b[\d']+(?:\.[\d']*)?|\B\.[\d']+)(?:e[+-]?[\d']+)?)[ful]{0,4}/i,
  			greedy: true
  		},
  		'operator': />>=?|<<=?|->|--|\+\+|&&|\|\||[?:~]|<=>|[-+*/%&|^!=<>]=?|\b(?:and|and_eq|bitand|bitor|not|not_eq|or|or_eq|xor|xor_eq)\b/,
  		'boolean': /\b(?:true|false)\b/
  	});
  
  	Prism.languages.insertBefore('cpp', 'string', {
  		'module': {
  			// https://en.cppreference.com/w/cpp/language/modules
  			pattern: RegExp(
  				/(\b(?:module|import)\s+)/.source +
  				'(?:' +
  				// header-name
  				/"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|<[^<>\r\n]*>/.source +
  				'|' +
  				// module name or partition or both
  				/<mod-name>(?:\s*:\s*<mod-name>)?|:\s*<mod-name>/.source.replace(/<mod-name>/g, function () { return modName; }) +
  				')'
  			),
  			lookbehind: true,
  			greedy: true,
  			inside: {
  				'string': /^[<"][\s\S]+/,
  				'operator': /:/,
  				'punctuation': /\./
  			}
  		},
  		'raw-string': {
  			pattern: /R"([^()\\ ]{0,16})\([\s\S]*?\)\1"/,
  			alias: 'string',
  			greedy: true
  		}
  	});
  
  	Prism.languages.insertBefore('cpp', 'keyword', {
  		'generic-function': {
  			pattern: /\b[a-z_]\w*\s*<(?:[^<>]|<(?:[^<>])*>)*>(?=\s*\()/i,
  			inside: {
  				'function': /^\w+/,
  				'generic': {
  					pattern: /<[\s\S]+/,
  					alias: 'class-name',
  					inside: Prism.languages.cpp
  				}
  			}
  		}
  	});
  
  	Prism.languages.insertBefore('cpp', 'operator', {
  		'double-colon': {
  			pattern: /::/,
  			alias: 'punctuation'
  		}
  	});
  
  	Prism.languages.insertBefore('cpp', 'class-name', {
  		// the base clause is an optional list of parent classes
  		// https://en.cppreference.com/w/cpp/language/class
  		'base-clause': {
  			pattern: /(\b(?:class|struct)\s+\w+\s*:\s*)[^;{}"'\s]+(?:\s+[^;{}"'\s]+)*(?=\s*[;{])/,
  			lookbehind: true,
  			greedy: true,
  			inside: Prism.languages.extend('cpp', {})
  		}
  	});
  
  	Prism.languages.insertBefore('inside', 'double-colon', {
  		// All untokenized words that are not namespaces should be class names
  		'class-name': /\b[a-z_]\w*\b(?!\s*::)/i
  	}, Prism.languages.cpp['base-clause']);
  
  }(Prism));
  