securemark 0.293.3 → 0.293.5

package/src/combinator/data/parser.ts

@@ -1,5 +1,4 @@
 import { Delimiters } from './parser/context/delimiter';
-import { MarkdownParser } from '../../../markdown';
 
 export type Parser<N, C extends CtxOptions = CtxOptions, D extends Parser<unknown, C>[] = any>
   = (input: Input<C & Ctx>) => Result<N, C, D>;
@@ -38,8 +37,6 @@ export type IntermediateParser<P extends Parser<unknown>> = Parser<SubNode<P>, C
 type ExtractSubNode<D extends Parser<unknown>[]> = ExtractSubParser<D> extends infer N ? N extends Parser<infer U> ? U : never : never;
 type ExtractSubParser<D extends Parser<unknown>[]> = D extends (infer P)[] ? P extends Parser<unknown> ? P : never : never;
 
-export function input(source: string, context: CtxOptions): Input<Ctx>;
-export function input(source: string, context: MarkdownParser.Options): Input<MarkdownParser.Context>;
 export function input(source: string, context: CtxOptions): Input<Ctx> {
   // @ts-expect-error
   context.source = source;

package/src/parser/api/bind.ts

@@ -1,7 +1,7 @@
 import { ParserSettings, Progress } from '../../..';
 import { MarkdownParser } from '../../../markdown';
 import { input, eval } from '../../combinator/data/parser';
-import { segment, validate, MAX_INPUT_SIZE } from '../segment';
+import { segment } from '../segment';
 import { header } from '../header';
 import { block } from '../block';
 import { normalize } from './normalize';
@@ -44,7 +44,7 @@ export function bind(target: DocumentFragment | HTMLElement | ShadowRoot, settin
   function* parse(source: string): Generator<Progress, undefined, undefined> {
     if (settings.chunk && revision) throw new Error('Chunks cannot be updated');
     const url = headers(source).find(field => field.toLowerCase().startsWith('url:'))?.slice(4).trim() ?? '';
-    source = normalize(validate(source, MAX_INPUT_SIZE) ? source : source.slice(0, MAX_INPUT_SIZE + 1));
+    source = normalize(source);
     // Change the object identity.
     context = {
       ...context,
@@ -78,7 +78,7 @@ export function bind(target: DocumentFragment | HTMLElement | ShadowRoot, settin
     for (; index < sourceSegments.length - last; ++index) {
       assert(rev === revision);
       const seg = sourceSegments[index];
-      const es = eval(header(input(seg, { header: index === 0 })) || block(input(seg, context)), []);
+      const es = eval(header(input(seg, { header: index === 0 } as MarkdownParser.Context)) || block(input(seg, context)), []);
       blocks.splice(index, 0, [seg, es, url]);
       if (es.length === 0) continue;
       // All deletion processes always run after all addition processes have done.

package/src/parser/api/normalize.ts

@@ -63,9 +63,7 @@ const unreadableEscapableCharacters = unreadableHTMLEntityNames
   .map(name => eval(unsafehtmlentity(input(`&${name};`, {})))![0]);
 assert(unreadableEscapableCharacters.length === unreadableHTMLEntityNames.length);
 assert(unreadableEscapableCharacters.every(c => c.length === 1));
-const unreadableEscapableCharacter = new RegExp(`[${
-  [...new Set<string>(unreadableEscapableCharacters)].join('')
-}]`, 'g');
+const unreadableEscapableCharacter = new RegExp(`[${unreadableEscapableCharacters.join('')}]`, 'g');
 assert(!unreadableEscapableCharacter.source.includes('&'));
 
 // https://www.pandanoir.info/entry/2018/03/11/193000

package/src/parser/api/parse.ts

@@ -34,7 +34,7 @@ export function parse(source: string, opts: Options = {}, context?: MarkdownPars
   const node = frag();
   let index = 0;
   for (const seg of segment(source)) {
-    node.append(...eval(header(input(seg, { header: index++ === 0 })) || block(input(seg, context)), []));
+    node.append(...eval(header(input(seg, { header: index++ === 0 } as MarkdownParser.Context)) || block(input(seg, context)), []));
   }
   assert(opts.id !== '' || !node.querySelector('[id], .index[href], .label[href], .annotation > a[href], .reference > a[href]'));
   if (opts.test) return node;

package/src/parser/block/dlist.test.ts

@@ -69,7 +69,7 @@ describe('Unit: parser/block/dlist', () => {
     it('indexer', () => {
       assert.deepStrictEqual(inspect(parser('~ a [|b]'), ctx), [['<dl><dt id="index::b">a<span class="indexer" data-index="b"></span></dt><dd></dd></dl>'], '']);
       assert.deepStrictEqual(inspect(parser('~ a [|b]\\'), ctx), [['<dl><dt id="index::a_[|b]">a <span class="invalid">[|b]</span></dt><dd></dd></dl>'], '']);
-      assert.deepStrictEqual(inspect(parser('~ A'), ctx), [['<dl><dt id="index::A">A</dt><dd></dd></dl>'], '']);
+      assert.deepStrictEqual(inspect(parser('~ - [|b]'), ctx), [['<dl><dt id="index::b">-<span class="indexer" data-index="b"></span></dt><dd></dd></dl>'], '']);
       assert.deepStrictEqual(inspect(parser('~ *A*'), ctx), [['<dl><dt id="index::A"><em>A</em></dt><dd></dd></dl>'], '']);
       assert.deepStrictEqual(inspect(parser('~ `A`'), ctx), [['<dl><dt id="index::`A`"><code data-src="`A`">A</code></dt><dd></dd></dl>'], '']);
       assert.deepStrictEqual(inspect(parser('~ ${A}$'), ctx), [['<dl><dt id="index::${A}$"><span class="math" translate="no" data-src="${A}$">${A}$</span></dt><dd></dd></dl>'], '']);

package/src/parser/block/heading.test.ts

@@ -79,6 +79,7 @@ describe('Unit: parser/block/heading', () => {
       assert.deepStrictEqual(inspect(parser('# a [|b] [|c]'), ctx), [['<h1 id="index::c">a <span class="invalid">[|b]</span><span class="indexer" data-index="c"></span></h1>'], '']);
       assert.deepStrictEqual(inspect(parser('# a  [|b] \n'), ctx), [['<h1 id="index::b">a<span class="indexer" data-index="b"></span></h1>'], '']);
       assert.deepStrictEqual(inspect(parser('# a \\[|b]'), ctx), [['<h1 id="index::a_[|b]">a [|b]</h1>'], '']);
+      assert.deepStrictEqual(inspect(parser('# - [|b]'), ctx), [['<h1 id="index::b">-<span class="indexer" data-index="b"></span></h1>'], '']);
       assert.deepStrictEqual(inspect(parser('## a [|b] [|c]'), ctx), [['<h2 id="index::c">a <span class="invalid">[|b]</span><span class="indexer" data-index="c"></span></h2>'], '']);
     });
 

package/src/parser/block/olist.test.ts

@@ -138,6 +138,7 @@ describe('Unit: parser/block/olist', () => {
       assert.deepStrictEqual(inspect(parser('1. [|a]'), ctx), [['<ol><li id="index::[|a]"><span class="invalid">[|a]</span></li></ol>'], '']);
       assert.deepStrictEqual(inspect(parser('1. a [|]'), ctx), [['<ol><li>a<span class="indexer" data-index=""></span></li></ol>'], '']);
       assert.deepStrictEqual(inspect(parser('1. a [|b]'), ctx), [['<ol><li id="index::b">a<span class="indexer" data-index="b"></span></li></ol>'], '']);
+      assert.deepStrictEqual(inspect(parser('1. - [|]'), ctx), [['<ol><li>-<span class="indexer" data-index=""></span></li></ol>'], '']);
       assert.deepStrictEqual(inspect(parser('1. [ ] [|a]'), ctx), [['<ol class="checklist"><li id="index::[|a]"><span class="checkbox">☐</span><span class="invalid">[|a]</span></li></ol>'], '']);
       assert.deepStrictEqual(inspect(parser('1. [ ] a [|b]'), ctx), [['<ol class="checklist"><li id="index::b"><span class="checkbox">☐</span>a<span class="indexer" data-index="b"></span></li></ol>'], '']);
       assert.deepStrictEqual(inspect(parser('1. a [|]\n 1. c [|d]'), ctx), [['<ol><li>a<span class="indexer" data-index=""></span><ol><li id="index::d">c<span class="indexer" data-index="d"></span></li></ol></li></ol>'], '']);

package/src/parser/block/reply/quote.ts

@@ -3,7 +3,6 @@ import { union, some, block, validate, rewrite, convert, lazy, fmap } from '../.
 import { math } from '../../inline/math';
 import { autolink } from '../../inline/autolink';
 import { linebreak, unescsource, anyline } from '../../source';
-import { linearize } from '../../util';
 import { html, defrag } from 'typed-dom/dom';
 
 export const syntax = />+[^\S\n]/y;
@@ -11,7 +10,8 @@ export const syntax = />+[^\S\n]/y;
 export const quote: ReplyParser.QuoteParser = lazy(() => block(fmap(
   rewrite(
     some(validate(syntax, anyline)),
-    linearize(convert(
+    convert(
+      // TODO: インデント数を渡してインデント数前の行頭確認を行う実装に置き換える
       source => source.replace(/(?<=^>+[^\S\n])/mg, '\r'),
       some(union([
         // quote補助関数が残した数式をパースする。
@@ -20,9 +20,9 @@ export const quote: ReplyParser.QuoteParser = lazy(() => block(fmap(
         linebreak,
         unescsource,
       ])),
-      false), -1)),
-  (ns: [string, ...(string | HTMLElement)[]]) => [
+      false)),
+  (ns: [string, ...(string | HTMLElement)[]], { source, position }) => [
+    source[position - 1] === '\n' ? ns.pop() as HTMLBRElement : html('br'),
     html('span', { class: 'quote' }, defrag(ns)),
-    html('br'),
-  ]),
+  ].reverse()),
   false));

package/src/parser/block/reply.ts

@@ -4,8 +4,8 @@ import { cite, syntax as csyntax } from './reply/cite';
 import { quote, syntax as qsyntax } from './reply/quote';
 import { inline } from '../inline';
 import { anyline } from '../source';
-import { linearize } from '../util';
 import { visualize, trimBlankNodeEnd } from '../visibility';
+import { push } from 'spica/array';
 import { html, defrag } from 'typed-dom/dom';
 
 const delimiter = new RegExp(`${csyntax.source}|${qsyntax.source}`, 'y');
@@ -16,6 +16,7 @@ export const reply: ReplyParser = block(validate(csyntax, fmap(
     quote,
     rewrite(
       some(anyline, delimiter),
-      visualize(linearize(some(inline), 1))),
+      visualize(fmap(some(inline), (ns, { source, position }) =>
+        source[position - 1] === '\n' ? ns : push(ns, [html('br')])))),
   ])),
   ns => [html('p', trimBlankNodeEnd(defrag(ns)))])));

package/src/parser/block/ulist.test.ts

@@ -75,6 +75,7 @@ describe('Unit: parser/block/ulist', () => {
       assert.deepStrictEqual(inspect(parser('- [|a]'), ctx), [['<ul><li id="index::[|a]"><span class="invalid">[|a]</span></li></ul>'], '']);
       assert.deepStrictEqual(inspect(parser('- a [|]'), ctx), [['<ul><li>a<span class="indexer" data-index=""></span></li></ul>'], '']);
       assert.deepStrictEqual(inspect(parser('- a [|b]'), ctx), [['<ul><li id="index::b">a<span class="indexer" data-index="b"></span></li></ul>'], '']);
+      assert.deepStrictEqual(inspect(parser('- - [|b]'), ctx), [['<ul><li id="index::b">-<span class="indexer" data-index="b"></span></li></ul>'], '']);
       assert.deepStrictEqual(inspect(parser('- [ ] [|a]'), ctx), [['<ul class="checklist"><li id="index::[|a]"><span class="checkbox">☐</span><span class="invalid">[|a]</span></li></ul>'], '']);
       assert.deepStrictEqual(inspect(parser('- [ ] a [|b]'), ctx), [['<ul class="checklist"><li id="index::b"><span class="checkbox">☐</span>a<span class="indexer" data-index="b"></span></li></ul>'], '']);
       assert.deepStrictEqual(inspect(parser('- a [|]\n - c [|d]'), ctx), [['<ul><li>a<span class="indexer" data-index=""></span><ul><li id="index::d">c<span class="indexer" data-index="d"></span></li></ul></li></ul>'], '']);

package/src/parser/header.test.ts

@@ -21,7 +21,8 @@ describe('Unit: parser/header', () => {
       assert.deepStrictEqual(inspect(parser('---\n\n---'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('---\n \n---'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('---\n-\n---'), ctx), [['<pre class="invalid" translate="no">---\n-\n---</pre>'], '']);
-      assert.deepStrictEqual(inspect(parser('----\na: b\n----'), ctx), [['<pre class="invalid" translate="no">----\na: b\n----</pre>'], '']);
+      assert.deepStrictEqual(inspect(parser('---\na: b\n----'), ctx), [['<pre class="invalid" translate="no">---\na: b\n----</pre>'], '']);
+      assert.deepStrictEqual(inspect(parser('----\na: b\n---'), ctx), [['<pre class="invalid" translate="no">----\na: b\n---</pre>'], '']);
       assert.deepStrictEqual(inspect(parser(`---\n${'a: b\n'.repeat(101)}---`), ctx), [[`<pre class="invalid" translate="no">---\n${'a: b\n'.repeat(101)}---</pre>`], '']);
     });
 
@@ -30,6 +31,7 @@ describe('Unit: parser/header', () => {
       assert.deepStrictEqual(inspect(parser('---\na: b\n---\n'), ctx), [['<aside class="header"><details open=""><summary>Header</summary><span class="field" data-name="a" data-value="b"><span class="field-name">a</span>: <span class="field-value">b</span>\n</span></details></aside>'], '']);
       assert.deepStrictEqual(inspect(parser('---\na: b\nC: D e\n---\n'), ctx), [['<aside class="header"><details open=""><summary>Header</summary><span class="field" data-name="a" data-value="b"><span class="field-name">a</span>: <span class="field-value">b</span>\n</span><span class="field" data-name="c" data-value="D e"><span class="field-name">C</span>: <span class="field-value">D e</span>\n</span></details></aside>'], '']);
       assert.deepStrictEqual(inspect(parser('--- \r\na: b \r\n--- \r\n \r\n \r\na'), ctx), [['<aside class="header"><details open=""><summary>Header</summary><span class="field" data-name="a" data-value="b"><span class="field-name">a</span>: <span class="field-value">b</span>\n</span></details></aside>'], ' \r\na']);
+      assert.deepStrictEqual(inspect(parser('----\na: b\n----'), ctx), [['<aside class="header"><details open=""><summary>Header</summary><span class="field" data-name="a" data-value="b"><span class="field-name">a</span>: <span class="field-value">b</span>\n</span></details></aside>'], '']);
     });
 
   });

package/src/parser/header.ts

@@ -7,7 +7,7 @@ import { normalize } from './api/normalize';
 import { html, defrag } from 'typed-dom/dom';
 
 export const header: MarkdownParser.HeaderParser = lazy(() => validate(
-  /---+[^\S\v\f\r\n]*\r?\n[^\S\n]*(?=\S)/y,
+  /---+[^\S\v\f\r\n]*\r?\n(?=\S)/y,
   inits([
     rewrite(
       ({ context }) => {
@@ -23,7 +23,7 @@ export const header: MarkdownParser.HeaderParser = lazy(() => validate(
       block(
         union([
           validate(({ context }) => context.header ?? true,
-          focus(/---[^\S\v\f\r\n]*\r?\n(?:[A-Za-z][0-9A-Za-z]*(?:-[A-Za-z][0-9A-Za-z]*)*:[ \t]+\S[^\v\f\r\n]*\r?\n){1,100}---[^\S\v\f\r\n]*(?:$|\r?\n)/y,
+          focus(/(---+)[^\S\v\f\r\n]*\r?\n(?:[A-Za-z][0-9A-Za-z]*(?:-[A-Za-z][0-9A-Za-z]*)*:[ \t]+\S[^\v\f\r\n]*\r?\n){1,100}\1[^\S\v\f\r\n]*(?:$|\r?\n)/y,
           convert(source =>
             normalize(source.slice(source.indexOf('\n') + 1, source.trimEnd().lastIndexOf('\n'))).replace(/(\S)\s+$/mg, '$1'),
             fmap(

package/src/parser/inline/emphasis.test.ts

@@ -40,6 +40,7 @@ describe('Unit: parser/inline/emphasis', () => {
 
     it('nest', () => {
       assert.deepStrictEqual(inspect(parser('*a *b**'), ctx), [['<em>a <em>b</em></em>'], '']);
+      assert.deepStrictEqual(inspect(parser('*- *b**'), ctx), [['<em>- <em>b</em></em>'], '']);
       assert.deepStrictEqual(inspect(parser('*a **b***'), ctx), [['<em>a <strong>b</strong></em>'], '']);
       assert.deepStrictEqual(inspect(parser('*a\\ *b**'), ctx), [['<em>a <em>b</em></em>'], '']);
       assert.deepStrictEqual(inspect(parser('*a&Tab;*b**'), ctx), [['<em>a\t<em>b</em></em>'], '']);

package/src/parser/inline/html.test.ts

@@ -67,7 +67,7 @@ describe('Unit: parser/inline/html', () => {
       assert.deepStrictEqual(inspect(parser('<wbr >'), ctx), [['<wbr>'], '']);
       assert.deepStrictEqual(inspect(parser('<wbr>a'), ctx), [['<wbr>'], 'a']);
       assert.deepStrictEqual(inspect(parser('<bdi >a</bdi>'), ctx), [['<bdi>a</bdi>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdi  >a</bdi>'), ctx), [['<bdi>a</bdi>'], '']);
+      assert.deepStrictEqual(inspect(parser('<bdi  >a</bdi>'), ctx), [['<span class="invalid">&lt;bdi  &gt;a&lt;/bdi&gt;</span>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdi> a</bdi>'), ctx), [['<bdi> a</bdi>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdi> a </bdi>'), ctx), [['<bdi> a </bdi>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdi>  a  </bdi>'), ctx), [['<bdi> a </bdi>'], '']);
@@ -122,8 +122,8 @@ describe('Unit: parser/inline/html', () => {
       assert.deepStrictEqual(inspect(parser('<bdo diR="rtl">a</bdo>'), ctx), [['<span class="invalid">&lt;bdo diR="rtl"&gt;a&lt;/bdo&gt;</span>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdo dir="rtl">a</bdo>'), ctx), [['<bdo dir="rtl">a</bdo>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdo dir="rtl" >a</bdo>'), ctx), [['<bdo dir="rtl">a</bdo>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdo dir="rtl"  >a</bdo>'), ctx), [['<bdo dir="rtl">a</bdo>'], '']);
-      assert.deepStrictEqual(inspect(parser('<bdo  dir="rtl">a</bdo>'), ctx), [['<bdo dir="rtl">a</bdo>'], '']);
+      assert.deepStrictEqual(inspect(parser('<bdo dir="rtl"  >a</bdo>'), ctx), [['<span class="invalid">&lt;bdo dir="rtl"  &gt;a&lt;/bdo&gt;</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('<bdo  dir="rtl">a</bdo>'), ctx), [['<span class="invalid">&lt;bdo  dir="rtl"&gt;a&lt;/bdo&gt;</span>'], '']);
       assert.deepStrictEqual(inspect(parser('<wbr\n>'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('<wbr \n>'), ctx), [['<span class="invalid">&lt;wbr </span>'], '\n>']);
       assert.deepStrictEqual(inspect(parser('<wbr constructor>'), ctx), [['<span class="invalid">&lt;wbr constructor&gt;</span>'], '']);

package/src/parser/inline/html.ts

@@ -20,13 +20,13 @@ const attrspecs = {
 Object.setPrototypeOf(attrspecs, null);
 Object.values(attrspecs).forEach(o => Object.setPrototypeOf(o, null));
 
-export const html: HTMLParser = lazy(() => validate(/<[a-z]+(?=[^\S\n]|>)/yi,
+export const html: HTMLParser = lazy(() => validate(/<[a-z]+(?=[ >])/yi,
   union([
     surround(
       // https://html.spec.whatwg.org/multipage/syntax.html#void-elements
-      str(/<(?:area|base|br|col|embed|hr|img|input|link|meta|source|track|wbr)(?=[^\S\n]|>)/yi),
+      str(/<(?:area|base|br|col|embed|hr|img|input|link|meta|source|track|wbr)(?=[ >])/yi),
       some(union([attribute])),
-      open(str(/[^\S\n]*/y), str('>'), true),
+      open(str(/ ?/y), str('>'), true),
       true,
       ([as, bs = [], cs], context) =>
         [[elem(as[0].slice(1), false, push(unshift(as, bs), cs), [], [], context)]],
@@ -38,14 +38,14 @@ export const html: HTMLParser = lazy(() => validate(/<[a-z]+(?=[^\S\n]|>)/yi,
       ([, tag]) =>
         surround<HTMLParser.TagParser, string>(
           surround(
-            str(`<${tag}`), some(attribute), open(str(/[^\S\n]*/y), str('>'), true),
+            str(`<${tag}`), some(attribute), open(str(/ ?/y), str('>'), true),
             true,
             ([as, bs = [], cs]) => [push(unshift(as, bs), cs)],
             ([as, bs = []]) => [unshift(as, bs)]),
           // 不可視のHTML構造が可視構造を変化させるべきでない。
           // 可視のHTMLは優先度変更を検討する。
           // このため<>は将来的に共通構造を変化させる可能性があり
-          // 共通構造を変更させない非構造文字列としては依然としてエスケープを要する。
+          // 共通構造を変化させない非構造文字列としては依然としてエスケープを要する。
           precedence(0, recursion(Recursion.inline,
           some(union([
             some(inline, blankWith('\n', `</${tag}>`)),
@@ -61,9 +61,9 @@ export const html: HTMLParser = lazy(() => validate(/<[a-z]+(?=[^\S\n]|>)/yi,
       new Map())),
     surround(
       // https://html.spec.whatwg.org/multipage/syntax.html#void-elements
-      str(/<[a-z]+(?=[^\S\n]|>)/yi),
+      str(/<[a-z]+(?=[ >])/yi),
       some(union([attribute])),
-      open(str(/[^\S\n]*/y), str('>'), true),
+      open(str(/ ?/y), str('>'), true),
       true,
       ([as, bs = [], cs], context) =>
         [[elem(as[0].slice(1), false, push(unshift(as, bs), cs), [], [], context)]],
@@ -72,8 +72,8 @@ export const html: HTMLParser = lazy(() => validate(/<[a-z]+(?=[^\S\n]|>)/yi,
   ])));
 
 export const attribute: HTMLParser.AttributeParser = union([
-  str(/[^\S\n]+[a-z]+(?:-[a-z]+)*(?:="(?:\\[^\n]|[^\\\n"])*")?(?=[^\S\n]|>)/yi),
-  str(/[^\S\n]+[^\s<>]+/y),
+  str(/ [a-z]+(?:-[a-z]+)*(?:="(?:\\[^\n]|[^\\\n"])*")?(?=[ >])/yi),
+  str(/ [^\s<>]+/y),
 ]);
 
 function elem(tag: string, content: boolean, as: string[], bs: (HTMLElement | string)[], cs: string[], context: Ctx): HTMLElement {

package/src/parser/inline/italic.test.ts

@@ -58,6 +58,7 @@ describe('Unit: parser/inline/italic', () => {
       assert.deepStrictEqual(inspect(parser('//////a//////'), ctx), [['<i><i>a</i></i>'], '']);
       assert.deepStrictEqual(inspect(parser('//////a///b///'), ctx), [['<i><i>a</i>b</i>'], '']);
       assert.deepStrictEqual(inspect(parser('///a ///b//////'), ctx), [['<i>a <i>b</i></i>'], '']);
+      assert.deepStrictEqual(inspect(parser('///- ///b//////'), ctx), [['<i>- <i>b</i></i>'], '']);
       assert.deepStrictEqual(inspect(parser('///a\\ ///b//////'), ctx), [['<i>a <i>b</i></i>'], '']);
       assert.deepStrictEqual(inspect(parser('///a //////b/////////'), ctx), [['<i>a <i><i>b</i></i></i>'], '']);
       assert.deepStrictEqual(inspect(parser('///a ///b///c///'), ctx), [['<i>a <i>b</i>c</i>'], '']);

package/src/parser/inline/link.test.ts

@@ -63,8 +63,8 @@ describe('Unit: parser/inline/link', () => {
       assert.deepStrictEqual(inspect(parser('[]'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('[]{}'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('[]{ }'), ctx), [['<span class="invalid">[]{ }</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[]{  }'), ctx), [['<span class="invalid">[]{  }</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[]{   }'), ctx), [['<span class="invalid">[]{   }</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('[]{  }'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('[]{   }'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('[]{{}'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('[]{}}'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('[]{{}}'), ctx), undefined);
@@ -105,12 +105,11 @@ describe('Unit: parser/inline/link', () => {
     it('basic', () => {
       assert.deepStrictEqual(inspect(parser('[]{b}'), ctx), [['<a class="url" href="b">b</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[]{b }'), ctx), [['<a class="url" href="b">b</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[]{b  }'), ctx), [['<a class="url" href="b">b</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[]{b  }'), ctx), [['<span class="invalid">[]{b</span>'], '  }']);
       assert.deepStrictEqual(inspect(parser('[]{ b }'), ctx), [['<a class="url" href="b">b</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[]{ b  }'), ctx), [['<a class="url" href="b">b</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[]{  b }'), ctx), [['<a class="url" href="b">b</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[]{  b  }'), ctx), [['<a class="url" href="b">b</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[]{  b   }'), ctx), [['<a class="url" href="b">b</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[]{ b  }'), ctx), [['<span class="invalid">[]{ b</span>'], '  }']);
+      assert.deepStrictEqual(inspect(parser('[]{  b }'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('[]{  b  }'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('[]{"}'), ctx), [[`<a class="url" href="&quot;">"</a>`], '']);
       assert.deepStrictEqual(inspect(parser('[]{"}"}'), ctx), [[`<a class="url" href="&quot;">"</a>`], '"}']);
       assert.deepStrictEqual(inspect(parser('[]{\\}'), ctx), [[`<a class="url" href="\\">\\</a>`], '']);
@@ -209,7 +208,6 @@ describe('Unit: parser/inline/link', () => {
       assert.deepStrictEqual(inspect(parser('[]{/ aspect-ratio="4/3"}'), ctx), [['<a class="invalid" href="/">/</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[]{/ 4:3}'), ctx), [['<a class="invalid" href="/">/</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[]{/ =}'), ctx), [['<a class="invalid" href="/">/</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[]{/  name}'), ctx), [['<a class="invalid" href="/">/</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[]{/\nname}'), ctx), [['<span class="invalid">[]{/</span>'], '\nname}']);
     });
 
@@ -221,8 +219,12 @@ describe('Unit: parser/inline/link', () => {
       assert.deepStrictEqual(inspect(parser('[]{/ nofollow nofollow}'), ctx), [['<a class="invalid" href="/" rel="nofollow">/</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[]{/ nofollow}'), ctx), [['<a class="url" href="/" rel="nofollow">/</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[]{/ nofollow }'), ctx), [['<a class="url" href="/" rel="nofollow">/</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[]{/ nofollow  }'), ctx), [['<span class="invalid">[]{/ nofollow</span>'], '  }']);
+      assert.deepStrictEqual(inspect(parser('[]{/  nofollow}'), ctx), [['<span class="invalid">[]{/</span>'], '  nofollow}']);
       assert.deepStrictEqual(inspect(parser('[]{ / nofollow}'), ctx), [['<a class="url" href="/" rel="nofollow">/</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[]{ / nofollow }'), ctx), [['<a class="url" href="/" rel="nofollow">/</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[]{ / nofollow  }'), ctx), [['<span class="invalid">[]{ / nofollow</span>'], '  }']);
+      assert.deepStrictEqual(inspect(parser('[]{ /  nofollow}'), ctx), [['<span class="invalid">[]{ /</span>'], '  nofollow}']);
       assert.deepStrictEqual(inspect(parser('[]{http://host nofollow}'), ctx), [['<a class="url" href="http://host" target="_blank" rel="nofollow">http://host</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[!http://host]{http://host nofollow}'), ctx), [['<a class="link" href="http://host" target="_blank" rel="nofollow"><img class="media" data-src="http://host" alt="http://host"></a>'], '']);
     });

package/src/parser/inline/link.ts

@@ -35,7 +35,7 @@ export const textlink: LinkParser.TextLinkParser = lazy(() => constraint(State.l
     dup(surround(
       /{(?![{}])/y,
       inits([uri, some(option)]),
-      /[^\S\n]*}/y,
+      / ?}/y,
       false,
       undefined,
       ([as, bs], context) => {
@@ -82,7 +82,7 @@ export const medialink: LinkParser.MediaLinkParser = lazy(() => constraint(State
       '[',
       union([media, shortmedia]),
       ']')),
-    dup(surround(/{(?![{}])/y, inits([uri, some(option)]), /[^\S\n]*}/y)),
+    dup(surround(/{(?![{}])/y, inits([uri, some(option)]), / ?}/y)),
   ])),
   ([params, content = []]: [string[], (HTMLElement | string)[]], context) =>
     [[parse(defrag(content), params, context)]]))))));
@@ -94,20 +94,20 @@ export const unsafelink: LinkParser.UnsafeLinkParser = lazy(() =>
       '[',
       some(union([unescsource]), ']'),
       ']')),
-    dup(surround(/{(?![{}])/y, inits([uri, some(option)]), /[^\S\n]*}/y)),
+    dup(surround(/{(?![{}])/y, inits([uri, some(option)]), / ?}/y)),
   ])),
   ([params, content = []], context) =>
     [[parse(defrag(content), params, context)]])));
 
 export const uri: LinkParser.ParameterParser.UriParser = union([
-  open(/[^\S\n]+/y, str(/\S+/y)),
+  open(/ /y, str(/\S+/y)),
   str(/[^\s{}]+/y),
 ]);
 
 export const option: LinkParser.ParameterParser.OptionParser = union([
-  fmap(str(/[^\S\n]+nofollow(?=[^\S\n]|})/y), () => [` rel="nofollow"`]),
-  str(/[^\S\n]+[a-z]+(?:-[a-z]+)*(?:="(?:\\[^\n]|[^\\\n"])*")?(?=[^\S\n]|})/yi),
-  str(/[^\S\n]+[^\s{}]+/y),
+  fmap(str(/ nofollow(?=[ }])/y), () => [` rel="nofollow"`]),
+  str(/ [a-z]+(?:-[a-z]+)*(?:="(?:\\[^\n]|[^\\\n"])*")?(?=[ }])/yi),
+  str(/ [^\s{}]+/y),
 ]);
 
 function parse(
@@ -155,11 +155,11 @@ function elem(
     case 'https:':
       assert(uri.host);
       switch (true) {
-        case /[a-z][0-9]*:\/{0,2}\S/i.test(stringify(content)):
+        case /[0-9a-z]:\S/i.test(stringify(content)):
           type = 'content';
           message = 'URI must not be contained';
           break;
-        case INSECURE_URI.slice(0, 2) === '^/'
+        case INSECURE_URI.startsWith('^/')
           && /\/\.\.?(?:\/|$)/.test(INSECURE_URI.slice(0, INSECURE_URI.search(/[?#]|$/))):
           type = 'argument';
           message = 'Dot-segments cannot be used in subresource paths';
@@ -223,7 +223,7 @@ export function resolve(uri: string, host: URL | Location, source: URL | Locatio
   assert(uri);
   assert(uri === uri.trim());
   switch (true) {
-    case uri.slice(0, 2) === '^/':
+    case uri.startsWith('^/'):
       const last = host.pathname.slice(host.pathname.lastIndexOf('/') + 1);
       return last.includes('.') // isFile
           // Exclude ISO 6709.
@@ -232,7 +232,7 @@ export function resolve(uri: string, host: URL | Location, source: URL | Locatio
         : `${host.pathname.replace(/\/?$/, '/')}${uri.slice(2)}`;
     case host.origin === source.origin
       && host.pathname === source.pathname:
-    case uri.slice(0, 2) === '//':
+    case uri.startsWith('//'):
       return uri;
     default:
       const target = new ReadonlyURL(uri, source.href);
@@ -243,13 +243,13 @@ export function resolve(uri: string, host: URL | Location, source: URL | Locatio
 }
 
 export function decode(uri: string): string {
-  const origin = uri.match(/[a-z](?:[-.](?=[0-9a-z])|[0-9a-z])*:(?:\/{0,2}[^/?#\s]+|\/\/(?=[/]))/yi)?.[0] ?? '';
+  const head = /^[a-z]+(?:[.+-][0-9a-z]+)*:\/*[^/?#\s]+/i;
+  const origin = uri.match(head)?.[0] ?? '';
   try {
-    let path = decodeURI(uri.slice(origin.length));
-    if (!origin && /[a-z](?:[-.](?=[0-9a-z])|[0-9a-z])*:\/{0,2}\S/yi.test(path)) {
-      path = uri.slice(origin.length);
-    }
-    uri = origin + path;
+    const path = decodeURI(uri.slice(origin.length));
+    uri = !origin && head.test(path)
+      ? uri.slice(origin.length)
+      : origin + path;
   }
   finally {
     return uri.replace(/\s+/g, encodeURI);

package/src/parser/inline/mark.test.ts

@@ -39,6 +39,7 @@ describe('Unit: parser/inline/mark', () => {
 
     it('nest', () => {
       assert.deepStrictEqual(inspect(parser('==a ==b===='), ctx), [['<mark id="mark::a_b">a <mark id="mark::b">b</mark><a href="#mark::b"></a></mark>', '<a href="#mark::a_b"></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('==- ==b===='), ctx), [['<mark id="mark::-_b">- <mark id="mark::b">b</mark><a href="#mark::b"></a></mark>', '<a href="#mark::-_b"></a>'], '']);
       assert.deepStrictEqual(inspect(parser('==a\\ ==b===='), ctx), [['<mark id="mark::a_b">a <mark id="mark::b">b</mark><a href="#mark::b"></a></mark>', '<a href="#mark::a_b"></a>'], '']);
       assert.deepStrictEqual(inspect(parser('==a&Tab;==b===='), ctx), [['<mark id="mark::a_b=33Mw2l">a\t<mark id="mark::b">b</mark><a href="#mark::b"></a></mark>', '<a href="#mark::a_b=33Mw2l"></a>'], '']);
       assert.deepStrictEqual(inspect(parser('==a<wbr>==b===='), ctx), [['<mark id="mark::ab">a<wbr><mark id="mark::b">b</mark><a href="#mark::b"></a></mark>', '<a href="#mark::ab"></a>'], '']);

package/src/parser/inline/media.test.ts

@@ -27,8 +27,8 @@ describe('Unit: parser/inline/media', () => {
       assert.deepStrictEqual(inspect(parser('![]'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('![]{}'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('![]{ }'), ctx), [['<span class="invalid">![]{ }</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('![]{  }'), ctx), [['<span class="invalid">![]{  }</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('![]{   }'), ctx), [['<span class="invalid">![]{   }</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('![]{  }'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('![]{   }'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('![]]{/}'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('![]{{}'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('![]{}}'), ctx), undefined);
@@ -66,12 +66,11 @@ describe('Unit: parser/inline/media', () => {
     it('basic', () => {
       assert.deepStrictEqual(inspect(parser('![]{b}'), ctx), [['<a href="b" target="_blank"><img class="media" data-src="b" alt="b"></a>'], '']);
       assert.deepStrictEqual(inspect(parser('![]{b }'), ctx), [['<a href="b" target="_blank"><img class="media" data-src="b" alt="b"></a>'], '']);
-      assert.deepStrictEqual(inspect(parser('![]{b  }'), ctx), [['<a href="b" target="_blank"><img class="media" data-src="b" alt="b"></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('![]{b  }'), ctx), [['<span class="invalid">![]{b</span>'], '  }']);
       assert.deepStrictEqual(inspect(parser('![]{ b }'), ctx), [['<a href="b" target="_blank"><img class="media" data-src="b" alt="b"></a>'], '']);
-      assert.deepStrictEqual(inspect(parser('![]{ b  }'), ctx), [['<a href="b" target="_blank"><img class="media" data-src="b" alt="b"></a>'], '']);
-      assert.deepStrictEqual(inspect(parser('![]{  b }'), ctx), [['<a href="b" target="_blank"><img class="media" data-src="b" alt="b"></a>'], '']);
-      assert.deepStrictEqual(inspect(parser('![]{  b  }'), ctx), [['<a href="b" target="_blank"><img class="media" data-src="b" alt="b"></a>'], '']);
-      assert.deepStrictEqual(inspect(parser('![]{  b   }'), ctx), [['<a href="b" target="_blank"><img class="media" data-src="b" alt="b"></a>'], '']);
+      assert.deepStrictEqual(inspect(parser('![]{ b  }'), ctx), [['<span class="invalid">![]{ b</span>'], '  }']);
+      assert.deepStrictEqual(inspect(parser('![]{  b }'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('![]{  b  }'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('![]{"}'), ctx), [['<a href="&quot;" target="_blank"><img class="media" data-src="&quot;" alt="&quot;"></a>'], '']);
       assert.deepStrictEqual(inspect(parser('![]{"}"}'), ctx), [['<a href="&quot;" target="_blank"><img class="media" data-src="&quot;" alt="&quot;"></a>'], '"}']);
       assert.deepStrictEqual(inspect(parser('![]{\\}'), ctx), [['<a href="\\" target="_blank"><img class="media" data-src="\\" alt="\\"></a>'], '']);

package/src/parser/inline/media.ts

@@ -40,7 +40,7 @@ export const media: MediaParser = lazy(() => constraint(State.media, creation(10
     dup(surround(
       /{(?![{}])/y,
       inits([uri, some(option)]),
-      /[^\S\n]*}/y,
+      / ?}/y,
       false,
       undefined,
       ([as, bs], context) => {
@@ -120,9 +120,9 @@ const bracket: MediaParser.TextParser.BracketParser = lazy(() => recursion(Recur
 
 const option: MediaParser.ParameterParser.OptionParser = lazy(() => union([
   surround(
-    open(/[^\S\n]+/y, str(/[1-9][0-9]*/y)),
+    open(/ /y, str(/[1-9][0-9]*/y)),
     str(/[x:]/y),
-    str(/[1-9][0-9]*(?=[^\S\n]|})/y),
+    str(/[1-9][0-9]*(?=[ }])/y),
     false,
     ([[a], [b], [c]]) => [
       b === 'x'

package/src/parser/inline/remark.test.ts

@@ -31,7 +31,7 @@ describe('Unit: parser/inline/remark', () => {
       assert.deepStrictEqual(inspect(parser('[%\\ a %]'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('[% a\\ %]'), ctx), [['[%', ' a', ' ', '%', ']'], '']);
       assert.deepStrictEqual(inspect(parser('[% a%]'), ctx), [['[%', ' a', '%', ']'], '']);
-      assert.deepStrictEqual(inspect(parser('[% a %%]'), ctx), [['[%', ' a', ' ', '%', '%', ']'], '']);
+      assert.deepStrictEqual(inspect(parser('[% a %%]'), ctx), [['[%', ' a %', '%', ']'], '']);
       assert.deepStrictEqual(inspect(parser('[% [%% %]'), ctx), [['<span class="remark"><input type="checkbox"><span>[% <span class="invalid">[%%</span> %]</span></span>'], '']);
       assert.deepStrictEqual(inspect(parser('[%% [% %%]'), ctx), [['<span class="invalid">[%%</span>'], ' [% %%]']);
       assert.deepStrictEqual(inspect(parser('[%% a %]'), ctx), [['<span class="invalid">[%%</span>'], ' a %]']);
@@ -43,7 +43,9 @@ describe('Unit: parser/inline/remark', () => {
       assert.deepStrictEqual(inspect(parser('[%  %]'), ctx), [['<span class="remark"><input type="checkbox"><span>[% %]</span></span>'], '']);
       assert.deepStrictEqual(inspect(parser('[%   %]'), ctx), [['<span class="remark"><input type="checkbox"><span>[% %]</span></span>'], '']);
       assert.deepStrictEqual(inspect(parser('[% a %]'), ctx), [['<span class="remark"><input type="checkbox"><span>[% a %]</span></span>'], '']);
+      assert.deepStrictEqual(inspect(parser('[% - %]'), ctx), [['<span class="remark"><input type="checkbox"><span>[% - %]</span></span>'], '']);
       assert.deepStrictEqual(inspect(parser('[%  a  %]'), ctx), [['<span class="remark"><input type="checkbox"><span>[% a %]</span></span>'], '']);
+      assert.deepStrictEqual(inspect(parser('[%  -  %]'), ctx), [['<span class="remark"><input type="checkbox"><span>[% - %]</span></span>'], '']);
       assert.deepStrictEqual(inspect(parser('[% a b %]'), ctx), [['<span class="remark"><input type="checkbox"><span>[% a b %]</span></span>'], '']);
       assert.deepStrictEqual(inspect(parser('[% a\nb %]'), ctx), [['<span class="remark"><input type="checkbox"><span>[% a<br>b %]</span></span>'], '']);
       assert.deepStrictEqual(inspect(parser('[% a %] %]'), ctx), [['<span class="remark"><input type="checkbox"><span>[% a %]</span></span>'], ' %]']);

package/src/parser/inline/strong.test.ts

@@ -39,6 +39,7 @@ describe('Unit: parser/inline/strong', () => {
 
     it('nest', () => {
       assert.deepStrictEqual(inspect(parser('**a *b***'), ctx), [['<strong>a <em>b</em></strong>'], '']);
+      assert.deepStrictEqual(inspect(parser('**- *b***'), ctx), [['<strong>- <em>b</em></strong>'], '']);
       assert.deepStrictEqual(inspect(parser('**a **b****'), ctx), [['<strong>a <strong>b</strong></strong>'], '']);
       assert.deepStrictEqual(inspect(parser('**a&Tab;**b****'), ctx), [['<strong>a\t<strong>b</strong></strong>'], '']);
       assert.deepStrictEqual(inspect(parser('**a<wbr>**b****'), ctx), [['<strong>a<wbr><strong>b</strong></strong>'], '']);

package/src/parser/source/escapable.test.ts

@@ -15,6 +15,7 @@ describe('Unit: parser/source/escsource', () => {
     it('basic', () => {
       assert.deepStrictEqual(inspect(parser('a'), ctx), [['a'], '']);
       assert.deepStrictEqual(inspect(parser('ab'), ctx), [['ab'], '']);
+      assert.deepStrictEqual(inspect(parser('a b c'), ctx), [['a b c'], '']);
       assert.deepStrictEqual(inspect(parser('09あいAZaz'), ctx), [['09あいAZaz'], '']);
     });
 

package/src/parser/source/escapable.ts

@@ -1,10 +1,10 @@
 import { EscapableSourceParser } from '../source';
 import { Command } from '../context';
 import { consume } from '../../combinator';
-import { nonWhitespace, isBlank, next } from './text';
+import { next } from './text';
 import { html } from 'typed-dom/dom';
 
-const delimiter = /(?=[\\$"`\[\](){}\r\n]|\s(?:\$)|:\/\/)/g;
+const delimiter = /(?=[\\$"`\[\](){}\r\n]|\s\$|:\/\/)/g;
 
 export const escsource: EscapableSourceParser = ({ context }) => {
   const { source, position } = context;
@@ -38,15 +38,7 @@ export const escsource: EscapableSourceParser = ({ context }) => {
     default:
       assert(char !== '\n');
       if (context.sequential) return [[char]];
-      nonWhitespace.lastIndex = position + 1;
-      const b = isBlank(source, position);
-      let i = b
-        ? source[position + 1] === '\n'
-          ? position + 1
-          : nonWhitespace.test(source)
-            ? nonWhitespace.lastIndex - 1
-            : source.length
-        : next(source, position, delimiter);
+      let i = next(source, position, delimiter);
       assert(i > position);
       i -= position;
       consume(i - 1, context);