utopia-project 0.37.6 → 0.38.0

data/public/_components/@socketry/syntax/Syntax/Language/html.js

@@ -0,0 +1,69 @@
+import {Language} from '../Language.js';
+import {Rule} from '../Rule.js';
+
+const language = new Language('html');
+
+// Custom handler for all <script> tags - determines language based on type attribute
+language.push({
+	pattern: /<script(\s+[^>]*?)?>((.|\n)*?)<\/script>/im,
+	matches: Rule.extractConditionalMatch(1, 2, [
+		{pattern: /type\s*=\s*["']importmap["']/i, language: 'json'},
+		{pattern: /type\s*=\s*["'](?:text|application)\/javascript["']/i, language: 'javascript'},
+		{language: 'javascript'} // Fallback: no type or unknown type defaults to JavaScript (HTML5)
+	])
+});
+
+// Embedded CSS in <style> tags
+language.push({
+	pattern: /<style.*?type=.?text\/css.*?>((.|\n)*?)<\/style>/im,
+	matches: Rule.extractMatches({language: 'css'})
+});
+
+// Embedded PHP
+language.push({
+	pattern: /((<\?php)([\s\S]*?)(\?>))/m,
+	matches: Rule.extractMatches(
+		{type: 'php-tag', allow: ['keyword', 'php-script']},
+		{type: 'keyword'},
+		{language: 'php-script'},
+		{type: 'keyword'}
+	)
+});
+
+// Embedded Ruby
+language.push({
+	pattern: /((<\?rb?)([\s\S]*?)(\?>))/m,
+	matches: Rule.extractMatches(
+		{type: 'ruby-tag', allow: ['keyword', 'ruby']},
+		{type: 'keyword'},
+		{language: 'ruby'},
+		{type: 'keyword'}
+	)
+});
+
+// ERB-style instructions
+language.push({
+	pattern: /<%=?(.*?)(%>)/,
+	type: 'instruction',
+	allow: ['string']
+});
+
+// DOCTYPE declarations
+language.push({
+	pattern: /<\!(DOCTYPE(.*?))>/,
+	matches: Rule.extractMatches({type: 'doctype'})
+});
+
+// Percent escapes
+language.push({
+	pattern: /(%[0-9a-f]{2})/i,
+	type: 'percent-escape',
+	only: ['html']
+});
+
+// Derive from XML for tag parsing
+language.derives('xml');
+
+export default function register(syntax) {
+	syntax.register('html', language);
+}

data/public/_components/@socketry/syntax/Syntax/Language/io.js

@@ -0,0 +1,68 @@
+import {Language} from '../Language.js';
+import {Rule} from '../Rule.js';
+
+const language = new Language('io');
+
+language.push(Rule.cStyleFunction);
+
+const keywords = ['return'];
+
+// Operators ordered longest-first
+const operators = [
+	'::=',
+	':=',
+	'or',
+	'and',
+	'new',
+	'delete',
+	'@',
+	'+',
+	'*',
+	'/',
+	'-',
+	'&',
+	'|',
+	'~',
+	'!',
+	'%',
+	'<',
+	'=',
+	'>',
+	'[',
+	']'
+];
+
+language.push(keywords, {type: 'keyword'});
+language.push(operators, {type: 'operator'});
+
+// Extract space delimited method invocations
+language.push({
+	pattern: /\b([ \t]+([a-z]+))/i,
+	matches: Rule.extractMatches({index: 2, type: 'function'})
+});
+
+language.push({
+	pattern: /\)([ \t]+([a-z]+))/i,
+	matches: Rule.extractMatches({index: 2, type: 'function'})
+});
+
+// CamelCase types
+language.push(Rule.camelCaseType);
+
+language.push(Rule.perlStyleComment);
+language.push(Rule.cStyleComment);
+language.push(Rule.cppStyleComment);
+language.push(Rule.webLink);
+
+// Strings
+language.push(Rule.singleQuotedString);
+language.push(Rule.doubleQuotedString);
+language.push(Rule.stringEscape);
+
+// Numbers
+language.push(Rule.decimalNumber);
+language.push(Rule.hexNumber);
+
+export default function register(syntax) {
+	syntax.register('io', language);
+}

data/public/_components/@socketry/syntax/Syntax/Language/java.js

@@ -0,0 +1,134 @@
+import {Language} from '../Language.js';
+import {Rule} from '../Rule.js';
+
+const language = new Language('java');
+
+const keywords = [
+	'abstract',
+	'continue',
+	'for',
+	'switch',
+	'assert',
+	'default',
+	'goto',
+	'synchronized',
+	'do',
+	'if',
+	'break',
+	'implements',
+	'throw',
+	'else',
+	'import',
+	'throws',
+	'case',
+	'enum',
+	'return',
+	'transient',
+	'catch',
+	'extends',
+	'try',
+	'final',
+	'interface',
+	'static',
+	'class',
+	'finally',
+	'strictfp',
+	'volatile',
+	'const',
+	'native',
+	'super',
+	'while'
+];
+
+const access = ['private', 'protected', 'public', 'package'];
+
+const types = [
+	'void',
+	'byte',
+	'short',
+	'int',
+	'long',
+	'float',
+	'double',
+	'boolean',
+	'char'
+];
+
+// Operators ordered longest-first to match correctly
+const operators = [
+	'>>>=',
+	'<<=',
+	'>>=',
+	'>>>',
+	'instanceof',
+	'==',
+	'!=',
+	'<=',
+	'>=',
+	'<<',
+	'>>',
+	'&&',
+	'||',
+	'++',
+	'--',
+	'+=',
+	'-=',
+	'*=',
+	'/=',
+	'%=',
+	'&=',
+	'^=',
+	'|=',
+	'new',
+	'delete',
+	'<',
+	'>',
+	'+',
+	'-',
+	'~',
+	'!',
+	'*',
+	'/',
+	'%',
+	'&',
+	'^',
+	'|',
+	'?',
+	'='
+];
+
+const constants = ['this', 'true', 'false', 'null'];
+
+language.push(constants, {type: 'constant'});
+language.push(types, {type: 'type'});
+language.push(keywords, {type: 'keyword'});
+language.push(operators, {type: 'operator'});
+language.push(access, {type: 'access'});
+
+// Camel Case Types
+language.push(Rule.camelCaseType);
+
+// Comments
+language.push(Rule.cStyleComment);
+language.push(Rule.cppStyleComment);
+language.push(Rule.webLink);
+
+// Numbers
+language.push(Rule.decimalNumber);
+language.push(Rule.hexNumber);
+
+// Strings
+language.push(Rule.singleQuotedString);
+language.push(Rule.doubleQuotedString);
+language.push(Rule.stringEscape);
+
+language.push(Rule.cStyleFunction);
+
+language.processes['function'] = Rule.webLinkProcess(
+	'java "Developer Documentation"',
+	true
+);
+
+export default function register(syntax) {
+	syntax.register('java', language);
+}

data/public/_components/@socketry/syntax/Syntax/Language/javascript.js

@@ -0,0 +1,89 @@
+import {Language} from '../Language.js';
+import {Rule} from '../Rule.js';
+
+const language = new Language('javascript');
+
+// Constants/values
+language.push(['this', 'true', 'false', 'null'], {type: 'constant'});
+
+// Keywords
+language.push(
+	[
+		'async',
+		'await',
+		'break',
+		'case',
+		'catch',
+		'class',
+		'const',
+		'continue',
+		'debugger',
+		'default',
+		'delete',
+		'do',
+		'else',
+		'export',
+		'extends',
+		'finally',
+		'for',
+		'function',
+		'if',
+		'import',
+		'in',
+		'instanceof',
+		'let',
+		'new',
+		'return',
+		'super',
+		'switch',
+		'this',
+		'throw',
+		'try',
+		'typeof',
+		'var',
+		'void',
+		'while',
+		'with',
+		'yield'
+	],
+	{type: 'keyword'}
+);
+
+// Operators
+language.push(['+', '*', '/', '-', '&', '|', '~', '!', '%', '<', '=', '>', '...'], {
+	type: 'operator'
+});
+
+// Access modifiers
+language.push(
+	['implements', 'package', 'protected', 'interface', 'private', 'public'],
+	{type: 'access'}
+);
+
+// Regular expressions
+language.push(Rule.perlStyleRegularExpression);
+
+// Camel Case Types
+language.push(Rule.camelCaseType);
+
+// Comments
+language.push(Rule.cStyleComment);
+language.push(Rule.cppStyleComment);
+language.push(Rule.webLink);
+
+// Strings
+language.push(Rule.singleQuotedString);
+language.push(Rule.doubleQuotedString);
+language.push(Rule.stringEscape);
+
+// Numbers
+language.push(Rule.decimalNumber);
+language.push(Rule.hexNumber);
+
+// Functions
+language.push(Rule.cStyleFunction);
+
+export default function register(syntax) {
+	syntax.register('javascript', language);
+	syntax.alias('javascript', ['js', 'actionscript']);
+}

data/public/_components/@socketry/syntax/Syntax/Language/json.js

@@ -0,0 +1,36 @@
+import {Language} from '../Language.js';
+import {Rule} from '../Rule.js';
+
+const language = new Language('json');
+
+// JSON values: true, false, null
+language.push(['true', 'false', 'null'], {type: 'constant'});
+
+// JSON numbers (integers, floats, scientific notation)
+language.push({
+	pattern: /-?(0|[1-9]\d*)(\.\d+)?([eE][+-]?\d+)?/,
+	type: 'constant'
+});
+
+// JSON strings (with escapes)
+language.push({
+	pattern: /"(?:[^"\\]|\\.)*"/,
+	type: 'string'
+});
+
+// Object keys (strings followed by colon)
+language.push({
+	pattern: /("(?:[^"\\]|\\.)*")(\s*)(:)/,
+	matches: Rule.extractMatches(
+		{type: 'key'},
+		null,
+		{type: 'operator'}
+	)
+});
+
+// Structural characters
+language.push(['{', '}', '[', ']', ','], {type: 'operator'});
+
+export default function register(syntax) {
+	syntax.register('json', language);
+}

data/public/_components/@socketry/syntax/Syntax/Language/lisp.js

@@ -0,0 +1,38 @@
+import {Language} from '../Language.js';
+import {Rule} from '../Rule.js';
+const lispStyleComment = {
+	pattern: /(;+) .*$/m,
+	type: 'comment',
+	allow: ['href']
+};
+
+// This syntax is intentionally very sparse. This is because it is a general syntax for Lisp like languages.
+// It might be a good idea to make specific dialects (e.g. common lisp, scheme, clojure, etc)
+
+const language = new Language('lisp');
+
+language.push(['(', ')'], {type: 'operator'});
+
+language.push(lispStyleComment);
+
+language.push(Rule.hexNumber);
+language.push(Rule.decimalNumber);
+language.push(Rule.webLink);
+
+language.push({
+	pattern: /\(\s*([^\s\(\)]+)/im,
+	matches: Rule.extractMatches({type: 'function'})
+});
+
+language.push({
+	pattern: /#[a-z]+/i,
+	type: 'constant'
+});
+
+// Strings
+language.push(Rule.multiLineDoubleQuotedString);
+language.push(Rule.stringEscape);
+
+export default function register(syntax) {
+	syntax.register('lisp', language);
+}

data/public/_components/@socketry/syntax/Syntax/Language/lua.js

@@ -0,0 +1,87 @@
+import {Language} from '../Language.js';
+import {Rule} from '../Rule.js';
+
+const language = new Language('lua');
+
+const keywords = [
+	'and',
+	'break',
+	'do',
+	'else',
+	'elseif',
+	'end',
+	'false',
+	'for',
+	'function',
+	'if',
+	'in',
+	'local',
+	'nil',
+	'not',
+	'or',
+	'repeat',
+	'return',
+	'then',
+	'true',
+	'until',
+	'while'
+];
+
+// Operators ordered longest-first
+const operators = [
+	'==',
+	'~=',
+	'<=',
+	'>=',
+	'..',
+	'+',
+	'-',
+	'*',
+	'/',
+	'%',
+	'^',
+	'#',
+	'=',
+	'<',
+	'>',
+	'?',
+	':'
+];
+
+const values = ['self', 'true', 'false', 'nil'];
+
+language.push(values, {type: 'constant'});
+language.push(keywords, {type: 'keyword'});
+language.push(operators, {type: 'operator'});
+
+// CamelCase types
+language.push(Rule.camelCaseType);
+language.push(Rule.cStyleFunction);
+
+// Single-line comments
+language.push({
+	pattern: /\-\-.*$/m,
+	type: 'comment',
+	allow: ['href']
+});
+
+// Multi-line comments
+language.push({
+	pattern: /\-\-\[\[(\n|.)*?\]\]\-\-/m,
+	type: 'comment',
+	allow: ['href']
+});
+
+// Strings
+language.push(Rule.singleQuotedString);
+language.push(Rule.doubleQuotedString);
+language.push(Rule.stringEscape);
+
+language.push(Rule.hexNumber);
+language.push(Rule.decimalNumber);
+
+language.push(Rule.webLink);
+
+export default function register(syntax) {
+	syntax.register('lua', language);
+}

data/public/_components/@socketry/syntax/Syntax/Language/markdown.js

@@ -0,0 +1,112 @@
+import {Language} from '../Language.js';
+import {Rule} from '../Rule.js';
+
+const language = new Language('markdown');
+
+// Headers
+language.push({
+	pattern: /^#{1,6}\s+.+$/m,
+	type: 'heading'
+});
+
+// Bold (strong emphasis)
+language.push({
+	pattern: /\*\*(.+?)\*\*/,
+	type: 'strong'
+});
+
+language.push({
+	pattern: /__(.+?)__/,
+	type: 'strong'
+});
+
+// Italic (emphasis)
+language.push({
+	pattern: /\*(.+?)\*/,
+	type: 'emphasis'
+});
+
+language.push({
+	pattern: /_(.+?)_/,
+	type: 'emphasis'
+});
+
+// Code blocks with language
+language.push({
+	pattern: /^```[\w-]*\n[\s\S]*?\n```$/m,
+	type: 'code'
+});
+
+// Inline code
+language.push({
+	// Do not allow newlines inside inline code to avoid spanning across blocks/fences:
+	pattern: /`([^`\n\r]+)`/,
+	type: 'code'
+});
+
+// Links - make them clickable
+language.push({
+	pattern: /\[([^\]]+)\]\(([^)]+)\)/,
+	type: 'link',
+	matches: Rule.extractMatches(
+		{type: 'string'}, // Link text
+		{
+			type: 'link',
+			process: function (container, match) {
+				const anchor = document.createElement('a');
+				anchor.className = container.className;
+				anchor.textContent = container.textContent;
+				anchor.href = match.value;
+				return anchor;
+			}
+		} // URL
+	)
+});
+
+// Images
+language.push({
+	pattern: /!\[([^\]]*)\]\(([^)]+)\)/,
+	type: 'link'
+});
+
+// Blockquotes
+language.push({
+	pattern: /^>\s+.+$/m,
+	type: 'quote'
+});
+
+// Unordered lists
+language.push({
+	pattern: /^[\s]*[-*+]\s+/m,
+	type: 'list-marker'
+});
+
+// Ordered lists
+language.push({
+	pattern: /^[\s]*\d+\.\s+/m,
+	type: 'list-marker'
+});
+
+// Horizontal rules
+language.push({
+	pattern: /^(?:[-*_]){3,}$/m,
+	type: 'operator'
+});
+
+// URLs - make them clickable
+language.push({
+	...Rule.webLink,
+	type: 'link',
+	process: function (container, match) {
+		const anchor = document.createElement('a');
+		anchor.className = container.className;
+		anchor.textContent = match.value;
+		anchor.href = match.value;
+		return anchor;
+	}
+});
+
+export default function register(syntax) {
+	syntax.register('markdown', language);
+	syntax.alias('markdown', ['md']);
+}

data/public/_components/@socketry/syntax/Syntax/Language/nginx.js

@@ -0,0 +1,37 @@
+import {Language} from '../Language.js';
+import {Rule} from '../Rule.js';
+
+const language = new Language('nginx');
+
+// Directives with web links to nginx documentation
+language.push({
+	pattern: /((\w+).*?);/,
+	matches: Rule.extractMatches(
+		{type: 'directive', allow: '*'},
+		{
+			type: 'function',
+			process: Rule.webLinkProcess('http://nginx.org/r/')
+		}
+	)
+});
+
+// Keywords (blocks with { )
+language.push({
+	pattern: /(\w+).*?{/,
+	matches: Rule.extractMatches({type: 'keyword'})
+});
+
+// Variables ($var)
+language.push({pattern: /(\$)[\w]+/, type: 'variable'});
+
+// Comments and strings
+language.push(Rule.perlStyleComment);
+language.push(Rule.singleQuotedString);
+language.push(Rule.doubleQuotedString);
+
+// Web links
+language.push(Rule.webLink);
+
+export default function register(syntax) {
+	syntax.register('nginx', language);
+}

data/public/_components/@socketry/syntax/Syntax/Language/objective-c.js

@@ -0,0 +1 @@
+export {default} from './clang.js';