@speed-highlight/core 1.1.7 → 1.1.8

package/examples/{helper/data.js → data.js}

@@ -1,51 +1,63 @@
+import '../typedef.js'
+
+/** @type {ShjLanguage[]} */
 export const languages = [
+	'js',
+	'py',
 	'bash',
-	'bf',
+	'ts',
+	'c',
 	'css',
+	'asm',
 	'csv',
 	'diff',
+	'docker',
 	'git',
+	'go',
 	'html',
 	'http',
 	'ini',
-	'js',
+	'java',
 	'jsdoc',
 	'json',
 	'leanpub-md',
+	'bf',
 	'log',
 	'lua',
 	'make',
 	'md',
 	'pl',
 	'plain',
-	'py',
 	'regex',
+	'rs',
 	'sql',
 	'todo',
 	'toml',
-	'ts',
 	'uri',
-	'yaml',
-	'docker',
 	'xml',
-	'c',
-	'rs',
-	'go',
-	'java',
-	'asm'
-].sort();
-export const themes = [
+	'yaml'
+]
+
+/** @type {ShjBrowserTheme[]} */
+export const themesBrowser = [
+	'default',
 	'atom-dark',
 	'github-dark',
 	'github-dim',
 	'dark',
-	'default',
 	'github-light',
 	'visual-studio-dark'
-];
+]
+
+/** @type {ShjTerminalTheme[]} */
+export const themesTerminal = [
+	'default',
+	'atom-dark'
+]
+
 export const testFiles = [
 	...languages,
 	'oneline.bash',
 	'oneline.http',
 	'screenshot.js'
-];
+]

package/examples/deno.js

@@ -1,14 +1,60 @@
-import { setTheme, printHighlight } from '../src/term.js';
+import { languages, themesTerminal } from './data.js'
+import { setTheme, printHighlight } from '../src/terminal.js';
 import { fromFileUrl } from 'https://deno.land/std/path/mod.ts';
+import { parse } from "https://deno.land/std/flags/mod.ts"
 
-const lang = Deno.args[0] ?? 'js';
+let args = parse(Deno.args)
 
-const path = fromFileUrl(import.meta.url.replace(/[^\\\/]+$/, `languages/test.${lang}`))
+if (args.help)
+{
+	console.log(`Usage deno run --allow-read deno.js [OPTION]... [TEST_FILE]`)
+	console.log(``)
+	console.log(`    --help              display this help and exit`)
+	console.log(`    --theme=[-]THEME    change the used THEME`)
+	console.log(`    --lang=[-]LANGUAGE  change the used LANGUAGE`)
+	console.log(`    --stdin             highlight code given from the stdin`)
+	console.log(``)
+	console.log(`THEME may be:`)
+	console.log(`${themesTerminal.join(', ')}`)
+	console.log(`LANGUAGE may be:`)
+	console.log(`${languages.join(', ')}`)
+	Deno.exit(0)
+}
+
+if (args.theme)
+{
+	if (!themesTerminal.includes(args.theme))
+	{
+		console.error(`'${args.theme}' is not a supported try on of the following theme:`)
+		console.log(`${themesTerminal.join(', ')}`)
+		Deno.exit(1)
+	}
+	await setTheme(args.theme)
+}
+
+if (args.lang && !languages.includes(args.lang))
+{
+	console.error(`'${args.lang}' is not a supported try on of the following languages:`)
+	console.log(`${languages.join(', ')}`)
+	Deno.exit(1)
+}
+
+if (args.stdin)
+{
+	const buf = new Uint8Array(1024)
+	let n;
+	do {
+		n = await Deno.stdin.read(buf)
+		const code = new TextDecoder().decode(buf.subarray(0, n))
+		await printHighlight(code, args.lang ?? 'js');
+	} while (n)
+	Deno.exit(0)
+}
+
+const absolutePath = args._[0] ?? fromFileUrl(import.meta.url.replace(/[^\\\/]+$/, './languages/test.js'))
 	.replace(Deno.cwd(), '')
 	.slice(1)
 
-const code = await Deno.readTextFile(path);
-
-await setTheme('default');
+const code = await Deno.readTextFile(absolutePath);
 
-printHighlight(code, lang);
+printHighlight(code, args.lang ?? args._[0]?.split?.('.')?.[1] ?? 'js');

package/examples/index.html

@@ -7,11 +7,14 @@
 	<title>Languages | Speed-highlight JS</title>
 	<style>
 		@import url('https://fonts.googleapis.com/css2?family=Fira+Code:wght@400&display=swap');
+		main {
+			max-width: 1000px;
+			margin: 0 auto
+		}
 		.fira {font: 18px 'Fira Code', monospace !important}
 		
 		body {margin: 0}
 		html {background: #001220}
-		main {margin: 10px}
 		h1 {
 			text-align: center;
 			font: bold 60px Arial;
@@ -56,7 +59,7 @@
 	<script type="module">
 		import { highlightElement } from '../src/index.js'
 		import { detectLanguage } from '../src/detect.js'
-		import { themes, testFiles } from './helper/data.js'
+		import { themesBrowser, testFiles } from './data.js'
 
 		const main = document.querySelector('main')
 		const elm = (type, opt) => Object.assign(document.createElement(type), opt)
@@ -86,8 +89,8 @@
 
 		async function	highlight(language) {
 			let path = language.includes('.') ? language : `test.${language}`,
-				txt = code.textContent = await (await fetch(`./languages/${path}`)).text()
-			let start = performance.now()
+				txt = code.textContent = await (await fetch(`./languages/${path}`)).text(),
+				start = performance.now()
 			await highlightElement(code, detect ? detectLanguage(txt) : path.split('.')[1], undefined, { hideLineNumbers })
 			chrono.textContent = `${(performance.now() - start).toFixed(3)}ms (counting loading time)`
 			chrono.animate([ { background: '#25f3' }, { background: 'unset' }],{ duration: 150 })
@@ -103,13 +106,13 @@
 
 		document.head.append(stylesheet)
 
-		new Radio('theme', theme => stylesheet.href = `../src/themes/${theme}.css`, themes)
+		new Radio('theme', theme => stylesheet.href = `../src/themes/${theme}.css`, themesBrowser)
 		new Checkbox('detect language', on => { detect = on; highlight(lang.selected) }, container)
 		new Checkbox('header mode', mode => code.classList.toggle('shj-mode-header', mode), container)
 		new Checkbox('use fira font', use => code.classList.toggle('fira', use), container).on = true
-		new Checkbox('hide line numbering', ln => { hideLineNumbers = ln; highlight(lang.selected) }, container)
+		new Checkbox('hide line numbering', ln => { hideLineNumbers = ln; highlight(lang.selected) }, container).on = true
 
 		main.append(container, chrono, code)
 	</script>
 </body>
-</html>
+</html>

package/examples/languages/test.c

@@ -30,7 +30,7 @@ int	main(int argc, char **argv)
 {
 	printf("Hello World!\n");
 
-	Point p;
+	Point pTest;
 
 	asm("movl $1, %0" : "=r"(p.x));
 	asm {

package/examples/languages/test.go

@@ -7,15 +7,15 @@ import "fmt"
 // main is the entry point for the program
 func main() {
 	// declare a variable named num and assign it the value of 10
-	num := 10
+	numTest := 10
 
 	// sanity check
-	fmt.Println("num is", num)
+	fmt.Println("num is", numTest)
 
 	//scan from the console and assign the value to the variable num
-	fmt.Scanln(&num)
+	fmt.Scanln(&numTest)
 
 
 	// print the value of num
-	fmt.Println(num)
+	fmt.Println(numTest)
 }

package/examples/languages/test.java

@@ -17,7 +17,7 @@ class Token {
 
 //lexer function that take a string and return a list of tokens
 List<Token> lexer(String s) {
-	List<Token> tokens = new ArrayList<Token>();
+	List<Token> tokensList = new ArrayList<Token>();
 	int line = 1;
 	int column = 0;
 	int i = 0;
@@ -47,6 +47,6 @@ void run(List<Token>) {
 //main function
 public static void main(String[] args) {
 	String s = "1+2+3";
-	List<Token> tokens = lexer(s);
-	run(tokens);
+	List<Token> tokensList = lexer(s);
+	run(tokensList);
 }

package/examples/node.js

@@ -1,6 +1,6 @@
 const fs = require('fs'),
 	path = require('path'),
-	{ setTheme, printHighlight } = require('../dist/node/term.js');
+	{ setTheme, printHighlight } = require('@speed-highlight/core/terminal');
 
 const lang = process.argv[2] ?? 'js';
 

package/jsdoc.json

@@ -0,0 +1,16 @@
+{
+    "plugins": [],
+    "recurseDepth": 10,
+    "source": {
+        "includePattern": ".+\\.js$"
+    },
+    "sourceType": "module",
+    "tags": {
+        "allowUnknownTags": true,
+        "dictionaries": ["jsdoc", "closure"]
+    },
+    "templates": {
+        "cleverLinks": false,
+        "monospaceLinks": false
+    }
+}

package/package.json

@@ -1,40 +1,44 @@
 {
-  "name": "@speed-highlight/core",
-  "version": "1.1.7",
-  "description": "🌈 Light, fast, and easy to use, dependencies free javascript syntax highlighter, with automatic language detection",
-  "main": "dist/node/index.js",
-  "directories": {
-    "example": "examples"
-  },
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git://github.com/speed-highlight/core.git"
-  },
-  "keywords": [
-    "javascript",
-    "syntax-highlighting",
-    "language",
-    "fast",
-    "js",
-    "simple",
-    "highlighter",
-    "regex",
-    "highlighting",
-    "highlightjs",
-    "small",
-    "deno"
-  ],
-  "author": "matubu",
-  "license": "CC0-1.0",
-  "bugs": {
-    "url": "https://github.com/speed-highlight/core/issues"
-  },
-  "homepage": "https://github.com/speed-highlight/core#readme",
-  "publishConfig": {
-    "registry": "https://npm.pkg.github.com/",
-    "access": "public"
-  }
+	"name": "@speed-highlight/core",
+	"version": "1.1.8",
+	"description": "🌈 Light, fast, and easy to use, dependencies free javascript syntax highlighter, with automatic language detection",
+	"main": "dist/node/index.js",
+	"exports": {
+		"./terminal": "./dist/node/terminal.js",
+		"./terminal.js": "./dist/node/terminal.js"
+	},
+	"directories": {
+		"example": "examples"
+	},
+	"scripts": {
+		"build": "./.github/workflows/minify.sh"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git://github.com/speed-highlight/core.git"
+	},
+	"keywords": [
+		"javascript",
+		"syntax-highlighting",
+		"language",
+		"fast",
+		"js",
+		"simple",
+		"highlighter",
+		"regex",
+		"highlighting",
+		"highlightjs",
+		"small",
+		"deno"
+	],
+	"author": "matubu",
+	"license": "CC0-1.0",
+	"bugs": {
+		"url": "https://github.com/speed-highlight/core/issues"
+	},
+	"homepage": "https://github.com/speed-highlight/core#readme",
+	"publishConfig": {
+		"registry": "https://npm.pkg.github.com/",
+		"access": "public"
+	}
 }

package/src/color.js

@@ -0,0 +1,11 @@
+export default {
+	black: '\x1b[30m',
+	red: '\x1b[31m',
+	green: '\x1b[32m',
+	gray: '\x1b[90m',
+	yellow: '\x1b[33m',
+	blue: '\x1b[34m',
+	magenta: '\x1b[35m',
+	cyan: '\x1b[36m',
+	white: '\x1b[37m'
+}

package/src/detect.js

@@ -1,3 +1,13 @@
+/**
+ * @module detect
+ * (Language detector)
+*/
+
+import '../typedef.js'
+
+/**
+ * @type {Array.<[ShjLanguage, ...[RegExp, Number][]]>}
+ */
 const languages = [
 	['bash', [/#!(\/usr)?\/bin\/bash/g, 500], [/\b(if|elif|then|fi|echo)\b|\$/g, 10]],
 	['html', [/<\/?[a-z-]+[^\n>]*>/g, 10], [/^\s+<!DOCTYPE\s+html/g, 500]],
@@ -22,12 +32,18 @@ const languages = [
 	['asm', [/^(section|global main|extern|\t(call|mov|ret))/gm, 100]],
 ]
 
+/**
+ * @function detectLanguage
+ * Try to find the language the given code belong to
+ * @param {String} code The code
+ * @returns {ShjLanguage} The language of the code
+ */
 export const detectLanguage = code => {
 	return (languages
 		.map(([lang, ...features]) => [
-			features.reduce((acc, [match, score]) => acc + [...code.matchAll(match)].length * score, 0),
-			lang
+			lang,
+			features.reduce((acc, [match, score]) => acc + [...code.matchAll(match)].length * score, 0)
 		])
-		.filter(([score, lang]) => score > 10)
-		.sort((a, b) => b[0] - a[0])[0]?.[1] || 'plain');
-}
+		.filter(([lang, score]) => score > 20)
+		.sort((a, b) => b[1] - a[1])[0]?.[0] || 'plain');
+}

package/src/index.js

@@ -1,28 +1,34 @@
 /**
- * Base script
+ * @module index
+ * (Base script)
 */
 
+import '../typedef.js'
+
 import expandData from './common.js';
 
 const langs = {},
 	sanitize = (str = '') =>
 		str.replaceAll('&', '&#38;').replaceAll?.('<', '&lt;').replaceAll?.('>', '&gt;'),
 	/**
-	 * A function that turn text in HTML to apply a class to it
-	 * @param {String} str need to be sanitize to be safe
-	 * @param {String} [token] token type
-	 * @returns A string with HTML semantics
+	 * @function
+	 * @ignore
+	 * Create a HTML element with the right token styling
+	 * @param {String} str The content (need to be sanitized)
+	 * @param {ShjToken} [token] The type of token
+	 * @returns A HMTL string
 	 */
 	toSpan = (str, token) => token ? `<span class="shj-syn-${token}">${str}</span>` : str;
 
 /**
- * A
- * @param {String} src
- * @param {String|Object} lang
- * @param {Function} token the callback that will be call for every token found.
- * the arguments pass will be:
- * * the token as a string (can be an empty string)
- * * the token type also as a string like 'err', 'cmnt', ...
+ * @function tokenize
+ * Find the tokens in the given code and call the callback
+ * @param {String} src The code
+ * @param {ShjLanguage|Array} lang The language of the code
+ * @param {function(String, ShjToken=):void} token The callback function
+ * this function will be given
+ * * the text of the token
+ * * the type of the token
  */
 export async function tokenize(src, lang, token) {
 	try {
@@ -79,20 +85,16 @@ export async function tokenize(src, lang, token) {
 }
 
 /**
- * @typedef {Object} HighlightOptions
- * @property {boolean} [hideLineNumbers=false] - Indicates whether to hide line numbers.
- */
-
-/**
+ * @function highlightText
  * @async
- * @function highlightText A function that highlight a string text and return it
+ * Highlight a string passed as argument and return it
  * @example
  * elm.innerHTML = await highlightText(code, 'js');
- * @param {String} src the text content to be highlighted
- * @param {String} lang the lang name ex: 'js'
- * @param {Boolean} [multiline=true] inline mode
- * @param {HighlightOptions} [opt={}] other options
- * @returns {String} the highlighted as String text
+ * @param {String} src The code
+ * @param {ShjLanguage} lang The language of the code
+ * @param {Boolean} [multiline=true] If it is multiline, it will add a wrapper for the line numbering and header
+ * @param {ShjOptions} [opt={}] Customization options
+ * @returns {Promise<String>} The highlighted string
  */
 export async function highlightText(src, lang, multiline = true, opt = {}) {
 	let tmp = ''
@@ -104,12 +106,13 @@ export async function highlightText(src, lang, multiline = true, opt = {}) {
 }
 
 /**
+ * @function highlightElement
  * @async
- * @function highlightElement highlight a element code with a 'pre' parent
- * @param {HTMLElement} elm the code elm
- * @param {String} [lang] the lang used for syntax highlighting by default is found in the className of the parent or the elm it self
- * @param {String} [mode] can be set to inline multiline or oneline by default it's auto detected: inline if `code` tag else depends of the number of lines
- * @param {HighlightOptions} [opt={}] other options
+ * Highlight a DOM element by getting the new innerHTML with highlightText
+ * @param {Element} elm The DOM element
+ * @param {ShjLanguage} [lang] The language of the code (seaching by default on `elm` for a 'shj-lang-' class)
+ * @param {ShjDisplayMode} [mode] The display mode (guessed by default)
+ * @param {ShjOptions} [opt={}] Customization options
  */
 export async function highlightElement(elm, lang = elm.className.match(/shj-lang-([\w-]+)/)?.[1], mode, opt) {
 	let txt = elm.textContent;
@@ -120,19 +123,22 @@ export async function highlightElement(elm, lang = elm.className.match(/shj-lang
 }
 
 /**
- * @async
  * @function highlightAll
- * for all element that have a class name starting with "shj-lang-"
- * this function will call highlightElement with the html element as argument
- * The function will select those scheme for example:
- * ```html
- * <div class='shj-lang-[code-language]'>[code]</div>
- * or
- * <code class='shj-lang-[code-language]'>[inline code]</code>
- * ```
- * @param {HighlightOptions} [opt={}] other options
+ * @async
+ * Call highlightElement on element with a css class starting with `shj-lang-`
+ * @param {ShjOptions} [opt={}] Customization options
  */
 export let highlightAll = async (opt) =>
 	document
 		.querySelectorAll('[class*="shj-lang-"]')
 		.forEach(elm => highlightElement(elm, undefined, undefined, opt))
+
+/**
+ * @function loadLanguage
+ * Load a language and add it to the langs object
+ * @param {String} languageName The name of the language
+ * @param {ShjLanguage} language The language
+ */
+export let loadLanguage = (languageName, language) => {
+	langs[languageName] = language;
+}

package/src/languages/c.js

@@ -47,6 +47,6 @@ export default [
 	},
 	{
 		type: 'class',
-		match: /[A-Z][\w_]*/g
+		match: /\b[A-Z][\w_]*\b/g
 	}
 ]

package/src/languages/go.js

@@ -19,7 +19,7 @@ export default [
 	},
 	{
 		type: 'class',
-		match: /[A-Z][\w_]*/g
+		match: /\b[A-Z][\w_]*\b/g
 	},
 	{
 		type: 'oper',

package/src/languages/java.js

@@ -23,6 +23,6 @@ export default [
 	},
 	{
 		type: 'class',
-		match: /[A-Z][\w_]*/g
+		match: /\b[A-Z][\w_]*\b/g
 	}
 ]

package/src/languages/js.js

@@ -39,7 +39,7 @@ export default [
 	},
 	{
 		type: 'class',
-		match: /\b[A-Z]\w*\b/g
+		match: /\b[A-Z][\w_]*\b/g
 	},
 	{
 		type: 'func',

package/src/languages/py.js

@@ -47,6 +47,6 @@ export default [
 	},
 	{
 		type: 'class',
-		match: /\b[A-Z]\w*\b/g
+		match: /\b[A-Z][\w_]*\b/g
 	}
 ]

package/src/languages/rs.js

@@ -19,7 +19,7 @@ export default [
 	},
 	{
 		type: 'class',
-		match: /\b[A-Z]\w*\b/g
+		match: /\b[A-Z][\w_]*\b/g
 	},
 	{
 		type: 'func',

package/src/terminal.js

@@ -0,0 +1,42 @@
+/**
+ * @module terminal
+ * (Terminal adaptor)
+*/
+
+import '../typedef.js'
+
+import { tokenize } from './index.js';
+
+let theme = import('./themes/default.js');
+
+/**
+ * @function highlightText
+ * @async
+ * Highlight a string passed as argument and return a string that can directly be printed
+ * @param {String} src The code
+ * @param {ShjLanguage} lang The language of the code
+ * @returns {Promise<String>} The highlighted string
+ */
+export const highlightText = async (src, lang) => {
+	let res = '', themeMap = (await theme).default;
+
+	await tokenize(src, lang, (str, token) => res += token ? `${themeMap[token] ?? ''}${str}\x1b[0m` : str);
+
+	return res;
+};
+
+/**
+ * @function printHighlight
+ * @async
+ * Highlight and print a given string
+ * @param {String} src The code
+ * @param {ShjLanguage} lang The language of the code
+ */
+export const printHighlight = async (src, lang) => console.log(await highlightText(src, lang));
+
+/**
+ * @function setTheme
+ * Change the current used theme for highlighting
+ * @param {ShjTerminalTheme} name The name of the theme
+ */
+export const setTheme = async name => theme = import(`./themes/${name}.js`);

package/src/themes/atom-dark.js

@@ -0,0 +1,18 @@
+import col from '../color.js'
+
+export default {
+	deleted: col.red,
+	var: col.red,
+	err: col.red,
+	kwd: col.magenta,
+	num: col.yellow,
+	class: col.yellow,
+	cmnt: col.gray,
+	insert: col.green,
+	str: col.green,
+	bool: col.cyan,
+	type: col.blue,
+	oper: col.blue,
+	section: col.magenta,
+	func: col.blue
+}