vue-files-preview-inno
Version:
A tool for previewing files such as doc, excel, pdf, image, markdown, txt, audio, and video and so on.
527 lines (526 loc) • 11.3 kB
JavaScript
var _, m;
function R() {
if (m) return _;
m = 1;
function E(e) {
const n = e.regex, a = e.COMMENT("//", "$", { contains: [{ begin: /\\\n/ }] }), u = "decltype\\(auto\\)", c = "[a-zA-Z_]\\w*::", f = "(?!struct)(" + u + "|" + n.optional(c) + "[a-zA-Z_]\\w*" + n.optional("<[^<>]+>") + ")", r = {
className: "type",
begin: "\\b[a-z\\d_]*_t\\b"
}, i = {
className: "string",
variants: [
{
begin: '(u8?|U|L)?"',
end: '"',
illegal: "\\n",
contains: [e.BACKSLASH_ESCAPE]
},
{
begin: "(u8?|U|L)?'(" + "\\\\(x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4,8}|[0-7]{3}|\\S)" + "|.)",
end: "'",
illegal: "."
},
e.END_SAME_AS_BEGIN({
begin: /(?:u8?|U|L)?R"([^()\\ ]{0,16})\(/,
end: /\)([^()\\ ]{0,16})"/
})
]
}, s = {
className: "number",
variants: [
// Floating-point literal.
{
begin: "[+-]?(?:(?:[0-9](?:'?[0-9])*\\.(?:[0-9](?:'?[0-9])*)?|\\.[0-9](?:'?[0-9])*)(?:[Ee][+-]?[0-9](?:'?[0-9])*)?|[0-9](?:'?[0-9])*[Ee][+-]?[0-9](?:'?[0-9])*|0[Xx](?:[0-9A-Fa-f](?:'?[0-9A-Fa-f])*(?:\\.(?:[0-9A-Fa-f](?:'?[0-9A-Fa-f])*)?)?|\\.[0-9A-Fa-f](?:'?[0-9A-Fa-f])*)[Pp][+-]?[0-9](?:'?[0-9])*)(?:[Ff](?:16|32|64|128)?|(BF|bf)16|[Ll]|)"
},
// Integer literal.
{
begin: "[+-]?\\b(?:0[Bb][01](?:'?[01])*|0[Xx][0-9A-Fa-f](?:'?[0-9A-Fa-f])*|0(?:'?[0-7])*|[1-9](?:'?[0-9])*)(?:[Uu](?:LL?|ll?)|[Uu][Zz]?|(?:LL?|ll?)[Uu]?|[Zz][Uu]|)"
// Note: there are user-defined literal suffixes too, but perhaps having the custom suffix not part of the
// literal highlight actually makes it stand out more.
}
],
relevance: 0
}, o = {
className: "meta",
begin: /#\s*[a-z]+\b/,
end: /$/,
keywords: { keyword: "if else elif endif define undef warning error line pragma _Pragma ifdef ifndef include" },
contains: [
{
begin: /\\\n/,
relevance: 0
},
e.inherit(i, { className: "string" }),
{
className: "string",
begin: /<.*?>/
},
a,
e.C_BLOCK_COMMENT_MODE
]
}, g = {
className: "title",
begin: n.optional(c) + e.IDENT_RE,
relevance: 0
}, d = n.optional(c) + e.IDENT_RE + "\\s*\\(", b = [
"alignas",
"alignof",
"and",
"and_eq",
"asm",
"atomic_cancel",
"atomic_commit",
"atomic_noexcept",
"auto",
"bitand",
"bitor",
"break",
"case",
"catch",
"class",
"co_await",
"co_return",
"co_yield",
"compl",
"concept",
"const_cast|10",
"consteval",
"constexpr",
"constinit",
"continue",
"decltype",
"default",
"delete",
"do",
"dynamic_cast|10",
"else",
"enum",
"explicit",
"export",
"extern",
"false",
"final",
"for",
"friend",
"goto",
"if",
"import",
"inline",
"module",
"mutable",
"namespace",
"new",
"noexcept",
"not",
"not_eq",
"nullptr",
"operator",
"or",
"or_eq",
"override",
"private",
"protected",
"public",
"reflexpr",
"register",
"reinterpret_cast|10",
"requires",
"return",
"sizeof",
"static_assert",
"static_cast|10",
"struct",
"switch",
"synchronized",
"template",
"this",
"thread_local",
"throw",
"transaction_safe",
"transaction_safe_dynamic",
"true",
"try",
"typedef",
"typeid",
"typename",
"union",
"using",
"virtual",
"volatile",
"while",
"xor",
"xor_eq"
], N = [
"bool",
"char",
"char16_t",
"char32_t",
"char8_t",
"double",
"float",
"int",
"long",
"short",
"void",
"wchar_t",
"unsigned",
"signed",
"const",
"static"
], T = [
"any",
"auto_ptr",
"barrier",
"binary_semaphore",
"bitset",
"complex",
"condition_variable",
"condition_variable_any",
"counting_semaphore",
"deque",
"false_type",
"future",
"imaginary",
"initializer_list",
"istringstream",
"jthread",
"latch",
"lock_guard",
"multimap",
"multiset",
"mutex",
"optional",
"ostringstream",
"packaged_task",
"pair",
"promise",
"priority_queue",
"queue",
"recursive_mutex",
"recursive_timed_mutex",
"scoped_lock",
"set",
"shared_future",
"shared_lock",
"shared_mutex",
"shared_timed_mutex",
"shared_ptr",
"stack",
"string_view",
"stringstream",
"timed_mutex",
"thread",
"true_type",
"tuple",
"unique_lock",
"unique_ptr",
"unordered_map",
"unordered_multimap",
"unordered_multiset",
"unordered_set",
"variant",
"vector",
"weak_ptr",
"wstring",
"wstring_view"
], y = [
"abort",
"abs",
"acos",
"apply",
"as_const",
"asin",
"atan",
"atan2",
"calloc",
"ceil",
"cerr",
"cin",
"clog",
"cos",
"cosh",
"cout",
"declval",
"endl",
"exchange",
"exit",
"exp",
"fabs",
"floor",
"fmod",
"forward",
"fprintf",
"fputs",
"free",
"frexp",
"fscanf",
"future",
"invoke",
"isalnum",
"isalpha",
"iscntrl",
"isdigit",
"isgraph",
"islower",
"isprint",
"ispunct",
"isspace",
"isupper",
"isxdigit",
"labs",
"launder",
"ldexp",
"log",
"log10",
"make_pair",
"make_shared",
"make_shared_for_overwrite",
"make_tuple",
"make_unique",
"malloc",
"memchr",
"memcmp",
"memcpy",
"memset",
"modf",
"move",
"pow",
"printf",
"putchar",
"puts",
"realloc",
"scanf",
"sin",
"sinh",
"snprintf",
"sprintf",
"sqrt",
"sscanf",
"std",
"stderr",
"stdin",
"stdout",
"strcat",
"strchr",
"strcmp",
"strcpy",
"strcspn",
"strlen",
"strncat",
"strncmp",
"strncpy",
"strpbrk",
"strrchr",
"strspn",
"strstr",
"swap",
"tan",
"tanh",
"terminate",
"to_underlying",
"tolower",
"toupper",
"vfprintf",
"visit",
"vprintf",
"vsprintf"
], t = {
type: N,
keyword: b,
literal: [
"NULL",
"false",
"nullopt",
"nullptr",
"true"
],
built_in: ["_Pragma"],
_type_hints: T
}, p = {
className: "function.dispatch",
relevance: 0,
keywords: {
// Only for relevance, not highlighting.
_hint: y
},
begin: n.concat(
/\b/,
/(?!decltype)/,
/(?!if)/,
/(?!for)/,
/(?!switch)/,
/(?!while)/,
e.IDENT_RE,
n.lookahead(/(<[^<>]+>|)\s*\(/)
)
}, l = [
p,
o,
r,
a,
e.C_BLOCK_COMMENT_MODE,
s,
i
], C = {
// This mode covers expression context where we can't expect a function
// definition and shouldn't highlight anything that looks like one:
// `return some()`, `else if()`, `(x*sum(1, 2))`
variants: [
{
begin: /=/,
end: /;/
},
{
begin: /\(/,
end: /\)/
},
{
beginKeywords: "new throw return else",
end: /;/
}
],
keywords: t,
contains: l.concat([
{
begin: /\(/,
end: /\)/,
keywords: t,
contains: l.concat(["self"]),
relevance: 0
}
]),
relevance: 0
}, v = {
className: "function",
begin: "(" + f + "[\\*&\\s]+)+" + d,
returnBegin: !0,
end: /[{;=]/,
excludeEnd: !0,
keywords: t,
illegal: /[^\w\s\*&:<>.]/,
contains: [
{
// to prevent it from being confused as the function title
begin: u,
keywords: t,
relevance: 0
},
{
begin: d,
returnBegin: !0,
contains: [g],
relevance: 0
},
// needed because we do not have look-behind on the below rule
// to prevent it from grabbing the final : in a :: pair
{
begin: /::/,
relevance: 0
},
// initializers
{
begin: /:/,
endsWithParent: !0,
contains: [
i,
s
]
},
// allow for multiple declarations, e.g.:
// extern void f(int), g(char);
{
relevance: 0,
match: /,/
},
{
className: "params",
begin: /\(/,
end: /\)/,
keywords: t,
relevance: 0,
contains: [
a,
e.C_BLOCK_COMMENT_MODE,
i,
s,
r,
// Count matching parentheses.
{
begin: /\(/,
end: /\)/,
keywords: t,
relevance: 0,
contains: [
"self",
a,
e.C_BLOCK_COMMENT_MODE,
i,
s,
r
]
}
]
},
r,
a,
e.C_BLOCK_COMMENT_MODE,
o
]
};
return {
name: "C++",
aliases: [
"cc",
"c++",
"h++",
"hpp",
"hh",
"hxx",
"cxx"
],
keywords: t,
illegal: "</",
classNameAliases: { "function.dispatch": "built_in" },
contains: [].concat(
C,
v,
p,
l,
[
o,
{
// containers: ie, `vector <int> rooms (9);`
begin: "\\b(deque|list|queue|priority_queue|pair|stack|vector|map|set|bitset|multiset|multimap|unordered_map|unordered_set|unordered_multiset|unordered_multimap|array|tuple|optional|variant|function)\\s*<(?!<)",
end: ">",
keywords: t,
contains: [
"self",
r
]
},
{
begin: e.IDENT_RE + "::",
keywords: t
},
{
match: [
// extra complexity to deal with `enum class` and `enum struct`
/\b(?:enum(?:\s+(?:class|struct))?|class|struct|union)/,
/\s+/,
/\w+/
],
className: {
1: "keyword",
3: "title.class"
}
}
]
)
};
}
return _ = E, _;
}
export {
R as __require
};
//# sourceMappingURL=cpp.mjs.map