udxcms 1.0.1

package/dist/components/cmsComponents/sdk/lib/highlight/lib/languages/d.js

@@ -0,0 +1,271 @@
+/*
+Language: D
+Author: Aleksandar Ruzicic <aleksandar@ruzicic.info>
+Description: D is a language with C-like syntax and static typing. It pragmatically combines efficiency, control, and modeling power, with safety and programmer productivity.
+Version: 1.0a
+Website: https://dlang.org
+Date: 2012-04-08
+*/
+
+/**
+ * Known issues:
+ *
+ * - invalid hex string literals will be recognized as a double quoted strings
+ *   but 'x' at the beginning of string will not be matched
+ *
+ * - delimited string literals are not checked for matching end delimiter
+ *   (not possible to do with js regexp)
+ *
+ * - content of token string is colored as a string (i.e. no keyword coloring inside a token string)
+ *   also, content of token string is not validated to contain only valid D tokens
+ *
+ * - special token sequence rule is not strictly following D grammar (anything following #line
+ *   up to the end of line is matched as special token sequence)
+ */
+
+/** @type LanguageFn */
+function d(hljs) {
+  /**
+   * Language keywords
+   *
+   * @type {Object}
+   */
+  const D_KEYWORDS = {
+    $pattern: hljs.UNDERSCORE_IDENT_RE,
+    keyword:
+      'abstract alias align asm assert auto body break byte case cast catch class ' +
+      'const continue debug default delete deprecated do else enum export extern final ' +
+      'finally for foreach foreach_reverse|10 goto if immutable import in inout int ' +
+      'interface invariant is lazy macro mixin module new nothrow out override package ' +
+      'pragma private protected public pure ref return scope shared static struct ' +
+      'super switch synchronized template this throw try typedef typeid typeof union ' +
+      'unittest version void volatile while with __FILE__ __LINE__ __gshared|10 ' +
+      '__thread __traits __DATE__ __EOF__ __TIME__ __TIMESTAMP__ __VENDOR__ __VERSION__',
+    built_in:
+      'bool cdouble cent cfloat char creal dchar delegate double dstring float function ' +
+      'idouble ifloat ireal long real short string ubyte ucent uint ulong ushort wchar ' +
+      'wstring',
+    literal:
+      'false null true'
+  };
+
+  /**
+   * Number literal regexps
+   *
+   * @type {String}
+   */
+  const decimal_integer_re = '(0|[1-9][\\d_]*)';
+  const decimal_integer_nosus_re = '(0|[1-9][\\d_]*|\\d[\\d_]*|[\\d_]+?\\d)';
+  const binary_integer_re = '0[bB][01_]+';
+  const hexadecimal_digits_re = '([\\da-fA-F][\\da-fA-F_]*|_[\\da-fA-F][\\da-fA-F_]*)';
+  const hexadecimal_integer_re = '0[xX]' + hexadecimal_digits_re;
+
+  const decimal_exponent_re = '([eE][+-]?' + decimal_integer_nosus_re + ')';
+  const decimal_float_re = '(' + decimal_integer_nosus_re + '(\\.\\d*|' + decimal_exponent_re + ')|' +
+                '\\d+\\.' + decimal_integer_nosus_re + '|' +
+                '\\.' + decimal_integer_re + decimal_exponent_re + '?' +
+              ')';
+  const hexadecimal_float_re = '(0[xX](' +
+                  hexadecimal_digits_re + '\\.' + hexadecimal_digits_re + '|' +
+                  '\\.?' + hexadecimal_digits_re +
+                 ')[pP][+-]?' + decimal_integer_nosus_re + ')';
+
+  const integer_re = '(' +
+      decimal_integer_re + '|' +
+      binary_integer_re + '|' +
+       hexadecimal_integer_re +
+    ')';
+
+  const float_re = '(' +
+      hexadecimal_float_re + '|' +
+      decimal_float_re +
+    ')';
+
+  /**
+   * Escape sequence supported in D string and character literals
+   *
+   * @type {String}
+   */
+  const escape_sequence_re = '\\\\(' +
+              '[\'"\\?\\\\abfnrtv]|' + // common escapes
+              'u[\\dA-Fa-f]{4}|' + // four hex digit unicode codepoint
+              '[0-7]{1,3}|' + // one to three octal digit ascii char code
+              'x[\\dA-Fa-f]{2}|' + // two hex digit ascii char code
+              'U[\\dA-Fa-f]{8}' + // eight hex digit unicode codepoint
+              ')|' +
+              '&[a-zA-Z\\d]{2,};'; // named character entity
+
+  /**
+   * D integer number literals
+   *
+   * @type {Object}
+   */
+  const D_INTEGER_MODE = {
+    className: 'number',
+    begin: '\\b' + integer_re + '(L|u|U|Lu|LU|uL|UL)?',
+    relevance: 0
+  };
+
+  /**
+   * [D_FLOAT_MODE description]
+   * @type {Object}
+   */
+  const D_FLOAT_MODE = {
+    className: 'number',
+    begin: '\\b(' +
+        float_re + '([fF]|L|i|[fF]i|Li)?|' +
+        integer_re + '(i|[fF]i|Li)' +
+      ')',
+    relevance: 0
+  };
+
+  /**
+   * D character literal
+   *
+   * @type {Object}
+   */
+  const D_CHARACTER_MODE = {
+    className: 'string',
+    begin: '\'(' + escape_sequence_re + '|.)',
+    end: '\'',
+    illegal: '.'
+  };
+
+  /**
+   * D string escape sequence
+   *
+   * @type {Object}
+   */
+  const D_ESCAPE_SEQUENCE = {
+    begin: escape_sequence_re,
+    relevance: 0
+  };
+
+  /**
+   * D double quoted string literal
+   *
+   * @type {Object}
+   */
+  const D_STRING_MODE = {
+    className: 'string',
+    begin: '"',
+    contains: [D_ESCAPE_SEQUENCE],
+    end: '"[cwd]?'
+  };
+
+  /**
+   * D wysiwyg and delimited string literals
+   *
+   * @type {Object}
+   */
+  const D_WYSIWYG_DELIMITED_STRING_MODE = {
+    className: 'string',
+    begin: '[rq]"',
+    end: '"[cwd]?',
+    relevance: 5
+  };
+
+  /**
+   * D alternate wysiwyg string literal
+   *
+   * @type {Object}
+   */
+  const D_ALTERNATE_WYSIWYG_STRING_MODE = {
+    className: 'string',
+    begin: '`',
+    end: '`[cwd]?'
+  };
+
+  /**
+   * D hexadecimal string literal
+   *
+   * @type {Object}
+   */
+  const D_HEX_STRING_MODE = {
+    className: 'string',
+    begin: 'x"[\\da-fA-F\\s\\n\\r]*"[cwd]?',
+    relevance: 10
+  };
+
+  /**
+   * D delimited string literal
+   *
+   * @type {Object}
+   */
+  const D_TOKEN_STRING_MODE = {
+    className: 'string',
+    begin: 'q"\\{',
+    end: '\\}"'
+  };
+
+  /**
+   * Hashbang support
+   *
+   * @type {Object}
+   */
+  const D_HASHBANG_MODE = {
+    className: 'meta',
+    begin: '^#!',
+    end: '$',
+    relevance: 5
+  };
+
+  /**
+   * D special token sequence
+   *
+   * @type {Object}
+   */
+  const D_SPECIAL_TOKEN_SEQUENCE_MODE = {
+    className: 'meta',
+    begin: '#(line)',
+    end: '$',
+    relevance: 5
+  };
+
+  /**
+   * D attributes
+   *
+   * @type {Object}
+   */
+  const D_ATTRIBUTE_MODE = {
+    className: 'keyword',
+    begin: '@[a-zA-Z_][a-zA-Z_\\d]*'
+  };
+
+  /**
+   * D nesting comment
+   *
+   * @type {Object}
+   */
+  const D_NESTING_COMMENT_MODE = hljs.COMMENT(
+    '\\/\\+',
+    '\\+\\/',
+    {
+      contains: ['self'],
+      relevance: 10
+    }
+  );
+
+  return {
+    name: 'D',
+    keywords: D_KEYWORDS,
+    contains: [
+      hljs.C_LINE_COMMENT_MODE,
+      hljs.C_BLOCK_COMMENT_MODE,
+      D_NESTING_COMMENT_MODE,
+      D_HEX_STRING_MODE,
+      D_STRING_MODE,
+      D_WYSIWYG_DELIMITED_STRING_MODE,
+      D_ALTERNATE_WYSIWYG_STRING_MODE,
+      D_TOKEN_STRING_MODE,
+      D_FLOAT_MODE,
+      D_INTEGER_MODE,
+      D_CHARACTER_MODE,
+      D_HASHBANG_MODE,
+      D_SPECIAL_TOKEN_SEQUENCE_MODE,
+      D_ATTRIBUTE_MODE
+    ]
+  };
+}
+
+module.exports = d;

package/dist/components/cmsComponents/sdk/lib/highlight/lib/languages/dart.d.ts

@@ -0,0 +1,11 @@
+export = dart;
+/** @type LanguageFn */
+declare function dart(hljs: any): {
+    name: string;
+    keywords: {
+        keyword: string;
+        built_in: string[];
+        $pattern: RegExp;
+    };
+    contains: any[];
+};

package/dist/components/cmsComponents/sdk/lib/highlight/lib/languages/dart.js

@@ -0,0 +1,199 @@
+/*
+Language: Dart
+Requires: markdown.js
+Author: Maxim Dikun <dikmax@gmail.com>
+Description: Dart a modern, object-oriented language developed by Google. For more information see https://www.dartlang.org/
+Website: https://dart.dev
+Category: scripting
+*/
+
+/** @type LanguageFn */
+function dart(hljs) {
+  const SUBST = {
+    className: 'subst',
+    variants: [{
+      begin: '\\$[A-Za-z0-9_]+'
+    }]
+  };
+
+  const BRACED_SUBST = {
+    className: 'subst',
+    variants: [{
+      begin: /\$\{/,
+      end: /\}/
+    }],
+    keywords: 'true false null this is new super'
+  };
+
+  const STRING = {
+    className: 'string',
+    variants: [
+      {
+        begin: 'r\'\'\'',
+        end: '\'\'\''
+      },
+      {
+        begin: 'r"""',
+        end: '"""'
+      },
+      {
+        begin: 'r\'',
+        end: '\'',
+        illegal: '\\n'
+      },
+      {
+        begin: 'r"',
+        end: '"',
+        illegal: '\\n'
+      },
+      {
+        begin: '\'\'\'',
+        end: '\'\'\'',
+        contains: [
+          hljs.BACKSLASH_ESCAPE,
+          SUBST,
+          BRACED_SUBST
+        ]
+      },
+      {
+        begin: '"""',
+        end: '"""',
+        contains: [
+          hljs.BACKSLASH_ESCAPE,
+          SUBST,
+          BRACED_SUBST
+        ]
+      },
+      {
+        begin: '\'',
+        end: '\'',
+        illegal: '\\n',
+        contains: [
+          hljs.BACKSLASH_ESCAPE,
+          SUBST,
+          BRACED_SUBST
+        ]
+      },
+      {
+        begin: '"',
+        end: '"',
+        illegal: '\\n',
+        contains: [
+          hljs.BACKSLASH_ESCAPE,
+          SUBST,
+          BRACED_SUBST
+        ]
+      }
+    ]
+  };
+  BRACED_SUBST.contains = [
+    hljs.C_NUMBER_MODE,
+    STRING
+  ];
+
+  const BUILT_IN_TYPES = [
+    // dart:core
+    'Comparable',
+    'DateTime',
+    'Duration',
+    'Function',
+    'Iterable',
+    'Iterator',
+    'List',
+    'Map',
+    'Match',
+    'Object',
+    'Pattern',
+    'RegExp',
+    'Set',
+    'Stopwatch',
+    'String',
+    'StringBuffer',
+    'StringSink',
+    'Symbol',
+    'Type',
+    'Uri',
+    'bool',
+    'double',
+    'int',
+    'num',
+    // dart:html
+    'Element',
+    'ElementList'
+  ];
+  const NULLABLE_BUILT_IN_TYPES = BUILT_IN_TYPES.map((e) => `${e}?`);
+
+  const KEYWORDS = {
+    keyword: 'abstract as assert async await break case catch class const continue covariant default deferred do ' +
+      'dynamic else enum export extends extension external factory false final finally for Function get hide if ' +
+      'implements import in inferface is late library mixin new null on operator part required rethrow return set ' +
+      'show static super switch sync this throw true try typedef var void while with yield',
+    built_in:
+      BUILT_IN_TYPES
+        .concat(NULLABLE_BUILT_IN_TYPES)
+        .concat([
+          // dart:core
+          'Never',
+          'Null',
+          'dynamic',
+          'print',
+          // dart:html
+          'document',
+          'querySelector',
+          'querySelectorAll',
+          'window'
+        ]),
+    $pattern: /[A-Za-z][A-Za-z0-9_]*\??/
+  };
+
+  return {
+    name: 'Dart',
+    keywords: KEYWORDS,
+    contains: [
+      STRING,
+      hljs.COMMENT(
+        /\/\*\*(?!\/)/,
+        /\*\//,
+        {
+          subLanguage: 'markdown',
+          relevance: 0
+        }
+      ),
+      hljs.COMMENT(
+        /\/{3,} ?/,
+        /$/, {
+          contains: [{
+            subLanguage: 'markdown',
+            begin: '.',
+            end: '$',
+            relevance: 0
+          }]
+        }
+      ),
+      hljs.C_LINE_COMMENT_MODE,
+      hljs.C_BLOCK_COMMENT_MODE,
+      {
+        className: 'class',
+        beginKeywords: 'class interface',
+        end: /\{/,
+        excludeEnd: true,
+        contains: [
+          {
+            beginKeywords: 'extends implements'
+          },
+          hljs.UNDERSCORE_TITLE_MODE
+        ]
+      },
+      hljs.C_NUMBER_MODE,
+      {
+        className: 'meta',
+        begin: '@[A-Za-z]+'
+      },
+      {
+        begin: '=>' // No markup, just a relevance booster
+      }
+    ]
+  };
+}
+
+module.exports = dart;

package/dist/components/cmsComponents/sdk/lib/highlight/lib/languages/delphi.d.ts

@@ -0,0 +1,10 @@
+export = delphi;
+/** @type LanguageFn */
+declare function delphi(hljs: any): {
+    name: string;
+    aliases: string[];
+    case_insensitive: boolean;
+    keywords: string;
+    illegal: RegExp;
+    contains: any[];
+};

package/dist/components/cmsComponents/sdk/lib/highlight/lib/languages/delphi.js

@@ -0,0 +1,126 @@
+/*
+Language: Delphi
+Website: https://www.embarcadero.com/products/delphi
+*/
+
+/** @type LanguageFn */
+function delphi(hljs) {
+  const KEYWORDS =
+    'exports register file shl array record property for mod while set ally label uses raise not ' +
+    'stored class safecall var interface or private static exit index inherited to else stdcall ' +
+    'override shr asm far resourcestring finalization packed virtual out and protected library do ' +
+    'xorwrite goto near function end div overload object unit begin string on inline repeat until ' +
+    'destructor write message program with read initialization except default nil if case cdecl in ' +
+    'downto threadvar of try pascal const external constructor type public then implementation ' +
+    'finally published procedure absolute reintroduce operator as is abstract alias assembler ' +
+    'bitpacked break continue cppdecl cvar enumerator experimental platform deprecated ' +
+    'unimplemented dynamic export far16 forward generic helper implements interrupt iochecks ' +
+    'local name nodefault noreturn nostackframe oldfpccall otherwise saveregisters softfloat ' +
+    'specialize strict unaligned varargs ';
+  const COMMENT_MODES = [
+    hljs.C_LINE_COMMENT_MODE,
+    hljs.COMMENT(/\{/, /\}/, {
+      relevance: 0
+    }),
+    hljs.COMMENT(/\(\*/, /\*\)/, {
+      relevance: 10
+    })
+  ];
+  const DIRECTIVE = {
+    className: 'meta',
+    variants: [
+      {
+        begin: /\{\$/,
+        end: /\}/
+      },
+      {
+        begin: /\(\*\$/,
+        end: /\*\)/
+      }
+    ]
+  };
+  const STRING = {
+    className: 'string',
+    begin: /'/,
+    end: /'/,
+    contains: [{
+      begin: /''/
+    }]
+  };
+  const NUMBER = {
+    className: 'number',
+    relevance: 0,
+    // Source: https://www.freepascal.org/docs-html/ref/refse6.html
+    variants: [
+      {
+        // Hexadecimal notation, e.g., $7F.
+        begin: '\\$[0-9A-Fa-f]+'
+      },
+      {
+        // Octal notation, e.g., &42.
+        begin: '&[0-7]+'
+      },
+      {
+        // Binary notation, e.g., %1010.
+        begin: '%[01]+'
+      }
+    ]
+  };
+  const CHAR_STRING = {
+    className: 'string',
+    begin: /(#\d+)+/
+  };
+  const CLASS = {
+    begin: hljs.IDENT_RE + '\\s*=\\s*class\\s*\\(',
+    returnBegin: true,
+    contains: [hljs.TITLE_MODE]
+  };
+  const FUNCTION = {
+    className: 'function',
+    beginKeywords: 'function constructor destructor procedure',
+    end: /[:;]/,
+    keywords: 'function constructor|10 destructor|10 procedure|10',
+    contains: [
+      hljs.TITLE_MODE,
+      {
+        className: 'params',
+        begin: /\(/,
+        end: /\)/,
+        keywords: KEYWORDS,
+        contains: [
+          STRING,
+          CHAR_STRING,
+          DIRECTIVE
+        ].concat(COMMENT_MODES)
+      },
+      DIRECTIVE
+    ].concat(COMMENT_MODES)
+  };
+  return {
+    name: 'Delphi',
+    aliases: [
+      'dpr',
+      'dfm',
+      'pas',
+      'pascal',
+      'freepascal',
+      'lazarus',
+      'lpr',
+      'lfm'
+    ],
+    case_insensitive: true,
+    keywords: KEYWORDS,
+    illegal: /"|\$[G-Zg-z]|\/\*|<\/|\|/,
+    contains: [
+      STRING,
+      CHAR_STRING,
+      hljs.NUMBER_MODE,
+      NUMBER,
+      CLASS,
+      FUNCTION,
+      DIRECTIVE
+    ].concat(COMMENT_MODES)
+  };
+}
+
+module.exports = delphi;

package/dist/components/cmsComponents/sdk/lib/highlight/lib/languages/diff.d.ts

@@ -0,0 +1,33 @@
+export = diff;
+/** @type LanguageFn */
+declare function diff(hljs: any): {
+    name: string;
+    aliases: string[];
+    contains: ({
+        className: string;
+        relevance: number;
+        variants: {
+            begin: RegExp;
+        }[];
+        begin?: undefined;
+        end?: undefined;
+    } | {
+        className: string;
+        variants: ({
+            begin: RegExp;
+            end: RegExp;
+        } | {
+            begin: RegExp;
+            end?: undefined;
+        })[];
+        relevance?: undefined;
+        begin?: undefined;
+        end?: undefined;
+    } | {
+        className: string;
+        begin: RegExp;
+        end: RegExp;
+        relevance?: undefined;
+        variants?: undefined;
+    })[];
+};