@pfmcodes/caret 0.1.1

package/highlight.js/es/languages/r.js

@@ -0,0 +1,257 @@
+/*
+Language: R
+Description: R is a free software environment for statistical computing and graphics.
+Author: Joe Cheng <joe@rstudio.org>
+Contributors: Konrad Rudolph <konrad.rudolph@gmail.com>
+Website: https://www.r-project.org
+Category: common,scientific
+*/
+
+/** @type LanguageFn */
+function r(hljs) {
+  const regex = hljs.regex;
+  // Identifiers in R cannot start with `_`, but they can start with `.` if it
+  // is not immediately followed by a digit.
+  // R also supports quoted identifiers, which are near-arbitrary sequences
+  // delimited by backticks (`…`), which may contain escape sequences. These are
+  // handled in a separate mode. See `test/markup/r/names.txt` for examples.
+  // FIXME: Support Unicode identifiers.
+  const IDENT_RE = /(?:(?:[a-zA-Z]|\.[._a-zA-Z])[._a-zA-Z0-9]*)|\.(?!\d)/;
+  const NUMBER_TYPES_RE = regex.either(
+    // Special case: only hexadecimal binary powers can contain fractions
+    /0[xX][0-9a-fA-F]+\.[0-9a-fA-F]*[pP][+-]?\d+i?/,
+    // Hexadecimal numbers without fraction and optional binary power
+    /0[xX][0-9a-fA-F]+(?:[pP][+-]?\d+)?[Li]?/,
+    // Decimal numbers
+    /(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?[Li]?/
+  );
+  const OPERATORS_RE = /[=!<>:]=|\|\||&&|:::?|<-|<<-|->>|->|\|>|[-+*\/?!$&|:<=>@^~]|\*\*/;
+  const PUNCTUATION_RE = regex.either(
+    /[()]/,
+    /[{}]/,
+    /\[\[/,
+    /[[\]]/,
+    /\\/,
+    /,/
+  );
+
+  return {
+    name: 'R',
+
+    keywords: {
+      $pattern: IDENT_RE,
+      keyword:
+        'function if in break next repeat else for while',
+      literal:
+        'NULL NA TRUE FALSE Inf NaN NA_integer_|10 NA_real_|10 '
+        + 'NA_character_|10 NA_complex_|10',
+      built_in:
+        // Builtin constants
+        'LETTERS letters month.abb month.name pi T F '
+        // Primitive functions
+        // These are all the functions in `base` that are implemented as a
+        // `.Primitive`, minus those functions that are also keywords.
+        + 'abs acos acosh all any anyNA Arg as.call as.character '
+        + 'as.complex as.double as.environment as.integer as.logical '
+        + 'as.null.default as.numeric as.raw asin asinh atan atanh attr '
+        + 'attributes baseenv browser c call ceiling class Conj cos cosh '
+        + 'cospi cummax cummin cumprod cumsum digamma dim dimnames '
+        + 'emptyenv exp expression floor forceAndCall gamma gc.time '
+        + 'globalenv Im interactive invisible is.array is.atomic is.call '
+        + 'is.character is.complex is.double is.environment is.expression '
+        + 'is.finite is.function is.infinite is.integer is.language '
+        + 'is.list is.logical is.matrix is.na is.name is.nan is.null '
+        + 'is.numeric is.object is.pairlist is.raw is.recursive is.single '
+        + 'is.symbol lazyLoadDBfetch length lgamma list log max min '
+        + 'missing Mod names nargs nzchar oldClass on.exit pos.to.env '
+        + 'proc.time prod quote range Re rep retracemem return round '
+        + 'seq_along seq_len seq.int sign signif sin sinh sinpi sqrt '
+        + 'standardGeneric substitute sum switch tan tanh tanpi tracemem '
+        + 'trigamma trunc unclass untracemem UseMethod xtfrm',
+    },
+
+    contains: [
+      // Roxygen comments
+      hljs.COMMENT(
+        /#'/,
+        /$/,
+        { contains: [
+          {
+            // Handle `@examples` separately to cause all subsequent code
+            // until the next `@`-tag on its own line to be kept as-is,
+            // preventing highlighting. This code is example R code, so nested
+            // doctags shouldn’t be treated as such. See
+            // `test/markup/r/roxygen.txt` for an example.
+            scope: 'doctag',
+            match: /@examples/,
+            starts: {
+              end: regex.lookahead(regex.either(
+                // end if another doc comment
+                /\n^#'\s*(?=@[a-zA-Z]+)/,
+                // or a line with no comment
+                /\n^(?!#')/
+              )),
+              endsParent: true
+            }
+          },
+          {
+            // Handle `@param` to highlight the parameter name following
+            // after.
+            scope: 'doctag',
+            begin: '@param',
+            end: /$/,
+            contains: [
+              {
+                scope: 'variable',
+                variants: [
+                  { match: IDENT_RE },
+                  { match: /`(?:\\.|[^`\\])+`/ }
+                ],
+                endsParent: true
+              }
+            ]
+          },
+          {
+            scope: 'doctag',
+            match: /@[a-zA-Z]+/
+          },
+          {
+            scope: 'keyword',
+            match: /\\[a-zA-Z]+/
+          }
+        ] }
+      ),
+
+      hljs.HASH_COMMENT_MODE,
+
+      {
+        scope: 'string',
+        contains: [ hljs.BACKSLASH_ESCAPE ],
+        variants: [
+          hljs.END_SAME_AS_BEGIN({
+            begin: /[rR]"(-*)\(/,
+            end: /\)(-*)"/
+          }),
+          hljs.END_SAME_AS_BEGIN({
+            begin: /[rR]"(-*)\{/,
+            end: /\}(-*)"/
+          }),
+          hljs.END_SAME_AS_BEGIN({
+            begin: /[rR]"(-*)\[/,
+            end: /\](-*)"/
+          }),
+          hljs.END_SAME_AS_BEGIN({
+            begin: /[rR]'(-*)\(/,
+            end: /\)(-*)'/
+          }),
+          hljs.END_SAME_AS_BEGIN({
+            begin: /[rR]'(-*)\{/,
+            end: /\}(-*)'/
+          }),
+          hljs.END_SAME_AS_BEGIN({
+            begin: /[rR]'(-*)\[/,
+            end: /\](-*)'/
+          }),
+          {
+            begin: '"',
+            end: '"',
+            relevance: 0
+          },
+          {
+            begin: "'",
+            end: "'",
+            relevance: 0
+          }
+        ],
+      },
+
+      // Matching numbers immediately following punctuation and operators is
+      // tricky since we need to look at the character ahead of a number to
+      // ensure the number is not part of an identifier, and we cannot use
+      // negative look-behind assertions. So instead we explicitly handle all
+      // possible combinations of (operator|punctuation), number.
+      // TODO: replace with negative look-behind when available
+      // { begin: /(?<![a-zA-Z0-9._])0[xX][0-9a-fA-F]+\.[0-9a-fA-F]*[pP][+-]?\d+i?/ },
+      // { begin: /(?<![a-zA-Z0-9._])0[xX][0-9a-fA-F]+([pP][+-]?\d+)?[Li]?/ },
+      // { begin: /(?<![a-zA-Z0-9._])(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?[Li]?/ }
+      {
+        relevance: 0,
+        variants: [
+          {
+            scope: {
+              1: 'operator',
+              2: 'number'
+            },
+            match: [
+              OPERATORS_RE,
+              NUMBER_TYPES_RE
+            ]
+          },
+          {
+            scope: {
+              1: 'operator',
+              2: 'number'
+            },
+            match: [
+              /%[^%]*%/,
+              NUMBER_TYPES_RE
+            ]
+          },
+          {
+            scope: {
+              1: 'punctuation',
+              2: 'number'
+            },
+            match: [
+              PUNCTUATION_RE,
+              NUMBER_TYPES_RE
+            ]
+          },
+          {
+            scope: { 2: 'number' },
+            match: [
+              /[^a-zA-Z0-9._]|^/, // not part of an identifier, or start of document
+              NUMBER_TYPES_RE
+            ]
+          }
+        ]
+      },
+
+      // Operators/punctuation when they're not directly followed by numbers
+      {
+        // Relevance boost for the most common assignment form.
+        scope: { 3: 'operator' },
+        match: [
+          IDENT_RE,
+          /\s+/,
+          /<-/,
+          /\s+/
+        ]
+      },
+
+      {
+        scope: 'operator',
+        relevance: 0,
+        variants: [
+          { match: OPERATORS_RE },
+          { match: /%[^%]*%/ }
+        ]
+      },
+
+      {
+        scope: 'punctuation',
+        relevance: 0,
+        match: PUNCTUATION_RE
+      },
+
+      {
+        // Escaped identifier
+        begin: '`',
+        end: '`',
+        contains: [ { begin: /\\./ } ]
+      }
+    ]
+  };
+}
+
+export { r as default };

package/highlight.js/es/languages/r.js.js

@@ -0,0 +1,11 @@
+function emitWarning() {
+    if (!emitWarning.warned) {
+      emitWarning.warned = true;
+      console.log(
+        'Deprecation (warning): Using file extension in specifier is deprecated, use "highlight.js/lib/languages/r" instead of "highlight.js/lib/languages/r.js"'
+      );
+    }
+  }
+  emitWarning();
+    import lang from './r.js';
+    export default lang;

package/highlight.js/es/languages/reasonml.js

@@ -0,0 +1,142 @@
+/*
+Language: ReasonML
+Description: Reason lets you write simple, fast and quality type safe code while leveraging both the JavaScript & OCaml ecosystems.
+Website: https://reasonml.github.io
+Author: Gidi Meir Morris <oss@gidi.io>
+Category: functional
+*/
+function reasonml(hljs) {
+  const BUILT_IN_TYPES = [
+    "array",
+    "bool",
+    "bytes",
+    "char",
+    "exn|5",
+    "float",
+    "int",
+    "int32",
+    "int64",
+    "list",
+    "lazy_t|5",
+    "nativeint|5",
+    "ref",
+    "string",
+    "unit",
+  ];
+  return {
+    name: 'ReasonML',
+    aliases: [ 're' ],
+    keywords: {
+      $pattern:  /[a-z_]\w*!?/,
+      keyword: [
+        "and",
+        "as",
+        "asr",
+        "assert",
+        "begin",
+        "class",
+        "constraint",
+        "do",
+        "done",
+        "downto",
+        "else",
+        "end",
+        "esfun",
+        "exception",
+        "external",
+        "for",
+        "fun",
+        "function",
+        "functor",
+        "if",
+        "in",
+        "include",
+        "inherit",
+        "initializer",
+        "land",
+        "lazy",
+        "let",
+        "lor",
+        "lsl",
+        "lsr",
+        "lxor",
+        "mod",
+        "module",
+        "mutable",
+        "new",
+        "nonrec",
+        "object",
+        "of",
+        "open",
+        "or",
+        "pri",
+        "pub",
+        "rec",
+        "sig",
+        "struct",
+        "switch",
+        "then",
+        "to",
+        "try",
+        "type",
+        "val",
+        "virtual",
+        "when",
+        "while",
+        "with",
+      ],
+      built_in: BUILT_IN_TYPES,
+      literal: ["true", "false"],
+    },
+    illegal: /(:-|:=|\$\{|\+=)/,
+    contains: [
+      {
+        scope: 'literal',
+        match: /\[(\|\|)?\]|\(\)/,
+        relevance: 0
+      },
+      hljs.C_LINE_COMMENT_MODE,
+      hljs.COMMENT(/\/\*/, /\*\//, { illegal: /^(#,\/\/)/ }),
+      { /* type variable */
+        scope: 'symbol',
+        match: /\'[A-Za-z_](?!\')[\w\']*/
+        /* the grammar is ambiguous on how 'a'b should be interpreted but not the compiler */
+      },
+      { /* polymorphic variant */
+        scope: 'type',
+        match: /`[A-Z][\w\']*/
+      },
+      { /* module or constructor */
+        scope: 'type',
+        match: /\b[A-Z][\w\']*/,
+        relevance: 0
+      },
+      { /* don't color identifiers, but safely catch all identifiers with ' */
+      match: /[a-z_]\w*\'[\w\']*/,
+        relevance: 0
+      },
+      {
+        scope: 'operator',
+        match: /\s+(\|\||\+[\+\.]?|\*[\*\/\.]?|\/[\.]?|\.\.\.|\|>|&&|===?)\s+/,
+        relevance: 0
+      },      
+      hljs.inherit(hljs.APOS_STRING_MODE, {
+        scope: 'string',
+        relevance: 0
+      }),
+      hljs.inherit(hljs.QUOTE_STRING_MODE, { illegal: null }),
+      {
+        scope: 'number',
+        variants: [
+          { match: /\b0[xX][a-fA-F0-9_]+[Lln]?/ },
+          { match: /\b0[oO][0-7_]+[Lln]?/ },
+          { match: /\b0[bB][01_]+[Lln]?/ },
+          { match: /\b[0-9][0-9_]*([Lln]|(\.[0-9_]*)?([eE][-+]?[0-9_]+)?)/ },
+        ],
+        relevance: 0
+      },
+    ]
+  };
+}
+
+export { reasonml as default };

package/highlight.js/es/languages/reasonml.js.js

@@ -0,0 +1,11 @@
+function emitWarning() {
+    if (!emitWarning.warned) {
+      emitWarning.warned = true;
+      console.log(
+        'Deprecation (warning): Using file extension in specifier is deprecated, use "highlight.js/lib/languages/reasonml" instead of "highlight.js/lib/languages/reasonml.js"'
+      );
+    }
+  }
+  emitWarning();
+    import lang from './reasonml.js';
+    export default lang;

package/highlight.js/es/languages/rib.js

@@ -0,0 +1,37 @@
+/*
+Language: RenderMan RIB
+Author: Konstantin Evdokimenko <qewerty@gmail.com>
+Contributors: Shuen-Huei Guan <drake.guan@gmail.com>
+Website: https://renderman.pixar.com/resources/RenderMan_20/ribBinding.html
+Category: graphics
+*/
+
+function rib(hljs) {
+  return {
+    name: 'RenderMan RIB',
+    keywords:
+      'ArchiveRecord AreaLightSource Atmosphere Attribute AttributeBegin AttributeEnd Basis '
+      + 'Begin Blobby Bound Clipping ClippingPlane Color ColorSamples ConcatTransform Cone '
+      + 'CoordinateSystem CoordSysTransform CropWindow Curves Cylinder DepthOfField Detail '
+      + 'DetailRange Disk Displacement Display End ErrorHandler Exposure Exterior Format '
+      + 'FrameAspectRatio FrameBegin FrameEnd GeneralPolygon GeometricApproximation Geometry '
+      + 'Hider Hyperboloid Identity Illuminate Imager Interior LightSource '
+      + 'MakeCubeFaceEnvironment MakeLatLongEnvironment MakeShadow MakeTexture Matte '
+      + 'MotionBegin MotionEnd NuPatch ObjectBegin ObjectEnd ObjectInstance Opacity Option '
+      + 'Orientation Paraboloid Patch PatchMesh Perspective PixelFilter PixelSamples '
+      + 'PixelVariance Points PointsGeneralPolygons PointsPolygons Polygon Procedural Projection '
+      + 'Quantize ReadArchive RelativeDetail ReverseOrientation Rotate Scale ScreenWindow '
+      + 'ShadingInterpolation ShadingRate Shutter Sides Skew SolidBegin SolidEnd Sphere '
+      + 'SubdivisionMesh Surface TextureCoordinates Torus Transform TransformBegin TransformEnd '
+      + 'TransformPoints Translate TrimCurve WorldBegin WorldEnd',
+    illegal: '</',
+    contains: [
+      hljs.HASH_COMMENT_MODE,
+      hljs.C_NUMBER_MODE,
+      hljs.APOS_STRING_MODE,
+      hljs.QUOTE_STRING_MODE
+    ]
+  };
+}
+
+export { rib as default };

package/highlight.js/es/languages/rib.js.js

@@ -0,0 +1,11 @@
+function emitWarning() {
+    if (!emitWarning.warned) {
+      emitWarning.warned = true;
+      console.log(
+        'Deprecation (warning): Using file extension in specifier is deprecated, use "highlight.js/lib/languages/rib" instead of "highlight.js/lib/languages/rib.js"'
+      );
+    }
+  }
+  emitWarning();
+    import lang from './rib.js';
+    export default lang;

package/highlight.js/es/languages/roboconf.js

@@ -0,0 +1,82 @@
+/*
+Language: Roboconf
+Author: Vincent Zurczak <vzurczak@linagora.com>
+Description: Syntax highlighting for Roboconf's DSL
+Website: http://roboconf.net
+Category: config
+*/
+
+function roboconf(hljs) {
+  const IDENTIFIER = '[a-zA-Z-_][^\\n{]+\\{';
+
+  const PROPERTY = {
+    className: 'attribute',
+    begin: /[a-zA-Z-_]+/,
+    end: /\s*:/,
+    excludeEnd: true,
+    starts: {
+      end: ';',
+      relevance: 0,
+      contains: [
+        {
+          className: 'variable',
+          begin: /\.[a-zA-Z-_]+/
+        },
+        {
+          className: 'keyword',
+          begin: /\(optional\)/
+        }
+      ]
+    }
+  };
+
+  return {
+    name: 'Roboconf',
+    aliases: [
+      'graph',
+      'instances'
+    ],
+    case_insensitive: true,
+    keywords: 'import',
+    contains: [
+      // Facet sections
+      {
+        begin: '^facet ' + IDENTIFIER,
+        end: /\}/,
+        keywords: 'facet',
+        contains: [
+          PROPERTY,
+          hljs.HASH_COMMENT_MODE
+        ]
+      },
+
+      // Instance sections
+      {
+        begin: '^\\s*instance of ' + IDENTIFIER,
+        end: /\}/,
+        keywords: 'name count channels instance-data instance-state instance of',
+        illegal: /\S/,
+        contains: [
+          'self',
+          PROPERTY,
+          hljs.HASH_COMMENT_MODE
+        ]
+      },
+
+      // Component sections
+      {
+        begin: '^' + IDENTIFIER,
+        end: /\}/,
+        contains: [
+          PROPERTY,
+          hljs.HASH_COMMENT_MODE
+        ]
+      },
+
+      // Comments
+      hljs.HASH_COMMENT_MODE
+    ]
+  };
+}
+
+export { roboconf as default };

package/highlight.js/es/languages/roboconf.js.js

@@ -0,0 +1,11 @@
+function emitWarning() {
+    if (!emitWarning.warned) {
+      emitWarning.warned = true;
+      console.log(
+        'Deprecation (warning): Using file extension in specifier is deprecated, use "highlight.js/lib/languages/roboconf" instead of "highlight.js/lib/languages/roboconf.js"'
+      );
+    }
+  }
+  emitWarning();
+    import lang from './roboconf.js';
+    export default lang;