shelving 1.86.1 → 1.86.3

package/constraint/Constraints.js

@@ -1,3 +1,4 @@
+import { getPrototype } from "../util/object.js";
 import { withArrayItems, omitArrayItems } from "../util/array.js";
 import { Constraint } from "./Constraint.js";
 /** Type of Rule that is powered by several sub-constraints (e.g. `Filters` and `Sorts` and `Query` itself extend this). */
@@ -21,12 +22,12 @@ export class Constraints extends Constraint {
     /** Clone this set of constraints but add additional constraints. */
     with(...constraints) {
         const _constraints = withArrayItems(this._constraints, ...constraints);
-        return _constraints !== this._constraints ? { __proto__: Object.getPrototypeOf(this), ...this, _constraints: _constraints } : this;
+        return _constraints !== this._constraints ? { __proto__: getPrototype(this), ...this, _constraints: _constraints } : this;
     }
     /** Clone this set of constraints but remove specific constraints. */
     omit(...constraints) {
         const _constraints = omitArrayItems(this._constraints, ...constraints);
-        return _constraints !== this._constraints ? { __proto__: Object.getPrototypeOf(this), ...this, _constraints: _constraints } : this;
+        return _constraints !== this._constraints ? { __proto__: getPrototype(this), ...this, _constraints: _constraints } : this;
     }
     /** Iterate over the constraints. */
     [Symbol.iterator]() {

package/constraint/QueryConstraints.d.ts

@@ -31,7 +31,7 @@ export declare class QueryConstraints<T extends Data = Data> extends Constraint<
     readonly filters: FilterConstraints<T>;
     readonly sorts: SortConstraints<T>;
     readonly limit: number | null;
-    constructor(filters?: FilterList<Partial<T>>, sorts?: SortList<Partial<T>>, limit?: number | null);
+    constructor(filters?: FilterList<Partial<T>> | FilterConstraints<T>, sorts?: SortList<Partial<T>> | SortConstraints<T>, limit?: number | null);
     filter(...filters: FilterList<Partial<T>>[]): this;
     get unfilter(): this;
     match(item: T): boolean;

package/constraint/QueryConstraints.js

@@ -1,4 +1,4 @@
-import { getProp } from "../util/object.js";
+import { getProp, getPrototype } from "../util/object.js";
 import { assert } from "../util/assert.js";
 import { limitArray } from "../util/array.js";
 import { FilterConstraints } from "./FilterConstraints.js";
@@ -19,7 +19,7 @@ export class QueryConstraints extends Constraint {
     // Implement `Filterable`
     filter(...filters) {
         return {
-            __proto__: Object.getPrototypeOf(this),
+            __proto__: getPrototype(this),
             ...this,
             filters: this.filters.filter(...filters),
         };
@@ -28,7 +28,7 @@ export class QueryConstraints extends Constraint {
         if (!this.filters.size)
             return this;
         return {
-            __proto__: Object.getPrototypeOf(this),
+            __proto__: getPrototype(this),
             ...this,
             filters: EMPTY_FILTERS,
         };
@@ -39,7 +39,7 @@ export class QueryConstraints extends Constraint {
     // Implement `Sortable`
     sort(...sorts) {
         return {
-            __proto__: Object.getPrototypeOf(this),
+            __proto__: getPrototype(this),
             ...this,
             sorts: this.sorts.sort(...sorts),
         };
@@ -48,7 +48,7 @@ export class QueryConstraints extends Constraint {
         if (!this.sorts.size)
             return this;
         return {
-            __proto__: Object.getPrototypeOf(this),
+            __proto__: getPrototype(this),
             ...this,
             sorts: EMPTY_SORTS,
         };
@@ -59,14 +59,14 @@ export class QueryConstraints extends Constraint {
     // Implement `Queryable`
     after(item) {
         return {
-            __proto__: Object.getPrototypeOf(this),
+            __proto__: getPrototype(this),
             ...this,
             filters: this.filters.with(..._getAfterFilters(this.sorts, item)),
         };
     }
     before(item) {
         return {
-            __proto__: Object.getPrototypeOf(this),
+            __proto__: getPrototype(this),
             ...this,
             filters: this.filters.with(..._getBeforeFilters(this.sorts, item)),
         };
@@ -75,7 +75,7 @@ export class QueryConstraints extends Constraint {
         if (this.limit === limit)
             return this;
         return {
-            __proto__: Object.getPrototypeOf(this),
+            __proto__: getPrototype(this),
             ...this,
             limit,
         };

package/error/ThroughError.js

@@ -7,7 +7,7 @@ export class ThroughError extends Error {
     constructor(message, cause) {
         super(message);
         this.cause = cause;
-        this.stack = `${this.stack}\nCause: ${cause instanceof Error ? cause.stack : debug(cause)}`;
+        this.stack = `${this.stack || ""}\nCause: ${cause instanceof Error ? cause.stack || "" : debug(cause)}`;
     }
 }
 ThroughError.prototype.name = "ThroughError";

package/firestore/client/FirestoreClientProvider.js

@@ -1,9 +1,8 @@
-import { orderBy as firestoreOrderBy, where as firestoreWhere, limit as firestoreLimit, increment as firestoreIncrement, arrayUnion as firestoreArrayUnion, arrayRemove as firestoreArrayRemove, deleteField as firestoreDeleteField, collection as firestoreCollection, doc as firestoreDocument, query as firestoreQuery, onSnapshot, addDoc, setDoc, updateDoc, deleteDoc, getDoc, getDocs, } from "firebase/firestore";
+import { documentId as firestoreDocumentId, orderBy as firestoreOrderBy, where as firestoreWhere, limit as firestoreLimit, increment as firestoreIncrement, arrayUnion as firestoreArrayUnion, arrayRemove as firestoreArrayRemove, deleteField as firestoreDeleteField, collection as firestoreCollection, doc as firestoreDocument, query as firestoreQuery, onSnapshot, addDoc, setDoc, updateDoc, deleteDoc, getDoc, getDocs, } from "firebase/firestore";
 import { LazyDeferredSequence } from "../../sequence/LazyDeferredSequence.js";
 import { ArrayUpdate, DataUpdate, Increment, DictionaryUpdate, Delete, Update } from "../../update/index.js";
 // Constants.
-// const ID = "__name__"; // DH: `__name__` is the entire path of the document. `__id__` is just ID.
-const ID = "__id__"; // Internal way Firestore Queries can reference the ID of the current document.
+const ID = firestoreDocumentId();
 // Map `Filter.types` to `WhereFilterOp`
 const OPERATORS = {
     IS: "==",

package/firestore/lite/FirestoreLiteProvider.js

@@ -1,9 +1,10 @@
-import { orderBy as firestoreOrderBy, where as firestoreWhere, limit as firestoreLimit, increment as firestoreIncrement, arrayUnion as firestoreArrayUnion, arrayRemove as firestoreArrayRemove, deleteField as firestoreDeleteField, collection as firestoreCollection, doc as firestoreDocument, query as firestoreQuery, setDoc, addDoc, updateDoc, deleteDoc, getDoc, getDocs, } from "firebase/firestore/lite";
+import { documentId as firestoreDocumentId, orderBy as firestoreOrderBy, where as firestoreWhere, limit as firestoreLimit, increment as firestoreIncrement, arrayUnion as firestoreArrayUnion, arrayRemove as firestoreArrayRemove, deleteField as firestoreDeleteField, collection as firestoreCollection, doc as firestoreDocument, query as firestoreQuery, setDoc, addDoc, updateDoc, deleteDoc, getDoc, getDocs, } from "firebase/firestore/lite";
 import { UnsupportedError } from "../../error/UnsupportedError.js";
 import { ArrayUpdate, DataUpdate, Increment, DictionaryUpdate, Delete, Update } from "../../update/index.js";
 // Constants.
 // const ID = "__name__"; // DH: `__name__` is the entire path of the document. `__id__` is just ID.
-const ID = "__id__"; // Internal way Firestore Queries can reference the ID of the current document.
+// const ID = "__id__"; // Internal way Firestore Queries can reference the ID of the current document.
+const ID = firestoreDocumentId();
 // Map `Filter.types` to `WhereFilterOp`
 const OPERATORS = {
     IS: "==",

package/firestore/server/FirestoreServerProvider.js

@@ -1,9 +1,8 @@
-import { Firestore, FieldValue as FirestoreFieldValue } from "@google-cloud/firestore";
+import { Firestore, FieldValue, FieldPath } from "@google-cloud/firestore";
 import { LazyDeferredSequence } from "../../sequence/LazyDeferredSequence.js";
 import { ArrayUpdate, DataUpdate, Increment, DictionaryUpdate, Delete, Update } from "../../update/index.js";
 // Constants.
-// const ID = "__name__"; // DH: `__name__` is the entire path of the document. `__id__` is just ID.
-const ID = "__id__"; // Internal way Firestore Queries can reference the ID of the current document.
+const ID = FieldPath.documentId();
 // Map `Filter.types` to `WhereFilterOp`
 const OPERATORS = {
     IS: "==",
@@ -53,11 +52,11 @@ function* _getFieldValues(updates, prefix = "") {
         else if (update instanceof ArrayUpdate) {
             if (update.adds.length) {
                 yield `${prefix}${key}`;
-                yield FirestoreFieldValue.arrayUnion(...update.adds);
+                yield FieldValue.arrayUnion(...update.adds);
             }
             if (update.deletes.length) {
                 yield `${prefix}${key}`;
-                yield FirestoreFieldValue.arrayRemove(...update.deletes);
+                yield FieldValue.arrayRemove(...update.deletes);
             }
         }
         else {
@@ -65,9 +64,9 @@ function* _getFieldValues(updates, prefix = "") {
             if (!(update instanceof Update))
                 yield update;
             else if (update instanceof Delete)
-                yield FirestoreFieldValue.delete();
+                yield FieldValue.delete();
             else if (update instanceof Increment)
-                yield FirestoreFieldValue.increment(update.amount);
+                yield FieldValue.increment(update.amount);
             else
                 yield update.transform();
         }

package/markup/index.d.ts

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

package/markup/index.js

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

package/markup/options.d.ts

@@ -1,4 +1,4 @@
-import { MarkupRules } from "./rules.js";
+import type { MarkupRules } from "./rule.js";
 /** The current parsing options (represents the current state of the parsing). */
 export type MarkupOptions = {
     /** The active list of parsing rules. */

package/markup/regexp.d.ts

@@ -2,13 +2,13 @@ import type { Data } from "../util/data.js";
 import { NamedRegExp, NamedRegExpData, 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 type MarkupMatch<T extends Data | undefined = Data | undefined> = {
+export type MarkupMatch<T extends Data | undefined> = {
     0: string;
     index: number;
     groups: T;
 };
 /** Function that matches a string and returns a `MarkupMatch` or `null` or `void` */
-export type MarkupMatcher<T extends Data | undefined = Data | undefined> = (input: string, options: MarkupOptions) => MarkupMatch<T> | null | void;
+export type MarkupMatcher<T extends Data> = (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;

package/markup/render.js

@@ -77,49 +77,48 @@ function _renderElement(element, options, context) {
  */
 function* _parseString(input, options, context, offset = 0) {
     let matchedRule = undefined;
-    let matchedPriority = Number.MIN_SAFE_INTEGER;
-    let matchedIndex = Number.MIN_SAFE_INTEGER;
-    let matchedLength = 0;
-    let matchedGroups = undefined;
+    let matchedResult = 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.
     for (const rule of options.rules) {
         // 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 = 0, match, contexts } = rule;
-        if (priority >= matchedPriority && contexts.includes(context)) {
-            const result = typeof match === "function" ? match(input, options) : match.exec(input);
+        const { priority } = rule;
+        if (rule.priority >= highPriority && rule.contexts.includes(context)) {
+            const result = rule.match(input, options);
             if (result) {
                 // Use the match if it has length and is earlier in the string or is higher priority.
-                const { 0: { length } = "", index, groups } = result;
-                if (length && (index < matchedIndex || priority > matchedPriority)) {
+                const { 0: { length } = "", index } = result;
+                if (length && (index < lowIndex || rule.priority > highPriority)) {
                     matchedRule = rule;
-                    matchedPriority = priority;
-                    matchedIndex = index;
-                    matchedLength = length;
-                    matchedGroups = groups;
+                    matchedResult = result;
+                    highPriority = priority;
+                    lowIndex = index;
                 }
             }
         }
     }
     // Did at least one rule match?
-    if (matchedRule && matchedLength) {
+    if (matchedRule && matchedResult) {
         // If index is more than zero, then the string before the match may match another rule at lower priority.
-        const prefix = input.slice(0, matchedIndex);
+        const prefix = input.slice(0, lowIndex);
         if (prefix.length)
             yield* _parseString(prefix, options, context, 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 { render, subcontext } = matchedRule;
-        const element = render(matchedGroups, options);
-        element.key = offset + matchedIndex;
+        const { 0: { length } = "", groups, index } = matchedResult;
+        const element = matchedRule.render(groups, options);
+        element.key = offset + index;
+        const { subcontext } = matchedRule;
         yield subcontext ? _renderElement(element, options, subcontext) : element;
         // Decrement the content.
-        const suffix = input.slice(matchedIndex + matchedLength);
+        const suffix = input.slice(index + length);
         if (suffix.length)
-            yield* _parseString(suffix, options, context, offset + matchedIndex + matchedLength);
+            yield* _parseString(suffix, options, context, offset + index + length);
     }
     else {
         // If nothing matched return the entire string..

package/markup/rule.d.ts

@@ -0,0 +1,74 @@
+import { NamedRegExp, NamedRegExpArray, NamedRegExpData } from "../util/regexp.js";
+import { Data } from "../util/data.js";
+import { JSXElement } from "../util/jsx.js";
+import { ImmutableArray } from "../util/array.js";
+import { MarkupOptions } from "./options.js";
+export type MarkupRuleMatch<T extends Data = Data> = {
+    0: string;
+    index: number;
+    groups?: T;
+};
+export declare abstract class 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;
+}
+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<{
+        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

@@ -0,0 +1,54 @@
+import { formatURL, getOptionalURL } from "../util/url.js";
+export class MarkupRule {
+    constructor(contexts, //
+    subcontext = null, priority = 0) {
+        this.contexts = contexts;
+        this.subcontext = subcontext;
+        this.priority = priority;
+    }
+}
+export class RegExpMarkupRule extends MarkupRule {
+    constructor(regexp, //
+    render, contexts, subcontext, priority) {
+        super(contexts, subcontext, priority);
+        this.regexp = regexp;
+        this.render = render;
+    }
+    match(input) {
+        return this.regexp.exec(input);
+    }
+}
+export class NamedRegExpMarkupRule extends MarkupRule {
+    constructor(regexp, //
+    render, contexts, subcontext, priority) {
+        super(contexts, subcontext, priority);
+        this.regexp = regexp;
+        this.render = render;
+    }
+    match(input) {
+        return this.regexp.exec(input);
+    }
+}
+export class LinkRegExpMarkupRule extends MarkupRule {
+    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 === null || title === void 0 ? void 0 : title.trim()) || formatURL(url) } };
+            }
+        }
+        return null;
+    }
+}

package/markup/rules.d.ts

@@ -1,49 +1,13 @@
-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";
-/** 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) | MarkupMatcher<T>;
-    /**
-     * Render the JSX element for this rule using the props matched by
-     */
-    readonly render: (orops: T, options: MarkupOptions) => JSXElement;
-    /**
-     * Contexts this rule should be applied in,
-     *
-     * @example `["block", "inline", "list"]`
-     */
-    readonly contexts: 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;
-    /**
-     * 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;
-}
-/** Any markup rule. */
-export type AnyMarkupRule = MarkupRule<any>;
-/** A set of markup rules (as an object or array). */
-export type MarkupRules = AnyMarkupRule[];
+import { LinkRegExpMarkupRule, MarkupRules, NamedRegExpMarkupRule, RegExpMarkupRule } from "./rule.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: MarkupRule<{
+export declare const HEADING_RULE: NamedRegExpMarkupRule<{
     prefix: string;
     heading: string;
 }>;
@@ -54,14 +18,14 @@ export declare const HEADING_RULE: MarkupRule<{
  * - Character must be the same every time (can't mix)
  * - Might have infinite number of spaces between the characters.
  */
-export declare const SEPARATOR_RULE: MarkupRule;
-export declare const UNORDERED_RULE: MarkupRule<{
+export declare const SEPARATOR_RULE: RegExpMarkupRule;
+export declare const UNORDERED_RULE: NamedRegExpMarkupRule<{
     list: string;
 }>;
-export declare const ORDERED_RULE: MarkupRule<{
+export declare const ORDERED_RULE: NamedRegExpMarkupRule<{
     list: string;
 }>;
-export declare const BLOCKQUOTE_RULE: MarkupRule<{
+export declare const BLOCKQUOTE_RULE: NamedRegExpMarkupRule<{
     quote: string;
 }>;
 /**
@@ -71,7 +35,7 @@ export declare const BLOCKQUOTE_RULE: MarkupRule<{
  * - 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: MarkupRule<{
+export declare const FENCED_CODE_RULE: NamedRegExpMarkupRule<{
     wrap: string;
     title?: string;
     code: string;
@@ -80,23 +44,14 @@ export declare const FENCED_CODE_RULE: MarkupRule<{
  * Paragraph.
  * - When ordering rules, paragraph should go after other "block" context elements (because it has a very generous capture).
  */
-export declare const PARAGRAPH_RULE: MarkupRule<{
+export declare const PARAGRAPH_RULE: NamedRegExpMarkupRule<{
     paragraph: string;
 }>;
-/**
- * Function that checks a link against the schemas allowed by rendering.
- * - Used by `URL_RULE~ and `LINK_RULE`
- * - 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`).
- */
-export declare function getLinkMatcher(regexp: NamedRegExp<{
-    title?: string;
-    href: string;
-}>): MarkupMatcher<{
+/** Render function for URL and LINK rules. */
+export declare function renderLinkRule({ href, title }: {
     title: string;
     href: string;
-}>;
+}, { rel }: MarkupOptions): JSXElement;
 /**
  * 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).
@@ -104,14 +59,7 @@ export declare function getLinkMatcher(regexp: NamedRegExp<{
  * - 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_REGEXP: NamedRegExp<{
-    title?: string;
-    href: string;
-}>;
-export declare const URL_RULE: MarkupRule<{
-    title: string;
-    href: string;
-}>;
+export declare const URL_RULE: LinkRegExpMarkupRule;
 /**
  * Markdown-style link.
  * - Link in standard Markdown format, e.g. `[Google Maps](http://google.com/maps)`
@@ -120,14 +68,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_REGEXP: NamedRegExp<{
-    title: string;
-    href: string;
-}>;
-export declare const LINK_RULE: MarkupRule<{
-    title: string;
-    href: string;
-}>;
+export declare const LINK_RULE: LinkRegExpMarkupRule;
 /**
  * Inline code.
  * - Text surrounded by one or more "`" backtick tilde characters.
@@ -135,7 +76,7 @@ export declare const LINK_RULE: MarkupRule<{
  * - Closing characters must exactly match opening characters.
  * - Same as Markdown syntax.
  */
-export declare const CODE_RULE: MarkupRule<{
+export declare const CODE_RULE: NamedRegExpMarkupRule<{
     code: string;
 }>;
 /**
@@ -160,7 +101,7 @@ declare const INLINE_CHARS: {
     "=": string;
     ":": string;
 };
-export declare const INLINE_RULE: MarkupRule<{
+export declare const INLINE_RULE: NamedRegExpMarkupRule<{
     char: keyof typeof INLINE_CHARS;
     wrap: string;
     text: string;
@@ -173,7 +114,7 @@ export declare const INLINE_RULE: MarkupRule<{
  *   - 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: MarkupRule;
+export declare const LINEBREAK_RULE: RegExpMarkupRule;
 /**
  * All markup rules.
  * - Syntax parsed by `renderMarkup()` is defined entirely by the list of rules (i.e. not by code).