shelving 1.86.0 → 1.86.2

package/api/Resource.d.ts

@@ -27,9 +27,9 @@ export declare class Resource<P = unknown, R = void> implements Validatable<R> {
     validate(unsafeResult: unknown): R;
 }
 /** Extract the payload type from a `Resource`. */
-export declare type PayloadType<X extends Resource> = X extends Resource<infer Y, unknown> ? Y : never;
+export type PayloadType<X extends Resource> = X extends Resource<infer Y, unknown> ? Y : never;
 /** Extract the result type from a `Resource`. */
-export declare type ResourceType<X extends Resource> = X extends Resource<unknown, infer Y> ? Y : never;
+export type ResourceType<X extends Resource> = X extends Resource<unknown, infer Y> ? Y : never;
 /**
  * Shortcut to create a new `Resource` (consistent with `Schema` shortcuts.
  * - Sets `undefined` as the default type for payload and result.

package/constraint/Constraints.js

@@ -1,11 +1,8 @@
+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). */
 export class Constraints extends Constraint {
-    constructor(...constraints) {
-        super();
-        this._constraints = constraints;
-    }
     /** Get the first constraint. */
     get first() {
         return this._constraints[0];
@@ -18,15 +15,19 @@ export class Constraints extends Constraint {
     get size() {
         return this._constraints.length;
     }
+    constructor(...constraints) {
+        super();
+        this._constraints = constraints;
+    }
     /** 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/FilterConstraint.d.ts

@@ -4,11 +4,11 @@ import { ImmutableArray } from "../util/array.js";
 import { Matchable } from "../util/match.js";
 import type { Constraint } from "./Constraint.js";
 /** Possible operator references. */
-export declare type FilterOperator = "IS" | "NOT" | "IN" | "OUT" | "CONTAINS" | "LT" | "LTE" | "GT" | "GTE";
+export type FilterOperator = "IS" | "NOT" | "IN" | "OUT" | "CONTAINS" | "LT" | "LTE" | "GT" | "GTE";
 /** Format that allows filters to be specified as a string, e.g. `!name` means `name is not` and `age>` means `age is more than` and `tags[]` means `tags array contains` */
-export declare type FilterKey<T extends Data> = DataKey<T> | `${DataKey<T>}` | `!${DataKey<T>}` | `${DataKey<T>}[]` | `${DataKey<T>}<` | `${DataKey<T>}<=` | `${DataKey<T>}>` | `${DataKey<T>}>=`;
+export type FilterKey<T extends Data> = DataKey<T> | `${DataKey<T>}` | `!${DataKey<T>}` | `${DataKey<T>}[]` | `${DataKey<T>}<` | `${DataKey<T>}<=` | `${DataKey<T>}>` | `${DataKey<T>}>=`;
 /** Format that allows multiple filters to be specified as a plain object. */
-export declare type FilterProps<T extends Data> = {
+export type FilterProps<T extends Data> = {
     [K in DataKey<T> as `${K}` | `!${K}`]?: T[K] | ImmutableArray<T[K]>;
 } & {
     [K in DataKey<T> as `${K}[]`]?: Required<T>[K] extends ImmutableArray<infer X> ? X : never;
@@ -16,7 +16,7 @@ export declare type FilterProps<T extends Data> = {
     [K in DataKey<T> as `${K}<` | `${K}<=` | `${K}>` | `${K}>=`]?: T[K];
 };
 /** List of filters in a flexible format. */
-export declare type FilterList<T extends Data> = Nullish<FilterProps<T> | FilterConstraint<T>> | Iterable<FilterList<T>>;
+export type FilterList<T extends Data> = Nullish<FilterProps<T> | FilterConstraint<T>> | Iterable<FilterList<T>>;
 /**
  * Filter: filters a list of data.
  *

package/constraint/FilterConstraint.js

@@ -21,6 +21,23 @@ const MATCHERS = {
  * @param value Value the specified property should be matched against.
  */
 export class FilterConstraint {
+    get filterKey() {
+        const { operator, key } = this;
+        if (operator === "NOT" || operator === "OUT")
+            return `!${key}`;
+        else if (operator === "CONTAINS")
+            return `${key}[]`;
+        else if (operator === "LT")
+            return `${key}<`;
+        else if (operator === "LTE")
+            return `${key}<=`;
+        else if (operator === "GT")
+            return `${key}>`;
+        else if (operator === "GTE")
+            return `${key}>=`;
+        else
+            return key;
+    }
     constructor(filterKey, value) {
         if (filterKey.startsWith("!")) {
             this.key = filterKey.slice(1);
@@ -52,23 +69,6 @@ export class FilterConstraint {
         }
         this.value = value;
     }
-    get filterKey() {
-        const { operator, key } = this;
-        if (operator === "NOT" || operator === "OUT")
-            return `!${key}`;
-        else if (operator === "CONTAINS")
-            return `${key}[]`;
-        else if (operator === "LT")
-            return `${key}<`;
-        else if (operator === "LTE")
-            return `${key}<=`;
-        else if (operator === "GT")
-            return `${key}>`;
-        else if (operator === "GTE")
-            return `${key}>=`;
-        else
-            return key;
-    }
     match(item) {
         return MATCHERS[this.operator](item[this.key], this.value);
     }

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/constraint/SortConstraint.d.ts

@@ -4,13 +4,13 @@ import type { Nullish } from "../util/null.js";
 import { Rankable } from "../util/sort.js";
 import type { Constraint } from "./Constraint.js";
 /** Format that allows sorts to be set as a plain string, e.g. `name` sorts by name in ascending order and `!date` sorts by date in descending order. */
-export declare type SortKey<T extends Data> = DataKey<T> | `${DataKey<T>}` | `!${DataKey<T>}`;
+export type SortKey<T extends Data> = DataKey<T> | `${DataKey<T>}` | `!${DataKey<T>}`;
 /** One or more sort keys. */
-export declare type SortKeys<T extends Data> = SortKey<T> | ImmutableArray<SortKey<T>>;
+export type SortKeys<T extends Data> = SortKey<T> | ImmutableArray<SortKey<T>>;
 /** Possible operator references. */
-export declare type SortDirection = "ASC" | "DESC";
+export type SortDirection = "ASC" | "DESC";
 /** List of sorts in a flexible format. */
-export declare type SortList<T extends Data> = Nullish<SortKeys<T> | SortConstraint<T> | Iterable<SortList<T>>>;
+export type SortList<T extends Data> = Nullish<SortKeys<T> | SortConstraint<T> | Iterable<SortList<T>>>;
 /** Sort a list of values. */
 export declare class SortConstraint<T extends Data = Data> implements Constraint<T>, Rankable<T> {
     readonly key: string;

package/constraint/SortConstraint.js

@@ -1,6 +1,9 @@
 import { rank, rankAsc, rankDesc, sortItems } from "../util/sort.js";
 /** Sort a list of values. */
 export class SortConstraint {
+    get sortKey() {
+        return `"${this.direction === "DESC" ? "!" : ""}${this.key}"`;
+    }
     constructor(sortKey) {
         if (sortKey.startsWith("!")) {
             this.key = sortKey.slice(1);
@@ -11,9 +14,6 @@ export class SortConstraint {
             this.direction = "ASC";
         }
     }
-    get sortKey() {
-        return `"${this.direction === "DESC" ? "!" : ""}${this.key}"`;
-    }
     rank(left, right) {
         return rank(left[this.key], this.direction === "ASC" ? rankAsc : rankDesc, right[this.key]);
     }

package/db/Change.d.ts

@@ -33,13 +33,13 @@ export interface DeleteChange<T extends Datas, K extends DataKey<T> = DataKey<T>
     readonly id: string;
 }
 /** Set, update, or delete change on an item. */
-export declare type ItemChange<T extends Datas, K extends DataKey<T> = DataKey<T>> = SetChange<T, K> | UpdateChange<T, K> | DeleteChange<T, K>;
+export type ItemChange<T extends Datas, K extends DataKey<T> = DataKey<T>> = SetChange<T, K> | UpdateChange<T, K> | DeleteChange<T, K>;
 /** Array of item changes. */
-export declare type ItemChanges<T extends Datas, K extends DataKey<T> = DataKey<T>> = ImmutableArray<ItemChange<T, K>>;
+export type ItemChanges<T extends Datas, K extends DataKey<T> = DataKey<T>> = ImmutableArray<ItemChange<T, K>>;
 /** Write change on an item. */
-export declare type WriteChange<T extends Datas, K extends DataKey<T> = DataKey<T>> = ItemChange<T, K> | AddChange<T, K>;
+export type WriteChange<T extends Datas, K extends DataKey<T> = DataKey<T>> = ItemChange<T, K> | AddChange<T, K>;
 /** Array of write changes. */
-export declare type WriteChanges<T extends Datas, K extends DataKey<T> = DataKey<T>> = ImmutableArray<WriteChange<T, K>>;
+export type WriteChanges<T extends Datas, K extends DataKey<T> = DataKey<T>> = ImmutableArray<WriteChange<T, K>>;
 /** Apply a set of changes to a synchronous provider. */
 export declare function changeProvider<T extends Datas, K extends DataKey<T>>(provider: Provider<T>, ...changes: DeepIterable<Nullish<WriteChange<T, K>>>[]): ItemChanges<T, K>;
 /** Apply a set of changes to an asynchronous provider. */

package/db/Item.d.ts

@@ -7,15 +7,15 @@ import type { DeleteChange, SetChange, UpdateChange } from "./Change.js";
 import type { AsyncQuery, Query } from "./Query.js";
 import type { AsyncDatabase, Database } from "./Database.js";
 /** Item data with a string ID that uniquely identifies it. */
-export declare type ItemData<T extends Data = Data> = T & {
+export type ItemData<T extends Data = Data> = T & {
     id: string;
 };
 /** Entity or `null` to indicate the item doesn't exist. */
-export declare type ItemValue<T extends Data = Data> = ItemData<T> | null;
+export type ItemValue<T extends Data = Data> = ItemData<T> | null;
 /** An array of item data. */
-export declare type ItemArray<T extends Data = Data> = ImmutableArray<ItemData<T>>;
+export type ItemArray<T extends Data = Data> = ImmutableArray<ItemData<T>>;
 /** A set of query constraints for item data. */
-export declare type ItemConstraints<T extends Data = Data> = QueryConstraints<ItemData<T>>;
+export type ItemConstraints<T extends Data = Data> = QueryConstraints<ItemData<T>>;
 /** Reference to an item in a synchronous or asynchronous database. */
 declare abstract class BaseItem<T extends Datas = Datas, K extends DataKey<T> = DataKey<T>> implements AsyncIterable<ItemValue<T[K]>> {
     abstract readonly db: Database<T> | AsyncDatabase<T>;

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/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,6 +1,6 @@
-import { MarkupRules } from "./rules.js";
+import type { MarkupRules } from "./rule.js";
 /** The current parsing options (represents the current state of the parsing). */
-export declare type MarkupOptions = {
+export type MarkupOptions = {
     /** The active list of parsing rules. */
     readonly rules: MarkupRules;
     /** The initial context to start parsing in (rules may render their children with a different context). */

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 declare 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 declare 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,80 @@
+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 {
+    private readonly _regexp;
+    private readonly _render;
+    constructor(_regexp: RegExp, //
+    _render: (props: Data, options: MarkupOptions) => JSXElement, contexts: ImmutableArray<string>, subcontext?: string | null, priority?: number);
+    match(input: string): MarkupRuleMatch | null;
+    render(props: Data, options: MarkupOptions): JSXElement;
+}
+export declare class NamedRegExpMarkupRule<T extends NamedRegExpData> extends MarkupRule {
+    private readonly _regexp;
+    private readonly _render;
+    constructor(_regexp: NamedRegExp<T>, //
+    _render: (props: T, options: MarkupOptions) => JSXElement, contexts: ImmutableArray<string>, subcontext?: string | null, priority?: number);
+    match(input: string): NamedRegExpArray<T> | null;
+    render(props: T, options: MarkupOptions): JSXElement;
+}
+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;
+    render(props: {
+        title: string;
+        href: string;
+    }, options: MarkupOptions): JSXElement<import("../util/jsx.js").JSXProps>;
+}
+export type MarkupRules = MarkupRule[];

package/markup/rule.js

@@ -0,0 +1,63 @@
+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);
+    }
+    render(props, options) {
+        return this._render(props, options);
+    }
+}
+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);
+    }
+    render(props, options) {
+        return this._render(props, options);
+    }
+}
+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;
+    }
+    render(props, options) {
+        return this._render(props, options);
+    }
+}