Transfrom languages to use the base property

src/languages/actionscript.ts

@@ -4,24 +4,18 @@ import type { GrammarToken, LanguageProto } from '../types';
 
 export default {
 	id: 'actionscript',
-	require: javascript,
-	grammar ({ extend }) {
-		const actionscript = extend('javascript', {
-			'keyword':
-				/\b(?:as|break|case|catch|class|const|default|delete|do|dynamic|each|else|extends|final|finally|for|function|get|if|implements|import|in|include|instanceof|interface|internal|is|namespace|native|new|null|override|package|private|protected|public|return|set|static|super|switch|this|throw|try|typeof|use|var|void|while|with)\b/,
-			'operator': /\+\+|--|(?:[+\-*\/%^]|&&?|\|\|?|<<?|>>?>?|[!=]=?)=?|[~?@]/,
-		});
-
-		const className = actionscript['class-name'] as GrammarToken;
+	base: javascript,
+	grammar ({ base }) {
+		const className = base['class-name'] as GrammarToken;
 		className.alias = 'function';
 
-		delete actionscript['doc-comment'];
+		delete base['doc-comment'];
 
 		// doesn't work with AS because AS is too complex
-		delete actionscript['parameter'];
-		delete actionscript['literal-property'];
+		delete base['parameter'];
+		delete base['literal-property'];
 
-		insertBefore(actionscript, 'string', {
+		insertBefore(base, 'string', {
 			'xml': {
 				pattern:
 					/(^|[^.])<\/?\w+(?:\s+[^\s>\/=]+=("|')(?:\\[\s\S]|(?!\2)[^\\])*\2)*\s*\/?>/,
@@ -30,6 +24,10 @@ export default {
 			},
 		});
 
-		return actionscript;
+		return {
+			'keyword':
+				/\b(?:as|break|case|catch|class|const|default|delete|do|dynamic|each|else|extends|final|finally|for|function|get|if|implements|import|in|include|instanceof|interface|internal|is|namespace|native|new|null|override|package|private|protected|public|return|set|static|super|switch|this|throw|try|typeof|use|var|void|while|with)\b/,
+			'operator': /\+\+|--|(?:[+\-*\/%^]|&&?|\|\|?|<<?|>>?>?|[!=]=?)=?|[~?@]/,
+		};
 	},
 } as LanguageProto<'actionscript'>;

src/languages/arduino.ts

@@ -3,16 +3,16 @@ import type { LanguageProto } from '../types';
 
 export default {
 	id: 'arduino',
-	require: cpp,
+	base: cpp,
 	alias: 'ino',
-	grammar ({ extend }) {
-		return extend('cpp', {
+	grammar () {
+		return {
 			'keyword':
 				/\b(?:String|array|bool|boolean|break|byte|case|catch|continue|default|do|double|else|finally|for|function|goto|if|in|instanceof|int|integer|long|loop|new|null|return|setup|string|switch|throw|try|void|while|word)\b/,
 			'constant':
 				/\b(?:ANALOG_MESSAGE|DEFAULT|DIGITAL_MESSAGE|EXTERNAL|FIRMATA_STRING|HIGH|INPUT|INPUT_PULLUP|INTERNAL|INTERNAL1V1|INTERNAL2V56|LED_BUILTIN|LOW|OUTPUT|REPORT_ANALOG|REPORT_DIGITAL|SET_PIN_MODE|SYSEX_START|SYSTEM_RESET)\b/,
 			'builtin':
 				/\b(?:Audio|BSSID|Bridge|Client|Console|EEPROM|Esplora|EsploraTFT|Ethernet|EthernetClient|EthernetServer|EthernetUDP|File|FileIO|FileSystem|Firmata|GPRS|GSM|GSMBand|GSMClient|GSMModem|GSMPIN|GSMScanner|GSMServer|GSMVoiceCall|GSM_SMS|HttpClient|IPAddress|IRread|Keyboard|KeyboardController|LiquidCrystal|LiquidCrystal_I2C|Mailbox|Mouse|MouseController|PImage|Process|RSSI|RobotControl|RobotMotor|SD|SPI|SSID|Scheduler|Serial|Server|Servo|SoftwareSerial|Stepper|Stream|TFT|Task|USBHost|WiFi|WiFiClient|WiFiServer|WiFiUDP|Wire|YunClient|YunServer|abs|addParameter|analogRead|analogReadResolution|analogReference|analogWrite|analogWriteResolution|answerCall|attach|attachGPRS|attachInterrupt|attached|autoscroll|available|background|beep|begin|beginPacket|beginSD|beginSMS|beginSpeaker|beginTFT|beginTransmission|beginWrite|bit|bitClear|bitRead|bitSet|bitWrite|blink|blinkVersion|buffer|changePIN|checkPIN|checkPUK|checkReg|circle|cityNameRead|cityNameWrite|clear|clearScreen|click|close|compassRead|config|connect|connected|constrain|cos|countryNameRead|countryNameWrite|createChar|cursor|debugPrint|delay|delayMicroseconds|detach|detachInterrupt|digitalRead|digitalWrite|disconnect|display|displayLogos|drawBMP|drawCompass|encryptionType|end|endPacket|endSMS|endTransmission|endWrite|exists|exitValue|fill|find|findUntil|flush|gatewayIP|get|getAsynchronously|getBand|getButton|getCurrentCarrier|getIMEI|getKey|getModifiers|getOemKey|getPINUsed|getResult|getSignalStrength|getSocket|getVoiceCallStatus|getXChange|getYChange|hangCall|height|highByte|home|image|interrupts|isActionDone|isDirectory|isListening|isPIN|isPressed|isValid|keyPressed|keyReleased|keyboardRead|knobRead|leftToRight|line|lineFollowConfig|listen|listenOnLocalhost|loadImage|localIP|lowByte|macAddress|maintain|map|max|messageAvailable|micros|millis|min|mkdir|motorsStop|motorsWrite|mouseDragged|mouseMoved|mousePressed|mouseReleased|move|noAutoscroll|noBlink|noBuffer|noCursor|noDisplay|noFill|noInterrupts|noListenOnLocalhost|noStroke|noTone|onReceive|onRequest|open|openNextFile|overflow|parseCommand|parseFloat|parseInt|parsePacket|pauseMode|peek|pinMode|playFile|playMelody|point|pointTo|position|pow|prepare|press|print|printFirmwareVersion|printVersion|println|process|processInput|pulseIn|put|random|randomSeed|read|readAccelerometer|readBlue|readButton|readBytes|readBytesUntil|readGreen|readJoystickButton|readJoystickSwitch|readJoystickX|readJoystickY|readLightSensor|readMessage|readMicrophone|readNetworks|readRed|readSlider|readString|readStringUntil|readTemperature|ready|rect|release|releaseAll|remoteIP|remoteNumber|remotePort|remove|requestFrom|retrieveCallingNumber|rewindDirectory|rightToLeft|rmdir|robotNameRead|robotNameWrite|run|runAsynchronously|runShellCommand|runShellCommandAsynchronously|running|scanNetworks|scrollDisplayLeft|scrollDisplayRight|seek|sendAnalog|sendDigitalPortPair|sendDigitalPorts|sendString|sendSysex|serialEvent|setBand|setBitOrder|setClockDivider|setCursor|setDNS|setDataMode|setFirmwareVersion|setMode|setPINUsed|setSpeed|setTextSize|setTimeout|shiftIn|shiftOut|shutdown|sin|size|sqrt|startLoop|step|stop|stroke|subnetMask|switchPIN|tan|tempoWrite|text|tone|transfer|tuneWrite|turn|updateIR|userNameRead|userNameWrite|voiceCall|waitContinue|width|write|writeBlue|writeGreen|writeJSON|writeMessage|writeMicroseconds|writeRGB|writeRed|yield)\b/,
-		});
+		};
 	},
 } as LanguageProto<'arduino'>;

src/languages/aspnet.ts

@@ -5,58 +5,43 @@ import type { Grammar, GrammarToken, LanguageProto } from '../types';
 
 export default {
 	id: 'aspnet',
-	require: [markup, csharp],
-	grammar ({ extend }) {
-		const pageDirectiveInside: Grammar = {
-			'page-directive': {
-				pattern:
-					/<%\s*@\s*(?:Assembly|Control|Implements|Import|Master(?:Type)?|OutputCache|Page|PreviousPageType|Reference|Register)?|%>/i,
-				alias: 'tag',
-			},
-		};
-
-		const aspnet = extend('markup', {
-			'page-directive': {
-				pattern: /<%\s*@.*%>/,
-				alias: 'tag',
-				inside: pageDirectiveInside,
-			},
-			'directive': {
-				pattern: /<%.*%>/,
-				alias: 'tag',
-				inside: {
-					'directive': {
-						pattern: /<%\s*?[$=%#:]{0,2}|%>/,
-						alias: 'tag',
-					},
-					$rest: 'csharp',
-				} as unknown as Grammar,
+	base: markup,
+	require: csharp,
+	grammar ({ base }) {
+		const directive = {
+			pattern: /<%.*%>/,
+			alias: 'tag',
+			inside: {
+				'directive': {
+					pattern: /<%\s*?[$=%#:]{0,2}|%>/,
+					alias: 'tag',
+				},
+				$rest: 'csharp',
 			},
-		});
+		} as unknown as GrammarToken;
 
-		const tag = aspnet['tag'] as GrammarToken & {
+		const tag = base['tag'] as GrammarToken & {
 			inside: { 'attr-value': { inside: Grammar } };
 		};
-		pageDirectiveInside.$rest = tag.inside;
 
 		// Regexp copied from markup, with a negative look-ahead added
 		tag.pattern =
 			/<(?!%)\/?[^\s>\/]+(?:\s+[^\s>\/=]+(?:=(?:("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|[^\s'">=]+))?)*\s*\/?>/;
 
 		// match directives of attribute value foo="<% Bar %>"
 		insertBefore(tag.inside['attr-value'].inside, 'punctuation', {
-			'directive': aspnet['directive'],
+			'directive': directive,
 		});
 
-		insertBefore(aspnet, 'comment', {
+		insertBefore(base, 'comment', {
 			'asp-comment': {
 				pattern: /<%--[\s\S]*?--%>/,
 				alias: ['asp', 'comment'],
 			},
 		});
 
 		// script runat="server" contains csharp, not javascript
-		insertBefore(aspnet, 'script' in aspnet ? 'script' : 'tag', {
+		insertBefore(base, 'script' in base ? 'script' : 'tag', {
 			'asp-script': {
 				pattern: /(<script(?=.*runat=['"]?server\b)[^>]*>)[\s\S]*?(?=<\/script>)/i,
 				lookbehind: true,
@@ -65,6 +50,20 @@ export default {
 			},
 		});
 
-		return aspnet;
+		return {
+			'page-directive': {
+				pattern: /<%\s*@.*%>/,
+				alias: 'tag',
+				inside: {
+					'page-directive': {
+						pattern:
+							/<%\s*@\s*(?:Assembly|Control|Implements|Import|Master(?:Type)?|OutputCache|Page|PreviousPageType|Reference|Register)?|%>/i,
+						alias: 'tag',
+					},
+					$rest: tag.inside as Grammar['$rest'],
+				},
+			},
+			'directive': directive,
+		};
 	},
 } as LanguageProto<'aspnet'>;

src/languages/birb.ts

@@ -4,9 +4,17 @@ import type { LanguageProto } from '../types';
 
 export default {
 	id: 'birb',
-	require: clike,
-	grammar ({ extend }) {
-		const birb = extend('clike', {
+	base: clike,
+	grammar ({ base }) {
+		insertBefore(base, 'function', {
+			'metadata': {
+				pattern: /<\w+>/,
+				greedy: true,
+				alias: 'symbol',
+			},
+		});
+
+		return {
 			'string': {
 				pattern: /r?("|')(?:\\.|(?!\1)[^\\])*\1/,
 				greedy: true,
@@ -21,16 +29,6 @@ export default {
 				/\b(?:assert|break|case|class|const|default|else|enum|final|follows|for|grab|if|nest|new|next|noSeeb|return|static|switch|throw|var|void|while)\b/,
 			'operator': /\+\+|--|&&|\|\||<<=?|>>=?|~(?:\/=?)?|[+\-*\/%&^|=!<>]=?|\?|:/,
 			'variable': /\b[a-z_]\w*\b/,
-		});
-
-		insertBefore(birb, 'function', {
-			'metadata': {
-				pattern: /<\w+>/,
-				greedy: true,
-				alias: 'symbol',
-			},
-		});
-
-		return birb;
+		};
 	},
 } as LanguageProto<'birb'>;

src/languages/bison.ts

@@ -4,12 +4,9 @@ import type { Grammar, LanguageProto } from '../types';
 
 export default {
 	id: 'bison',
-	require: c,
-	grammar ({ extend, getLanguage }) {
-		const c = getLanguage('c');
-		const bison = extend('c', {});
-
-		insertBefore(bison, 'comment', {
+	base: c,
+	grammar ({ base }) {
+		insertBefore(base, 'comment', {
 			'bison': {
 				// This should match all the beginning of the file
 				// including the prologue(s), the bison declarations and
@@ -31,11 +28,11 @@ export default {
 									'punctuation': /<|>/,
 								},
 							},
-							$rest: c,
+							$rest: 'c',
 						} as unknown as Grammar,
 					},
-					'comment': c.comment,
-					'string': c.string,
+					'comment': base.comment,
+					'string': base.string,
 					'property': /\S+(?=:)/,
 					'keyword': /%\w+/,
 					'number': {
@@ -47,6 +44,6 @@ export default {
 			},
 		});
 
-		return bison;
+		return {};
 	},
 } as LanguageProto<'bison'>;

src/languages/c.ts

@@ -4,41 +4,18 @@ import type { GrammarToken, LanguageProto } from '../types';
 
 export default {
 	id: 'c',
-	require: clike,
+	base: clike,
 	optional: 'opencl-extensions',
-	grammar ({ extend, getOptionalLanguage }) {
-		const c = extend('clike', {
-			'comment': {
-				pattern: /\/\/(?:[^\r\n\\]|\\(?:\r\n?|\n|(?![\r\n])))*|\/\*[\s\S]*?(?:\*\/|$)/,
-				greedy: true,
-			},
-			'string': {
-				// https://en.cppreference.com/w/c/language/string_literal
-				pattern: /"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"/,
-				greedy: true,
-			},
-			'class-name': {
-				pattern:
-					/(\b(?:enum|struct)\s+(?:__attribute__\s*\(\([\s\S]*?\)\)\s*)?)\w+|\b[a-z]\w*_t\b/,
-				lookbehind: true,
-			},
-			'keyword':
-				/\b(?:_Alignas|_Alignof|_Atomic|_Bool|_Complex|_Generic|_Imaginary|_Noreturn|_Static_assert|_Thread_local|__attribute__|asm|auto|break|case|char|const|continue|default|do|double|else|enum|extern|float|for|goto|if|inline|int|long|register|return|short|signed|sizeof|static|struct|switch|typedef|typeof|union|unsigned|void|volatile|while)\b/,
-			'function': /\b[a-z_]\w*(?=\s*\()/i,
-			'number':
-				/(?:\b0x(?:[\da-f]+(?:\.[\da-f]*)?|\.[\da-f]+)(?:p[+-]?\d+)?|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?)[ful]{0,4}/i,
-			'operator': />>=?|<<=?|->|([-+&|:])\1|[?:~]|[-+*/%&|^!=<>]=?/,
-		});
-
-		insertBefore(c, 'string', {
+	grammar ({ base, getOptionalLanguage }) {
+		insertBefore(base, 'string', {
 			'char': {
 				// https://en.cppreference.com/w/c/language/character_constant
 				pattern: /'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n]){0,32}'/,
 				greedy: true,
 			},
 		});
 
-		insertBefore(c, 'string', {
+		insertBefore(base, 'string', {
 			'macro': {
 				// allow for multiline macro definitions
 				// spaces after the # character compile fine with gcc
@@ -54,10 +31,10 @@ export default {
 							pattern: /^(#\s*include\s*)<[^>]+>/,
 							lookbehind: true,
 						},
-						c['string'] as GrammarToken,
+						base['string'] as GrammarToken,
 					],
-					'char': c['char'],
-					'comment': c['comment'],
+					'char': base['char'],
+					'comment': base['comment'],
 					'macro-name': [
 						{
 							pattern: /(^#\s*define\s+)\w+\b(?!\()/i,
@@ -79,27 +56,48 @@ export default {
 					'punctuation': /##|\\(?=[\r\n])/,
 					'expression': {
 						pattern: /\S[\s\S]*/,
-						inside: c,
+						inside: 'c',
 					},
 				},
 			},
 		});
 
-		insertBefore(c, 'function', {
+		insertBefore(base, 'function', {
 			// highlight predefined macros as constants
 			'constant':
 				/\b(?:EOF|NULL|SEEK_CUR|SEEK_END|SEEK_SET|__DATE__|__FILE__|__LINE__|__TIMESTAMP__|__TIME__|__func__|stderr|stdin|stdout)\b/,
 		});
 
-		delete c['boolean'];
+		delete base['boolean'];
 
 		/* OpenCL host API */
 		const extensions = getOptionalLanguage('opencl-extensions');
 		if (extensions) {
-			insertBefore(c, 'keyword', extensions);
-			delete c['type-opencl-host-cpp'];
+			insertBefore(base, 'keyword', extensions);
+			delete base['type-opencl-host-cpp'];
 		}
 
-		return c;
+		return {
+			'comment': {
+				pattern: /\/\/(?:[^\r\n\\]|\\(?:\r\n?|\n|(?![\r\n])))*|\/\*[\s\S]*?(?:\*\/|$)/,
+				greedy: true,
+			},
+			'string': {
+				// https://en.cppreference.com/w/c/language/string_literal
+				pattern: /"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"/,
+				greedy: true,
+			},
+			'class-name': {
+				pattern:
+					/(\b(?:enum|struct)\s+(?:__attribute__\s*\(\([\s\S]*?\)\)\s*)?)\w+|\b[a-z]\w*_t\b/,
+				lookbehind: true,
+			},
+			'keyword':
+				/\b(?:_Alignas|_Alignof|_Atomic|_Bool|_Complex|_Generic|_Imaginary|_Noreturn|_Static_assert|_Thread_local|__attribute__|asm|auto|break|case|char|const|continue|default|do|double|else|enum|extern|float|for|goto|if|inline|int|long|register|return|short|signed|sizeof|static|struct|switch|typedef|typeof|union|unsigned|void|volatile|while)\b/,
+			'function': /\b[a-z_]\w*(?=\s*\()/i,
+			'number':
+				/(?:\b0x(?:[\da-f]+(?:\.[\da-f]*)?|\.[\da-f]+)(?:p[+-]?\d+)?|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?)[ful]{0,4}/i,
+			'operator': />>=?|<<=?|->|([-+&|:])\1|[?:~]|[-+*/%&|^!=<>]=?/,
+		};
 	},
 } as LanguageProto<'c'>;