
- [Regex cheatsheet - MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions/Cheatsheet)
- [Regex cheatsheet - docs.linuxfoundation.org](https://docs.linuxfoundation.org/v2/security-service/manage-false-positives/regular-expressions-cheat-sheet)

## Character classes

| Character | Meaning                      |
| --------- | ---------------------------- |
| `.`       | Any character except newline |
| `\d`      | One digit                    |
| `\D`      | One non-digit                |
| `\s`      | One whitespace               |
| `\S`      | One non-whitespace           |
| `\w`      | One word character           |
| `\W`      | One non-word character       |
| `\t`      | Horizontal tab               |
| `\v`      | Vertical tab                 |
| `\r`      | Carriage return              |
| `\n`      | Newline/Linefeed             |
| `\f`      | Form-feed                    |
| `[\b]`    | Backspace character          |
| `\0`      | NUL character                |
| `\`       | Escape a special character   |

## Assertions

| Character | Meaning                                                              |
| --------- | -------------------------------------------------------------------- |
| `^`       | Start of string                                                      |
| `$`       | End of string                                                        |
| `\b`      | Word boundary                                                        |
| `\B`      | Non-word boundary                                                    |
| `x(?=y)`  | Positive lookahead (Matches "x" only if "x" is followed by "y")      |
| `x(?!y)`  | Negative lookahead (Matches "x" only if "x" is not followed by "y")  |
| `(?<=y)x` | Positive lookbehind (Matches "x" only if "x" is preceded by "y")     |
| `(?<!y)x` | Negative lookbehind (Matches "x" only if "x" is not preceded by "y") |

## Groups and ranges

| Character             | Meaning                                                                                     |
| --------------------- | ------------------------------------------------------------------------------------------- |
| <code>x&#124;y</code> | Either "x" or "y"                                                                           |
| `[xyz]` `[a-c]`       | Any one of the enclosed characters                                                          |
| `[^xyz]` `[^a-c]`     | Anything that is not enclosed in the brackets                                               |
| `(x)`                 | Capturing group (matches "x" and remembers the match)                                       |
| `(?<Name>x)`          | Named capturing group (matches "x" and stores it as "Name")                                 |
| `(?:x)`               | Non-capturing group (matches "x" but does not remember the match)                           |
| `\N`                  | Match the Nth captured group                                                                |
| `\k<Name>`            | Back reference to the last substring matching the named capturing group specified by "Name" |

## Quantifiers

| Character | Meaning                                                           |
| --------- | ----------------------------------------------------------------- |
| `*`       | 0 or more                                                         |
| `+`       | 1 or more                                                         |
| `?`       | 0 or 1                                                            |
| `x{n}`    | Exactly n occurences of x                                         |
| `x{n, m}` | Between n and m occurences of x                                   |
| `x{n,}`   | n or more occurences of x                                         |
| `?`       | Make the quantifier non-greedy (stop as soon as it finds a match) |

## POSIX classes

| Character    | Meaning                          |
| ------------ | -------------------------------- |
| `[:alnum:]`  | Letters and digits               |
| `[:alpha:]`  | Letters                          |
| `[:ascii:]`  | Ascii codes 0 - 127              |
| `[:blank:]`  | Space or tab only                |
| `[:cntrl:]`  | Control characters               |
| `[:digit:]`  | Decimal digits                   |
| `[:graph:]`  | Visible characters, except space |
| `[:upper:]`  | Uppercase letters                |
| `[:lower:]`  | Lowercase letters                |
| `[:word:]`   | Word characters                  |
| `[:print:]`  | Visible characters               |
| `[:punct:]`  | Visible punctuation characters   |
| `[:space:]`  | Whitespace                       |
| `[:xdigit:]` | Hexadecimal digits               |


Regular expressions

[Top]

Character classes

Assertions

Groups and ranges

Quantifiers

POSIX classes


Source code for bookmarklets that I've written.

## Copy Markdown link for current page

Cleans up the title a bit. If there is some selected text on the page, it will be copied after a ` > `.

```javascript
javascript: (() => {
  let link = `[${document.title}](${location.href})`.replace(/ - YouTube| - Wikipedia|GitHub - | \| Goodreads/, '');
  let sel = getSelection().toString();
  if (sel) link += ` > ${sel}`;
  navigator.clipboard.writeText(link);
})();
```

## Copy HTML link for current page

```javascript
javascript: (() => {
  let link = `<a href="${location.href}">${document.title}</a>`.replace(/ - YouTube| - Wikipedia|GitHub - | \| Goodreads/, '');
  navigator.clipboard.writeText(link);
})();
```

## Google Translate

```javascript
javascript: (() => {
  window.open(`https://translate.google.com/translate?langpair==auto|en&hl=en&u=${location.href}`);
})();
```

## whois lookup for current domain

```javascript
javascript: (() => {
  window.open(`https://who.is/whois/${location.hostname.split('.').splice(-2).join('.')}`);
})();
```

## Search archive.org for current page

```javascript
javascript: (() => {
  window.open(`https://web.archive.org/web/*/${location}`);
})();
```

## Save current page to archive.org

```javascript
javascript: (() => {
  window.open(`https://web.archive.org/save/${location.href}`);
})();
```

## Search archive.today for current page 

```javascript
javascript: (() => {
  window.open(`https://archive.today/${location}`);
})();
```

## Search HN for current domain

```javascript
javascript: (() => {
  window.open(`https://hn.algolia.com/?query=${location.hostname}`);
})();
```

## Search HN for current webpage

```javascript
javascript: (() => {
  window.open(`https://hn.algolia.com/?query=${location.href.replace(/https?:\/\//, "")}`);
})();
```

## Browse HN frontpage on a random date

```javascript
javascript:(() => {
  const first = new Date('2007-02-19').getTime();
  const last = new Date().getTime();
  const rand = new Date(first + Math.random() * (last - first)).toISOString().split('T')[0];
  window.open(`https://news.ycombinator.com/front?day=${rand}`);
})();
```

## View new comments on HN thread

```javascript
javascript: (() => {
  const id = location.href.match(/\d+$/g)[0];
  window.open(`https://hn.algolia.com/?dateRange=all&page=0&prefix=false&query=story:${id}&sort=byDate&type=comment`);
})();
```

## Edit any webpage

```javascript
javascript: (() => {
  document.body.contentEditable = 'true';
  document.designMode='on';
})();
```

## Get QR code for current link

```javascript
javascript: (() => {
  window.open(`https://duckduckgo.com/?q=qr ${location}`)
})();
```

## Get QR code for text selected on the page

```javascript
javascript: (() => {
  window.open(`https://duckduckgo.com/?q=qr ${getSelection()}`)
})();
```

## Submit to HN

```javascript
javascript:(() => {
  window.open(`https://news.ycombinator.com/submitlink?u=${location}&t=${document.title}`);
})();
```

## Submit to Lobste.rs

```javascript
javascript:(() => {
  window.open(`https://lobste.rs/stories/new?url=${location}&title=${document.title}`);
})();
```

## Normalize font

For those stupid websites with tiny unreadable fonts. Changes font family to system-ui, font size and weight of paragraphs to 18px and 400 respectively.

```javascript
javascript: (() => {
  let s = document.createElement('style');
  s.innerHTML = 'body,div,p,h1,h2,h3,h4,h5,h6 {font-family: system-ui !important;} p {font-size: 18px; font-weight: 400;}';
  document.body.appendChild(s);
})();
```

## Go to source repo for a GitHub/GitLab Pages site

Do you ever come across some [site](https://unawaz.github.io/stochastic-hill-climbing/tasks/) hosted on GitHub Pages with a URL like `https://user.github.io/repo` and you look around but the link to the source repository is nowhere to be found?

This bookmarklet opens the source repo for such sites.

```javascript
javascript: (() => {
  const [user, site, ...rest] = location.host.split('.');
  const repo = location.pathname.split('/')[1] || `${user}.${site}.io`;
  window.open(`https://${site}.com/${user}/${repo}`);
})();
```

## IMDb list to Markdown list

For some time now, I have been maintaining my reading list using a JSON file, having shifted away from Goodreads. Likewise, I no longer use an IMDb account to keep track of my watchlist. I have exported all the data to my browser bookmarks.

Occasionally, I come across an [IMDb list](https://www.imdb.com/list/ls053826112/ 'Most Watched Movies Of All Time
') that I want to include in my library, but there is no convenient means to export it directly to my bookmarks. An obvious approach is to just drag each item into the toolbar, but you don't get any metadata like the release year or rating with that. Additionally, this is not practical for longer lists. On top of that, IMDb links are riddled with tracking parameters that require manual cleanup.

This bookmarklet parses the DOM to get the movie list in Markdown, and copies the list to the clipboard. It then shows a prompt asking whether or not to open [pandoc.org/try](https://pandoc.org/try). If clicked "OK", it opens up the pandoc online playground in a new tab where I paste the markdown, and get converted HTML which can be imported into my browser.

The playground also supports a permalink with query parameters to pre-populate the input and options, so there's no need to copy anything but since there is a limit to the URL size, it doesn't work for large lists.

```javascript showLineNumbers
javascript: (() => {
  let movies = '';
  let count = 0;
  document.querySelectorAll('.ipc-metadata-list-summary-item').forEach(item => {
    const title = item.querySelector('h3').innerText.replace(/^\d+\. /, '');
    const link = item
      .querySelector('a')
      .getAttribute('href')
      .replace(/\?ref.+/, '');
    let year = item.querySelector('.sc-ab348ad5-8');
    year = year ? ` (${year.innerText})` : '';
    let rating = item.querySelector('.ipc-rating-star--rating');
    rating = rating ? ` (Rating: ${rating.innerText})` : '';
    movies += `- [${title}${year}${rating}](https://www.imdb.com${link})\n`;
    count += 1;
  });

  navigator.clipboard
    .writeText(movies)
    .then(() => {
      if (confirm(`Copied markdown with ${count} movies. Open pandoc?`)) {
        window.open(
          `https://pandoc.org/try/?params={"from":"markdown","to":"html5","wrap":"none"}`
        );
      }
    })
    .catch(err => alert('Error copying text'));
})();
```

## YouTube playlist to Markdown list

Same as above but for YouTube playlists.

```javascript showLineNumbers
javascript: (() => {
  let videos = "";
  let count = 0;
  document
    .querySelectorAll("#video-title.ytd-playlist-video-renderer")
    .forEach((v) => {
      let title = v.getAttribute("title");
      let link = v.getAttribute("href").replace(/\&list=.+$/, "");
      videos += `- [${title}](https://www.youtube.com${link})\n`;
      count += 1;
    });

  navigator.clipboard
    .writeText(videos)
    .then(() => {
      if (confirm(`Copied markdown with ${count} videos. Open pandoc?`)) {
        window.open(
          `https://pandoc.org/try/?params={"from":"markdown","to":"html5","wrap":"none"}`,
        );
      }
    })
    .catch((err) => alert("Error copying text"));
})();
```

## Dictionary lookups

Look up the selected word/phrase in various online dictionaries. When activated, it shows a prompt asking to select a dictionary. Leave empty for default (Merriam-Webster). Append 't' for thesaurus versions.

Examples:
- `o`: OALD
- `ct`: Cambridge Thesaurus
- `ht`: Chambers Thesaurus

```javascript showLineNumbers
javascript: (() => {
  let word = getSelection().toString().toLowerCase();
  let d = {
    m: "https://www.merriam-webster.com/dictionary/",
    mt: "https://www.merriam-webster.com/thesaurus/",
    o: "https://www.oxfordlearnersdictionaries.com/definition/english/",
    ot: "https://www.oxfordlearnersdictionaries.com/definition/english/",
    c: "https://dictionary.cambridge.org/dictionary/english/",
    ct: "https://dictionary.cambridge.org/thesaurus/",
    h: "https://chambers.co.uk/search/?title=21st&query=",
    ht: "https://chambers.co.uk/search/?title=thes&query=",
    w: "https://en.wiktionary.org/wiki/",
    wt: "https://en.wiktionary.org/wiki/Thesaurus:",
  };

  let c = window
    .prompt(
      "Choose a dictionary. Append 't' for thesaurus.\n\n" +
        "m: Merriam-Webster\n" +
        "o: Oxford Advanced Learner's Dictionary\n" +
        "c: Cambridge Dictionary\n" +
        "h: Chambers Dictionary\n" +
        "w: Wiktionary",
    )
    .toLowerCase() || "m";
  let t = c.endsWith("t") ? "t" : "";
  let url = c === "t" ? d.mt : d[c[0] + t] || d["m" + t];
  window.open(url + word);
})();
```

## Instantly open an IMDb list for selected title

This uses Google's "I'm Feeling Lucky" feature. Can be modified for other sites by changing the `site` variable.

An example use case: Let's say I'm on [Die Hard Wikipedia page](https://en.wikipedia.org/wiki/Die_Hard_(film_series)) and I want to see all films in the franchise and their ratings on IMDb, then I can simply select the title of the page and click the bookmarklet.

```javascript
javascript:(() => {
  let t = getSelection().toString();
  let site = 'site:imdb.com/list' + ' ';
  window.open(`https://www.google.com/search?q=${site}${t}&btnI=I`);
})();
```

## Links

- [zserge/awfice](https://zserge.com/posts/awfice/) - The world smallest office suite.
- [t-mart/kill-sticky](https://github.com/t-mart/kill-sticky) - Bookmarklet to remove sticky elements and restore scrolling to web pages.
- [Jesse's Bookmarklets Site](https://www.squarefree.com/bookmarklets/)
- [Bookmarklets.net](http://www.bookmarklets.com/)
- [Subsimple Bookmarklets](http://subsimple.com/bookmarklets/collection.php)
- [Browser bookmarklets - Thomas Leplus](https://thomasleplus.github.io/bookmarklets/)
- [Some Bookmarklets I use - Philipp Uhl](https://ph-uhl.com/0010-Bookmarklets/)


Bookmarklets


## Common list operations

```python
# Initialize an empty list
>>> s = [] # or
>>> s = list()

# Create a list
>>> s = ["Chess", "Go"]

# Get length of list
>>> len(s)
2

# Add an item to end of list
>>> s.append('Hex')
>>> s
["Chess", "Go", "Hex"]

# Remove an item from end of list
>>> s = ["Chess", "Go", "Monopoly", "Hex"]
>>> s.pop()
"Hex" # Returns the removed item
>>> s
["Chess", "Go", "Monopoly"]
>>> s.pop(1) # Remove item at index 1
"Go"
>>> s
["Chess", "Monopoly"]

# Add an item at an index
>>> s.insert(1, "KenKen")
>>> s
["Chess", "KenKen", "Go"]

# Remove the first item from the list whose value is equal to x
>>> s.remove("Chess")
["KenKen", "Go"]

# Get index of first occurence of item in list
>>> s = ["Monkey", "Carrot", "Red", "Carrot"]
>>> s.index("Carrot")
1

# Get total occurrences of item in list
>>> s = ["Monkey", "Carrot", "Red", "Carrot"]
>>> s.count("Carrot")
2

# Check if an element exists in list
>>> s = ["Chess", "KenKen", "Go"]
>>> "Go" in s
True
>>> "Monopoly" in s
False
>>> "Go" not in s
False

# Concatenate multiple lists
>>> s = ["Chess", "Go"]
>>> s + ["Hex"]
["Chess", "Go", "Hex"]

# Get the smallest/largest item of list
>>> s = [10, 6, 89, 37]
>>> min(s)
6
>>> max(s)
89

# Slicing a list with list[start:end] (end is exclusive)
>>> s = ["Monkey", "Carrot", "Red", "Carrot"]
>>> s[1:3]
['Carrot', 'Red']

# Slicing a list with step with list[start:end:step]
>>> s = [1, 3, 5, 6, 7, 8]
>>> s[1:5:2]
[3, 6]

# Create a shallow copy of list
>>> s_copy = s.copy() # or
>>> s_copy = s[:]

# Create a deep copy of list
>>> import copy
>>> s_deepcopy = copy.deepcopy(s)

# Remove all items from list
>>> s.clear() # or
>>> del s[:]

# Reverse a list
>>> s[::-1] # Returns a new list
>>> s.reverse() # Reverses list in place

# Extend a list by appending all items from another iterable
>>> s = ["Chess", "Go"]
>>> s.extend(["Hex", "Shogi"])
>>> s
["Chess", "Go", "Hex", "Shogi"]

# Sort a list
>>> s = ["Chess", "Go", "Hex", "Shogi"]
>>> s.sort() # Sort list in place
# sorted(s) returns a new sorted list
>>> s
['Chess', 'Go', 'Hex', 'Shogi']
```

## Easter eggs

```plaintext
>>> import this
The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!
```

```plaintext
>>> import antigravity
```

```plaintext
>>> import __hello__
Hello world!
```

```plaintext
>>> from __future__ import braces
  File "<stdin>", line 1
SyntaxError: not a chance
```

- [Secret code in Ex Machina (2014)](https://www.reddit.com/r/movies/comments/365f9b/secret_code_in_ex_machina/)

## Snippets

```python
# Multiple assignment
>>> x, y = 2, 3 # or
>>> x, y = (2, 3) # or
>>> x, y, z = 'abd'

# Get Python version
>>> import sys
>>> sys.version
'3.8.10 (default ...)'

# Get Unix timestamp
>>> import time
>>> time.time()
1636620498.0040886

# Check the type of object
>>> n = 34
>>> type(n)
<class 'int'>
>>> st = "Hello, world!"
>>> type(st)
<class 'str'>

# Count the number of unique characters in a string
len(set("stackoverflow"))

# Check if an element in one list exists in another
any(e in list2 for e in list1)
```


Character	Meaning
`.`	Any character except newline
`\d`	One digit
`\D`	One non-digit
`\s`	One whitespace
`\S`	One non-whitespace
`\w`	One word character
`\W`	One non-word character
`\t`	Horizontal tab
`\v`	Vertical tab
`\r`	Carriage return
`\n`	Newline/Linefeed
`\f`	Form-feed
`[\b]`	Backspace character
`\0`	NUL character
`\`	Escape a special character

Character	Meaning
`^`	Start of string
`$`	End of string
`\b`	Word boundary
`\B`	Non-word boundary
`x(?=y)`	Positive lookahead (Matches "x" only if "x" is followed by "y")
`x(?!y)`	Negative lookahead (Matches "x" only if "x" is not followed by "y")
`(?<=y)x`	Positive lookbehind (Matches "x" only if "x" is preceded by "y")
`(?<!y)x`	Negative lookbehind (Matches "x" only if "x" is not preceded by "y")

Character	Meaning
`x\|y`	Either "x" or "y"
`[xyz]` `[a-c]`	Any one of the enclosed characters
`[^xyz]` `[^a-c]`	Anything that is not enclosed in the brackets
`(x)`	Capturing group (matches "x" and remembers the match)
`(?<Name>x)`	Named capturing group (matches "x" and stores it as "Name")
`(?:x)`	Non-capturing group (matches "x" but does not remember the match)
`\N`	Match the Nth captured group
`\k<Name>`	Back reference to the last substring matching the named capturing group specified by "Name"

Character	Meaning
`*`	0 or more
`+`	1 or more
`?`	0 or 1
`x{n}`	Exactly n occurences of x
`x{n, m}`	Between n and m occurences of x
`x{n,}`	n or more occurences of x
`?`	Make the quantifier non-greedy (stop as soon as it finds a match)

Character	Meaning
`[:alnum:]`	Letters and digits
`[:alpha:]`	Letters
`[:ascii:]`	Ascii codes 0 - 127
`[:blank:]`	Space or tab only
`[:cntrl:]`	Control characters
`[:digit:]`	Decimal digits
`[:graph:]`	Visible characters, except space
`[:upper:]`	Uppercase letters
`[:lower:]`	Lowercase letters
`[:word:]`	Word characters
`[:print:]`	Visible characters
`[:punct:]`	Visible punctuation characters
`[:space:]`	Whitespace
`[:xdigit:]`	Hexadecimal digits