@pfmcodes/caret 0.1.1

package/highlight.js/es/languages/abnf.js

@@ -0,0 +1,83 @@
+/*
+Language: Augmented Backus-Naur Form
+Author: Alex McKibben <alex@nullscope.net>
+Website: https://tools.ietf.org/html/rfc5234
+Category: syntax
+Audit: 2020
+*/
+
+/** @type LanguageFn */
+function abnf(hljs) {
+  const regex = hljs.regex;
+  const IDENT = /^[a-zA-Z][a-zA-Z0-9-]*/;
+
+  const KEYWORDS = [
+    "ALPHA",
+    "BIT",
+    "CHAR",
+    "CR",
+    "CRLF",
+    "CTL",
+    "DIGIT",
+    "DQUOTE",
+    "HEXDIG",
+    "HTAB",
+    "LF",
+    "LWSP",
+    "OCTET",
+    "SP",
+    "VCHAR",
+    "WSP"
+  ];
+
+  const COMMENT = hljs.COMMENT(/;/, /$/);
+
+  const TERMINAL_BINARY = {
+    scope: "symbol",
+    match: /%b[0-1]+(-[0-1]+|(\.[0-1]+)+)?/
+  };
+
+  const TERMINAL_DECIMAL = {
+    scope: "symbol",
+    match: /%d[0-9]+(-[0-9]+|(\.[0-9]+)+)?/
+  };
+
+  const TERMINAL_HEXADECIMAL = {
+    scope: "symbol",
+    match: /%x[0-9A-F]+(-[0-9A-F]+|(\.[0-9A-F]+)+)?/
+  };
+
+  const CASE_SENSITIVITY = {
+    scope: "symbol",
+    match: /%[si](?=".*")/
+  };
+
+  const RULE_DECLARATION = {
+    scope: "attribute",
+    match: regex.concat(IDENT, /(?=\s*=)/)
+  };
+
+  const ASSIGNMENT = {
+    scope: "operator",
+    match: /=\/?/
+  };
+
+  return {
+    name: 'Augmented Backus-Naur Form',
+    illegal: /[!@#$^&',?+~`|:]/,
+    keywords: KEYWORDS,
+    contains: [
+      ASSIGNMENT,
+      RULE_DECLARATION,
+      COMMENT,
+      TERMINAL_BINARY,
+      TERMINAL_DECIMAL,
+      TERMINAL_HEXADECIMAL,
+      CASE_SENSITIVITY,
+      hljs.QUOTE_STRING_MODE,
+      hljs.NUMBER_MODE
+    ]
+  };
+}
+
+export { abnf as default };

package/highlight.js/es/languages/abnf.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/abnf" instead of "highlight.js/lib/languages/abnf.js"'
+      );
+    }
+  }
+  emitWarning();
+    import lang from './abnf.js';
+    export default lang;

package/highlight.js/es/languages/accesslog.js

@@ -0,0 +1,92 @@
+/*
+ Language: Apache Access Log
+ Author: Oleg Efimov <efimovov@gmail.com>
+ Description: Apache/Nginx Access Logs
+ Website: https://httpd.apache.org/docs/2.4/logs.html#accesslog
+ Category: web, logs
+ Audit: 2020
+ */
+
+/** @type LanguageFn */
+function accesslog(hljs) {
+  const regex = hljs.regex;
+  // https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods
+  const HTTP_VERBS = [
+    "GET",
+    "POST",
+    "HEAD",
+    "PUT",
+    "DELETE",
+    "CONNECT",
+    "OPTIONS",
+    "PATCH",
+    "TRACE"
+  ];
+  return {
+    name: 'Apache Access Log',
+    contains: [
+      // IP
+      {
+        className: 'number',
+        begin: /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}(:\d{1,5})?\b/,
+        relevance: 5
+      },
+      // Other numbers
+      {
+        className: 'number',
+        begin: /\b\d+\b/,
+        relevance: 0
+      },
+      // Requests
+      {
+        className: 'string',
+        begin: regex.concat(/"/, regex.either(...HTTP_VERBS)),
+        end: /"/,
+        keywords: HTTP_VERBS,
+        illegal: /\n/,
+        relevance: 5,
+        contains: [
+          {
+            begin: /HTTP\/[12]\.\d'/,
+            relevance: 5
+          }
+        ]
+      },
+      // Dates
+      {
+        className: 'string',
+        // dates must have a certain length, this prevents matching
+        // simple array accesses a[123] and [] and other common patterns
+        // found in other languages
+        begin: /\[\d[^\]\n]{8,}\]/,
+        illegal: /\n/,
+        relevance: 1
+      },
+      {
+        className: 'string',
+        begin: /\[/,
+        end: /\]/,
+        illegal: /\n/,
+        relevance: 0
+      },
+      // User agent / relevance boost
+      {
+        className: 'string',
+        begin: /"Mozilla\/\d\.\d \(/,
+        end: /"/,
+        illegal: /\n/,
+        relevance: 3
+      },
+      // Strings
+      {
+        className: 'string',
+        begin: /"/,
+        end: /"/,
+        illegal: /\n/,
+        relevance: 0
+      }
+    ]
+  };
+}
+
+export { accesslog as default };

package/highlight.js/es/languages/accesslog.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/accesslog" instead of "highlight.js/lib/languages/accesslog.js"'
+      );
+    }
+  }
+  emitWarning();
+    import lang from './accesslog.js';
+    export default lang;

package/highlight.js/es/languages/actionscript.js

@@ -0,0 +1,153 @@
+/*
+Language: ActionScript
+Author: Alexander Myadzel <myadzel@gmail.com>
+Category: scripting
+Audit: 2020
+*/
+
+/** @type LanguageFn */
+function actionscript(hljs) {
+  const regex = hljs.regex;
+  const IDENT_RE = /[a-zA-Z_$][a-zA-Z0-9_$]*/;
+  const PKG_NAME_RE = regex.concat(
+    IDENT_RE,
+    regex.concat("(\\.", IDENT_RE, ")*")
+  );
+  const IDENT_FUNC_RETURN_TYPE_RE = /([*]|[a-zA-Z_$][a-zA-Z0-9_$]*)/;
+
+  const AS3_REST_ARG_MODE = {
+    className: 'rest_arg',
+    begin: /[.]{3}/,
+    end: IDENT_RE,
+    relevance: 10
+  };
+
+  const KEYWORDS = [
+    "as",
+    "break",
+    "case",
+    "catch",
+    "class",
+    "const",
+    "continue",
+    "default",
+    "delete",
+    "do",
+    "dynamic",
+    "each",
+    "else",
+    "extends",
+    "final",
+    "finally",
+    "for",
+    "function",
+    "get",
+    "if",
+    "implements",
+    "import",
+    "in",
+    "include",
+    "instanceof",
+    "interface",
+    "internal",
+    "is",
+    "namespace",
+    "native",
+    "new",
+    "override",
+    "package",
+    "private",
+    "protected",
+    "public",
+    "return",
+    "set",
+    "static",
+    "super",
+    "switch",
+    "this",
+    "throw",
+    "try",
+    "typeof",
+    "use",
+    "var",
+    "void",
+    "while",
+    "with"
+  ];
+  const LITERALS = [
+    "true",
+    "false",
+    "null",
+    "undefined"
+  ];
+
+  return {
+    name: 'ActionScript',
+    aliases: [ 'as' ],
+    keywords: {
+      keyword: KEYWORDS,
+      literal: LITERALS
+    },
+    contains: [
+      hljs.APOS_STRING_MODE,
+      hljs.QUOTE_STRING_MODE,
+      hljs.C_LINE_COMMENT_MODE,
+      hljs.C_BLOCK_COMMENT_MODE,
+      hljs.C_NUMBER_MODE,
+      {
+        match: [
+          /\bpackage/,
+          /\s+/,
+          PKG_NAME_RE
+        ],
+        className: {
+          1: "keyword",
+          3: "title.class"
+        }
+      },
+      {
+        match: [
+          /\b(?:class|interface|extends|implements)/,
+          /\s+/,
+          IDENT_RE
+        ],
+        className: {
+          1: "keyword",
+          3: "title.class"
+        }
+      },
+      {
+        className: 'meta',
+        beginKeywords: 'import include',
+        end: /;/,
+        keywords: { keyword: 'import include' }
+      },
+      {
+        beginKeywords: 'function',
+        end: /[{;]/,
+        excludeEnd: true,
+        illegal: /\S/,
+        contains: [
+          hljs.inherit(hljs.TITLE_MODE, { className: "title.function" }),
+          {
+            className: 'params',
+            begin: /\(/,
+            end: /\)/,
+            contains: [
+              hljs.APOS_STRING_MODE,
+              hljs.QUOTE_STRING_MODE,
+              hljs.C_LINE_COMMENT_MODE,
+              hljs.C_BLOCK_COMMENT_MODE,
+              AS3_REST_ARG_MODE
+            ]
+          },
+          { begin: regex.concat(/:\s*/, IDENT_FUNC_RETURN_TYPE_RE) }
+        ]
+      },
+      hljs.METHOD_GUARD
+    ],
+    illegal: /#/
+  };
+}
+
+export { actionscript as default };

package/highlight.js/es/languages/actionscript.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/actionscript" instead of "highlight.js/lib/languages/actionscript.js"'
+      );
+    }
+  }
+  emitWarning();
+    import lang from './actionscript.js';
+    export default lang;

package/highlight.js/es/languages/ada.js

@@ -0,0 +1,265 @@
+/*
+Language: Ada
+Author: Lars Schulna <kartoffelbrei.mit.muskatnuss@gmail.org>
+Description: Ada is a general-purpose programming language that has great support for saftey critical and real-time applications.
+             It has been developed by the DoD and thus has been used in military and safety-critical applications (like civil aviation).
+             The first version appeared in the 80s, but it's still actively developed today with
+             the newest standard being Ada2012.
+*/
+
+// We try to support full Ada2012
+//
+// We highlight all appearances of types, keywords, literals (string, char, number, bool)
+// and titles (user defined function/procedure/package)
+// CSS classes are set accordingly
+//
+// Languages causing problems for language detection:
+// xml (broken by Foo : Bar type), elm (broken by Foo : Bar type), vbscript-html (broken by body keyword)
+// sql (ada default.txt has a lot of sql keywords)
+
+/** @type LanguageFn */
+function ada(hljs) {
+  // Regular expression for Ada numeric literals.
+  // stolen form the VHDL highlighter
+
+  // Decimal literal:
+  const INTEGER_RE = '\\d(_|\\d)*';
+  const EXPONENT_RE = '[eE][-+]?' + INTEGER_RE;
+  const DECIMAL_LITERAL_RE = INTEGER_RE + '(\\.' + INTEGER_RE + ')?' + '(' + EXPONENT_RE + ')?';
+
+  // Based literal:
+  const BASED_INTEGER_RE = '\\w+';
+  const BASED_LITERAL_RE = INTEGER_RE + '#' + BASED_INTEGER_RE + '(\\.' + BASED_INTEGER_RE + ')?' + '#' + '(' + EXPONENT_RE + ')?';
+
+  const NUMBER_RE = '\\b(' + BASED_LITERAL_RE + '|' + DECIMAL_LITERAL_RE + ')';
+
+  // Identifier regex
+  const ID_REGEX = '[A-Za-z](_?[A-Za-z0-9.])*';
+
+  // bad chars, only allowed in literals
+  const BAD_CHARS = `[]\\{\\}%#'"`;
+
+  // Ada doesn't have block comments, only line comments
+  const COMMENTS = hljs.COMMENT('--', '$');
+
+  // variable declarations of the form
+  // Foo : Bar := Baz;
+  // where only Bar will be highlighted
+  const VAR_DECLS = {
+    // TODO: These spaces are not required by the Ada syntax
+    // however, I have yet to see handwritten Ada code where
+    // someone does not put spaces around :
+    begin: '\\s+:\\s+',
+    end: '\\s*(:=|;|\\)|=>|$)',
+    // endsWithParent: true,
+    // returnBegin: true,
+    illegal: BAD_CHARS,
+    contains: [
+      {
+        // workaround to avoid highlighting
+        // named loops and declare blocks
+        beginKeywords: 'loop for declare others',
+        endsParent: true
+      },
+      {
+        // properly highlight all modifiers
+        className: 'keyword',
+        beginKeywords: 'not null constant access function procedure in out aliased exception'
+      },
+      {
+        className: 'type',
+        begin: ID_REGEX,
+        endsParent: true,
+        relevance: 0
+      }
+    ]
+  };
+
+  const KEYWORDS = [
+    "abort",
+    "else",
+    "new",
+    "return",
+    "abs",
+    "elsif",
+    "not",
+    "reverse",
+    "abstract",
+    "end",
+    "accept",
+    "entry",
+    "select",
+    "access",
+    "exception",
+    "of",
+    "separate",
+    "aliased",
+    "exit",
+    "or",
+    "some",
+    "all",
+    "others",
+    "subtype",
+    "and",
+    "for",
+    "out",
+    "synchronized",
+    "array",
+    "function",
+    "overriding",
+    "at",
+    "tagged",
+    "generic",
+    "package",
+    "task",
+    "begin",
+    "goto",
+    "pragma",
+    "terminate",
+    "body",
+    "private",
+    "then",
+    "if",
+    "procedure",
+    "type",
+    "case",
+    "in",
+    "protected",
+    "constant",
+    "interface",
+    "is",
+    "raise",
+    "use",
+    "declare",
+    "range",
+    "delay",
+    "limited",
+    "record",
+    "when",
+    "delta",
+    "loop",
+    "rem",
+    "while",
+    "digits",
+    "renames",
+    "with",
+    "do",
+    "mod",
+    "requeue",
+    "xor"
+  ];
+
+  return {
+    name: 'Ada',
+    case_insensitive: true,
+    keywords: {
+      keyword: KEYWORDS,
+      literal: [
+        "True",
+        "False"
+      ]
+    },
+    contains: [
+      COMMENTS,
+      // strings "foobar"
+      {
+        className: 'string',
+        begin: /"/,
+        end: /"/,
+        contains: [
+          {
+            begin: /""/,
+            relevance: 0
+          }
+        ]
+      },
+      // characters ''
+      {
+        // character literals always contain one char
+        className: 'string',
+        begin: /'.'/
+      },
+      {
+        // number literals
+        className: 'number',
+        begin: NUMBER_RE,
+        relevance: 0
+      },
+      {
+        // Attributes
+        className: 'symbol',
+        begin: "'" + ID_REGEX
+      },
+      {
+        // package definition, maybe inside generic
+        className: 'title',
+        begin: '(\\bwith\\s+)?(\\bprivate\\s+)?\\bpackage\\s+(\\bbody\\s+)?',
+        end: '(is|$)',
+        keywords: 'package body',
+        excludeBegin: true,
+        excludeEnd: true,
+        illegal: BAD_CHARS
+      },
+      {
+        // function/procedure declaration/definition
+        // maybe inside generic
+        begin: '(\\b(with|overriding)\\s+)?\\b(function|procedure)\\s+',
+        end: '(\\bis|\\bwith|\\brenames|\\)\\s*;)',
+        keywords: 'overriding function procedure with is renames return',
+        // we need to re-match the 'function' keyword, so that
+        // the title mode below matches only exactly once
+        returnBegin: true,
+        contains:
+                [
+                  COMMENTS,
+                  {
+                    // name of the function/procedure
+                    className: 'title',
+                    begin: '(\\bwith\\s+)?\\b(function|procedure)\\s+',
+                    end: '(\\(|\\s+|$)',
+                    excludeBegin: true,
+                    excludeEnd: true,
+                    illegal: BAD_CHARS
+                  },
+                  // 'self'
+                  // // parameter types
+                  VAR_DECLS,
+                  {
+                    // return type
+                    className: 'type',
+                    begin: '\\breturn\\s+',
+                    end: '(\\s+|;|$)',
+                    keywords: 'return',
+                    excludeBegin: true,
+                    excludeEnd: true,
+                    // we are done with functions
+                    endsParent: true,
+                    illegal: BAD_CHARS
+
+                  }
+                ]
+      },
+      {
+        // new type declarations
+        // maybe inside generic
+        className: 'type',
+        begin: '\\b(sub)?type\\s+',
+        end: '\\s+',
+        keywords: 'type',
+        excludeBegin: true,
+        illegal: BAD_CHARS
+      },
+
+      // see comment above the definition
+      VAR_DECLS
+
+      // no markup
+      // relevance boosters for small snippets
+      // {begin: '\\s*=>\\s*'},
+      // {begin: '\\s*:=\\s*'},
+      // {begin: '\\s+:=\\s+'},
+    ]
+  };
+}
+
+export { ada as default };

package/highlight.js/es/languages/ada.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/ada" instead of "highlight.js/lib/languages/ada.js"'
+      );
+    }
+  }
+  emitWarning();
+    import lang from './ada.js';
+    export default lang;