shelving 1.110.0 → 1.110.1

package/markup/render.js

@@ -66,8 +66,7 @@ function _renderNode(node, options, context) {
  * Render a JSX element in a given context.
  */
 function _renderElement(element, options, context) {
-    if (element.props.children)
-        element.props.children = _renderNode(element.props.children, options, context);
+    element.props.children = _renderNode(element.props.children, options, context);
     return element;
 }
 /**
@@ -75,9 +74,8 @@ function _renderElement(element, options, context) {
  *
  * @param offset Keeps track of where we are within the wider string we're parsing when we're several calls deep.
  */
-function* _parseString(input, options, context, offset = 0) {
-    let matchedRule = undefined;
-    let matchedResult = undefined;
+function* _parseString(input, options, outerContext, offset = 0) {
+    let element = undefined;
     let highPriority = Number.MIN_SAFE_INTEGER;
     let lowIndex = Number.MIN_SAFE_INTEGER;
     // Loop through all rules in the list and see if any match.
@@ -85,15 +83,14 @@ function* _parseString(input, options, context, offset = 0) {
         // Only apply this rule if both:
         // 1. The priority is equal or higher to the current priority.
         // 2. The rule is allowed in the current context.
-        const { priority } = rule;
-        if (rule.priority >= highPriority && rule.contexts.includes(context)) {
-            const result = rule.match(input, options);
-            if (result) {
+        const { priority = 0, contexts } = rule;
+        if (priority >= highPriority && contexts.includes(outerContext)) {
+            const match = rule.match(input, options);
+            if (match) {
                 // Use the match if it has length and is earlier in the string or is higher priority.
-                const { 0: { length } = "", index } = result;
-                if (length && (index < lowIndex || rule.priority > highPriority)) {
-                    matchedRule = rule;
-                    matchedResult = result;
+                const { index, length } = match;
+                if (length && (index < lowIndex || priority > highPriority)) {
+                    element = match;
                     highPriority = priority;
                     lowIndex = index;
                 }
@@ -101,24 +98,22 @@ function* _parseString(input, options, context, offset = 0) {
         }
     }
     // Did at least one rule match?
-    if (matchedRule && matchedResult) {
+    if (element) {
         // If index is more than zero, then the string before the match may match another rule at lower priority.
         const prefix = input.slice(0, lowIndex);
         if (prefix.length)
-            yield* _parseString(prefix, options, context, offset);
+            yield* _parseString(prefix, options, outerContext, offset);
         // Call the rule's `render()` function to generate the node.
         // React gets annoyed if we don't set a `key:` property on lists of elements.
         // We use the string offset as the `.key` property in the element because it's cheap to calculate and guaranteed to be unique within the string.
         // Trying to generate an incrementing number would require tracking the number and passing it back and forth through `_parseString()`
-        const { 0: { length } = "", groups, index } = matchedResult;
-        const element = matchedRule.render(groups, options);
+        const { index, length, context } = element;
         element.key = offset + index;
-        const { subcontext } = matchedRule;
-        yield subcontext ? _renderElement(element, options, subcontext) : element;
+        yield context ? _renderElement(element, options, context) : element;
         // Decrement the content.
         const suffix = input.slice(index + length);
         if (suffix.length)
-            yield* _parseString(suffix, options, context, offset + index + length);
+            yield* _parseString(suffix, options, outerContext, offset + index + length);
     }
     else {
         // If nothing matched return the entire string..

package/markup/rule.d.ts

@@ -1,74 +1,48 @@
 import type { MarkupOptions } from "./options.js";
 import type { ImmutableArray } from "../util/array.js";
-import type { Data } from "../util/data.js";
 import type { JSXElement } from "../util/jsx.js";
-import type { NamedRegExp, NamedRegExpArray, NamedRegExpData } from "../util/regexp.js";
-export type MarkupRuleMatch<T extends Data = Data> = {
-    0: string;
+import type { NamedRegExp, NamedRegExpData, TypedRegExp, TypedRegExpExecArray } from "../util/regexp.js";
+export type MarkupElement = {
+    /** String index where this element was matched in the input string. */
     index: number;
-    groups?: T;
-};
-export declare abstract class MarkupRule {
+    /** String length where this element was matched in the input string. */
+    length: number;
+    /** Context for this element's children in the input string, e.g. `"inline"` */
+    context?: string;
+} & JSXElement;
+export interface MarkupRule {
     /**
      * Contexts this rule should be applied in,
      *
      * @example `["block", "inline", "list"]`
      */
     readonly contexts: ImmutableArray<string>;
-    /**
-     * Context that children should be rendered with.
-     *
-     * @example `"inline"` // Children of the element rendered by this rule will be parsed against markup rules applied in the "inline" context.
-     */
-    readonly subcontext: string | null;
     /**
      * Priority for this rule (defaults to zero).
      *
      * @example e.g. `<p>` rule is lower priority than other blocks so it matches last and paragraphs can be interrupted by e.g. `<ul>` and `<blockquote>`.
      * @example e.g. `<code>` rule is higher priority than other inlines so e.g. `<strong>` or `<em>` don't match inside a code block.
      */
-    readonly priority: number;
-    constructor(contexts: ImmutableArray<string>, //
-    subcontext?: string | null, priority?: number);
-    /** Match an input string against this  */
-    abstract match(input: string, options: MarkupOptions): MarkupRuleMatch | null;
-    /** Render the JSX element for this rule using the props matched by `.match` */
-    abstract render(props: Data | undefined, options: MarkupOptions): JSXElement;
+    readonly priority?: number | undefined;
+    /** Match an input string against this and return an element if there was a match. */
+    match(input: string, options: MarkupOptions): MarkupElement | undefined;
 }
-export declare class RegExpMarkupRule extends MarkupRule {
-    readonly regexp: RegExp;
-    readonly render: (props: Data, options: MarkupOptions) => JSXElement;
-    constructor(regexp: RegExp, //
-    render: (props: Data, options: MarkupOptions) => JSXElement, contexts: ImmutableArray<string>, subcontext?: string | null, priority?: number);
-    match(input: string): MarkupRuleMatch | null;
-}
-export declare class NamedRegExpMarkupRule<T extends NamedRegExpData> extends MarkupRule {
-    readonly regexp: NamedRegExp<T>;
-    readonly render: (props: T, options: MarkupOptions) => JSXElement;
-    constructor(regexp: NamedRegExp<T>, //
-    render: (props: T, options: MarkupOptions) => JSXElement, contexts: ImmutableArray<string>, subcontext?: string | null, priority?: number);
-    match(input: string): NamedRegExpArray<T> | null;
-}
-export declare class LinkRegExpMarkupRule extends MarkupRule {
-    readonly regexp: NamedRegExp<{
+export declare function getMarkupRule<T extends string = string>(regexp: TypedRegExp<T>, //
+render: (props: TypedRegExpExecArray<T>, options: MarkupOptions) => JSXElement, contexts: ImmutableArray<string>, priority?: number): MarkupRule & {
+    regexp: TypedRegExp<T>;
+};
+export declare function getNamedMarkupRule<T extends NamedRegExpData>(regexp: NamedRegExp<T>, //
+render: (data: T, options: MarkupOptions) => JSXElement, contexts: ImmutableArray<string>, priority?: number): MarkupRule & {
+    regexp: NamedRegExp<T>;
+};
+export declare function getLinkMarkupRule(regexp: NamedRegExp<{
+    title?: string;
+    href: string;
+}>, //
+render: (title: string, href: string, options: MarkupOptions) => JSXElement, contexts: ImmutableArray<string>, priority?: number): MarkupRule & {
+    regexp: NamedRegExp<{
         title?: string;
         href: string;
     }>;
-    readonly render: (props: {
-        title: string;
-        href: string;
-    }, options: MarkupOptions) => JSXElement;
-    constructor(regexp: NamedRegExp<{
-        title?: string;
-        href: string;
-    }>, //
-    render: (props: {
-        title: string;
-        href: string;
-    }, options: MarkupOptions) => JSXElement, contexts: ImmutableArray<string>, subcontext?: string | null, priority?: number);
-    match(input: string, { schemes, url: base }: MarkupOptions): MarkupRuleMatch<{
-        title: string;
-        href: string;
-    }> | null;
-}
+};
 export type MarkupRules = MarkupRule[];

package/markup/rule.js

@@ -1,79 +1,49 @@
 import { formatURL, getOptionalURL } from "../util/url.js";
-export class MarkupRule {
-    /**
-     * Contexts this rule should be applied in,
-     *
-     * @example `["block", "inline", "list"]`
-     */
-    contexts;
-    /**
-     * Context that children should be rendered with.
-     *
-     * @example `"inline"` // Children of the element rendered by this rule will be parsed against markup rules applied in the "inline" context.
-     */
-    subcontext;
-    /**
-     * Priority for this rule (defaults to zero).
-     *
-     * @example e.g. `<p>` rule is lower priority than other blocks so it matches last and paragraphs can be interrupted by e.g. `<ul>` and `<blockquote>`.
-     * @example e.g. `<code>` rule is higher priority than other inlines so e.g. `<strong>` or `<em>` don't match inside a code block.
-     */
-    priority;
-    constructor(contexts, //
-    subcontext = null, priority = 0) {
-        this.contexts = contexts;
-        this.subcontext = subcontext;
-        this.priority = priority;
-    }
-}
-export class RegExpMarkupRule extends MarkupRule {
-    regexp;
-    render;
-    constructor(regexp, //
-    render, contexts, subcontext, priority) {
-        super(contexts, subcontext, priority);
-        this.regexp = regexp;
-        this.render = render;
-    }
-    match(input) {
-        return this.regexp.exec(input);
-    }
+export function getMarkupRule(regexp, //
+render, contexts, priority) {
+    return {
+        regexp,
+        match(input, options) {
+            const match = regexp.exec(input);
+            if (match) {
+                const { index, 0: { length }, } = match;
+                return { index, length, ...render(match, options) };
+            }
+        },
+        contexts,
+        priority,
+    };
 }
-export class NamedRegExpMarkupRule extends MarkupRule {
-    regexp;
-    render;
-    constructor(regexp, //
-    render, contexts, subcontext, priority) {
-        super(contexts, subcontext, priority);
-        this.regexp = regexp;
-        this.render = render;
-    }
-    match(input) {
-        return this.regexp.exec(input);
-    }
+export function getNamedMarkupRule(regexp, //
+render, contexts, priority) {
+    return {
+        regexp,
+        match(input, options) {
+            const match = regexp.exec(input);
+            if (match) {
+                const { index, 0: { length }, groups, } = match;
+                return { index, length, ...render(groups, options) };
+            }
+        },
+        contexts,
+        priority,
+    };
 }
-export class LinkRegExpMarkupRule extends MarkupRule {
-    regexp;
-    render;
-    constructor(regexp, //
-    render, contexts, subcontext, priority) {
-        super(contexts, subcontext, priority);
-        this.regexp = regexp;
-        this.render = render;
-    }
-    // Validates that the link is a valid URL (using `getOptionalURL()` to resolve relative links relative to `options.url`).
-    // Validates that the link's URL scheme is in the `options.schemes` whitelist (defaults to `http` and `https`).
-    // Generates a default title for the link using `formatURL()` (e.g. `shax.com/my/dir`).
-    match(input, { schemes, url: base }) {
-        const match = this.regexp.exec(input);
-        if (match) {
-            const { 0: first, index, groups } = match;
-            const { href, title } = groups;
-            const url = getOptionalURL(href, base);
-            if (url && schemes.includes(url.protocol)) {
-                return { 0: first, index, groups: { href: url.href, title: title?.trim() || formatURL(url) } };
+export function getLinkMarkupRule(regexp, //
+render, contexts, priority) {
+    return {
+        regexp,
+        match(input, options) {
+            const match = this.regexp.exec(input);
+            if (match) {
+                const { schemes, url: base } = options;
+                const { 0: { length }, index, groups: { href, title }, } = match;
+                const url = getOptionalURL(href, base);
+                if (url && schemes.includes(url.protocol))
+                    return { index, length, ...render(title?.trim() || formatURL(url), url.href, options) };
             }
-        }
-        return null;
-    }
+        },
+        contexts,
+        priority,
+    };
 }

package/markup/rules.d.ts

@@ -1,17 +1,18 @@
 import type { MarkupOptions } from "./options.js";
 import type { MarkupRules } from "./rule.js";
-import type { JSXElement } from "../util/jsx.js";
-import { LinkRegExpMarkupRule, NamedRegExpMarkupRule, RegExpMarkupRule } from "./rule.js";
+import type { NamedRegExp } from "../util/regexp.js";
 /**
  * Headings are single line only (don't allow multiline).
  * - 1-6 hashes then 1+ spaces, then the title.
  * - Same as Markdown syntax.
  * - Markdown's underline syntax is not supported (for simplification).
  */
-export declare const HEADING_RULE: NamedRegExpMarkupRule<{
-    prefix: string;
-    heading: string;
-}>;
+export declare const HEADING_RULE: import("./rule.js").MarkupRule & {
+    regexp: NamedRegExp<{
+        prefix: string;
+        heading: string;
+    }>;
+};
 /**
  * Separator (horizontal rule / thematic break).
  * - Same as Markdown syntax but also allows `•` bullet character (in addition to `-` dash, `+` plus, `*` asterisk, `_` underscore).
@@ -19,16 +20,24 @@ export declare const HEADING_RULE: NamedRegExpMarkupRule<{
  * - Character must be the same every time (can't mix)
  * - Might have infinite number of spaces between the characters.
  */
-export declare const SEPARATOR_RULE: RegExpMarkupRule;
-export declare const UNORDERED_RULE: NamedRegExpMarkupRule<{
-    list: string;
-}>;
-export declare const ORDERED_RULE: NamedRegExpMarkupRule<{
-    list: string;
-}>;
-export declare const BLOCKQUOTE_RULE: NamedRegExpMarkupRule<{
-    quote: string;
-}>;
+export declare const SEPARATOR_RULE: import("./rule.js").MarkupRule & {
+    regexp: import("../util/regexp.js").TypedRegExp<string>;
+};
+export declare const UNORDERED_RULE: import("./rule.js").MarkupRule & {
+    regexp: NamedRegExp<{
+        list: string;
+    }>;
+};
+export declare const ORDERED_RULE: import("./rule.js").MarkupRule & {
+    regexp: NamedRegExp<{
+        list: string;
+    }>;
+};
+export declare const BLOCKQUOTE_RULE: import("./rule.js").MarkupRule & {
+    regexp: NamedRegExp<{
+        quote: string;
+    }>;
+};
 /**
  * Fenced code blocks
  * - Same as Markdown syntax.
@@ -36,23 +45,35 @@ export declare const BLOCKQUOTE_RULE: NamedRegExpMarkupRule<{
  * - If there's no closing fence the code block will run to the end of the current string.
  * - Markdown-style four-space indent syntax is not supported (only fenced code, since it's easier to use).
  */
-export declare const FENCED_CODE_RULE: NamedRegExpMarkupRule<{
-    wrap: string;
-    title?: string;
-    code: string;
-}>;
+export declare const FENCED_CODE_RULE: import("./rule.js").MarkupRule & {
+    regexp: NamedRegExp<{
+        wrap: string;
+        title?: string;
+        code: string;
+    }>;
+};
 /**
  * Paragraph.
  * - When ordering rules, paragraph should go after other "block" context elements (because it has a very generous capture).
  */
-export declare const PARAGRAPH_RULE: NamedRegExpMarkupRule<{
-    paragraph: string;
-}>;
+export declare const PARAGRAPH_RULE: import("./rule.js").MarkupRule & {
+    regexp: NamedRegExp<{
+        paragraph: string;
+    }>;
+};
 /** Render function for URL and LINK rules. */
-export declare function renderLinkRule({ href, title }: {
-    title: string;
-    href: string;
-}, { rel }: MarkupOptions): JSXElement;
+export declare function renderLinkRule(title: string, href: string, { rel }: MarkupOptions): {
+    type: string;
+    key: null;
+    ref: null;
+    $$typeof: symbol;
+    props: {
+        children: string;
+        href: string;
+        rel: string | undefined;
+    };
+    context: string;
+};
 /**
  * Autolinked URL starts with `http:` or `https:` or `mailto:` (any scheme in `options.schemes`) and matches an unlimited number of non-space characters.
  * - If followed by space and then text in `()` round or `[]` square brackets that will be used as the title, e.g. `http://google.com/maps (Google Maps)` or `http://google.com/maps [Google Maps]` (this syntax is from Todoist and maybe other things too).
@@ -60,7 +81,12 @@ export declare function renderLinkRule({ href, title }: {
  * - If link is not valid (using `new URL(url)` then unparsed text will be returned.
  * - For security only schemes that appear in `options.schemes` will match (defaults to `http:` and `https:`).
  */
-export declare const URL_RULE: LinkRegExpMarkupRule;
+export declare const URL_RULE: import("./rule.js").MarkupRule & {
+    regexp: NamedRegExp<{
+        title?: string;
+        href: string;
+    }>;
+};
 /**
  * Markdown-style link.
  * - Link in standard Markdown format, e.g. `[Google Maps](http://google.com/maps)`
@@ -69,7 +95,12 @@ export declare const URL_RULE: LinkRegExpMarkupRule;
  * - 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_RULE: LinkRegExpMarkupRule;
+export declare const LINK_RULE: import("./rule.js").MarkupRule & {
+    regexp: NamedRegExp<{
+        title?: string;
+        href: string;
+    }>;
+};
 /**
  * Inline code.
  * - Text surrounded by one or more "`" backtick tilde characters.
@@ -77,9 +108,11 @@ export declare const LINK_RULE: LinkRegExpMarkupRule;
  * - Closing characters must exactly match opening characters.
  * - Same as Markdown syntax.
  */
-export declare const CODE_RULE: NamedRegExpMarkupRule<{
-    code: string;
-}>;
+export declare const CODE_RULE: import("./rule.js").MarkupRule & {
+    regexp: NamedRegExp<{
+        code: string;
+    }>;
+};
 /**
  * Inline strong, emphasis, insert, delete, highlight.
  * - Inline strong text wrapped in one or more `*` asterisks.
@@ -102,11 +135,13 @@ declare const INLINE_CHARS: {
     "=": string;
     ":": string;
 };
-export declare const INLINE_RULE: NamedRegExpMarkupRule<{
-    char: keyof typeof INLINE_CHARS;
-    wrap: string;
-    text: string;
-}>;
+export declare const INLINE_RULE: import("./rule.js").MarkupRule & {
+    regexp: NamedRegExp<{
+        char: keyof typeof INLINE_CHARS;
+        wrap: string;
+        text: string;
+    }>;
+};
 /**
  * Hard linebreak (`<br />` tag).
  * - Any line break in a paragraph will become a hard `<br />` tag.
@@ -115,7 +150,9 @@ export declare const INLINE_RULE: NamedRegExpMarkupRule<{
  *   - This is more intuitive (a linebreak becomes a linebreak is isn't silently ignored).
  *   - This works better with textareas that wrap text (since manually breaking up long lines is no longer necessary).
  */
-export declare const LINEBREAK_RULE: RegExpMarkupRule;
+export declare const LINEBREAK_RULE: import("./rule.js").MarkupRule & {
+    regexp: import("../util/regexp.js").TypedRegExp<string>;
+};
 /**
  * All markup rules.
  * - Syntax parsed by `renderMarkup()` is defined entirely by the list of rules (i.e. not by code).

package/markup/rules.js

@@ -1,7 +1,6 @@
-/* eslint-disable import/export */
 import { getRegExp } from "../util/regexp.js";
 import { BLOCK_REGEXP, LINE_REGEXP, WordRegExp, getBlockRegExp, getLineRegExp } from "./regexp.js";
-import { LinkRegExpMarkupRule, NamedRegExpMarkupRule, RegExpMarkupRule } from "./rule.js";
+import { getLinkMarkupRule, getMarkupRule, getNamedMarkupRule } from "./rule.js";
 /** React security symbol — see https://github.com/facebook/react/pull/4832 */
 const $$typeof = Symbol.for("react.element");
 /**
@@ -10,13 +9,14 @@ const $$typeof = Symbol.for("react.element");
  * - Same as Markdown syntax.
  * - Markdown's underline syntax is not supported (for simplification).
  */
-export const HEADING_RULE = new NamedRegExpMarkupRule(getLineRegExp(`(?<prefix>#{1,6}) +(?<heading>${LINE_REGEXP.source})`), ({ prefix, heading }) => ({
+export const HEADING_RULE = getNamedMarkupRule(getLineRegExp(`(?<prefix>#{1,6}) +(?<heading>${LINE_REGEXP.source})`), ({ prefix, heading }) => ({
     type: `h${prefix.length}`,
     key: null,
     ref: null,
     $$typeof,
     props: { children: heading.trim() },
-}), ["block"], "inline");
+    context: "inline",
+}), ["block"]);
 /**
  * Separator (horizontal rule / thematic break).
  * - Same as Markdown syntax but also allows `•` bullet character (in addition to `-` dash, `+` plus, `*` asterisk, `_` underscore).
@@ -24,7 +24,7 @@ export const HEADING_RULE = new NamedRegExpMarkupRule(getLineRegExp(`(?<prefix>#
  * - Character must be the same every time (can't mix)
  * - Might have infinite number of spaces between the characters.
  */
-export const SEPARATOR_RULE = new RegExpMarkupRule(getLineRegExp("([-*•+_=])(?: *\\1){2,}"), () => ({
+export const SEPARATOR_RULE = getMarkupRule(getLineRegExp("([-*•+_=])(?: *\\1){2,}"), () => ({
     type: "hr",
     key: null,
     ref: null,
@@ -41,13 +41,14 @@ export const SEPARATOR_RULE = new RegExpMarkupRule(getLineRegExp("([-*•+_=])(?
 const UNORDERED_PREFIX = "[-*•+] +";
 const UNORDERED_SPLIT = new RegExp(`(?:^|\n)+${UNORDERED_PREFIX}`, "g");
 const UNORDERED_INDENT = /^\t/gm;
-export const UNORDERED_RULE = new NamedRegExpMarkupRule(getBlockRegExp(`(?<list>${UNORDERED_PREFIX}${BLOCK_REGEXP.source})`), ({ list }) => ({
+export const UNORDERED_RULE = getNamedMarkupRule(getBlockRegExp(`(?<list>${UNORDERED_PREFIX}${BLOCK_REGEXP.source})`), ({ list }) => ({
     type: "ul",
     key: null,
     ref: null,
     $$typeof,
     props: { children: list.split(UNORDERED_SPLIT).filter(Boolean).map(_mapUnordered) },
-}), ["block", "list"], "list");
+    context: "list",
+}), ["block", "list"]);
 const _mapUnordered = (item, key) => ({
     type: "li",
     key,
@@ -63,13 +64,14 @@ const _mapUnordered = (item, key) => ({
 const ORDERED_PREFIX = "[1-9][0-9]{0,8}[.):] +"; // Number for a numbered list, e.g. `1.` or `2)` or `3:`
 const ORDERED_SPLIT = new RegExp(`\n+(?=${ORDERED_PREFIX})`, "g");
 const ORDERED_INDENT = UNORDERED_INDENT;
-export const ORDERED_RULE = new NamedRegExpMarkupRule(getBlockRegExp(`(?<list>${ORDERED_PREFIX}${BLOCK_REGEXP.source})`), ({ list }) => ({
+export const ORDERED_RULE = getNamedMarkupRule(getBlockRegExp(`(?<list>${ORDERED_PREFIX}${BLOCK_REGEXP.source})`), ({ list }) => ({
     type: "ol",
     key: null,
     ref: null,
     $$typeof,
     props: { children: list.split(ORDERED_SPLIT).map(_mapOrdered) },
-}), ["block", "list"], "list");
+    context: "list",
+}), ["block", "list"]);
 const _mapOrdered = (item, key) => ({
     type: "li",
     key,
@@ -91,13 +93,14 @@ const _mapOrdered = (item, key) => ({
  */
 const BLOCKQUOTE_PREFIX = "> *";
 const BLOCKQUOTE_INDENT = new RegExp(`^${BLOCKQUOTE_PREFIX}`, "gm");
-export const BLOCKQUOTE_RULE = new NamedRegExpMarkupRule(getLineRegExp(`(?<quote>${BLOCKQUOTE_PREFIX}${LINE_REGEXP.source}(?:\n${BLOCKQUOTE_PREFIX}${LINE_REGEXP.source})*)`), ({ quote }) => ({
+export const BLOCKQUOTE_RULE = getNamedMarkupRule(getLineRegExp(`(?<quote>${BLOCKQUOTE_PREFIX}${LINE_REGEXP.source}(?:\n${BLOCKQUOTE_PREFIX}${LINE_REGEXP.source})*)`), ({ quote }) => ({
     type: "blockquote",
     key: null,
     ref: null,
     $$typeof,
     props: { children: quote.replace(BLOCKQUOTE_INDENT, "") },
-}), ["block", "list"], "block");
+    context: "block",
+}), ["block", "list"]);
 /**
  * Fenced code blocks
  * - Same as Markdown syntax.
@@ -105,7 +108,7 @@ export const BLOCKQUOTE_RULE = new NamedRegExpMarkupRule(getLineRegExp(`(?<quote
  * - If there's no closing fence the code block will run to the end of the current string.
  * - Markdown-style four-space indent syntax is not supported (only fenced code, since it's easier to use).
  */
-export const FENCED_CODE_RULE = new NamedRegExpMarkupRule(
+export const FENCED_CODE_RULE = getNamedMarkupRule(
 // Matcher has its own end that only stops when it reaches a matching closing fence or the end of the string.
 getLineRegExp(`(?<wrap>\`{3,}|~{3,}) *(?<title>${LINE_REGEXP.source})\n(?<code>${BLOCK_REGEXP.source})`, `(?:\n\\k<wrap>|$)`), ({ title, code }) => ({
     type: "pre",
@@ -121,26 +124,28 @@ getLineRegExp(`(?<wrap>\`{3,}|~{3,}) *(?<title>${LINE_REGEXP.source})\n(?<code>$
             props: { title: title?.trim() || undefined, children: code.trim() },
         },
     },
-}), ["block", "list"], null, 10);
+}), ["block", "list"], 10);
 /**
  * Paragraph.
  * - When ordering rules, paragraph should go after other "block" context elements (because it has a very generous capture).
  */
-export const PARAGRAPH_RULE = new NamedRegExpMarkupRule(getBlockRegExp(`(?<paragraph>${BLOCK_REGEXP.source})`), ({ paragraph }) => ({
+export const PARAGRAPH_RULE = getNamedMarkupRule(getBlockRegExp(`(?<paragraph>${BLOCK_REGEXP.source})`), ({ paragraph }) => ({
     type: `p`,
     key: null,
     ref: null,
     $$typeof,
     props: { children: paragraph.trim() },
-}), ["block"], "inline", -10);
+    context: "inline",
+}), ["block"], -10);
 /** Render function for URL and LINK rules. */
-export function renderLinkRule({ href, title }, { rel }) {
+export function renderLinkRule(title, href, { rel }) {
     return {
         type: "a",
         key: null,
         ref: null,
         $$typeof,
         props: { children: title, href, rel },
+        context: "link",
     };
 }
 /**
@@ -150,8 +155,8 @@ export function renderLinkRule({ href, title }, { rel }) {
  * - If link is not valid (using `new URL(url)` then unparsed text will be returned.
  * - For security only schemes that appear in `options.schemes` will match (defaults to `http:` and `https:`).
  */
-export const URL_RULE = new LinkRegExpMarkupRule(getRegExp(/(?<href>[a-z]+:[-$_@.&!*,=;/#?:%a-zA-Z0-9]+)(?: +(?:\((?<title>[^)]*?)\)))?/), //
-renderLinkRule, ["inline", "list"], "link");
+export const URL_RULE = getLinkMarkupRule(getRegExp(/(?<href>[a-z]+:[-$_@.&!*,=;/#?:%a-zA-Z0-9]+)(?: +(?:\((?<title>[^)]*?)\)))?/), //
+renderLinkRule, ["inline", "list"]);
 /**
  * Markdown-style link.
  * - Link in standard Markdown format, e.g. `[Google Maps](http://google.com/maps)`
@@ -160,8 +165,8 @@ renderLinkRule, ["inline", "list"], "link");
  * - 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_RULE = new LinkRegExpMarkupRule(getRegExp(/\[(?<title>[^\]]*?)\]\((?<href>[^)]*?)\)/), //
-renderLinkRule, ["inline", "list"], "link");
+export const LINK_RULE = getLinkMarkupRule(getRegExp(/\[(?<title>[^\]]*?)\]\((?<href>[^)]*?)\)/), //
+renderLinkRule, ["inline", "list"]);
 /**
  * Inline code.
  * - Text surrounded by one or more "`" backtick tilde characters.
@@ -169,13 +174,13 @@ renderLinkRule, ["inline", "list"], "link");
  * - Closing characters must exactly match opening characters.
  * - Same as Markdown syntax.
  */
-export const CODE_RULE = new NamedRegExpMarkupRule(new RegExp(`(?<wrap>\`+)(?<code>${BLOCK_REGEXP.source})\\k<wrap>`), ({ code }) => ({
+export const CODE_RULE = getNamedMarkupRule(new RegExp(`(?<wrap>\`+)(?<code>${BLOCK_REGEXP.source})\\k<wrap>`), ({ code }) => ({
     type: "code",
     key: null,
     ref: null,
     $$typeof,
     props: { children: code },
-}), ["inline", "list"], null, 10);
+}), ["inline", "list"], 10);
 /**
  * Inline strong, emphasis, insert, delete, highlight.
  * - Inline strong text wrapped in one or more `*` asterisks.
@@ -190,14 +195,15 @@ export const CODE_RULE = new NamedRegExpMarkupRule(new RegExp(`(?<wrap>\`+)(?<co
  * - Different to Markdown: strong is always surrounded by `*asterisks*` and emphasis is always surrounded by `_underscores_` (strong isn't 'double emphasis').
  */
 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 = new NamedRegExpMarkupRule(new WordRegExp(`(?<wrap>(?<char>[${Object.keys(INLINE_CHARS).join("")}])+)(?<text>(?!\\k<char>)\\S|(?!\\k<char>)\\S[\\s\\S]*?(?!\\k<char>)\\S)\\k<wrap>`), // prettier-ignore
+export const INLINE_RULE = getNamedMarkupRule(new WordRegExp(`(?<wrap>(?<char>[${Object.keys(INLINE_CHARS).join("")}])+)(?<text>(?!\\k<char>)\\S|(?!\\k<char>)\\S[\\s\\S]*?(?!\\k<char>)\\S)\\k<wrap>`), // prettier-ignore
 ({ char, text }) => ({
     type: INLINE_CHARS[char],
     key: null,
     ref: null,
     $$typeof,
     props: { children: text },
-}), ["inline", "list", "link"], "inline");
+    context: "inline",
+}), ["inline", "list", "link"]);
 /**
  * Hard linebreak (`<br />` tag).
  * - Any line break in a paragraph will become a hard `<br />` tag.
@@ -206,13 +212,13 @@ export const INLINE_RULE = new NamedRegExpMarkupRule(new WordRegExp(`(?<wrap>(?<
  *   - This is more intuitive (a linebreak becomes a linebreak is isn't silently ignored).
  *   - This works better with textareas that wrap text (since manually breaking up long lines is no longer necessary).
  */
-export const LINEBREAK_RULE = new RegExpMarkupRule(/\n/, () => ({
+export const LINEBREAK_RULE = getMarkupRule(/\n/, () => ({
     type: "br",
     key: null,
     ref: null,
     $$typeof,
     props: {},
-}), ["inline", "list", "link"], "inline");
+}), ["inline", "list", "link"]);
 /**
  * All markup rules.
  * - Syntax parsed by `renderMarkup()` is defined entirely by the list of rules (i.e. not by code).

package/package.json

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

package/util/regexp.d.ts

@@ -6,18 +6,6 @@ export declare const ALWAYS_REGEXP: RegExp;
 export declare const NEVER_REGEXP: RegExp;
 /** Things that can be convert to a regular expression. */
 export type PossibleRegExp = string | RegExp;
-/** Set of named match groups from a regular expression. */
-export type NamedRegExpData = {
-    [named: string]: string;
-};
-/** Regular expression match array that you've asserted contains the specified named groups. */
-export interface NamedRegExpArray<T extends NamedRegExpData = NamedRegExpData> extends RegExpExecArray {
-    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;
-}
 /** Is an unknown value a `RegExp` instance? */
 export declare const isRegExp: (value: unknown) => value is RegExp;
 /** Assert that an unknown value is a `RegExp` instance. */
@@ -39,3 +27,23 @@ export declare function getAllRegExp(patterns: Iterable<PossibleRegExp> & NotStr
 export declare const isRegExpMatch: Match<[item: string, target: RegExp]>;
 /** Match function for finding strings that match against regular expressions (use with `filter()` to negatively filter iterable sets of items). */
 export declare const notRegExpMatch: Match<[item: string, target: RegExp]>;
+/** Regular expression match array that you've asserted contains the specified named groups. */
+export interface TypedRegExpExecArray<T extends string = string> extends RegExpExecArray {
+    0: T;
+}
+/** Regular expression that you've asserted contains the specified named capture groups. */
+export interface TypedRegExp<T extends string = string> extends RegExp {
+    exec(input: string): TypedRegExpExecArray<T> | null;
+}
+/** Set of named match groups from a regular expression. */
+export type NamedRegExpData = {
+    [named: string]: string;
+};
+/** Regular expression match array that you've asserted contains the specified named groups. */
+export interface NamedRegExpExecArray<T extends NamedRegExpData = NamedRegExpData> extends RegExpExecArray {
+    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): NamedRegExpExecArray<T> | null;
+}