@sveltia/ui 0.62.0 → 0.63.0

package/dist/components/text-editor/shiki/facade.js

@@ -0,0 +1,452 @@
+/**
+ * Thin wrapper around a Shiki highlighter instance.
+ *
+ * Adapted from Lexical’s `FacadeShiki.ts` (MIT licensed). Two things differ from upstream, both to
+ * keep Shiki out of the consumer’s bundle. First, the engine is loaded on demand rather than
+ * imported at module scope, so a page that never shows a code block never pays for it. Second,
+ * grammar and theme metadata comes from `generated.js` rather than `shiki/langs` and
+ * `shiki/themes`, whose lazy `import()` thunks would drag the whole grammar set into a bundle.
+ * @see https://github.com/facebook/lexical/tree/v0.49.0/packages/lexical-code-shiki
+ * @see https://github.com/sveltia/sveltia-cms/issues/587
+ */
+
+import {
+  $isCodeNode as isCodeNode,
+  $createCodeHighlightNode as createCodeHighlightNode,
+} from '@lexical/code-core';
+import {
+  $createLineBreakNode as createLineBreakNode,
+  $createTabNode as createTabNode,
+  $getNodeByKey as getNodeByKey,
+  HISTORY_MERGE_TAG,
+  tokenizeRawText,
+} from 'lexical';
+import { cachePayload, getCachedPayload } from './cache.js';
+import { LANGUAGES, THEMES } from './generated.js';
+import { getCodeHighlighterLoaders } from './loader.js';
+import { getCodeTheme } from './theme.js';
+
+/**
+ * @import { CodeNode } from '@lexical/code-core';
+ * @import { LexicalEditor, LexicalNode, NodeKey } from 'lexical';
+ */
+
+/**
+ * Languages that need no grammar and no engine: the content is shown verbatim. Shiki treats these
+ * as special languages internally; we short-circuit them so that a plain code block — the default
+ * for a new block — costs no network request at all.
+ *
+ * `ansi` is deliberately excluded: Shiki does render it, so it still needs the engine.
+ */
+const PLAIN_LANGUAGES = ['', 'plain', 'plaintext', 'text', 'txt'];
+const DIFF_LANGUAGE_REGEX = /^diff-([\w-]+)/i;
+/**
+ * Loaded engine module, once `loadEngine()` has resolved.
+ * @type {any}
+ */
+let engine = null;
+/**
+ * Highlighter instance built from the loaded engine.
+ * @type {any}
+ */
+let highlighter = null;
+/** Set when the engine could not be fetched, so we stop retrying on every keystroke. */
+let engineUnavailable = false;
+/**
+ * Get the language a `diff-*` language wraps, if any.
+ * @param {string} language Language identifier.
+ * @returns {string | null} Wrapped language, or `null` when this is not a diff language.
+ */
+const getDiffedLanguage = (language) => DIFF_LANGUAGE_REGEX.exec(language)?.[1] ?? null;
+
+/**
+ * Whether the given language is rendered as plain text without any highlighting.
+ * @param {string | null | undefined} language Language identifier.
+ * @returns {boolean} Result.
+ */
+export const isPlainLanguage = (language) => PLAIN_LANGUAGES.includes(language ?? '');
+
+/**
+ * Whether the syntax highlighting engine is loaded and ready to tokenize.
+ * @returns {boolean} Result.
+ */
+export const isEngineLoaded = () => !!highlighter;
+
+/**
+ * Whether the engine failed to load. Code blocks fall back to plain text in that case instead of
+ * waiting forever.
+ * @returns {boolean} Result.
+ */
+export const isEngineUnavailable = () => engineUnavailable;
+
+/**
+ * Whether the grammar for the given language is loaded.
+ * @param {string} language Language identifier, like `scss` or `diff-js`.
+ * @returns {boolean} Result.
+ */
+export const isCodeLanguageLoaded = (language) => {
+  if (!highlighter) {
+    return false;
+  }
+
+  const id = getDiffedLanguage(language) ?? language;
+
+  // Shiki handles a handful of languages without a grammar
+  if (engine.isSpecialLang(id)) {
+    return true;
+  }
+
+  // `getLoadedLanguages()` also returns aliases
+  return highlighter.getLoadedLanguages().includes(id);
+};
+
+/**
+ * Mark a code node dirty so the highlighting transform runs again once an async load has completed.
+ * @param {LexicalEditor} editor Editor instance.
+ * @param {NodeKey} codeNodeKey Key of the code node to refresh.
+ */
+const refreshCodeNode = (editor, codeNodeKey) => {
+  editor.update(
+    () => {
+      const codeNode = getNodeByKey(codeNodeKey);
+
+      if (!isCodeNode(codeNode)) {
+        return;
+      }
+
+      const language = codeNode.getLanguage();
+
+      if (language && isCodeLanguageLoaded(language) && !codeNode.getIsSyntaxHighlightSupported()) {
+        codeNode.setIsSyntaxHighlightSupported(true);
+      }
+
+      codeNode.markDirty();
+    },
+    { tag: HISTORY_MERGE_TAG },
+  );
+};
+
+/**
+ * In-flight loads, keyed by what is being loaded.
+ * @type {Map<string, { promise: Promise<void>, targets: Map<NodeKey, LexicalEditor> }>}
+ */
+const pendingLoads = new Map();
+
+/**
+ * Run an asynchronous load once, however many callers ask for it while it is in flight, and refresh
+ * each waiting code node exactly once when it completes.
+ *
+ * The transform fires on every keystroke, so without this a burst of typing during a load would
+ * start a download per keystroke and then flood the editor with one update each. That storm is
+ * enough to starve the final re-highlight, leaving a block tokenized as of an earlier keystroke.
+ * @param {string} key Cache key identifying the load.
+ * @param {() => Promise<void>} run Work to perform on the first call.
+ * @param {LexicalEditor} [editor] Editor instance to refresh once the load completes.
+ * @param {NodeKey} [codeNodeKey] Key of the code node to refresh.
+ * @returns {Promise<void>} Promise resolving when the load has completed.
+ */
+const loadOnce = (key, run, editor, codeNodeKey) => {
+  let entry = pendingLoads.get(key);
+
+  if (!entry) {
+    /** @type {Map<NodeKey, LexicalEditor>} */
+    const targets = new Map();
+
+    const promise = (async () => {
+      try {
+        await run();
+      } catch {
+        // Leave the block unhighlighted; the transform falls back to plain text
+      }
+
+      pendingLoads.delete(key);
+      targets.forEach((target, nodeKey) => refreshCodeNode(target, nodeKey));
+    })();
+
+    entry = { promise, targets };
+    pendingLoads.set(key, entry);
+  }
+
+  if (editor && codeNodeKey) {
+    entry.targets.set(codeNodeKey, editor);
+  }
+
+  return entry.promise;
+};
+
+/**
+ * Load the syntax highlighting engine, then refresh the given code node.
+ *
+ * Tokenizing is synchronous because it runs inside a Lexical node transform, so the engine has to
+ * be resident before any highlighting can happen. The transform bails out while this is in flight
+ * and is re-run by `refreshCodeNode()`, the same mechanism upstream already uses for grammars.
+ * @param {LexicalEditor} [editor] Editor instance to refresh once the engine is ready.
+ * @param {NodeKey} [codeNodeKey] Key of the code node to refresh.
+ * @returns {Promise<void> | undefined} Promise resolving when the engine is ready, or `undefined`
+ * when it is already loaded or known to be unavailable.
+ */
+export const loadEngine = (editor, codeNodeKey) => {
+  if (highlighter || engineUnavailable) {
+    return undefined;
+  }
+
+  return loadOnce(
+    'engine',
+    async () => {
+      try {
+        engine = await getCodeHighlighterLoaders().loadEngine();
+
+        highlighter = engine.createHighlighterCoreSync({
+          engine: engine.createJavaScriptRegexEngine(),
+          langs: [],
+          themes: [],
+        });
+      } catch {
+        engineUnavailable = true;
+      }
+    },
+    editor,
+    codeNodeKey,
+  );
+};
+
+/**
+ * Get a grammar or theme, from the cache when possible, otherwise through the configured loader.
+ *
+ * Shiki normalizes a registration in place while loading it, so the payload is cached before it is
+ * handed over. Caching is best-effort and never blocks: a write that fails just means the next
+ * session fetches again.
+ * @param {string} kind Payload kind, either `lang` or `theme`.
+ * @param {string} id Language or theme ID.
+ * @param {() => Promise<any>} load Loader to call on a cache miss.
+ * @returns {Promise<any>} Payload, or a falsy value when unavailable.
+ */
+const resolvePayload = async (kind, id, load) => {
+  const cached = await getCachedPayload(kind, id);
+
+  if (cached) {
+    return cached;
+  }
+
+  const module = await load();
+
+  if (!module) {
+    return undefined;
+  }
+
+  const payload = module.default ?? module;
+
+  await cachePayload(kind, id, payload);
+
+  return payload;
+};
+
+/**
+ * Resolve a language alias to its canonical identifier.
+ * @param {string} language Language identifier or alias, like `ts`.
+ * @returns {string} Canonical identifier, like `typescript`. Returns the input unchanged when the
+ * language is unknown.
+ */
+export const normalizeCodeLanguage = (language) =>
+  LANGUAGES.find(({ id, aliases }) => id === language || aliases?.includes(language))?.id ??
+  language;
+
+/**
+ * Load the grammar for the given language, then refresh the given code node.
+ * @param {string} language Language identifier, like `scss` or `diff-js`.
+ * @param {LexicalEditor} [editor] Editor instance to refresh once the grammar is ready.
+ * @param {NodeKey} [codeNodeKey] Key of the code node to refresh.
+ * @returns {Promise<void> | undefined} Promise resolving when the grammar is ready, or `undefined`
+ * when it is already loaded or the language is not supported.
+ */
+export const loadCodeLanguage = (language, editor, codeNodeKey) => {
+  const id = getDiffedLanguage(language) ?? language;
+
+  if (!highlighter || isCodeLanguageLoaded(id)) {
+    return undefined;
+  }
+
+  const info = LANGUAGES.find(({ id: langId, aliases }) => langId === id || aliases?.includes(id));
+
+  if (!info) {
+    return undefined;
+  }
+
+  return loadOnce(
+    `lang/${info.id}`,
+    async () => {
+      const payload = await resolvePayload('lang', info.id, () =>
+        getCodeHighlighterLoaders().loadLanguage(info.id),
+      );
+
+      if (payload) {
+        await highlighter.loadLanguage(payload);
+      }
+    },
+    editor,
+    codeNodeKey,
+  );
+};
+
+/**
+ * Whether the given theme is loaded.
+ * @param {string} theme Theme identifier, like `github-light`.
+ * @returns {boolean} Result.
+ */
+export const isCodeThemeLoaded = (theme) => {
+  if (!highlighter) {
+    return false;
+  }
+
+  return engine.isSpecialTheme(theme) || highlighter.getLoadedThemes().includes(theme);
+};
+
+/**
+ * Load the given theme, then refresh the given code node.
+ * @param {string} theme Theme identifier, like `github-light`.
+ * @param {LexicalEditor} [editor] Editor instance to refresh once the theme is ready.
+ * @param {NodeKey} [codeNodeKey] Key of the code node to refresh.
+ * @returns {Promise<void> | undefined} Promise resolving when the theme is ready, or `undefined`
+ * when it is already loaded or unknown.
+ */
+export const loadCodeTheme = (theme, editor, codeNodeKey) => {
+  if (!highlighter || isCodeThemeLoaded(theme)) {
+    return undefined;
+  }
+
+  if (!THEMES.some(({ id }) => id === theme)) {
+    return undefined;
+  }
+
+  return loadOnce(
+    `theme/${theme}`,
+    async () => {
+      const payload = await resolvePayload('theme', theme, () =>
+        getCodeHighlighterLoaders().loadTheme(theme),
+      );
+
+      if (payload) {
+        await highlighter.loadTheme(payload);
+      }
+    },
+    editor,
+    codeNodeKey,
+  );
+};
+
+/**
+ * Convert Shiki tokens to Lexical nodes.
+ * @param {any[][]} tokens Tokens, one array per line.
+ * @param {boolean} diff Whether the language is a `diff-*` language.
+ * @returns {LexicalNode[]} Lexical nodes.
+ */
+const mapTokensToLexicalStructure = (tokens, diff) => {
+  /** @type {LexicalNode[]} */
+  const nodes = [];
+
+  tokens.forEach((line, lineIndex) => {
+    if (lineIndex) {
+      nodes.push(createLineBreakNode());
+    }
+
+    line.forEach((token, tokenIndex) => {
+      let { content: text } = token;
+
+      // Implement `diff-*` languages
+      if (diff && tokenIndex === 0 && text.length > 0) {
+        const prefixes = ['+', '-', '>', '<', ' '];
+        const prefixTypes = ['inserted', 'deleted', 'inserted', 'deleted', 'unchanged'];
+        const prefixIndex = prefixes.indexOf(text[0]);
+
+        if (prefixIndex !== -1) {
+          nodes.push(createCodeHighlightNode(prefixes[prefixIndex], prefixTypes[prefixIndex]));
+          text = text.slice(1);
+        }
+      }
+
+      const style = engine.stringifyTokenStyle(
+        token.htmlStyle || engine.getTokenStyleObject(token),
+      );
+
+      tokenizeRawText(text, {
+        /**
+         * Append a line break node.
+         * @returns {number} New node count.
+         */
+        linebreak: () => nodes.push(createLineBreakNode()),
+        /**
+         * Append a tab node.
+         * @returns {number} New node count.
+         */
+        tab: () => nodes.push(createTabNode()),
+        /**
+         * Create a highlight node carrying the token’s colour.
+         * @param {string} part Text fragment.
+         */
+        text: (part) => {
+          const node = createCodeHighlightNode(part);
+
+          node.setStyle(style);
+          nodes.push(node);
+        },
+      });
+    });
+  });
+
+  return nodes;
+};
+
+/**
+ * Tokenize a code node’s content into Lexical nodes.
+ *
+ * Unlike upstream, the theme’s background and foreground colours are not copied onto the code node.
+ * The block’s own colours come from `--sui-code-background-color` so that plain and highlighted
+ * blocks look alike and follow the app’s theme rather than Shiki’s; only the per-token colours are
+ * taken from the theme.
+ * @param {CodeNode} codeNode Code node to tokenize.
+ * @param {string} language Language identifier.
+ * @returns {LexicalNode[]} Lexical nodes.
+ */
+export const getHighlightNodes = (codeNode, language) => {
+  const diffedLanguage = getDiffedLanguage(language);
+
+  const { tokens } = highlighter.codeToTokens(codeNode.getTextContent(), {
+    lang: diffedLanguage ?? language,
+    theme: codeNode.getTheme(),
+  });
+
+  return mapTokensToLexicalStructure(tokens, !!diffedLanguage);
+};
+
+/**
+ * Highlight a snippet of code as an HTML string.
+ *
+ * Unlike the editor, which builds Lexical nodes, this returns markup for rendering elsewhere, such
+ * as a Markdown preview. It is synchronous, so it can be called from a renderer that cannot await:
+ * when the engine, grammar or theme is not loaded yet, it returns `undefined` rather than blocking,
+ * and the caller can render the code unhighlighted. Call {@link loadCodeHighlighter} first and
+ * render again once it resolves to get the highlighted result.
+ * @param {string} code Code to highlight.
+ * @param {string} language Language identifier or alias, like `ts` or `diff-js`.
+ * @param {object} [options] Options.
+ * @param {string} [options.theme] Shiki theme ID. Defaults to the one matching the app’s
+ * appearance.
+ * @returns {string | undefined} HTML string, or `undefined` when the code cannot be highlighted
+ * yet.
+ */
+export const highlightCodeToHTML = (code, language, { theme } = {}) => {
+  const id = normalizeCodeLanguage(getDiffedLanguage(language) ?? language);
+
+  if (!highlighter || isPlainLanguage(id) || !isCodeLanguageLoaded(id)) {
+    return undefined;
+  }
+
+  // Resolved only once the cheap checks pass, so bailing out early costs nothing
+  const resolvedTheme = theme ?? getCodeTheme();
+
+  if (!isCodeThemeLoaded(resolvedTheme)) {
+    return undefined;
+  }
+
+  return highlighter.codeToHtml(code, { lang: id, theme: resolvedTheme });
+};

package/dist/components/text-editor/shiki/generated.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Version of Shiki whose grammars and themes are fetched at runtime. Must stay in sync with the
+ * version bundled into `dist/shiki-engine.js`, because grammar and theme payloads are only
+ * guaranteed to be compatible with the matching engine.
+ */
+export const SHIKI_VERSION: "4.4.3";
+/**
+ * Version of this package, used to resolve the prebuilt Shiki engine chunk from a CDN.
+ */
+export const UI_VERSION: "0.63.0";
+/**
+ * Available syntax highlighting languages, sorted by display name.
+ * @type {{ id: string, name: string, aliases?: string[] }[]}
+ */
+export const LANGUAGES: {
+    id: string;
+    name: string;
+    aliases?: string[];
+}[];
+/**
+ * Available syntax highlighting themes.
+ * @type {{ id: string, displayName: string, type: string }[]}
+ */
+export const THEMES: {
+    id: string;
+    displayName: string;
+    type: string;
+}[];

package/dist/components/text-editor/shiki/generated.js

@@ -0,0 +1,25 @@
+// Generated by `scripts/generate-shiki-metadata.js`. DO NOT EDIT.
+
+/**
+ * Version of Shiki whose grammars and themes are fetched at runtime. Must stay in sync with the
+ * version bundled into `dist/shiki-engine.js`, because grammar and theme payloads are only
+ * guaranteed to be compatible with the matching engine.
+ */
+export const SHIKI_VERSION = "4.4.3";
+
+/**
+ * Version of this package, used to resolve the prebuilt Shiki engine chunk from a CDN.
+ */
+export const UI_VERSION = "0.63.0";
+
+/**
+ * Available syntax highlighting languages, sorted by display name.
+ * @type {{ id: string, name: string, aliases?: string[] }[]}
+ */
+export const LANGUAGES = [{"id":"bsl","name":"1C (Enterprise)","aliases":["1c"]},{"id":"sdbl","name":"1C (Query)","aliases":["1c-query"]},{"id":"abap","name":"ABAP"},{"id":"actionscript-3","name":"ActionScript","aliases":["actionscript","as3"]},{"id":"ada","name":"Ada"},{"id":"angular-html","name":"Angular HTML"},{"id":"angular-ts","name":"Angular TypeScript"},{"id":"apache","name":"Apache Conf"},{"id":"apex","name":"Apex"},{"id":"apl","name":"APL"},{"id":"applescript","name":"AppleScript"},{"id":"ara","name":"Ara"},{"id":"asciidoc","name":"AsciiDoc","aliases":["adoc"]},{"id":"razor","name":"ASP.NET Razor"},{"id":"asm","name":"Assembly"},{"id":"astro","name":"Astro"},{"id":"ahk","name":"AutoHotkey","aliases":["ahk1"]},{"id":"ahk2","name":"AutoHotkey2"},{"id":"awk","name":"AWK"},{"id":"ballerina","name":"Ballerina"},{"id":"bat","name":"Batch File","aliases":["batch","cmd"]},{"id":"beancount","name":"Beancount"},{"id":"berry","name":"Berry","aliases":["be"]},{"id":"bibtex","name":"BibTeX"},{"id":"bicep","name":"Bicep"},{"id":"bird2","name":"BIRD2 Configuration","aliases":["bird"]},{"id":"blade","name":"Blade"},{"id":"c","name":"C"},{"id":"csharp","name":"C#","aliases":["c#","cs"]},{"id":"cpp","name":"C++","aliases":["c++"]},{"id":"c3","name":"C3"},{"id":"cadence","name":"Cadence","aliases":["cdc"]},{"id":"cairo","name":"Cairo"},{"id":"chapel","name":"Chapel","aliases":["chpl"]},{"id":"clarity","name":"Clarity"},{"id":"clojure","name":"Clojure","aliases":["clj"]},{"id":"soy","name":"Closure Templates","aliases":["closure-templates"]},{"id":"cmake","name":"CMake"},{"id":"cobol","name":"COBOL"},{"id":"codeowners","name":"CODEOWNERS"},{"id":"codeql","name":"CodeQL","aliases":["ql"]},{"id":"coffee","name":"CoffeeScript","aliases":["coffeescript"]},{"id":"common-lisp","name":"Common Lisp","aliases":["lisp"]},{"id":"crystal","name":"Crystal"},{"id":"css","name":"CSS"},{"id":"csv","name":"CSV"},{"id":"cue","name":"CUE"},{"id":"cypher","name":"Cypher","aliases":["cql"]},{"id":"d","name":"D"},{"id":"dart","name":"Dart"},{"id":"dax","name":"DAX"},{"id":"desktop","name":"Desktop"},{"id":"diff","name":"Diff"},{"id":"docker","name":"Dockerfile","aliases":["dockerfile"]},{"id":"dotenv","name":"dotEnv"},{"id":"dream-maker","name":"Dream Maker"},{"id":"edge","name":"Edge"},{"id":"elixir","name":"Elixir"},{"id":"elm","name":"Elm"},{"id":"emacs-lisp","name":"Emacs Lisp","aliases":["elisp"]},{"id":"erb","name":"ERB"},{"id":"erlang","name":"Erlang","aliases":["erl"]},{"id":"fsharp","name":"F#","aliases":["f#","fs"]},{"id":"fennel","name":"Fennel"},{"id":"fish","name":"Fish"},{"id":"fluent","name":"Fluent","aliases":["ftl"]},{"id":"fortran-fixed-form","name":"Fortran (Fixed Form)","aliases":["f","for","f77"]},{"id":"fortran-free-form","name":"Fortran (Free Form)","aliases":["f90","f95","f03","f08","f18"]},{"id":"gdresource","name":"GDResource","aliases":["tscn","tres"]},{"id":"gdscript","name":"GDScript","aliases":["gd"]},{"id":"gdshader","name":"GDShader"},{"id":"genie","name":"Genie"},{"id":"po","name":"Gettext PO","aliases":["pot","potx"]},{"id":"gherkin","name":"Gherkin"},{"id":"git-commit","name":"Git Commit Message"},{"id":"git-rebase","name":"Git Rebase Message"},{"id":"gleam","name":"Gleam"},{"id":"glimmer-js","name":"Glimmer JS","aliases":["gjs"]},{"id":"glimmer-ts","name":"Glimmer TS","aliases":["gts"]},{"id":"glsl","name":"GLSL"},{"id":"gn","name":"GN"},{"id":"smalltalk","name":"GNU Smalltalk"},{"id":"gnuplot","name":"Gnuplot"},{"id":"go","name":"Go"},{"id":"graphql","name":"GraphQL","aliases":["gql"]},{"id":"groovy","name":"Groovy"},{"id":"hack","name":"Hack"},{"id":"handlebars","name":"Handlebars","aliases":["hbs"]},{"id":"hcl","name":"HashiCorp HCL"},{"id":"haskell","name":"Haskell","aliases":["hs"]},{"id":"haxe","name":"Haxe"},{"id":"hjson","name":"Hjson"},{"id":"hlsl","name":"HLSL"},{"id":"html","name":"HTML"},{"id":"html-derivative","name":"HTML (Derivative)"},{"id":"http","name":"HTTP"},{"id":"hurl","name":"Hurl"},{"id":"hxml","name":"HXML"},{"id":"hy","name":"Hy"},{"id":"imba","name":"Imba"},{"id":"ini","name":"INI","aliases":["properties"]},{"id":"java","name":"Java"},{"id":"javascript","name":"JavaScript","aliases":["js","cjs","mjs"]},{"id":"jinja","name":"Jinja"},{"id":"jison","name":"Jison"},{"id":"json","name":"JSON"},{"id":"jsonl","name":"JSON Lines"},{"id":"jsonc","name":"JSON with Comments"},{"id":"json5","name":"JSON5"},{"id":"jsonnet","name":"Jsonnet"},{"id":"jssm","name":"JSSM","aliases":["fsl"]},{"id":"jsx","name":"JSX"},{"id":"julia","name":"Julia","aliases":["jl"]},{"id":"just","name":"Just","aliases":["justfile"]},{"id":"kdl","name":"KDL"},{"id":"kotlin","name":"Kotlin","aliases":["kt","kts"]},{"id":"kusto","name":"Kusto","aliases":["kql"]},{"id":"latex","name":"LaTeX"},{"id":"lean","name":"Lean 4","aliases":["lean4"]},{"id":"less","name":"Less"},{"id":"liquid","name":"Liquid"},{"id":"llvm","name":"LLVM IR"},{"id":"log","name":"Log file"},{"id":"logo","name":"Logo"},{"id":"lua","name":"Lua"},{"id":"luau","name":"Luau"},{"id":"make","name":"Makefile","aliases":["makefile"]},{"id":"markdown","name":"Markdown","aliases":["md"]},{"id":"marko","name":"Marko"},{"id":"matlab","name":"MATLAB"},{"id":"mdc","name":"MDC"},{"id":"mdx","name":"MDX"},{"id":"mermaid","name":"Mermaid","aliases":["mmd"]},{"id":"mipsasm","name":"MIPS Assembly","aliases":["mips"]},{"id":"mojo","name":"Mojo"},{"id":"moonbit","name":"MoonBit","aliases":["mbt","mbti"]},{"id":"move","name":"Move"},{"id":"narrat","name":"Narrat Language","aliases":["nar"]},{"id":"nextflow","name":"Nextflow","aliases":["nf"]},{"id":"nextflow-groovy","name":"Nextflow Groovy"},{"id":"nginx","name":"Nginx"},{"id":"nim","name":"Nim"},{"id":"nix","name":"Nix"},{"id":"nsis","name":"NSIS"},{"id":"nushell","name":"nushell","aliases":["nu"]},{"id":"objective-c","name":"Objective-C","aliases":["objc"]},{"id":"objective-cpp","name":"Objective-C++"},{"id":"ocaml","name":"OCaml"},{"id":"odin","name":"Odin"},{"id":"openscad","name":"OpenSCAD","aliases":["scad"]},{"id":"org","name":"Org Markup"},{"id":"pascal","name":"Pascal"},{"id":"perl","name":"Perl"},{"id":"php","name":"PHP"},{"id":"pkl","name":"Pkl"},{"id":"plsql","name":"PL/SQL"},{"id":"polar","name":"Polar"},{"id":"postcss","name":"PostCSS"},{"id":"powerquery","name":"PowerQuery"},{"id":"powershell","name":"PowerShell","aliases":["ps","ps1","pwsh"]},{"id":"prisma","name":"Prisma"},{"id":"prolog","name":"Prolog"},{"id":"proto","name":"Protocol Buffer 3","aliases":["protobuf"]},{"id":"pug","name":"Pug","aliases":["jade"]},{"id":"puppet","name":"Puppet"},{"id":"purescript","name":"PureScript"},{"id":"python","name":"Python","aliases":["py"]},{"id":"qml","name":"QML"},{"id":"qmldir","name":"QML Directory"},{"id":"qss","name":"Qt Style Sheets"},{"id":"r","name":"R"},{"id":"racket","name":"Racket"},{"id":"raku","name":"Raku","aliases":["perl6"]},{"id":"rbs","name":"RBS","aliases":["ruby-signature"]},{"id":"regexp","name":"RegExp","aliases":["regex"]},{"id":"rel","name":"Rel"},{"id":"rst","name":"reStructuredText"},{"id":"riscv","name":"RISC-V"},{"id":"coq","name":"Rocq"},{"id":"ron","name":"RON"},{"id":"rosmsg","name":"ROS Interface"},{"id":"ruby","name":"Ruby","aliases":["rb"]},{"id":"haml","name":"Ruby Haml"},{"id":"rust","name":"Rust","aliases":["rs"]},{"id":"sas","name":"SAS"},{"id":"sass","name":"Sass"},{"id":"scala","name":"Scala"},{"id":"scheme","name":"Scheme"},{"id":"scss","name":"SCSS"},{"id":"shaderlab","name":"ShaderLab","aliases":["shader"]},{"id":"shellscript","name":"Shell","aliases":["bash","sh","shell","zsh"]},{"id":"shellsession","name":"Shell Session","aliases":["console"]},{"id":"smithy","name":"Smithy"},{"id":"solidity","name":"Solidity"},{"id":"sparql","name":"SPARQL"},{"id":"splunk","name":"Splunk Query Language","aliases":["spl"]},{"id":"sql","name":"SQL"},{"id":"ssh-config","name":"SSH Config"},{"id":"stata","name":"Stata"},{"id":"stylus","name":"Stylus","aliases":["styl"]},{"id":"surrealql","name":"SurrealQL","aliases":["surql"]},{"id":"svelte","name":"Svelte"},{"id":"swift","name":"Swift"},{"id":"systemd","name":"Systemd Units"},{"id":"system-verilog","name":"SystemVerilog"},{"id":"talonscript","name":"TalonScript","aliases":["talon"]},{"id":"tasl","name":"Tasl"},{"id":"tcl","name":"Tcl"},{"id":"templ","name":"Templ"},{"id":"terraform","name":"Terraform","aliases":["tf","tfvars"]},{"id":"tex","name":"TeX"},{"id":"toml","name":"TOML"},{"id":"tsv","name":"TSV"},{"id":"tsx","name":"TSX"},{"id":"turtle","name":"Turtle"},{"id":"twig","name":"Twig"},{"id":"typescript","name":"TypeScript","aliases":["ts","cts","mts"]},{"id":"ts-tags","name":"TypeScript with Tags","aliases":["lit"]},{"id":"typespec","name":"TypeSpec","aliases":["tsp"]},{"id":"typst","name":"Typst","aliases":["typ"]},{"id":"v","name":"V"},{"id":"vala","name":"Vala"},{"id":"verilog","name":"Verilog"},{"id":"vhdl","name":"VHDL"},{"id":"viml","name":"Vim Script","aliases":["vim","vimscript"]},{"id":"vb","name":"Visual Basic"},{"id":"vue","name":"Vue"},{"id":"vue-html","name":"Vue HTML"},{"id":"vue-vine","name":"Vue Vine"},{"id":"vyper","name":"Vyper","aliases":["vy"]},{"id":"wasm","name":"WebAssembly"},{"id":"wit","name":"WebAssembly Interface Types"},{"id":"wenyan","name":"Wenyan","aliases":["文言"]},{"id":"wgsl","name":"WGSL"},{"id":"wikitext","name":"Wikitext","aliases":["mediawiki","wiki"]},{"id":"reg","name":"Windows Registry Script"},{"id":"wolfram","name":"Wolfram","aliases":["wl"]},{"id":"xml","name":"XML"},{"id":"xsl","name":"XSL"},{"id":"yaml","name":"YAML","aliases":["yml"]},{"id":"zenscript","name":"ZenScript"},{"id":"zig","name":"Zig"}];
+
+/**
+ * Available syntax highlighting themes.
+ * @type {{ id: string, displayName: string, type: string }[]}
+ */
+export const THEMES = [{"id":"andromeeda","displayName":"Andromeeda","type":"dark"},{"id":"aurora-x","displayName":"Aurora X","type":"dark"},{"id":"ayu-dark","displayName":"Ayu Dark","type":"dark"},{"id":"ayu-light","displayName":"Ayu Light","type":"light"},{"id":"ayu-mirage","displayName":"Ayu Mirage","type":"dark"},{"id":"catppuccin-frappe","displayName":"Catppuccin Frappé","type":"dark"},{"id":"catppuccin-latte","displayName":"Catppuccin Latte","type":"light"},{"id":"catppuccin-macchiato","displayName":"Catppuccin Macchiato","type":"dark"},{"id":"catppuccin-mocha","displayName":"Catppuccin Mocha","type":"dark"},{"id":"dark-plus","displayName":"Dark Plus","type":"dark"},{"id":"dracula","displayName":"Dracula Theme","type":"dark"},{"id":"dracula-soft","displayName":"Dracula Theme Soft","type":"dark"},{"id":"everforest-dark","displayName":"Everforest Dark","type":"dark"},{"id":"everforest-light","displayName":"Everforest Light","type":"light"},{"id":"github-dark","displayName":"GitHub Dark","type":"dark"},{"id":"github-dark-default","displayName":"GitHub Dark Default","type":"dark"},{"id":"github-dark-dimmed","displayName":"GitHub Dark Dimmed","type":"dark"},{"id":"github-dark-high-contrast","displayName":"GitHub Dark High Contrast","type":"dark"},{"id":"github-light","displayName":"GitHub Light","type":"light"},{"id":"github-light-default","displayName":"GitHub Light Default","type":"light"},{"id":"github-light-high-contrast","displayName":"GitHub Light High Contrast","type":"light"},{"id":"gruvbox-dark-hard","displayName":"Gruvbox Dark Hard","type":"dark"},{"id":"gruvbox-dark-medium","displayName":"Gruvbox Dark Medium","type":"dark"},{"id":"gruvbox-dark-soft","displayName":"Gruvbox Dark Soft","type":"dark"},{"id":"gruvbox-light-hard","displayName":"Gruvbox Light Hard","type":"light"},{"id":"gruvbox-light-medium","displayName":"Gruvbox Light Medium","type":"light"},{"id":"gruvbox-light-soft","displayName":"Gruvbox Light Soft","type":"light"},{"id":"horizon","displayName":"Horizon","type":"dark"},{"id":"horizon-bright","displayName":"Horizon Bright","type":"light"},{"id":"houston","displayName":"Houston","type":"dark"},{"id":"kanagawa-dragon","displayName":"Kanagawa Dragon","type":"dark"},{"id":"kanagawa-lotus","displayName":"Kanagawa Lotus","type":"light"},{"id":"kanagawa-wave","displayName":"Kanagawa Wave","type":"dark"},{"id":"laserwave","displayName":"LaserWave","type":"dark"},{"id":"light-plus","displayName":"Light Plus","type":"light"},{"id":"material-theme","displayName":"Material Theme","type":"dark"},{"id":"material-theme-darker","displayName":"Material Theme Darker","type":"dark"},{"id":"material-theme-lighter","displayName":"Material Theme Lighter","type":"light"},{"id":"material-theme-ocean","displayName":"Material Theme Ocean","type":"dark"},{"id":"material-theme-palenight","displayName":"Material Theme Palenight","type":"dark"},{"id":"min-dark","displayName":"Min Dark","type":"dark"},{"id":"min-light","displayName":"Min Light","type":"light"},{"id":"monokai","displayName":"Monokai","type":"dark"},{"id":"night-owl","displayName":"Night Owl","type":"dark"},{"id":"night-owl-light","displayName":"Night Owl Light","type":"light"},{"id":"nord","displayName":"Nord","type":"dark"},{"id":"one-dark-pro","displayName":"One Dark Pro","type":"dark"},{"id":"one-light","displayName":"One Light","type":"light"},{"id":"plastic","displayName":"Plastic","type":"dark"},{"id":"poimandres","displayName":"Poimandres","type":"dark"},{"id":"red","displayName":"Red","type":"dark"},{"id":"rose-pine","displayName":"Rosé Pine","type":"dark"},{"id":"rose-pine-dawn","displayName":"Rosé Pine Dawn","type":"light"},{"id":"rose-pine-moon","displayName":"Rosé Pine Moon","type":"dark"},{"id":"slack-dark","displayName":"Slack Dark","type":"dark"},{"id":"slack-ochin","displayName":"Slack Ochin","type":"light"},{"id":"snazzy-light","displayName":"Snazzy Light","type":"light"},{"id":"solarized-dark","displayName":"Solarized Dark","type":"dark"},{"id":"solarized-light","displayName":"Solarized Light","type":"light"},{"id":"synthwave-84","displayName":"Synthwave '84","type":"dark"},{"id":"tokyo-night","displayName":"Tokyo Night","type":"dark"},{"id":"vesper","displayName":"Vesper","type":"dark"},{"id":"vitesse-black","displayName":"Vitesse Black","type":"dark"},{"id":"vitesse-dark","displayName":"Vitesse Dark","type":"dark"},{"id":"vitesse-light","displayName":"Vitesse Light","type":"light"}];

package/dist/components/text-editor/shiki/highlighter.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Default tokenizer backed by Shiki.
+ *
+ * Falls back to unhighlighted text whenever highlighting is impossible — a plain language, or an
+ * engine that has not loaded yet or could not be fetched — so a code block always renders.
+ * @type {CodeTokenizer}
+ */
+export const shikiTokenizer: CodeTokenizer;
+export function registerCodeHighlighting(editor: LexicalEditor, tokenizer?: CodeTokenizer | undefined): () => void;
+import type { CodeTokenizer } from '../../../typedefs';
+import type { LexicalEditor } from 'lexical';