udxcms 1.0.9 → 1.0.11

package/dist/components/cmsComponents/wiki/lib/highlight/lib/languages/ada.js

@@ -6,6 +6,7 @@ Description: Ada is a general-purpose programming language that has great suppor
              The first version appeared in the 80s, but it's still actively developed today with
              the newest standard being Ada2012.
 */
+
 // We try to support full Ada2012
 //
 // We highlight all appearances of types, keywords, literals (string, char, number, bool)
@@ -15,163 +16,179 @@ Description: Ada is a general-purpose programming language that has great suppor
 // Languages causing problems for language detection:
 // xml (broken by Foo : Bar type), elm (broken by Foo : Bar type), vbscript-html (broken by body keyword)
 // sql (ada default.txt has a lot of sql keywords)
+
 /** @type LanguageFn */
 function ada(hljs) {
-    // Regular expression for Ada numeric literals.
-    // stolen form the VHDL highlighter
-    // Decimal literal:
-    const INTEGER_RE = '\\d(_|\\d)*';
-    const EXPONENT_RE = '[eE][-+]?' + INTEGER_RE;
-    const DECIMAL_LITERAL_RE = INTEGER_RE + '(\\.' + INTEGER_RE + ')?' + '(' + EXPONENT_RE + ')?';
-    // Based literal:
-    const BASED_INTEGER_RE = '\\w+';
-    const BASED_LITERAL_RE = INTEGER_RE + '#' + BASED_INTEGER_RE + '(\\.' + BASED_INTEGER_RE + ')?' + '#' + '(' + EXPONENT_RE + ')?';
-    const NUMBER_RE = '\\b(' + BASED_LITERAL_RE + '|' + DECIMAL_LITERAL_RE + ')';
-    // Identifier regex
-    const ID_REGEX = '[A-Za-z](_?[A-Za-z0-9.])*';
-    // bad chars, only allowed in literals
-    const BAD_CHARS = `[]\\{\\}%#'"`;
-    // Ada doesn't have block comments, only line comments
-    const COMMENTS = hljs.COMMENT('--', '$');
-    // variable declarations of the form
-    // Foo : Bar := Baz;
-    // where only Bar will be highlighted
-    const VAR_DECLS = {
-        // TODO: These spaces are not required by the Ada syntax
-        // however, I have yet to see handwritten Ada code where
-        // someone does not put spaces around :
-        begin: '\\s+:\\s+',
-        end: '\\s*(:=|;|\\)|=>|$)',
-        // endsWithParent: true,
-        // returnBegin: true,
-        illegal: BAD_CHARS,
-        contains: [
-            {
-                // workaround to avoid highlighting
-                // named loops and declare blocks
-                beginKeywords: 'loop for declare others',
-                endsParent: true
-            },
-            {
-                // properly highlight all modifiers
-                className: 'keyword',
-                beginKeywords: 'not null constant access function procedure in out aliased exception'
-            },
-            {
-                className: 'type',
-                begin: ID_REGEX,
-                endsParent: true,
-                relevance: 0
-            }
-        ]
-    };
-    return {
-        name: 'Ada',
-        case_insensitive: true,
-        keywords: {
-            keyword: 'abort else new return abs elsif not reverse abstract end ' +
+  // Regular expression for Ada numeric literals.
+  // stolen form the VHDL highlighter
+
+  // Decimal literal:
+  const INTEGER_RE = '\\d(_|\\d)*';
+  const EXPONENT_RE = '[eE][-+]?' + INTEGER_RE;
+  const DECIMAL_LITERAL_RE = INTEGER_RE + '(\\.' + INTEGER_RE + ')?' + '(' + EXPONENT_RE + ')?';
+
+  // Based literal:
+  const BASED_INTEGER_RE = '\\w+';
+  const BASED_LITERAL_RE = INTEGER_RE + '#' + BASED_INTEGER_RE + '(\\.' + BASED_INTEGER_RE + ')?' + '#' + '(' + EXPONENT_RE + ')?';
+
+  const NUMBER_RE = '\\b(' + BASED_LITERAL_RE + '|' + DECIMAL_LITERAL_RE + ')';
+
+  // Identifier regex
+  const ID_REGEX = '[A-Za-z](_?[A-Za-z0-9.])*';
+
+  // bad chars, only allowed in literals
+  const BAD_CHARS = `[]\\{\\}%#'"`;
+
+  // Ada doesn't have block comments, only line comments
+  const COMMENTS = hljs.COMMENT('--', '$');
+
+  // variable declarations of the form
+  // Foo : Bar := Baz;
+  // where only Bar will be highlighted
+  const VAR_DECLS = {
+    // TODO: These spaces are not required by the Ada syntax
+    // however, I have yet to see handwritten Ada code where
+    // someone does not put spaces around :
+    begin: '\\s+:\\s+',
+    end: '\\s*(:=|;|\\)|=>|$)',
+    // endsWithParent: true,
+    // returnBegin: true,
+    illegal: BAD_CHARS,
+    contains: [
+      {
+        // workaround to avoid highlighting
+        // named loops and declare blocks
+        beginKeywords: 'loop for declare others',
+        endsParent: true
+      },
+      {
+        // properly highlight all modifiers
+        className: 'keyword',
+        beginKeywords: 'not null constant access function procedure in out aliased exception'
+      },
+      {
+        className: 'type',
+        begin: ID_REGEX,
+        endsParent: true,
+        relevance: 0
+      }
+    ]
+  };
+
+  return {
+    name: 'Ada',
+    case_insensitive: true,
+    keywords: {
+      keyword:
+                'abort else new return abs elsif not reverse abstract end ' +
                 'accept entry select access exception of separate aliased exit or some ' +
                 'all others subtype and for out synchronized array function overriding ' +
                 'at tagged generic package task begin goto pragma terminate ' +
                 'body private then if procedure type case in protected constant interface ' +
                 'is raise use declare range delay limited record when delta loop rem while ' +
                 'digits renames with do mod requeue xor',
-            literal: 'True False'
-        },
-        contains: [
-            COMMENTS,
-            // strings "foobar"
-            {
-                className: 'string',
-                begin: /"/,
-                end: /"/,
-                contains: [{
-                        begin: /""/,
-                        relevance: 0
-                    }]
-            },
-            // characters ''
-            {
-                // character literals always contain one char
-                className: 'string',
-                begin: /'.'/
-            },
-            {
-                // number literals
-                className: 'number',
-                begin: NUMBER_RE,
-                relevance: 0
-            },
-            {
-                // Attributes
-                className: 'symbol',
-                begin: "'" + ID_REGEX
-            },
-            {
-                // package definition, maybe inside generic
-                className: 'title',
-                begin: '(\\bwith\\s+)?(\\bprivate\\s+)?\\bpackage\\s+(\\bbody\\s+)?',
-                end: '(is|$)',
-                keywords: 'package body',
-                excludeBegin: true,
-                excludeEnd: true,
-                illegal: BAD_CHARS
-            },
-            {
-                // function/procedure declaration/definition
-                // maybe inside generic
-                begin: '(\\b(with|overriding)\\s+)?\\b(function|procedure)\\s+',
-                end: '(\\bis|\\bwith|\\brenames|\\)\\s*;)',
-                keywords: 'overriding function procedure with is renames return',
-                // we need to re-match the 'function' keyword, so that
-                // the title mode below matches only exactly once
-                returnBegin: true,
-                contains: [
-                    COMMENTS,
-                    {
-                        // name of the function/procedure
-                        className: 'title',
-                        begin: '(\\bwith\\s+)?\\b(function|procedure)\\s+',
-                        end: '(\\(|\\s+|$)',
-                        excludeBegin: true,
-                        excludeEnd: true,
-                        illegal: BAD_CHARS
-                    },
-                    // 'self'
-                    // // parameter types
-                    VAR_DECLS,
-                    {
-                        // return type
-                        className: 'type',
-                        begin: '\\breturn\\s+',
-                        end: '(\\s+|;|$)',
-                        keywords: 'return',
-                        excludeBegin: true,
-                        excludeEnd: true,
-                        // we are done with functions
-                        endsParent: true,
-                        illegal: BAD_CHARS
-                    }
+      literal:
+                'True False'
+    },
+    contains: [
+      COMMENTS,
+      // strings "foobar"
+      {
+        className: 'string',
+        begin: /"/,
+        end: /"/,
+        contains: [{
+          begin: /""/,
+          relevance: 0
+        }]
+      },
+      // characters ''
+      {
+        // character literals always contain one char
+        className: 'string',
+        begin: /'.'/
+      },
+      {
+        // number literals
+        className: 'number',
+        begin: NUMBER_RE,
+        relevance: 0
+      },
+      {
+        // Attributes
+        className: 'symbol',
+        begin: "'" + ID_REGEX
+      },
+      {
+        // package definition, maybe inside generic
+        className: 'title',
+        begin: '(\\bwith\\s+)?(\\bprivate\\s+)?\\bpackage\\s+(\\bbody\\s+)?',
+        end: '(is|$)',
+        keywords: 'package body',
+        excludeBegin: true,
+        excludeEnd: true,
+        illegal: BAD_CHARS
+      },
+      {
+        // function/procedure declaration/definition
+        // maybe inside generic
+        begin: '(\\b(with|overriding)\\s+)?\\b(function|procedure)\\s+',
+        end: '(\\bis|\\bwith|\\brenames|\\)\\s*;)',
+        keywords: 'overriding function procedure with is renames return',
+        // we need to re-match the 'function' keyword, so that
+        // the title mode below matches only exactly once
+        returnBegin: true,
+        contains:
+                [
+                  COMMENTS,
+                  {
+                    // name of the function/procedure
+                    className: 'title',
+                    begin: '(\\bwith\\s+)?\\b(function|procedure)\\s+',
+                    end: '(\\(|\\s+|$)',
+                    excludeBegin: true,
+                    excludeEnd: true,
+                    illegal: BAD_CHARS
+                  },
+                  // 'self'
+                  // // parameter types
+                  VAR_DECLS,
+                  {
+                    // return type
+                    className: 'type',
+                    begin: '\\breturn\\s+',
+                    end: '(\\s+|;|$)',
+                    keywords: 'return',
+                    excludeBegin: true,
+                    excludeEnd: true,
+                    // we are done with functions
+                    endsParent: true,
+                    illegal: BAD_CHARS
+
+                  }
                 ]
-            },
-            {
-                // new type declarations
-                // maybe inside generic
-                className: 'type',
-                begin: '\\b(sub)?type\\s+',
-                end: '\\s+',
-                keywords: 'type',
-                excludeBegin: true,
-                illegal: BAD_CHARS
-            },
-            // see comment above the definition
-            VAR_DECLS
-            // no markup
-            // relevance boosters for small snippets
-            // {begin: '\\s*=>\\s*'},
-            // {begin: '\\s*:=\\s*'},
-            // {begin: '\\s+:=\\s+'},
-        ]
-    };
+      },
+      {
+        // new type declarations
+        // maybe inside generic
+        className: 'type',
+        begin: '\\b(sub)?type\\s+',
+        end: '\\s+',
+        keywords: 'type',
+        excludeBegin: true,
+        illegal: BAD_CHARS
+      },
+
+      // see comment above the definition
+      VAR_DECLS
+
+      // no markup
+      // relevance boosters for small snippets
+      // {begin: '\\s*=>\\s*'},
+      // {begin: '\\s*:=\\s*'},
+      // {begin: '\\s+:=\\s+'},
+    ]
+  };
 }
+
 module.exports = ada;

package/dist/components/cmsComponents/wiki/lib/highlight/lib/languages/angelscript.js

@@ -4,101 +4,120 @@ Author: Melissa Geels <melissa@nimble.tools>
 Category: scripting
 Website: https://www.angelcode.com/angelscript/
 */
+
 /** @type LanguageFn */
 function angelscript(hljs) {
-    var builtInTypeMode = {
-        className: 'built_in',
-        begin: '\\b(void|bool|int|int8|int16|int32|int64|uint|uint8|uint16|uint32|uint64|string|ref|array|double|float|auto|dictionary)'
-    };
-    var objectHandleMode = {
-        className: 'symbol',
-        begin: '[a-zA-Z0-9_]+@'
-    };
-    var genericMode = {
-        className: 'keyword',
-        begin: '<', end: '>',
-        contains: [builtInTypeMode, objectHandleMode]
-    };
-    builtInTypeMode.contains = [genericMode];
-    objectHandleMode.contains = [genericMode];
-    return {
-        name: 'AngelScript',
-        aliases: ['asc'],
-        keywords: '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',
-        // avoid close detection with C# and JS
-        illegal: '(^using\\s+[A-Za-z0-9_\\.]+;$|\\bfunction\\s*[^\\(])',
+  var builtInTypeMode = {
+    className: 'built_in',
+    begin: '\\b(void|bool|int|int8|int16|int32|int64|uint|uint8|uint16|uint32|uint64|string|ref|array|double|float|auto|dictionary)'
+  };
+
+  var objectHandleMode = {
+    className: 'symbol',
+    begin: '[a-zA-Z0-9_]+@'
+  };
+
+  var genericMode = {
+    className: 'keyword',
+    begin: '<', end: '>',
+    contains: [ builtInTypeMode, objectHandleMode ]
+  };
+
+  builtInTypeMode.contains = [ genericMode ];
+  objectHandleMode.contains = [ genericMode ];
+
+  return {
+    name: 'AngelScript',
+    aliases: ['asc'],
+
+    keywords:
+      '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',
+
+    // 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: [ hljs.BACKSLASH_ESCAPE ],
+        relevance: 0
+      },
+
+      // """heredoc strings"""
+      {
+        className: 'string',
+        begin: '"""', end: '"""'
+      },
+
+      { // "strings"
+        className: 'string',
+        begin: '"', end: '"',
+        illegal: '\\n',
+        contains: [ hljs.BACKSLASH_ESCAPE ],
+        relevance: 0
+      },
+
+      hljs.C_LINE_COMMENT_MODE, // single-line comments
+      hljs.C_BLOCK_COMMENT_MODE, // comment blocks
+
+      { // metadata
+        className: 'string',
+        begin: '^\\s*\\[', end: '\\]',
+      },
+
+      { // interface or namespace declaration
+        beginKeywords: 'interface namespace', end: /\{/,
+        illegal: '[;.\\-]',
         contains: [
-            {
-                className: 'string',
-                begin: '\'', end: '\'',
-                illegal: '\\n',
-                contains: [hljs.BACKSLASH_ESCAPE],
-                relevance: 0
-            },
-            // """heredoc strings"""
-            {
-                className: 'string',
-                begin: '"""', end: '"""'
-            },
-            {
-                className: 'string',
-                begin: '"', end: '"',
-                illegal: '\\n',
-                contains: [hljs.BACKSLASH_ESCAPE],
-                relevance: 0
-            },
-            hljs.C_LINE_COMMENT_MODE, // single-line comments
-            hljs.C_BLOCK_COMMENT_MODE, // comment blocks
-            {
-                className: 'string',
-                begin: '^\\s*\\[', end: '\\]',
-            },
-            {
-                beginKeywords: 'interface namespace', end: /\{/,
-                illegal: '[;.\\-]',
-                contains: [
-                    {
-                        className: 'symbol',
-                        begin: '[a-zA-Z0-9_]+'
-                    }
-                ]
-            },
-            {
-                beginKeywords: 'class', end: /\{/,
-                illegal: '[;.\\-]',
+          { // 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_]+',
-                        contains: [
-                            {
-                                begin: '[:,]\\s*',
-                                contains: [
-                                    {
-                                        className: 'symbol',
-                                        begin: '[a-zA-Z0-9_]+'
-                                    }
-                                ]
-                            }
-                        ]
-                    }
+                  {
+                    className: 'symbol',
+                    begin: '[a-zA-Z0-9_]+'
+                  }
                 ]
-            },
-            builtInTypeMode, // built-in types
-            objectHandleMode, // object handles
-            {
-                className: 'literal',
-                begin: '\\b(null|true|false)'
-            },
-            {
-                className: 'number',
-                relevance: 0,
-                begin: '(-?)(\\b0[xXbBoOdD][a-fA-F0-9]+|(\\b\\d+(\\.\\d*)?f?|\\.\\d+f?)([eE][-+]?\\d+f?)?)'
-            }
+              }
+            ]
+          }
         ]
-    };
+      },
+
+      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?)?)'
+      }
+    ]
+  };
 }
+
 module.exports = angelscript;