gsd-pi 2.9.0 → 2.10.0

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

@@ -1,63 +0,0 @@
-/*
-Language: JSON
-Description: JSON (JavaScript Object Notation) is a lightweight data-interchange format.
-Author: Ivan Sagalaev <maniac@softwaremaniacs.org>
-Website: http://www.json.org
-Category: common, protocols
-*/
-
-function json(hljs) {
-  const LITERALS = {
-    literal: 'true false null'
-  };
-  const ALLOWED_COMMENTS = [
-    hljs.C_LINE_COMMENT_MODE,
-    hljs.C_BLOCK_COMMENT_MODE
-  ];
-  const TYPES = [
-    hljs.QUOTE_STRING_MODE,
-    hljs.C_NUMBER_MODE
-  ];
-  const VALUE_CONTAINER = {
-    end: ',',
-    endsWithParent: true,
-    excludeEnd: true,
-    contains: TYPES,
-    keywords: LITERALS
-  };
-  const OBJECT = {
-    begin: /\{/,
-    end: /\}/,
-    contains: [
-      {
-        className: 'attr',
-        begin: /"/,
-        end: /"/,
-        contains: [hljs.BACKSLASH_ESCAPE],
-        illegal: '\\n'
-      },
-      hljs.inherit(VALUE_CONTAINER, {
-        begin: /:/
-      })
-    ].concat(ALLOWED_COMMENTS),
-    illegal: '\\S'
-  };
-  const ARRAY = {
-    begin: '\\[',
-    end: '\\]',
-    contains: [hljs.inherit(VALUE_CONTAINER)], // inherit is a workaround for a bug that makes shared modes with endsWithParent compile only the ending of one of the parents
-    illegal: '\\S'
-  };
-  TYPES.push(OBJECT, ARRAY);
-  ALLOWED_COMMENTS.forEach(function(rule) {
-    TYPES.push(rule);
-  });
-  return {
-    name: 'JSON',
-    contains: TYPES,
-    keywords: LITERALS,
-    illegal: '\\S'
-  };
-}
-
-module.exports = json;

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

@@ -1,50 +0,0 @@
-/*
-Language: Julia REPL
-Description: Julia REPL sessions
-Author: Morten Piibeleht <morten.piibeleht@gmail.com>
-Website: https://julialang.org
-Requires: julia.js
-
-The Julia REPL code blocks look something like the following:
-
-  julia> function foo(x)
-             x + 1
-         end
-  foo (generic function with 1 method)
-
-They start on a new line with "julia>". Usually there should also be a space after this, but
-we also allow the code to start right after the > character. The code may run over multiple
-lines, but the additional lines must start with six spaces (i.e. be indented to match
-"julia>"). The rest of the code is assumed to be output from the executed code and will be
-left un-highlighted.
-
-Using simply spaces to identify line continuations may get a false-positive if the output
-also prints out six spaces, but such cases should be rare.
-*/
-
-function juliaRepl(hljs) {
-  return {
-    name: 'Julia REPL',
-    contains: [
-      {
-        className: 'meta',
-        begin: /^julia>/,
-        relevance: 10,
-        starts: {
-          // end the highlighting if we are on a new line and the line does not have at
-          // least six spaces in the beginning
-          end: /^(?![ ]{6})/,
-          subLanguage: 'julia'
-      },
-      // jldoctest Markdown blocks are used in the Julia manual and package docs indicate
-      // code snippets that should be verified when the documentation is built. They can be
-      // either REPL-like or script-like, but are usually REPL-like and therefore we apply
-      // julia-repl highlighting to them. More information can be found in Documenter's
-      // manual: https://juliadocs.github.io/Documenter.jl/latest/man/doctests.html
-      aliases: ['jldoctest']
-      }
-    ]
-  }
-}
-
-module.exports = juliaRepl;

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

@@ -1,416 +0,0 @@
-/*
-Language: Julia
-Description: Julia is a high-level, high-performance, dynamic programming language.
-Author: Kenta Sato <bicycle1885@gmail.com>
-Contributors: Alex Arslan <ararslan@comcast.net>, Fredrik Ekre <ekrefredrik@gmail.com>
-Website: https://julialang.org
-*/
-
-function julia(hljs) {
-  // Since there are numerous special names in Julia, it is too much trouble
-  // to maintain them by hand. Hence these names (i.e. keywords, literals and
-  // built-ins) are automatically generated from Julia 1.5.2 itself through
-  // the following scripts for each.
-
-  // ref: https://docs.julialang.org/en/v1/manual/variables/#Allowed-Variable-Names
-  var VARIABLE_NAME_RE = '[A-Za-z_\\u00A1-\\uFFFF][A-Za-z_0-9\\u00A1-\\uFFFF]*';
-
-  // # keyword generator, multi-word keywords handled manually below (Julia 1.5.2)
-  // import REPL.REPLCompletions
-  // res = String["in", "isa", "where"]
-  // for kw in collect(x.keyword for x in REPLCompletions.complete_keyword(""))
-  //     if !(contains(kw, " ") || kw == "struct")
-  //         push!(res, kw)
-  //     end
-  // end
-  // sort!(unique!(res))
-  // foreach(x -> println("\'", x, "\',"), res)
-  var KEYWORD_LIST = [
-    'baremodule',
-    'begin',
-    'break',
-    'catch',
-    'ccall',
-    'const',
-    'continue',
-    'do',
-    'else',
-    'elseif',
-    'end',
-    'export',
-    'false',
-    'finally',
-    'for',
-    'function',
-    'global',
-    'if',
-    'import',
-    'in',
-    'isa',
-    'let',
-    'local',
-    'macro',
-    'module',
-    'quote',
-    'return',
-    'true',
-    'try',
-    'using',
-    'where',
-    'while',
-  ];
-
-  // # literal generator (Julia 1.5.2)
-  // import REPL.REPLCompletions
-  // res = String["true", "false"]
-  // for compl in filter!(x -> isa(x, REPLCompletions.ModuleCompletion) && (x.parent === Base || x.parent === Core),
-  //                     REPLCompletions.completions("", 0)[1])
-  //     try
-  //         v = eval(Symbol(compl.mod))
-  //         if !(v isa Function || v isa Type || v isa TypeVar || v isa Module || v isa Colon)
-  //             push!(res, compl.mod)
-  //         end
-  //     catch e
-  //     end
-  // end
-  // sort!(unique!(res))
-  // foreach(x -> println("\'", x, "\',"), res)
-  var LITERAL_LIST = [
-    'ARGS',
-    'C_NULL',
-    'DEPOT_PATH',
-    'ENDIAN_BOM',
-    'ENV',
-    'Inf',
-    'Inf16',
-    'Inf32',
-    'Inf64',
-    'InsertionSort',
-    'LOAD_PATH',
-    'MergeSort',
-    'NaN',
-    'NaN16',
-    'NaN32',
-    'NaN64',
-    'PROGRAM_FILE',
-    'QuickSort',
-    'RoundDown',
-    'RoundFromZero',
-    'RoundNearest',
-    'RoundNearestTiesAway',
-    'RoundNearestTiesUp',
-    'RoundToZero',
-    'RoundUp',
-    'VERSION|0',
-    'devnull',
-    'false',
-    'im',
-    'missing',
-    'nothing',
-    'pi',
-    'stderr',
-    'stdin',
-    'stdout',
-    'true',
-    'undef',
-    'π',
-    'ℯ',
-  ];
-
-  // # built_in generator (Julia 1.5.2)
-  // import REPL.REPLCompletions
-  // res = String[]
-  // for compl in filter!(x -> isa(x, REPLCompletions.ModuleCompletion) && (x.parent === Base || x.parent === Core),
-  //                     REPLCompletions.completions("", 0)[1])
-  //     try
-  //         v = eval(Symbol(compl.mod))
-  //         if (v isa Type || v isa TypeVar) && (compl.mod != "=>")
-  //             push!(res, compl.mod)
-  //         end
-  //     catch e
-  //     end
-  // end
-  // sort!(unique!(res))
-  // foreach(x -> println("\'", x, "\',"), res)
-  var BUILT_IN_LIST = [
-    'AbstractArray',
-    'AbstractChannel',
-    'AbstractChar',
-    'AbstractDict',
-    'AbstractDisplay',
-    'AbstractFloat',
-    'AbstractIrrational',
-    'AbstractMatrix',
-    'AbstractRange',
-    'AbstractSet',
-    'AbstractString',
-    'AbstractUnitRange',
-    'AbstractVecOrMat',
-    'AbstractVector',
-    'Any',
-    'ArgumentError',
-    'Array',
-    'AssertionError',
-    'BigFloat',
-    'BigInt',
-    'BitArray',
-    'BitMatrix',
-    'BitSet',
-    'BitVector',
-    'Bool',
-    'BoundsError',
-    'CapturedException',
-    'CartesianIndex',
-    'CartesianIndices',
-    'Cchar',
-    'Cdouble',
-    'Cfloat',
-    'Channel',
-    'Char',
-    'Cint',
-    'Cintmax_t',
-    'Clong',
-    'Clonglong',
-    'Cmd',
-    'Colon',
-    'Complex',
-    'ComplexF16',
-    'ComplexF32',
-    'ComplexF64',
-    'CompositeException',
-    'Condition',
-    'Cptrdiff_t',
-    'Cshort',
-    'Csize_t',
-    'Cssize_t',
-    'Cstring',
-    'Cuchar',
-    'Cuint',
-    'Cuintmax_t',
-    'Culong',
-    'Culonglong',
-    'Cushort',
-    'Cvoid',
-    'Cwchar_t',
-    'Cwstring',
-    'DataType',
-    'DenseArray',
-    'DenseMatrix',
-    'DenseVecOrMat',
-    'DenseVector',
-    'Dict',
-    'DimensionMismatch',
-    'Dims',
-    'DivideError',
-    'DomainError',
-    'EOFError',
-    'Enum',
-    'ErrorException',
-    'Exception',
-    'ExponentialBackOff',
-    'Expr',
-    'Float16',
-    'Float32',
-    'Float64',
-    'Function',
-    'GlobalRef',
-    'HTML',
-    'IO',
-    'IOBuffer',
-    'IOContext',
-    'IOStream',
-    'IdDict',
-    'IndexCartesian',
-    'IndexLinear',
-    'IndexStyle',
-    'InexactError',
-    'InitError',
-    'Int',
-    'Int128',
-    'Int16',
-    'Int32',
-    'Int64',
-    'Int8',
-    'Integer',
-    'InterruptException',
-    'InvalidStateException',
-    'Irrational',
-    'KeyError',
-    'LinRange',
-    'LineNumberNode',
-    'LinearIndices',
-    'LoadError',
-    'MIME',
-    'Matrix',
-    'Method',
-    'MethodError',
-    'Missing',
-    'MissingException',
-    'Module',
-    'NTuple',
-    'NamedTuple',
-    'Nothing',
-    'Number',
-    'OrdinalRange',
-    'OutOfMemoryError',
-    'OverflowError',
-    'Pair',
-    'PartialQuickSort',
-    'PermutedDimsArray',
-    'Pipe',
-    'ProcessFailedException',
-    'Ptr',
-    'QuoteNode',
-    'Rational',
-    'RawFD',
-    'ReadOnlyMemoryError',
-    'Real',
-    'ReentrantLock',
-    'Ref',
-    'Regex',
-    'RegexMatch',
-    'RoundingMode',
-    'SegmentationFault',
-    'Set',
-    'Signed',
-    'Some',
-    'StackOverflowError',
-    'StepRange',
-    'StepRangeLen',
-    'StridedArray',
-    'StridedMatrix',
-    'StridedVecOrMat',
-    'StridedVector',
-    'String',
-    'StringIndexError',
-    'SubArray',
-    'SubString',
-    'SubstitutionString',
-    'Symbol',
-    'SystemError',
-    'Task',
-    'TaskFailedException',
-    'Text',
-    'TextDisplay',
-    'Timer',
-    'Tuple',
-    'Type',
-    'TypeError',
-    'TypeVar',
-    'UInt',
-    'UInt128',
-    'UInt16',
-    'UInt32',
-    'UInt64',
-    'UInt8',
-    'UndefInitializer',
-    'UndefKeywordError',
-    'UndefRefError',
-    'UndefVarError',
-    'Union',
-    'UnionAll',
-    'UnitRange',
-    'Unsigned',
-    'Val',
-    'Vararg',
-    'VecElement',
-    'VecOrMat',
-    'Vector',
-    'VersionNumber',
-    'WeakKeyDict',
-    'WeakRef',
-  ];
-
-  var KEYWORDS = {
-    $pattern: VARIABLE_NAME_RE,
-    keyword: KEYWORD_LIST,
-    literal: LITERAL_LIST,
-    built_in: BUILT_IN_LIST,
-  };
-
-  // placeholder for recursive self-reference
-  var DEFAULT = {
-    keywords: KEYWORDS, illegal: /<\//
-  };
-
-  // ref: https://docs.julialang.org/en/v1/manual/integers-and-floating-point-numbers/
-  var NUMBER = {
-    className: 'number',
-    // supported numeric literals:
-    //  * binary literal (e.g. 0x10)
-    //  * octal literal (e.g. 0o76543210)
-    //  * hexadecimal literal (e.g. 0xfedcba876543210)
-    //  * hexadecimal floating point literal (e.g. 0x1p0, 0x1.2p2)
-    //  * decimal literal (e.g. 9876543210, 100_000_000)
-    //  * floating pointe literal (e.g. 1.2, 1.2f, .2, 1., 1.2e10, 1.2e-10)
-    begin: /(\b0x[\d_]*(\.[\d_]*)?|0x\.\d[\d_]*)p[-+]?\d+|\b0[box][a-fA-F0-9][a-fA-F0-9_]*|(\b\d[\d_]*(\.[\d_]*)?|\.\d[\d_]*)([eEfF][-+]?\d+)?/,
-    relevance: 0
-  };
-
-  var CHAR = {
-    className: 'string',
-    begin: /'(.|\\[xXuU][a-zA-Z0-9]+)'/
-  };
-
-  var INTERPOLATION = {
-    className: 'subst',
-    begin: /\$\(/, end: /\)/,
-    keywords: KEYWORDS
-  };
-
-  var INTERPOLATED_VARIABLE = {
-    className: 'variable',
-    begin: '\\$' + VARIABLE_NAME_RE
-  };
-
-  // TODO: neatly escape normal code in string literal
-  var STRING = {
-    className: 'string',
-    contains: [hljs.BACKSLASH_ESCAPE, INTERPOLATION, INTERPOLATED_VARIABLE],
-    variants: [
-      { begin: /\w*"""/, end: /"""\w*/, relevance: 10 },
-      { begin: /\w*"/, end: /"\w*/ }
-    ]
-  };
-
-  var COMMAND = {
-    className: 'string',
-    contains: [hljs.BACKSLASH_ESCAPE, INTERPOLATION, INTERPOLATED_VARIABLE],
-    begin: '`', end: '`'
-  };
-
-  var MACROCALL = {
-    className: 'meta',
-    begin: '@' + VARIABLE_NAME_RE
-  };
-
-  var COMMENT = {
-    className: 'comment',
-    variants: [
-      { begin: '#=', end: '=#', relevance: 10 },
-      { begin: '#', end: '$' }
-    ]
-  };
-
-  DEFAULT.name = 'Julia';
-  DEFAULT.contains = [
-    NUMBER,
-    CHAR,
-    STRING,
-    COMMAND,
-    MACROCALL,
-    COMMENT,
-    hljs.HASH_COMMENT_MODE,
-    {
-      className: 'keyword',
-      begin:
-        '\\b(((abstract|primitive)\\s+)type|(mutable\\s+)?struct)\\b'
-    },
-    {begin: /<:/}  // relevance booster
-  ];
-  INTERPOLATION.contains = DEFAULT.contains;
-
-  return DEFAULT;
-}
-
-module.exports = julia;