securemark 0.293.5 → 0.294.1

package/src/parser/block/blockquote.ts

@@ -1,8 +1,10 @@
 import { BlockquoteParser } from '../block';
 import { Recursion } from '../context';
+import { List, Data } from '../../combinator/data/parser';
 import { union, some, creation, recursion, block, validate, rewrite, open, convert, lazy, fmap } from '../../combinator';
 import { autolink } from '../autolink';
 import { contentline } from '../source';
+import { unwrap } from '../util';
 import { parse } from '../api/parse';
 import { html, defrag } from 'typed-dom/dom';
 
@@ -26,9 +28,9 @@ const source: BlockquoteParser.SourceParser = lazy(() => fmap(
       convert(unindent, source, false, true)),
     rewrite(
       some(contentline, opener),
-      convert(unindent, fmap(autolink, ns => [html('pre', defrag(ns))]), false, true)),
+      convert(unindent, fmap(autolink, ns => new List([new Data(html('pre', defrag(unwrap(ns))))])), false, true)),
   ]))),
-  ns => [html('blockquote', ns)]));
+  ns => new List([new Data(html('blockquote', unwrap(ns)))])));
 
 const markdown: BlockquoteParser.MarkdownParser = lazy(() => fmap(
   some(recursion(Recursion.blockquote, union([
@@ -48,7 +50,7 @@ const markdown: BlockquoteParser.MarkdownParser = lazy(() => fmap(
           },
         }, context);
         context.position = source.length;
-        return [[html('section', [document, html('h2', 'References'), references])]];
+        return new List([new Data(html('section', [document, html('h2', 'References'), references]))]);
       }, false, true))),
   ]))),
-  ns => [html('blockquote', ns)]));
+  ns => new List([new Data(html('blockquote', unwrap(ns)))])));

package/src/parser/block/codeblock.ts

@@ -1,8 +1,8 @@
 import { CodeBlockParser } from '../block';
-import { input, eval } from '../../combinator/data/parser';
+import { List, Data, subinput } from '../../combinator/data/parser';
 import { block, fence, clear, fmap } from '../../combinator';
 import { autolink } from '../autolink';
-import { invalid } from '../util';
+import { unwrap, invalid } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 const opener = /(`{3,})(?!`)([^\n]*)(?:$|\n)/y;
@@ -17,7 +17,8 @@ export const segment_: CodeBlockParser.SegmentParser = block(
 export const codeblock: CodeBlockParser = block(fmap(
   fence(opener, 300),
   // Bug: Type mismatch between outer and inner.
-  ([body, overflow, closer, opener, delim, param]: string[], context) => {
+  (nodes, context) => {
+    const [body, overflow, closer, opener, delim, param] = unwrap<string>(nodes);
     const params = param.match(/(?:\\.?|\S)+/g)?.reduce<{
       lang?: string;
       path?: string;
@@ -49,7 +50,7 @@ export const codeblock: CodeBlockParser = block(fmap(
         : params[name] = value;
       return params;
     }, {}) ?? {};
-    if (!closer || overflow || params.invalid) return [html('pre', {
+    if (!closer || overflow || params.invalid) return new List([new Data(html('pre', {
       class: 'invalid',
       translate: 'no',
       ...invalid(
@@ -60,7 +61,7 @@ export const codeblock: CodeBlockParser = block(fmap(
           : overflow
             ? `Invalid trailing line after the closing delimiter "${delim}"`
             : params.invalid!),
-    }, `${opener}${body}${overflow || closer}`)];
+    }, `${opener}${body}${overflow || closer}`))]);
     const el = html('pre',
       {
         class: params.lang ? `code language-${params.lang}` : 'text',
@@ -72,6 +73,6 @@ export const codeblock: CodeBlockParser = block(fmap(
       params.lang
         ? context.caches?.code?.get(`${params.lang ?? ''}\n${body.slice(0, -1)}`)?.cloneNode(true).childNodes ||
           body.slice(0, -1) || undefined
-        : defrag(eval(autolink(input(body.slice(0, -1), { ...context })), [])));
-    return [el];
+        : defrag(unwrap(autolink(subinput(body.slice(0, -1), context)))));
+    return new List([new Data(el)]);
   }));

package/src/parser/block/dlist.ts

@@ -1,10 +1,11 @@
 import { DListParser } from '../block';
 import { State } from '../context';
+import { List, Data } from '../../combinator/data/parser';
 import { union, inits, some, state, block, line, validate, rewrite, open, lazy, fmap } from '../../combinator';
 import { inline, indexee, indexer, dataindex } from '../inline';
 import { anyline } from '../source';
 import { visualize, trimBlank, trimBlankEnd } from '../visibility';
-import { push } from 'spica/array';
+import { unwrap } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 export const dlist: DListParser = lazy(() => block(fmap(validate(
@@ -14,13 +15,13 @@ export const dlist: DListParser = lazy(() => block(fmap(validate(
     some(term)),
     some(desc),
   ]))),
-  es => [html('dl', fillTrailingDescription(es))])));
+  ns => new List([new Data(html('dl', unwrap(fillTrailingDescription(ns))))]))));
 
 const term: DListParser.TermParser = line(indexee(fmap(open(
   /~[^\S\n]+(?=\S)/y,
   visualize(trimBlank(some(union([indexer, inline])))),
   true),
-  ns => [html('dt', { 'data-index': dataindex(ns) }, defrag(ns))])));
+  ns => new List([new Data(html('dt', { 'data-index': dataindex(ns) }, defrag(unwrap(ns))))]))));
 
 const desc: DListParser.DescriptionParser = block(fmap(open(
   /:[^\S\n]+(?=\S)|/y,
@@ -28,11 +29,11 @@ const desc: DListParser.DescriptionParser = block(fmap(open(
     some(anyline, /[~:][^\S\n]+\S/y),
     visualize(trimBlankEnd(some(union([inline]))))),
   true),
-  ns => [html('dd', defrag(ns))]),
+  ns => new List([new Data(html('dd', defrag(unwrap(ns))))])),
   false);
 
-function fillTrailingDescription(es: HTMLElement[]): HTMLElement[] {
-  return es.length > 0 && es.at(-1)!.tagName === 'DT'
-    ? push(es, [html('dd')])
-    : es;
+function fillTrailingDescription(nodes: List<Data<HTMLElement>>): List<Data<HTMLElement>> {
+  return nodes.last?.value.tagName === 'DT'
+    ? nodes.push(new Data(html('dd'))) && nodes
+    : nodes;
 }

package/src/parser/block/extension/aside.ts

@@ -1,25 +1,29 @@
 import { ExtensionParser } from '../../block';
 import { Recursion } from '../../context';
+import { List, Data } from '../../../combinator/data/parser';
 import { recursion, block, fence, fmap } from '../../../combinator';
 import { identity } from '../../inline/extension/indexee';
-import { invalid } from '../../util';
+import { unwrap, invalid } from '../../util';
 import { parse } from '../../api/parse';
 import { html } from 'typed-dom/dom';
 
 export const aside: ExtensionParser.AsideParser = recursion(Recursion.block, block(fmap(
   fence(/(~{3,})aside(?!\S)([^\n]*)(?:$|\n)/y, 300),
   // Bug: Type mismatch between outer and inner.
-  ([body, overflow, closer, opener, delim, param]: string[], context) => {
-    if (!closer || overflow || param.trimStart()) return [html('pre', {
-      class: 'invalid',
-      translate: 'no',
-      ...invalid(
-        'aside',
-        !closer || overflow ? 'fence' : 'argument',
-        !closer ? `Missing the closing delimiter "${delim}"` :
-          overflow ? `Invalid trailing line after the closing delimiter "${delim}"` :
-            'Invalid argument'),
-    }, `${opener}${body}${overflow || closer}`)];
+  (nodes: List<Data<string>>, context) => {
+    const [body, overflow, closer, opener, delim, param] = unwrap(nodes);
+    if (!closer || overflow || param.trimStart()) return new List([
+      new Data(html('pre', {
+        class: 'invalid',
+        translate: 'no',
+        ...invalid(
+          'aside',
+          !closer || overflow ? 'fence' : 'argument',
+          !closer ? `Missing the closing delimiter "${delim}"` :
+            overflow ? `Invalid trailing line after the closing delimiter "${delim}"` :
+              'Invalid argument'),
+      }, `${opener}${body}${overflow || closer}`))
+    ]);
     const references = html('ol', { class: 'references' });
     const document = parse(body.slice(0, -1), {
       id: '',
@@ -29,17 +33,19 @@ export const aside: ExtensionParser.AsideParser = recursion(Recursion.block, blo
     }, context);
     assert(!document.querySelector('[id]'));
     const heading = 'H1 H2 H3 H4 H5 H6'.split(' ').includes(document.firstElementChild?.tagName!) && document.firstElementChild as HTMLHeadingElement;
-    if (!heading) return [html('pre', {
-      class: 'invalid',
-      translate: 'no',
-      ...invalid('aside', 'content', 'Missing the title at the first line'),
-    }, `${opener}${body}${closer}`)];
+    if (!heading) return new List([
+      new Data(html('pre', {
+        class: 'invalid',
+        translate: 'no',
+        ...invalid('aside', 'content', 'Missing the title at the first line'),
+      }, `${opener}${body}${closer}`))
+    ]);
     assert(identity('index', context.id, heading));
-    return [
-      html('aside', { id: identity('index', context.id, heading), class: 'aside' }, [
+    return new List([
+      new Data(html('aside', { id: identity('index', context.id, heading), class: 'aside' }, [
         document,
         html('h2', 'References'),
         references,
-      ]),
-    ];
+      ]))
+    ]);
   })));

package/src/parser/block/extension/example.ts

@@ -1,9 +1,9 @@
 import { ExtensionParser } from '../../block';
 import { Recursion } from '../../context';
-import { input, eval } from '../../../combinator/data/parser';
+import { List, Data, subinput } from '../../../combinator/data/parser';
 import { recursion, block, fence, fmap } from '../../../combinator';
 import { mathblock } from '../mathblock';
-import { invalid } from '../../util';
+import { unwrap, invalid } from '../../util';
 import { parse } from '../../api/parse';
 import { html } from 'typed-dom/dom';
 
@@ -12,17 +12,20 @@ const opener = /(~{3,})(?:example\/(\S+))?(?!\S)([^\n]*)(?:$|\n)/y;
 export const example: ExtensionParser.ExampleParser = recursion(Recursion.block, block(fmap(
   fence(opener, 300),
   // Bug: Type mismatch between outer and inner.
-  ([body, overflow, closer, opener, delim, type = 'markdown', param]: string[], context) => {
-    if (!closer || overflow || param.trimStart()) return [html('pre', {
-      class: 'invalid',
-      translate: 'no',
-      ...invalid(
-        'example',
-        !closer || overflow ? 'fence' : 'argument',
-        !closer ? `Missing the closing delimiter "${delim}"` :
-          overflow ? `Invalid trailing line after the closing delimiter "${delim}"` :
-            'Invalid argument'),
-    }, `${opener}${body}${overflow || closer}`)];
+  (nodes: List<Data<string>>, context) => {
+    const [body, overflow, closer, opener, delim, type = 'markdown', param] = unwrap(nodes);
+    if (!closer || overflow || param.trimStart()) return new List([
+      new Data(html('pre', {
+        class: 'invalid',
+        translate: 'no',
+        ...invalid(
+          'example',
+          !closer || overflow ? 'fence' : 'argument',
+          !closer ? `Missing the closing delimiter "${delim}"` :
+            overflow ? `Invalid trailing line after the closing delimiter "${delim}"` :
+              'Invalid argument'),
+      }, `${opener}${body}${overflow || closer}`))
+    ]);
     switch (type) {
       case 'markdown': {
         const references = html('ol', { class: 'references' });
@@ -33,29 +36,29 @@ export const example: ExtensionParser.ExampleParser = recursion(Recursion.block,
           },
         }, context);
         assert(!document.querySelector('[id]'));
-        return [
-          html('aside', { class: 'example', 'data-type': 'markdown' }, [
+        return new List([
+          new Data(html('aside', { class: 'example', 'data-type': 'markdown' }, [
             html('pre', { translate: 'no' }, body.slice(0, -1)),
             html('hr'),
             html('section', [document, html('h2', 'References'), references]),
-          ]),
-        ];
+          ])),
+        ]);
       }
       case 'math':
-        return [
-          html('aside', { class: 'example', 'data-type': 'math' }, [
+        return new List([
+          new Data(html('aside', { class: 'example', 'data-type': 'math' }, [
             html('pre', { translate: 'no' }, body.slice(0, -1)),
             html('hr'),
-            eval(mathblock(input(`$$\n${body}$$`, { ...context })), [])[0],
-          ]),
-        ];
+            mathblock(subinput(`$$\n${body}$$`, context))!.head!.value,
+          ])),
+        ]);
       default:
-        return [
-          html('pre', {
+        return new List([
+          new Data(html('pre', {
             class: 'invalid',
             translate: 'no',
             ...invalid('example', 'type', 'Invalid example type'),
-          }, `${opener}${body}${closer}`),
-        ];
+          }, `${opener}${body}${closer}`)),
+        ]);
     }
   })));

package/src/parser/block/extension/fig.ts

@@ -36,7 +36,7 @@ export const fig: FigParser = block(rewrite(segment, verify(convert(
   },
   union([figure]),
   false),
-  ([el]) => el.tagName === 'FIGURE')));
+  ([{ value: el }]) => el.tagName === 'FIGURE')));
 
 const parser = sequence([
   line(close(seg_label, /(?=\s).*\n/y)),

package/src/parser/block/extension/figbase.ts

@@ -1,4 +1,5 @@
 import { ExtensionParser } from '../../block';
+import { List, Data } from '../../../combinator/data/parser';
 import { union, block, line, validate, fmap } from '../../../combinator';
 import { label } from '../../inline/extension/label';
 import { html } from 'typed-dom/dom';
@@ -6,14 +7,14 @@ import { html } from 'typed-dom/dom';
 export const figbase: ExtensionParser.FigbaseParser = block(fmap(
   validate(/\[?\$-(?:[0-9]+\.)*0\]?[^\S\n]*(?!\S|\n[^\S\n]*\S)/y,
   line(union([label]))),
-  ([el]) => {
+  ([{ value: el }]) => {
     const label = el.getAttribute('data-label')!;
     const group = label.split('-', 1)[0];
-    return [
-      html('figure', {
+    return new List([
+      new Data(html('figure', {
         'data-label': label,
         'data-group': group,
         hidden: '',
-      }),
-    ];
+      })),
+    ]);
   }));

package/src/parser/block/extension/figure.ts

@@ -1,5 +1,5 @@
 import { ExtensionParser } from '../../block';
-import { input } from '../../../combinator/data/parser';
+import { List, Data, subinput } from '../../../combinator/data/parser';
 import { union, inits, sequence, some, block, line, fence, rewrite, close, match, convert, fallback, fmap } from '../../../combinator';
 import { str, contentline, emptyline } from '../../source';
 import { label, segment as seg_label } from '../../inline/extension/label';
@@ -14,7 +14,7 @@ import { blockquote, segment as seg_blockquote } from '../blockquote';
 import { placeholder, segment_ as seg_placeholder } from './placeholder';
 import { inline, media, lineshortmedia } from '../../inline';
 import { visualize, trimBlank } from '../../visibility';
-import { invalid } from '../../util';
+import { unwrap, invalid } from '../../util';
 import { memoize } from 'spica/memoize';
 import { html, defrag } from 'typed-dom/dom';
 
@@ -44,7 +44,7 @@ export const segment: FigureParser.SegmentParser = block(match(
       ]),
     ]),
     closer),
-  ([, fence]) => fence.length, {})));
+  ([, fence]) => fence.length <= 16 ? fence.length : -1, [])));
 
 export const figure: FigureParser = block(fallback(rewrite(segment, fmap(
   convert(source => source.slice(source.match(/^~+(?:\w+\s+)?/)![0].length, source.trimEnd().lastIndexOf('\n')),
@@ -68,20 +68,24 @@ export const figure: FigureParser = block(fallback(rewrite(segment, fmap(
       block(visualize(trimBlank(some(inline)))),
     ]),
   ]), false),
-  ([label, param, content, ...caption]: [HTMLAnchorElement, string, ...HTMLElement[]]) => [
-    html('figure',
-      attributes(label.getAttribute('data-label')!, param, content, caption),
-      [
-        html('figcaption', [
-          html('span', { class: 'figindex' }),
-          html('span', { class: 'figtext' }, defrag(caption)),
-        ]),
-        html('div', [content]),
-      ])
-  ])),
+  nodes => {
+    const [label, param, content, ...caption] = unwrap(nodes) as [HTMLAnchorElement, string, ...HTMLElement[]];
+    return new List([
+      new Data(html('figure',
+        attributes(label.getAttribute('data-label')!, param, content, caption),
+        [
+          html('figcaption', [
+            html('span', { class: 'figindex' }),
+            html('span', { class: 'figtext' }, defrag(caption)),
+          ]),
+          html('div', [content]),
+        ]))
+    ]);
+  })),
   fmap(
     fence(/(~{3,})(?:figure|\[?\$\S*)(?!\S)[^\n]*(?:$|\n)/y, 300),
-    ([body, overflow, closer, opener, delim]: string[], context) => {
+    (nodes, context) => {
+      const [body, overflow, closer, opener, delim] = unwrap<string>(nodes);
       const violation =
         !closer && [
           'fence',
@@ -91,7 +95,7 @@ export const figure: FigureParser = block(fallback(rewrite(segment, fmap(
           'fence',
           `Invalid trailing line after the closing delimiter "${delim}"`,
         ] ||
-        !seg_label(input(opener.match(/^~+(?:figure[^\S\n]+)?(\[?\$\S+)/)?.[1] ?? '', { ...context })) && [
+        !seg_label(subinput(opener.match(/^~+(?:figure[^\S\n]+)?(\[?\$\S+)/)?.[1] ?? '', context)) && [
           'label',
           'Invalid label',
         ] ||
@@ -103,13 +107,13 @@ export const figure: FigureParser = block(fallback(rewrite(segment, fmap(
           'content',
           'Invalid content',
         ];
-      return [
-        html('pre', {
+      return new List([
+        new Data(html('pre', {
           class: 'invalid',
           translate: 'no',
           ...invalid('figure', violation[0], violation[1]),
-        }, `${opener}${body}${overflow || closer}`),
-      ];
+        }, `${opener}${body}${overflow || closer}`)),
+      ]);
     })));
 
 function attributes(label: string, param: string, content: HTMLElement, caption: readonly HTMLElement[]): Record<string, string | undefined> {

package/src/parser/block/extension/message.ts

@@ -1,5 +1,5 @@
 import { ExtensionParser } from '../../block';
-import { input, eval } from '../../../combinator/data/parser';
+import { List, Data, subinput } from '../../../combinator/data/parser';
 import { union, block, fence, fmap } from '../../../combinator';
 import { segment } from '../../segment';
 import { emptyline } from '../../source';
@@ -13,8 +13,8 @@ import { sidefence } from '../sidefence';
 import { blockquote } from '../blockquote';
 import { mediablock } from '../mediablock';
 import { paragraph } from '../paragraph';
-import { invalid } from '../../util';
-import { unshift, push } from 'spica/array';
+import { unwrap, invalid } from '../../util';
+import { push } from 'spica/array';
 import { html } from 'typed-dom/dom';
 
 import MessageParser = ExtensionParser.MessageParser;
@@ -22,34 +22,45 @@ import MessageParser = ExtensionParser.MessageParser;
 export const message: MessageParser = block(fmap(
   fence(/(~{3,})message\/(\S+)([^\n]*)(?:$|\n)/y, 300),
   // Bug: Type mismatch between outer and inner.
-  ([body, overflow, closer, opener, delim, type, param]: string[], context) => {
-    if (!closer || overflow || param.trimStart()) return [html('pre', {
-      class: 'invalid',
-      translate: 'no',
-      ...invalid(
-        'message',
-        !closer || overflow ? 'fence' : 'argument',
-        !closer ? `Missing the closing delimiter "${delim}"` :
-          overflow ? `Invalid trailing line after the closing delimiter "${delim}"` :
-            'Invalid argument'),
-    }, `${opener}${body}${overflow || closer}`)];
+  (nodes: List<Data<string>>, context) => {
+    const [body, overflow, closer, opener, delim, type, param] = unwrap(nodes);
+    if (!closer || overflow || param.trimStart()) return new List([
+      new Data(html('pre', {
+        class: 'invalid',
+        translate: 'no',
+        ...invalid(
+          'message',
+          !closer || overflow ? 'fence' : 'argument',
+          !closer ? `Missing the closing delimiter "${delim}"` :
+            overflow ? `Invalid trailing line after the closing delimiter "${delim}"` :
+              'Invalid argument'),
+      }, `${opener}${body}${overflow || closer}`))
+    ]);
     switch (type) {
       case 'note':
       case 'caution':
       case 'warning':
         break;
       default:
-        return [html('pre', {
-          class: 'invalid',
-          translate: 'no',
-          ...invalid('message', 'type', 'Invalid message type'),
-        }, `${opener}${body}${closer}`)];
+        return new List([
+          new Data(html('pre', {
+            class: 'invalid',
+            translate: 'no',
+            ...invalid('message', 'type', 'Invalid message type'),
+          }, `${opener}${body}${closer}`))
+        ]);
     }
-    return [
-      html('section', { class: `message`, 'data-type': type }, unshift(
-        [html('h1', title(type))],
-        [...segment(body)].reduce((acc, seg) => push(acc, eval(content(input(seg, { ...context })), [])), []))),
-    ];
+    return new List([
+      new Data(html('section',
+        {
+          class: `message`,
+          'data-type': type,
+        },
+        [...segment(body)].reduce(
+          (acc, seg) =>
+            push(acc, unwrap(content(subinput(seg, context)))),
+          [html('h1', title(type))])))
+    ]);
   }));
 
 function title(type: string): string {

package/src/parser/block/extension/placeholder.ts

@@ -1,6 +1,7 @@
 import { ExtensionParser } from '../../block';
+import { List, Data } from '../../../combinator/data/parser';
 import { block, fence, clear, fmap } from '../../../combinator';
-import { invalid } from '../../util';
+import { unwrap, invalid } from '../../util';
 import { html } from 'typed-dom/dom';
 
 const opener = /(~{3,})(?!~)[^\n]*(?:$|\n)/y;
@@ -13,15 +14,18 @@ export const segment_: ExtensionParser.PlaceholderParser.SegmentParser = block(
 
 export const placeholder: ExtensionParser.PlaceholderParser = block(fmap(
   fence(opener, Infinity),
-  ([body, overflow, closer, opener, delim]) => [
-    html('pre', {
-      class: 'invalid',
-      translate: 'no',
-      ...invalid(
-        'extension',
-        'fence',
-        !closer ? `Missing the closing delimiter "${delim}"` :
-          overflow ? `Invalid trailing line after the closing delimiter "${delim}"` :
-            'Invalid argument'),
-    }, `${opener}${body}${overflow || closer}`),
-  ]));
+  nodes => {
+    const [body, overflow, closer, opener, delim] = unwrap(nodes);
+    return new List([
+      new Data(html('pre', {
+        class: 'invalid',
+        translate: 'no',
+        ...invalid(
+          'extension',
+          'fence',
+          !closer ? `Missing the closing delimiter "${delim}"` :
+            overflow ? `Invalid trailing line after the closing delimiter "${delim}"` :
+              'Invalid argument'),
+      }, `${opener}${body}${overflow || closer}`)),
+    ]);
+  }));