Language System

/**
 * Object containing all loaded language grammars
 * @type {Object<string, Grammar>}
 */
Prism.languages;

// Access loaded languages
console.log(Object.keys(Prism.languages));
// Output: ['markup', 'css', 'clike', 'javascript', ...]

// Check if language is loaded
if (Prism.languages.python) {
    console.log('Python syntax highlighting available');
}

// Get grammar for highlighting
const jsGrammar = Prism.languages.javascript;
const highlighted = Prism.highlight('const x = 1;', jsGrammar, 'javascript');

/**
 * HTML/XML markup language grammar
 * @type {Grammar}
 */
Prism.languages.markup;

/**
 * CSS language grammar
 * @type {Grammar}
 */
Prism.languages.css;

/**
 * C-like language base grammar
 * @type {Grammar}
 */
Prism.languages.clike;

/**
 * JavaScript language grammar
 * @type {Grammar}
 */
Prism.languages.javascript;

// Common aliases are automatically set up
Prism.languages.html === Prism.languages.markup; // true
Prism.languages.xml === Prism.languages.markup;  // true
Prism.languages.svg === Prism.languages.markup;  // true
Prism.languages.js === Prism.languages.javascript; // true

/**
 * Create new language by extending existing grammar
 * @param {string} id - Existing language ID to extend from
 * @param {object} redef - New grammar rules to add or override
 * @returns {object} New language grammar object
 */
Prism.languages.extend(id, redef);

// Extend JavaScript for JSX
Prism.languages.jsx = Prism.languages.extend('javascript', {
    'tag': {
        pattern: /<\/?(?:[\w.:-]+(?:\s+(?:[\w.:-]+(?:=(?:"[^"]*"|'[^']*'|[^\s'">=]+))?)\s*)*\/?)?>|</,
        inside: {
            'tag-name': /^<\/?[\w.:-]+/,
            'attr-name': /[\w.:-]+(?=\s*=)/,
            'attr-value': /=(?:"[^"]*"|'[^']*'|[^\s'">=]+)/,
            'punctuation': /[=<>\/]/
        }
    }
});

// Extend CSS for SCSS
Prism.languages.scss = Prism.languages.extend('css', {
    'variable': /\$[\w-]+/,
    'at-rule': {
        pattern: /@[\w-]+(?:\([^)]*\))?(?=\s*{)/,
        inside: {
            'punctuation': /[()]/
        }
    }
});

// Create TypeScript by extending JavaScript  
Prism.languages.typescript = Prism.languages.extend('javascript', {
    'keyword': [
        /\b(?:abstract|as|asserts|async|await|break|case|catch|class|const|continue|debugger|declare|default|delete|do|else|enum|export|extends|finally|for|from|function|get|if|implements|import|in|instanceof|interface|is|keyof|let|module|namespace|new|null|of|package|private|protected|public|readonly|return|require|set|static|super|switch|this|throw|try|type|typeof|undefined|var|void|while|with|yield)\b/
    ],
    'type-annotation': {
        pattern: /:\s*[a-zA-Z_][\w<>[\],.]*/, 
        inside: {
            'punctuation': /:/
        }
    }
});

/**
 * Insert new grammar rules before existing rule
 * @param {string} inside - Target language ID to modify
 * @param {string} before - Existing rule name to insert before
 * @param {object} insert - New rules to insert
 * @param {object} [root] - Root grammar object (defaults to Prism.languages)
 */
Prism.languages.insertBefore(inside, before, insert, root);

// Add template literals to JavaScript before strings
Prism.languages.insertBefore('javascript', 'string', {
    'template-string': {
        pattern: /`(?:\\[\s\S]|\${(?:[^{}]|{(?:[^{}]|{[^}]*})*})+}|(?!\${)[^\\`])*`/,
        greedy: true,
        inside: {
            'template-interpolation': {
                pattern: /\${(?:[^{}]|{(?:[^{}]|{[^}]*})*})+}/,
                inside: {
                    'interpolation-punctuation': {
                        pattern: /^\${|}$/,
                        alias: 'punctuation'
                    },
                    rest: Prism.languages.javascript
                }
            },
            'string': /[\s\S]+/
        }
    }
});

// Add JSDoc comments before regular comments
Prism.languages.insertBefore('javascript', 'comment', {
    'jsdoc': {
        pattern: /\/\*\*[\s\S]*?\*\//,
        inside: {
            'tag': /@\w+/,
            'parameter': /\{[^}]+\}/
        }
    }
});

// Modify existing language in place
Prism.languages.insertBefore('css', 'property', {
    'custom-property': {
        pattern: /--[\w-]+/,
        alias: 'variable'
    }
});

/**
 * Perform depth-first search on grammar object
 * @param {object} o - Grammar object to traverse
 * @param {function} callback - Function called for each node
 * @param {string|function} [type] - Type filter or type function
 * @param {WeakMap} [visited] - Visited objects map for circular reference handling
 */
Prism.languages.DFS(o, callback, type, visited);

// Find all string patterns in a grammar
const stringPatterns = [];
Prism.languages.DFS(Prism.languages.javascript, function(key, value) {
    if (key === 'pattern' && value instanceof RegExp) {
        stringPatterns.push(value);
    }
});

// Modify all regex patterns to be case insensitive
Prism.languages.DFS(Prism.languages.css, function(key, value, type) {
    if (key === 'pattern' && value instanceof RegExp && !value.ignoreCase) {
        return new RegExp(value.source, value.flags + 'i');
    }
});

// Count different token types in a grammar
const tokenCounts = {};
Prism.languages.DFS(Prism.languages.python, function(key, value, type) {
    if (typeof key === 'string' && typeof value === 'object' && value.pattern) {
        tokenCounts[key] = (tokenCounts[key] || 0) + 1;
    }
});

/**
 * Load language components dynamically (Node.js only)
 * @param {string|string[]} [languages] - Language IDs to load, or all if undefined
 */
const loadLanguages = require('prismjs/components/');
loadLanguages(languages);

/**
 * Suppress warning messages during loading
 * @type {boolean}
 */
loadLanguages.silent;

const loadLanguages = require('prismjs/components/');

// Load specific languages
loadLanguages(['css', 'markup']);

// Load all available languages
loadLanguages();

// Load with dependencies automatically resolved
loadLanguages(['jsx']); // Automatically loads javascript first

// Suppress warnings for missing languages
loadLanguages.silent = true;
loadLanguages(['nonexistent-language']); // Won't log warning

// Check what languages are available
const components = require('prismjs/components.js');
console.log(Object.keys(components.languages));

// Popular programming languages
Prism.languages.javascript  // JavaScript/ECMAScript
Prism.languages.typescript  // TypeScript
Prism.languages.python      // Python  
Prism.languages.java        // Java
Prism.languages.csharp      // C#
Prism.languages.cpp         // C++
Prism.languages.c           // C
Prism.languages.php         // PHP
Prism.languages.ruby        // Ruby
Prism.languages.go          // Go
Prism.languages.rust        // Rust
Prism.languages.swift       // Swift
Prism.languages.kotlin      // Kotlin
Prism.languages.scala       // Scala

// Web markup and styling
Prism.languages.html        // HTML (alias for markup)
Prism.languages.css         // CSS
Prism.languages.scss        // Sass/SCSS
Prism.languages.less        // Less CSS
Prism.languages.stylus      // Stylus
Prism.languages.xml         // XML
Prism.languages.svg         // SVG

// Configuration and data formats
Prism.languages.json        // JSON
Prism.languages.yaml        // YAML
Prism.languages.toml        // TOML
Prism.languages.ini         // INI files
Prism.languages.properties  // Properties files
Prism.languages.csv         // CSV

// Database and query languages
Prism.languages.sql         // SQL
Prism.languages.mongodb     // MongoDB queries
Prism.languages.graphql     // GraphQL
Prism.languages.sparql      // SPARQL

// Shell and system languages
Prism.languages.bash        // Bash shell
Prism.languages.powershell  // PowerShell
Prism.languages.batch       // Windows Batch
Prism.languages.dockerfile  // Docker files
Prism.languages.nginx       // Nginx config

// Dependencies are handled automatically
loadLanguages(['jsx']);        // Loads javascript first
loadLanguages(['typescript']); // Loads javascript first  
loadLanguages(['scss']);       // Loads css first
loadLanguages(['php']);        // Loads markup first for embedded HTML

// Define a custom language
Prism.languages.mylang = {
    'comment': /\/\/.*$/m,
    'string': /"(?:[^"\\]|\\.)*"/,
    'number': /\b\d+\.?\d*\b/,
    'keyword': /\b(?:if|else|while|function|return)\b/,
    'operator': /[+\-*\/=<>!]/,
    'punctuation': /[{}();,]/
};

// Use the custom language
const code = 'function hello() { return "world"; }';
const highlighted = Prism.highlight(code, Prism.languages.mylang, 'mylang');

/**
 * Grammar object structure
 * @typedef {Object} Grammar
 * @property {RegExp|Object} [tokenName] - Token definition with pattern and options
 */

// Example grammar structure
const exampleGrammar = {
    'comment': {
        pattern: /\/\*[\s\S]*?\*\/|\/\/.*$/m,
        greedy: true
    },
    'string': {
        pattern: /"(?:[^"\\]|\\.)*"/,
        greedy: true
    },
    'keyword': /\b(?:if|else|function|return)\b/,
    'number': /\b\d+\.?\d*\b/,
    'operator': /[=+\-*\/]/,
    'punctuation': /[{}();,]/
};

// Safe language access
function getLanguage(langId) {
    if (Prism.languages[langId]) {
        return Prism.languages[langId];
    } else {
        console.warn(`Language '${langId}' not found`);
        return Prism.languages.plain || {};
    }
}

// Language loading error handling
try {
    loadLanguages(['python']);
    console.log('Python loaded successfully');
} catch (error) {
    console.error('Failed to load Python:', error);
}