static/highlight/es/languages/nix.js

   1 /*! `nix` grammar compiled for Highlight.js 11.11.1 */
   2 var hljsGrammar = (function () {
   3   'use strict';
   4
   5   /*
   6   Language: Nix
   7   Author: Domen Kožar <domen@dev.si>
   8   Description: Nix functional language
   9   Website: http://nixos.org/nix
  10   Category: system
  11   */
  12
  13   /** @type LanguageFn */
  14   function nix(hljs) {
  15     const regex = hljs.regex;
  16     const KEYWORDS = {
  17       keyword: [
  18         "assert",
  19         "else",
  20         "if",
  21         "in",
  22         "inherit",
  23         "let",
  24         "or",
  25         "rec",
  26         "then",
  27         "with",
  28       ],
  29       literal: [
  30         "true",
  31         "false",
  32         "null",
  33       ],
  34       built_in: [
  35         // toplevel builtins
  36         "abort",
  37         "baseNameOf",
  38         "builtins",
  39         "derivation",
  40         "derivationStrict",
  41         "dirOf",
  42         "fetchGit",
  43         "fetchMercurial",
  44         "fetchTarball",
  45         "fetchTree",
  46         "fromTOML",
  47         "import",
  48         "isNull",
  49         "map",
  50         "placeholder",
  51         "removeAttrs",
  52         "scopedImport",
  53         "throw",
  54         "toString",
  55       ],
  56     };
  57
  58     const BUILTINS = {
  59       scope: 'built_in',
  60       match: regex.either(...[
  61         "abort",
  62         "add",
  63         "addDrvOutputDependencies",
  64         "addErrorContext",
  65         "all",
  66         "any",
  67         "appendContext",
  68         "attrNames",
  69         "attrValues",
  70         "baseNameOf",
  71         "bitAnd",
  72         "bitOr",
  73         "bitXor",
  74         "break",
  75         "builtins",
  76         "catAttrs",
  77         "ceil",
  78         "compareVersions",
  79         "concatLists",
  80         "concatMap",
  81         "concatStringsSep",
  82         "convertHash",
  83         "currentSystem",
  84         "currentTime",
  85         "deepSeq",
  86         "derivation",
  87         "derivationStrict",
  88         "dirOf",
  89         "div",
  90         "elem",
  91         "elemAt",
  92         "false",
  93         "fetchGit",
  94         "fetchMercurial",
  95         "fetchTarball",
  96         "fetchTree",
  97         "fetchurl",
  98         "filter",
  99         "filterSource",
 100         "findFile",
 101         "flakeRefToString",
 102         "floor",
 103         "foldl'",
 104         "fromJSON",
 105         "fromTOML",
 106         "functionArgs",
 107         "genList",
 108         "genericClosure",
 109         "getAttr",
 110         "getContext",
 111         "getEnv",
 112         "getFlake",
 113         "groupBy",
 114         "hasAttr",
 115         "hasContext",
 116         "hashFile",
 117         "hashString",
 118         "head",
 119         "import",
 120         "intersectAttrs",
 121         "isAttrs",
 122         "isBool",
 123         "isFloat",
 124         "isFunction",
 125         "isInt",
 126         "isList",
 127         "isNull",
 128         "isPath",
 129         "isString",
 130         "langVersion",
 131         "length",
 132         "lessThan",
 133         "listToAttrs",
 134         "map",
 135         "mapAttrs",
 136         "match",
 137         "mul",
 138         "nixPath",
 139         "nixVersion",
 140         "null",
 141         "parseDrvName",
 142         "parseFlakeRef",
 143         "partition",
 144         "path",
 145         "pathExists",
 146         "placeholder",
 147         "readDir",
 148         "readFile",
 149         "readFileType",
 150         "removeAttrs",
 151         "replaceStrings",
 152         "scopedImport",
 153         "seq",
 154         "sort",
 155         "split",
 156         "splitVersion",
 157         "storeDir",
 158         "storePath",
 159         "stringLength",
 160         "sub",
 161         "substring",
 162         "tail",
 163         "throw",
 164         "toFile",
 165         "toJSON",
 166         "toPath",
 167         "toString",
 168         "toXML",
 169         "trace",
 170         "traceVerbose",
 171         "true",
 172         "tryEval",
 173         "typeOf",
 174         "unsafeDiscardOutputDependency",
 175         "unsafeDiscardStringContext",
 176         "unsafeGetAttrPos",
 177         "warn",
 178         "zipAttrsWith",
 179       ].map(b => `builtins\\.${b}`)),
 180       relevance: 10,
 181     };
 182
 183     const IDENTIFIER_REGEX = '[A-Za-z_][A-Za-z0-9_\'-]*';
 184
 185     const LOOKUP_PATH = {
 186       scope: 'symbol',
 187       match: new RegExp(`<${IDENTIFIER_REGEX}(/${IDENTIFIER_REGEX})*>`),
 188     };
 189
 190     const PATH_PIECE = "[A-Za-z0-9_\\+\\.-]+";
 191     const PATH = {
 192       scope: 'symbol',
 193       match: new RegExp(`(\\.\\.|\\.|~)?/(${PATH_PIECE})?(/${PATH_PIECE})*(?=[\\s;])`),
 194     };
 195
 196     const OPERATOR_WITHOUT_MINUS_REGEX = regex.either(...[
 197       '==',
 198       '=',
 199       '\\+\\+',
 200       '\\+',
 201       '<=',
 202       '<\\|',
 203       '<',
 204       '>=',
 205       '>',
 206       '->',
 207       '//',
 208       '/',
 209       '!=',
 210       '!',
 211       '\\|\\|',
 212       '\\|>',
 213       '\\?',
 214       '\\*',
 215       '&&',
 216     ]);
 217
 218     const OPERATOR = {
 219       scope: 'operator',
 220       match: regex.concat(OPERATOR_WITHOUT_MINUS_REGEX, /(?!-)/),
 221       relevance: 0,
 222     };
 223
 224     // '-' is being handled by itself to ensure we are able to tell the difference
 225     // between a dash in an identifier and a minus operator
 226     const NUMBER = {
 227       scope: 'number',
 228       match: new RegExp(`${hljs.NUMBER_RE}(?!-)`),
 229       relevance: 0,
 230     };
 231     const MINUS_OPERATOR = {
 232       variants: [
 233         {
 234           scope: 'operator',
 235           beforeMatch: /\s/,
 236           // The (?!>) is used to ensure this doesn't collide with the '->' operator
 237           begin: /-(?!>)/,
 238         },
 239         {
 240           begin: [
 241             new RegExp(`${hljs.NUMBER_RE}`),
 242             /-/,
 243             /(?!>)/,
 244           ],
 245           beginScope: {
 246             1: 'number',
 247             2: 'operator'
 248           },
 249         },
 250         {
 251           begin: [
 252             OPERATOR_WITHOUT_MINUS_REGEX,
 253             /-/,
 254             /(?!>)/,
 255           ],
 256           beginScope: {
 257             1: 'operator',
 258             2: 'operator'
 259           },
 260         },
 261       ],
 262       relevance: 0,
 263     };
 264
 265     const ATTRS = {
 266       beforeMatch: /(^|\{|;)\s*/,
 267       begin: new RegExp(`${IDENTIFIER_REGEX}(\\.${IDENTIFIER_REGEX})*\\s*=(?!=)`),
 268       returnBegin: true,
 269       relevance: 0,
 270       contains: [
 271         {
 272           scope: 'attr',
 273           match: new RegExp(`${IDENTIFIER_REGEX}(\\.${IDENTIFIER_REGEX})*(?=\\s*=)`),
 274           relevance: 0.2,
 275         }
 276       ],
 277     };
 278
 279     const NORMAL_ESCAPED_DOLLAR = {
 280       scope: 'char.escape',
 281       match: /\\\$/,
 282     };
 283     const INDENTED_ESCAPED_DOLLAR = {
 284       scope: 'char.escape',
 285       match: /''\$/,
 286     };
 287     const ANTIQUOTE = {
 288       scope: 'subst',
 289       begin: /\$\{/,
 290       end: /\}/,
 291       keywords: KEYWORDS,
 292     };
 293     const ESCAPED_DOUBLEQUOTE = {
 294       scope: 'char.escape',
 295       match: /'''/,
 296     };
 297     const ESCAPED_LITERAL = {
 298       scope: 'char.escape',
 299       match: /\\(?!\$)./,
 300     };
 301     const STRING = {
 302       scope: 'string',
 303       variants: [
 304         {
 305           begin: "''",
 306           end: "''",
 307           contains: [
 308             INDENTED_ESCAPED_DOLLAR,
 309             ANTIQUOTE,
 310             ESCAPED_DOUBLEQUOTE,
 311             ESCAPED_LITERAL,
 312           ],
 313         },
 314         {
 315           begin: '"',
 316           end: '"',
 317           contains: [
 318             NORMAL_ESCAPED_DOLLAR,
 319             ANTIQUOTE,
 320             ESCAPED_LITERAL,
 321           ],
 322         },
 323       ],
 324     };
 325
 326     const FUNCTION_PARAMS = {
 327       scope: 'params',
 328       match: new RegExp(`${IDENTIFIER_REGEX}\\s*:(?=\\s)`),
 329     };
 330
 331     const EXPRESSIONS = [
 332       NUMBER,
 333       hljs.HASH_COMMENT_MODE,
 334       hljs.C_BLOCK_COMMENT_MODE,
 335       hljs.COMMENT(
 336         /\/\*\*(?!\/)/,
 337         /\*\//,
 338         {
 339           subLanguage: 'markdown',
 340           relevance: 0
 341         }
 342       ),
 343       BUILTINS,
 344       STRING,
 345       LOOKUP_PATH,
 346       PATH,
 347       FUNCTION_PARAMS,
 348       ATTRS,
 349       MINUS_OPERATOR,
 350       OPERATOR,
 351     ];
 352
 353     ANTIQUOTE.contains = EXPRESSIONS;
 354
 355     const REPL = [
 356       {
 357         scope: 'meta.prompt',
 358         match: /^nix-repl>(?=\s)/,
 359         relevance: 10,
 360       },
 361       {
 362         scope: 'meta',
 363         beforeMatch: /\s+/,
 364         begin: /:([a-z]+|\?)/,
 365       },
 366     ];
 367
 368     return {
 369       name: 'Nix',
 370       aliases: [ "nixos" ],
 371       keywords: KEYWORDS,
 372       contains: EXPRESSIONS.concat(REPL),
 373     };
 374   }
 375
 376   return nix;
 377
 378 })();
 379 ;
 380 export default hljsGrammar;