Oh my gosh this is awesome! Great, thanks! :)

I was also thinking, after my last comment, alternatively, that there might be a more involved, but perhaps ultimately better solution, also for other coalescing extensions.
Also maintain a list of unique extensions mapping to language names.
It would be useful for github/markup, but also for other tools that only have a file name or extension name, and for whatever reason can’t apply heuristics/infer modelines based on file contents.

Also maintain a list of unique extensions mapping to language names.
It would be useful for github/markup, but also for other tools that only have a file name or extension name, and for whatever reason can’t apply heuristics/infer modelines based on file contents.

We've got this already... it's the languages.yml file 😁 This can be parsed by any app that isn't written in Ruby or doesn't want to use Linguist to do as you've suggested. I'm not a fan of adding another file to do this as it would be something else to maintain and would be unnecessary overhead as Linguist doesn't need it.

I looked at duplicates in that files. To see what else you could use the same “hack” for. Here’s the result.

Some explanation:
First and last columns are probs pretty obvious.
Second and third, with and without dot, are more complex.

To illustrate, let’s look at .inc, which has a bunch of different potential matches.
It’s marked as Assembly if with a dot, and as PHP when without:

` ```.inc `:

```.inc
mov	[con_handle],STD_OUTPUT_HANDLE ; assembly?
class PullRequest { static $_TSPEC; } // php?
```

` ```inc `:

```inc
mov	[con_handle],STD_OUTPUT_HANDLE ; assembly?
class PullRequest { static $_TSPEC; } // php?
```

For reference, ` ```asm `:

```asm
mov	[con_handle],STD_OUTPUT_HANDLE ; assembly?
class PullRequest { static $_TSPEC; } // php?
```

For reference, ` ```php `:

```php
mov	[con_handle],STD_OUTPUT_HANDLE ; assembly?
class PullRequest { static $_TSPEC; } // php?
```

```.inc:

mov	[con_handle],STD_OUTPUT_HANDLE ; assembly?
class PullRequest { static $_TSPEC; } // php?

```inc:

mov	[con_handle],STD_OUTPUT_HANDLE ; assembly?
class PullRequest { static $_TSPEC; } // php?

For reference, ```asm:

mov	[con_handle],STD_OUTPUT_HANDLE ; assembly?
class PullRequest { static $_TSPEC; } // php?

For reference, ```php:

mov	[con_handle],STD_OUTPUT_HANDLE ; assembly?
class PullRequest { static $_TSPEC; } // php?

Note that probably no one knows that you can use a dot in a info string like this! But it’s interesting to show the difference.

It’s also important to understand that when an extension is listed but not classified as a name (so say .mdx prior to my recent PR), it is possible to use it without a dot too.
That’s what most folks likely do use: ```mdx to match MDX, even though no name is specified.

Now, what you show in this PR, is that you can add an extension name which would otherwise be classified wrongly, without a dot as a name.
When the third column is n/a (meaning a name is still available), and the second column is wrong, you can add the extension name (without a dot) to one of the alternatives.

To illustrate, .es is currently classified as Erlang instead of JavaScript.
Assuming after some investigation it turns out most folks use ```es to signal JavaScript instead (doubtful), the name alias ES could be added for JavaScript, fixing the code blocks!

Thanks @wooorm. That's way more than you really needed to do 🙇

Lets keep things simple and start with just this md/markdown case and consider the others as and when they come up.

Hah, yeah.
Just trying to match GitHub as closely as I can. Will be quite useful for the markdown grammar for example, as that should show people when embedded languages will or wont highlight. Thought I’d share ;)

Also, TIL, you can put filenames and entire paths in there?! I never knew.

Input:

```example.js
console.log(1)
```

```folder/to/index.tsx
export function huh() {
  return <div />
}
```

Output:

console.log(1)

export function huh() {
  return <div />
}

@wooorm Wanna know another cool trick? In markup formats other than Markdown (Wikitext, reStructuredText, AsciiDoc, etc), you can achieve highlighted code-blocks using specially prepared HTML. Similar hacks exist for footnotes, diagrams, and equations.

Yeah, weird stuff in the depths of GitHub! I don’t know much about how the other languages work, but I did know you can embed things in markdown! I know of ````mermaid, ```geojson, ```topojson, and ```stl. Also knew about the <pre lang="stuff">, but didn’t know about <a href="...mp3> turning into a video, nor that you can use <sup>s and <section>s into footnotes (which makes sense)! Thanks :)

```mermaid
graph TD;
    A-->B;
    A-->C;
    B-->D;
    C-->D;
```

```geojson
{
    "type": "Point",
    "coordinates": [-122.43, 37.77],
    "properties": {"name": "SF", "marker-color": "ff6347"}
}
```

```topojson
{
  "type": "Topology",
  "objects": {
    "example": {
      "type": "GeometryCollection",
      "geometries": [
        {
          "type": "Point",
          "coordinates": [-122.43, 37.77],
          "properties": {"name": "SF", "marker-color": "ff6347"}
        }
      ]
    }
  }
}
```

```stl
solid square
   facet normal -1 0 0
      outer loop
         vertex 0 100 100
         vertex 0 100 0
         vertex 0 0 100
      endloop
   endfacet
   facet normal -1 0 0
      outer loop
         vertex 0 0 100
         vertex 0 100 0
         vertex 0 0 0
      endloop
   endfacet
   facet normal 0 0 1
      outer loop
         vertex 100 100 100
         vertex 0 100 100
         vertex 100 0 100
      endloop
   endfacet
   facet normal 0 0 1
      outer loop
         vertex 100 0 100
         vertex 0 100 100
         vertex 0 0 100
      endloop
   endfacet
   facet normal 1 0 0
      outer loop
         vertex 100 100 0
         vertex 100 100 100
         vertex 100 0 0
      endloop
   endfacet
   facet normal 1 0 0
      outer loop
         vertex 100 0 0
         vertex 100 100 100
         vertex 100 0 100
      endloop
   endfacet
   facet normal 0 0 -1
      outer loop
         vertex 0 100 0
         vertex 100 100 0
         vertex 0 0 0
      endloop
   endfacet
   facet normal 0 0 -1
      outer loop
         vertex 0 0 0
         vertex 100 100 0
         vertex 100 0 0
      endloop
   endfacet
   facet normal 0 1 0
      outer loop
         vertex 100 100 100
         vertex 100 100 0
         vertex 0 100 100
      endloop
   endfacet
   facet normal 0 1 0
      outer loop
         vertex 0 100 100
         vertex 100 100 0
         vertex 0 100 0
      endloop
   endfacet
   facet normal 0 -1 0
      outer loop
         vertex 100 0 0
         vertex 100 0 100
         vertex 0 0 0
      endloop
   endfacet
   facet normal 0 -1 0
      outer loop
         vertex 0 0 0
         vertex 100 0 100
         vertex 0 0 100
      endloop
   endfacet
endsolid
```

I know of ```mermaid, ```geojson, ```topojson, and ```stl

Those aren't specific to Markdown, GitHub-flavoured or otherwise. Watch:

$ cmark-gfm --github-pre-lang <<'MARKDOWN'
```mermaid
graph TD;
	A-->B;
	A-->C;
	B-->D;
	C-->D;
```
MARKDOWN

<pre lang="mermaid"><code>graph TD;
	A--&gt;B;
	A--&gt;C;
	B--&gt;D;
	C--&gt;D;
</code></pre>

That HTML output could've been prepared by any number of lightweight markup languages that GitHub supports, as the markup rendering pipeline essentially goes like:

flowchart LR
	Markup --> html1
	html1[Raw HTML] --> html2
	html2[Sanitised HTML] --> html3
	html3[Code-blocks processed] --> html4
	html4[Other stuff addded:<br/>tasklists, emoji, etc]

Good to know, just, my focus is markdown, and GH is a big player there :)