markshell 1.7.0 → 1.8.0

package/bin/markshell.js

@@ -36,6 +36,51 @@ if (args.length === 0 || args.indexOf('--help') !== -1) {
     printHelp();
 }
 
+// Handle --example flag to run interactive demos
+const exampleIdx = args.indexOf('--example');
+if (exampleIdx !== -1) {
+    const path = require('path');
+    const exampleName = args[exampleIdx + 1];
+
+    const examples = {
+        'dynamic-loading': path.join(__dirname, '../examples/dynamic-loading-demo.js'),
+        'syntax-colors': path.join(__dirname, '../examples/syntax-colors-demo.js'),
+        'demo': path.join(__dirname, '../DEMO.md')
+    };
+
+    if (!exampleName || !examples[exampleName]) {
+        console.log(`Markshell - Version ${pkg.version}
+
+${chalk.yellow.bold('Available examples:')}
+
+  ${chalk.cyan('markshell --example dynamic-loading')}
+    Interactive demo showing dynamic language loading with statistics
+
+  ${chalk.cyan('markshell --example syntax-colors')}
+    Visual demonstration of syntax highlighting colors
+
+  ${chalk.cyan('markshell --example demo')}
+    Comprehensive demo showcasing all markdown features and 25+ languages
+`);
+        process.exit(0);
+    }
+
+    const examplePath = examples[exampleName];
+
+    if (exampleName === 'demo') {
+        // Render the DEMO.md file
+        try {
+            markshell.toConsole(examplePath);
+        } catch (e) {
+            printError(e);
+        }
+    } else {
+        // Execute the example script
+        require(examplePath);
+    }
+    process.exit(0);
+}
+
 const theme = args.indexOf('--theme');
 
 if (theme !== 1) {

package/docs/usage.md

@@ -1,16 +1,34 @@
 # Usage
 
 ```bash
-   markshell [filenpath | -f [filepath] | --filepath [filepath]]
+   markshell [filepath | -f [filepath] | --filepath [filepath]]
+   markshell --example [example-name]
+   markshell --help
 ```
 
-**filepath or -f **
+## Options
+
+**filepath or -f**
 : path to markdown file
+
+**--example [name]**
+: run interactive examples and demos
+  - `dynamic-loading` - Shows dynamic language loading with statistics
+  - `syntax-colors` - Visual demonstration of syntax highlighting colors
+  - `demo` - Comprehensive showcase of all markdown features
+
 **--help**
-: what you see now
+: display usage information
 
 ## Examples
 
 ```sh
+   # Render a markdown file
+   markshell ./my/markdownfile.md
    markshell --filepath './my/markdownfile.md'
-```
+
+   # Run interactive examples
+   markshell --example dynamic-loading
+   markshell --example syntax-colors
+   markshell --example demo
+```

package/lib/index.js

@@ -230,6 +230,9 @@ const _codeBlock = (content) => {
  * Formats source code blocks using PrismJS
  * @param {string} content of MarkDown file
  */
+// Module-level storage for code block placeholders
+let _codeBlockPlaceholders = [];
+
 const _highlightedCodeBlock = (content) => {
 
     let codeRegex = new RegExp(/(\`\`\`)(.*?)(\`\`\`)/igs);
@@ -239,6 +242,10 @@ const _highlightedCodeBlock = (content) => {
         return content;
     }
 
+    // Reset and store highlighted code blocks with placeholders to protect from inline code processing
+    _codeBlockPlaceholders = [];
+    let placeholderIndex = 0;
+
     newContent.forEach((element) => {
 
         let langRegex = new RegExp(/(\`\`\`)(.*?)(\r?\n)/igs);
@@ -259,7 +266,12 @@ const _highlightedCodeBlock = (content) => {
                 let hlSource = syntaxHighlighter.highlight(source, lang, this._theme.sourceCodeTheme);
                 this._theme.sourceCodeTheme;
 
-                content = content.replace(element, hlSource)
+                // Use a placeholder that won't be matched by inline code regex
+                const placeholder = `__CODEBLOCK_${placeholderIndex}__`;
+                _codeBlockPlaceholders.push({ placeholder, code: hlSource });
+                placeholderIndex++;
+
+                content = content.replace(element, placeholder)
 
             } catch (e) {
 
@@ -275,6 +287,14 @@ const _highlightedCodeBlock = (content) => {
 
 }
 
+const _restoreCodeBlocks = (content) => {
+    // Restore code blocks from placeholders
+    _codeBlockPlaceholders.forEach(({ placeholder, code }) => {
+        content = content.replace(placeholder, code);
+    });
+    return content;
+}
+
 /**
  * Formats Blockquote
  * @param {string} content of markdown file
@@ -457,13 +477,23 @@ const _addBold = (content) => {
 
 /**
  * Formats italic elements in MarkDown
+ * Supports both underscore (_text_) and asterisk (*text*) emphasis markers
  * @param {string} content of markdown file
  */
 const _addItalic = (content) => {
 
-    let regExp = new RegExp(/(?<!\w)_([^_\n]+?)_(?!\w)/g);
+    // First pass: Handle underscore emphasis
+    // Pattern: _text_ where underscores are not adjacent to word characters
+    let underscoreRegex = new RegExp(/(?<!\w)_([^_\n]+?)_(?!\w)/g);
+    content = _highlightText(content, underscoreRegex, this._theme.italic);
 
-    return _highlightText(content, regExp, this._theme.italic);
+    // Second pass: Handle asterisk emphasis (but not bold **)
+    // Pattern: *text* where asterisks are not adjacent to other asterisks (to avoid matching **bold**)
+    // Also not adjacent to word characters on the outside to avoid matching mid-word asterisks
+    let asteriskRegex = new RegExp(/(?<!\*)(?<!\w)\*([^*\n]+?)\*(?!\*)(?!\w)/g);
+    content = _highlightText(content, asteriskRegex, this._theme.italic);
+
+    return content;
 
 }
 
@@ -493,8 +523,10 @@ const _addCode = (content) => {
  */
 const _addInlineCode = (content) => {
 
-    // return _highlightText(content, /\`/ig, this._theme.inlineCode);
-    return _highlightText(content, /`([^`]*)`/g, this._theme.inlineCode);
+    // Use negative lookbehind/lookahead to avoid matching backticks that are part of triple-backtick code blocks
+    // (?<!`) = not preceded by backtick, (?!`) = not followed by backtick
+    // This ensures we only match single backticks for inline code, not triple backticks for code blocks
+    return _highlightText(content, /(?<!`)`([^`]+)`(?!`)/g, this._theme.inlineCode);
 
 }
 
@@ -682,17 +714,26 @@ const _toRawContent = (filepath) => {
 
 
     try {
-        // console.log('Inline code')
+        // Process code blocks FIRST - replaces them with placeholders
+        // This prevents inline code regex from matching backticks inside code blocks
+        content = _highlightedCodeBlock(content);
+    } catch (e) {
+        throw `Error in Highlighted Code: ${e}`;
+    }
+
+    try {
+        // Process inline code AFTER code blocks are replaced with placeholders
+        // At this point, code blocks are hidden as __CODEBLOCK_N__ so inline code won't match them
         content = _addInlineCode(content);
     } catch (e) {
         throw `Error in addInlineCode: ${e}`;
     }
 
     try {
-        // console.log('Highlight code block');
-        content = _highlightedCodeBlock(content);
+        // Restore code blocks from placeholders
+        content = _restoreCodeBlocks(content);
     } catch (e) {
-        throw `Error in Highlighted Code: ${e}`;
+        throw `Error in restoring code blocks: ${e}`;
     }
 
     try {

package/lib/syntaxhighlighter/index.d.ts

@@ -1,5 +1,14 @@
 export var theme: any;
 export var themeTokenKeys: string[];
+
+/**
+ * Information about loaded languages
+ */
+export interface LoadedLanguagesInfo {
+    count: number;
+    languages: string[];
+}
+
 /**
  *
  * @param {string} source
@@ -7,6 +16,20 @@ export var themeTokenKeys: string[];
  * @param {sourceTheme} outTheme
  */
 declare function _highlight(source: string, language: string, outTheme: sourceTheme): string;
+
+/**
+ * Resolves language aliases to canonical names
+ * @param language - Language identifier (may be an alias)
+ * @returns Canonical language name or null
+ */
+declare function _resolveLanguageAlias(language: string): string | null;
+
+/**
+ * Get information about currently loaded languages
+ * @returns Statistics about loaded languages
+ */
+declare function _getLoadedLanguagesInfo(): LoadedLanguagesInfo;
+
 type sourceTheme = string;
 declare namespace sourceTheme {
     const COY: string;
@@ -18,4 +41,11 @@ declare namespace sourceTheme {
     const TOMORROW: string;
     const TWILIGHT: string;
 }
-export { _highlight as highlight, sourceTheme as themes, sourceTheme as availableThemes };
+
+export {
+    _highlight as highlight,
+    sourceTheme as themes,
+    sourceTheme as availableThemes,
+    _getLoadedLanguagesInfo as getLoadedLanguagesInfo,
+    _resolveLanguageAlias as resolveLanguageAlias
+};

package/lib/syntaxhighlighter/index.js

@@ -17,7 +17,75 @@ const prismjs = require('prismjs/prism');
 // load all supported languages
 // @ts-ignore
 const loadLanguages = require('prismjs/components/');
-loadLanguages();
+// Languages will be loaded on-demand for better performance
+
+/**
+ * Cache of loaded languages to avoid redundant loading
+ * @type {Set<string>}
+ */
+const loadedLanguagesCache = new Set();
+
+/**
+ * Comprehensive language alias mapping based on PrismJS components
+ * Maps common aliases to their canonical language names
+ * @type {Object<string, string>}
+ */
+const languageAliases = {
+    // JavaScript ecosystem
+    'js': 'javascript',
+    'mjs': 'javascript',
+    'cjs': 'javascript',
+    'jsx': 'javascript',
+    'ts': 'typescript',
+    'tsx': 'typescript',
+
+    // Shell/Bash variants
+    'sh': 'bash',
+    'shell': 'bash',
+    'console': 'bash',
+    'command': 'bash',
+    'bash session': 'bash',
+    'zsh': 'bash',
+
+    // Python
+    'py': 'python',
+    'py3': 'python',
+    'python3': 'python',
+
+    // Ruby
+    'rb': 'ruby',
+
+    // Markup languages
+    'html': 'markup',
+    'xml': 'markup',
+    'svg': 'markup',
+    'mathml': 'markup',
+    'ssml': 'markup',
+
+    // C family
+    'c++': 'cpp',
+    'c#': 'csharp',
+    'cs': 'csharp',
+
+    // Other common aliases
+    'yml': 'yaml',
+    'md': 'markdown',
+    'dockerfile': 'docker',
+    'objc': 'objectivec',
+    'hs': 'haskell',
+    'rs': 'rust',
+    'kt': 'kotlin',
+    'proto': 'protobuf',
+    'coffee': 'coffeescript',
+    'gawk': 'awk',
+    'hbs': 'handlebars',
+    'mustache': 'handlebars',
+    'g4': 'antlr4',
+    'ino': 'arduino',
+    'adoc': 'asciidoc',
+    'idr': 'idris',
+    'eta': 'ejs',
+};
 
 /**
  * @readonly
@@ -50,9 +118,9 @@ const getHighlightToken = (tokens) => {
 
     for (let i = 0; i < tokens.length; i++) {
 
-        if (this.themeTokenKeys.indexOf(tokens[i]) !== -1) {
+        if (themeTokenKeys.indexOf(tokens[i]) !== -1) {
 
-            tokenFound = this.theme.token[tokens[i]];
+            tokenFound = theme.token[tokens[i]];
             break;
         }
 
@@ -132,7 +200,7 @@ const _addBackground = (source, originalSource) => {
         }
 
         bgAddedSource.push(
-            this.theme.background(sourceLines[i]) + this.theme.toEOL((" ").repeat(fill2end))
+            theme.background(sourceLines[i]) + theme.toEOL((" ").repeat(fill2end))
         );
 
     }
@@ -142,14 +210,88 @@ const _addBackground = (source, originalSource) => {
 }
 
 /**
- * 
- * @param {string} source 
- * @param {string} language 
- * @param {sourceTheme} outTheme 
+ * Resolves language aliases to canonical names
+ * @param {string} language - Language identifier (may be an alias)
+ * @returns {string|null} - Canonical language name or null if no language provided
+ */
+const resolveLanguageAlias = (language) => {
+    if (!language) return null;
+
+    const normalized = language.toLowerCase().trim();
+    return languageAliases[normalized] || normalized;
+};
+
+/**
+ * Dynamically loads a language component if not already loaded
+ * @param {string} language - Language to load (canonical name or alias)
+ * @returns {boolean} - True if language is available, false otherwise
+ */
+const ensureLanguageLoaded = (language) => {
+    if (!language) return false;
+
+    // Resolve alias to canonical name
+    const canonicalLang = resolveLanguageAlias(language);
+    if (!canonicalLang) return false;
+
+    // Check if already loaded in our cache
+    if (loadedLanguagesCache.has(canonicalLang)) {
+        return true;
+    }
+
+    // Check if language exists in Prism.languages (might be pre-loaded)
+    // @ts-ignore
+    if (Prism.languages[canonicalLang] !== undefined) {
+        loadedLanguagesCache.add(canonicalLang);
+        return true;
+    }
+
+    // Attempt to load the language
+    try {
+        // Suppress PrismJS warnings for this operation
+        const originalSilent = loadLanguages.silent;
+        loadLanguages.silent = true;
+
+        // Load the language (PrismJS handles dependencies automatically)
+        loadLanguages([canonicalLang]);
+
+        // Restore original silent setting
+        loadLanguages.silent = originalSilent;
+
+        // Verify it loaded successfully
+        // @ts-ignore
+        if (Prism.languages[canonicalLang] !== undefined) {
+            loadedLanguagesCache.add(canonicalLang);
+            return true;
+        }
+
+        return false;
+
+    } catch (error) {
+        // Language loading failed
+        return false;
+    }
+};
+
+/**
+ * Get information about loaded languages (for debugging/monitoring)
+ * @returns {{count: number, languages: string[]}} - Statistics about loaded languages
+ */
+const getLoadedLanguagesInfo = () => {
+    return {
+        count: loadedLanguagesCache.size,
+        languages: Array.from(loadedLanguagesCache).sort()
+    };
+};
+
+/**
+ *
+ * @param {string} source
+ * @param {string} language
+ * @param {sourceTheme} outTheme
  */
 const _highlight = (source, language, outTheme) => {
 
-    // Detect if theme value is supported - otherwise just use default Okaida theme
+    // Detect if theme value is supported - otherwise just use default Okaidia theme
     if (outTheme !== undefined) {
 
         let themePath = path.join(__dirname, './themes/', outTheme + '.theme'),
@@ -157,48 +299,51 @@ const _highlight = (source, language, outTheme) => {
 
         if (fs.existsSync(filePath)) {
 
-            this.theme = require(filePath);
-            this.themeTokenKeys = Object.keys(theme.token);
-
+            theme = require(filePath);
+            themeTokenKeys = Object.keys(theme.token);
 
         } else {
 
-            throw `Theme '${outTheme}' do not exists`
+            throw `Theme '${outTheme}' do not exist`
 
         }
 
     }
 
-    // Parse source code and return HTML from PrismJS output
-    // console.log(language, Prism.languages[language]);
-    // @ts-ignore
-    Prism.languages['sh'] = Prism.languages['shell'];
-    // @ts-ignore
-    Prism.languages['console'] = Prism.languages['shell'];
-    // @ts-ignore
-    Prism.languages['command'] = Prism.languages['shell'];
-    // @ts-ignore
-    Prism.languages['bash session'] = Prism.languages['shell'];
+    // If no language specified, render as plain text
+    if (!language) {
+        return _addBackground(source, source);
+    }
 
-    // @ts-ignore
-    if (Prism.languages[language] !== undefined) {
+    // Dynamically load the language if needed
+    const languageLoaded = ensureLanguageLoaded(language);
+
+    if (!languageLoaded) {
+        // Language doesn't exist or failed to load - fallback to plain text
+        // Optionally log a warning (can be configured via environment variable)
+        if (process.env.MARKSHELL_WARN_UNKNOWN_LANG === 'true') {
+            console.warn(`[markshell] Unknown language '${language}' - rendering as plain text`);
+        }
+        return _addBackground(source, source);
+    }
+
+    // Get the canonical language name for highlighting
+    const canonicalLang = resolveLanguageAlias(language);
+
+    // @ts-ignore - Prism is loaded globally
+    if (Prism.languages[canonicalLang] !== undefined) {
         // @ts-ignore
-        const prismCode = prismjs.highlight(source, Prism.languages[language], language);
+        const prismCode = prismjs.highlight(source, Prism.languages[canonicalLang], canonicalLang);
         // load HTML fragment
         const dom = JSDOM.fragment(prismCode);
 
-        // console.log('Original Source:\n', source);
-
         var highlightedSource = parseFormatedContent(dom.childNodes, 0);
 
         return _addBackground(highlightedSource, source);
 
     } else {
-
+        // Shouldn't reach here if ensureLanguageLoaded worked correctly
         return _addBackground(source, source);
-
-        // throw `Language '${language}' couldn't be found`;
-
     }
 
 }
@@ -206,5 +351,7 @@ const _highlight = (source, language, outTheme) => {
 module.exports = {
     highlight: _highlight,
     themes: sourceTheme,
-    availableThemes: sourceTheme
+    availableThemes: sourceTheme,
+    getLoadedLanguagesInfo: getLoadedLanguagesInfo,
+    resolveLanguageAlias: resolveLanguageAlias
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "markshell",
-  "version": "1.7.0",
+  "version": "1.8.0",
   "description": "markshell allows you to output any markdown file formatted and style to the console",
   "keywords": [
     "markdown",