@podlite/to-jsx/lib/shiki.js

Render Podlite markup as React JSX components

"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
    var ownKeys = function(o) {
        ownKeys = Object.getOwnPropertyNames || function (o) {
            var ar = [];
            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
            return ar;
        };
        return ownKeys(o);
    };
    return function (mod) {
        if (mod && mod.__esModule) return mod;
        var result = {};
        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
        __setModuleDefault(result, mod);
        return result;
    };
})();
Object.defineProperty(exports, "__esModule", { value: true });
exports.isLanguageLoaded = void 0;
exports.normalizeLanguage = normalizeLanguage;
exports.getHighlighter = getHighlighter;
exports.codeToHtml = codeToHtml;
exports.codeToThemedHtml = codeToThemedHtml;
const loadShiki = () => Promise.resolve().then(() => __importStar(require('shiki')));
// Configuration
const CONFIG = {
    themes: {
        light: 'one-light',
        dark: 'github-dark',
    },
    initialLanguages: ['shell', 'txt'],
};
// Language aliases mapping
const languageAliases = {
    text: 'txt',
    plaintext: 'txt',
    plain: 'txt',
    sh: 'shell',
    bash: 'shell',
    zsh: 'shell',
    shellscript: 'shell',
    'shell-script': 'shell',
    console: 'shell',
    terminal: 'shell',
    js: 'javascript',
    node: 'javascript',
    nodejs: 'javascript',
    ts: 'typescript',
    py: 'python',
    python3: 'python',
    py3: 'python',
    rb: 'ruby',
    md: 'markdown',
    cpp: 'c++',
    cc: 'c++',
    cs: 'c#',
    csharp: 'c#',
    htm: 'html',
    yml: 'yaml',
    dockerfile: 'docker',
    styles: 'css',
    style: 'css',
    jsonc: 'json',
    json5: 'json',
    xaml: 'xml',
    xhtml: 'xml',
    svg: 'xml',
    mysql: 'sql',
    postgresql: 'sql',
    postgres: 'sql',
    pgsql: 'sql',
    plsql: 'sql',
    oracle: 'sql',
};
// Singleton state
const state = {
    instance: null,
    initPromise: null,
    loadedLanguages: new Set(['txt']),
    pendingLoads: new Map(),
    warnedLanguages: new Set(),
};
// Normalize language to valid Shiki language
async function normalizeLanguage(language) {
    if (!language)
        return 'txt';
    const normalized = language.toLowerCase();
    const { bundledLanguages } = await loadShiki();
    if (normalized in bundledLanguages) {
        return normalized;
    }
    if (normalized in languageAliases) {
        return languageAliases[normalized];
    }
    if (!state.warnedLanguages.has(language)) {
        console.warn(`[podlite] shiki unrecognized language '${language}', defaulting to [txt]`);
        state.warnedLanguages.add(language);
    }
    return 'txt';
}
// Get or create highlighter instance
async function getHighlighterInstance() {
    if (!state.initPromise) {
        state.initPromise = (async () => {
            const { createHighlighter } = await loadShiki();
            const instance = await createHighlighter({
                themes: Object.values(CONFIG.themes),
                langs: CONFIG.initialLanguages,
            });
            state.instance = instance;
            CONFIG.initialLanguages.forEach(lang => state.loadedLanguages.add(lang));
            return instance;
        })();
    }
    return state.initPromise;
}
// Load a language if not already loaded
async function ensureLanguageLoaded(instance, lang) {
    if (state.loadedLanguages.has(lang))
        return;
    let pending = state.pendingLoads.get(lang);
    if (!pending) {
        pending = instance
            .loadLanguage(lang)
            .then(() => {
            state.loadedLanguages.add(lang);
        })
            .finally(() => state.pendingLoads.delete(lang));
        state.pendingLoads.set(lang, pending);
    }
    await pending;
}
// Main API: get highlighter with language loaded
async function getHighlighter(language) {
    const lang = await normalizeLanguage(language);
    const instance = await getHighlighterInstance();
    await ensureLanguageLoaded(instance, lang);
    return instance;
}
// Convenience: convert code to HTML with dual themes (CSS-based switching)
async function codeToHtml({ code, language }) {
    const lang = await normalizeLanguage(language);
    const highlighter = await getHighlighter(language);
    return highlighter.codeToHtml(code, {
        lang,
        themes: CONFIG.themes,
    });
}
// Convert code to HTML with explicit theme selection (for runtime theme detection)
async function codeToThemedHtml({ code, language, theme, decorations, }) {
    const lang = await normalizeLanguage(language);
    const highlighter = await getHighlighter(language);
    if (theme === 'light' || theme === 'dark') {
        return highlighter.codeToHtml(code, {
            lang,
            theme: CONFIG.themes[theme],
            decorations,
        });
    }
    return highlighter.codeToHtml(code, {
        lang,
        themes: CONFIG.themes,
        decorations,
    });
}
// Check if a language is loaded (sync — only meaningful after a prior async normalize)
const isLanguageLoaded = (language) => {
    return state.loadedLanguages.has(language);
};
exports.isLanguageLoaded = isLanguageLoaded;
//# sourceMappingURL=shiki.js.map