Quick, what does this match?
\n/^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)(?:-((?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\\+([0-9a-zA-Z-]+(?:\\.[0-9a-zA-Z-]+)*))?$/;\n// Take\n// your\n// time...\n//\n// ...still decoding?\n//\n// OK, keep reading :)That's the official regexp from semver.org. It validates version numbers like:
\n// matches\n"1.2.3"\n"0.10.0"\n"2.0.0-rc.1"\n"1.0.0-alpha.1+build.5"\n"1.0.0+20260930"\n// doesn't match\n"01.2.3" // leading zero\n"1.2" // missing patch\n"v1.2.3" // no "v" prefix allowed\n"1.0.0-01" // numeric pre-release with a leading zero\n"1.2.3-" // empty pre-releaseDon't get me wrong, I love regexps, but in practice you probably spend a bunch of time writing one, testing it against some cases, and moving on, proud of your achievement!
\nSome time passes and lucky future you (or unlucky someone else) has to change it. Dramatic pause here.
\nI bet you've been there. Now your options are probably: decode it again from the start, rewrite the whole thing, or, in the age of AI, ask (and hopefully not blindly accept) an LLM for a new recipe.
\nEmacs has had a nice answer for more readable regexps for a long time:\nthe rx macro. I started using it all the time in Emacs Lisp, as\nreviewers always suggested it to me. Later, I started missing this DSL\nin JavaScript and TypeScript, so I wrote a small version of it for my\nprojects.
So, what about reading that SemVer regexp like semver in the code\nbelow?
const num = or("0", seq(anyOf("1-9"), zeroOrMore(digit)));\nconst idChar = anyOf(alnum, "-");\nconst preId = or(num, seq(zeroOrMore(digit), anyOf(alpha, "-"), zeroOrMore(idChar)));\nconst dotted = (x: Item) => seq(x, zeroOrMore(".", x));\nconst semver = RX(\n start,\n named("major", num), ".",\n named("minor", num), ".",\n named("patch", num),\n optional("-", named("pre", dotted(preId))),\n optional("+", named("build", dotted(oneOrMore(idChar)))),\n end,\n);The same strings match, and you get named groups as a bonus. By the end of this post you'll know every piece of it.
\nTL;DR: jump straight to the cheat sheet,\nthe side-by-side examples, the full\nsource, or grab the\ngist\nto sneak a peek at the result.
\nNOTE: the RX here has nothing to do with\nRxJS, which is an amazing library for reactive\nprogramming with observables.
With rx you describe a regexp as a tree of named forms, and Emacs\nturns it into the regexp string for you:
(rx bos (+ digit) eos)\n;; => "\\\\`[[:digit:]]+\\\\'"\n(rx bol "colo" (? "u") "r" eol)\n;; => "^colou?r$"\n(rx bos "(" (= 3 digit) ")" space (= 3 digit) "-" (= 4 digit) eos)\n;; => "\\\\`([[:digit:]]\\\\{3\\\\})[[:space:]][[:digit:]]\\\\{3\\\\}-[[:digit:]]\\\\{4\\\\}\\\\'"A few things to notice:
\nStrings are literals."(" means a parenthesis. You don't
need to escape anything by hand.
Sequence is implicit. Every form takes a list of things and
matches them one after the other. You don't need to wrap them in aseq , even thoughseq exists.
(+ digit) becomes[[:digit:]]+ , not\\(?:[[:digit:]]\\)+ .The proposed JavaScript/TypeScript version in this post reads like this:
\nconst phone = RX(\n start, "(", repeat(3, digit), ")", space,\n repeat(3, digit), "-", repeat(4, digit), end,\n);\n// => /^\\(\\d{3}\\)\\s\\d{3}-\\d{4}$/If you want strings to be literals, you can't represent a regexp piece\nas a plain string, otherwise you can't tell "(" (a literal\nparenthesis) apart from "(?:...)" (a group you built). So every\npiece is a small object:
type Kind = "atom" | "seq" | "alt";\ninterface RxNode {\n readonly src: string;\n readonly kind: Kind;\n readonly set?: string; // char sets only, see below\n readonly neg?: boolean;\n}\ntype Item = string | RxNode;src is the regexp text. kind records how that text behaves when\nyou glue it to other things:
atom : a single unit, likea ,\\d ,[a-z] or(...) . You can
put a quantifier right after it.
seq : safe to concatenate, but a quantifier needs(?:...) around
it.abc is aseq , and so isa+ , sincea+? would silently\nturn into a lazy quantifier.
alt : has a| at the top level, so it needs(?:...) almost
everywhere.
Plain strings go through literal, which escapes them:
const esc = (s: string) => s.replace(/[.*+?^${}()|[\\]\\\\]/g, "\\\\$&");\nconst literal = (s: string): RxNode => ({\n src: esc(s),\n kind: s.length === 1 ? "atom" : "seq",\n});\nconst toNode = (x: Item): RxNode => (typeof x === "string" ? literal(x) : x);With that in place, seq joins nodes and only brackets alternations:
const seq = (...xs: Item[]): RxNode => {\n const nodes = xs.map(toNode).filter((n) => n.src !== "");\n if (nodes.length === 0) return { src: "", kind: "seq" };\n if (nodes.length === 1) return nodes[0];\n let src = "";\n for (const n of nodes) {\n const part = n.kind === "alt" ? `(?:${n.src})` : n.src;\n // `\\1` followed by a literal `0` would read as `\\10`\n if (/\\\\\\d+$/.test(src) && /^\\d/.test(part)) src += "(?:)";\n src += part;\n }\n return { src, kind: "seq" };\n};(That backreference check is one of those bugs you only find by\nwriting tests, or when it happens to you in prod. backref(1)\nfollowed by the literal "0" gives you backreference number ten.)
Every quantifier is a seq of its arguments plus a suffix, bracketed\nonly when the body isn't an atom:
const quantifiable = (n: RxNode) =>\n n.kind === "atom" ? n.src : `(?:${n.src})`;\nconst quantifier =\n (suffix: string) =>\n (...xs: Item[]): RxNode => ({\n src: quantifiable(seq(...xs)) + suffix,\n kind: "seq",\n });\nconst zeroOrMore = quantifier("*");\nconst oneOrMore = quantifier("+");\nconst optional = quantifier("?");Because each quantifier calls seq on its arguments, you get the\nimplicit sequence for free: optional("-", group(x)) becomes\n(?:-(x))?.
And finally, the two entry points. As in Emacs, rx returns a\nstring. RX returns a RegExp you can use right away:
const rx = (...xs: Item[]): string => seq(...xs).src;\nfunction RX(...xs: Item[]): RegExp {\n return new RegExp(rx(...xs));\n}\nRX.flags = (flags: string, ...xs: Item[]): RegExp =>\n new RegExp(rx(...xs), flags);RX.flags exists because Emacs controls case folding through the\ncase-fold-search variable, and JavaScript puts it on the regexp\nitself.
That's the whole engine! Now, let's build our vocabulary.
\nIn Emacs you write (any "a-z" "_"). Inside those strings, a-z is a\nrange, and a - at either end is a plain dash. I kept the same rule:
const hexDigit = anyOf("0-9a-fA-F");\nRX(start, "#", repeat(6, hexDigit), end);\n// => /^#[0-9a-fA-F]{6}$/\nRX(start, optional(anyOf("+-")), oneOrMore(digit), end);\n// => /^[+\\-]?\\d+$/The dash comes out escaped because sets can merge. If you combine\nanyOf("+-") with anyOf("0-9"), an unescaped - would end up in\nthe middle and create a range from + to 0. Escaping it costs one\nbackslash.
And merging is the reason why RxNode has a set field. It is there\nto hold the text that goes between [ and ], so anyOf can take\nother sets as arguments:
const lower = anyOf("a-z");\nconst upper = anyOf("A-Z");\nconst alpha = anyOf(lower, upper); // [a-zA-Z]\nconst alnum = anyOf(alpha, "0-9"); // [a-zA-Z0-9]not negates a set, and it knows the shorthand classes:
not(digit); // \\D\nnot(anyOf(space, "@")); // [^\\s@]\nnotChar(","); // [^,] (rx's not-char)The simple email check, which most of us have written as\n/^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$/ at some point, becomes:
const part = oneOrMore(not(anyOf(space, "@")));\nRX(start, part, "@", part, ".", part, end);\n// => /^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$/The rest of the Emacs character classes are there too: digit,\nhexDigit, space, blank, wordChar, notWordChar, alpha,\nalnum, lower, upper, punct, control, graphic, printing,\nascii and nonascii. One difference: in Emacs they understand\nUnicode, and mine are ASCII only. alpha won't match é.
Two more come from rx's symbol list, and people (me, many times) mix them up:
\nconst notNewline: RxNode = { src: ".", kind: "atom" }; // rx: nonl\nconst anything = set("\\\\s\\\\S"); // rx: anything / anycharIn rx, anything really means anything, newlines included. Here is\nwhere the difference shows up:
const code = "a = 1; /* first\\n second */ b = 2;";\nRX("/*", zeroOrMoreLazy(notNewline), "*/").exec(code);\n// => null\nRX("/*", zeroOrMoreLazy(anything), "*/").exec(code)?.[0];\n// => "/* first\\n second */"or works as you'd expect, and gets bracketed when it lands inside a\nsequence:
RX(start, or("cat", "dog", "bird"), end);\n// => /^(?:bird|cat|dog)$/Did you notice the order changed? I copied that behavior from\nEmacs. When every branch of an or is a plain string, rx hands them\nto regexp-opt, which builds a pattern that prefers the longest\nmatch:
(rx (or "in" "int" "interface"))\n;; => "\\\\(?:in\\\\(?:t\\\\(?:erface\\\\)?\\\\)?\\\\)"JavaScript alternation takes the first branch that matches, going left to right. So the naive regexp for a list of keywords has a 'bug':
\n/in|int|interface/.exec("interface Foo")?.[0];\n// => "in"\nRX(or("in", "int", "interface")).exec("interface Foo")?.[0];\n// => "interface"I don't build a trie like regexp-opt does. Sorting the strings by\nlength, longest first, is enough to get the same behavior:
const or = (...xs: Item[]): RxNode => {\n if (xs.length === 0) return unmatchable;\n if (xs.length === 1) return toNode(xs[0]);\n const branches = xs.every((x) => typeof x === "string")\n ? [...(xs as string[])].sort((a, b) => b.length - a.length)\n : xs;\n return { src: branches.map((x) => toNode(x).src).join("|"), kind: "alt" };\n};As in Emacs, or() with no branches returns unmatchable, which is\n(?!) here. It's handy when you build the branch list at runtime and\nit might come out empty.
Emacs has (= n ...), (>= n ...) and (** n m ...). Here they are\nrepeat, atLeast and between:
RX(start, between(2, 4, digit), end); // /^\\d{2,4}$/\nRX(atLeast(3, digit)); // /\\d{3,}/The lazy versions *?, +? and ?? are zeroOrMoreLazy,\noneOrMoreLazy and optionalLazy. The classic HTML tag example:
const html = "<b>bold</b> and <i>italic</i>";\nRX("<", oneOrMore(notNewline), ">").exec(html)?.[0];\n// => "<b>bold</b> and <i>italic</i>"\nRX("<", oneOrMoreLazy(notNewline), ">").exec(html)?.[0];\n// => "<b>"group is a capturing group, and backref points back to it:
RX(start, group(oneOrMore(wordChar)), space, backref(1), end);\n// => /^(\\w+)\\s\\1$/ matches "hello hello", not "hello world"Emacs also has (group-n N ...) to pick the group number. JavaScript\ncan't do that, but it has named groups, which serve the same purpose\nand read better:
const date = RX(\n named("y", repeat(4, digit)), "-",\n named("m", repeat(2, digit)), "-",\n named("d", repeat(2, digit)),\n);\ndate.exec("2026-09-30")?.groups;\n// => { y: '2026', m: '09', d: '30' }backref accepts a name as well:
RX(\n "<", named("tag", oneOrMore(wordChar)), ">",\n zeroOrMoreLazy(notNewline),\n "</", backref("tag"), ">",\n);\n// => /<(?<tag>\\w+)>.*?<\\/\\k<tag>>/rx distinguishes the start of the string (bos) from the start of a\nline (bol). In JavaScript both are ^, and the m flag decides\nwhich one you get. I kept both names so the intent shows in the code:
const text = "TODO: write post\\nDONE: fix rx\\nTODO: publish";\nconst todo = RX.flags(\n "gm",\n lineStart, "TODO: ", named("task", oneOrMore(notNewline)), lineEnd,\n);\n[...text.matchAll(todo)].map((m) => m.groups?.task);\n// => [ 'write post', 'publish' ]Why not add start and end automatically? Because you only want\nthem when validating a whole string. When searching inside a text, as\nin split, replace or matchAll, a hidden ^ and $ would break\neverything. Emacs agrees: bos and eos are explicit in rx too.
wordBoundary and notWordBoundary map straight to \\b and \\B.\nEmacs also has bow and eow (\\< and \\>), start and end of a\nword. JavaScript lacks those, so I combined \\b with a lookaround:
const wordStart = zeroWidth("\\\\b(?=\\\\w)");\nconst wordEnd = zeroWidth("\\\\b(?<=\\\\w)");Plain strings are already literals, but rx has an explicit literal\nform for strings computed at runtime, and I kept it. It documents that\nthe value came from somewhere else:
const userInput = "1+1=2? (maybe)";\nnew RegExp(userInput).test(userInput); // false, oops\nRX(literal(userInput)).test(userInput); // trueThe opposite direction is rx's (regexp ...) form, the escape hatch.\nHere it's raw, and it receives either a string or an existing\nRegExp. It lets you adopt the DSL in a codebase full of old regexps\nwithout rewriting all of them, like:
const legacyZip = /\\d{5}(?:-\\d{4})?/;\nRX(start, repeat(2, upper), " ", raw(legacyZip), end);\n// => /^[A-Z]{2} (?:\\d{5}(?:-\\d{4})?)$/raw can't see inside the text it gets, so it adds brackets whenever\nit's combined with something else. It's an extra (?:), and the\nregexp still works.
Back to the regexp from the intro. In Emacs you would give names to\nthe pieces with rx-define or rx-let. In TypeScript those are just\nconsts:
const num = or("0", seq(anyOf("1-9"), zeroOrMore(digit)));\nconst idChar = anyOf(alnum, "-");\nconst preId = or(num, seq(zeroOrMore(digit), anyOf(alpha, "-"), zeroOrMore(idChar)));\nconst dotted = (x: Item) => seq(x, zeroOrMore(".", x));\nconst semver = RX(\n start,\n named("major", num), ".",\n named("minor", num), ".",\n named("patch", num),\n optional("-", named("pre", dotted(preId))),\n optional("+", named("build", dotted(oneOrMore(idChar)))),\n end,\n);Now you can read the spec in the code. A numeric identifier is 0, or\na non-zero digit followed by any number of digits. A pre-release is a\ndotted list of identifiers, and so is build metadata. dotted is a\nplain function returning a node, which is as far as abstraction needs\nto go here.
It matches the same strings as the official regexp, and the named groups give you a result like:
\nsemver.exec("1.0.0-alpha.1+build.5")?.groups;\n// => {\n// major: '1',\n// minor: '0',\n// patch: '0',\n// pre: 'alpha.1',\n// build: 'build.5'\n// }Next time the spec changes, you can understand what the current regex does at a glance, instead of fighting an army of punctuation.
\nI tried to map every rx form, and a few have no JavaScript equivalent:
point : JavaScript regexps don't know about a cursor.symbol-start ,symbol-end ,syntax ,category : these depend on
Emacs syntax tables.
intersection : possible with thev flag, but I haven't needed it.minimal-match /maximal-match : these flip the greediness of
everything inside them. Doable, but it would need a separate pass,\nand the*Lazy functions cover my use cases.
eval : TypeScript already evaluates expressions everywhere, so you
get it for free.
And one addition Emacs doesn't need: RX.flags.
| Emacs rx | TypeScript | JS regexp (roughly) |
|---|---|---|
seq ,: ,and | seq(...) , implicit in every form | ab |
or ,| | or(...) | a|b |
any ,in ,char | anyOf("a-z", "_", digit) | [a-z_\\d] |
not-char | notChar(...) | [^...] |
not | not(charset) | \\D ,[^...] |
* ,+ ,? | zeroOrMore ,oneOrMore ,optional | x* ,x+ ,x? |
*? ,+? ,?? | zeroOrMoreLazy ,oneOrMoreLazy ,optionalLazy | x*? ,x+? ,x?? |
= ,>= ,** | repeat ,atLeast ,between | x{n} ,x{n,} ,x{n,m} |
group | group(...) | (...) |
group-n | named("name", ...) | (?<name>...) |
backref | backref(1) ,backref("name") | \\1 ,\\k<name> |
literal | literal(s) | s , escaped:1\\+1 |
regexp ,regex | raw("...") ,raw(/.../) | (?:...) , as-is |
rx-define ,rx-let | const | (none) |
bos ,eos | start ,end | ^ ,$ |
bol ,eol | lineStart ,lineEnd (with them flag) | ^ ,$ |
bow ,eow | wordStart ,wordEnd | \\b(?=\\w) ,\\b(?<=\\w) |
word-boundary | wordBoundary | \\b |
not-word-boundary | notWordBoundary | \\B |
nonl ,not-newline | notNewline | . |
anychar ,anything | anything | [\\s\\S] |
unmatchable | unmatchable | (?!) |
digit | digit | \\d |
hex-digit ,xdigit | hexDigit | [0-9a-fA-F] |
space ,whitespace | space | \\s |
blank | blank | [ \\t] |
word ,wordchar | wordChar | \\w |
not-wordchar | notWordChar | \\W |
alpha ,letter | alpha | [a-zA-Z] |
alnum | alnum | [a-zA-Z0-9] |
lower ,upper | lower ,upper | [a-z] ,[A-Z] |
punct ,punctuation | punct | [!-/:-@[-`{-~] |
cntrl ,control | control | [\\x00-\\x1f\\x7f] |
graph ,graphic | graphic | [!-~] |
print ,printing | printing | [ -~] |
ascii ,nonascii | ascii ,nonascii | [\\x00-\\x7f] ,[\\u0080-\\uffff] |
Each example below shows the goal, the Emacs rx form in a comment,\nthe regexp you would write by hand, and the RX version. When RX\nproduces a different regexp text, the // => line shows it. The\nresults at the bottom come from running both against the same strings.
The whole string is digits.
\n// Emacs: (rx bos (+ digit) eos)\nconst regex = /^\\d+$/;\nconst dsl = RX(start, oneOrMore(digit), end);\n// "123" -> true\n// "12a" -> falseThe whole string is ASCII letters.
\n// Emacs: (rx bos (+ alpha) eos)\nconst regex = /^[a-zA-Z]+$/;\nconst dsl = RX(start, oneOrMore(alpha), end);\n// "Hello" -> true\n// "He11o" -> falseBoth spellings, color and colour.
\n// Emacs: (rx bos "colo" (? "u") "r" eos)\nconst regex = /^colou?r$/;\nconst dsl = RX(start, "colo", optional("u"), "r", end);\n// "color" -> true\n// "colour" -> true\n// "colouur" -> falseTwo words separated by a space.
\n// Emacs: (rx bos (+ wordchar) space (+ wordchar) eos)\nconst regex = /^\\w+\\s\\w+$/;\nconst word = oneOrMore(wordChar);\nconst dsl = RX(start, word, space, word, end);\n// "hello world" -> true\n// "hello" -> false(123) 456-7890, parentheses and all.
\n// Emacs: (rx bos "(" (= 3 digit) ")" space (= 3 digit) "-" (= 4 digit) eos)\nconst regex = /^\\(\\d{3}\\)\\s\\d{3}-\\d{4}$/;\nconst dsl = RX(\n start, "(", repeat(3, digit), ")", space,\n repeat(3, digit), "-", repeat(4, digit), end,\n);\n// "(123) 456-7890" -> true\n// "123-456-7890" -> false#ff00aa-style colors.
// Emacs: (rx bos "#" (= 6 hex-digit) eos)\nconst regex = /^#[0-9a-fA-F]{6}$/;\nconst dsl = RX(start, "#", repeat(6, hexDigit), end);\n// "#ff00aa" -> true\n// "#ff00ag" -> falseAn optional sign, then digits.
\n// Emacs: (rx bos (? (any "+-")) (+ digit) eos)\nconst regex = /^[+-]?\\d+$/;\nconst dsl = RX(start, optional(anyOf("+-")), oneOrMore(digit), end);\n// => /^[+\\-]?\\d+$/\n// "-42" -> true\n// "42" -> true\n// "*42" -> falseSomething@something.something, no spaces.
\n// Emacs: (rx-let ((part (+ (not (any space "@")))))\n// (rx bos part "@" part "." part eos))\nconst regex = /^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$/;\nconst part = oneOrMore(not(anyOf(space, "@")));\nconst dsl = RX(start, part, "@", part, ".", part, end);\n// "a@b.com" -> true\n// "a b@c.com" -> false\n// "a@b" -> falseA string without any digit.
\n// Emacs: (rx bos (+ (not digit)) eos)\nconst regex = /^[^\\d]+$/;\nconst dsl = RX(start, oneOrMore(not(digit)), end);\n// => /^\\D+$/\n// "abc" -> true\n// "a1b" -> falseExactly three comma-separated fields.
\n// Emacs: (rx-let ((field (+ (not-char ","))))\n// (rx bos field "," field "," field eos))\nconst regex = /^[^,]+,[^,]+,[^,]+$/;\nconst field = oneOrMore(notChar(","));\nconst dsl = RX(start, field, ",", field, ",", field, end);\n// "a,b,c" -> true\n// "a,b," -> falseA fixed list of words.
\n// Emacs: (rx bos (or "cat" "dog" "bird") eos)\nconst regex = /^(?:cat|dog|bird)$/;\nconst dsl = RX(start, or("cat", "dog", "bird"), end);\n// => /^(?:bird|cat|dog)$/\n// "cat" -> true\n// "bird" -> true\n// "cow" -> falsemr or ms, then a name, keeping the title.
// Emacs: (rx bos (group (or "mr" "ms")) space (+ wordchar) eos)\nconst regex = /^(mr|ms)\\s\\w+$/;\nconst dsl = RX(start, group(or("mr", "ms")), space, oneOrMore(wordChar), end);\n// "mr john" -> true\n// "dr john" -> falseTwo to four digits.
\n// Emacs: (rx bos (** 2 4 digit) eos)\nconst regex = /^\\d{2,4}$/;\nconst dsl = RX(start, between(2, 4, digit), end);\n// "12" -> true\n// "12345" -> falseThree or more digits, anywhere.
\n// Emacs: (rx (>= 3 digit))\nconst regex = /\\d{3,}/;\nconst dsl = RX(atLeast(3, digit));\n// "12" -> false\n// "a123" -> trueThe same word twice.
\n// Emacs: (rx bos (group (+ wordchar)) space (backref 1) eos)\nconst regex = /^(\\w+)\\s\\1$/;\nconst dsl = RX(start, group(oneOrMore(wordChar)), space, backref(1), end);\n// "hello hello" -> true\n// "hello world" -> falseAn open tag and its own closing tag.
\n// Emacs: (rx "<" (group-n 1 (+ wordchar)) ">" (*? nonl) "</" (backref 1) ">")\nconst regex = /<(?<tag>\\w+)>.*?<\\/\\k<tag>>/;\nconst dsl = RX(\n "<", named("tag", oneOrMore(wordChar)), ">",\n zeroOrMoreLazy(notNewline),\n "</", backref("tag"), ">",\n);\n// "<b>bold</b>" -> true\n// "<b>oops</i>" -> falsecat as a word, not inside another one.
// Emacs: (rx word-boundary "cat" word-boundary)\nconst regex = /\\bcat\\b/;\nconst dsl = RX(wordBoundary, "cat", wordBoundary);\n// "the cat sat" -> true\n// "concatenate" -> falsehello, in any case.
// Emacs: (let ((case-fold-search t))\n// (string-match-p (rx bos "hello" eos) "HeLLo"))\nconst regex = /^hello$/i;\nconst dsl = RX.flags("i", start, "hello", end);\n// "HeLLo" -> true\n// "help" -> falseIt's a single file with no dependencies. Copy it into your project and start deleting the forms you don't need, or adding the ones you miss.
\nYou can check the same code, plus all the examples from this post (and a few more), in this gist. If you'd rather not set anything up, paste it into the TypeScript Playground, hit "Run", and check the "Logs" tab.
\n/* =========================================================\n * CORE\n * ========================================================= */\n// How a node behaves when combined with others:\n// atom -> single unit, a quantifier can be glued right after it\n// seq -> safe to concatenate, needs (?:) to be quantified\n// alt -> has a top-level `|`, needs (?:) almost everywhere\ntype Kind = "atom" | "seq" | "alt";\ninterface RxNode {\n readonly src: string;\n readonly kind: Kind;\n // char sets only: the text that goes inside [ ], so sets can merge\n readonly set?: string;\n readonly neg?: boolean;\n}\ntype Item = string | RxNode;\nconst esc = (s: string) => s.replace(/[.*+?^${}()|[\\]\\\\]/g, "\\\\$&");\nconst escSet = (s: string) => s.replace(/[\\]\\\\^-]/g, "\\\\$&");\n// rx: (literal EXPR) — a string computed at runtime, matched as-is\nconst literal = (s: string): RxNode => ({\n src: esc(s),\n kind: s.length === 1 ? "atom" : "seq",\n});\nconst toNode = (x: Item): RxNode => (typeof x === "string" ? literal(x) : x);\n// wrap a node so a quantifier applies to all of it\nconst quantifiable = (n: RxNode) =>\n n.kind === "atom" ? n.src : `(?:${n.src})`;\n// rx: (regexp EXPR) — escape hatch, trust the regexp as-is\nconst raw = (re: string | RegExp): RxNode => ({\n src: typeof re === "string" ? re : re.source,\n kind: "alt",\n});\n/* =========================================================\n * COMPOSITION\n * ========================================================= */\nconst seq = (...xs: Item[]): RxNode => {\n const nodes = xs.map(toNode).filter((n) => n.src !== "");\n if (nodes.length === 0) return { src: "", kind: "seq" };\n if (nodes.length === 1) return nodes[0];\n let src = "";\n for (const n of nodes) {\n const part = n.kind === "alt" ? `(?:${n.src})` : n.src;\n // `\\1` followed by a literal `0` would read as `\\10`\n if (/\\\\\\d+$/.test(src) && /^\\d/.test(part)) src += "(?:)";\n src += part;\n }\n return { src, kind: "seq" };\n};\nconst unmatchable: RxNode = { src: "(?!)", kind: "atom" };\n// Like rx: when every branch is a plain string, try the longest first,\n// so or("in", "int") matches "int" instead of stopping at "in".\nconst or = (...xs: Item[]): RxNode => {\n if (xs.length === 0) return unmatchable;\n if (xs.length === 1) return toNode(xs[0]);\n const branches = xs.every((x) => typeof x === "string")\n ? [...(xs as string[])].sort((a, b) => b.length - a.length)\n : xs;\n return { src: branches.map((x) => toNode(x).src).join("|"), kind: "alt" };\n};\n/* =========================================================\n * CHARACTER SETS\n * ========================================================= */\nconst set = (body: string, neg = false): RxNode => ({\n src: neg ? `[^${body}]` : `[${body}]`,\n kind: "atom",\n set: body,\n neg,\n});\n// class escapes are sets too, so they can go inside anyOf(...)\nconst classEscape = (e: string): RxNode => ({\n src: e,\n kind: "atom",\n set: e,\n neg: false,\n});\n// Same reading as rx: inside a string, "a-z" is a range, while a `-`\n// at the start or end is just a dash ("+-" is plus or minus).\nconst intervals = (s: string): string => {\n let body = "";\n let i = 0;\n while (i < s.length) {\n if (i < s.length - 2 && s[i + 1] === "-") {\n body += `${escSet(s[i])}-${escSet(s[i + 2])}`;\n i += 3;\n } else {\n body += escSet(s[i]);\n i += 1;\n }\n }\n return body;\n};\n// rx: (any "a-z" "_" digit) — also known as `in` and `char`\nconst anyOf = (...xs: Item[]): RxNode => {\n const body = xs\n .map((x) => {\n if (typeof x === "string") return intervals(x);\n if (x.set === undefined || x.neg)\n throw new Error(`anyOf: not a positive char set: ${x.src}`);\n return x.set;\n })\n .join("");\n return set(body);\n};\n// rx: (not charset) — not(digit) -> \\D, not(anyOf(",;")) -> [^,;]\nconst not = (x: Item): RxNode => {\n const n = typeof x === "string" ? anyOf(x) : x;\n if (n.set === undefined) throw new Error(`not: not a char set: ${n.src}`);\n if (n.neg) return set(n.set);\n if (/^\\\\[dswDSW]$/.test(n.src)) {\n const c = n.src[1];\n const flipped = c === c.toLowerCase() ? c.toUpperCase() : c.toLowerCase();\n return classEscape(`\\\\${flipped}`);\n }\n return set(n.set, true);\n};\n// rx: (not-char "a-z" ...) — shorthand for (not (any ...))\nconst notChar = (...xs: Item[]) => not(anyOf(...xs));\n// rx char classes, `[[:name:]]` in Emacs\nconst digit = classEscape("\\\\d");\nconst space = classEscape("\\\\s");\nconst wordChar = classEscape("\\\\w");\nconst notWordChar = not(wordChar);\nconst lower = anyOf("a-z");\nconst upper = anyOf("A-Z");\nconst alpha = anyOf(lower, upper);\nconst alnum = anyOf(alpha, "0-9");\nconst hexDigit = anyOf("0-9a-fA-F");\nconst blank = set(" \\\\t");\nconst control = set("\\\\x00-\\\\x1f\\\\x7f");\nconst punct = anyOf("!-/:-@[-`{-~");\nconst graphic = anyOf("!-~");\nconst printing = anyOf(" -~");\nconst ascii = set("\\\\x00-\\\\x7f");\nconst nonascii = set("\\\\u0080-\\\\uffff");\n// rx: `nonl` is any char but newline; `anything` really is anything\nconst notNewline: RxNode = { src: ".", kind: "atom" };\nconst anything = set("\\\\s\\\\S");\n/* =========================================================\n * ANCHORS (zero-width)\n * ========================================================= */\nconst zeroWidth = (src: string): RxNode => ({ src, kind: "seq" });\n// rx: bos / eos\nconst start = zeroWidth("^");\nconst end = zeroWidth("$");\n// rx: bol / eol — same symbols, only per line with the "m" flag\nconst lineStart = start;\nconst lineEnd = end;\nconst wordBoundary = zeroWidth("\\\\b");\nconst notWordBoundary = zeroWidth("\\\\B");\n// rx: bow / eow — JS has no \\< \\>, so a boundary plus a lookaround\nconst wordStart = zeroWidth("\\\\b(?=\\\\w)");\nconst wordEnd = zeroWidth("\\\\b(?<=\\\\w)");\n/* =========================================================\n * GROUPS & BACKREFERENCES\n * ========================================================= */\nconst group = (...xs: Item[]): RxNode => ({\n src: `(${seq(...xs).src})`,\n kind: "atom",\n});\n// rx has (group-n N ...); JS can't pick group numbers, but it can name them\nconst named = (name: string, ...xs: Item[]): RxNode => ({\n src: `(?<${name}>${seq(...xs).src})`,\n kind: "atom",\n});\nconst backref = (ref: number | string): RxNode => ({\n src: typeof ref === "number" ? `\\\\${ref}` : `\\\\k<${ref}>`,\n kind: "atom",\n});\n/* =========================================================\n * QUANTIFIERS\n * ========================================================= */\nconst quantifier =\n (suffix: string) =>\n (...xs: Item[]): RxNode => ({\n src: quantifiable(seq(...xs)) + suffix,\n kind: "seq",\n });\n// greedy — rx: * + ?\nconst zeroOrMore = quantifier("*");\nconst oneOrMore = quantifier("+");\nconst optional = quantifier("?");\n// lazy — rx: *? +? ??\nconst zeroOrMoreLazy = quantifier("*?");\nconst oneOrMoreLazy = quantifier("+?");\nconst optionalLazy = quantifier("??");\n// rx: (= n ...) (>= n ...) (** n m ...)\nconst repeat = (n: number, ...xs: Item[]) => quantifier(`{${n}}`)(...xs);\nconst atLeast = (n: number, ...xs: Item[]) => quantifier(`{${n},}`)(...xs);\nconst between = (n: number, m: number, ...xs: Item[]) =>\n quantifier(`{${n},${m}}`)(...xs);\n/* =========================================================\n * ENTRY POINTS\n * ========================================================= */\n// rx(...) -> the regexp source string (like Emacs, rx returns a string)\n// RX(...) -> a ready-to-use RegExp, no more `new RegExp(seq(...))`\nconst rx = (...xs: Item[]): string => seq(...xs).src;\nfunction RX(...xs: Item[]): RegExp {\n return new RegExp(rx(...xs));\n}\n// Emacs uses `case-fold-search` for this; JS puts it on the regexp\nRX.flags = (flags: string, ...xs: Item[]): RegExp =>\n new RegExp(rx(...xs), flags);None of this is new. On the Emacs side, as I said before, rx has\nshipped for decades, and the Elisp version is more complete than mine.
The idea of describing patterns with a small DSL instead of raw syntax isn't new either. Plenty of people have tried it, each in their own way. One project I like a lot in this space is Zod, which I wrote about in my Zod quick tutorial. It's not a regexp builder: you compose small schema pieces, and Zod gives you back a parser and a TypeScript type from the same construction. It follows the same spirit, though: build big things out of small named pieces you can read.
\nIf you write Elisp and have never tried rx, open *scratch*, type\n(rx (+ digit)), and C-x C-e it. If you write JavaScript or\nTypeScript, the file above is yours. And if you port it to another\nlanguage, send me a link.