gsd-pi 2.9.0 → 2.10.1

package/node_modules/highlight.js/lib/languages/elixir.js

@@ -1,259 +0,0 @@
-/*
-Language: Elixir
-Author: Josh Adams <josh@isotope11.com>
-Description: language definition for Elixir source code files (.ex and .exs).  Based on ruby language support.
-Category: functional
-Website: https://elixir-lang.org
-*/
-
-/** @type LanguageFn */
-function elixir(hljs) {
-  const ELIXIR_IDENT_RE = '[a-zA-Z_][a-zA-Z0-9_.]*(!|\\?)?';
-  const ELIXIR_METHOD_RE = '[a-zA-Z_]\\w*[!?=]?|[-+~]@|<<|>>|=~|===?|<=>|[<>]=?|\\*\\*|[-/+%^&*~`|]|\\[\\]=?';
-  const ELIXIR_KEYWORDS = {
-    $pattern: ELIXIR_IDENT_RE,
-    keyword: 'and false then defined module in return redo retry end for true self when ' +
-    'next until do begin unless nil break not case cond alias while ensure or ' +
-    'include use alias fn quote require import with|0'
-  };
-  const SUBST = {
-    className: 'subst',
-    begin: /#\{/,
-    end: /\}/,
-    keywords: ELIXIR_KEYWORDS
-  };
-  const NUMBER = {
-    className: 'number',
-    begin: '(\\b0o[0-7_]+)|(\\b0b[01_]+)|(\\b0x[0-9a-fA-F_]+)|(-?\\b[1-9][0-9_]*(\\.[0-9_]+([eE][-+]?[0-9]+)?)?)',
-    relevance: 0
-  };
-  const SIGIL_DELIMITERS = '[/|([{<"\']';
-  const LOWERCASE_SIGIL = {
-    className: 'string',
-    begin: '~[a-z]' + '(?=' + SIGIL_DELIMITERS + ')',
-    contains: [
-      {
-        endsParent: true,
-        contains: [
-          {
-            contains: [
-              hljs.BACKSLASH_ESCAPE,
-              SUBST
-            ],
-            variants: [
-              {
-                begin: /"/,
-                end: /"/
-              },
-              {
-                begin: /'/,
-                end: /'/
-              },
-              {
-                begin: /\//,
-                end: /\//
-              },
-              {
-                begin: /\|/,
-                end: /\|/
-              },
-              {
-                begin: /\(/,
-                end: /\)/
-              },
-              {
-                begin: /\[/,
-                end: /\]/
-              },
-              {
-                begin: /\{/,
-                end: /\}/
-              },
-              {
-                begin: /</,
-                end: />/
-              }
-            ]
-          }
-        ]
-      }
-    ]
-  };
-
-  const UPCASE_SIGIL = {
-    className: 'string',
-    begin: '~[A-Z]' + '(?=' + SIGIL_DELIMITERS + ')',
-    contains: [
-      {
-        begin: /"/,
-        end: /"/
-      },
-      {
-        begin: /'/,
-        end: /'/
-      },
-      {
-        begin: /\//,
-        end: /\//
-      },
-      {
-        begin: /\|/,
-        end: /\|/
-      },
-      {
-        begin: /\(/,
-        end: /\)/
-      },
-      {
-        begin: /\[/,
-        end: /\]/
-      },
-      {
-        begin: /\{/,
-        end: /\}/
-      },
-      {
-        begin: /</,
-        end: />/
-      }
-    ]
-  };
-
-  const STRING = {
-    className: 'string',
-    contains: [
-      hljs.BACKSLASH_ESCAPE,
-      SUBST
-    ],
-    variants: [
-      {
-        begin: /"""/,
-        end: /"""/
-      },
-      {
-        begin: /'''/,
-        end: /'''/
-      },
-      {
-        begin: /~S"""/,
-        end: /"""/,
-        contains: [] // override default
-      },
-      {
-        begin: /~S"/,
-        end: /"/,
-        contains: [] // override default
-      },
-      {
-        begin: /~S'''/,
-        end: /'''/,
-        contains: [] // override default
-      },
-      {
-        begin: /~S'/,
-        end: /'/,
-        contains: [] // override default
-      },
-      {
-        begin: /'/,
-        end: /'/
-      },
-      {
-        begin: /"/,
-        end: /"/
-      }
-    ]
-  };
-  const FUNCTION = {
-    className: 'function',
-    beginKeywords: 'def defp defmacro',
-    end: /\B\b/, // the mode is ended by the title
-    contains: [
-      hljs.inherit(hljs.TITLE_MODE, {
-        begin: ELIXIR_IDENT_RE,
-        endsParent: true
-      })
-    ]
-  };
-  const CLASS = hljs.inherit(FUNCTION, {
-    className: 'class',
-    beginKeywords: 'defimpl defmodule defprotocol defrecord',
-    end: /\bdo\b|$|;/
-  });
-  const ELIXIR_DEFAULT_CONTAINS = [
-    STRING,
-    UPCASE_SIGIL,
-    LOWERCASE_SIGIL,
-    hljs.HASH_COMMENT_MODE,
-    CLASS,
-    FUNCTION,
-    {
-      begin: '::'
-    },
-    {
-      className: 'symbol',
-      begin: ':(?![\\s:])',
-      contains: [
-        STRING,
-        {
-          begin: ELIXIR_METHOD_RE
-        }
-      ],
-      relevance: 0
-    },
-    {
-      className: 'symbol',
-      begin: ELIXIR_IDENT_RE + ':(?!:)',
-      relevance: 0
-    },
-    NUMBER,
-    {
-      className: 'variable',
-      begin: '(\\$\\W)|((\\$|@@?)(\\w+))'
-    },
-    {
-      begin: '->'
-    },
-    { // regexp container
-      begin: '(' + hljs.RE_STARTERS_RE + ')\\s*',
-      contains: [
-        hljs.HASH_COMMENT_MODE,
-        {
-          // to prevent false regex triggers for the division function:
-          // /:
-          begin: /\/: (?=\d+\s*[,\]])/,
-          relevance: 0,
-          contains: [NUMBER]
-        },
-        {
-          className: 'regexp',
-          illegal: '\\n',
-          contains: [
-            hljs.BACKSLASH_ESCAPE,
-            SUBST
-          ],
-          variants: [
-            {
-              begin: '/',
-              end: '/[a-z]*'
-            },
-            {
-              begin: '%r\\[',
-              end: '\\][a-z]*'
-            }
-          ]
-        }
-      ],
-      relevance: 0
-    }
-  ];
-  SUBST.contains = ELIXIR_DEFAULT_CONTAINS;
-
-  return {
-    name: 'Elixir',
-    keywords: ELIXIR_KEYWORDS,
-    contains: ELIXIR_DEFAULT_CONTAINS
-  };
-}
-
-module.exports = elixir;

package/node_modules/highlight.js/lib/languages/elm.js

@@ -1,129 +0,0 @@
-/*
-Language: Elm
-Author: Janis Voigtlaender <janis.voigtlaender@gmail.com>
-Website: https://elm-lang.org
-Category: functional
-*/
-
-/** @type LanguageFn */
-function elm(hljs) {
-  const COMMENT = {
-    variants: [
-      hljs.COMMENT('--', '$'),
-      hljs.COMMENT(
-        /\{-/,
-        /-\}/,
-        {
-          contains: ['self']
-        }
-      )
-    ]
-  };
-
-  const CONSTRUCTOR = {
-    className: 'type',
-    begin: '\\b[A-Z][\\w\']*', // TODO: other constructors (built-in, infix).
-    relevance: 0
-  };
-
-  const LIST = {
-    begin: '\\(',
-    end: '\\)',
-    illegal: '"',
-    contains: [
-      {
-        className: 'type',
-        begin: '\\b[A-Z][\\w]*(\\((\\.\\.|,|\\w+)\\))?'
-      },
-      COMMENT
-    ]
-  };
-
-  const RECORD = {
-    begin: /\{/,
-    end: /\}/,
-    contains: LIST.contains
-  };
-
-  const CHARACTER = {
-    className: 'string',
-    begin: '\'\\\\?.',
-    end: '\'',
-    illegal: '.'
-  };
-
-  return {
-    name: 'Elm',
-    keywords:
-      'let in if then else case of where module import exposing ' +
-      'type alias as infix infixl infixr port effect command subscription',
-    contains: [
-
-      // Top-level constructions.
-
-      {
-        beginKeywords: 'port effect module',
-        end: 'exposing',
-        keywords: 'port effect module where command subscription exposing',
-        contains: [
-          LIST,
-          COMMENT
-        ],
-        illegal: '\\W\\.|;'
-      },
-      {
-        begin: 'import',
-        end: '$',
-        keywords: 'import as exposing',
-        contains: [
-          LIST,
-          COMMENT
-        ],
-        illegal: '\\W\\.|;'
-      },
-      {
-        begin: 'type',
-        end: '$',
-        keywords: 'type alias',
-        contains: [
-          CONSTRUCTOR,
-          LIST,
-          RECORD,
-          COMMENT
-        ]
-      },
-      {
-        beginKeywords: 'infix infixl infixr',
-        end: '$',
-        contains: [
-          hljs.C_NUMBER_MODE,
-          COMMENT
-        ]
-      },
-      {
-        begin: 'port',
-        end: '$',
-        keywords: 'port',
-        contains: [COMMENT]
-      },
-
-      // Literals and names.
-
-      CHARACTER,
-      hljs.QUOTE_STRING_MODE,
-      hljs.C_NUMBER_MODE,
-      CONSTRUCTOR,
-      hljs.inherit(hljs.TITLE_MODE, {
-        begin: '^[_a-z][\\w\']*'
-      }),
-      COMMENT,
-
-      {
-        begin: '->|<-'
-      } // No markup, relevance booster
-    ],
-    illegal: /;/
-  };
-}
-
-module.exports = elm;

package/node_modules/highlight.js/lib/languages/erb.js

@@ -1,29 +0,0 @@
-/*
-Language: ERB (Embedded Ruby)
-Requires: xml.js, ruby.js
-Author: Lucas Mazza <lucastmazza@gmail.com>
-Contributors: Kassio Borges <kassioborgesm@gmail.com>
-Description: "Bridge" language defining fragments of Ruby in HTML within <% .. %>
-Website: https://ruby-doc.org/stdlib-2.6.5/libdoc/erb/rdoc/ERB.html
-Category: template
-*/
-
-/** @type LanguageFn */
-function erb(hljs) {
-  return {
-    name: 'ERB',
-    subLanguage: 'xml',
-    contains: [
-      hljs.COMMENT('<%#', '%>'),
-      {
-        begin: '<%[%=-]?',
-        end: '[%-]?%>',
-        subLanguage: 'ruby',
-        excludeBegin: true,
-        excludeEnd: true
-      }
-    ]
-  };
-}
-
-module.exports = erb;

package/node_modules/highlight.js/lib/languages/erlang-repl.js

@@ -1,86 +0,0 @@
-/**
- * @param {string} value
- * @returns {RegExp}
- * */
-
-/**
- * @param {RegExp | string } re
- * @returns {string}
- */
-function source(re) {
-  if (!re) return null;
-  if (typeof re === "string") return re;
-
-  return re.source;
-}
-
-/**
- * @param {...(RegExp | string) } args
- * @returns {string}
- */
-function concat(...args) {
-  const joined = args.map((x) => source(x)).join("");
-  return joined;
-}
-
-/*
-Language: Erlang REPL
-Author: Sergey Ignatov <sergey@ignatov.spb.su>
-Website: https://www.erlang.org
-Category: functional
-*/
-
-/** @type LanguageFn */
-function erlangRepl(hljs) {
-  return {
-    name: 'Erlang REPL',
-    keywords: {
-      built_in:
-        'spawn spawn_link self',
-      keyword:
-        'after and andalso|10 band begin bnot bor bsl bsr bxor case catch cond div end fun if ' +
-        'let not of or orelse|10 query receive rem try when xor'
-    },
-    contains: [
-      {
-        className: 'meta',
-        begin: '^[0-9]+> ',
-        relevance: 10
-      },
-      hljs.COMMENT('%', '$'),
-      {
-        className: 'number',
-        begin: '\\b(\\d+(_\\d+)*#[a-fA-F0-9]+(_[a-fA-F0-9]+)*|\\d+(_\\d+)*(\\.\\d+(_\\d+)*)?([eE][-+]?\\d+)?)',
-        relevance: 0
-      },
-      hljs.APOS_STRING_MODE,
-      hljs.QUOTE_STRING_MODE,
-      {
-        begin: concat(
-          /\?(::)?/,
-          /([A-Z]\w*)/, // at least one identifier
-          /((::)[A-Z]\w*)*/ // perhaps more
-        )
-      },
-      {
-        begin: '->'
-      },
-      {
-        begin: 'ok'
-      },
-      {
-        begin: '!'
-      },
-      {
-        begin: '(\\b[a-z\'][a-zA-Z0-9_\']*:[a-z\'][a-zA-Z0-9_\']*)|(\\b[a-z\'][a-zA-Z0-9_\']*)',
-        relevance: 0
-      },
-      {
-        begin: '[A-Z][a-zA-Z0-9_\']*',
-        relevance: 0
-      }
-    ]
-  };
-}
-
-module.exports = erlangRepl;

package/node_modules/highlight.js/lib/languages/erlang.js

@@ -1,199 +0,0 @@
-/*
-Language: Erlang
-Description: Erlang is a general-purpose functional language, with strict evaluation, single assignment, and dynamic typing.
-Author: Nikolay Zakharov <nikolay.desh@gmail.com>, Dmitry Kovega <arhibot@gmail.com>
-Website: https://www.erlang.org
-Category: functional
-*/
-
-/** @type LanguageFn */
-function erlang(hljs) {
-  const BASIC_ATOM_RE = '[a-z\'][a-zA-Z0-9_\']*';
-  const FUNCTION_NAME_RE = '(' + BASIC_ATOM_RE + ':' + BASIC_ATOM_RE + '|' + BASIC_ATOM_RE + ')';
-  const ERLANG_RESERVED = {
-    keyword:
-      'after and andalso|10 band begin bnot bor bsl bzr bxor case catch cond div end fun if ' +
-      'let not of orelse|10 query receive rem try when xor',
-    literal:
-      'false true'
-  };
-
-  const COMMENT = hljs.COMMENT('%', '$');
-  const NUMBER = {
-    className: 'number',
-    begin: '\\b(\\d+(_\\d+)*#[a-fA-F0-9]+(_[a-fA-F0-9]+)*|\\d+(_\\d+)*(\\.\\d+(_\\d+)*)?([eE][-+]?\\d+)?)',
-    relevance: 0
-  };
-  const NAMED_FUN = {
-    begin: 'fun\\s+' + BASIC_ATOM_RE + '/\\d+'
-  };
-  const FUNCTION_CALL = {
-    begin: FUNCTION_NAME_RE + '\\(',
-    end: '\\)',
-    returnBegin: true,
-    relevance: 0,
-    contains: [
-      {
-        begin: FUNCTION_NAME_RE,
-        relevance: 0
-      },
-      {
-        begin: '\\(',
-        end: '\\)',
-        endsWithParent: true,
-        returnEnd: true,
-        relevance: 0
-        // "contains" defined later
-      }
-    ]
-  };
-  const TUPLE = {
-    begin: /\{/,
-    end: /\}/,
-    relevance: 0
-    // "contains" defined later
-  };
-  const VAR1 = {
-    begin: '\\b_([A-Z][A-Za-z0-9_]*)?',
-    relevance: 0
-  };
-  const VAR2 = {
-    begin: '[A-Z][a-zA-Z0-9_]*',
-    relevance: 0
-  };
-  const RECORD_ACCESS = {
-    begin: '#' + hljs.UNDERSCORE_IDENT_RE,
-    relevance: 0,
-    returnBegin: true,
-    contains: [
-      {
-        begin: '#' + hljs.UNDERSCORE_IDENT_RE,
-        relevance: 0
-      },
-      {
-        begin: /\{/,
-        end: /\}/,
-        relevance: 0
-        // "contains" defined later
-      }
-    ]
-  };
-
-  const BLOCK_STATEMENTS = {
-    beginKeywords: 'fun receive if try case',
-    end: 'end',
-    keywords: ERLANG_RESERVED
-  };
-  BLOCK_STATEMENTS.contains = [
-    COMMENT,
-    NAMED_FUN,
-    hljs.inherit(hljs.APOS_STRING_MODE, {
-      className: ''
-    }),
-    BLOCK_STATEMENTS,
-    FUNCTION_CALL,
-    hljs.QUOTE_STRING_MODE,
-    NUMBER,
-    TUPLE,
-    VAR1,
-    VAR2,
-    RECORD_ACCESS
-  ];
-
-  const BASIC_MODES = [
-    COMMENT,
-    NAMED_FUN,
-    BLOCK_STATEMENTS,
-    FUNCTION_CALL,
-    hljs.QUOTE_STRING_MODE,
-    NUMBER,
-    TUPLE,
-    VAR1,
-    VAR2,
-    RECORD_ACCESS
-  ];
-  FUNCTION_CALL.contains[1].contains = BASIC_MODES;
-  TUPLE.contains = BASIC_MODES;
-  RECORD_ACCESS.contains[1].contains = BASIC_MODES;
-
-  const DIRECTIVES = [
-    "-module",
-    "-record",
-    "-undef",
-    "-export",
-    "-ifdef",
-    "-ifndef",
-    "-author",
-    "-copyright",
-    "-doc",
-    "-vsn",
-    "-import",
-    "-include",
-    "-include_lib",
-    "-compile",
-    "-define",
-    "-else",
-    "-endif",
-    "-file",
-    "-behaviour",
-    "-behavior",
-    "-spec"
-  ];
-
-  const PARAMS = {
-    className: 'params',
-    begin: '\\(',
-    end: '\\)',
-    contains: BASIC_MODES
-  };
-  return {
-    name: 'Erlang',
-    aliases: ['erl'],
-    keywords: ERLANG_RESERVED,
-    illegal: '(</|\\*=|\\+=|-=|/\\*|\\*/|\\(\\*|\\*\\))',
-    contains: [
-      {
-        className: 'function',
-        begin: '^' + BASIC_ATOM_RE + '\\s*\\(',
-        end: '->',
-        returnBegin: true,
-        illegal: '\\(|#|//|/\\*|\\\\|:|;',
-        contains: [
-          PARAMS,
-          hljs.inherit(hljs.TITLE_MODE, {
-            begin: BASIC_ATOM_RE
-          })
-        ],
-        starts: {
-          end: ';|\\.',
-          keywords: ERLANG_RESERVED,
-          contains: BASIC_MODES
-        }
-      },
-      COMMENT,
-      {
-        begin: '^-',
-        end: '\\.',
-        relevance: 0,
-        excludeEnd: true,
-        returnBegin: true,
-        keywords: {
-          $pattern: '-' + hljs.IDENT_RE,
-          keyword: DIRECTIVES.map(x => `${x}|1.5`).join(" ")
-        },
-        contains: [PARAMS]
-      },
-      NUMBER,
-      hljs.QUOTE_STRING_MODE,
-      RECORD_ACCESS,
-      VAR1,
-      VAR2,
-      TUPLE,
-      {
-        begin: /\.$/
-      } // relevance booster
-    ]
-  };
-}
-
-module.exports = erlang;