shelving 1.71.0 → 1.71.1

package/markup/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./options.js";
 export * from "./rules.js";
 export * from "./render.js";
+export * from "./regexp.js";

package/markup/index.js

@@ -1,3 +1,4 @@
 export * from "./options.js";
 export * from "./rules.js";
 export * from "./render.js";
+export * from "./regexp.js";

package/markup/regexp.d.ts

@@ -0,0 +1,39 @@
+import type { Data } from "../util/data.js";
+import { PossibleRegExp } from "../util/regexp.js";
+import type { MarkupOptions } from "./options.js";
+/** Subset of `NamedRegExpArray<T>` that are the only things we're required return from a `MarkupMatcher` function. */
+export declare type MarkupMatch<T extends Data | undefined = Data | undefined> = {
+    0: string;
+    index: number;
+    groups: T;
+};
+/** Function that matches a string and returns a `MarkupMatch` or `null` or `void` */
+export declare type MarkupMatcher<T extends Data | undefined = Data | undefined> = (input: string, options: MarkupOptions) => MarkupMatch<T> | null | void;
+export declare const LINE_REGEXP: RegExp;
+export declare const LINE_START_REGEXP: RegExp;
+export declare const LINE_END_REGEXP: RegExp;
+export declare const BLOCK_REGEXP: RegExp;
+export declare const BLOCK_START_REGEXP: RegExp;
+export declare const BLOCK_END_REGEXP: RegExp;
+/** Create regular expression that matches a block of content. */
+export declare function getBlockRegExp(content?: PossibleRegExp, end?: PossibleRegExp, start?: PossibleRegExp): RegExp;
+/** Create regular expression that matches a line of content. */
+export declare function getLineRegExp(content?: PossibleRegExp, end?: PossibleRegExp, start?: PossibleRegExp): RegExp;
+/**
+ * Regular expression that only matches complete its pattern if it's a complete word.
+ * - Won't match if there are letters or numbers directly before/after the matched content.
+ * - Will match if there is punctuation before/after the matched content or it is at the start/end of the string.
+ * - e.g. `this` and `"this"` and `that this that` and `that (this) that` will match because `this` is a complete word.
+ * - e.g. `thatthis` and `thatthisthat` will not because `this` is only part of a complete word.
+ *
+ * @note This isn't guaranteed to work with `String.prototype.match()` and `String.prototype.replace()`
+ *
+ * @todo This can be much less complicated when Safari supports lookbehinds in regular expressions.
+ * - We use a negative lookahead for the end of the word and it works great.
+ * - If we could use a negative lookbehind for the start of the word we wouldn't need to create a function that offsets the start.
+ */
+export declare class WordRegExp extends RegExp {
+    constructor(pattern: string);
+    exec(input: string): RegExpExecArray | null;
+    test(input: string): boolean;
+}

package/markup/regexp.js

@@ -0,0 +1,50 @@
+import { getRegExpSource } from "../util/regexp.js";
+// Regular expressions.
+export const LINE_REGEXP = /[^\n]*/; // Match line of content (anything that's not a newline).
+export const LINE_START_REGEXP = /^\n*|\n+/; // Starts at start of line (one or more linebreak or start of string).
+export const LINE_END_REGEXP = /\n+|$/; // Ends at end of line (one or more linebreak or end of string).
+export const BLOCK_REGEXP = /[\s\S]*?/; // Match block of content (including newlines so don't be greedy).
+export const BLOCK_START_REGEXP = /^\n*|\n+/; // Starts at start of a block (one or more linebreak or start of string).
+export const BLOCK_END_REGEXP = /\n*$|\n\n+/; // End of a block (two or more linebreaks or end of string).
+/** Create regular expression that matches a block of content. */
+export function getBlockRegExp(content = BLOCK_REGEXP, end = BLOCK_END_REGEXP, start = BLOCK_START_REGEXP) {
+    return new RegExp(`(?:${getRegExpSource(start)})(?:${getRegExpSource(content)})(?:${getRegExpSource(end)})`);
+}
+/** Create regular expression that matches a line of content. */
+export function getLineRegExp(content = LINE_REGEXP, end = LINE_END_REGEXP, start = LINE_START_REGEXP) {
+    return new RegExp(`(?:${getRegExpSource(start)})(?:${getRegExpSource(content)})(?:${getRegExpSource(end)})`);
+}
+/**
+ * Regular expression that only matches complete its pattern if it's a complete word.
+ * - Won't match if there are letters or numbers directly before/after the matched content.
+ * - Will match if there is punctuation before/after the matched content or it is at the start/end of the string.
+ * - e.g. `this` and `"this"` and `that this that` and `that (this) that` will match because `this` is a complete word.
+ * - e.g. `thatthis` and `thatthisthat` will not because `this` is only part of a complete word.
+ *
+ * @note This isn't guaranteed to work with `String.prototype.match()` and `String.prototype.replace()`
+ *
+ * @todo This can be much less complicated when Safari supports lookbehinds in regular expressions.
+ * - We use a negative lookahead for the end of the word and it works great.
+ * - If we could use a negative lookbehind for the start of the word we wouldn't need to create a function that offsets the start.
+ */
+export class WordRegExp extends RegExp {
+    constructor(pattern) {
+        super(`(?<lookbehind>^|[^\\p{L}\\p{N}])${pattern}(?![\\p{L}\\p{N}])`);
+    }
+    exec(input) {
+        var _a;
+        const match = super.exec(input);
+        if (match) {
+            const { 0: zero, groups } = match;
+            const offset = ((_a = groups === null || groups === void 0 ? void 0 : groups.lookbehind) === null || _a === void 0 ? void 0 : _a.length) || 0;
+            if (zero && offset) {
+                match[0] = zero.slice(offset); // Slice off the start of the match to remove the matched first character.
+                match.index += offset; // Increment the index to remove the matched first character.
+            }
+        }
+        return match;
+    }
+    test(input) {
+        return !!this.exec(input);
+    }
+}

package/markup/rules.d.ts

@@ -1,19 +1,14 @@
 import type { Data } from "../util/data.js";
 import type { JSXElement } from "../util/jsx.js";
 import { NamedRegExp, NamedRegExpData } from "../util/regexp.js";
+import { MarkupMatcher } from "./regexp.js";
 import type { MarkupOptions } from "./options.js";
-/** Subset of `NamedRegExpArray<T>` that are the only things we're required return from `match()` (because ) */
-export declare type MarkupMatch<T extends Data | undefined> = {
-    0: string;
-    index: number;
-    groups: T;
-};
 /** Rule for parsing string markup into a JSX element. */
 export interface MarkupRule<T extends Data | undefined = Data | undefined> {
     /**
      * Regular expression or custom matching function.
      */
-    readonly match: (T extends undefined ? RegExp : T extends NamedRegExpData ? NamedRegExp<T> : never) | ((input: string, options: MarkupOptions) => MarkupMatch<T> | null | void);
+    readonly match: (T extends undefined ? RegExp : T extends NamedRegExpData ? NamedRegExp<T> : never) | MarkupMatcher<T>;
     /**
      * Render the JSX element for this rule using the props matched by
      */
@@ -48,22 +43,18 @@ export declare type MarkupRules = AnyMarkupRule[];
  * - Same as Markdown syntax.
  * - Markdown's underline syntax is not supported (for simplification).
  */
-export declare const MATCH_HEADING: NamedRegExp<{
-    prefix: string;
-    heading: string;
-}>;
 export declare const HEADING_RULE: MarkupRule<{
-    level: number;
+    prefix: string;
     heading: string;
 }>;
 /**
- * Horizontal rules
+ * Separator (horizontal rule / thematic break).
  * - Same as Markdown syntax but also allows `•` bullet character (in addition to `-` dash, `+` plus, `*` asterisk, `_` underscore).
  * - Character must be repeated three (or more) times.
  * - Character must be the same every time (can't mix)
  * - Might have infinite number of spaces between the characters.
  */
-export declare const HORIZONTAL_RULE: MarkupRule;
+export declare const SEPARATOR_RULE: MarkupRule;
 export declare const UNORDERED_RULE: MarkupRule<{
     list: string;
 }>;
@@ -81,6 +72,7 @@ export declare const BLOCKQUOTE_RULE: MarkupRule<{
  * - Markdown-style four-space indent syntax is not supported (only fenced code, since it's easier to use).
  */
 export declare const FENCED_CODE_RULE: MarkupRule<{
+    wrap: string;
     title?: string;
     code: string;
 }>;
@@ -99,7 +91,7 @@ export declare const PARAGRAPH_RULE: MarkupRule<{
  * - For security only schemes that appear in `options.schemes` will match (defaults to `http:` and `https:`).
  */
 export declare const URL_CHAR = "[-$_@.&!*,=;/#?:%a-zA-Z0-9]";
-export declare const URL_MATCH: NamedRegExp<{
+export declare const URL_REGEXP: NamedRegExp<{
     title?: string;
     href: string;
 }>;
@@ -115,7 +107,7 @@ export declare const URL_RULE: MarkupRule<{
  * - If link is not valid (using `new URL(url)` then unparsed text will be returned.
  * - For security only `http://` or `https://` links will work (if invalid the unparsed text will be returned).
  */
-export declare const LINK_MATCH: NamedRegExp<{
+export declare const LINK_REGEXP: NamedRegExp<{
     title: string;
     href: string;
 }>;
@@ -131,50 +123,33 @@ export declare const LINK_RULE: MarkupRule<{
  * - Same as Markdown syntax.
  */
 export declare const CODE_RULE: MarkupRule<{
-    text: string;
+    code: string;
 }>;
 /**
- * Inline strong.
- * - Inline text wrapped in one or more `*` asterisks.
- * - Must be surrounded by space (e.g. ` *abc* `) — so formatting cannot be applied inside a word (e.g. `a*b*c`).
+ * Inline strong, emphasis, insert, delete, highlight.
+ * - Inline strong text wrapped in one or more `*` asterisks.
+ * - Inline emphasis text wrapped in one or more `_` underscores.
+ * - Inline inserted text wrapped in one or more `+` pluses.
+ * - Inline deleted text wrapped in one or more `-` minuses or `~` tildes.
+ * - Inline highlighted text wrapped in one or more `=` equals or `:` colons.
  * - Whitespace cannot be the first or last character of the element (e.g. `* abc *` will not work).
+ * - Closing chars must match opening characters.
+ * - Cannot occur in the middle of a word (e.g. `this*that*this` will not work).
  * - Closing characters must exactly match opening characters.
  * - Different to Markdown: strong is always surrounded by `*asterisks*` and emphasis is always surrounded by `_underscores_` (strong isn't 'double emphasis').
  */
-export declare const STRONG_RULE: MarkupRule<{
-    text: string;
-}>;
-/**
- * Inline emphasis.
- * - Inline text wrapped in one or more `_` underscore symbols.
- * - Works inside words (e.g. `magi_carp_carp`).
- * - Whitespace cannot be the first or last character of the element (e.g. `_ abc _` will not work).
- * - Closing characters must exactly match opening characters.
- * - Different to Markdown: strong is always surrounded by `*asterisks*` and emphasis is always surrounded by `_underscores_` (strong isn't 'double emphasis').
- */
-export declare const EMPHASIS_RULE: MarkupRule<{
-    text: string;
-}>;
-/**
- * Inserted text (`<ins>` tag),
- * - Inline text wrapped in two or more `++` pluses.
- * - Works inside words (e.g. `magi++karp++carp`).
- * - Whitespace cannot be the first or last character of the element (e.g. `+ abc +` will not work).
- * - Closing characters must exactly match opening characters.
- * - Markdown doesn't have this.
- */
-export declare const INSERT_RULE: MarkupRule<{
-    text: string;
-}>;
-/**
- * Deleted text (`<del>` tag),
- * - Inline text wrapped in two or more `--` hyphens or `~~` tildes.
- * - Works inside words (e.g. `magi--karp--carp`).
- * - Whitespace cannot be the first or last character of the element (e.g. `-- abc --` will not work).
- * - Closing characters must exactly match opening characters.
- * - Markdown doesn't have this.
- */
-export declare const DELETE_RULE: MarkupRule<{
+declare const INLINE_CHARS: {
+    "-": string;
+    "~": string;
+    "+": string;
+    "*": string;
+    _: string;
+    "=": string;
+    ":": string;
+};
+export declare const INLINE_RULE: MarkupRule<{
+    char: keyof typeof INLINE_CHARS;
+    wrap: string;
     text: string;
 }>;
 /**
@@ -202,3 +177,4 @@ export declare const MARKUP_RULES_BLOCK: MarkupRules;
 export declare const MARKUP_RULES_INLINE: MarkupRules;
 /** Subset of markup rules that are relevant for collapsed shortform content. */
 export declare const MARKUP_RULES_SHORTFORM: MarkupRules;
+export {};

package/markup/rules.js

@@ -1,6 +1,7 @@
 /* eslint-disable import/export */
-import { getBlockRegExp, getLineRegExp, getNamedRegExp, getWrapRegExp, MATCH_BLOCK, MATCH_LINE } from "../util/regexp.js";
+import { getRegExp } from "../util/regexp.js";
 import { formatURL, getOptionalURL } from "../util/url.js";
+import { getBlockRegExp, getLineRegExp, BLOCK_REGEXP, LINE_REGEXP, WordRegExp } from "./regexp.js";
 /** React security symbol — see https://github.com/facebook/react/pull/4832 */
 const $$typeof = Symbol.for("react.element");
 /**
@@ -9,18 +10,10 @@ const $$typeof = Symbol.for("react.element");
  * - Same as Markdown syntax.
  * - Markdown's underline syntax is not supported (for simplification).
  */
-export const MATCH_HEADING = getLineRegExp(`(?<prefix>#{1,6}) +(?<heading>${MATCH_LINE.source})`);
 export const HEADING_RULE = {
-    match: input => {
-        const match = MATCH_HEADING.exec(input);
-        if (match) {
-            const { index, 0: first, groups } = match;
-            const { prefix, heading } = groups;
-            return { index, 0: first, groups: { level: prefix.length, heading } };
-        }
-    },
-    render: ({ level, heading }) => ({
-        type: `h${level}`,
+    match: getLineRegExp(`(?<prefix>#{1,6}) +(?<heading>${LINE_REGEXP.source})`),
+    render: ({ prefix, heading }) => ({
+        type: `h${prefix.length}`,
         key: null,
         ref: null,
         $$typeof,
@@ -30,13 +23,13 @@ export const HEADING_RULE = {
     subcontext: "inline",
 };
 /**
- * Horizontal rules
+ * Separator (horizontal rule / thematic break).
  * - Same as Markdown syntax but also allows `•` bullet character (in addition to `-` dash, `+` plus, `*` asterisk, `_` underscore).
  * - Character must be repeated three (or more) times.
  * - Character must be the same every time (can't mix)
  * - Might have infinite number of spaces between the characters.
  */
-export const HORIZONTAL_RULE = {
+export const SEPARATOR_RULE = {
     match: getLineRegExp(`([-*•+_=])(?: *\\1){2,}`),
     render: () => ({
         type: "hr",
@@ -58,7 +51,7 @@ const UNORDERED_PREFIX = `[-*•+] +`;
 const UNORDERED_SPLIT = new RegExp(`\n+${UNORDERED_PREFIX}`, "g");
 const UNORDERED_INDENT = /^\t/gm;
 export const UNORDERED_RULE = {
-    match: getBlockRegExp(`${UNORDERED_PREFIX}(?<list>${MATCH_BLOCK.source})`),
+    match: getBlockRegExp(`${UNORDERED_PREFIX}(?<list>${BLOCK_REGEXP.source})`),
     render: ({ list }) => ({
         type: "ul",
         key: null,
@@ -85,7 +78,7 @@ const ORDERED_PREFIX = "[1-9][0-9]{0,8}[.):] +"; // Number for a numbered list,
 const ORDERED_SPLIT = new RegExp(`\n+(?=${ORDERED_PREFIX})`, "g");
 const ORDERED_INDENT = UNORDERED_INDENT;
 export const ORDERED_RULE = {
-    match: getBlockRegExp(`(?<list>${ORDERED_PREFIX}${MATCH_BLOCK.source})`),
+    match: getBlockRegExp(`(?<list>${ORDERED_PREFIX}${BLOCK_REGEXP.source})`),
     render: ({ list }) => ({
         type: "ol",
         key: null,
@@ -118,7 +111,7 @@ const _mapOrdered = (item, key) => ({
 const BLOCKQUOTE_PREFIX = "> *";
 const BLOCKQUOTE_INDENT = new RegExp(`^${BLOCKQUOTE_PREFIX}`, "gm");
 export const BLOCKQUOTE_RULE = {
-    match: getLineRegExp(`(?<quote>${BLOCKQUOTE_PREFIX}${MATCH_LINE.source}(?:\n${BLOCKQUOTE_PREFIX}${MATCH_LINE.source})*)`),
+    match: getLineRegExp(`(?<quote>${BLOCKQUOTE_PREFIX}${LINE_REGEXP.source}(?:\n${BLOCKQUOTE_PREFIX}${LINE_REGEXP.source})*)`),
     render: ({ quote }) => ({
         type: "blockquote",
         key: null,
@@ -138,7 +131,7 @@ export const BLOCKQUOTE_RULE = {
  */
 export const FENCED_CODE_RULE = {
     // Matcher has its own end that only stops when it reaches a matching closing fence or the end of the string.
-    match: getBlockRegExp(`(\`{3,}|~{3,}) *(?<title>${MATCH_LINE.source})\n(?<code>${MATCH_BLOCK.source})`, `\n\\1\n+|\n\\1$|$`),
+    match: getLineRegExp(`(?<wrap>\`{3,}|~{3,}) *(?<title>${LINE_REGEXP.source})\n(?<code>${BLOCK_REGEXP.source})`, `(?:\n\\k<wrap>|$)`),
     render: ({ title, code }) => ({
         type: "pre",
         key: null,
@@ -162,7 +155,7 @@ export const FENCED_CODE_RULE = {
  * - When ordering rules, paragraph should go after other "block" context elements (because it has a very generous capture).
  */
 export const PARAGRAPH_RULE = {
-    match: getBlockRegExp(`(?<paragraph>${MATCH_BLOCK.source})`),
+    match: getBlockRegExp(`(?<paragraph>${BLOCK_REGEXP.source})`),
     render: ({ paragraph }) => ({
         type: `p`,
         key: null,
@@ -182,9 +175,9 @@ export const PARAGRAPH_RULE = {
  * - For security only schemes that appear in `options.schemes` will match (defaults to `http:` and `https:`).
  */
 export const URL_CHAR = "[-$_@.&!*,=;/#?:%a-zA-Z0-9]";
-export const URL_MATCH = getNamedRegExp(`(?<href>[a-z]+:${URL_CHAR}+)(?: +(?:\\((?<title>[^)]*?)\\)))?`);
+export const URL_REGEXP = new RegExp(`(?<href>[a-z]+:${URL_CHAR}+)(?: +(?:\\((?<title>[^)]*?)\\)))?`);
 export const URL_RULE = {
-    match: (input, options) => _urlMatch(URL_MATCH.exec(input), options),
+    match: (input, options) => _urlMatch(URL_REGEXP.exec(input), options),
     render: ({ href, title }, { rel }) => ({
         type: "a",
         key: null,
@@ -213,10 +206,10 @@ function _urlMatch(match, { schemes, url: base }) {
  * - If link is not valid (using `new URL(url)` then unparsed text will be returned.
  * - For security only `http://` or `https://` links will work (if invalid the unparsed text will be returned).
  */
-export const LINK_MATCH = getNamedRegExp(/\[(?<title>[^\]]*?)\]\((?<href>[^)]*?)\)/);
+export const LINK_REGEXP = getRegExp(/\[(?<title>[^\]]*?)\]\((?<href>[^)]*?)\)/);
 export const LINK_RULE = {
     ...URL_RULE,
-    match: (input, options) => _urlMatch(LINK_MATCH.exec(input), options),
+    match: (input, options) => _urlMatch(LINK_REGEXP.exec(input), options),
 };
 /**
  * Inline code.
@@ -226,89 +219,35 @@ export const LINK_RULE = {
  * - Same as Markdown syntax.
  */
 export const CODE_RULE = {
-    match: getWrapRegExp("`+", MATCH_BLOCK.source),
-    render: ({ text }) => ({
+    match: new RegExp(`(?<wrap>\`+)(?<code>${BLOCK_REGEXP.source})\\k<wrap>`),
+    render: ({ code }) => ({
         type: "code",
         key: null,
         ref: null,
         $$typeof,
-        props: { children: text },
+        props: { children: code },
     }),
     contexts: ["inline", "list"],
     priority: 10, // Higher priority than e.g. `strong` or `em` (from CommonMark spec: "Code span backticks have higher precedence than any other inline constructs except HTML tags and autolinks.")
 };
 /**
- * Inline strong.
- * - Inline text wrapped in one or more `*` asterisks.
- * - Must be surrounded by space (e.g. ` *abc* `) — so formatting cannot be applied inside a word (e.g. `a*b*c`).
+ * Inline strong, emphasis, insert, delete, highlight.
+ * - Inline strong text wrapped in one or more `*` asterisks.
+ * - Inline emphasis text wrapped in one or more `_` underscores.
+ * - Inline inserted text wrapped in one or more `+` pluses.
+ * - Inline deleted text wrapped in one or more `-` minuses or `~` tildes.
+ * - Inline highlighted text wrapped in one or more `=` equals or `:` colons.
  * - Whitespace cannot be the first or last character of the element (e.g. `* abc *` will not work).
+ * - Closing chars must match opening characters.
+ * - Cannot occur in the middle of a word (e.g. `this*that*this` will not work).
  * - Closing characters must exactly match opening characters.
  * - Different to Markdown: strong is always surrounded by `*asterisks*` and emphasis is always surrounded by `_underscores_` (strong isn't 'double emphasis').
  */
-export const STRONG_RULE = {
-    match: getWrapRegExp("\\*+"),
-    render: ({ text }) => ({
-        type: "strong",
-        key: null,
-        ref: null,
-        $$typeof,
-        props: { children: text },
-    }),
-    contexts: ["inline", "list", "link"],
-    subcontext: "inline",
-};
-/**
- * Inline emphasis.
- * - Inline text wrapped in one or more `_` underscore symbols.
- * - Works inside words (e.g. `magi_carp_carp`).
- * - Whitespace cannot be the first or last character of the element (e.g. `_ abc _` will not work).
- * - Closing characters must exactly match opening characters.
- * - Different to Markdown: strong is always surrounded by `*asterisks*` and emphasis is always surrounded by `_underscores_` (strong isn't 'double emphasis').
- */
-export const EMPHASIS_RULE = {
-    match: getWrapRegExp("_+"),
-    render: ({ text }) => ({
-        type: "em",
-        key: null,
-        ref: null,
-        $$typeof,
-        props: { children: text },
-    }),
-    contexts: ["inline", "list", "link"],
-    subcontext: "inline",
-};
-/**
- * Inserted text (`<ins>` tag),
- * - Inline text wrapped in two or more `++` pluses.
- * - Works inside words (e.g. `magi++karp++carp`).
- * - Whitespace cannot be the first or last character of the element (e.g. `+ abc +` will not work).
- * - Closing characters must exactly match opening characters.
- * - Markdown doesn't have this.
- */
-export const INSERT_RULE = {
-    match: getWrapRegExp("\\+\\++"),
-    render: ({ text }) => ({
-        type: "ins",
-        key: null,
-        ref: null,
-        $$typeof,
-        props: { children: text },
-    }),
-    contexts: ["inline", "list", "link"],
-    subcontext: "inline",
-};
-/**
- * Deleted text (`<del>` tag),
- * - Inline text wrapped in two or more `--` hyphens or `~~` tildes.
- * - Works inside words (e.g. `magi--karp--carp`).
- * - Whitespace cannot be the first or last character of the element (e.g. `-- abc --` will not work).
- * - Closing characters must exactly match opening characters.
- * - Markdown doesn't have this.
- */
-export const DELETE_RULE = {
-    match: getWrapRegExp("--+|~~+"),
-    render: ({ text }) => ({
-        type: "del",
+const INLINE_CHARS = { "-": "del", "~": "del", "+": "ins", "*": "strong", "_": "em", "=": "mark", ":": "mark" }; // Hyphen must be first so it works when we use the keys as a character class.
+export const INLINE_RULE = {
+    match: new WordRegExp(`(?<wrap>(?<char>[${Object.keys(INLINE_CHARS).join("")}])+)(?<text>(?!\\k<char>)\\S|(?!\\k<char>)\\S[\\s\\S]*?(?!\\k<char>)\\S)\\k<wrap>`),
+    render: ({ char, text }) => ({
+        type: INLINE_CHARS[char],
         key: null,
         ref: null,
         $$typeof,
@@ -348,7 +287,7 @@ export const LINEBREAK_RULE = {
  */
 export const MARKUP_RULES = [
     HEADING_RULE,
-    HORIZONTAL_RULE,
+    SEPARATOR_RULE,
     UNORDERED_RULE,
     ORDERED_RULE,
     BLOCKQUOTE_RULE,
@@ -357,16 +296,14 @@ export const MARKUP_RULES = [
     LINK_RULE,
     URL_RULE,
     CODE_RULE,
-    STRONG_RULE,
-    EMPHASIS_RULE,
-    INSERT_RULE,
-    DELETE_RULE,
+    INLINE_RULE,
     LINEBREAK_RULE,
+    //
 ];
 /** Subset of markup rules that work in a block context. */
 export const MARKUP_RULES_BLOCK = [
     HEADING_RULE,
-    HORIZONTAL_RULE,
+    SEPARATOR_RULE,
     UNORDERED_RULE,
     ORDERED_RULE,
     BLOCKQUOTE_RULE,
@@ -379,10 +316,7 @@ export const MARKUP_RULES_INLINE = [
     LINK_RULE,
     URL_RULE,
     CODE_RULE,
-    STRONG_RULE,
-    EMPHASIS_RULE,
-    INSERT_RULE,
-    DELETE_RULE,
+    INLINE_RULE,
     LINEBREAK_RULE,
     //
 ];
@@ -394,10 +328,7 @@ export const MARKUP_RULES_SHORTFORM = [
     LINK_RULE,
     URL_RULE,
     CODE_RULE,
-    STRONG_RULE,
-    EMPHASIS_RULE,
-    INSERT_RULE,
-    DELETE_RULE,
+    INLINE_RULE,
     LINEBREAK_RULE,
     //
 ];

package/package.json

@@ -11,7 +11,7 @@
 		"state-management",
 		"query-builder"
 	],
-	"version": "1.71.0",
+	"version": "1.71.1",
 	"repository": "https://github.com/dhoulb/shelving",
 	"author": "Dave Houlbrooke <dave@shax.com>",
 	"license": "0BSD",

package/util/debug.js

@@ -31,10 +31,10 @@ export function debug(value) {
     return typeof value;
 }
 /** Debug a string. */
-export const debugString = (value) => `"${value.replace(MATCH_ESCAPES, _debugChar)}"`;
-const MATCH_ESCAPES = /[\x00-\x08\x0B-\x1F\x7F-\x9F"\\]/g; // Match control characters, `"` double quote, `\` backslash.
-const ESCAPES = { '"': '\\"', "\\": "\\\\", "\r": "\\r", "\n": "\\n", "\t": "\\t", "\b": "\\b", "\f": "\\f", "\v": "\\v" };
-const _debugChar = (char) => ESCAPES[char] || `\\x${char.charCodeAt(0).toString(16).padStart(2, "00")}`;
+export const debugString = (value) => `"${value.replace(ESCAPE_REGEXP, _escapeChar)}"`;
+const ESCAPE_REGEXP = /[\x00-\x08\x0B-\x1F\x7F-\x9F"\\]/g; // Match control characters, `"` double quote, `\` backslash.
+const ESCAPE_LIST = { '"': '\\"', "\\": "\\\\", "\r": "\\r", "\n": "\\n", "\t": "\\t", "\b": "\\b", "\f": "\\f", "\v": "\\v" };
+const _escapeChar = (char) => ESCAPE_LIST[char] || `\\x${char.charCodeAt(0).toString(16).padStart(2, "00")}`;
 /** Debug an array. */
 export function debugArray(value) {
     const prototype = Object.getPrototypeOf(value);

package/util/regexp.d.ts

@@ -1,14 +1,9 @@
 import { Match } from "./match.js";
 import { NotString } from "./string.js";
-export declare const MATCH_LINE: RegExp;
-export declare const MATCH_LINE_START: RegExp;
-export declare const MATCH_LINE_END: RegExp;
-export declare const MATCH_BLOCK: RegExp;
-export declare const MATCH_BLOCK_START: RegExp;
-export declare const MATCH_BLOCK_END: RegExp;
-export declare const MATCH_TEXT: RegExp;
-export declare const MATCH_ALWAYS: RegExp;
-export declare const MATCH_NEVER: RegExp;
+/** Regular expression that always matches everything. */
+export declare const ALWAYS_REGEXP: RegExp;
+/** Regular expression that never matches anything. */
+export declare const NEVER_REGEXP: RegExp;
 /** Things that can be convert to a regular expression. */
 export declare type PossibleRegExp = string | RegExp;
 /** Is an unknown value a `RegExp` instance? */
@@ -27,25 +22,13 @@ export declare type NamedRegExpData = {
 };
 /** Regular expression match array that you've asserted contains the specified named groups. */
 export interface NamedRegExpArray<T extends NamedRegExpData = NamedRegExpData> extends RegExpExecArray {
-    readonly 0: string;
-    readonly groups: T;
+    0: string;
+    groups: T;
 }
 /** Regular expression that you've asserted contains the specified named capture groups. */
 export interface NamedRegExp<T extends NamedRegExpData = NamedRegExpData> extends RegExp {
     exec(input: string): NamedRegExpArray<T> | null;
 }
-/** Create a named regular expression (note: this is unsafe). */
-export declare const getNamedRegExp: <T extends NamedRegExpData>(pattern: string | RegExp, flags?: string) => NamedRegExp<T>;
-/** Create regular expression that matches a block of content (possibly asserting that it contains named match groups). */
-export declare function getBlockRegExp<T extends NamedRegExpData>(middle: PossibleRegExp, end?: PossibleRegExp, start?: PossibleRegExp, flags?: string): NamedRegExp<T>;
-export declare function getBlockRegExp(middle: PossibleRegExp, end?: PossibleRegExp, start?: PossibleRegExp, flags?: string): RegExp;
-/** Create regular expression that matches a line of content (possibly asserting that it contains named match groups). */
-export declare function getLineRegExp<T extends NamedRegExpData>(middle: PossibleRegExp, end?: PossibleRegExp, start?: PossibleRegExp, flags?: string): NamedRegExp<T>;
-export declare function getLineRegExp(middle: PossibleRegExp, end?: PossibleRegExp, start?: PossibleRegExp, flags?: string): RegExp;
-/** Create regular expression that matches piece of text wrapped by another expression (use `text` match group). */
-export declare function getWrapRegExp(wrapper: PossibleRegExp, middle?: PossibleRegExp, flags?: string): NamedRegExp<{
-    text: string;
-}>;
 /** Create regular expression that matches any of a list of other expressions. */
 export declare function getAnyRegExp(patterns: Iterable<PossibleRegExp> & NotString, flags?: string): RegExp;
 /** Create regular expression that matches all of a list of other expressions. */

package/util/regexp.js

@@ -1,15 +1,9 @@
 import { AssertionError } from "../error/AssertionError.js";
 import { getArray } from "./array.js";
-// Regular expressions.
-export const MATCH_LINE = /[^\n]*/; // Match line of content (anything that's not a newline).
-export const MATCH_LINE_START = /^\n*|\n+/; // Starts at start of line (one or more linebreak or start of string).
-export const MATCH_LINE_END = /\n+|$/; // Ends at end of line (one or more linebreak or end of string).
-export const MATCH_BLOCK = /[\s\S]*?/; // Match block of content (including newlines so don't be greedy).
-export const MATCH_BLOCK_START = /^\n*|\n+/; // Starts at start of a block (one or more linebreak or start of string).
-export const MATCH_BLOCK_END = /\n*$|\n\n+/; // End of a block (two or more linebreaks or end of string).
-export const MATCH_TEXT = /\S(?:[\s\S]*?\S)?/; // Run of text that starts and ends with non-space characters (possibly multi-line).
-export const MATCH_ALWAYS = /^.*$/; // Regular expression that always matches.
-export const MATCH_NEVER = /^(?=a)a/; // Regular expression that never matches.
+/** Regular expression that always matches everything. */
+export const ALWAYS_REGEXP = /^.*$/;
+/** Regular expression that never matches anything. */
+export const NEVER_REGEXP = /^(?=a)a/;
 /** Is an unknown value a `RegExp` instance? */
 export const isRegExp = (v) => v instanceof RegExp;
 /** Assert that an unknown value is a `RegExp` instance. */
@@ -24,24 +18,12 @@ export const getRegExpSource = (regexp) => (typeof regexp === "string" ? regexp
 /** Escape special characters in a string regular expression. */
 export const escapeRegExp = (pattern) => pattern.replace(REPLACE_ESCAPED, "\\$&");
 const REPLACE_ESCAPED = /[-[\]/{}()*+?.\\^$|]/g;
-/** Create a named regular expression (note: this is unsafe). */
-export const getNamedRegExp = (pattern, flags) => (typeof pattern === "string" ? new RegExp(pattern, flags) : pattern);
-export function getBlockRegExp(middle = MATCH_BLOCK, end = MATCH_BLOCK_END, start = MATCH_BLOCK_START, flags) {
-    return new RegExp(`(?:${getRegExpSource(start)})(?:${getRegExpSource(middle)})(?:${getRegExpSource(end)})`, flags);
-}
-export function getLineRegExp(middle = MATCH_LINE, end = MATCH_LINE_END, start = MATCH_LINE_START, flags) {
-    return new RegExp(`(?:${getRegExpSource(start)})(?:${getRegExpSource(middle)})(?:${getRegExpSource(end)})`, flags);
-}
-/** Create regular expression that matches piece of text wrapped by another expression (use `text` match group). */
-export function getWrapRegExp(wrapper, middle = MATCH_TEXT, flags) {
-    return getNamedRegExp(`(${getRegExpSource(wrapper)})(?<text>${getRegExpSource(middle)})\\1`, flags);
-}
 /** Create regular expression that matches any of a list of other expressions. */
 export function getAnyRegExp(patterns, flags) {
     const arr = getArray(patterns).filter(Boolean);
     // If there are no patterns to match against then _no_ string can ever match against any of nothing.
     if (!arr.length)
-        return MATCH_NEVER;
+        return NEVER_REGEXP;
     // Create RegExp using multiple joined matches like `(?:AAA)|(?:BBB)`
     return new RegExp(`(?:${getArray(patterns).map(getRegExpSource).join(")|(?:")})`, flags);
 }
@@ -50,7 +32,7 @@ export function getAllRegExp(patterns, flags) {
     const arr = getArray(patterns).filter(Boolean);
     // If there are no patterns to match against then _every_ string will match against the entire list of nothing.
     if (!arr.length)
-        return MATCH_ALWAYS;
+        return ALWAYS_REGEXP;
     // Create RegExp using multiple lookaheads like `^(?=.*?(?:AAA))(?=.*?(?:BBB))`
     return new RegExp(`^(?=.*?(?:${getArray(patterns).map(getRegExpSource).join("))(?=.*?(?:")}))`, flags);
 }

package/util/string.d.ts

@@ -41,6 +41,7 @@ export declare const joinStrings: (strs: Iterable<string> & NotString, joiner?:
  * - Remove allow control characters
  * - Normalise runs of whitespace to one ` ` space,
  * - Trim whitespace from the start and end of the string.
+ *
  * @example santizeString("\x00Nice!   "); // Returns `"Nice!"`
  */
 export declare const sanitizeString: (str: string) => string;
@@ -54,7 +55,7 @@ export declare const sanitizeString: (str: string) => string;
  * - Allow spaces at the start of each line (for indentation) but trim the end of each line.
  * - Trim excess newlines at the start and end of the string and runs of more than two newlines in a row.
  *
- * @todo Use lookbehind when Safari supports it to fix the replacements
+ * @todo Use lookbehind when Safari supports it, so replacements don't need `$1`
  */
 export declare const sanitizeLines: (str: string) => string;
 /**

package/util/string.js

@@ -53,29 +53,18 @@ export function getString(value) {
 }
 /** Concatenate an iterable set of strings together. */
 export const joinStrings = (strs, joiner = "") => getArray(strs).join(joiner);
-// Regular expressions.
-const MATCH_CONTROL_CHARS = /[\x00-\x1F\x7F-\x9F]/g; // Match control characters.
-const MATCH_LINE_CONTROL_CHARS = /[\x00-\x08\x0B-\x1F\x7F-\x9F]/g; // Match control characters except `\n` newline and `\t` tab.
-const MATCH_PARAGRAPH_SEPARATOR = /\n\n+|\f|\u2029/g; // Match indications of paragraph separation.
-const MATCH_LINE_SEPARATOR = /\r\n?|\n|\v|\x85|\u2028/g; // Match indications of line separation.
-const MATCH_WORD_SEPARATOR = /[\s\p{P}\p{S}\p{Z}]+/gu; // Match indications of word separation.
-const MATCH_WHITESPACE = /\s+/g; // Match runs of whitespace characters.
-const MATCH_TRAILING_WHITESPACE = /[^\S\n]+(?=\n)|\s+$/g; // Trailing whitespace at the end of a line or the whole string.
-const MATCH_NON_TEXT = /[^\p{L}\p{N} ]+/gu; // Match any characters that isn't a letter, number, or ` ` space.
-const MATCH_LEADING_NEWLINES = /^\n+/g; // `\n` newline characters at the start of the string.
-// const MATCH_TRAILING_NEWLINES = /\n+$/g; // `\n` newline characters at the end of the string.
-const MATCH_FOUR_SPACES = / {4}/g; // Match a run of four whitespace characters.
 /**
  * Sanitize a single-line string.
  * - Used when you're sanitising a single-line input, e.g. a title for something.
  * - Remove allow control characters
  * - Normalise runs of whitespace to one ` ` space,
  * - Trim whitespace from the start and end of the string.
+ *
  * @example santizeString("\x00Nice!   "); // Returns `"Nice!"`
  */
 export const sanitizeString = (str) => str
-    .replace(MATCH_WHITESPACE, " ") // Normalise runs of all whitespace to one ` ` space.
-    .replace(MATCH_CONTROL_CHARS, "") // Strip control characters.
+    .replace(/[^\P{C}\s]/gu, "") // Strip control characters (except whitespace).
+    .replace(/\s+/gu, " ") // Normalise runs of whitespace to one ` ` space.
     .trim(); // Trim whitespace from the start and end of the string.
 /**
  * Sanitize a multiline string.
@@ -87,17 +76,18 @@ export const sanitizeString = (str) => str
  * - Allow spaces at the start of each line (for indentation) but trim the end of each line.
  * - Trim excess newlines at the start and end of the string and runs of more than two newlines in a row.
  *
- * @todo Use lookbehind when Safari supports it to fix the replacements
+ * @todo Use lookbehind when Safari supports it, so replacements don't need `$1`
  */
 export const sanitizeLines = (str) => str
-    .replace(MATCH_TRAILING_WHITESPACE, "") // Trim whitespace from the end of each line and the end of the string.
-    .replace(MATCH_LEADING_NEWLINES, "") // Trim excess newlines at the start of the string (no need to trim trailing newlines because it was matched as trailing whitespace).
-    .replace(MATCH_LINE_SEPARATOR, "\n") // Normalise all line separators to `\n` newline
-    .replace(MATCH_PARAGRAPH_SEPARATOR, "\n\n") // Normalise all paragraph separators to `\n\n` double newline.
-    .replace(/(\S)[^\S\n]+(?=\S)/g, "$1 ") // Normalise runs of whitespace to one ` ` space (except indentation at the beginning of a line, by only matching runs after a non-space character).
-    .replace(MATCH_FOUR_SPACES, "\t") // Normalise runs of `    ` four spaces to a single `\t` tab (this will only exist in indentation because we already stripped it in other places).
-    .replace(/(^|\n|\t) +/g, "$1") // Remove runs  of ` ` space in indentation (will only match three or fewer because four spaces have already been normalised to `\t` tab).
-    .replace(MATCH_LINE_CONTROL_CHARS, ""); // Strip control characters (except newline).
+    .replace(/[^\P{C}\s]/gu, "") // Strip control characters (except whitespace).
+    .replace(/\r\n?|\v|\x85|\u2028/g, "\n") // Normalise line separators to `\n` newline
+    .replace(/[^\S\n]+(?=\n|$)/g, "") // Trim trailing whitespace on each line.
+    .replace(/\f|\u2029/g, "\n\n") // Normalise paragraph separators to `\n\n` double newline.
+    .replace(/^\n+|\n+$/g, "") // Trim leading and trailing newlines.
+    .replace(/\n{3,}/g, "\n\n") // Normalise `\n\n\n` triple newline (or more) to `\n\n` double newline.
+    .replace(/(\S)[^\S\n]+(?=\S)/g, "$1 ") // Normalise runs of whitespace in the middle of each line to one ` ` space.
+    .replace(/ {4}/g, "\t") // Normalise runs of `    ` four spaces to a single `\t` tab (this will only exist in indentation because we already stripped it in other places).
+    .replace(/(^|\n|\t) +/g, "$1"); // Remove runs  of ` ` space in indentation (will only match three or fewer because four spaces have already been normalised to `\t` tab).
 /**
  * Simplify a string by removing anything that isn't a number, letter, or space.
  * - Used when you're running a query against a string entered by a user.
@@ -106,8 +96,8 @@ export const sanitizeLines = (str) => str
  */
 export const simplifyString = (str) => str
     .normalize("NFD") // Convert ligatures (e.g. `ff`) and letters with marks (e.g. `ü`) to separate characters (e.g. `ff` and `u◌̈`)`.
-    .replace(MATCH_WORD_SEPARATOR, " ") // Normalise word separators to ` ` space.
-    .replace(MATCH_NON_TEXT, "") // Strip characters that aren't letters, numbers, spaces.
+    .replace(/[\s\p{P}\p{S}\p{Z}]+/gu, " ") // Normalise word separators to ` ` space.
+    .replace(/[^\p{L}\p{N} ]+/gu, "") // Strip characters that aren't letters, numbers, spaces.
     .trim()
     .toLowerCase();
 /**
@@ -117,7 +107,7 @@ export const simplifyString = (str) => str
  *
  * Note: this splits words based on spaces, so won't work well with logographic writing systems e.g. kanji.
  */
-export const getSlug = (str) => simplifyString(str).replace(MATCH_WHITESPACE, "-");
+export const getSlug = (str) => simplifyString(str).replace(/ /g, "-");
 /**
  * Return an array of the separate words and "quoted phrases" found in a string.
  * - Phrases enclosed "in quotes" are a single word.
@@ -132,14 +122,14 @@ export const getWords = (str) => Array.from(yieldWords(str));
  * Note: this splits words based on spaces, so won't work well with logographic writing systems e.g. kanji.
  */
 export function* yieldWords(str) {
-    for (const [, word, phrase] of str.matchAll(MATCH_WORD)) {
+    for (const [, word, phrase] of str.matchAll(WORD)) {
         if (phrase)
             yield phrase;
         else if (word)
             yield word;
     }
 }
-const MATCH_WORD = /([^\s"]+)|"([^"]*)"|'([^']*)'/g; // Runs of characters without spaces, or "quoted phrases"
+const WORD = /([^\s"]+)|"([^"]*)"|'([^']*)'/g; // Runs of characters without spaces, or "quoted phrases"
 /** Is the first character of a string an uppercase letter? */
 export const isUppercaseLetter = (str) => isBetween(str.charCodeAt(0), 65, 90);
 /** Is the first character of a string a lowercase letter? */