edu360-web-ui 1.0.102 → 1.0.104

package/dist/shizhanyun-web-ui.js

@@ -26966,7 +26966,7 @@ var hasRequiredAngelscript;
 function requireAngelscript() {
   if (hasRequiredAngelscript) return angelscript_1;
   hasRequiredAngelscript = 1;
-  function angelscript(hljs2) {
+  function angelscript2(hljs2) {
     const builtInTypeMode = {
       className: "built_in",
       begin: "\\b(void|bool|int8|int16|int32|int64|int|uint8|uint16|uint32|uint64|uint|string|ref|array|double|float|auto|dictionary)"
@@ -27130,7 +27130,7 @@ function requireAngelscript() {
       ]
     };
   }
-  angelscript_1 = angelscript;
+  angelscript_1 = angelscript2;
   return angelscript_1;
 }
 var apache_1;
@@ -29058,7 +29058,7 @@ var hasRequiredAsciidoc;
 function requireAsciidoc() {
   if (hasRequiredAsciidoc) return asciidoc_1;
   hasRequiredAsciidoc = 1;
-  function asciidoc(hljs2) {
+  function asciidoc2(hljs2) {
     const regex2 = hljs2.regex;
     const HORIZONTAL_RULE = {
       begin: "^'{3,}[ \\t]*$",
@@ -29304,7 +29304,7 @@ function requireAsciidoc() {
       ]
     };
   }
-  asciidoc_1 = asciidoc;
+  asciidoc_1 = asciidoc2;
   return asciidoc_1;
 }
 var aspectj_1;
@@ -29835,7 +29835,7 @@ var hasRequiredAwk;
 function requireAwk() {
   if (hasRequiredAwk) return awk_1;
   hasRequiredAwk = 1;
-  function awk(hljs2) {
+  function awk2(hljs2) {
     const VARIABLE = {
       className: "variable",
       variants: [
@@ -29892,7 +29892,7 @@ function requireAwk() {
       ]
     };
   }
-  awk_1 = awk;
+  awk_1 = awk2;
   return awk_1;
 }
 var axapta_1;
@@ -29900,7 +29900,7 @@ var hasRequiredAxapta;
 function requireAxapta() {
   if (hasRequiredAxapta) return axapta_1;
   hasRequiredAxapta = 1;
-  function axapta(hljs2) {
+  function axapta2(hljs2) {
     const IDENT_RE2 = hljs2.UNDERSCORE_IDENT_RE;
     const BUILT_IN_KEYWORDS = [
       "anytype",
@@ -30072,7 +30072,7 @@ function requireAxapta() {
       ]
     };
   }
-  axapta_1 = axapta;
+  axapta_1 = axapta2;
   return axapta_1;
 }
 var bash_1;
@@ -31352,7 +31352,7 @@ var hasRequiredCeylon;
 function requireCeylon() {
   if (hasRequiredCeylon) return ceylon_1;
   hasRequiredCeylon = 1;
-  function ceylon(hljs2) {
+  function ceylon2(hljs2) {
     const KEYWORDS2 = [
       "assembly",
       "module",
@@ -31478,7 +31478,7 @@ function requireCeylon() {
       ].concat(EXPRESSIONS2)
     };
   }
-  ceylon_1 = ceylon;
+  ceylon_1 = ceylon2;
   return ceylon_1;
 }
 var clean_1;
@@ -58953,7 +58953,7 @@ var hasRequiredNix;
 function requireNix() {
   if (hasRequiredNix) return nix_1;
   hasRequiredNix = 1;
-  function nix(hljs2) {
+  function nix2(hljs2) {
     const regex2 = hljs2.regex;
     const KEYWORDS2 = {
       keyword: [
@@ -59298,7 +59298,7 @@ function requireNix() {
       contains: EXPRESSIONS2.concat(REPL)
     };
   }
-  nix_1 = nix;
+  nix_1 = nix2;
   return nix_1;
 }
 var nodeRepl_1;
@@ -78481,7 +78481,12 @@ const _sfc_main$b = {
       "routeros",
       // 纯文本
       "plaintext",
-      "text"
+      "text",
+      "awk",
+      "axapta",
+      "angelscript",
+      "asciidoc",
+      "ceylon"
     ].sort();
     const lang = ref(props.node.attrs.language || "javascript");
     const updateLanguage = (data) => {
@@ -78605,7 +78610,171 @@ const _sfc_main$b = {
     };
   }
 };
-const CodeBlockView = /* @__PURE__ */ _export_sfc(_sfc_main$b, [["__scopeId", "data-v-86650c4c"]]);
+const CodeBlockView = /* @__PURE__ */ _export_sfc(_sfc_main$b, [["__scopeId", "data-v-b028180b"]]);
+function angelscript(hljs2) {
+  const builtInTypeMode = {
+    className: "built_in",
+    begin: "\\b(void|bool|int8|int16|int32|int64|int|uint8|uint16|uint32|uint64|uint|string|ref|array|double|float|auto|dictionary)"
+  };
+  const objectHandleMode = {
+    className: "symbol",
+    begin: "[a-zA-Z0-9_]+@"
+  };
+  const genericMode = {
+    className: "keyword",
+    begin: "<",
+    end: ">",
+    contains: [
+      builtInTypeMode,
+      objectHandleMode
+    ]
+  };
+  builtInTypeMode.contains = [genericMode];
+  objectHandleMode.contains = [genericMode];
+  const KEYWORDS2 = [
+    "for",
+    "in|0",
+    "break",
+    "continue",
+    "while",
+    "do|0",
+    "return",
+    "if",
+    "else",
+    "case",
+    "switch",
+    "namespace",
+    "is",
+    "cast",
+    "or",
+    "and",
+    "xor",
+    "not",
+    "get|0",
+    "in",
+    "inout|10",
+    "out",
+    "override",
+    "set|0",
+    "private",
+    "public",
+    "const",
+    "default|0",
+    "final",
+    "shared",
+    "external",
+    "mixin|10",
+    "enum",
+    "typedef",
+    "funcdef",
+    "this",
+    "super",
+    "import",
+    "from",
+    "interface",
+    "abstract|0",
+    "try",
+    "catch",
+    "protected",
+    "explicit",
+    "property"
+  ];
+  return {
+    name: "AngelScript",
+    aliases: ["asc"],
+    keywords: KEYWORDS2,
+    // avoid close detection with C# and JS
+    illegal: "(^using\\s+[A-Za-z0-9_\\.]+;$|\\bfunction\\s*[^\\(])",
+    contains: [
+      {
+        // 'strings'
+        className: "string",
+        begin: "'",
+        end: "'",
+        illegal: "\\n",
+        contains: [hljs2.BACKSLASH_ESCAPE],
+        relevance: 0
+      },
+      // """heredoc strings"""
+      {
+        className: "string",
+        begin: '"""',
+        end: '"""'
+      },
+      {
+        // "strings"
+        className: "string",
+        begin: '"',
+        end: '"',
+        illegal: "\\n",
+        contains: [hljs2.BACKSLASH_ESCAPE],
+        relevance: 0
+      },
+      hljs2.C_LINE_COMMENT_MODE,
+      // single-line comments
+      hljs2.C_BLOCK_COMMENT_MODE,
+      // comment blocks
+      {
+        // metadata
+        className: "string",
+        begin: "^\\s*\\[",
+        end: "\\]"
+      },
+      {
+        // interface or namespace declaration
+        beginKeywords: "interface namespace",
+        end: /\{/,
+        illegal: "[;.\\-]",
+        contains: [
+          {
+            // interface or namespace name
+            className: "symbol",
+            begin: "[a-zA-Z0-9_]+"
+          }
+        ]
+      },
+      {
+        // class declaration
+        beginKeywords: "class",
+        end: /\{/,
+        illegal: "[;.\\-]",
+        contains: [
+          {
+            // class name
+            className: "symbol",
+            begin: "[a-zA-Z0-9_]+",
+            contains: [
+              {
+                begin: "[:,]\\s*",
+                contains: [
+                  {
+                    className: "symbol",
+                    begin: "[a-zA-Z0-9_]+"
+                  }
+                ]
+              }
+            ]
+          }
+        ]
+      },
+      builtInTypeMode,
+      // built-in types
+      objectHandleMode,
+      // object handles
+      {
+        // literals
+        className: "literal",
+        begin: "\\b(null|true|false)"
+      },
+      {
+        // numbers
+        className: "number",
+        relevance: 0,
+        begin: "(-?)(\\b0[xXbBoOdD][a-fA-F0-9]+|(\\b\\d+(\\.\\d*)?f?|\\.\\d+f?)([eE][-+]?\\d+f?)?)"
+      }
+    ]
+  };
+}
 function armasm(hljs2) {
   const COMMENT2 = { variants: [
     hljs2.COMMENT("^[ \\t]*(?=#)", "$", {
@@ -78692,6 +78861,607 @@ function armasm(hljs2) {
     ]
   };
 }
+function asciidoc(hljs2) {
+  const regex2 = hljs2.regex;
+  const HORIZONTAL_RULE = {
+    begin: "^'{3,}[ \\t]*$",
+    relevance: 10
+  };
+  const ESCAPED_FORMATTING = [
+    // escaped constrained formatting marks (i.e., \* \_ or \`)
+    { begin: /\\[*_`]/ },
+    // escaped unconstrained formatting marks (i.e., \\** \\__ or \\``)
+    // must ignore until the next formatting marks
+    // this rule might not be 100% compliant with Asciidoctor 2.0 but we are entering undefined behavior territory...
+    { begin: /\\\\\*{2}[^\n]*?\*{2}/ },
+    { begin: /\\\\_{2}[^\n]*_{2}/ },
+    { begin: /\\\\`{2}[^\n]*`{2}/ },
+    // guard: constrained formatting mark may not be preceded by ":", ";" or
+    // "}". match these so the constrained rule doesn't see them
+    { begin: /[:;}][*_`](?![*_`])/ }
+  ];
+  const STRONG = [
+    // inline unconstrained strong (single line)
+    {
+      className: "strong",
+      begin: /\*{2}([^\n]+?)\*{2}/
+    },
+    // inline unconstrained strong (multi-line)
+    {
+      className: "strong",
+      begin: regex2.concat(
+        /\*\*/,
+        /((\*(?!\*)|\\[^\n]|[^*\n\\])+\n)+/,
+        /(\*(?!\*)|\\[^\n]|[^*\n\\])*/,
+        /\*\*/
+      ),
+      relevance: 0
+    },
+    // inline constrained strong (single line)
+    {
+      className: "strong",
+      // must not precede or follow a word character
+      begin: /\B\*(\S|\S[^\n]*?\S)\*(?!\w)/
+    },
+    // inline constrained strong (multi-line)
+    {
+      className: "strong",
+      // must not precede or follow a word character
+      begin: /\*[^\s]([^\n]+\n)+([^\n]+)\*/
+    }
+  ];
+  const EMPHASIS = [
+    // inline unconstrained emphasis (single line)
+    {
+      className: "emphasis",
+      begin: /_{2}([^\n]+?)_{2}/
+    },
+    // inline unconstrained emphasis (multi-line)
+    {
+      className: "emphasis",
+      begin: regex2.concat(
+        /__/,
+        /((_(?!_)|\\[^\n]|[^_\n\\])+\n)+/,
+        /(_(?!_)|\\[^\n]|[^_\n\\])*/,
+        /__/
+      ),
+      relevance: 0
+    },
+    // inline constrained emphasis (single line)
+    {
+      className: "emphasis",
+      // must not precede or follow a word character
+      begin: /\b_(\S|\S[^\n]*?\S)_(?!\w)/
+    },
+    // inline constrained emphasis (multi-line)
+    {
+      className: "emphasis",
+      // must not precede or follow a word character
+      begin: /_[^\s]([^\n]+\n)+([^\n]+)_/
+    },
+    // inline constrained emphasis using single quote (legacy)
+    {
+      className: "emphasis",
+      // must not follow a word character or be followed by a single quote or space
+      begin: "\\B'(?!['\\s])",
+      end: "(\\n{2}|')",
+      // allow escaped single quote followed by word char
+      contains: [
+        {
+          begin: "\\\\'\\w",
+          relevance: 0
+        }
+      ],
+      relevance: 0
+    }
+  ];
+  const ADMONITION = {
+    className: "symbol",
+    begin: "^(NOTE|TIP|IMPORTANT|WARNING|CAUTION):\\s+",
+    relevance: 10
+  };
+  const BULLET_LIST = {
+    className: "bullet",
+    begin: "^(\\*+|-+|\\.+|[^\\n]+?::)\\s+"
+  };
+  return {
+    name: "AsciiDoc",
+    aliases: ["adoc"],
+    contains: [
+      // block comment
+      hljs2.COMMENT(
+        "^/{4,}\\n",
+        "\\n/{4,}$",
+        // can also be done as...
+        // '^/{4,}$',
+        // '^/{4,}$',
+        { relevance: 10 }
+      ),
+      // line comment
+      hljs2.COMMENT(
+        "^//",
+        "$",
+        { relevance: 0 }
+      ),
+      // title
+      {
+        className: "title",
+        begin: "^\\.\\w.*$"
+      },
+      // example, admonition & sidebar blocks
+      {
+        begin: "^[=\\*]{4,}\\n",
+        end: "\\n^[=\\*]{4,}$",
+        relevance: 10
+      },
+      // headings
+      {
+        className: "section",
+        relevance: 10,
+        variants: [
+          { begin: "^(={1,6})[ 	].+?([ 	]\\1)?$" },
+          { begin: "^[^\\[\\]\\n]+?\\n[=\\-~\\^\\+]{2,}$" }
+        ]
+      },
+      // document attributes
+      {
+        className: "meta",
+        begin: "^:.+?:",
+        end: "\\s",
+        excludeEnd: true,
+        relevance: 10
+      },
+      // block attributes
+      {
+        className: "meta",
+        begin: "^\\[.+?\\]$",
+        relevance: 0
+      },
+      // quoteblocks
+      {
+        className: "quote",
+        begin: "^_{4,}\\n",
+        end: "\\n_{4,}$",
+        relevance: 10
+      },
+      // listing and literal blocks
+      {
+        className: "code",
+        begin: "^[\\-\\.]{4,}\\n",
+        end: "\\n[\\-\\.]{4,}$",
+        relevance: 10
+      },
+      // passthrough blocks
+      {
+        begin: "^\\+{4,}\\n",
+        end: "\\n\\+{4,}$",
+        contains: [
+          {
+            begin: "<",
+            end: ">",
+            subLanguage: "xml",
+            relevance: 0
+          }
+        ],
+        relevance: 10
+      },
+      BULLET_LIST,
+      ADMONITION,
+      ...ESCAPED_FORMATTING,
+      ...STRONG,
+      ...EMPHASIS,
+      // inline smart quotes
+      {
+        className: "string",
+        variants: [
+          { begin: "``.+?''" },
+          { begin: "`.+?'" }
+        ]
+      },
+      // inline unconstrained emphasis
+      {
+        className: "code",
+        begin: /`{2}/,
+        end: /(\n{2}|`{2})/
+      },
+      // inline code snippets (TODO should get same treatment as strong and emphasis)
+      {
+        className: "code",
+        begin: "(`.+?`|\\+.+?\\+)",
+        relevance: 0
+      },
+      // indented literal block
+      {
+        className: "code",
+        begin: "^[ \\t]",
+        end: "$",
+        relevance: 0
+      },
+      HORIZONTAL_RULE,
+      // images and links
+      {
+        begin: "(link:)?(http|https|ftp|file|irc|image:?):\\S+?\\[[^[]*?\\]",
+        returnBegin: true,
+        contains: [
+          {
+            begin: "(link|image:?):",
+            relevance: 0
+          },
+          {
+            className: "link",
+            begin: "\\w",
+            end: "[^\\[]+",
+            relevance: 0
+          },
+          {
+            className: "string",
+            begin: "\\[",
+            end: "\\]",
+            excludeBegin: true,
+            excludeEnd: true,
+            relevance: 0
+          }
+        ],
+        relevance: 10
+      }
+    ]
+  };
+}
+function awk(hljs2) {
+  const VARIABLE = {
+    className: "variable",
+    variants: [
+      { begin: /\$[\w\d#@][\w\d_]*/ },
+      { begin: /\$\{(.*?)\}/ }
+    ]
+  };
+  const KEYWORDS2 = "BEGIN END if else while do for in break continue delete next nextfile function func exit|10";
+  const STRING = {
+    className: "string",
+    contains: [hljs2.BACKSLASH_ESCAPE],
+    variants: [
+      {
+        begin: /(u|b)?r?'''/,
+        end: /'''/,
+        relevance: 10
+      },
+      {
+        begin: /(u|b)?r?"""/,
+        end: /"""/,
+        relevance: 10
+      },
+      {
+        begin: /(u|r|ur)'/,
+        end: /'/,
+        relevance: 10
+      },
+      {
+        begin: /(u|r|ur)"/,
+        end: /"/,
+        relevance: 10
+      },
+      {
+        begin: /(b|br)'/,
+        end: /'/
+      },
+      {
+        begin: /(b|br)"/,
+        end: /"/
+      },
+      hljs2.APOS_STRING_MODE,
+      hljs2.QUOTE_STRING_MODE
+    ]
+  };
+  return {
+    name: "Awk",
+    keywords: { keyword: KEYWORDS2 },
+    contains: [
+      VARIABLE,
+      STRING,
+      hljs2.REGEXP_MODE,
+      hljs2.HASH_COMMENT_MODE,
+      hljs2.NUMBER_MODE
+    ]
+  };
+}
+function axapta(hljs2) {
+  const IDENT_RE2 = hljs2.UNDERSCORE_IDENT_RE;
+  const BUILT_IN_KEYWORDS = [
+    "anytype",
+    "boolean",
+    "byte",
+    "char",
+    "container",
+    "date",
+    "double",
+    "enum",
+    "guid",
+    "int",
+    "int64",
+    "long",
+    "real",
+    "short",
+    "str",
+    "utcdatetime",
+    "var"
+  ];
+  const LITERAL_KEYWORDS = [
+    "default",
+    "false",
+    "null",
+    "true"
+  ];
+  const NORMAL_KEYWORDS = [
+    "abstract",
+    "as",
+    "asc",
+    "avg",
+    "break",
+    "breakpoint",
+    "by",
+    "byref",
+    "case",
+    "catch",
+    "changecompany",
+    "class",
+    "client",
+    "client",
+    "common",
+    "const",
+    "continue",
+    "count",
+    "crosscompany",
+    "delegate",
+    "delete_from",
+    "desc",
+    "display",
+    "div",
+    "do",
+    "edit",
+    "else",
+    "eventhandler",
+    "exists",
+    "extends",
+    "final",
+    "finally",
+    "firstfast",
+    "firstonly",
+    "firstonly1",
+    "firstonly10",
+    "firstonly100",
+    "firstonly1000",
+    "flush",
+    "for",
+    "forceliterals",
+    "forcenestedloop",
+    "forceplaceholders",
+    "forceselectorder",
+    "forupdate",
+    "from",
+    "generateonly",
+    "group",
+    "hint",
+    "if",
+    "implements",
+    "in",
+    "index",
+    "insert_recordset",
+    "interface",
+    "internal",
+    "is",
+    "join",
+    "like",
+    "maxof",
+    "minof",
+    "mod",
+    "namespace",
+    "new",
+    "next",
+    "nofetch",
+    "notexists",
+    "optimisticlock",
+    "order",
+    "outer",
+    "pessimisticlock",
+    "print",
+    "private",
+    "protected",
+    "public",
+    "readonly",
+    "repeatableread",
+    "retry",
+    "return",
+    "reverse",
+    "select",
+    "server",
+    "setting",
+    "static",
+    "sum",
+    "super",
+    "switch",
+    "this",
+    "throw",
+    "try",
+    "ttsabort",
+    "ttsbegin",
+    "ttscommit",
+    "unchecked",
+    "update_recordset",
+    "using",
+    "validtimestate",
+    "void",
+    "where",
+    "while"
+  ];
+  const KEYWORDS2 = {
+    keyword: NORMAL_KEYWORDS,
+    built_in: BUILT_IN_KEYWORDS,
+    literal: LITERAL_KEYWORDS
+  };
+  const CLASS_DEFINITION = {
+    variants: [
+      { match: [
+        /(class|interface)\s+/,
+        IDENT_RE2,
+        /\s+(extends|implements)\s+/,
+        IDENT_RE2
+      ] },
+      { match: [
+        /class\s+/,
+        IDENT_RE2
+      ] }
+    ],
+    scope: {
+      2: "title.class",
+      4: "title.class.inherited"
+    },
+    keywords: KEYWORDS2
+  };
+  return {
+    name: "X++",
+    aliases: ["x++"],
+    keywords: KEYWORDS2,
+    contains: [
+      hljs2.C_LINE_COMMENT_MODE,
+      hljs2.C_BLOCK_COMMENT_MODE,
+      hljs2.APOS_STRING_MODE,
+      hljs2.QUOTE_STRING_MODE,
+      hljs2.C_NUMBER_MODE,
+      {
+        className: "meta",
+        begin: "#",
+        end: "$"
+      },
+      CLASS_DEFINITION
+    ]
+  };
+}
+function ceylon(hljs2) {
+  const KEYWORDS2 = [
+    "assembly",
+    "module",
+    "package",
+    "import",
+    "alias",
+    "class",
+    "interface",
+    "object",
+    "given",
+    "value",
+    "assign",
+    "void",
+    "function",
+    "new",
+    "of",
+    "extends",
+    "satisfies",
+    "abstracts",
+    "in",
+    "out",
+    "return",
+    "break",
+    "continue",
+    "throw",
+    "assert",
+    "dynamic",
+    "if",
+    "else",
+    "switch",
+    "case",
+    "for",
+    "while",
+    "try",
+    "catch",
+    "finally",
+    "then",
+    "let",
+    "this",
+    "outer",
+    "super",
+    "is",
+    "exists",
+    "nonempty"
+  ];
+  const DECLARATION_MODIFIERS = [
+    "shared",
+    "abstract",
+    "formal",
+    "default",
+    "actual",
+    "variable",
+    "late",
+    "native",
+    "deprecated",
+    "final",
+    "sealed",
+    "annotation",
+    "suppressWarnings",
+    "small"
+  ];
+  const DOCUMENTATION = [
+    "doc",
+    "by",
+    "license",
+    "see",
+    "throws",
+    "tagged"
+  ];
+  const SUBST = {
+    className: "subst",
+    excludeBegin: true,
+    excludeEnd: true,
+    begin: /``/,
+    end: /``/,
+    keywords: KEYWORDS2,
+    relevance: 10
+  };
+  const EXPRESSIONS2 = [
+    {
+      // verbatim string
+      className: "string",
+      begin: '"""',
+      end: '"""',
+      relevance: 10
+    },
+    {
+      // string literal or template
+      className: "string",
+      begin: '"',
+      end: '"',
+      contains: [SUBST]
+    },
+    {
+      // character literal
+      className: "string",
+      begin: "'",
+      end: "'"
+    },
+    {
+      // numeric literal
+      className: "number",
+      begin: "#[0-9a-fA-F_]+|\\$[01_]+|[0-9_]+(?:\\.[0-9_](?:[eE][+-]?\\d+)?)?[kMGTPmunpf]?",
+      relevance: 0
+    }
+  ];
+  SUBST.contains = EXPRESSIONS2;
+  return {
+    name: "Ceylon",
+    keywords: {
+      keyword: KEYWORDS2.concat(DECLARATION_MODIFIERS),
+      meta: DOCUMENTATION
+    },
+    illegal: "\\$[^01]|#[^0-9a-fA-F]",
+    contains: [
+      hljs2.C_LINE_COMMENT_MODE,
+      hljs2.COMMENT("/\\*", "\\*/", { contains: ["self"] }),
+      {
+        // compiler annotation
+        className: "meta",
+        begin: '@[a-z]\\w*(?::"[^"]*")?'
+      }
+    ].concat(EXPRESSIONS2)
+  };
+}
 function clojure(hljs2) {
   const SYMBOLSTART = "a-zA-Z_\\-!.?+*=<>&'";
   const SYMBOL_RE = "[#]?[" + SYMBOLSTART + "][" + SYMBOLSTART + "0-9/;:$#]*";
@@ -82763,6 +83533,351 @@ function nginx(hljs2) {
     illegal: "[^\\s\\}\\{]"
   };
 }
+function nix(hljs2) {
+  const regex2 = hljs2.regex;
+  const KEYWORDS2 = {
+    keyword: [
+      "assert",
+      "else",
+      "if",
+      "in",
+      "inherit",
+      "let",
+      "or",
+      "rec",
+      "then",
+      "with"
+    ],
+    literal: [
+      "true",
+      "false",
+      "null"
+    ],
+    built_in: [
+      // toplevel builtins
+      "abort",
+      "baseNameOf",
+      "builtins",
+      "derivation",
+      "derivationStrict",
+      "dirOf",
+      "fetchGit",
+      "fetchMercurial",
+      "fetchTarball",
+      "fetchTree",
+      "fromTOML",
+      "import",
+      "isNull",
+      "map",
+      "placeholder",
+      "removeAttrs",
+      "scopedImport",
+      "throw",
+      "toString"
+    ]
+  };
+  const BUILTINS = {
+    scope: "built_in",
+    match: regex2.either(...[
+      "abort",
+      "add",
+      "addDrvOutputDependencies",
+      "addErrorContext",
+      "all",
+      "any",
+      "appendContext",
+      "attrNames",
+      "attrValues",
+      "baseNameOf",
+      "bitAnd",
+      "bitOr",
+      "bitXor",
+      "break",
+      "builtins",
+      "catAttrs",
+      "ceil",
+      "compareVersions",
+      "concatLists",
+      "concatMap",
+      "concatStringsSep",
+      "convertHash",
+      "currentSystem",
+      "currentTime",
+      "deepSeq",
+      "derivation",
+      "derivationStrict",
+      "dirOf",
+      "div",
+      "elem",
+      "elemAt",
+      "false",
+      "fetchGit",
+      "fetchMercurial",
+      "fetchTarball",
+      "fetchTree",
+      "fetchurl",
+      "filter",
+      "filterSource",
+      "findFile",
+      "flakeRefToString",
+      "floor",
+      "foldl'",
+      "fromJSON",
+      "fromTOML",
+      "functionArgs",
+      "genList",
+      "genericClosure",
+      "getAttr",
+      "getContext",
+      "getEnv",
+      "getFlake",
+      "groupBy",
+      "hasAttr",
+      "hasContext",
+      "hashFile",
+      "hashString",
+      "head",
+      "import",
+      "intersectAttrs",
+      "isAttrs",
+      "isBool",
+      "isFloat",
+      "isFunction",
+      "isInt",
+      "isList",
+      "isNull",
+      "isPath",
+      "isString",
+      "langVersion",
+      "length",
+      "lessThan",
+      "listToAttrs",
+      "map",
+      "mapAttrs",
+      "match",
+      "mul",
+      "nixPath",
+      "nixVersion",
+      "null",
+      "parseDrvName",
+      "parseFlakeRef",
+      "partition",
+      "path",
+      "pathExists",
+      "placeholder",
+      "readDir",
+      "readFile",
+      "readFileType",
+      "removeAttrs",
+      "replaceStrings",
+      "scopedImport",
+      "seq",
+      "sort",
+      "split",
+      "splitVersion",
+      "storeDir",
+      "storePath",
+      "stringLength",
+      "sub",
+      "substring",
+      "tail",
+      "throw",
+      "toFile",
+      "toJSON",
+      "toPath",
+      "toString",
+      "toXML",
+      "trace",
+      "traceVerbose",
+      "true",
+      "tryEval",
+      "typeOf",
+      "unsafeDiscardOutputDependency",
+      "unsafeDiscardStringContext",
+      "unsafeGetAttrPos",
+      "warn",
+      "zipAttrsWith"
+    ].map((b2) => `builtins\\.${b2}`)),
+    relevance: 10
+  };
+  const IDENTIFIER_REGEX = "[A-Za-z_][A-Za-z0-9_'-]*";
+  const LOOKUP_PATH = {
+    scope: "symbol",
+    match: new RegExp(`<${IDENTIFIER_REGEX}(/${IDENTIFIER_REGEX})*>`)
+  };
+  const PATH_PIECE = "[A-Za-z0-9_\\+\\.-]+";
+  const PATH = {
+    scope: "symbol",
+    match: new RegExp(`(\\.\\.|\\.|~)?/(${PATH_PIECE})?(/${PATH_PIECE})*(?=[\\s;])`)
+  };
+  const OPERATOR_WITHOUT_MINUS_REGEX = regex2.either(...[
+    "==",
+    "=",
+    "\\+\\+",
+    "\\+",
+    "<=",
+    "<\\|",
+    "<",
+    ">=",
+    ">",
+    "->",
+    "//",
+    "/",
+    "!=",
+    "!",
+    "\\|\\|",
+    "\\|>",
+    "\\?",
+    "\\*",
+    "&&"
+  ]);
+  const OPERATOR = {
+    scope: "operator",
+    match: regex2.concat(OPERATOR_WITHOUT_MINUS_REGEX, /(?!-)/),
+    relevance: 0
+  };
+  const NUMBER = {
+    scope: "number",
+    match: new RegExp(`${hljs2.NUMBER_RE}(?!-)`),
+    relevance: 0
+  };
+  const MINUS_OPERATOR = {
+    variants: [
+      {
+        scope: "operator",
+        beforeMatch: /\s/,
+        // The (?!>) is used to ensure this doesn't collide with the '->' operator
+        begin: /-(?!>)/
+      },
+      {
+        begin: [
+          new RegExp(`${hljs2.NUMBER_RE}`),
+          /-/,
+          /(?!>)/
+        ],
+        beginScope: {
+          1: "number",
+          2: "operator"
+        }
+      },
+      {
+        begin: [
+          OPERATOR_WITHOUT_MINUS_REGEX,
+          /-/,
+          /(?!>)/
+        ],
+        beginScope: {
+          1: "operator",
+          2: "operator"
+        }
+      }
+    ],
+    relevance: 0
+  };
+  const ATTRS = {
+    beforeMatch: /(^|\{|;)\s*/,
+    begin: new RegExp(`${IDENTIFIER_REGEX}(\\.${IDENTIFIER_REGEX})*\\s*=(?!=)`),
+    returnBegin: true,
+    relevance: 0,
+    contains: [
+      {
+        scope: "attr",
+        match: new RegExp(`${IDENTIFIER_REGEX}(\\.${IDENTIFIER_REGEX})*(?=\\s*=)`),
+        relevance: 0.2
+      }
+    ]
+  };
+  const NORMAL_ESCAPED_DOLLAR = {
+    scope: "char.escape",
+    match: /\\\$/
+  };
+  const INDENTED_ESCAPED_DOLLAR = {
+    scope: "char.escape",
+    match: /''\$/
+  };
+  const ANTIQUOTE = {
+    scope: "subst",
+    begin: /\$\{/,
+    end: /\}/,
+    keywords: KEYWORDS2
+  };
+  const ESCAPED_DOUBLEQUOTE = {
+    scope: "char.escape",
+    match: /'''/
+  };
+  const ESCAPED_LITERAL = {
+    scope: "char.escape",
+    match: /\\(?!\$)./
+  };
+  const STRING = {
+    scope: "string",
+    variants: [
+      {
+        begin: "''",
+        end: "''",
+        contains: [
+          INDENTED_ESCAPED_DOLLAR,
+          ANTIQUOTE,
+          ESCAPED_DOUBLEQUOTE,
+          ESCAPED_LITERAL
+        ]
+      },
+      {
+        begin: '"',
+        end: '"',
+        contains: [
+          NORMAL_ESCAPED_DOLLAR,
+          ANTIQUOTE,
+          ESCAPED_LITERAL
+        ]
+      }
+    ]
+  };
+  const FUNCTION_PARAMS = {
+    scope: "params",
+    match: new RegExp(`${IDENTIFIER_REGEX}\\s*:(?=\\s)`)
+  };
+  const EXPRESSIONS2 = [
+    NUMBER,
+    hljs2.HASH_COMMENT_MODE,
+    hljs2.C_BLOCK_COMMENT_MODE,
+    hljs2.COMMENT(
+      /\/\*\*(?!\/)/,
+      /\*\//,
+      {
+        subLanguage: "markdown",
+        relevance: 0
+      }
+    ),
+    BUILTINS,
+    STRING,
+    LOOKUP_PATH,
+    PATH,
+    FUNCTION_PARAMS,
+    ATTRS,
+    MINUS_OPERATOR,
+    OPERATOR
+  ];
+  ANTIQUOTE.contains = EXPRESSIONS2;
+  const REPL = [
+    {
+      scope: "meta.prompt",
+      match: /^nix-repl>(?=\s)/,
+      relevance: 10
+    },
+    {
+      scope: "meta",
+      beforeMatch: /\s+/,
+      begin: /:([a-z]+|\?)/
+    }
+  ];
+  return {
+    name: "Nix",
+    aliases: ["nixos"],
+    keywords: KEYWORDS2,
+    contains: EXPRESSIONS2.concat(REPL)
+  };
+}
 function ocaml(hljs2) {
   return {
     name: "OCaml",
@@ -98739,6 +99854,12 @@ lowlight.register("prolog", prolog);
 lowlight.register("tcl", tcl);
 lowlight.register("pascal", delphi);
 lowlight.register("delphi", delphi);
+lowlight.register("awk", awk);
+lowlight.register("axapta", axapta);
+lowlight.register("angelscript", angelscript);
+lowlight.register("asciidoc", asciidoc);
+lowlight.register("nix", nix);
+lowlight.register("ceylon", ceylon);
 const CodeBlockCustom = index_default$1.extend({
   addOptions() {
     return {
@@ -123139,7 +124260,7 @@ const _sfc_main = {
           ])), [
             [_directive_loading, unref(isLoading)]
           ]),
-          __props.limitLength != Infinity ? (openBlock(), createElementBlock("div", _hoisted_8, [
+          __props.limitLength != Infinity && !__props.isInline ? (openBlock(), createElementBlock("div", _hoisted_8, [
             createElementVNode("div", null, [
               renderSlot(_ctx.$slots, "default", {}, void 0, true)
             ]),
@@ -123150,7 +124271,7 @@ const _sfc_main = {
     };
   }
 };
-const TiptapVue = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-3f27f95b"]]);
+const TiptapVue = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-61a8ac4c"]]);
 const components = [
   {
     name: "TiptapVue",