Humid.sublime-color-scheme

{
  "name": "Humid",
  "author": "https://github.com/frou",

  "variables": {
    "black": "#000000",
    // TWIN: What the Adaptive theme automatically derives for the Side Bar background colour.
    // TWIN: What I set `--mdpopups-hl-bg` to in User/mdpopups.css
    "black_light": "#141212",
    "blue": "#5a70a9",
    "blue_light": "#65a8ff",
    "gold": "#ad9361",
    "gold_punchy": "#eed600",
    "green": "#6a8856",
    "grey": "#3f3938",
    "grey_light": "#4f4d4d",
    "orange": "#ae7337",
    "orange_punchy": "#ff8000",
    "purple": "#995a64",
    "purple_punchy": "#fe3bff",
    "red": "#b75b4e",
    "red_punchy": "#bb0000",
    "slate": "#211e1e",
    "slate_light": "#60605a", // TWIN: "kind_namespace_color" in Adaptive theme customisation
    "slate_green": "#1e211e",
    "slate_blue": "#1e1e21",
    "steel": "#8c8c99",
    "steel_green": "#8c998c",
    "steel_red": "#998c8c",
    "white": "#cccccc", // NOTE: Use this for foreground when using `black` or `black_light` as background.
    "white_light": "#dadada",
    "white_punchy": "#ffffff",

    // Overrule ST where it picks what I feel is the wrong colour from those used in
    // this colour scheme to be a given *ish colour.
    //
    // REF: https://www.sublimetext.com/docs/minihtml.html#predefined-variables
    "--redish": "var(red)",
    //"--greenish": "var()",
    "--bluish": "var(blue)",
    "--yellowish": "var(gold)",
    //"--pinkish": "var()",
    "--cyanish": "var(steel)",
    //"--orangish": "var()",
    "--purplish": "var(purple)",
    //"--foreground": "var()",
    //"--background": "var()",
    //"--accent": "var()",
  },

  // REF: https://www.sublimetext.com/docs/color_schemes.html#global_settings
  "globals": {
    // @todo Use "popup_css" to make "Kind" icons in popups (e.g. the hover popup that shows Definition location) use my preferred colouring.
    // @body REF: discord://discord.com/channels/280102180189634562/280157067396775936/1053270072619180052
    // @body REF: https://github.com/sublimehq/sublime_text/issues/2935
    // @body REF: https://github.com/sublimehq/sublime_text/issues/3650
    // @body REF: https://github.com/sublimehq/sublime_text/issues/3651
    //
    // TWIN: User/Adaptive.sublime-theme
    //
    //"popup_css": "#show-definitions > span.kind_function { ... } ...",

    "foreground": "var(white_light)",
    "background": "var(slate)",

    "caret": "var(white_punchy)",

    "invisibles": "var(grey_light)",

    // NOTE: For lines with carets, this colour is used for line backgrounds if the
    //       "highlight_line" Preference is enabled, and for gutter backgrounds
    //       if the "highlight_gutter" Preference is enabled.
    "line_highlight": "var(grey)",

    "selection": "var(grey)",
    "selection_border": "var(grey)",
    "selection_corner_style": "square",

    "gutter": "var(slate)",
    "gutter_foreground": "var(grey)",
    // NOTE: For lines with carets, this colour is used for line numbers if the
    //       "highlight_line_number" Preference is enabled.
    "gutter_foreground_highlight": "var(slate_light)",

    "guide": "var(grey)",
    //"active_guide": "",
    //"stack_guide": "",

    "find_highlight_foreground": "var(black)",
    "find_highlight": "var(gold_punchy)",

    "brackets_options": "glow",
    "brackets_foreground": "var(orange_punchy)",

    "bracket_contents_options": "glow",
    "bracket_contents_foreground": "var(orange_punchy)",

    "tags_options": "glow",
    "tags_foreground": "var(gold_punchy)",

    "line_diff_width": "4",
    "line_diff_added": "color(var(green) lightness(- 20%))",
    "line_diff_modified": "color(var(blue) lightness(- 20%))",
    "line_diff_deleted": "color(var(red) lightness(- 20%))",

    "misspelling": "var(red_punchy)",
    //"fold_marker": "var(white_punchy)",
    "accent": "var(blue)",
  },

  // @todo Update selectors accordingly once using a build with the new wildcard scopes
  // @body https://github.com/sublimehq/Packages/pull/3803

  // NOTE: Operator precedence (descending) in scope selectors:
  // REF: https://www.sublimetext.com/docs/selectors.html#order-of-operations
  // REF: https://stackoverflow.com/questions/33562253/sublime-text-scope-selector-operators
  //
  //   ( )   Grouping
  //    -    Logical NOT
  //    &    Logical AND
  //    |    Logical OR
  //    ,    Logical OR
  //
  // By convention, use comma (lowest precedence) to separate different
  // languages in a scope selector.
  //
  // NOTE: When a selector consists of multiple space-separated scopes, it will only
  //       match something that has those scopes in the same order. Rather than using
  //       just a space in the selector, an & can be used to mean order doesn't
  //       matter, i.e. consider `foo bar` vs `bar foo` vs `foo & bar`.
  // REF: https://www.sublimetext.com/docs/selectors.html#:~:text=When%20a%20selector%20has%20multiple%20scope%20names
  // REF: https://www.sublimetext.com/docs/selectors.html#:~:text=The%20logical%20AND%20operator
  // @todo Was forgetting about the above why I had some issue and had to have the (js|jsx|ts|tsx)&() more than once in a selector to workaround?
  //
  "rules": [
    // ~~~~~~~
    // Comment
    // ~~~~~~~
    {
      "scope": "comment - ((source.clojure | source.edn) & comment.punctuation.comma)",
      "foreground": "var(slate_light)"
    },
    {
      // Stuff that isn't misclassified, but I want it to have the same colour as `comment`, just because.
      "scope": "source.zig string.unquoted punctuation.definition.string.begin , source.elixir & (variable.parameter.unused | variable.other.unused)",
      "foreground": "var(slate_light)"
    },
    {
      // Structured comment formats like JSDoc contain tags like @param. Make those look distinct from the rest of the comment.
      "scope": "(source.js | source.jsx | source.ts | source.tsx) & comment.block.documentation entity.other.attribute-name.documentation",
      "foreground": "var(steel_red)"
    },
    // ~~~~~~~~
    // Constant
    // ~~~~~~~~
    {
      "scope": "constant - ((source.js | source.jsx | source.ts | source.tsx) & meta.import constant.other , (source.js | source.jsx | source.ts | source.tsx) & meta.export constant.other , source.python comment meta.type , source.shell.bash constant.other.wildcard , constant.language.shebang , source.rust constant.other.rust , source.python comment meta.type constant.other.error-code , text.syntax-tests meta.summary.success message.info constant.numeric , source.erlang constant.other.macro)",
      "foreground": "var(red)"
    },
    {
      // Stuff that isn't misclassified, but I want it to have the same colour as `constant`, just because.
      "scope": "text.build-results markup.pointing-carets , text.xml.kajiki & (punctuation.section.interpolation.begin | punctuation.section.interpolation.end) , text.build-results.go keyword.pseudo-linter-name , source.elixir variable.language.special-form , source.ruby meta.tag.heredoc entity.name.tag , (source.ts | source.tsx) & meta.type & (support.type.primitive.undefined | support.type.primitive.null | support.type.primitive.boolean.true | support.type.primitive.boolean.false)",
      "foreground": "var(red)"
    },
    {
      // Despite the conventional scope name used for them, Escape Sequences (like `\n`) are conceptually the opposite of constant characters (like `a`). So use something other than the normal `constant` colour.
      "scope": "constant.character.escape",
      "foreground": "var(blue_light)"
    },
    // ~~~~~~
    // Entity
    // ~~~~~~
    {
      "scope": "entity - (source.c++ entity.name.function punctuation.accessor , source.go entity.name.namespace , source.ruby & (entity.other.inherited-class | entity.name.namespace) & punctuation.accessor.double-colon , source.yaml.sublime.syntax comment entity.name.section)",
      "foreground": "var(orange)"
    },
    {
      // Stuff that isn't misclassified, but I want it to have the same colour as `entity`, just because.
      "scope": "source.file-pattern support.constant , source.ts meta.interface variable.other.readwrite",
      "foreground": "var(orange)"
    },
    // ~~~~~~~
    // Invalid
    // ~~~~~~~
    {
      "scope": "invalid - source.python.lenient , text.syntax-tests meta.summary.failure message.error constant.numeric",
      "background": "var(red_punchy)",
      "foreground": "var(white_light)"
    },
    {
      "scope": "invalid.deprecated - source.python.lenient",
      "background": "var(red)",
      "foreground": "var(white_light)"
    },
    // ~~~~~~~
    // Keyword
    // ~~~~~~~
    {
      // PL word-like keywords.
      // @todo `(source.ts | source.tsx) & meta.type keyword.declaration.function` in here seems to affect Go?
      // @→    e.g. `func` in `type Input struct { cleanup func() }` doesn't get coloured.
      "scope": "keyword - keyword.operator - ((source.js | source.jsx | source.ts | source.tsx) & keyword.declaration.function.arrow , (source.ts | source.tsx) & meta.type keyword.declaration.function , source.python keyword.control.import.relative , source.python comment meta.type , source.ruby keyword.declaration.function.anonymous)",
      "foreground": "var(green)"
    },
    {
      // PL word-like operators.
      //
      // NOTE: For programming languages, this Colour Scheme intends that typical punctuation-like
      // operators e.g. `+ / && =` should never be coloured (because they already look distinct enough
      // due to the shapes of the glyphs alone), which is why the scope `keyword.operator` is negated
      // in the previous rule.
      //
      // However, this Colour Scheme does intend that word-like operators e.g. `and not in instanceof`
      // should be coloured.
      //
      // Not all Syntax Definitions establish any distinction in scopes between those two kinds of
      // operators, and so some .sublime-syntax files additionally need to be Overridden (the
      // modifications usually being the addition of the scope `keyword.operator.word.*`).
      // Among ST's stock Syntax Definitions, some that currently need such an override file are:
      //   - Erlang
      //   - Ruby
      //   - TypeScript
      // REF: https://github.com/sublimehq/Packages/pull/2090
      "scope": "keyword.operator.word - keyword.operator.type.assertion.dh.js , keyword.operator.js , source.python keyword.operator.logical.python , source.sql & (keyword.operator.logical | keyword.operator.assignment) - meta.string.python , source.yaml.sublime.syntax keyword.operator.include , source.elixir & (keyword.operator.when | keyword.operator.logical) , source.go keyword.operator.type , text.html.svelte source.js.embedded.svelte keyword.operator.assignment.as",
      "foreground": "var(green)"
    },
    { // 'File Pattern' operators (ST UI); Regexp operators (ST UI & Some other Syntaxes); Regexp Literal internal operators (PLs with Regexp Literals).
      "scope": "source.file-pattern & (keyword.operator.logical | punctuation.separator - punctuation.separator.path) , source.regexp keyword.operator , source.regexp-replace & (keyword.operator | variable.language.backref) , (source.js | source.jsx | source.ts | source.tsx) & string.regexp.js & (keyword.operator | punctuation - punctuation.definition.string) , (source.clojure | source.edn) & string.regexp.edn keyword.operator - keyword.operator.macro",
      "foreground": "var(green)"
    },
    {
      // Stuff I feel should be classified as `keyword` but I don't control the syntax definitions. Make them look like it at least.
      "scope": "source.python & (storage.modifier - storage.modifier.conversion - storage.modifier.debug - storage.modifier.named-args-only - storage.modifier.positional-args-only) - source.sql , (source.js | source.jsx | source.ts | source.tsx) & (variable.language.super | variable.language.this | storage.modifier - (meta.type | storage.modifier.array | storage.modifier.optional | storage.modifier.definite)) , (source.c | source.c++) & storage.modifier , source.ruby entity.name.function.preprocessor , source.ruby variable.language , source.makefile constant.language.makefile",
      "foreground": "var(green)"
    },
    {
      // Stuff that isn't misclassified, but I want it to have the same colour as `keyword`, just because.
      "scope": "source.css support.constant , source.makefile variable.language.automatic , (source.js | source.jsx | source.ts | source.tsx) & (variable.language.global | variable.language.arguments)",
      "foreground": "var(green)"
    },
    // ~~~~~~
    // Markup
    // ~~~~~~
    {
      "scope": "markup - (text.html.markdown & (markup.raw.code-fence | markup.raw.inline | meta.paragraph.list )) , text.html.markdown punctuation.definition.raw",
      "foreground": "var(steel)"
    },
    {
      // Stuff I feel should be classified as `markup` but I don't control the syntax definitions. Make them look like it at least.
      "scope": "source string constant.other.placeholder",
      "foreground": "var(steel)"
    },
    // Stuff that isn't misclassified, but I want it to have the same colour as `markup`, just because.
    {
      "scope": "source.ocaml meta.path , (source.clojure | source.edn) & constant.other.keyword , source.json.sublime.color-scheme meta.scope-selector.sublime & (keyword.operator | punctuation.section.group) , source.css meta.selector & (entity.other.attribute-name.class | entity.other.pseudo-class) , meta.diff , source.erlang & (constant.other.symbol | constant.language.exception | constant.language.boolean) , (source.js | source.jsx | source.ts | source.tsx) & (meta.string meta.interpolation punctuation.section.interpolation | meta.mapping.key - variable.parameter.function) , (source.jsx | source.tsx) & entity.other.attribute-name , source.python & (meta.function-call.arguments.python variable.parameter - meta.function.inline.parameters) , source.regexp-replace variable.language.match , source.sml meta.path variable.namespace , source.yaml.sublime.syntax meta.variable & (punctuation.definition.variable | variable.other) , source.ruby constant.other.symbol , source.ruby meta.string meta.interpolation punctuation.section.interpolation , source.ruby meta.string meta.interpolation punctuation.definition.variable - source.ruby.embedded , source.sbnf string.quoted variable.parameter.sbnf , source.raku variable.parameter , source.elixir constant.other.symbol , source.elixir meta.string meta.interpolation punctuation.section.interpolation , source.elixir support.attr , source.makefile meta.interpolation variable.parameter , source.swift variable.parameter.external-parameter-name",
      "foreground": "var(steel)"
    },
    { // NOTE: For an unclear reason, this needed to be split out from the above to work. Was the total selector complexity tripping some limit?
      "scope": "source.shell.bash & (meta.string.shell | meta.string.heredoc.shell | meta.conditional.shell) & (punctuation.definition.variable | punctuation.section.interpolation | variable.other.readwrite) , source.python meta.string meta.interpolation punctuation.section.interpolation",
      "foreground": "var(steel)"
    },
    // ~~~~~~~
    // Storage
    // ~~~~~~~
    {
      "scope": "storage - (source.python storage.modifier.debug , source.python storage.modifier.positional-args-only , source.python storage.modifier.named-args-only , (source.ts | source.tsx) & storage.modifier.array)",
      "foreground": "var(gold)"
    },
    {
      // Stuff I feel should be classified as `storage` but I don't control the syntax definitions. Make them look like it at least.
      "scope": "source.python & (meta.type & (support.class.typing | meta.generic-name | constant.language) | meta.statement.exception.catch meta.path & (support.class.exception | meta.generic-name) | support.type - (variable.function | meta.function-call.identifier) | variable.parameter.type) , source.c support.type , (source.js | source.jsx | source.ts | source.tsx) & (variable.type | variable.parameter.generic | support.type - support.type.object | support.class.builtin) , (source.ts | source.tsx) & (meta.type | meta.type-alias | meta.generic) & support.class , source.swift & (support.type | support.class) , source.erlang meta.preprocessor.spec meta.atom support.type",
      "foreground": "var(gold)"
    },
    {
      // Stuff that isn't misclassified, but I want it to have the same colour as `storage`, just because.
      "scope": "entity.other.inherited-class - (source.ruby punctuation.accessor.double-colon) , source.css meta.selector & (entity.name.tag | entity.other.pseudo-element) , text.git.commit markup.heading.subject , (source.js | source.jsx | source.ts | source.tsx) & (keyword.declaration.async.js | entity.name.function.constructor | keyword.declaration.generator | keyword.generator.asterisk) , (text.xml | text.html | text.build-results.html-validate | source.jsx | source.tsx | source.ts comment.line.triple-slash) & entity.name.tag , source.ruby & (support.other.namespace | support.class) , source.ruby string.quoted.other.literal punctuation.definition.string , source.python & (meta.function.parameters | meta.generic) & keyword.operator.unpacking , source.shell.bash meta.interpolation.parameter & (keyword.operator | meta.item-access variable.language.array) , source.sml & (constant.other | entity.name.function.constructor) , source.makefile meta.function.arguments.makefile string.unquoted.makefile - punctuation.separator.continuation.line , source.elixir constant.other.module , source.rust support.type",
      "foreground": "var(gold)"
    },
    // ~~~~~~
    // String
    // ~~~~~~
    {
      "scope": "string - ((source.shell.bash | source.shell.embedded.makefile) & meta.function-call.arguments.shell string.unquoted.shell - string.quoted , source.shell.bash string.unquoted.shell , (source.clojure | source.edn) & string.regexp punctuation.definition.string.begin keyword.operator.macro , source.ruby string.interpolated punctuation.definition.string , source.python comment meta.type , (source.js | source.jsx | source.ts | source.tsx) & string.regexp - punctuation.definition.string , source.makefile punctuation.separator.continuation.line)",
      "foreground": "var(blue)"
    },
    {
      // Stuff I feel should be classified as `string` but I don't control the syntax definitions. Make them look like it at least.
      "scope": "source.shell.bash meta.function-call.identifier meta.string.shell punctuation.definition.string , source.python comment.block.documentation , source.go string.quoted.single constant.character.literal",
      "foreground": "var(blue)"
    },
    {
      // Stuff that isn't misclassified, but I want it to have the same colour as `string`, just because.
      "scope": "source.ruby meta.constant meta.interpolation punctuation.section.interpolation",
      "foreground": "var(blue)"
    },
    // ~~~~~~~
    // Support
    // ~~~~~~~
    {
      "scope": "support - ((source.js | source.jsx | source.ts | source.tsx) , source.go support.type , source.python entity.name.function , source.python meta.statement.import , source.python support.variable.magic , source.erlang support.namespace , source.ruby support.function.builtin) , (source.js | source.jsx | source.ts | source.tsx) & (support.function - invalid.deprecated)",
      "foreground": "var(purple)"
    },
    {
      // Stuff I feel should be classified as `support` but I don't control the syntax definitions. Make them look like it at least.
      "scope": "source variable.function - ((source.clojure | source.edn) & (meta.namespace | punctuation.accessor)) , source.python variable.annotation",
      "foreground": "var(purple)"
    },
    {
      // Stuff that isn't misclassified, but I want it to have the same colour as `support`, just because.
      "scope": "(source.json | source.yaml | source.ini) & meta.mapping.key string , source.toml meta.tag.key & (entity.name.tag | string.quoted) , (text.xml | text.html | source.ts comment.line.triple-slash) & entity.other.attribute-name , source.clojure keyword.declaration.namespace , source.file-pattern & (constant.language | constant.other.wildcard) , (source.jsx | source.tsx) & meta.tag.name & (entity.name.tag - entity.name.tag.native | punctuation.accessor) , source.erlang & (meta.function.identifier | meta.function-call.identifier) & meta.atom constant.other.macro",
      "foreground": "var(purple)"
    },

    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    // Nullify the SQL syntax highlighter kicking in inside strings in other
    // languages. That such a feature is possible is a cool technical achievement
    // of ST, but subjectively I don't find that it helps overall readability.
    //
    // NOTE: The following is not in the "String" section above, because it seems like
    // it needs to be after the "Support" section to win against it when both the
    // selectors score the same. e.g. `COUNT` in
    //     "SELECT COUNT(*) FROM ..."
    // ...would still be purple even though `SELECT` and `FROM` wouldn't be green.
    // Though, would scores be the same if the following issue was fixed?
    //     https://github.com/sublimehq/sublime_text/issues/2152
    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    {
      "scope": "source.python meta.string.python source.sql & (source | comment | constant | entity | keyword | markup | storage | string | support)",
      "foreground": "var(blue)"
    },

    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    // Basic Styling
    // REF: https://www.sublimetext.com/docs/scope_naming.html#markup
    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    {"name": "markup bold",                  "scope": "markup.bold", "font_style": "bold"},
    {"name": "markup italic",                "scope": "markup.italic", "font_style": "italic"},
    {"name": "markup underline",             "scope": "markup.underline", "font_style": "underline"},
    {"name": "markup bold/italic",           "scope": "markup.italic markup.bold | markup.bold markup.italic", "font_style": "bold italic"},
    {"name": "markup bold/underline",        "scope": "markup.underline markup.bold | markup.bold markup.underline", "font_style": "bold underline"},
    {"name": "markup italic/underline",      "scope": "markup.underline markup.italic | markup.italic markup.underline", "font_style": "italic underline"},
    {"name": "markup bold/italic/underline", "scope": "markup.bold markup.italic markup.underline | markup.bold markup.underline markup.italic | markup.italic markup.bold markup.underline | markup.italic markup.underline markup.bold | markup.underline markup.bold markup.italic | markup.underline markup.italic markup.bold", "font_style": "bold italic underline"},

    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    // Things that should GLOW
    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    {
      "scope": "source.erlang & (punctuation.separator.expressions | punctuation.separator.clauses | punctuation.terminator.clause) , meta.dangerous , source.zig & (constant.language.undefined | variable.language.ignore)",
      "font_style": "glow"
    },

    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    // Exotic Strings
    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    {
      "scope": "source.erlang meta.sequence.binary & (string.quoted.double)", // punctuation.definition.sequence |
      "foreground": "var(steel_red)"
    },

    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    // Embedded programming languages in otherwise freeform text templates:
    //   - ERB (Though ERB is not Rails-specific, the ST stock packages call it "Rails")
    //   - EEx
    //   - Jinja2
    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    {
      "scope": "meta.embedded.rails , meta.embedded.eex , meta.template.jinja & (meta.embedded.statement | meta.embedded.expression)",
      "background": "var(black)"
    },

    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    // JSX Templating
    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    {
      "scope": "(source.jsx | source.tsx) & meta.jsx meta.interpolation",
      "background": "var(black)"
    },

    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    // Markdown Code Spans and Fenced Code Blocks (Indented Code Blocks omitted)
    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    {
      "scope": "text.html.markdown & (markup.raw.code-fence | markup.raw.inline)",
      "background": "var(black)"
    },

    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    // Excerpts of one's own code in sometimes many-line warning/error messages
    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    {
      "scope": "text.build-results.mlton source.sml.embedded",
      "background": "var(black)",
      "foreground": "var(white)"
    },

    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    // Preprocessor Directives, and certain Annotations
    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    { // Repurposed comments according to the respective Syntax Definitions.
      "scope": "comment & (meta.preprocessor | meta.annotation) - source.erlang",
      "background": "var(black)",
    },
    { // Non-comments according to the respective Syntax Definitions.
      "scope": "source.haskell meta.preprocessor , source.ocaml meta.preprocessor , source.rust meta.annotation",
      "background": "var(black)",
      "foreground": "var(slate_light)"
    },

    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    // Native Regexp Literal (for languages which have them) bodies
    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    {
      "scope": "(source.js | source.jsx | source.ts | source.tsx) & string.regexp - punctuation.definition.string , source.ruby meta.string.regexp - punctuation.definition.string , source.clojure string.regexp.edn - punctuation.definition.string",
      "background": "var(black)"
    },

    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    // Shell Arithmetic Expansion
    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    {
      "scope": "source.shell.bash meta.interpolation.arithmetic",
      "background": "var(black)"
    },

    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    // Python Interpolations in f-strings
    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    {
      "scope": "source.python meta.string meta.interpolation & (source.python.embedded | storage.modifier.debug)", // punctuation.section.interpolation
      "background": "var(black)"
    },

    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    // Argument labels in languages where we're using the 'Markup' colour for some
    // other significant syntactic construct (e.g. symbol literals, module paths)
    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    {
      "scope": "source.ocaml punctuation.label.argument , source.ruby constant.other.symbol.hash-key-sugar , source.elixir constant.other.keyword , source.scala3 variable.parameter , source.sml meta.mapping.key , source.erlang meta.mapping.key meta.atom constant.other.symbol",
      "foreground": "var(steel_green)",
    },
    { // In languages that don't have the above circumstances, instead make use of the colour in miscellaneous ways.
      "scope": "source.python & (keyword.declaration.async | storage.modifier.async | keyword.control.flow.await) , source.yaml.sublime.syntax meta.include string.unquoted.plain variable.other , source.clojure constant.other.keyword.auto-qualified , source.sml variable.other.member",
      "foreground": "var(steel_green)",
    },

    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    // Dangerous Language-Constructs/Functions/etc
    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    {
      "scope": "meta.dangerous - source.sml meta.dangerous.exception-raiser.suffix",
      "foreground": "var(red)"
    },
    {
      "scope": "meta.dangerous keyword.operator - keyword.operator.word",
      // Operators that aren't words are generally 1-2 punctuation characters, which need extra help to visually stand out.
      "foreground": "var(red_punchy)"
    },

    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    // File Paths and Line Numbers
    //   - Find Results panel
    //   - LSP panels
    //     - Diagnostics
    //     - References
    //   - Build Results panel
    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    {"scope": "text.find-in-files & (entity.name.filename | constant.numeric.line-number.match) , output.lsp & (entity.name.filename | constant.numeric.line-number | constant.numeric.col-number) , text.build-results markup.location.build-results", "foreground": "var(steel)", "selection_foreground": "var(gold_punchy)"},
    {"scope": "text.find-in-files constant.numeric.line-number", "foreground": "var(grey)"}, // "Context" lines

    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    // Insertions and Deletions
    //   - Stock diffs
    //   - Override Audit diffs
    //   - https://github.com/SublimeText/UnitTesting results panel
    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    {"scope": "markup.inserted", "foreground": "var(green)"},
    {"scope": "markup.deleted",  "foreground": "var(red)"},

    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    // Results / Diagnostics
    // - Build Results panel
    // - LSP Diagnostics Panel
    //   - REF: https://lsp.sublimetext.io/customization/#diagnostics
    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    {"scope": "markup.error",                    "foreground": "var(red)"},
    {"scope": "markup.warning",                  "foreground": "var(gold)"},
    {"scope": "markup.note",                     "foreground": "var(slate_light)"},
    {"scope": "markup.info",                     "foreground": "var(blue)"},
    {"scope": "markup.info.hint",                "foreground": "var(green)"},
    {"scope": "meta.error-header.build-results", "background": "var(black)"},

    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    // Diagnostic
    // - LSP Diagnostics Highlights (in the view, e.g. squiggles and gutter icons)
    //   - REF: `DIAGNOSTIC_SEVERITY` in https://github.com/sublimelsp/LSP/blob/main/plugin/core/views.py
    //   - REF: `_draw_diagnostics` in https://github.com/sublimelsp/LSP/blob/main/plugin/session_view.py
    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    {"scope": "region markup.error.lsp",     "foreground": "var(red_punchy)"}, // var(red) is a bit too faint when used for squiggly underlines.
    {"scope": "region markup.warning.lsp",   "foreground": "var(orange_punchy)"},
    {"scope": "region markup.info.lsp",      "foreground": "var(white)"},
    {"scope": "region markup.info.hint.lsp", "foreground": "var(steel)"},

    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    // Highlights / Underlines
    // - LSP hovered range (see LSP "hover_highlight_style" setting)
    //   - REF: https://lsp.sublimetext.io/customization/#hover-highlights
    // - LSP server-identified link (see LSP "link_highlight_style" setting)
    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    {"scope": "markup.highlight.hover.lsp", "background": "var(grey_light)"},
    {"scope": "markup.underline.link.lsp",  "background": "var(white_punchy)"},

    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    // LSP: "Signature Help" popup (distinct from AutoComplete)
    // NOTE: Normal language highlighting (Syntax Definition based) is not applied in this popup (unlike in the LSP Hover popup).
    // REF: https://lsp.sublimetext.io/customization/#signature-help
    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    {"scope": "entity.name.function.sighelp.lsp",     "foreground": "var(steel)"}, // Function name, parens, commas, etc.
    {"scope": "variable.parameter.sighelp.lsp",       "foreground": "var(white_light)"},
    {"scope": "variable.parameter.sighelp.active.lsp","foreground": "var(white_punchy)", "font_style": "bold underline"},

    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    // LSP: Other visible occurences of the thing at the caret (see LSP "document_highlight_style" setting)
    // REF: https://lsp.sublimetext.io/customization/#document-highlights
    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    {"scope": "markup.highlight.text.lsp",  "foreground": "var(white_light)"},
    {"scope": "markup.highlight.read.lsp",  "foreground": "var(white_light)"},
    {"scope": "markup.highlight.write.lsp", "foreground": "var(white_light)"},

    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    // PackageDev
    // - Syntax Definition authoring
    // - Syntax Test authoring
    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    {"scope": "markup.info.capture.sublime-syntax", "background": "var(white_light)"},
    {"scope": "markup.info.test.sublime-syntax",    "background": "var(white_light)"},

    // REF: https://lsp.sublimetext.io/customization/#semantic-highlighting
    //{
    //  "scope": "meta.semantic-token",
    //  "background": "color(var(slate) alpha(0.1))",
    //  //"background": "color(var(red) alpha(0.1))"
    //},
  ]
}