shelving 1.128.2 → 1.129.0

package/iterate/{AbstractGenerator.d.ts → AbstractIterator.d.ts}

@@ -1,8 +1,7 @@
 /** Abstract generator designed to be extended that implements the full generator protocol. */
-export declare abstract class AbstractGenerator<T, R, N> implements Generator<T, R, N> {
-    readonly [Symbol.toStringTag] = "Generator";
+export declare abstract class AbstractIterator<T, R, N> implements Iterator<T, R, N>, Iterable<T, R, N> {
     abstract next(value: N): IteratorResult<T, R>;
     throw(thrown: unknown): IteratorResult<T, R>;
     return(value: R): IteratorResult<T, R>;
-    [Symbol.iterator](): Generator<T, R, N>;
+    [Symbol.iterator](): Iterator<T, R, N>;
 }

package/iterate/{AbstractGenerator.js → AbstractIterator.js}

@@ -1,6 +1,5 @@
 /** Abstract generator designed to be extended that implements the full generator protocol. */
-export class AbstractGenerator {
-    [Symbol.toStringTag] = "Generator";
+export class AbstractIterator {
     throw(thrown) {
         // Default behaviour for a generator is to throw the error back out of the iterator and not continue.
         throw thrown;

package/iterate/{InspectGenerator.d.ts → InspectIterator.d.ts}

@@ -1,15 +1,15 @@
-import { ThroughGenerator } from "./ThroughGenerator.js";
+import { ThroughIterator } from "./ThroughIterator.js";
 /**
  * Iterable that inspects a source iterable as it iterates.
  * - Stores: first/last yielded value, returned value, whether iteration is done, the number of items that were iterated.
  *
  * @example
- * 	const watch = new WatchIterator(iterable);
+ * 	const watch = new InspectIterator(iterable);
  * 	for (const next of capture) console.log("YIELDED", next);
  * 	console.log("FIRST", watch.first);
  * 	console.log("RETURNED", watch.returned);
  */
-export declare class InspectGenerator<T, R, N> extends ThroughGenerator<T, R, N> {
+export declare class InspectIterator<T, R, N> extends ThroughIterator<T, R, N> implements Iterator<T, R, N>, Iterable<T, R, N> {
     /** Get the number of results received by this iterator so far. */
     readonly count = 0;
     /** Is the iteration done? */

package/iterate/{InspectGenerator.js → InspectIterator.js}

@@ -1,5 +1,5 @@
 import { StateError } from "../error/StateError.js";
-import { ThroughGenerator } from "./ThroughGenerator.js";
+import { ThroughIterator } from "./ThroughIterator.js";
 /** Used when the sequence hasn't inspected anything yet. */
 const _NOVALUE = Symbol("shelving/InspectGenerator.NOVALUE");
 /**
@@ -7,12 +7,12 @@ const _NOVALUE = Symbol("shelving/InspectGenerator.NOVALUE");
  * - Stores: first/last yielded value, returned value, whether iteration is done, the number of items that were iterated.
  *
  * @example
- * 	const watch = new WatchIterator(iterable);
+ * 	const watch = new InspectIterator(iterable);
  * 	for (const next of capture) console.log("YIELDED", next);
  * 	console.log("FIRST", watch.first);
  * 	console.log("RETURNED", watch.returned);
  */
-export class InspectGenerator extends ThroughGenerator {
+export class InspectIterator extends ThroughIterator {
     /** Get the number of results received by this iterator so far. */
     count = 0;
     /** Is the iteration done? */

package/iterate/{ThroughGenerator.d.ts → ThroughIterator.d.ts}

@@ -1,6 +1,6 @@
-import { AbstractGenerator } from "./AbstractGenerator.js";
+import { AbstractIterator } from "./AbstractIterator.js";
 /** Iterable that pulls values from a source iterable. */
-export declare class ThroughGenerator<T, R, N> extends AbstractGenerator<T, R, N> {
+export declare class ThroughIterator<T, R, N> extends AbstractIterator<T, R, N> implements Iterator<T, R, N>, Iterable<T, R, N> {
     private readonly _source;
     constructor(iterator: Iterator<T, R, N>);
     next(value: N): IteratorResult<T, R>;

package/iterate/{ThroughGenerator.js → ThroughIterator.js}

@@ -1,12 +1,12 @@
-import { AbstractGenerator } from "./AbstractGenerator.js";
+import { AbstractIterator } from "./AbstractIterator.js";
 /** Iterable that pulls values from a source iterable. */
-export class ThroughGenerator extends AbstractGenerator {
+export class ThroughIterator extends AbstractIterator {
     _source;
     constructor(iterator) {
         super();
         this._source = iterator;
     }
-    // Implement `AbstractGenerator`
+    // Implement `AbstractIterator`
     next(value) {
         return this._source.next(value);
     }

package/iterate/index.d.ts

@@ -1,3 +1,3 @@
-export * from "./AbstractGenerator.js";
-export * from "./ThroughGenerator.js";
-export * from "./InspectGenerator.js";
+export * from "./AbstractIterator.js";
+export * from "./ThroughIterator.js";
+export * from "./InspectIterator.js";

package/iterate/index.js

@@ -1,3 +1,3 @@
-export * from "./AbstractGenerator.js";
-export * from "./ThroughGenerator.js";
-export * from "./InspectGenerator.js";
+export * from "./AbstractIterator.js";
+export * from "./ThroughIterator.js";
+export * from "./InspectIterator.js";

package/markup/index.d.ts

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

package/markup/index.js

@@ -1,5 +1,6 @@
-export * from "./options.js";
-export * from "./rule.js";
-export * from "./rules.js";
+export * from "./util/options.js";
+export * from "./util/rule.js";
+export * from "./util/regexp.js";
+// export * from "./util/internal.js"; // Not exported.
+export * from "./rule/index.js";
 export * from "./render.js";
-export * from "./regexp.js";

package/markup/render.d.ts

@@ -1,36 +1,13 @@
 import type { JSXNode } from "../util/jsx.js";
-import type { MarkupOptions } from "./options.js";
+import type { MarkupOptions } from "./util/options.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.
- * - Default rules define syntax similar to Markdown but with improvements:
- *   1. Syntax is more intuitive (e.g. `*strong*` always uses `*` asterisk and `_em_` always uses `_` underscore, and URLs are always autolinked).
- *   2. More compatible with textboxes that wrap lines by default (e.g. single `\n` linebreaks don't need the trailing double space to, they're always treated as `<br />`).
- *   3. Don't support fussy fragile syntax that lets users make mistakes (e.g. literal HTML tags or `&amp;` character entities).
- *
- * DH: This code is heavily inspired by `simple-markdown`, but intends to be even simpler by always producing JSX elements.
- *
- * @todo [ ] Default rules support "list items containing paragraphs" syntax (CommonMark calls this loose lists).
- *           - i.e. Lists can include `\n\n` double line breaks, and wrap all their contents in `<p>` entities, i.e. childContext is "block"
- *           - Hard because you have to capture the entire list including `\n\n`, so there's no obvious place to end it.
- *           - If there are breaks then any sub-lines need to be indented by two or more spaces otherwise it will break the list.
- *           - Make reference lists support this loose format too.
- * @todo [ ] Default rules support tables using `|` pipe syntax.
- * @todo [ ] Default rules support todo lists using `- [x]` syntax.
- * @todo [ ] Default rules support new reference syntax (combines reference lists/sidenotes/footnotes/reference and produces <dl> syntax).
- *           - All of these can be the same because reference links and Extended Markdown footnotes are basically the same.
- *           - e.g. `[Google Maps][1]` → `[1]: http://google.com Content goes here` (Markdown reference link syntax).
- *           - e.g. `[Google Maps]` → `[Google Maps]: http://google.com Content goes here` syntax.
- *           - e.g. `[DNS]` → `[DNS]: Domain Name System (extended Markdown definition list format).
- *           - If a `[Reference]` does not correspond to anything it will not be linked and e.g. will appear unlinked.
- *           - Single/double quotes around definition part are optional and are trimmed from the start/end (Extended Markdown definition lists require quotes, but that's dumb).
- *           - A `<dl>` definition list is used as the output format for all of these different use cases.
- *           - If the first thing in the definition is a URL, then it's recognised as a link reference (and produces an `<a href=""></a>`)
- *           - If the first thing in the definition isn't a URL, then it's recognised as a sidenote/footnote and tapping it will scroll you to that point (and popup the definition like Marco Arment's Bigfoot code).
  *
  * @param input The string content possibly containing markup syntax, e.g. "This is a *bold* string.
  * @param options An options object for the render.
+ * @param context The context to render in (defaults to `"block"`).
  *
  * @returns JSXNode, i.e. either a complete `JSXElement`, `null`, `undefined`, `string`, or an array of zero or more of those.
  */
-export declare function renderMarkup(input: string, options?: Partial<MarkupOptions>): JSXNode;
+export declare function renderMarkup(input: string, options: MarkupOptions, context?: string): JSXNode;

package/markup/render.js

@@ -1,119 +1,63 @@
-import { isArray } from "../util/array.js";
-import { mapArray } from "../util/transform.js";
-import { MARKUP_OPTIONS } from "./options.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.
- * - Default rules define syntax similar to Markdown but with improvements:
- *   1. Syntax is more intuitive (e.g. `*strong*` always uses `*` asterisk and `_em_` always uses `_` underscore, and URLs are always autolinked).
- *   2. More compatible with textboxes that wrap lines by default (e.g. single `\n` linebreaks don't need the trailing double space to, they're always treated as `<br />`).
- *   3. Don't support fussy fragile syntax that lets users make mistakes (e.g. literal HTML tags or `&amp;` character entities).
- *
- * DH: This code is heavily inspired by `simple-markdown`, but intends to be even simpler by always producing JSX elements.
- *
- * @todo [ ] Default rules support "list items containing paragraphs" syntax (CommonMark calls this loose lists).
- *           - i.e. Lists can include `\n\n` double line breaks, and wrap all their contents in `<p>` entities, i.e. childContext is "block"
- *           - Hard because you have to capture the entire list including `\n\n`, so there's no obvious place to end it.
- *           - If there are breaks then any sub-lines need to be indented by two or more spaces otherwise it will break the list.
- *           - Make reference lists support this loose format too.
- * @todo [ ] Default rules support tables using `|` pipe syntax.
- * @todo [ ] Default rules support todo lists using `- [x]` syntax.
- * @todo [ ] Default rules support new reference syntax (combines reference lists/sidenotes/footnotes/reference and produces <dl> syntax).
- *           - All of these can be the same because reference links and Extended Markdown footnotes are basically the same.
- *           - e.g. `[Google Maps][1]` → `[1]: http://google.com Content goes here` (Markdown reference link syntax).
- *           - e.g. `[Google Maps]` → `[Google Maps]: http://google.com Content goes here` syntax.
- *           - e.g. `[DNS]` → `[DNS]: Domain Name System (extended Markdown definition list format).
- *           - If a `[Reference]` does not correspond to anything it will not be linked and e.g. will appear unlinked.
- *           - Single/double quotes around definition part are optional and are trimmed from the start/end (Extended Markdown definition lists require quotes, but that's dumb).
- *           - A `<dl>` definition list is used as the output format for all of these different use cases.
- *           - If the first thing in the definition is a URL, then it's recognised as a link reference (and produces an `<a href=""></a>`)
- *           - If the first thing in the definition isn't a URL, then it's recognised as a sidenote/footnote and tapping it will scroll you to that point (and popup the definition like Marco Arment's Bigfoot code).
  *
  * @param input The string content possibly containing markup syntax, e.g. "This is a *bold* string.
  * @param options An options object for the render.
+ * @param context The context to render in (defaults to `"block"`).
  *
  * @returns JSXNode, i.e. either a complete `JSXElement`, `null`, `undefined`, `string`, or an array of zero or more of those.
  */
-export function renderMarkup(input, options) {
-    if (!input)
-        return null;
-    const combined = options ? { ...MARKUP_OPTIONS, ...options } : MARKUP_OPTIONS;
-    return _renderString(input, combined, combined.context);
-}
-/**
- * Render a string to its corresponding JSX node in a given context.
- */
-function _renderString(input, options, context) {
-    const nodes = Array.from(_parseString(input, options, context));
-    return !nodes.length ? null : nodes.length === 1 ? nodes[0] : nodes;
-}
-/**
- * Render a JSX node in a given context.
- */
-function _renderNode(node, options, context) {
-    if (!node)
-        return node;
-    if (typeof node === "string")
-        return _renderString(node, options, context);
-    if (isArray(node))
-        return mapArray(node, _renderNode, options, context);
-    return _renderElement(node, options, context);
-}
-/**
- * Render a JSX element in a given context.
- */
-function _renderElement(element, options, context) {
-    element.props.children = _renderNode(element.props.children, options, context);
-    return element;
+export function renderMarkup(input, options, context = "block") {
+    const arr = Array.from(_parseString(input, options, context));
+    return !arr.length ? null : arr.length === 1 ? arr[0] : arr;
 }
 /**
  * Parse a string to its corresponding JSX nodes in a given context.
- *
- * @param offset Keeps track of where we are within the wider string we're parsing when we're several calls deep.
+ * - This code is heavily inspired by `simple-markdown`, but intends to be even simpler (and faster) by always producing JSX elements.
  */
-function* _parseString(input, options, outerContext, offset = 0) {
-    let element = undefined;
-    let highPriority = Number.MIN_SAFE_INTEGER;
-    let lowIndex = Number.MIN_SAFE_INTEGER;
+function* _parseString(
+/** The input string. */
+input, 
+/** Options that configure the render including the rules we're using. */
+options, 
+/** The context for the render e.g. `"block"` */
+context, 
+/** The offset of where we are in the _original_ string — this is used to compute the `key` property for the returned element. */
+offset = 0) {
+    // The best matched rule is the one with the highest priority.
+    // If two have equal priority use the earliest match in the string.
+    let bestMatch = undefined;
+    let bestRule = undefined;
     // 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, 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 { index, length } = match;
-                if (length && (index < lowIndex || priority > highPriority)) {
-                    element = match;
-                    highPriority = priority;
-                    lowIndex = index;
-                }
+        const { priority, regexp, contexts } = rule;
+        // Skip rule if it has lower priority than the current best rule, or it doesn't apply in this context.
+        if ((!bestRule || priority >= bestRule.priority) && contexts.includes(context)) {
+            const match = regexp.exec(input);
+            // This rule is the best rule if it matches, has higher priority than the current best rule, or is earlier in the string than the current best rule.
+            if (match && (!bestRule || !bestMatch || priority > bestRule.priority || match.index < bestMatch.index)) {
+                bestRule = rule;
+                bestMatch = match;
             }
         }
     }
-    // Did at least one rule match?
-    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, 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 { index, length, context } = element;
-        element.key = (offset + index).toString();
-        yield context ? _renderElement(element, options, context) : element;
-        // Decrement the content.
-        const suffix = input.slice(index + length);
-        if (suffix.length)
-            yield* _parseString(suffix, options, outerContext, offset + index + length);
+    // Was there a matching rule?
+    if (bestRule && bestMatch) {
+        const { index, 0: { length }, } = bestMatch;
+        const end = bestMatch.index + length;
+        // Parse the prefix and yield any elements.
+        if (bestMatch.index > 0)
+            yield* _parseString(input.slice(0, bestMatch.index), options, context);
+        // Yield the matched element.
+        yield bestRule.render(bestMatch, options, (offset + index).toString());
+        // Parse the suffix and yield any elements.
+        // Pass `end` as `offset` so that `key` for any yielded elements acknowledges its increased position in the string.
+        if (input.length > end)
+            yield* _parseString(input.slice(end), options, context, end);
     }
-    else {
-        // If nothing matched return the entire string..
+    else if (input.length) {
+        // Nothing matched so return the entire string because this is a text node.
         yield input;
     }
 }

package/markup/rule/blockquote.d.ts

@@ -0,0 +1,8 @@
+export declare const BLOCKQUOTE_REGEXP: RegExp;
+/**
+ * Blockquote block.
+ * - `>` quote character followed by zero or more spaces.
+ * - No spaces can appear before the `>` quote character.
+ * - Quote block is only broken by `\n\n` two newline characters.
+ */
+export declare const BLOCKQUOTE_RULE: import("../util/rule.js").MarkupRule;

package/markup/rule/blockquote.js

@@ -0,0 +1,19 @@
+import { renderMarkup } from "../render.js";
+import { REACT_ELEMENT_TYPE } from "../util/internal.js";
+import { BLOCK_CONTENT_REGEXP, getBlockRegExp } from "../util/regexp.js";
+import { getMarkupRule } from "../util/rule.js";
+const PREFIX = ">";
+const INDENT = new RegExp(`^${PREFIX}`, "gm");
+export const BLOCKQUOTE_REGEXP = getBlockRegExp(`${PREFIX}${BLOCK_CONTENT_REGEXP}`);
+/**
+ * Blockquote block.
+ * - `>` quote character followed by zero or more spaces.
+ * - No spaces can appear before the `>` quote character.
+ * - Quote block is only broken by `\n\n` two newline characters.
+ */
+export const BLOCKQUOTE_RULE = getMarkupRule(BLOCKQUOTE_REGEXP, ([quote], options, key) => ({
+    key,
+    $$typeof: REACT_ELEMENT_TYPE,
+    type: "blockquote",
+    props: { children: renderMarkup(quote.replace(INDENT, ""), options, "block") },
+}), ["block", "list"]);

package/markup/rule/code.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Inline code.
+ * - Text surrounded by one or more "`" backtick tilde characters.
+ * - Unlike strong/emphasis first or last character of the element can be space, (e.g. `- abc -` will not work).
+ * - Closing characters must exactly match opening characters.
+ * - Same as Markdown syntax.
+ */
+export declare const CODE_RULE: import("../util/rule.js").MarkupRule;

package/markup/rule/code.js

@@ -0,0 +1,18 @@
+import { getRegExp } from "../../util/regexp.js";
+import { REACT_ELEMENT_TYPE } from "../util/internal.js";
+import { BLOCK_CONTENT_REGEXP } from "../util/regexp.js";
+import { getMarkupRule } from "../util/rule.js";
+const CODE_REGEXP = getRegExp(`(?<fence>\`+)(?<code>${BLOCK_CONTENT_REGEXP})\\k<fence>`);
+/**
+ * Inline code.
+ * - Text surrounded by one or more "`" backtick tilde characters.
+ * - Unlike strong/emphasis first or last character of the element can be space, (e.g. `- abc -` will not work).
+ * - Closing characters must exactly match opening characters.
+ * - Same as Markdown syntax.
+ */
+export const CODE_RULE = getMarkupRule(CODE_REGEXP, ({ groups: { code } }, options, key) => ({
+    key,
+    $$typeof: REACT_ELEMENT_TYPE,
+    type: "code",
+    props: { children: code },
+}), ["inline", "list"], 10);

package/markup/rule/fenced.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Fenced code blocks
+ * - Same as Markdown syntax.
+ * - Start when we reach an opening fence on a new line.
+ * - Stop when we reach a matching closing fence on a new line, or the end of the string.
+ * - Closing fence must be exactly the same as the opening fence, and can be made of three or more "```" backticks, or three or more `~~~` tildes.
+ * - 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 less confusing and more common).
+ */
+export declare const FENCED_RULE: import("../util/rule.js").MarkupRule;

package/markup/rule/fenced.js

@@ -0,0 +1,34 @@
+import { REACT_ELEMENT_TYPE } from "../util/internal.js";
+import { BLOCK_CONTENT_REGEXP, BLOCK_START_REGEXP, LINE_CONTENT_REGEXP, LINE_SPACE_REGEXP, getBlockRegExp } from "../util/regexp.js";
+import { getMarkupRule } from "../util/rule.js";
+const FENCE = "`{3,}|~{3,}";
+const FENCED_REGEXP = getBlockRegExp(`(?<code>${BLOCK_CONTENT_REGEXP})`, 
+// Starts with the fence
+`${BLOCK_START_REGEXP}(?<fence>${FENCE}) *(?<title>${LINE_CONTENT_REGEXP})\n`, 
+// Ends when we hit the end of the string or the matching closing fence (trims any matching newlines after the fence).
+`(?:${LINE_SPACE_REGEXP}*\n\\k<fence>(?:\\s*\\n)?|$)`);
+/**
+ * Fenced code blocks
+ * - Same as Markdown syntax.
+ * - Start when we reach an opening fence on a new line.
+ * - Stop when we reach a matching closing fence on a new line, or the end of the string.
+ * - Closing fence must be exactly the same as the opening fence, and can be made of three or more "```" backticks, or three or more `~~~` tildes.
+ * - 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 less confusing and more common).
+ */
+export const FENCED_RULE = getMarkupRule(FENCED_REGEXP, ({ groups: { title, code } }, options, key) => ({
+    key,
+    $$typeof: REACT_ELEMENT_TYPE,
+    type: "pre",
+    props: {
+        children: {
+            $$typeof: REACT_ELEMENT_TYPE,
+            type: "code",
+            key: null,
+            props: {
+                title: title?.trim() || undefined,
+                children: code.trim(),
+            },
+        },
+    },
+}), ["block", "list"], 10);

package/markup/rule/heading.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Headings are single line only (don't allow multiline).
+ * - `#` 1-6 hashes, then one or more spaces, then the title.
+ * - `#` must be the first character on the line.
+ * - Markdown's underline syntax is not supported (for simplification).
+ */
+export declare const HEADING_RULE: import("../util/rule.js").MarkupRule;

package/markup/rule/heading.js

@@ -0,0 +1,17 @@
+import { renderMarkup } from "../render.js";
+import { REACT_ELEMENT_TYPE } from "../util/internal.js";
+import { LINE_CONTENT_REGEXP, LINE_SPACE_REGEXP, getLineRegExp } from "../util/regexp.js";
+import { getMarkupRule } from "../util/rule.js";
+const HEADING_REGEXP = getLineRegExp(`(?<prefix>#{1,6})(?:${LINE_SPACE_REGEXP}+(?<heading>${LINE_CONTENT_REGEXP}))?`);
+/**
+ * Headings are single line only (don't allow multiline).
+ * - `#` 1-6 hashes, then one or more spaces, then the title.
+ * - `#` must be the first character on the line.
+ * - Markdown's underline syntax is not supported (for simplification).
+ */
+export const HEADING_RULE = getMarkupRule(HEADING_REGEXP, ({ groups: { prefix, heading = "" } }, options, key) => ({
+    key,
+    $$typeof: REACT_ELEMENT_TYPE,
+    type: `h${prefix.length}`,
+    props: { children: renderMarkup(heading.trim(), options, "inline") },
+}), ["block"]);

package/markup/rule/index.d.ts

@@ -0,0 +1,44 @@
+import type { MarkupRules } from "../util/rule.js";
+/** Markup rules that work in a block context. */
+export declare const MARKUP_RULES_BLOCK: MarkupRules;
+/** Markup rules that work in an inline context. */
+export declare const MARKUP_RULES_INLINE: MarkupRules;
+/**
+ * Default markup rules
+ *
+ * These rules define a syntax similar to Markdown but with improvements:
+ * 1. Syntax is more intuitive (e.g. `*strong*` always uses `*` asterisk and `_em_` always uses `_` underscore, and URLs are always autolinked).
+ * 2. More compatible with textboxes that wrap lines by default (e.g. single `\n` linebreaks don't need the trailing double space to, they're always treated as `<br />`).
+ * 3. Don't support fussy fragile syntax that lets users make mistakes (e.g. literal HTML tags or `&amp;` character entities).
+ *
+ * @todo Default rules support "list items containing paragraphs" syntax (CommonMark calls this loose lists).
+ *   - i.e. Lists can include `\n\n` double line breaks, and wrap all their contents in `<p>` entities, i.e. childContext is "block"
+ *   - Hard because you have to capture the entire list including `\n\n`, so there's no obvious place to end it.
+ *   - If there are breaks then any sub-lines need to be indented by two or more spaces otherwise it will break the list.
+ *   - Make reference lists support this loose format too.
+ * @todo [ ] Default rules support tables using `|` pipe syntax.
+ * @todo [ ] Default rules support todo lists using `- [x]` syntax.
+ * @todo [ ] Default rules support new reference syntax (combines reference lists/sidenotes/footnotes/reference and produces <dl> syntax).
+ *   - All of these can be the same because reference links and Extended Markdown footnotes are basically the same.
+ *   - e.g. `[Google Maps][1]` → `[1]: http://google.com Content goes here` (Markdown reference link syntax).
+ *   - e.g. `[Google Maps]` → `[Google Maps]: http://google.com Content goes here` syntax.
+ *   - e.g. `[DNS]` → `[DNS]: Domain Name System (extended Markdown definition list format).
+ *   - If a `[Reference]` does not correspond to anything it will not be linked and e.g. will appear unlinked.
+ *   - Single/double quotes around definition part are optional and are trimmed from the start/end (Extended Markdown definition lists require quotes, but that's dumb).
+ *   - A `<dl>` definition list is used as the output format for all of these different use cases.
+ *   - If the first thing in the definition is a URL, then it's recognised as a link reference (and produces an `<a href=""></a>`)
+ *   - If the first thing in the definition isn't a URL, then it's recognised as a sidenote/footnote and tapping it will scroll you to that point (and popup the definition like Marco Arment's Bigfoot code).
+ */
+export declare const MARKUP_RULES: MarkupRules;
+export * from "./blockquote.js";
+export * from "./code.js";
+export * from "./fenced.js";
+export * from "./heading.js";
+export * from "./inline.js";
+export * from "./linebreak.js";
+export * from "./link.js";
+export * from "./link.js";
+export * from "./ordered.js";
+export * from "./paragraph.js";
+export * from "./separator.js";
+export * from "./unordered.js";

package/markup/rule/index.js

@@ -0,0 +1,63 @@
+import { BLOCKQUOTE_RULE } from "./blockquote.js";
+import { CODE_RULE } from "./code.js";
+import { FENCED_RULE } from "./fenced.js";
+import { HEADING_RULE } from "./heading.js";
+import { INLINE_RULE } from "./inline.js";
+import { LINEBREAK_RULE } from "./linebreak.js";
+import { LINK_RULE } from "./link.js";
+import { AUTOLINK_RULE } from "./link.js";
+import { ORDERED_RULE } from "./ordered.js";
+import { PARAGRAPH_RULE } from "./paragraph.js";
+import { SEPARATOR_RULE } from "./separator.js";
+import { UNORDERED_RULE } from "./unordered.js";
+/** Markup rules that work in a block context. */
+export const MARKUP_RULES_BLOCK = [
+    FENCED_RULE,
+    HEADING_RULE,
+    SEPARATOR_RULE,
+    UNORDERED_RULE,
+    ORDERED_RULE,
+    BLOCKQUOTE_RULE,
+    PARAGRAPH_RULE,
+];
+/** Markup rules that work in an inline context. */
+export const MARKUP_RULES_INLINE = [CODE_RULE, LINK_RULE, AUTOLINK_RULE, INLINE_RULE, LINEBREAK_RULE];
+/**
+ * Default markup rules
+ *
+ * These rules define a syntax similar to Markdown but with improvements:
+ * 1. Syntax is more intuitive (e.g. `*strong*` always uses `*` asterisk and `_em_` always uses `_` underscore, and URLs are always autolinked).
+ * 2. More compatible with textboxes that wrap lines by default (e.g. single `\n` linebreaks don't need the trailing double space to, they're always treated as `<br />`).
+ * 3. Don't support fussy fragile syntax that lets users make mistakes (e.g. literal HTML tags or `&amp;` character entities).
+ *
+ * @todo Default rules support "list items containing paragraphs" syntax (CommonMark calls this loose lists).
+ *   - i.e. Lists can include `\n\n` double line breaks, and wrap all their contents in `<p>` entities, i.e. childContext is "block"
+ *   - Hard because you have to capture the entire list including `\n\n`, so there's no obvious place to end it.
+ *   - If there are breaks then any sub-lines need to be indented by two or more spaces otherwise it will break the list.
+ *   - Make reference lists support this loose format too.
+ * @todo [ ] Default rules support tables using `|` pipe syntax.
+ * @todo [ ] Default rules support todo lists using `- [x]` syntax.
+ * @todo [ ] Default rules support new reference syntax (combines reference lists/sidenotes/footnotes/reference and produces <dl> syntax).
+ *   - All of these can be the same because reference links and Extended Markdown footnotes are basically the same.
+ *   - e.g. `[Google Maps][1]` → `[1]: http://google.com Content goes here` (Markdown reference link syntax).
+ *   - e.g. `[Google Maps]` → `[Google Maps]: http://google.com Content goes here` syntax.
+ *   - e.g. `[DNS]` → `[DNS]: Domain Name System (extended Markdown definition list format).
+ *   - If a `[Reference]` does not correspond to anything it will not be linked and e.g. will appear unlinked.
+ *   - Single/double quotes around definition part are optional and are trimmed from the start/end (Extended Markdown definition lists require quotes, but that's dumb).
+ *   - A `<dl>` definition list is used as the output format for all of these different use cases.
+ *   - If the first thing in the definition is a URL, then it's recognised as a link reference (and produces an `<a href=""></a>`)
+ *   - If the first thing in the definition isn't a URL, then it's recognised as a sidenote/footnote and tapping it will scroll you to that point (and popup the definition like Marco Arment's Bigfoot code).
+ */
+export const MARKUP_RULES = [...MARKUP_RULES_BLOCK, ...MARKUP_RULES_INLINE];
+export * from "./blockquote.js";
+export * from "./code.js";
+export * from "./fenced.js";
+export * from "./heading.js";
+export * from "./inline.js";
+export * from "./linebreak.js";
+export * from "./link.js";
+export * from "./link.js";
+export * from "./ordered.js";
+export * from "./paragraph.js";
+export * from "./separator.js";
+export * from "./unordered.js";

package/markup/rule/inline.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Inline strong, emphasis, insert, delete, highlight.
+ * - Inline strong text wrapped in one or more `*` asterisks.
+ * - Inline emphasis text wrapped in one or more `_` underscores.
+ * - Inline inserted text wrapped in one or more `+` pluses.
+ * - Inline deleted text wrapped in one or more `-` minuses or `~` tildes.
+ * - Inline highlighted text wrapped in one or more `=` equals or `:` colons.
+ * - Whitespace cannot be the first or last character of the element (e.g. `* abc *` will not work).
+ * - Closing chars must match opening characters.
+ * - Cannot occur in the middle of a word (e.g. `this*that*this` will not work).
+ * - Closing characters must exactly match opening characters.
+ * - Different to Markdown: strong is always surrounded by `*asterisks*` and emphasis is always surrounded by `_underscores_` (strong isn't 'double emphasis').
+ */
+export declare const INLINE_RULE: import("../util/rule.js").MarkupRule;

package/markup/rule/inline.js

@@ -0,0 +1,26 @@
+import { renderMarkup } from "../render.js";
+import { REACT_ELEMENT_TYPE } from "../util/internal.js";
+import { getWordRegExp } from "../util/regexp.js";
+import { getMarkupRule } from "../util/rule.js";
+/** Map characters, e.g. `*`, to their coresponding HTML tag, e.g. `strong` */
+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.
+const INLINE_REGEXP = getWordRegExp(`(?<wrap>(?<char>[${Object.keys(INLINE_CHARS).join("")}])+)(?<text>(?!\\k<char>)\\S(?:[\\s\\S]*?(?!\\k<char>)\\S)?)\\k<wrap>`);
+/**
+ * Inline strong, emphasis, insert, delete, highlight.
+ * - Inline strong text wrapped in one or more `*` asterisks.
+ * - Inline emphasis text wrapped in one or more `_` underscores.
+ * - Inline inserted text wrapped in one or more `+` pluses.
+ * - Inline deleted text wrapped in one or more `-` minuses or `~` tildes.
+ * - Inline highlighted text wrapped in one or more `=` equals or `:` colons.
+ * - Whitespace cannot be the first or last character of the element (e.g. `* abc *` will not work).
+ * - Closing chars must match opening characters.
+ * - Cannot occur in the middle of a word (e.g. `this*that*this` will not work).
+ * - Closing characters must exactly match opening characters.
+ * - Different to Markdown: strong is always surrounded by `*asterisks*` and emphasis is always surrounded by `_underscores_` (strong isn't 'double emphasis').
+ */
+export const INLINE_RULE = getMarkupRule(INLINE_REGEXP, ({ groups: { char, text } }, options, key) => ({
+    key,
+    $$typeof: REACT_ELEMENT_TYPE,
+    type: INLINE_CHARS[char],
+    props: { children: renderMarkup(text, options, "inline") },
+}), ["inline", "list", "link"]);