@bluepic/embed 0.5.1 → 0.5.4

package/dist/cpp-DxGBPWa5.js

@@ -1,538 +0,0 @@
-function S(e) {
-  const n = e.regex, a = e.COMMENT("//", "$", { contains: [{ begin: /\\\n/ }] }), _ = "decltype\\(auto\\)", c = "[a-zA-Z_]\\w*::", m = "(?!struct)(" + _ + "|" + n.optional(c) + "[a-zA-Z_]\\w*" + n.optional("<[^<>]+>") + ")", s = {
-    className: "type",
-    begin: "\\b[a-z\\d_]*_t\\b"
-  }, r = {
-    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: "."
-      },
-      // https://en.cppreference.com/w/cpp/language/string_literal
-      // a d-char-sequence never contains parentheses, backslashes or whitespace;
-      // quotes are excluded as well so the closing delimiter cannot swallow the
-      // quote that actually terminates the literal
-      e.END_SAME_AS_BEGIN({
-        begin: /(?:u8?|U|L)?R"([^()\\\s"]{0,16})\(/,
-        end: /\)([^()\\\s"]{0,16})"/
-      })
-    ]
-  }, i = {
-    className: "number",
-    variants: [
-      // Floating-point literal.
-      {
-        begin: "[+-]?(?:(?:\\b[0-9](?:'?[0-9])*\\.(?:[0-9](?:'?[0-9])*)?|\\.[0-9](?:'?[0-9])*)(?:[Ee][+-]?[0-9](?:'?[0-9])*)?|\\b[0-9](?:'?[0-9])*[Ee][+-]?[0-9](?:'?[0-9])*|\\b0[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
-  }, E = {
-    scope: "meta",
-    begin: /#\s*include\b/,
-    end: /$/,
-    keywords: { keyword: "include" },
-    contains: [
-      {
-        // the `\` at the end of a line signaling continuation
-        begin: /\\\n/
-      },
-      r,
-      {
-        scope: "string",
-        begin: /<.*?>/
-      },
-      a,
-      e.C_BLOCK_COMMENT_MODE
-    ]
-  }, f = {
-    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(r, { className: "string" }),
-      a,
-      e.C_BLOCK_COMMENT_MODE
-    ]
-  }, o = [
-    E,
-    f
-  ], g = {
-    className: "title",
-    begin: n.optional(c) + e.IDENT_RE,
-    relevance: 0
-  }, u = n.optional(c) + e.IDENT_RE + "\\s*\\(", b = 12, d = [
-    "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",
-    "flat_map",
-    "flat_set",
-    "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"
-  ], C = [
-    "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: d,
-    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: C
-    },
-    begin: n.concat(
-      /\b/,
-      `(?!${d.join("|")})`,
-      e.IDENT_RE,
-      n.lookahead(/(<[^<>]+>|)\s*\(/)
-    )
-  }, l = [
-    p,
-    ...o,
-    s,
-    a,
-    e.C_BLOCK_COMMENT_MODE,
-    i,
-    r
-  ], y = {
-    // 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
-  }, O = {
-    className: "function",
-    begin: "(" + m + "[\\*&\\s]+){1," + b + "}" + u,
-    returnBegin: !0,
-    end: /[{;=]/,
-    excludeEnd: !0,
-    keywords: t,
-    illegal: /[^\w\s\*&:<>.]/,
-    contains: [
-      {
-        // to prevent it from being confused as the function title
-        begin: _,
-        keywords: t,
-        relevance: 0
-      },
-      {
-        begin: u,
-        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: [
-          r,
-          i
-        ]
-      },
-      // 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,
-          r,
-          i,
-          s,
-          // Count matching parentheses.
-          {
-            begin: /\(/,
-            end: /\)/,
-            keywords: t,
-            relevance: 0,
-            contains: [
-              "self",
-              a,
-              e.C_BLOCK_COMMENT_MODE,
-              r,
-              i,
-              s
-            ]
-          }
-        ]
-      },
-      s,
-      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(
-      y,
-      O,
-      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|flat_map|flat_set)\\s*<(?!<)",
-          end: ">",
-          keywords: t,
-          contains: [
-            "self",
-            s
-          ]
-        },
-        {
-          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"
-          }
-        }
-      ]
-    )
-  };
-}
-export {
-  S as default
-};