shelving 1.51.0 → 1.51.4

package/markup/index.d.ts

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

package/markup/index.js

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

package/markup/render.d.ts

@@ -1,4 +1,5 @@
-import type { MarkupOptions, MarkupNode } from "./types.js";
+import { JSXNode } from "../util/index.js";
+import type { MarkupOptions } from "./types.js";
 /**
  * Parse a text string as Markdownish syntax and render it as a JSX node.
  * - Syntax is not defined by this code, but by the rules supplied to it.
@@ -32,4 +33,4 @@ import type { MarkupOptions, MarkupNode } from "./types.js";
  *
  * @returns ReactNode, i.e. either a complete `ReactElement`, `null`, `undefined`, `string`, or an array of zero or more of those.
  */
-export declare function renderMarkup(content: string, options?: Partial<MarkupOptions>): MarkupNode;
+export declare function renderMarkup(content: string, options?: Partial<MarkupOptions>): JSXNode;

package/markup/render.js

@@ -1,5 +1,5 @@
 /* eslint-disable no-param-reassign */
-import { sanitizeLines } from "../index.js";
+import { sanitizeLines } from "../util/index.js";
 import { MARKUP_RULES } from "./rules.js";
 /** Convert a string into an array of React nodes using a set of rules. */
 function renderString(content, options) {
@@ -15,12 +15,12 @@ function renderString(content, options) {
         let matchedRule = undefined;
         let matchedResult = undefined;
         for (const rule of options.rules) {
-            const { priority = 0, match, contexts } = rule;
+            const { priority = 0, match, regexp, contexts } = rule;
             // 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.
             if (priority >= matchedPriority && contexts.includes(options.context)) {
-                const result = match(content, options);
+                const result = match ? match(content, options) : regexp ? content.match(regexp) : null;
                 // If this matched and has an index (it might not if it's a `/g` global RegExp, which would be a mistake).
                 if (result && typeof result.index === "number") {
                     const index = result.index;
@@ -46,13 +46,12 @@ function renderString(content, options) {
             // Call the rule's `render()` function to generate the node.
             const childOptions = { ...options, context: matchedRule.childContext };
             const element = matchedRule.render(matchedResult, childOptions);
-            element.rule = matchedRule;
             appendNode(nodes, renderNode(element, childOptions));
             // Decrement the content.
             content = content.slice(matchedIndex + matchedResult[0].length);
         }
         else {
-            // If nothing else matched add the rest of the string as a node (presumably it doesn't have any punctuation).
+            // If nothing else matched add the rest of the string as a node.
             // Don't need to push the string through `renderNode()` because we already know it doesn't match any rules in the current context.
             nodes.push(content);
             content = "";
@@ -103,10 +102,11 @@ function renderNode(node, options) {
     if (node instanceof Array)
         return node.map(n => renderNode(n, options));
     if (typeof node === "object" && node) {
-        node.$$typeof = REACT_SECURITY_SYMBOL; // Inject React security type. See https://github.com/facebook/react/pull/4832
-        if (node.props.children)
-            node.props.children = renderNode(node.props.children, options);
-        return node;
+        return {
+            ...node,
+            $$typeof: REACT_SECURITY_SYMBOL,
+            props: node.props.children ? { ...node.props, children: renderNode(node.props.children, options) } : node.props,
+        };
     }
     return node;
 }

package/markup/rules.d.ts

@@ -38,19 +38,19 @@ export declare const FENCED_CODE_RULE: MarkupRule;
 export declare const PARAGRAPH_RULE: MarkupRule;
 /**
  * Markdown-style link.
- * - Link in standard Markdown format, e.g. `[http://google.com/maps](Google Maps)`
+ * - Link in standard Markdown format, e.g. `[Google Maps](http://google.com/maps)`
  * - If no title is specified a cleaned up version of the URL will be used, e.g. `google.com/maps`
  * - Does not need space before/after the 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 declare const LINK_MARKUP: MarkupRule;
+export declare const LINK_RULE: MarkupRule;
 /**
- * Autolinked URL starts with `http:` or `https:` and matches an unlimited number of non-space characters.
+ * 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).
  * - If no title is specified a cleaned up version of the URL will be used, e.g. `google.com/maps`
  * - If link is not valid (using `new URL(url)` then unparsed text will be returned.
- * - For security only schemes that appear in the `options.schemes` will match (defaults to `http:` and `https:`).
+ * - For security only schemes that appear in `options.schemes` will match (defaults to `http:` and `https:`).
  */
 export declare const AUTOLINK_RULE: MarkupRule;
 /**
@@ -69,7 +69,7 @@ export declare const CODE_RULE: MarkupRule;
  * - 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_MARKUP: MarkupRule;
+export declare const STRONG_RULE: MarkupRule;
 /**
  * Inline emphasis.
  * - Inline text wrapped in one or more `_` underscore symbols.

package/markup/rules.js

@@ -1,10 +1,8 @@
-import { formatUrl, toURL, getLineRegExp, MATCH_LINE, getBlockRegExp, MATCH_BLOCK, getWrapRegExp } from "../util/index.js";
+import { formatUrl, toURL, getLineRegExp, getBlockRegExp, MATCH_LINE, MATCH_BLOCK, getWrapRegExp } from "../util/index.js";
 // Regular expression partials (`\` slashes must be escaped as `\\`).
 const BULLETS = "-*•+"; // Anything that can be a bullet (used for unordered lists and horizontal rules).
 // Regular expressions.
-const REPLACE_INDENT = /^ {1,2}/gm;
-// Regular expression makers.
-const getMatcher = regexp => content => content.match(regexp);
+const MATCH_INDENT = /^ {1,2}/gm;
 /**
  * Headings are single line only (don't allow multiline).
  * - 1-6 hashes then 1+ spaces, then the title.
@@ -12,7 +10,7 @@ const getMatcher = regexp => content => content.match(regexp);
  * - Markdown's underline syntax is not supported (for simplification).
  */
 export const HEADING_RULE = {
-    match: getMatcher(getLineRegExp(`(#{1,6}) +(${MATCH_LINE})`)),
+    regexp: getLineRegExp(`(#{1,6}) +(${MATCH_LINE.source})`),
     render: ([, prefix = "", children = ""]) => ({ type: `h${prefix.length}`, key: null, props: { children } }),
     contexts: ["block"],
     childContext: "inline",
@@ -25,7 +23,7 @@ export const HEADING_RULE = {
  * - Might have infinite number of spaces between the characters.
  */
 export const HORIZONTAL_RULE = {
-    match: getMatcher(getLineRegExp(`([${BULLETS}])(?: *\\1){2,}`)),
+    regexp: getLineRegExp(`([${BULLETS}])(?: *\\1){2,}`),
     render: () => ({ type: "hr", key: null, props: {} }),
     contexts: ["block"],
 };
@@ -38,7 +36,7 @@ export const HORIZONTAL_RULE = {
  */
 const UNORDERED = `[${BULLETS}] +`; // Anything that can be a bullet (used for unordered lists and horizontal rules).
 export const UNORDERED_LIST_RULE = {
-    match: getMatcher(getBlockRegExp(`${UNORDERED}(${MATCH_BLOCK})`)),
+    regexp: getBlockRegExp(`${UNORDERED}(${MATCH_BLOCK.source})`),
     render: ([, list = ""]) => {
         const children = list.split(SPLIT_UL_ITEMS).map(mapUnorderedItem);
         return { type: "ul", key: null, props: { children } };
@@ -48,7 +46,7 @@ export const UNORDERED_LIST_RULE = {
 };
 const SPLIT_UL_ITEMS = new RegExp(`\\n+${UNORDERED}`, "g");
 const mapUnorderedItem = (item, key) => {
-    const children = item.replace(REPLACE_INDENT, "");
+    const children = item.replace(MATCH_INDENT, "");
     return { type: "li", key, props: { children } };
 };
 /**
@@ -58,7 +56,7 @@ const mapUnorderedItem = (item, key) => {
  */
 const ORDERED = "[0-9]+[.):] +"; // Number for a numbered list (e.g. `1.` or `2)` or `3:`)
 export const ORDERED_LIST_RULE = {
-    match: getMatcher(getBlockRegExp(`(${ORDERED}${MATCH_BLOCK})`)),
+    regexp: getBlockRegExp(`(${ORDERED}${MATCH_BLOCK.source})`),
     render: ([, list = ""]) => {
         const children = list.split(SPLIT_OL_ITEMS).map(mapOrderedItem);
         return { type: "ol", key: null, props: { children } };
@@ -73,7 +71,7 @@ const mapOrderedItem = (item, key) => {
     const children = item
         .slice(firstSpace + 1)
         .trimStart()
-        .replace(REPLACE_INDENT, "");
+        .replace(MATCH_INDENT, "");
     return { type: "li", key, props: { value, children } };
 };
 /**
@@ -83,7 +81,7 @@ const mapOrderedItem = (item, key) => {
  * - Quote indent symbol can be followed by zero or more spaces.
  */
 export const BLOCKQUOTE_RULE = {
-    match: getMatcher(getLineRegExp(`(>${MATCH_LINE}(?:\\n>${MATCH_LINE})*)`)),
+    regexp: getLineRegExp(`(>${MATCH_LINE.source}(?:\\n>${MATCH_LINE.source})*)`),
     render: ([, quote = ""]) => ({
         type: "blockquote",
         key: null,
@@ -102,7 +100,7 @@ const BLOCKQUOTE_LINES = /^>/gm;
  */
 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: getMatcher(getBlockRegExp(`(\`{3,}|~{3,}) *(${MATCH_LINE})\\n(${MATCH_BLOCK})`, `\\n\\1\\n+|\\n\\1$|$`)),
+    regexp: getBlockRegExp(`(\`{3,}|~{3,}) *(${MATCH_LINE.source})\\n(${MATCH_BLOCK.source})`, `\\n\\1\\n+|\\n\\1$|$`),
     render: ([, , file, children]) => ({
         type: "pre",
         key: null,
@@ -121,7 +119,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: getMatcher(getBlockRegExp(` *(${MATCH_BLOCK})`)),
+    regexp: getBlockRegExp(` *(${MATCH_BLOCK.source})`),
     render: ([, children]) => ({ type: `p`, key: null, props: { children } }),
     contexts: ["block"],
     childContext: "inline",
@@ -129,61 +127,65 @@ export const PARAGRAPH_RULE = {
 };
 /**
  * Markdown-style link.
- * - Link in standard Markdown format, e.g. `[http://google.com/maps](Google Maps)`
+ * - Link in standard Markdown format, e.g. `[Google Maps](http://google.com/maps)`
  * - If no title is specified a cleaned up version of the URL will be used, e.g. `google.com/maps`
  * - Does not need space before/after the 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_MARKUP = {
+export const LINK_RULE = {
+    regexp: /\[([^\]]*?)\]\(([^)]*?)\)/,
     // Custom matcher to check the URL against the allowed schemes.
     match: (content, { schemes, url: base }) => {
-        const matches = content.match(MATCH_LINK);
-        if (matches && typeof matches.index === "number") {
+        const matches = content.match(LINK_RULE.regexp);
+        if (matches) {
             const [, title = "", href = ""] = matches;
             const url = toURL(href, base);
             if (url && url.protocol && schemes.includes(url.protocol)) {
                 matches[1] = title.trim();
-                matches[2] = url.href; // Use fixed URL from `new URL`
+                matches[2] = url.href;
                 return matches;
             }
         }
     },
-    render: ([, title = "", href = ""], { rel }) => ({
-        type: href ? "a" : "span",
+    render: ([, title, href = ""], { rel }) => ({
+        type: "a",
         key: null,
-        props: { children: title || formatUrl(href), href: href || undefined, rel },
+        props: { children: title || formatUrl(href), href, rel },
     }),
     contexts: ["inline", "list"],
     childContext: "link",
 };
-const MATCH_LINK = /\[([^\]]*?)\]\(([^)]*?)\)/;
 /**
- * Autolinked URL starts with `http:` or `https:` and matches an unlimited number of non-space characters.
+ * 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).
  * - If no title is specified a cleaned up version of the URL will be used, e.g. `google.com/maps`
  * - If link is not valid (using `new URL(url)` then unparsed text will be returned.
- * - For security only schemes that appear in the `options.schemes` will match (defaults to `http:` and `https:`).
+ * - For security only schemes that appear in `options.schemes` will match (defaults to `http:` and `https:`).
  */
 export const AUTOLINK_RULE = {
+    regexp: /([a-z]+:\S+)(?: +(?:\(([^)]*?)\)|\[([^\]]*?)\]))?/,
     // Custom matcher to check the URL against the allowed schemes.
     match: (content, { schemes, url: base }) => {
-        const matches = content.match(MATCH_AUTOLINK);
+        const matches = content.match(AUTOLINK_RULE.regexp);
         if (matches && typeof matches.index === "number") {
-            const [, href = "", title1 = "", title2 = ""] = matches;
+            const [, href = "", roundTitle = "", squareTitle = ""] = matches;
             const url = toURL(href, base);
             if (url && url.protocol && schemes.includes(url.protocol)) {
-                matches[1] = (title1 || title2).trim();
-                matches[2] = url.href;
+                matches[1] = url.href;
+                matches[2] = (roundTitle || squareTitle).trim();
                 return matches;
             }
         }
     },
-    render: LINK_MARKUP.render,
+    render: ([, href = "", title], { rel }) => ({
+        type: "a",
+        key: null,
+        props: { children: title || formatUrl(href), href, rel },
+    }),
     contexts: ["inline", "list"],
     childContext: "link",
 };
-const MATCH_AUTOLINK = /([a-z][a-z0-9-]*[a-z0-9]:\S+)(?: +(?:\(([^)]*?)\)|\[([^\]]*?)\]))?/i;
 /**
  * Inline code.
  * - Text surrounded by one or more "`" backtick tilde characters.
@@ -192,7 +194,7 @@ const MATCH_AUTOLINK = /([a-z][a-z0-9-]*[a-z0-9]:\S+)(?: +(?:\(([^)]*?)\)|\[([^\
  * - Same as Markdown syntax.
  */
 export const CODE_RULE = {
-    match: getMatcher(getWrapRegExp("`+", MATCH_BLOCK)),
+    regexp: getWrapRegExp("`+", MATCH_BLOCK.source),
     render: ([, , children]) => ({ type: "code", key: null, props: { children } }),
     contexts: ["inline", "list"],
     priority: 10, // Higher priority than other inlines so it matches first before e.g. `strong` or `em` (from CommonMark spec: "Code span backticks have higher precedence than any other inline constructs except HTML tags and autolinks.")
@@ -205,8 +207,8 @@ export const CODE_RULE = {
  * - 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_MARKUP = {
-    match: getMatcher(getWrapRegExp("\\*+")),
+export const STRONG_RULE = {
+    regexp: getWrapRegExp("\\*+"),
     render: ([, , children]) => ({ type: "strong", key: null, props: { children } }),
     contexts: ["inline", "list", "link"],
     childContext: "inline",
@@ -220,7 +222,7 @@ export const STRONG_MARKUP = {
  * - 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: getMatcher(getWrapRegExp("_+")),
+    regexp: getWrapRegExp("_+"),
     render: ([, , children]) => ({ type: "em", key: null, props: { children } }),
     contexts: ["inline", "list", "link"],
     childContext: "inline",
@@ -234,7 +236,7 @@ export const EMPHASIS_RULE = {
  * - Markdown doesn't have this.
  */
 export const INSERT_RULE = {
-    match: getMatcher(getWrapRegExp("\\+\\++")),
+    regexp: getWrapRegExp("\\+\\++"),
     render: ([, , children]) => ({ type: "ins", key: null, props: { children } }),
     contexts: ["inline", "list", "link"],
     childContext: "inline",
@@ -248,7 +250,7 @@ export const INSERT_RULE = {
  * - Markdown doesn't have this.
  */
 export const DELETE_RULE = {
-    match: getMatcher(getWrapRegExp("--+|~~+")),
+    regexp: getWrapRegExp("--+|~~+"),
     render: ([, , children]) => ({ type: "del", key: null, props: { children } }),
     contexts: ["inline", "list", "link"],
     childContext: "inline",
@@ -262,7 +264,7 @@ export const DELETE_RULE = {
  *   - This works better with textareas that wrap text (since manually breaking up long lines is no longer necessary).
  */
 export const LINEBREAK_RULE = {
-    match: getMatcher(/\n/),
+    regexp: /\n/,
     render: () => ({ type: "br", key: null, props: {} }),
     contexts: ["inline", "list", "link"],
     childContext: "inline",
@@ -284,10 +286,10 @@ export const MARKUP_RULES = [
     BLOCKQUOTE_RULE,
     FENCED_CODE_RULE,
     PARAGRAPH_RULE,
-    LINK_MARKUP,
+    LINK_RULE,
     AUTOLINK_RULE,
     CODE_RULE,
-    STRONG_MARKUP,
+    STRONG_RULE,
     EMPHASIS_RULE,
     INSERT_RULE,
     DELETE_RULE,
@@ -305,10 +307,10 @@ export const MARKUP_RULES_BLOCK = [
 ];
 /** Subset of markup rules that work in an inline context. */
 export const MARKUP_RULES_INLINE = [
-    LINK_MARKUP,
+    LINK_RULE,
     AUTOLINK_RULE,
     CODE_RULE,
-    STRONG_MARKUP,
+    STRONG_RULE,
     EMPHASIS_RULE,
     INSERT_RULE,
     DELETE_RULE,
@@ -319,10 +321,10 @@ export const MARKUP_RULES_SHORTFORM = [
     UNORDERED_LIST_RULE,
     ORDERED_LIST_RULE,
     PARAGRAPH_RULE,
-    LINK_MARKUP,
+    LINK_RULE,
     AUTOLINK_RULE,
     CODE_RULE,
-    STRONG_MARKUP,
+    STRONG_RULE,
     EMPHASIS_RULE,
     INSERT_RULE,
     DELETE_RULE,

package/markup/types.d.ts

@@ -1,25 +1,10 @@
-/**
- * JSX element.
- * - Compatible with but _slightly_ more flexible than `React.ReactElement`
- */
-export declare type MarkupElement = {
-    type: string;
-    key: string | number | null;
-    props: MarkupElementProps;
-    $$typeof?: symbol;
-    /** This specifies the rule that created this element. */
-    rule?: MarkupRule;
-};
-export declare type MarkupElementProps = {
-    [prop: string]: unknown;
-    children?: MarkupNode;
-};
-/** JSX node (compatible with but slightly more flexible than `React.ReactNode`) */
-export declare type MarkupNode = undefined | null | string | MarkupElement | MarkupNode[];
+import { JSXElement } from "../util/index.js";
 /** A single markup parsing rule. */
 export declare type MarkupRule = {
-    /** RegExp that matches this rule. */
-    readonly match: MarkupRuleMatcher;
+    /** RegExp for matching this rule. */
+    readonly regexp: RegExp;
+    /** Custom matching function for this rule (overrides `regexp` if present. */
+    readonly match?: (content: string, options: MarkupOptions) => RegExpMatchArray | null | undefined | void;
     /**
      * Return a corresponding JSX element for the match.
      * @param ...matches The matches from `match` RegExp (without the `0` zeroeth "whole match").
@@ -27,7 +12,7 @@ export declare type MarkupRule = {
      *   - The `key` property is not required (will be set automatically).
      *   - e.g. `{ type: "a", props: { href: "/example.html", className: "strong", children: "Children *can* include _syntax_" } }`
      */
-    readonly render: MarkupRuleRenderer;
+    readonly render: (matches: RegExpMatchArray, options: MarkupOptions) => JSXElement;
     /** Apply the rule only when in certain contexts, e.g. `["block", "inline", "list"]` */
     readonly contexts: string[];
     /** Context any string children returned from `render()` should be rendered with. */
@@ -42,8 +27,6 @@ export declare type MarkupRule = {
      */
     readonly priority?: number;
 };
-export declare type MarkupRuleMatcher = (content: string, options: MarkupOptions) => RegExpMatchArray | null | undefined | void;
-export declare type MarkupRuleRenderer = (matches: RegExpMatchArray, options: MarkupOptions) => MarkupElement;
 /** A set of parse rules (as an object or array). */
 export declare type MarkupRules = Iterable<MarkupRule>;
 /** The current parsing options (represents the current state of the parsing). */
@@ -59,5 +42,3 @@ export declare type MarkupOptions = {
     /** Valid URL schemes/protocols for links (including trailing commas), defaults to `[`http:`, `https:`]` */
     readonly schemes: string[];
 };
-/** The create element function. */
-export declare type MarkupElementCreator = (type: string, props?: MarkupElementProps | null) => MarkupElement;

package/package.json

@@ -11,7 +11,7 @@
 		"state-management",
 		"query-builder"
 	],
-	"version": "1.51.0",
+	"version": "1.51.4",
 	"repository": "https://github.com/dhoulb/shelving",
 	"author": "Dave Houlbrooke <dave@shax.com>",
 	"license": "0BSD",
@@ -63,14 +63,14 @@
 		"@types/jest": "^27.4.0",
 		"@types/react": "^17.0.39",
 		"@types/react-dom": "^17.0.11",
-		"@typescript-eslint/eslint-plugin": "^5.10.2",
-		"@typescript-eslint/parser": "^5.10.2",
-		"eslint": "^8.8.0",
+		"@typescript-eslint/eslint-plugin": "^5.11.0",
+		"@typescript-eslint/parser": "^5.11.0",
+		"eslint": "^8.9.0",
 		"eslint-config-prettier": "^8.3.0",
 		"eslint-plugin-import": "^2.25.4",
 		"eslint-plugin-prettier": "^4.0.0",
 		"firebase": "^9.6.6",
-		"jest": "^27.5.0",
+		"jest": "^27.5.1",
 		"jest-ts-webcompat-resolver": "^1.0.0",
 		"prettier": "^2.5.1",
 		"react": "^17.0.2",

package/react/useQuery.d.ts

@@ -34,8 +34,8 @@ export declare function useAsyncQuery<T extends Data>(ref: DatabaseQuery<T> | un
 export declare function useQuery<T extends Data>(ref: DatabaseQuery<T>, maxAge?: number | true): Results<T>;
 export declare function useQuery<T extends Data>(ref: DatabaseQuery<T> | undefined, maxAge?: number | true): Results<T> | undefined;
 /** Use the first result of a query or `undefined` if the query has no matching results (or a promise indicating the result is loading). */
-export declare function useAsyncQueryResult<T extends Data>(ref: DatabaseQuery<T>, maxAge?: number | true): DocumentResult<T> | undefined | PromiseLike<DocumentResult<T> | undefined>;
-export declare function useAsyncQueryResult<T extends Data>(ref: DatabaseQuery<T> | undefined, maxAge?: number | true): DocumentResult<T> | undefined | PromiseLike<DocumentResult<T> | undefined>;
+export declare function useAsyncQueryResult<T extends Data>(ref: DatabaseQuery<T>, maxAge?: number | true): DocumentResult<T> | PromiseLike<DocumentResult<T>>;
+export declare function useAsyncQueryResult<T extends Data>(ref: DatabaseQuery<T> | undefined, maxAge?: number | true): DocumentResult<T> | PromiseLike<DocumentResult<T>> | undefined;
 /** Use the first result of a query or `undefined` if the query has no matching results */
 export declare function useQueryResult<T extends Data>(ref: DatabaseQuery<T>, maxAge?: number | true): DocumentResult<T>;
 export declare function useQueryResult<T extends Data>(ref: DatabaseQuery<T> | undefined, maxAge?: number | true): DocumentResult<T> | undefined;

package/util/index.d.ts

@@ -17,6 +17,7 @@ export * from "./filter.js";
 export * from "./function.js";
 export * from "./hydrate.js";
 export * from "./iterate.js";
+export * from "./jsx.js";
 export * from "./lazy.js";
 export * from "./map.js";
 export * from "./merge.js";

package/util/index.js

@@ -17,6 +17,7 @@ export * from "./filter.js";
 export * from "./function.js";
 export * from "./hydrate.js";
 export * from "./iterate.js";
+export * from "./jsx.js";
 export * from "./lazy.js";
 export * from "./map.js";
 export * from "./merge.js";

package/util/jsx.d.ts

@@ -0,0 +1,35 @@
+import { Data } from "./data.js";
+/** Function that creates a JSX element. */
+export declare type JSXElementCreator<P extends Data = Data> = (props: P) => JSXElement | null;
+/** Set of valid props for a JSX element. */
+export declare type JSXProps = {
+    readonly [key: string]: unknown;
+    readonly children?: JSXNode;
+};
+/** JSX element (similar to `React.ReactElement`)  */
+export declare type JSXElement<P extends JSXProps = JSXProps, T extends string | JSXElementCreator<P> = string | JSXElementCreator<P>> = {
+    type: T;
+    props: P;
+    key: string | number | null;
+    $$typeof?: symbol;
+};
+/** JSX node (similar to `React.ReactNode`) */
+export declare type JSXNode = undefined | null | string | JSXElement | JSXNode[];
+/** Is an unknown value a JSX element? */
+export declare const isElement: <T extends JSXNode>(el: unknown) => el is T;
+/** Is an unknown value a JSX node? */
+export declare const isNode: <T extends JSXNode>(node: unknown) => node is T;
+/**
+ * Take a Markup JSX node and strip all tags from it to produce a plain text string.
+ *
+ * @param node A JsxNode, e.g. either a JSX element, a plain string, or null/undefined (or an array of those things).
+ * @returns The combined string made from the JSX node.
+ *
+ * @example `- Item with *strong*\n- Item with _em_` becomes `Item with strong Item with em`
+ */
+export declare function nodeToText(node?: JSXNode): string;
+/**
+ * Iterate through all elements in a node.
+ * - This is useful if you, e.g. want to apply a `className` to all `<h1>` elements, or make a list of all URLs found in a Node.
+ */
+export declare function yieldElements(node: JSXNode): Generator<JSXElement, void>;

package/util/jsx.js

@@ -0,0 +1,35 @@
+/** Is an unknown value a JSX element? */
+export const isElement = (el) => typeof el === "object" && el !== null && "type" in el;
+/** Is an unknown value a JSX node? */
+export const isNode = (node) => node === null || typeof node === "string" || isElement(node) || node instanceof Array;
+/**
+ * Take a Markup JSX node and strip all tags from it to produce a plain text string.
+ *
+ * @param node A JsxNode, e.g. either a JSX element, a plain string, or null/undefined (or an array of those things).
+ * @returns The combined string made from the JSX node.
+ *
+ * @example `- Item with *strong*\n- Item with _em_` becomes `Item with strong Item with em`
+ */
+export function nodeToText(node) {
+    if (typeof node === "string")
+        return node;
+    if (node instanceof Array)
+        return node.map(nodeToText).join(" ");
+    if (typeof node === "object" && node)
+        return nodeToText(node.props.children);
+    return "";
+}
+/**
+ * Iterate through all elements in a node.
+ * - This is useful if you, e.g. want to apply a `className` to all `<h1>` elements, or make a list of all URLs found in a Node.
+ */
+export function* yieldElements(node) {
+    if (node instanceof Array)
+        for (const n of node)
+            yield* yieldElements(n);
+    else if (typeof node === "object" && node) {
+        yield node;
+        if (isNode(node.props.children))
+            yield* yieldElements(node.props.children);
+    }
+}

package/util/search.d.ts

@@ -1,5 +1,16 @@
 import type { ImmutableArray } from "./array.js";
 import { Matchable } from "./filter.js";
+export declare const MATCH_SPACE: RegExp;
+export declare const MATCH_SPACES: RegExp;
+export declare const MATCH_LINEBREAK: RegExp;
+export declare const MATCH_LINEBREAKS: RegExp;
+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_WORDS: RegExp;
 /**
  * Convert a string to a regular expression that matches that string.
  *
@@ -9,13 +20,6 @@ import { Matchable } from "./filter.js";
 export declare const toRegExp: (str: string, flags?: string) => RegExp;
 /** Escape special characters in a string regular expression. */
 export declare const escapeRegExp: (str: string) => string;
-export declare const MATCH_LINE = "[^\\n]*";
-export declare const MATCH_LINE_START = "^\\n*|\\n+";
-export declare const MATCH_LINE_END = "\\n+|$";
-export declare const MATCH_BLOCK = "[\\s\\S]*?";
-export declare const MATCH_BLOCK_START = "^\\n*|\\n+";
-export declare const MATCH_BLOCK_END = "\\n*$|\\n\\n+";
-export declare const MATCH_WORDS = "\\S(?:[\\s\\S]*?\\S)?";
 /** Create regular expression that matches a block of content. */
 export declare const getBlockRegExp: (middle?: string, end?: string, start?: string) => RegExp;
 /** Create regular expression that matches a line of content. */

package/util/search.js

@@ -1,4 +1,16 @@
 import { toWords, normalizeString } from "./string.js";
+// Regular expressions.
+export const MATCH_SPACE = /\s+/; // Match the first run of one or more space characters.
+export const MATCH_SPACES = /\s+/g; // Match all runs of one or more space characters.
+export const MATCH_LINEBREAK = /\n+/; // Match the first run of one or more linebreak characters.
+export const MATCH_LINEBREAKS = /\n+/; // Match all runs of one or more linebreak characters.
+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_WORDS = /\S(?:[\s\S]*?\S)?/; // Run of text that starts and ends with non-space characters (possibly multi-line).
 /**
  * Convert a string to a regular expression that matches that string.
  *
@@ -9,20 +21,12 @@ export const toRegExp = (str, flags = "") => new RegExp(escapeRegExp(str), flags
 /** Escape special characters in a string regular expression. */
 export const escapeRegExp = (str) => str.replace(REPLACE_ESCAPED, "\\$&");
 const REPLACE_ESCAPED = /[-[\]/{}()*+?.\\^$|]/g;
-// Regular expression partials (`\` slashes must be escaped as `\\`).
-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_WORDS = `\\S(?:[\\s\\S]*?\\S)?`; // Run of text that starts and ends with non-space characters (possibly multi-line).
 /** Create regular expression that matches a block of content. */
-export const getBlockRegExp = (middle = MATCH_BLOCK, end = MATCH_BLOCK_END, start = MATCH_BLOCK_START) => new RegExp(`(?:${start})${middle}(?:${end})`);
+export const getBlockRegExp = (middle = MATCH_BLOCK.source, end = MATCH_BLOCK_END.source, start = MATCH_BLOCK_START.source) => new RegExp(`(?:${start})${middle}(?:${end})`);
 /** Create regular expression that matches a line of content. */
-export const getLineRegExp = (middle = MATCH_LINE, end = MATCH_LINE_END, start = MATCH_LINE_START) => new RegExp(`(?:${start})${middle}(?:${end})`);
+export const getLineRegExp = (middle = MATCH_LINE.source, end = MATCH_LINE_END.source, start = MATCH_LINE_START.source) => new RegExp(`(?:${start})${middle}(?:${end})`);
 /** Create regular expression that matches piece of text wrapped by a set of characters. */
-export const getWrapRegExp = (chars, middle = MATCH_WORDS) => new RegExp(`(${chars})(${middle})\\1`);
+export const getWrapRegExp = (chars, middle = MATCH_WORDS.source) => new RegExp(`(${chars})(${middle})\\1`);
 /**
  * Convert a string query to the corresponding set of case-insensitive regular expressions.
  * - Splies the query into words (respecting "quoted phrases").

package/markup/helpers.d.ts

@@ -1,25 +0,0 @@
-import type { MarkupElement, MarkupNode } from "./types.js";
-/**
- * Take a Markup JSX node and strip all tags from it to produce a plain text string.
- *
- * @param node A JsxNode, e.g. either a JSX element, a plain string, or null/undefined (or an array of those things).
- * @returns The combined string made from the JSX node.
- *
- * @example `- Item with *strong*\n- Item with _em_` becomes `Item with strong Item with em`
- */
-export declare function nodeToText(node: MarkupNode): string;
-/**
- * Take a Markup JSX node and convert it to an HTML string.
- *
- * @param node Any `MarkupNode`, i.e. a string, `MarkupElement`, or array of those.
- * - Any props in the node will be rendered if they are strings or numbers or `true`. All other props are skipped.
- * @returns The HTML generated from the node.
- *
- * @example `- Item with *strong*\n- Item with _em_` becomes `<ul><li>Item with <strong>strong</strong></li><li>Item with <em>em</em></ul>`
- */
-export declare function nodeToHtml(node: MarkupNode): string;
-/**
- * Iterate through all elements in a node.
- * - This is useful if you, e.g. want to apply a `className` to all `<h1>` elements, or make a list of all URLs found in a Node.
- */
-export declare function yieldElements(node: MarkupNode): Generator<MarkupElement, void>;

package/markup/helpers.js

@@ -1,54 +0,0 @@
-import { serialise } from "../util/index.js";
-/**
- * Take a Markup JSX node and strip all tags from it to produce a plain text string.
- *
- * @param node A JsxNode, e.g. either a JSX element, a plain string, or null/undefined (or an array of those things).
- * @returns The combined string made from the JSX node.
- *
- * @example `- Item with *strong*\n- Item with _em_` becomes `Item with strong Item with em`
- */
-export function nodeToText(node) {
-    if (typeof node === "string")
-        return node;
-    if (node instanceof Array)
-        return node.map(nodeToText).join(" ");
-    if (typeof node === "object" && node)
-        return nodeToText(node.props.children);
-    return "";
-}
-/**
- * Take a Markup JSX node and convert it to an HTML string.
- *
- * @param node Any `MarkupNode`, i.e. a string, `MarkupElement`, or array of those.
- * - Any props in the node will be rendered if they are strings or numbers or `true`. All other props are skipped.
- * @returns The HTML generated from the node.
- *
- * @example `- Item with *strong*\n- Item with _em_` becomes `<ul><li>Item with <strong>strong</strong></li><li>Item with <em>em</em></ul>`
- */
-export function nodeToHtml(node) {
-    if (typeof node === "string")
-        return node;
-    if (node instanceof Array)
-        return node.map(nodeToHtml).join("");
-    if (typeof node === "object" && node) {
-        const { type, props: { children, ...props }, } = node;
-        const strings = Object.entries(props).map(propToString).filter(Boolean);
-        return `<${type}${strings.length ? ` ${strings.join(" ")}` : ""}>${nodeToHtml(children)}</${type}>`;
-    }
-    return "";
-}
-const propToString = ([key, value]) => (value === true ? key : typeof value === "number" && Number.isFinite(value) ? `${key}="${value.toString()}"` : typeof value === "string" ? `${key}=${serialise(value)}` : "");
-/**
- * Iterate through all elements in a node.
- * - This is useful if you, e.g. want to apply a `className` to all `<h1>` elements, or make a list of all URLs found in a Node.
- */
-export function* yieldElements(node) {
-    if (node instanceof Array)
-        for (const n of node)
-            yield* yieldElements(n);
-    else if (typeof node === "object" && node) {
-        yield node;
-        if (node.props.children)
-            yield* yieldElements(node.props.children);
-    }
-}