@pfmcodes/caret 0.1.1

package/highlight.js/lib/languages/javascript.js.js

@@ -0,0 +1,10 @@
+function emitWarning() {
+    if (!emitWarning.warned) {
+      emitWarning.warned = true;
+      console.log(
+        'Deprecation (warning): Using file extension in specifier is deprecated, use "highlight.js/lib/languages/javascript" instead of "highlight.js/lib/languages/javascript.js"'
+      );
+    }
+  }
+  emitWarning();
+    module.exports = require('./javascript.js');

package/highlight.js/lib/languages/jboss-cli.js

@@ -0,0 +1,63 @@
+/*
+ Language: JBoss CLI
+ Author: Raphaël Parrëe <rparree@edc4it.com>
+ Description: language definition jboss cli
+ Website: https://docs.jboss.org/author/display/WFLY/Command+Line+Interface
+ Category: config
+ */
+
+function jbossCli(hljs) {
+  const PARAM = {
+    begin: /[\w-]+ *=/,
+    returnBegin: true,
+    relevance: 0,
+    contains: [
+      {
+        className: 'attr',
+        begin: /[\w-]+/
+      }
+    ]
+  };
+  const PARAMSBLOCK = {
+    className: 'params',
+    begin: /\(/,
+    end: /\)/,
+    contains: [ PARAM ],
+    relevance: 0
+  };
+  const OPERATION = {
+    className: 'function',
+    begin: /:[\w\-.]+/,
+    relevance: 0
+  };
+  const PATH = {
+    className: 'string',
+    begin: /\B([\/.])[\w\-.\/=]+/
+  };
+  const COMMAND_PARAMS = {
+    className: 'params',
+    begin: /--[\w\-=\/]+/
+  };
+  return {
+    name: 'JBoss CLI',
+    aliases: [ 'wildfly-cli' ],
+    keywords: {
+      $pattern: '[a-z\-]+',
+      keyword: 'alias batch cd clear command connect connection-factory connection-info data-source deploy '
+      + 'deployment-info deployment-overlay echo echo-dmr help history if jdbc-driver-info jms-queue|20 jms-topic|20 ls '
+      + 'patch pwd quit read-attribute read-operation reload rollout-plan run-batch set shutdown try unalias '
+      + 'undeploy unset version xa-data-source', // module
+      literal: 'true false'
+    },
+    contains: [
+      hljs.HASH_COMMENT_MODE,
+      hljs.QUOTE_STRING_MODE,
+      COMMAND_PARAMS,
+      OPERATION,
+      PATH,
+      PARAMSBLOCK
+    ]
+  };
+}
+
+module.exports = jbossCli;

package/highlight.js/lib/languages/jboss-cli.js.js

@@ -0,0 +1,10 @@
+function emitWarning() {
+    if (!emitWarning.warned) {
+      emitWarning.warned = true;
+      console.log(
+        'Deprecation (warning): Using file extension in specifier is deprecated, use "highlight.js/lib/languages/jboss-cli" instead of "highlight.js/lib/languages/jboss-cli.js"'
+      );
+    }
+  }
+  emitWarning();
+    module.exports = require('./jboss-cli.js');

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

@@ -0,0 +1,54 @@
+/*
+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, web
+*/
+
+function json(hljs) {
+  const ATTRIBUTE = {
+    className: 'attr',
+    begin: /"(\\.|[^\\"\r\n])*"(?=\s*:)/,
+    relevance: 1.01
+  };
+  const PUNCTUATION = {
+    match: /[{}[\],:]/,
+    className: "punctuation",
+    relevance: 0
+  };
+  const LITERALS = [
+    "true",
+    "false",
+    "null"
+  ];
+  // NOTE: normally we would rely on `keywords` for this but using a mode here allows us
+  // - to use the very tight `illegal: \S` rule later to flag any other character
+  // - as illegal indicating that despite looking like JSON we do not truly have
+  // - JSON and thus improve false-positively greatly since JSON will try and claim
+  // - all sorts of JSON looking stuff
+  const LITERALS_MODE = {
+    scope: "literal",
+    beginKeywords: LITERALS.join(" "),
+  };
+
+  return {
+    name: 'JSON',
+    aliases: ['jsonc'],
+    keywords:{
+      literal: LITERALS,
+    },
+    contains: [
+      ATTRIBUTE,
+      PUNCTUATION,
+      hljs.QUOTE_STRING_MODE,
+      LITERALS_MODE,
+      hljs.C_NUMBER_MODE,
+      hljs.C_LINE_COMMENT_MODE,
+      hljs.C_BLOCK_COMMENT_MODE
+    ],
+    illegal: '\\S'
+  };
+}
+
+module.exports = json;

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

@@ -0,0 +1,10 @@
+function emitWarning() {
+    if (!emitWarning.warned) {
+      emitWarning.warned = true;
+      console.log(
+        'Deprecation (warning): Using file extension in specifier is deprecated, use "highlight.js/lib/languages/json" instead of "highlight.js/lib/languages/json.js"'
+      );
+    }
+  }
+  emitWarning();
+    module.exports = require('./json.js');

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

@@ -0,0 +1,51 @@
+/*
+Language: Julia REPL
+Description: Julia REPL sessions
+Author: Morten Piibeleht <morten.piibeleht@gmail.com>
+Website: https://julialang.org
+Requires: julia.js
+Category: scientific
+
+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.prompt',
+        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/highlight.js/lib/languages/julia-repl.js.js

@@ -0,0 +1,10 @@
+function emitWarning() {
+    if (!emitWarning.warned) {
+      emitWarning.warned = true;
+      console.log(
+        'Deprecation (warning): Using file extension in specifier is deprecated, use "highlight.js/lib/languages/julia-repl" instead of "highlight.js/lib/languages/julia-repl.js"'
+      );
+    }
+  }
+  emitWarning();
+    module.exports = require('./julia-repl.js');

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

@@ -0,0 +1,442 @@
+/*
+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
+Category: scientific
+*/
+
+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
+  const 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)
+  const 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)
+  const 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)
+  const 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',
+  ];
+
+  const KEYWORDS = {
+    $pattern: VARIABLE_NAME_RE,
+    keyword: KEYWORD_LIST,
+    literal: LITERAL_LIST,
+    built_in: BUILT_IN_LIST,
+  };
+
+  // placeholder for recursive self-reference
+  const DEFAULT = {
+    keywords: KEYWORDS,
+    illegal: /<\//
+  };
+
+  // ref: https://docs.julialang.org/en/v1/manual/integers-and-floating-point-numbers/
+  const 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
+  };
+
+  const CHAR = {
+    className: 'string',
+    begin: /'(.|\\[xXuU][a-zA-Z0-9]+)'/
+  };
+
+  const INTERPOLATION = {
+    className: 'subst',
+    begin: /\$\(/,
+    end: /\)/,
+    keywords: KEYWORDS
+  };
+
+  const INTERPOLATED_VARIABLE = {
+    className: 'variable',
+    begin: '\\$' + VARIABLE_NAME_RE
+  };
+
+  // TODO: neatly escape normal code in string literal
+  const STRING = {
+    className: 'string',
+    contains: [
+      hljs.BACKSLASH_ESCAPE,
+      INTERPOLATION,
+      INTERPOLATED_VARIABLE
+    ],
+    variants: [
+      {
+        begin: /\w*"""/,
+        end: /"""\w*/,
+        relevance: 10
+      },
+      {
+        begin: /\w*"/,
+        end: /"\w*/
+      }
+    ]
+  };
+
+  const COMMAND = {
+    className: 'string',
+    contains: [
+      hljs.BACKSLASH_ESCAPE,
+      INTERPOLATION,
+      INTERPOLATED_VARIABLE
+    ],
+    begin: '`',
+    end: '`'
+  };
+
+  const MACROCALL = {
+    className: 'meta',
+    begin: '@' + VARIABLE_NAME_RE
+  };
+
+  const 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;

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

@@ -0,0 +1,10 @@
+function emitWarning() {
+    if (!emitWarning.warned) {
+      emitWarning.warned = true;
+      console.log(
+        'Deprecation (warning): Using file extension in specifier is deprecated, use "highlight.js/lib/languages/julia" instead of "highlight.js/lib/languages/julia.js"'
+      );
+    }
+  }
+  emitWarning();
+    module.exports = require('./julia.js');