mirror of
https://github.com/Sevichecc/Urara-Blog.git
synced 2025-05-05 00:39:30 +08:00
2252 lines
71 KiB
Text
2252 lines
71 KiB
Text
import { loadWASM, createOnigScanner, createOnigString } from 'vscode-oniguruma';
|
|
import { INITIAL, Registry as Registry$1 } from 'vscode-textmate';
|
|
|
|
const themes = [
|
|
'css-variables',
|
|
'dark-plus',
|
|
'dracula-soft',
|
|
'dracula',
|
|
'github-dark-dimmed',
|
|
'github-dark',
|
|
'github-light',
|
|
'light-plus',
|
|
'material-darker',
|
|
'material-default',
|
|
'material-lighter',
|
|
'material-ocean',
|
|
'material-palenight',
|
|
'min-dark',
|
|
'min-light',
|
|
'monokai',
|
|
'nord',
|
|
'one-dark-pro',
|
|
'poimandres',
|
|
'rose-pine-dawn',
|
|
'rose-pine-moon',
|
|
'rose-pine',
|
|
'slack-dark',
|
|
'slack-ochin',
|
|
'solarized-dark',
|
|
'solarized-light',
|
|
'vitesse-dark',
|
|
'vitesse-light'
|
|
];
|
|
|
|
const languages = [
|
|
{
|
|
id: 'abap',
|
|
scopeName: 'source.abap',
|
|
path: 'abap.tmLanguage.json',
|
|
samplePath: 'abap.sample'
|
|
},
|
|
{
|
|
id: 'actionscript-3',
|
|
scopeName: 'source.actionscript.3',
|
|
path: 'actionscript-3.tmLanguage.json',
|
|
samplePath: 'actionscript-3.sample'
|
|
},
|
|
{
|
|
id: 'ada',
|
|
scopeName: 'source.ada',
|
|
path: 'ada.tmLanguage.json',
|
|
samplePath: 'ada.sample'
|
|
},
|
|
{
|
|
id: 'apache',
|
|
scopeName: 'source.apacheconf',
|
|
path: 'apache.tmLanguage.json'
|
|
},
|
|
{
|
|
id: 'apex',
|
|
scopeName: 'source.apex',
|
|
path: 'apex.tmLanguage.json',
|
|
samplePath: 'apex.sample'
|
|
},
|
|
{
|
|
id: 'apl',
|
|
scopeName: 'source.apl',
|
|
path: 'apl.tmLanguage.json',
|
|
embeddedLangs: ['html', 'xml', 'css', 'javascript', 'json']
|
|
},
|
|
{
|
|
id: 'applescript',
|
|
scopeName: 'source.applescript',
|
|
path: 'applescript.tmLanguage.json',
|
|
samplePath: 'applescript.sample'
|
|
},
|
|
{
|
|
id: 'asm',
|
|
scopeName: 'source.asm.x86_64',
|
|
path: 'asm.tmLanguage.json',
|
|
samplePath: 'asm.sample'
|
|
},
|
|
{
|
|
id: 'astro',
|
|
scopeName: 'text.html.astro',
|
|
path: 'astro.tmLanguage.json',
|
|
samplePath: 'astro.sample',
|
|
embeddedLangs: ['css', 'javascript', 'less', 'sass', 'scss', 'stylus', 'typescript', 'tsx']
|
|
},
|
|
{
|
|
id: 'awk',
|
|
scopeName: 'source.awk',
|
|
path: 'awk.tmLanguage.json',
|
|
samplePath: 'awk.sample'
|
|
},
|
|
{
|
|
id: 'ballerina',
|
|
scopeName: 'source.ballerina',
|
|
path: 'ballerina.tmLanguage.json',
|
|
samplePath: 'ballerina.sample'
|
|
},
|
|
{
|
|
id: 'bat',
|
|
scopeName: 'source.batchfile',
|
|
path: 'bat.tmLanguage.json',
|
|
samplePath: 'bat.sample',
|
|
aliases: ['batch']
|
|
},
|
|
{
|
|
id: 'berry',
|
|
scopeName: 'source.berry',
|
|
path: 'berry.tmLanguage.json',
|
|
samplePath: 'berry.sample',
|
|
aliases: ['be']
|
|
},
|
|
{
|
|
id: 'bibtex',
|
|
scopeName: 'text.bibtex',
|
|
path: 'bibtex.tmLanguage.json'
|
|
},
|
|
{
|
|
id: 'bicep',
|
|
scopeName: 'source.bicep',
|
|
path: 'bicep.tmLanguage.json',
|
|
samplePath: 'bicep.sample'
|
|
},
|
|
{
|
|
id: 'c',
|
|
scopeName: 'source.c',
|
|
path: 'c.tmLanguage.json',
|
|
samplePath: 'c.sample'
|
|
},
|
|
{
|
|
id: 'clojure',
|
|
scopeName: 'source.clojure',
|
|
path: 'clojure.tmLanguage.json',
|
|
samplePath: 'clojure.sample',
|
|
aliases: ['clj']
|
|
},
|
|
{
|
|
id: 'cobol',
|
|
scopeName: 'source.cobol',
|
|
path: 'cobol.tmLanguage.json',
|
|
samplePath: 'cobol.sample',
|
|
embeddedLangs: ['sql', 'html', 'java']
|
|
},
|
|
{
|
|
id: 'codeql',
|
|
scopeName: 'source.ql',
|
|
path: 'codeql.tmLanguage.json',
|
|
samplePath: 'codeql.sample',
|
|
aliases: ['ql']
|
|
},
|
|
{
|
|
id: 'coffee',
|
|
scopeName: 'source.coffee',
|
|
path: 'coffee.tmLanguage.json',
|
|
samplePath: 'coffee.sample',
|
|
embeddedLangs: ['javascript']
|
|
},
|
|
{
|
|
id: 'cpp',
|
|
scopeName: 'source.cpp',
|
|
path: 'cpp.tmLanguage.json',
|
|
samplePath: 'cpp.sample',
|
|
embeddedLangs: ['sql']
|
|
},
|
|
{
|
|
id: 'crystal',
|
|
scopeName: 'source.crystal',
|
|
path: 'crystal.tmLanguage.json',
|
|
samplePath: 'crystal.sample',
|
|
embeddedLangs: ['html', 'sql', 'css', 'c', 'javascript', 'shellscript']
|
|
},
|
|
{
|
|
id: 'csharp',
|
|
scopeName: 'source.cs',
|
|
path: 'csharp.tmLanguage.json',
|
|
samplePath: 'csharp.sample',
|
|
aliases: ['c#']
|
|
},
|
|
{
|
|
id: 'css',
|
|
scopeName: 'source.css',
|
|
path: 'css.tmLanguage.json',
|
|
samplePath: 'css.sample'
|
|
},
|
|
{
|
|
id: 'cue',
|
|
scopeName: 'source.cue',
|
|
path: 'cue.tmLanguage.json',
|
|
samplePath: 'cue.sample'
|
|
},
|
|
{
|
|
id: 'd',
|
|
scopeName: 'source.d',
|
|
path: 'd.tmLanguage.json',
|
|
samplePath: 'd.sample'
|
|
},
|
|
{
|
|
id: 'dart',
|
|
scopeName: 'source.dart',
|
|
path: 'dart.tmLanguage.json',
|
|
samplePath: 'dart.sample'
|
|
},
|
|
{
|
|
id: 'diff',
|
|
scopeName: 'source.diff',
|
|
path: 'diff.tmLanguage.json',
|
|
samplePath: 'diff.sample'
|
|
},
|
|
{
|
|
id: 'docker',
|
|
scopeName: 'source.dockerfile',
|
|
path: 'docker.tmLanguage.json',
|
|
samplePath: 'docker.sample'
|
|
},
|
|
{
|
|
id: 'dream-maker',
|
|
scopeName: 'source.dm',
|
|
path: 'dream-maker.tmLanguage.json'
|
|
},
|
|
{
|
|
id: 'elixir',
|
|
scopeName: 'source.elixir',
|
|
path: 'elixir.tmLanguage.json',
|
|
samplePath: 'elixir.sample',
|
|
embeddedLangs: ['html']
|
|
},
|
|
{
|
|
id: 'elm',
|
|
scopeName: 'source.elm',
|
|
path: 'elm.tmLanguage.json',
|
|
samplePath: 'elm.sample'
|
|
},
|
|
{
|
|
id: 'erb',
|
|
scopeName: 'text.html.erb',
|
|
path: 'erb.tmLanguage.json',
|
|
samplePath: 'erb.sample',
|
|
embeddedLangs: ['html', 'ruby']
|
|
},
|
|
{
|
|
id: 'erlang',
|
|
scopeName: 'source.erlang',
|
|
path: 'erlang.tmLanguage.json',
|
|
samplePath: 'erlang.sample'
|
|
},
|
|
{
|
|
id: 'fish',
|
|
scopeName: 'source.fish',
|
|
path: 'fish.tmLanguage.json',
|
|
samplePath: 'fish.sample'
|
|
},
|
|
{
|
|
id: 'fsharp',
|
|
scopeName: 'source.fsharp',
|
|
path: 'fsharp.tmLanguage.json',
|
|
samplePath: 'fsharp.sample',
|
|
aliases: ['f#'],
|
|
embeddedLangs: ['markdown']
|
|
},
|
|
{
|
|
id: 'gherkin',
|
|
scopeName: 'text.gherkin.feature',
|
|
path: 'gherkin.tmLanguage.json'
|
|
},
|
|
{
|
|
id: 'git-commit',
|
|
scopeName: 'text.git-commit',
|
|
path: 'git-commit.tmLanguage.json',
|
|
embeddedLangs: ['diff']
|
|
},
|
|
{
|
|
id: 'git-rebase',
|
|
scopeName: 'text.git-rebase',
|
|
path: 'git-rebase.tmLanguage.json',
|
|
embeddedLangs: ['shellscript']
|
|
},
|
|
{
|
|
id: 'gnuplot',
|
|
scopeName: 'source.gnuplot',
|
|
path: 'gnuplot.tmLanguage.json'
|
|
},
|
|
{
|
|
id: 'go',
|
|
scopeName: 'source.go',
|
|
path: 'go.tmLanguage.json',
|
|
samplePath: 'go.sample'
|
|
},
|
|
{
|
|
id: 'graphql',
|
|
scopeName: 'source.graphql',
|
|
path: 'graphql.tmLanguage.json',
|
|
embeddedLangs: ['javascript', 'typescript', 'jsx', 'tsx']
|
|
},
|
|
{
|
|
id: 'groovy',
|
|
scopeName: 'source.groovy',
|
|
path: 'groovy.tmLanguage.json'
|
|
},
|
|
{
|
|
id: 'hack',
|
|
scopeName: 'source.hack',
|
|
path: 'hack.tmLanguage.json',
|
|
embeddedLangs: ['html', 'sql']
|
|
},
|
|
{
|
|
id: 'haml',
|
|
scopeName: 'text.haml',
|
|
path: 'haml.tmLanguage.json',
|
|
embeddedLangs: ['ruby', 'javascript', 'sass', 'coffee', 'markdown', 'css']
|
|
},
|
|
{
|
|
id: 'handlebars',
|
|
scopeName: 'text.html.handlebars',
|
|
path: 'handlebars.tmLanguage.json',
|
|
aliases: ['hbs'],
|
|
embeddedLangs: ['html', 'css', 'javascript', 'yaml']
|
|
},
|
|
{
|
|
id: 'haskell',
|
|
scopeName: 'source.haskell',
|
|
path: 'haskell.tmLanguage.json'
|
|
},
|
|
{
|
|
id: 'hcl',
|
|
scopeName: 'source.hcl',
|
|
path: 'hcl.tmLanguage.json'
|
|
},
|
|
{
|
|
id: 'hlsl',
|
|
scopeName: 'source.hlsl',
|
|
path: 'hlsl.tmLanguage.json'
|
|
},
|
|
{
|
|
id: 'html',
|
|
scopeName: 'text.html.basic',
|
|
path: 'html.tmLanguage.json',
|
|
samplePath: 'html.sample',
|
|
embeddedLangs: ['javascript', 'css']
|
|
},
|
|
{
|
|
id: 'ini',
|
|
scopeName: 'source.ini',
|
|
path: 'ini.tmLanguage.json'
|
|
},
|
|
{
|
|
id: 'java',
|
|
scopeName: 'source.java',
|
|
path: 'java.tmLanguage.json',
|
|
samplePath: 'java.sample'
|
|
},
|
|
{
|
|
id: 'javascript',
|
|
scopeName: 'source.js',
|
|
path: 'javascript.tmLanguage.json',
|
|
samplePath: 'javascript.sample',
|
|
aliases: ['js']
|
|
},
|
|
{
|
|
id: 'jinja-html',
|
|
scopeName: 'text.html.jinja',
|
|
path: 'jinja-html.tmLanguage.json',
|
|
embeddedLangs: ['html']
|
|
},
|
|
{
|
|
id: 'json',
|
|
scopeName: 'source.json',
|
|
path: 'json.tmLanguage.json'
|
|
},
|
|
{
|
|
id: 'jsonc',
|
|
scopeName: 'source.json.comments',
|
|
path: 'jsonc.tmLanguage.json'
|
|
},
|
|
{
|
|
id: 'jsonnet',
|
|
scopeName: 'source.jsonnet',
|
|
path: 'jsonnet.tmLanguage.json'
|
|
},
|
|
{
|
|
id: 'jssm',
|
|
scopeName: 'source.jssm',
|
|
path: 'jssm.tmLanguage.json',
|
|
samplePath: 'jssm.sample',
|
|
aliases: ['fsl']
|
|
},
|
|
{
|
|
id: 'jsx',
|
|
scopeName: 'source.js.jsx',
|
|
path: 'jsx.tmLanguage.json'
|
|
},
|
|
{
|
|
id: 'julia',
|
|
scopeName: 'source.julia',
|
|
path: 'julia.tmLanguage.json',
|
|
embeddedLangs: ['cpp', 'python', 'javascript', 'r', 'sql']
|
|
},
|
|
{
|
|
id: 'jupyter',
|
|
scopeName: 'source.jupyter',
|
|
path: 'jupyter.tmLanguage.json',
|
|
embeddedLangs: ['json']
|
|
},
|
|
{
|
|
id: 'kotlin',
|
|
scopeName: 'source.kotlin',
|
|
path: 'kotlin.tmLanguage.json'
|
|
},
|
|
{
|
|
id: 'latex',
|
|
scopeName: 'text.tex.latex',
|
|
path: 'latex.tmLanguage.json',
|
|
embeddedLangs: ['tex', 'css', 'html', 'java', 'javascript', 'typescript', 'lua', 'python', 'julia', 'ruby', 'xml', 'yaml', 'cpp', 'haskell', 'scala', 'gnuplot']
|
|
},
|
|
{
|
|
id: 'less',
|
|
scopeName: 'source.css.less',
|
|
path: 'less.tmLanguage.json',
|
|
embeddedLangs: ['css']
|
|
},
|
|
{
|
|
id: 'lisp',
|
|
scopeName: 'source.lisp',
|
|
path: 'lisp.tmLanguage.json'
|
|
},
|
|
{
|
|
id: 'logo',
|
|
scopeName: 'source.logo',
|
|
path: 'logo.tmLanguage.json'
|
|
},
|
|
{
|
|
id: 'lua',
|
|
scopeName: 'source.lua',
|
|
path: 'lua.tmLanguage.json',
|
|
embeddedLangs: ['c']
|
|
},
|
|
{
|
|
id: 'make',
|
|
scopeName: 'source.makefile',
|
|
path: 'make.tmLanguage.json',
|
|
aliases: ['makefile']
|
|
},
|
|
{
|
|
id: 'markdown',
|
|
scopeName: 'text.html.markdown',
|
|
path: 'markdown.tmLanguage.json',
|
|
aliases: ['md'],
|
|
embeddedLangs: ['css', 'html', 'ini', 'java', 'lua', 'make', 'perl', 'r', 'ruby', 'php', 'sql', 'vb', 'xml', 'xsl', 'yaml', 'bat', 'clojure', 'coffee', 'c', 'cpp', 'diff', 'docker', 'git-commit', 'git-rebase', 'go', 'groovy', 'pug', 'javascript', 'json', 'jsonc', 'less', 'objective-c', 'swift', 'scss', 'raku', 'powershell', 'python', 'rust', 'scala', 'shellscript', 'typescript', 'tsx', 'csharp', 'fsharp', 'dart', 'handlebars', 'erlang', 'elixir', 'latex', 'bibtex']
|
|
},
|
|
{
|
|
id: 'marko',
|
|
scopeName: 'text.marko',
|
|
path: 'marko.tmLanguage.json',
|
|
samplePath: 'marko.sample',
|
|
embeddedLangs: ['css', 'less', 'scss', 'javascript']
|
|
},
|
|
{
|
|
id: 'matlab',
|
|
scopeName: 'source.matlab',
|
|
path: 'matlab.tmLanguage.json'
|
|
},
|
|
{
|
|
id: 'mdx',
|
|
scopeName: 'text.html.markdown.jsx',
|
|
path: 'mdx.tmLanguage.json',
|
|
embeddedLangs: ['jsx', 'markdown']
|
|
},
|
|
{
|
|
id: 'nginx',
|
|
scopeName: 'source.nginx',
|
|
path: 'nginx.tmLanguage.json',
|
|
embeddedLangs: ['lua']
|
|
},
|
|
{
|
|
id: 'nim',
|
|
scopeName: 'source.nim',
|
|
path: 'nim.tmLanguage.json',
|
|
embeddedLangs: ['c', 'html', 'xml', 'javascript', 'css', 'markdown']
|
|
},
|
|
{
|
|
id: 'nix',
|
|
scopeName: 'source.nix',
|
|
path: 'nix.tmLanguage.json'
|
|
},
|
|
{
|
|
id: 'objective-c',
|
|
scopeName: 'source.objc',
|
|
path: 'objective-c.tmLanguage.json',
|
|
aliases: ['objc']
|
|
},
|
|
{
|
|
id: 'objective-cpp',
|
|
scopeName: 'source.objcpp',
|
|
path: 'objective-cpp.tmLanguage.json'
|
|
},
|
|
{
|
|
id: 'ocaml',
|
|
scopeName: 'source.ocaml',
|
|
path: 'ocaml.tmLanguage.json'
|
|
},
|
|
{
|
|
id: 'pascal',
|
|
scopeName: 'source.pascal',
|
|
path: 'pascal.tmLanguage.json'
|
|
},
|
|
{
|
|
id: 'perl',
|
|
scopeName: 'source.perl',
|
|
path: 'perl.tmLanguage.json',
|
|
embeddedLangs: ['html', 'xml', 'css', 'javascript', 'sql']
|
|
},
|
|
{
|
|
id: 'php',
|
|
scopeName: 'source.php',
|
|
path: 'php.tmLanguage.json',
|
|
embeddedLangs: ['html', 'xml', 'sql', 'javascript', 'json', 'css']
|
|
},
|
|
{
|
|
id: 'plsql',
|
|
scopeName: 'source.plsql.oracle',
|
|
path: 'plsql.tmLanguage.json'
|
|
},
|
|
{
|
|
id: 'postcss',
|
|
scopeName: 'source.css.postcss',
|
|
path: 'postcss.tmLanguage.json'
|
|
},
|
|
{
|
|
id: 'powershell',
|
|
scopeName: 'source.powershell',
|
|
path: 'powershell.tmLanguage.json',
|
|
aliases: ['ps', 'ps1']
|
|
},
|
|
{
|
|
id: 'prisma',
|
|
scopeName: 'source.prisma',
|
|
path: 'prisma.tmLanguage.json',
|
|
samplePath: 'prisma.sample'
|
|
},
|
|
{
|
|
id: 'prolog',
|
|
scopeName: 'source.prolog',
|
|
path: 'prolog.tmLanguage.json'
|
|
},
|
|
{
|
|
id: 'pug',
|
|
scopeName: 'text.pug',
|
|
path: 'pug.tmLanguage.json',
|
|
aliases: ['jade'],
|
|
embeddedLangs: ['javascript', 'css', 'sass', 'stylus', 'coffee', 'html']
|
|
},
|
|
{
|
|
id: 'puppet',
|
|
scopeName: 'source.puppet',
|
|
path: 'puppet.tmLanguage.json'
|
|
},
|
|
{
|
|
id: 'purescript',
|
|
scopeName: 'source.purescript',
|
|
path: 'purescript.tmLanguage.json'
|
|
},
|
|
{
|
|
id: 'python',
|
|
scopeName: 'source.python',
|
|
path: 'python.tmLanguage.json',
|
|
samplePath: 'python.sample',
|
|
aliases: ['py']
|
|
},
|
|
{
|
|
id: 'r',
|
|
scopeName: 'source.r',
|
|
path: 'r.tmLanguage.json'
|
|
},
|
|
{
|
|
id: 'raku',
|
|
scopeName: 'source.perl.6',
|
|
path: 'raku.tmLanguage.json',
|
|
aliases: ['perl6']
|
|
},
|
|
{
|
|
id: 'razor',
|
|
scopeName: 'text.aspnetcorerazor',
|
|
path: 'razor.tmLanguage.json',
|
|
embeddedLangs: ['html', 'csharp']
|
|
},
|
|
{
|
|
id: 'rel',
|
|
scopeName: 'source.rel',
|
|
path: 'rel.tmLanguage.json',
|
|
samplePath: 'rel.sample'
|
|
},
|
|
{
|
|
id: 'riscv',
|
|
scopeName: 'source.riscv',
|
|
path: 'riscv.tmLanguage.json'
|
|
},
|
|
{
|
|
id: 'ruby',
|
|
scopeName: 'source.ruby',
|
|
path: 'ruby.tmLanguage.json',
|
|
samplePath: 'ruby.sample',
|
|
aliases: ['rb'],
|
|
embeddedLangs: ['html', 'xml', 'sql', 'css', 'c', 'javascript', 'shellscript', 'lua']
|
|
},
|
|
{
|
|
id: 'rust',
|
|
scopeName: 'source.rust',
|
|
path: 'rust.tmLanguage.json',
|
|
aliases: ['rs']
|
|
},
|
|
{
|
|
id: 'sas',
|
|
scopeName: 'source.sas',
|
|
path: 'sas.tmLanguage.json',
|
|
embeddedLangs: ['sql']
|
|
},
|
|
{
|
|
id: 'sass',
|
|
scopeName: 'source.sass',
|
|
path: 'sass.tmLanguage.json'
|
|
},
|
|
{
|
|
id: 'scala',
|
|
scopeName: 'source.scala',
|
|
path: 'scala.tmLanguage.json'
|
|
},
|
|
{
|
|
id: 'scheme',
|
|
scopeName: 'source.scheme',
|
|
path: 'scheme.tmLanguage.json'
|
|
},
|
|
{
|
|
id: 'scss',
|
|
scopeName: 'source.css.scss',
|
|
path: 'scss.tmLanguage.json',
|
|
embeddedLangs: ['css']
|
|
},
|
|
{
|
|
id: 'shaderlab',
|
|
scopeName: 'source.shaderlab',
|
|
path: 'shaderlab.tmLanguage.json',
|
|
aliases: ['shader'],
|
|
embeddedLangs: ['hlsl']
|
|
},
|
|
{
|
|
id: 'shellscript',
|
|
scopeName: 'source.shell',
|
|
path: 'shellscript.tmLanguage.json',
|
|
aliases: ['shell', 'bash', 'sh', 'zsh'],
|
|
embeddedLangs: ['ruby', 'python', 'applescript', 'html', 'markdown']
|
|
},
|
|
{
|
|
id: 'smalltalk',
|
|
scopeName: 'source.smalltalk',
|
|
path: 'smalltalk.tmLanguage.json'
|
|
},
|
|
{
|
|
id: 'solidity',
|
|
scopeName: 'source.solidity',
|
|
path: 'solidity.tmLanguage.json'
|
|
},
|
|
{
|
|
id: 'sparql',
|
|
scopeName: 'source.sparql',
|
|
path: 'sparql.tmLanguage.json',
|
|
samplePath: 'sparql.sample',
|
|
embeddedLangs: ['turtle']
|
|
},
|
|
{
|
|
id: 'sql',
|
|
scopeName: 'source.sql',
|
|
path: 'sql.tmLanguage.json'
|
|
},
|
|
{
|
|
id: 'ssh-config',
|
|
scopeName: 'source.ssh-config',
|
|
path: 'ssh-config.tmLanguage.json'
|
|
},
|
|
{
|
|
id: 'stata',
|
|
scopeName: 'source.stata',
|
|
path: 'stata.tmLanguage.json',
|
|
samplePath: 'stata.sample',
|
|
embeddedLangs: ['sql']
|
|
},
|
|
{
|
|
id: 'stylus',
|
|
scopeName: 'source.stylus',
|
|
path: 'stylus.tmLanguage.json',
|
|
aliases: ['styl']
|
|
},
|
|
{
|
|
id: 'svelte',
|
|
scopeName: 'source.svelte',
|
|
path: 'svelte.tmLanguage.json',
|
|
embeddedLangs: ['javascript', 'typescript', 'coffee', 'stylus', 'sass', 'css', 'scss', 'less', 'postcss', 'pug', 'markdown']
|
|
},
|
|
{
|
|
id: 'swift',
|
|
scopeName: 'source.swift',
|
|
path: 'swift.tmLanguage.json'
|
|
},
|
|
{
|
|
id: 'system-verilog',
|
|
scopeName: 'source.systemverilog',
|
|
path: 'system-verilog.tmLanguage.json'
|
|
},
|
|
{
|
|
id: 'tasl',
|
|
scopeName: 'source.tasl',
|
|
path: 'tasl.tmLanguage.json',
|
|
samplePath: 'tasl.sample'
|
|
},
|
|
{
|
|
id: 'tcl',
|
|
scopeName: 'source.tcl',
|
|
path: 'tcl.tmLanguage.json'
|
|
},
|
|
{
|
|
id: 'tex',
|
|
scopeName: 'text.tex',
|
|
path: 'tex.tmLanguage.json',
|
|
embeddedLangs: ['r']
|
|
},
|
|
{
|
|
id: 'toml',
|
|
scopeName: 'source.toml',
|
|
path: 'toml.tmLanguage.json'
|
|
},
|
|
{
|
|
id: 'tsx',
|
|
scopeName: 'source.tsx',
|
|
path: 'tsx.tmLanguage.json',
|
|
samplePath: 'tsx.sample'
|
|
},
|
|
{
|
|
id: 'turtle',
|
|
scopeName: 'source.turtle',
|
|
path: 'turtle.tmLanguage.json',
|
|
samplePath: 'turtle.sample'
|
|
},
|
|
{
|
|
id: 'twig',
|
|
scopeName: 'text.html.twig',
|
|
path: 'twig.tmLanguage.json',
|
|
embeddedLangs: ['css', 'javascript', 'php', 'python', 'ruby']
|
|
},
|
|
{
|
|
id: 'typescript',
|
|
scopeName: 'source.ts',
|
|
path: 'typescript.tmLanguage.json',
|
|
aliases: ['ts']
|
|
},
|
|
{
|
|
id: 'vb',
|
|
scopeName: 'source.asp.vb.net',
|
|
path: 'vb.tmLanguage.json',
|
|
aliases: ['cmd']
|
|
},
|
|
{
|
|
id: 'verilog',
|
|
scopeName: 'source.verilog',
|
|
path: 'verilog.tmLanguage.json'
|
|
},
|
|
{
|
|
id: 'vhdl',
|
|
scopeName: 'source.vhdl',
|
|
path: 'vhdl.tmLanguage.json'
|
|
},
|
|
{
|
|
id: 'viml',
|
|
scopeName: 'source.viml',
|
|
path: 'viml.tmLanguage.json',
|
|
aliases: ['vim', 'vimscript']
|
|
},
|
|
{
|
|
id: 'vue-html',
|
|
scopeName: 'text.html.vue-html',
|
|
path: 'vue-html.tmLanguage.json',
|
|
embeddedLangs: ['vue', 'javascript']
|
|
},
|
|
{
|
|
id: 'vue',
|
|
scopeName: 'source.vue',
|
|
path: 'vue.tmLanguage.json',
|
|
embeddedLangs: ['json', 'markdown', 'pug', 'haml', 'vue-html', 'sass', 'scss', 'less', 'stylus', 'postcss', 'css', 'typescript', 'coffee', 'javascript']
|
|
},
|
|
{
|
|
id: 'wasm',
|
|
scopeName: 'source.wat',
|
|
path: 'wasm.tmLanguage.json'
|
|
},
|
|
{
|
|
id: 'wenyan',
|
|
scopeName: 'source.wenyan',
|
|
path: 'wenyan.tmLanguage.json',
|
|
aliases: ['文言']
|
|
},
|
|
{
|
|
id: 'xml',
|
|
scopeName: 'text.xml',
|
|
path: 'xml.tmLanguage.json',
|
|
embeddedLangs: ['java']
|
|
},
|
|
{
|
|
id: 'xsl',
|
|
scopeName: 'text.xml.xsl',
|
|
path: 'xsl.tmLanguage.json',
|
|
embeddedLangs: ['xml']
|
|
},
|
|
{
|
|
id: 'yaml',
|
|
scopeName: 'source.yaml',
|
|
path: 'yaml.tmLanguage.json'
|
|
},
|
|
{
|
|
id: 'zenscript',
|
|
scopeName: 'source.zenscript',
|
|
path: 'zenscript.tmLanguage.json',
|
|
samplePath: 'zenscript.sample'
|
|
}
|
|
];
|
|
|
|
var FontStyle;
|
|
(function (FontStyle) {
|
|
FontStyle[FontStyle["NotSet"] = -1] = "NotSet";
|
|
FontStyle[FontStyle["None"] = 0] = "None";
|
|
FontStyle[FontStyle["Italic"] = 1] = "Italic";
|
|
FontStyle[FontStyle["Bold"] = 2] = "Bold";
|
|
FontStyle[FontStyle["Underline"] = 4] = "Underline";
|
|
})(FontStyle || (FontStyle = {}));
|
|
class StackElementMetadata {
|
|
static toBinaryStr(metadata) {
|
|
let r = metadata.toString(2);
|
|
while (r.length < 32) {
|
|
r = '0' + r;
|
|
}
|
|
return r;
|
|
}
|
|
static printMetadata(metadata) {
|
|
let languageId = StackElementMetadata.getLanguageId(metadata);
|
|
let tokenType = StackElementMetadata.getTokenType(metadata);
|
|
let fontStyle = StackElementMetadata.getFontStyle(metadata);
|
|
let foreground = StackElementMetadata.getForeground(metadata);
|
|
let background = StackElementMetadata.getBackground(metadata);
|
|
console.log({
|
|
languageId: languageId,
|
|
tokenType: tokenType,
|
|
fontStyle: fontStyle,
|
|
foreground: foreground,
|
|
background: background
|
|
});
|
|
}
|
|
static getLanguageId(metadata) {
|
|
return (metadata & 255 /* LANGUAGEID_MASK */) >>> 0 /* LANGUAGEID_OFFSET */;
|
|
}
|
|
static getTokenType(metadata) {
|
|
return (metadata & 1792 /* TOKEN_TYPE_MASK */) >>> 8 /* TOKEN_TYPE_OFFSET */;
|
|
}
|
|
static getFontStyle(metadata) {
|
|
return (metadata & 14336 /* FONT_STYLE_MASK */) >>> 11 /* FONT_STYLE_OFFSET */;
|
|
}
|
|
static getForeground(metadata) {
|
|
return (metadata & 8372224 /* FOREGROUND_MASK */) >>> 14 /* FOREGROUND_OFFSET */;
|
|
}
|
|
static getBackground(metadata) {
|
|
return (metadata & 4286578688 /* BACKGROUND_MASK */) >>> 23 /* BACKGROUND_OFFSET */;
|
|
}
|
|
static set(metadata, languageId, tokenType, fontStyle, foreground, background) {
|
|
let _languageId = StackElementMetadata.getLanguageId(metadata);
|
|
let _tokenType = StackElementMetadata.getTokenType(metadata);
|
|
let _fontStyle = StackElementMetadata.getFontStyle(metadata);
|
|
let _foreground = StackElementMetadata.getForeground(metadata);
|
|
let _background = StackElementMetadata.getBackground(metadata);
|
|
if (languageId !== 0) {
|
|
_languageId = languageId;
|
|
}
|
|
if (tokenType !== 0 /* Other */) {
|
|
_tokenType =
|
|
tokenType === 8 /* MetaEmbedded */ ? 0 /* Other */ : tokenType;
|
|
}
|
|
if (fontStyle !== FontStyle.NotSet) {
|
|
_fontStyle = fontStyle;
|
|
}
|
|
if (foreground !== 0) {
|
|
_foreground = foreground;
|
|
}
|
|
if (background !== 0) {
|
|
_background = background;
|
|
}
|
|
return (((_languageId << 0 /* LANGUAGEID_OFFSET */) |
|
|
(_tokenType << 8 /* TOKEN_TYPE_OFFSET */) |
|
|
(_fontStyle << 11 /* FONT_STYLE_OFFSET */) |
|
|
(_foreground << 14 /* FOREGROUND_OFFSET */) |
|
|
(_background << 23 /* BACKGROUND_OFFSET */)) >>>
|
|
0);
|
|
}
|
|
}
|
|
|
|
function trimEndSlash(str) {
|
|
if (str.endsWith('/') || str.endsWith('\\'))
|
|
return str.slice(0, -1);
|
|
return str;
|
|
}
|
|
function trimStartDot(str) {
|
|
if (str.startsWith('./'))
|
|
return str.slice(2);
|
|
return str;
|
|
}
|
|
function dirname(str) {
|
|
const parts = str.split(/[\/\\]/g);
|
|
return parts[parts.length - 2];
|
|
}
|
|
function join(...parts) {
|
|
return parts.map(trimEndSlash).map(trimStartDot).join('/');
|
|
}
|
|
function groupBy(elements, keyGetter) {
|
|
const map = new Map();
|
|
for (const element of elements) {
|
|
const key = keyGetter(element);
|
|
if (map.has(key)) {
|
|
const group = map.get(key);
|
|
group.push(element);
|
|
}
|
|
else {
|
|
map.set(key, [element]);
|
|
}
|
|
}
|
|
return map;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------------------------
|
|
* Copyright (c) Microsoft Corporation. All rights reserved.
|
|
* Licensed under the MIT License. See License.txt in the project root for license information.
|
|
*--------------------------------------------------------------------------------------------*/
|
|
/**
|
|
* Creates a JSON scanner on the given text.
|
|
* If ignoreTrivia is set, whitespaces or comments are ignored.
|
|
*/
|
|
function createScanner(text, ignoreTrivia) {
|
|
if (ignoreTrivia === void 0) { ignoreTrivia = false; }
|
|
var len = text.length;
|
|
var pos = 0, value = '', tokenOffset = 0, token = 16 /* Unknown */, lineNumber = 0, lineStartOffset = 0, tokenLineStartOffset = 0, prevTokenLineStartOffset = 0, scanError = 0 /* None */;
|
|
function scanHexDigits(count, exact) {
|
|
var digits = 0;
|
|
var value = 0;
|
|
while (digits < count || !exact) {
|
|
var ch = text.charCodeAt(pos);
|
|
if (ch >= 48 /* _0 */ && ch <= 57 /* _9 */) {
|
|
value = value * 16 + ch - 48 /* _0 */;
|
|
}
|
|
else if (ch >= 65 /* A */ && ch <= 70 /* F */) {
|
|
value = value * 16 + ch - 65 /* A */ + 10;
|
|
}
|
|
else if (ch >= 97 /* a */ && ch <= 102 /* f */) {
|
|
value = value * 16 + ch - 97 /* a */ + 10;
|
|
}
|
|
else {
|
|
break;
|
|
}
|
|
pos++;
|
|
digits++;
|
|
}
|
|
if (digits < count) {
|
|
value = -1;
|
|
}
|
|
return value;
|
|
}
|
|
function setPosition(newPosition) {
|
|
pos = newPosition;
|
|
value = '';
|
|
tokenOffset = 0;
|
|
token = 16 /* Unknown */;
|
|
scanError = 0 /* None */;
|
|
}
|
|
function scanNumber() {
|
|
var start = pos;
|
|
if (text.charCodeAt(pos) === 48 /* _0 */) {
|
|
pos++;
|
|
}
|
|
else {
|
|
pos++;
|
|
while (pos < text.length && isDigit(text.charCodeAt(pos))) {
|
|
pos++;
|
|
}
|
|
}
|
|
if (pos < text.length && text.charCodeAt(pos) === 46 /* dot */) {
|
|
pos++;
|
|
if (pos < text.length && isDigit(text.charCodeAt(pos))) {
|
|
pos++;
|
|
while (pos < text.length && isDigit(text.charCodeAt(pos))) {
|
|
pos++;
|
|
}
|
|
}
|
|
else {
|
|
scanError = 3 /* UnexpectedEndOfNumber */;
|
|
return text.substring(start, pos);
|
|
}
|
|
}
|
|
var end = pos;
|
|
if (pos < text.length && (text.charCodeAt(pos) === 69 /* E */ || text.charCodeAt(pos) === 101 /* e */)) {
|
|
pos++;
|
|
if (pos < text.length && text.charCodeAt(pos) === 43 /* plus */ || text.charCodeAt(pos) === 45 /* minus */) {
|
|
pos++;
|
|
}
|
|
if (pos < text.length && isDigit(text.charCodeAt(pos))) {
|
|
pos++;
|
|
while (pos < text.length && isDigit(text.charCodeAt(pos))) {
|
|
pos++;
|
|
}
|
|
end = pos;
|
|
}
|
|
else {
|
|
scanError = 3 /* UnexpectedEndOfNumber */;
|
|
}
|
|
}
|
|
return text.substring(start, end);
|
|
}
|
|
function scanString() {
|
|
var result = '', start = pos;
|
|
while (true) {
|
|
if (pos >= len) {
|
|
result += text.substring(start, pos);
|
|
scanError = 2 /* UnexpectedEndOfString */;
|
|
break;
|
|
}
|
|
var ch = text.charCodeAt(pos);
|
|
if (ch === 34 /* doubleQuote */) {
|
|
result += text.substring(start, pos);
|
|
pos++;
|
|
break;
|
|
}
|
|
if (ch === 92 /* backslash */) {
|
|
result += text.substring(start, pos);
|
|
pos++;
|
|
if (pos >= len) {
|
|
scanError = 2 /* UnexpectedEndOfString */;
|
|
break;
|
|
}
|
|
var ch2 = text.charCodeAt(pos++);
|
|
switch (ch2) {
|
|
case 34 /* doubleQuote */:
|
|
result += '\"';
|
|
break;
|
|
case 92 /* backslash */:
|
|
result += '\\';
|
|
break;
|
|
case 47 /* slash */:
|
|
result += '/';
|
|
break;
|
|
case 98 /* b */:
|
|
result += '\b';
|
|
break;
|
|
case 102 /* f */:
|
|
result += '\f';
|
|
break;
|
|
case 110 /* n */:
|
|
result += '\n';
|
|
break;
|
|
case 114 /* r */:
|
|
result += '\r';
|
|
break;
|
|
case 116 /* t */:
|
|
result += '\t';
|
|
break;
|
|
case 117 /* u */:
|
|
var ch3 = scanHexDigits(4, true);
|
|
if (ch3 >= 0) {
|
|
result += String.fromCharCode(ch3);
|
|
}
|
|
else {
|
|
scanError = 4 /* InvalidUnicode */;
|
|
}
|
|
break;
|
|
default:
|
|
scanError = 5 /* InvalidEscapeCharacter */;
|
|
}
|
|
start = pos;
|
|
continue;
|
|
}
|
|
if (ch >= 0 && ch <= 0x1f) {
|
|
if (isLineBreak(ch)) {
|
|
result += text.substring(start, pos);
|
|
scanError = 2 /* UnexpectedEndOfString */;
|
|
break;
|
|
}
|
|
else {
|
|
scanError = 6 /* InvalidCharacter */;
|
|
// mark as error but continue with string
|
|
}
|
|
}
|
|
pos++;
|
|
}
|
|
return result;
|
|
}
|
|
function scanNext() {
|
|
value = '';
|
|
scanError = 0 /* None */;
|
|
tokenOffset = pos;
|
|
lineStartOffset = lineNumber;
|
|
prevTokenLineStartOffset = tokenLineStartOffset;
|
|
if (pos >= len) {
|
|
// at the end
|
|
tokenOffset = len;
|
|
return token = 17 /* EOF */;
|
|
}
|
|
var code = text.charCodeAt(pos);
|
|
// trivia: whitespace
|
|
if (isWhiteSpace(code)) {
|
|
do {
|
|
pos++;
|
|
value += String.fromCharCode(code);
|
|
code = text.charCodeAt(pos);
|
|
} while (isWhiteSpace(code));
|
|
return token = 15 /* Trivia */;
|
|
}
|
|
// trivia: newlines
|
|
if (isLineBreak(code)) {
|
|
pos++;
|
|
value += String.fromCharCode(code);
|
|
if (code === 13 /* carriageReturn */ && text.charCodeAt(pos) === 10 /* lineFeed */) {
|
|
pos++;
|
|
value += '\n';
|
|
}
|
|
lineNumber++;
|
|
tokenLineStartOffset = pos;
|
|
return token = 14 /* LineBreakTrivia */;
|
|
}
|
|
switch (code) {
|
|
// tokens: []{}:,
|
|
case 123 /* openBrace */:
|
|
pos++;
|
|
return token = 1 /* OpenBraceToken */;
|
|
case 125 /* closeBrace */:
|
|
pos++;
|
|
return token = 2 /* CloseBraceToken */;
|
|
case 91 /* openBracket */:
|
|
pos++;
|
|
return token = 3 /* OpenBracketToken */;
|
|
case 93 /* closeBracket */:
|
|
pos++;
|
|
return token = 4 /* CloseBracketToken */;
|
|
case 58 /* colon */:
|
|
pos++;
|
|
return token = 6 /* ColonToken */;
|
|
case 44 /* comma */:
|
|
pos++;
|
|
return token = 5 /* CommaToken */;
|
|
// strings
|
|
case 34 /* doubleQuote */:
|
|
pos++;
|
|
value = scanString();
|
|
return token = 10 /* StringLiteral */;
|
|
// comments
|
|
case 47 /* slash */:
|
|
var start = pos - 1;
|
|
// Single-line comment
|
|
if (text.charCodeAt(pos + 1) === 47 /* slash */) {
|
|
pos += 2;
|
|
while (pos < len) {
|
|
if (isLineBreak(text.charCodeAt(pos))) {
|
|
break;
|
|
}
|
|
pos++;
|
|
}
|
|
value = text.substring(start, pos);
|
|
return token = 12 /* LineCommentTrivia */;
|
|
}
|
|
// Multi-line comment
|
|
if (text.charCodeAt(pos + 1) === 42 /* asterisk */) {
|
|
pos += 2;
|
|
var safeLength = len - 1; // For lookahead.
|
|
var commentClosed = false;
|
|
while (pos < safeLength) {
|
|
var ch = text.charCodeAt(pos);
|
|
if (ch === 42 /* asterisk */ && text.charCodeAt(pos + 1) === 47 /* slash */) {
|
|
pos += 2;
|
|
commentClosed = true;
|
|
break;
|
|
}
|
|
pos++;
|
|
if (isLineBreak(ch)) {
|
|
if (ch === 13 /* carriageReturn */ && text.charCodeAt(pos) === 10 /* lineFeed */) {
|
|
pos++;
|
|
}
|
|
lineNumber++;
|
|
tokenLineStartOffset = pos;
|
|
}
|
|
}
|
|
if (!commentClosed) {
|
|
pos++;
|
|
scanError = 1 /* UnexpectedEndOfComment */;
|
|
}
|
|
value = text.substring(start, pos);
|
|
return token = 13 /* BlockCommentTrivia */;
|
|
}
|
|
// just a single slash
|
|
value += String.fromCharCode(code);
|
|
pos++;
|
|
return token = 16 /* Unknown */;
|
|
// numbers
|
|
case 45 /* minus */:
|
|
value += String.fromCharCode(code);
|
|
pos++;
|
|
if (pos === len || !isDigit(text.charCodeAt(pos))) {
|
|
return token = 16 /* Unknown */;
|
|
}
|
|
// found a minus, followed by a number so
|
|
// we fall through to proceed with scanning
|
|
// numbers
|
|
case 48 /* _0 */:
|
|
case 49 /* _1 */:
|
|
case 50 /* _2 */:
|
|
case 51 /* _3 */:
|
|
case 52 /* _4 */:
|
|
case 53 /* _5 */:
|
|
case 54 /* _6 */:
|
|
case 55 /* _7 */:
|
|
case 56 /* _8 */:
|
|
case 57 /* _9 */:
|
|
value += scanNumber();
|
|
return token = 11 /* NumericLiteral */;
|
|
// literals and unknown symbols
|
|
default:
|
|
// is a literal? Read the full word.
|
|
while (pos < len && isUnknownContentCharacter(code)) {
|
|
pos++;
|
|
code = text.charCodeAt(pos);
|
|
}
|
|
if (tokenOffset !== pos) {
|
|
value = text.substring(tokenOffset, pos);
|
|
// keywords: true, false, null
|
|
switch (value) {
|
|
case 'true': return token = 8 /* TrueKeyword */;
|
|
case 'false': return token = 9 /* FalseKeyword */;
|
|
case 'null': return token = 7 /* NullKeyword */;
|
|
}
|
|
return token = 16 /* Unknown */;
|
|
}
|
|
// some
|
|
value += String.fromCharCode(code);
|
|
pos++;
|
|
return token = 16 /* Unknown */;
|
|
}
|
|
}
|
|
function isUnknownContentCharacter(code) {
|
|
if (isWhiteSpace(code) || isLineBreak(code)) {
|
|
return false;
|
|
}
|
|
switch (code) {
|
|
case 125 /* closeBrace */:
|
|
case 93 /* closeBracket */:
|
|
case 123 /* openBrace */:
|
|
case 91 /* openBracket */:
|
|
case 34 /* doubleQuote */:
|
|
case 58 /* colon */:
|
|
case 44 /* comma */:
|
|
case 47 /* slash */:
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
function scanNextNonTrivia() {
|
|
var result;
|
|
do {
|
|
result = scanNext();
|
|
} while (result >= 12 /* LineCommentTrivia */ && result <= 15 /* Trivia */);
|
|
return result;
|
|
}
|
|
return {
|
|
setPosition: setPosition,
|
|
getPosition: function () { return pos; },
|
|
scan: ignoreTrivia ? scanNextNonTrivia : scanNext,
|
|
getToken: function () { return token; },
|
|
getTokenValue: function () { return value; },
|
|
getTokenOffset: function () { return tokenOffset; },
|
|
getTokenLength: function () { return pos - tokenOffset; },
|
|
getTokenStartLine: function () { return lineStartOffset; },
|
|
getTokenStartCharacter: function () { return tokenOffset - prevTokenLineStartOffset; },
|
|
getTokenError: function () { return scanError; },
|
|
};
|
|
}
|
|
function isWhiteSpace(ch) {
|
|
return ch === 32 /* space */ || ch === 9 /* tab */ || ch === 11 /* verticalTab */ || ch === 12 /* formFeed */ ||
|
|
ch === 160 /* nonBreakingSpace */ || ch === 5760 /* ogham */ || ch >= 8192 /* enQuad */ && ch <= 8203 /* zeroWidthSpace */ ||
|
|
ch === 8239 /* narrowNoBreakSpace */ || ch === 8287 /* mathematicalSpace */ || ch === 12288 /* ideographicSpace */ || ch === 65279 /* byteOrderMark */;
|
|
}
|
|
function isLineBreak(ch) {
|
|
return ch === 10 /* lineFeed */ || ch === 13 /* carriageReturn */ || ch === 8232 /* lineSeparator */ || ch === 8233 /* paragraphSeparator */;
|
|
}
|
|
function isDigit(ch) {
|
|
return ch >= 48 /* _0 */ && ch <= 57 /* _9 */;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------------------------
|
|
* Copyright (c) Microsoft Corporation. All rights reserved.
|
|
* Licensed under the MIT License. See License.txt in the project root for license information.
|
|
*--------------------------------------------------------------------------------------------*/
|
|
var ParseOptions;
|
|
(function (ParseOptions) {
|
|
ParseOptions.DEFAULT = {
|
|
allowTrailingComma: false
|
|
};
|
|
})(ParseOptions || (ParseOptions = {}));
|
|
/**
|
|
* Parses the given text and returns the object the JSON content represents. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.
|
|
* Therefore always check the errors list to find out if the input was valid.
|
|
*/
|
|
function parse$1(text, errors, options) {
|
|
if (errors === void 0) { errors = []; }
|
|
if (options === void 0) { options = ParseOptions.DEFAULT; }
|
|
var currentProperty = null;
|
|
var currentParent = [];
|
|
var previousParents = [];
|
|
function onValue(value) {
|
|
if (Array.isArray(currentParent)) {
|
|
currentParent.push(value);
|
|
}
|
|
else if (currentProperty !== null) {
|
|
currentParent[currentProperty] = value;
|
|
}
|
|
}
|
|
var visitor = {
|
|
onObjectBegin: function () {
|
|
var object = {};
|
|
onValue(object);
|
|
previousParents.push(currentParent);
|
|
currentParent = object;
|
|
currentProperty = null;
|
|
},
|
|
onObjectProperty: function (name) {
|
|
currentProperty = name;
|
|
},
|
|
onObjectEnd: function () {
|
|
currentParent = previousParents.pop();
|
|
},
|
|
onArrayBegin: function () {
|
|
var array = [];
|
|
onValue(array);
|
|
previousParents.push(currentParent);
|
|
currentParent = array;
|
|
currentProperty = null;
|
|
},
|
|
onArrayEnd: function () {
|
|
currentParent = previousParents.pop();
|
|
},
|
|
onLiteralValue: onValue,
|
|
onError: function (error, offset, length) {
|
|
errors.push({ error: error, offset: offset, length: length });
|
|
}
|
|
};
|
|
visit(text, visitor, options);
|
|
return currentParent[0];
|
|
}
|
|
/**
|
|
* Parses the given text and invokes the visitor functions for each object, array and literal reached.
|
|
*/
|
|
function visit(text, visitor, options) {
|
|
if (options === void 0) { options = ParseOptions.DEFAULT; }
|
|
var _scanner = createScanner(text, false);
|
|
function toNoArgVisit(visitFunction) {
|
|
return visitFunction ? function () { return visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()); } : function () { return true; };
|
|
}
|
|
function toOneArgVisit(visitFunction) {
|
|
return visitFunction ? function (arg) { return visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()); } : function () { return true; };
|
|
}
|
|
var onObjectBegin = toNoArgVisit(visitor.onObjectBegin), onObjectProperty = toOneArgVisit(visitor.onObjectProperty), onObjectEnd = toNoArgVisit(visitor.onObjectEnd), onArrayBegin = toNoArgVisit(visitor.onArrayBegin), onArrayEnd = toNoArgVisit(visitor.onArrayEnd), onLiteralValue = toOneArgVisit(visitor.onLiteralValue), onSeparator = toOneArgVisit(visitor.onSeparator), onComment = toNoArgVisit(visitor.onComment), onError = toOneArgVisit(visitor.onError);
|
|
var disallowComments = options && options.disallowComments;
|
|
var allowTrailingComma = options && options.allowTrailingComma;
|
|
function scanNext() {
|
|
while (true) {
|
|
var token = _scanner.scan();
|
|
switch (_scanner.getTokenError()) {
|
|
case 4 /* InvalidUnicode */:
|
|
handleError(14 /* InvalidUnicode */);
|
|
break;
|
|
case 5 /* InvalidEscapeCharacter */:
|
|
handleError(15 /* InvalidEscapeCharacter */);
|
|
break;
|
|
case 3 /* UnexpectedEndOfNumber */:
|
|
handleError(13 /* UnexpectedEndOfNumber */);
|
|
break;
|
|
case 1 /* UnexpectedEndOfComment */:
|
|
if (!disallowComments) {
|
|
handleError(11 /* UnexpectedEndOfComment */);
|
|
}
|
|
break;
|
|
case 2 /* UnexpectedEndOfString */:
|
|
handleError(12 /* UnexpectedEndOfString */);
|
|
break;
|
|
case 6 /* InvalidCharacter */:
|
|
handleError(16 /* InvalidCharacter */);
|
|
break;
|
|
}
|
|
switch (token) {
|
|
case 12 /* LineCommentTrivia */:
|
|
case 13 /* BlockCommentTrivia */:
|
|
if (disallowComments) {
|
|
handleError(10 /* InvalidCommentToken */);
|
|
}
|
|
else {
|
|
onComment();
|
|
}
|
|
break;
|
|
case 16 /* Unknown */:
|
|
handleError(1 /* InvalidSymbol */);
|
|
break;
|
|
case 15 /* Trivia */:
|
|
case 14 /* LineBreakTrivia */:
|
|
break;
|
|
default:
|
|
return token;
|
|
}
|
|
}
|
|
}
|
|
function handleError(error, skipUntilAfter, skipUntil) {
|
|
if (skipUntilAfter === void 0) { skipUntilAfter = []; }
|
|
if (skipUntil === void 0) { skipUntil = []; }
|
|
onError(error);
|
|
if (skipUntilAfter.length + skipUntil.length > 0) {
|
|
var token = _scanner.getToken();
|
|
while (token !== 17 /* EOF */) {
|
|
if (skipUntilAfter.indexOf(token) !== -1) {
|
|
scanNext();
|
|
break;
|
|
}
|
|
else if (skipUntil.indexOf(token) !== -1) {
|
|
break;
|
|
}
|
|
token = scanNext();
|
|
}
|
|
}
|
|
}
|
|
function parseString(isValue) {
|
|
var value = _scanner.getTokenValue();
|
|
if (isValue) {
|
|
onLiteralValue(value);
|
|
}
|
|
else {
|
|
onObjectProperty(value);
|
|
}
|
|
scanNext();
|
|
return true;
|
|
}
|
|
function parseLiteral() {
|
|
switch (_scanner.getToken()) {
|
|
case 11 /* NumericLiteral */:
|
|
var tokenValue = _scanner.getTokenValue();
|
|
var value = Number(tokenValue);
|
|
if (isNaN(value)) {
|
|
handleError(2 /* InvalidNumberFormat */);
|
|
value = 0;
|
|
}
|
|
onLiteralValue(value);
|
|
break;
|
|
case 7 /* NullKeyword */:
|
|
onLiteralValue(null);
|
|
break;
|
|
case 8 /* TrueKeyword */:
|
|
onLiteralValue(true);
|
|
break;
|
|
case 9 /* FalseKeyword */:
|
|
onLiteralValue(false);
|
|
break;
|
|
default:
|
|
return false;
|
|
}
|
|
scanNext();
|
|
return true;
|
|
}
|
|
function parseProperty() {
|
|
if (_scanner.getToken() !== 10 /* StringLiteral */) {
|
|
handleError(3 /* PropertyNameExpected */, [], [2 /* CloseBraceToken */, 5 /* CommaToken */]);
|
|
return false;
|
|
}
|
|
parseString(false);
|
|
if (_scanner.getToken() === 6 /* ColonToken */) {
|
|
onSeparator(':');
|
|
scanNext(); // consume colon
|
|
if (!parseValue()) {
|
|
handleError(4 /* ValueExpected */, [], [2 /* CloseBraceToken */, 5 /* CommaToken */]);
|
|
}
|
|
}
|
|
else {
|
|
handleError(5 /* ColonExpected */, [], [2 /* CloseBraceToken */, 5 /* CommaToken */]);
|
|
}
|
|
return true;
|
|
}
|
|
function parseObject() {
|
|
onObjectBegin();
|
|
scanNext(); // consume open brace
|
|
var needsComma = false;
|
|
while (_scanner.getToken() !== 2 /* CloseBraceToken */ && _scanner.getToken() !== 17 /* EOF */) {
|
|
if (_scanner.getToken() === 5 /* CommaToken */) {
|
|
if (!needsComma) {
|
|
handleError(4 /* ValueExpected */, [], []);
|
|
}
|
|
onSeparator(',');
|
|
scanNext(); // consume comma
|
|
if (_scanner.getToken() === 2 /* CloseBraceToken */ && allowTrailingComma) {
|
|
break;
|
|
}
|
|
}
|
|
else if (needsComma) {
|
|
handleError(6 /* CommaExpected */, [], []);
|
|
}
|
|
if (!parseProperty()) {
|
|
handleError(4 /* ValueExpected */, [], [2 /* CloseBraceToken */, 5 /* CommaToken */]);
|
|
}
|
|
needsComma = true;
|
|
}
|
|
onObjectEnd();
|
|
if (_scanner.getToken() !== 2 /* CloseBraceToken */) {
|
|
handleError(7 /* CloseBraceExpected */, [2 /* CloseBraceToken */], []);
|
|
}
|
|
else {
|
|
scanNext(); // consume close brace
|
|
}
|
|
return true;
|
|
}
|
|
function parseArray() {
|
|
onArrayBegin();
|
|
scanNext(); // consume open bracket
|
|
var needsComma = false;
|
|
while (_scanner.getToken() !== 4 /* CloseBracketToken */ && _scanner.getToken() !== 17 /* EOF */) {
|
|
if (_scanner.getToken() === 5 /* CommaToken */) {
|
|
if (!needsComma) {
|
|
handleError(4 /* ValueExpected */, [], []);
|
|
}
|
|
onSeparator(',');
|
|
scanNext(); // consume comma
|
|
if (_scanner.getToken() === 4 /* CloseBracketToken */ && allowTrailingComma) {
|
|
break;
|
|
}
|
|
}
|
|
else if (needsComma) {
|
|
handleError(6 /* CommaExpected */, [], []);
|
|
}
|
|
if (!parseValue()) {
|
|
handleError(4 /* ValueExpected */, [], [4 /* CloseBracketToken */, 5 /* CommaToken */]);
|
|
}
|
|
needsComma = true;
|
|
}
|
|
onArrayEnd();
|
|
if (_scanner.getToken() !== 4 /* CloseBracketToken */) {
|
|
handleError(8 /* CloseBracketExpected */, [4 /* CloseBracketToken */], []);
|
|
}
|
|
else {
|
|
scanNext(); // consume close bracket
|
|
}
|
|
return true;
|
|
}
|
|
function parseValue() {
|
|
switch (_scanner.getToken()) {
|
|
case 3 /* OpenBracketToken */:
|
|
return parseArray();
|
|
case 1 /* OpenBraceToken */:
|
|
return parseObject();
|
|
case 10 /* StringLiteral */:
|
|
return parseString(true);
|
|
default:
|
|
return parseLiteral();
|
|
}
|
|
}
|
|
scanNext();
|
|
if (_scanner.getToken() === 17 /* EOF */) {
|
|
if (options.allowEmptyContent) {
|
|
return true;
|
|
}
|
|
handleError(4 /* ValueExpected */, [], []);
|
|
return false;
|
|
}
|
|
if (!parseValue()) {
|
|
handleError(4 /* ValueExpected */, [], []);
|
|
return false;
|
|
}
|
|
if (_scanner.getToken() !== 17 /* EOF */) {
|
|
handleError(9 /* EndOfFileExpected */, [], []);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------------------------
|
|
* Copyright (c) Microsoft Corporation. All rights reserved.
|
|
* Licensed under the MIT License. See License.txt in the project root for license information.
|
|
*--------------------------------------------------------------------------------------------*/
|
|
/**
|
|
* Parses the given text and returns the object the JSON content represents. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.
|
|
* Therefore, always check the errors list to find out if the input was valid.
|
|
*/
|
|
var parse = parse$1;
|
|
|
|
const isWebWorker = typeof self !== 'undefined' && typeof self.WorkerGlobalScope !== 'undefined';
|
|
const isBrowser = isWebWorker ||
|
|
(typeof window !== 'undefined' &&
|
|
typeof window.document !== 'undefined' &&
|
|
typeof fetch !== 'undefined');
|
|
// to be replaced by rollup
|
|
let CDN_ROOT = '';
|
|
let WASM = '';
|
|
/**
|
|
* Set the route for loading the assets
|
|
* URL should end with `/`
|
|
*
|
|
* For example:
|
|
* ```ts
|
|
* setCDN('https://unpkg.com/shiki/') // use unpkg
|
|
* setCDN('/assets/shiki/') // serve by yourself
|
|
* ```
|
|
*/
|
|
function setCDN(root) {
|
|
CDN_ROOT = root;
|
|
}
|
|
/**
|
|
* Explicitly set the source for loading the oniguruma web assembly module.
|
|
*
|
|
* Accepts Url or ArrayBuffer
|
|
*/
|
|
function setWasm(path) {
|
|
WASM = path;
|
|
}
|
|
let _onigurumaPromise = null;
|
|
async function getOniguruma() {
|
|
if (!_onigurumaPromise) {
|
|
let loader;
|
|
if (isBrowser) {
|
|
if (typeof WASM === 'string') {
|
|
loader = loadWASM({
|
|
data: await fetch(_resolvePath('dist/onig.wasm')).then(r => r.arrayBuffer())
|
|
});
|
|
}
|
|
else {
|
|
loader = loadWASM(WASM);
|
|
}
|
|
}
|
|
else {
|
|
const path = require('path');
|
|
const wasmPath = path.join(require.resolve('vscode-oniguruma'), '../onig.wasm');
|
|
const fs = require('fs');
|
|
const wasmBin = fs.readFileSync(wasmPath).buffer;
|
|
loader = loadWASM(wasmBin);
|
|
}
|
|
_onigurumaPromise = loader.then(() => {
|
|
return {
|
|
createOnigScanner(patterns) {
|
|
return createOnigScanner(patterns);
|
|
},
|
|
createOnigString(s) {
|
|
return createOnigString(s);
|
|
}
|
|
};
|
|
});
|
|
}
|
|
return _onigurumaPromise;
|
|
}
|
|
function _resolvePath(filepath) {
|
|
if (isBrowser) {
|
|
if (!CDN_ROOT) {
|
|
console.warn('[Shiki] no CDN provider found, use `setCDN()` to specify the CDN for loading the resources before calling `getHighlighter()`');
|
|
}
|
|
return `${CDN_ROOT}${filepath}`;
|
|
}
|
|
else {
|
|
const path = require('path');
|
|
if (path.isAbsolute(filepath)) {
|
|
return filepath;
|
|
}
|
|
else {
|
|
return path.resolve(__dirname, '..', filepath);
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* @param filepath assert path related to ./packages/shiki
|
|
*/
|
|
async function _fetchAssets(filepath) {
|
|
const path = _resolvePath(filepath);
|
|
if (isBrowser) {
|
|
return await fetch(path).then(r => r.text());
|
|
}
|
|
else {
|
|
const fs = require('fs');
|
|
return await fs.promises.readFile(path, 'utf-8');
|
|
}
|
|
}
|
|
async function _fetchJSONAssets(filepath) {
|
|
const errors = [];
|
|
const rawTheme = parse(await _fetchAssets(filepath), errors, {
|
|
allowTrailingComma: true
|
|
});
|
|
if (errors.length) {
|
|
throw errors[0];
|
|
}
|
|
return rawTheme;
|
|
}
|
|
/**
|
|
* @param themePath related path to theme.json
|
|
*/
|
|
async function fetchTheme(themePath) {
|
|
let theme = await _fetchJSONAssets(themePath);
|
|
const shikiTheme = toShikiTheme(theme);
|
|
if (shikiTheme.include) {
|
|
const includedTheme = await fetchTheme(join(dirname(themePath), shikiTheme.include));
|
|
if (includedTheme.settings) {
|
|
shikiTheme.settings = includedTheme.settings.concat(shikiTheme.settings);
|
|
}
|
|
if (includedTheme.bg && !shikiTheme.bg) {
|
|
shikiTheme.bg = includedTheme.bg;
|
|
}
|
|
if (includedTheme.colors) {
|
|
shikiTheme.colors = Object.assign(Object.assign({}, includedTheme.colors), shikiTheme.colors);
|
|
}
|
|
delete shikiTheme.include;
|
|
}
|
|
return shikiTheme;
|
|
}
|
|
async function fetchGrammar(filepath) {
|
|
return await _fetchJSONAssets(filepath);
|
|
}
|
|
function repairTheme(theme) {
|
|
// Has the default no-scope setting with fallback colors
|
|
if (!theme.settings)
|
|
theme.settings = [];
|
|
if (theme.settings[0] && theme.settings[0].settings && !theme.settings[0].scope) {
|
|
return;
|
|
}
|
|
// Push a no-scope setting with fallback colors
|
|
theme.settings.unshift({
|
|
settings: {
|
|
foreground: theme.fg,
|
|
background: theme.bg
|
|
}
|
|
});
|
|
}
|
|
function toShikiTheme(rawTheme) {
|
|
const type = rawTheme.type || 'dark';
|
|
const shikiTheme = Object.assign(Object.assign({ name: rawTheme.name, type }, rawTheme), getThemeDefaultColors(rawTheme));
|
|
if (rawTheme.include) {
|
|
shikiTheme.include = rawTheme.include;
|
|
}
|
|
if (rawTheme.tokenColors) {
|
|
shikiTheme.settings = rawTheme.tokenColors;
|
|
delete shikiTheme.tokenColors;
|
|
}
|
|
repairTheme(shikiTheme);
|
|
return shikiTheme;
|
|
}
|
|
/**
|
|
* https://github.com/microsoft/vscode/blob/f7f05dee53fb33fe023db2e06e30a89d3094488f/src/vs/platform/theme/common/colorRegistry.ts#L258-L268
|
|
*/
|
|
const VSCODE_FALLBACK_EDITOR_FG = { light: '#333333', dark: '#bbbbbb' };
|
|
const VSCODE_FALLBACK_EDITOR_BG = { light: '#fffffe', dark: '#1e1e1e' };
|
|
function getThemeDefaultColors(theme) {
|
|
var _a, _b, _c, _d, _e, _f;
|
|
let fg, bg;
|
|
/**
|
|
* First try:
|
|
* Theme might contain a global `tokenColor` without `name` or `scope`
|
|
* Used as default value for foreground/background
|
|
*/
|
|
let settings = theme.settings ? theme.settings : theme.tokenColors;
|
|
const globalSetting = settings
|
|
? settings.find(s => {
|
|
return !s.name && !s.scope;
|
|
})
|
|
: undefined;
|
|
if ((_a = globalSetting === null || globalSetting === void 0 ? void 0 : globalSetting.settings) === null || _a === void 0 ? void 0 : _a.foreground) {
|
|
fg = globalSetting.settings.foreground;
|
|
}
|
|
if ((_b = globalSetting === null || globalSetting === void 0 ? void 0 : globalSetting.settings) === null || _b === void 0 ? void 0 : _b.background) {
|
|
bg = globalSetting.settings.background;
|
|
}
|
|
/**
|
|
* Second try:
|
|
* If there's no global `tokenColor` without `name` or `scope`
|
|
* Use `editor.foreground` and `editor.background`
|
|
*/
|
|
if (!fg && ((_d = (_c = theme) === null || _c === void 0 ? void 0 : _c.colors) === null || _d === void 0 ? void 0 : _d['editor.foreground'])) {
|
|
fg = theme.colors['editor.foreground'];
|
|
}
|
|
if (!bg && ((_f = (_e = theme) === null || _e === void 0 ? void 0 : _e.colors) === null || _f === void 0 ? void 0 : _f['editor.background'])) {
|
|
bg = theme.colors['editor.background'];
|
|
}
|
|
/**
|
|
* Last try:
|
|
* If there's no fg/bg color specified in theme, use default
|
|
*/
|
|
if (!fg) {
|
|
fg = theme.type === 'light' ? VSCODE_FALLBACK_EDITOR_FG.light : VSCODE_FALLBACK_EDITOR_FG.dark;
|
|
}
|
|
if (!bg) {
|
|
bg = theme.type === 'light' ? VSCODE_FALLBACK_EDITOR_BG.light : VSCODE_FALLBACK_EDITOR_BG.dark;
|
|
}
|
|
return {
|
|
fg,
|
|
bg
|
|
};
|
|
}
|
|
|
|
/*---------------------------------------------------------
|
|
* Copyright (C) Microsoft Corporation. All rights reserved.
|
|
*--------------------------------------------------------*/
|
|
class Resolver {
|
|
constructor(onigLibPromise, onigLibName) {
|
|
this.languagesPath = 'languages/';
|
|
this.languageMap = {};
|
|
this.scopeToLangMap = {};
|
|
this._onigLibPromise = onigLibPromise;
|
|
this._onigLibName = onigLibName;
|
|
}
|
|
get onigLib() {
|
|
return this._onigLibPromise;
|
|
}
|
|
getOnigLibName() {
|
|
return this._onigLibName;
|
|
}
|
|
getLangRegistration(langIdOrAlias) {
|
|
return this.languageMap[langIdOrAlias];
|
|
}
|
|
async loadGrammar(scopeName) {
|
|
const lang = this.scopeToLangMap[scopeName];
|
|
if (!lang) {
|
|
return null;
|
|
}
|
|
if (lang.grammar) {
|
|
return lang.grammar;
|
|
}
|
|
const g = await fetchGrammar(languages.includes(lang) ? `${this.languagesPath}${lang.path}` : lang.path);
|
|
lang.grammar = g;
|
|
return g;
|
|
}
|
|
addLanguage(l) {
|
|
this.languageMap[l.id] = l;
|
|
if (l.aliases) {
|
|
l.aliases.forEach(a => {
|
|
this.languageMap[a] = l;
|
|
});
|
|
}
|
|
this.scopeToLangMap[l.scopeName] = l;
|
|
}
|
|
}
|
|
|
|
/*---------------------------------------------------------
|
|
* Copyright (C) Microsoft Corporation. All rights reserved.
|
|
*--------------------------------------------------------*/
|
|
function tokenizeWithTheme(theme, colorMap, fileContents, grammar, options) {
|
|
let lines = fileContents.split(/\r\n|\r|\n/);
|
|
let ruleStack = INITIAL;
|
|
let actual = [];
|
|
let final = [];
|
|
for (let i = 0, len = lines.length; i < len; i++) {
|
|
let line = lines[i];
|
|
if (line === '') {
|
|
actual = [];
|
|
final.push([]);
|
|
continue;
|
|
}
|
|
let resultWithScopes;
|
|
let tokensWithScopes;
|
|
let tokensWithScopesIndex;
|
|
if (options.includeExplanation) {
|
|
resultWithScopes = grammar.tokenizeLine(line, ruleStack);
|
|
tokensWithScopes = resultWithScopes.tokens;
|
|
tokensWithScopesIndex = 0;
|
|
}
|
|
let result = grammar.tokenizeLine2(line, ruleStack);
|
|
let tokensLength = result.tokens.length / 2;
|
|
for (let j = 0; j < tokensLength; j++) {
|
|
let startIndex = result.tokens[2 * j];
|
|
let nextStartIndex = j + 1 < tokensLength ? result.tokens[2 * j + 2] : line.length;
|
|
if (startIndex === nextStartIndex) {
|
|
continue;
|
|
}
|
|
let metadata = result.tokens[2 * j + 1];
|
|
let foreground = StackElementMetadata.getForeground(metadata);
|
|
let foregroundColor = colorMap[foreground];
|
|
let fontStyle = StackElementMetadata.getFontStyle(metadata);
|
|
let explanation = [];
|
|
if (options.includeExplanation) {
|
|
let offset = 0;
|
|
while (startIndex + offset < nextStartIndex) {
|
|
let tokenWithScopes = tokensWithScopes[tokensWithScopesIndex];
|
|
let tokenWithScopesText = line.substring(tokenWithScopes.startIndex, tokenWithScopes.endIndex);
|
|
offset += tokenWithScopesText.length;
|
|
explanation.push({
|
|
content: tokenWithScopesText,
|
|
scopes: explainThemeScopes(theme, tokenWithScopes.scopes)
|
|
});
|
|
tokensWithScopesIndex++;
|
|
}
|
|
}
|
|
actual.push({
|
|
content: line.substring(startIndex, nextStartIndex),
|
|
color: foregroundColor,
|
|
fontStyle,
|
|
explanation: explanation
|
|
});
|
|
}
|
|
final.push(actual);
|
|
actual = [];
|
|
ruleStack = result.ruleStack;
|
|
}
|
|
return final;
|
|
}
|
|
function explainThemeScopes(theme, scopes) {
|
|
let result = [];
|
|
for (let i = 0, len = scopes.length; i < len; i++) {
|
|
let parentScopes = scopes.slice(0, i);
|
|
let scope = scopes[i];
|
|
result[i] = {
|
|
scopeName: scope,
|
|
themeMatches: explainThemeScope(theme, scope, parentScopes)
|
|
};
|
|
}
|
|
return result;
|
|
}
|
|
function matchesOne(selector, scope) {
|
|
let selectorPrefix = selector + '.';
|
|
if (selector === scope || scope.substring(0, selectorPrefix.length) === selectorPrefix) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function matches(selector, selectorParentScopes, scope, parentScopes) {
|
|
if (!matchesOne(selector, scope)) {
|
|
return false;
|
|
}
|
|
let selectorParentIndex = selectorParentScopes.length - 1;
|
|
let parentIndex = parentScopes.length - 1;
|
|
while (selectorParentIndex >= 0 && parentIndex >= 0) {
|
|
if (matchesOne(selectorParentScopes[selectorParentIndex], parentScopes[parentIndex])) {
|
|
selectorParentIndex--;
|
|
}
|
|
parentIndex--;
|
|
}
|
|
if (selectorParentIndex === -1) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function explainThemeScope(theme, scope, parentScopes) {
|
|
let result = [], resultLen = 0;
|
|
for (let i = 0, len = theme.settings.length; i < len; i++) {
|
|
let setting = theme.settings[i];
|
|
let selectors;
|
|
if (typeof setting.scope === 'string') {
|
|
selectors = setting.scope.split(/,/).map(scope => scope.trim());
|
|
}
|
|
else if (Array.isArray(setting.scope)) {
|
|
selectors = setting.scope;
|
|
}
|
|
else {
|
|
continue;
|
|
}
|
|
for (let j = 0, lenJ = selectors.length; j < lenJ; j++) {
|
|
let rawSelector = selectors[j];
|
|
let rawSelectorPieces = rawSelector.split(/ /);
|
|
let selector = rawSelectorPieces[rawSelectorPieces.length - 1];
|
|
let selectorParentScopes = rawSelectorPieces.slice(0, rawSelectorPieces.length - 1);
|
|
if (matches(selector, selectorParentScopes, scope, parentScopes)) {
|
|
// match!
|
|
result[resultLen++] = setting;
|
|
// break the loop
|
|
j = lenJ;
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
function renderToHtml(lines, options = {}) {
|
|
var _a;
|
|
const bg = options.bg || '#fff';
|
|
const optionsByLineNumber = groupBy((_a = options.lineOptions) !== null && _a !== void 0 ? _a : [], option => option.line);
|
|
let html = '';
|
|
html += `<pre class="shiki" style="background-color: ${bg}">`;
|
|
if (options.langId) {
|
|
html += `<div class="language-id">${options.langId}</div>`;
|
|
}
|
|
html += `<code>`;
|
|
lines.forEach((l, lineIndex) => {
|
|
var _a;
|
|
const lineNumber = lineIndex + 1;
|
|
const lineOptions = (_a = optionsByLineNumber.get(lineNumber)) !== null && _a !== void 0 ? _a : [];
|
|
const lineClasses = getLineClasses(lineOptions).join(' ');
|
|
html += `<span class="${lineClasses}">`;
|
|
l.forEach(token => {
|
|
const cssDeclarations = [`color: ${token.color || options.fg}`];
|
|
if (token.fontStyle & FontStyle.Italic) {
|
|
cssDeclarations.push('font-style: italic');
|
|
}
|
|
if (token.fontStyle & FontStyle.Bold) {
|
|
cssDeclarations.push('font-weight: bold');
|
|
}
|
|
if (token.fontStyle & FontStyle.Underline) {
|
|
cssDeclarations.push('text-decoration: underline');
|
|
}
|
|
html += `<span style="${cssDeclarations.join('; ')}">${escapeHtml(token.content)}</span>`;
|
|
});
|
|
html += `</span>\n`;
|
|
});
|
|
html = html.replace(/\n*$/, ''); // Get rid of final new lines
|
|
html += `</code></pre>`;
|
|
return html;
|
|
}
|
|
const htmlEscapes = {
|
|
'&': '&',
|
|
'<': '<',
|
|
'>': '>',
|
|
'"': '"',
|
|
"'": '''
|
|
};
|
|
function escapeHtml(html) {
|
|
return html.replace(/[&<>"']/g, chr => htmlEscapes[chr]);
|
|
}
|
|
function getLineClasses(lineOptions) {
|
|
var _a;
|
|
const lineClasses = new Set(['line']);
|
|
for (const lineOption of lineOptions) {
|
|
for (const lineClass of (_a = lineOption.classes) !== null && _a !== void 0 ? _a : []) {
|
|
lineClasses.add(lineClass);
|
|
}
|
|
}
|
|
return Array.from(lineClasses);
|
|
}
|
|
|
|
class Registry extends Registry$1 {
|
|
constructor(_resolver) {
|
|
super(_resolver);
|
|
this._resolver = _resolver;
|
|
this.themesPath = 'themes/';
|
|
this._resolvedThemes = {};
|
|
this._resolvedGrammars = {};
|
|
}
|
|
getTheme(theme) {
|
|
if (typeof theme === 'string') {
|
|
return this._resolvedThemes[theme];
|
|
}
|
|
else {
|
|
return theme;
|
|
}
|
|
}
|
|
async loadTheme(theme) {
|
|
if (typeof theme === 'string') {
|
|
if (!this._resolvedThemes[theme]) {
|
|
this._resolvedThemes[theme] = await fetchTheme(`${this.themesPath}${theme}.json`);
|
|
}
|
|
return this._resolvedThemes[theme];
|
|
}
|
|
else {
|
|
theme = toShikiTheme(theme);
|
|
if (theme.name) {
|
|
this._resolvedThemes[theme.name] = theme;
|
|
}
|
|
return theme;
|
|
}
|
|
}
|
|
async loadThemes(themes) {
|
|
return await Promise.all(themes.map(theme => this.loadTheme(theme)));
|
|
}
|
|
getLoadedThemes() {
|
|
return Object.keys(this._resolvedThemes);
|
|
}
|
|
getGrammar(name) {
|
|
return this._resolvedGrammars[name];
|
|
}
|
|
async loadLanguage(lang) {
|
|
const g = await this.loadGrammar(lang.scopeName);
|
|
this._resolvedGrammars[lang.id] = g;
|
|
if (lang.aliases) {
|
|
lang.aliases.forEach(la => {
|
|
this._resolvedGrammars[la] = g;
|
|
});
|
|
}
|
|
}
|
|
async loadLanguages(langs) {
|
|
for (const lang of langs) {
|
|
this._resolver.addLanguage(lang);
|
|
}
|
|
for (const lang of langs) {
|
|
await this.loadLanguage(lang);
|
|
}
|
|
}
|
|
getLoadedLanguages() {
|
|
return Object.keys(this._resolvedGrammars);
|
|
}
|
|
}
|
|
|
|
function resolveLang(lang) {
|
|
return typeof lang === 'string'
|
|
? languages.find(l => { var _a; return l.id === lang || ((_a = l.aliases) === null || _a === void 0 ? void 0 : _a.includes(lang)); })
|
|
: lang;
|
|
}
|
|
function resolveOptions(options) {
|
|
var _a;
|
|
let _languages = languages;
|
|
let _themes = options.themes || [];
|
|
if ((_a = options.langs) === null || _a === void 0 ? void 0 : _a.length) {
|
|
_languages = options.langs.map(resolveLang);
|
|
}
|
|
if (options.theme) {
|
|
_themes.unshift(options.theme);
|
|
}
|
|
if (!_themes.length) {
|
|
_themes = ['nord'];
|
|
}
|
|
return { _languages, _themes };
|
|
}
|
|
async function getHighlighter(options) {
|
|
var _a, _b;
|
|
const { _languages, _themes } = resolveOptions(options);
|
|
const _resolver = new Resolver(getOniguruma(), 'vscode-oniguruma');
|
|
const _registry = new Registry(_resolver);
|
|
if ((_a = options.paths) === null || _a === void 0 ? void 0 : _a.themes) {
|
|
_registry.themesPath = options.paths.themes;
|
|
}
|
|
if ((_b = options.paths) === null || _b === void 0 ? void 0 : _b.languages) {
|
|
_resolver.languagesPath = options.paths.languages;
|
|
}
|
|
const themes = await _registry.loadThemes(_themes);
|
|
const _defaultTheme = themes[0];
|
|
let _currentTheme;
|
|
await _registry.loadLanguages(_languages);
|
|
/**
|
|
* Shiki was designed for VS Code, so CSS variables are not currently supported.
|
|
* See: https://github.com/shikijs/shiki/pull/212#issuecomment-906924986
|
|
*
|
|
* Instead, we work around this by using valid hex color codes as lookups in a
|
|
* final "repair" step which translates those codes to the correct CSS variables.
|
|
*/
|
|
const COLOR_REPLACEMENTS = {
|
|
'#000001': 'var(--shiki-color-text)',
|
|
'#000002': 'var(--shiki-color-background)',
|
|
'#000004': 'var(--shiki-token-constant)',
|
|
'#000005': 'var(--shiki-token-string)',
|
|
'#000006': 'var(--shiki-token-comment)',
|
|
'#000007': 'var(--shiki-token-keyword)',
|
|
'#000008': 'var(--shiki-token-parameter)',
|
|
'#000009': 'var(--shiki-token-function)',
|
|
'#000010': 'var(--shiki-token-string-expression)',
|
|
'#000011': 'var(--shiki-token-punctuation)',
|
|
'#000012': 'var(--shiki-token-link)'
|
|
};
|
|
function fixCssVariablesTheme(theme, colorMap) {
|
|
theme.bg = COLOR_REPLACEMENTS[theme.bg] || theme.bg;
|
|
theme.fg = COLOR_REPLACEMENTS[theme.fg] || theme.fg;
|
|
colorMap.forEach((val, i) => {
|
|
colorMap[i] = COLOR_REPLACEMENTS[val] || val;
|
|
});
|
|
}
|
|
function getTheme(theme) {
|
|
const _theme = theme ? _registry.getTheme(theme) : _defaultTheme;
|
|
if (!_theme) {
|
|
throw Error(`No theme registration for ${theme}`);
|
|
}
|
|
if (!_currentTheme || _currentTheme.name !== _theme.name) {
|
|
_registry.setTheme(_theme);
|
|
_currentTheme = _theme;
|
|
}
|
|
const _colorMap = _registry.getColorMap();
|
|
if (_theme.name === 'css-variables') {
|
|
fixCssVariablesTheme(_theme, _colorMap);
|
|
}
|
|
return { _theme, _colorMap };
|
|
}
|
|
function getGrammar(lang) {
|
|
const _grammar = _registry.getGrammar(lang);
|
|
if (!_grammar) {
|
|
throw Error(`No language registration for ${lang}`);
|
|
}
|
|
return { _grammar };
|
|
}
|
|
function codeToThemedTokens(code, lang = 'text', theme, options = { includeExplanation: true }) {
|
|
if (isPlaintext(lang)) {
|
|
const lines = code.split(/\r\n|\r|\n/);
|
|
return [...lines.map(line => [{ content: line }])];
|
|
}
|
|
const { _grammar } = getGrammar(lang);
|
|
const { _theme, _colorMap } = getTheme(theme);
|
|
return tokenizeWithTheme(_theme, _colorMap, code, _grammar, options);
|
|
}
|
|
function codeToHtml(code, arg1 = 'text', arg2) {
|
|
let options;
|
|
// codeToHtml(code, options?) overload
|
|
if (typeof arg1 === 'object') {
|
|
options = arg1;
|
|
}
|
|
// codeToHtml(code, lang?, theme?) overload
|
|
else {
|
|
options = {
|
|
lang: arg1,
|
|
theme: arg2
|
|
};
|
|
}
|
|
const tokens = codeToThemedTokens(code, options.lang, options.theme, {
|
|
includeExplanation: false
|
|
});
|
|
const { _theme } = getTheme(options.theme);
|
|
return renderToHtml(tokens, {
|
|
fg: _theme.fg,
|
|
bg: _theme.bg,
|
|
lineOptions: options === null || options === void 0 ? void 0 : options.lineOptions
|
|
});
|
|
}
|
|
async function loadTheme(theme) {
|
|
await _registry.loadTheme(theme);
|
|
}
|
|
async function loadLanguage(lang) {
|
|
const _lang = resolveLang(lang);
|
|
_resolver.addLanguage(_lang);
|
|
await _registry.loadLanguage(_lang);
|
|
}
|
|
function getLoadedThemes() {
|
|
return _registry.getLoadedThemes();
|
|
}
|
|
function getLoadedLanguages() {
|
|
return _registry.getLoadedLanguages();
|
|
}
|
|
function getBackgroundColor(theme) {
|
|
const { _theme } = getTheme(theme);
|
|
return _theme.bg;
|
|
}
|
|
function getForegroundColor(theme) {
|
|
const { _theme } = getTheme(theme);
|
|
return _theme.fg;
|
|
}
|
|
return {
|
|
codeToThemedTokens,
|
|
codeToHtml,
|
|
getTheme: (theme) => {
|
|
return getTheme(theme)._theme;
|
|
},
|
|
loadTheme,
|
|
loadLanguage,
|
|
getBackgroundColor,
|
|
getForegroundColor,
|
|
getLoadedThemes,
|
|
getLoadedLanguages
|
|
};
|
|
}
|
|
function isPlaintext(lang) {
|
|
return !lang || ['plaintext', 'txt', 'text'].includes(lang);
|
|
}
|
|
|
|
/** @deprecated use setWasm instead, will be removed in a future version */
|
|
function setOnigasmWASM(path) {
|
|
setWasm(path);
|
|
}
|
|
|
|
export { languages as BUNDLED_LANGUAGES, themes as BUNDLED_THEMES, FontStyle, getHighlighter, fetchTheme as loadTheme, renderToHtml, setCDN, setOnigasmWASM, setWasm, toShikiTheme };
|