securemark 0.299.3 → 0.300.0

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

@@ -1,9 +1,9 @@
 import { ExtensionParser } from '../../block';
 import { Segment } from '../../context';
-import { List, Node, subinput } from '../../../combinator/data/parser';
-import { union, inits, sequence, some, block, line, fence, rewrite, close, match, convert, fallback, fmap } from '../../../combinator';
+import { List, Node } from '../../../combinator/parser';
+import { union, inits, sequence, some, scope, block, line, fence, rewrite, close, match, fallback, fmap } from '../../../combinator';
 import { str, contentline, emptyline } from '../../source';
-import { label, segment as seg_label } from '../../inline/extension/label';
+import { label, test as test_label } from '../../inline/extension/label';
 import { ulist } from '../ulist';
 import { olist } from '../olist';
 import { table as styled_table } from '../table';
@@ -48,9 +48,9 @@ export const segment: FigureParser.SegmentParser = block(match(
   ([, fence]) => fence.length - 1, [], 2 ** 4 - 1)), true, Segment.figure);
 
 export const figure: FigureParser = block(fallback(rewrite(segment, fmap(
-  convert(source => source.slice(source.match(/^~+(?:\w+\s+)?/)![0].length, source.trimEnd().lastIndexOf('\n')),
+  scope(({ source }) => source.slice(source.match(/^~+(?:\w+\s+)?/)![0].length, source.trimEnd().lastIndexOf('\n')),
   sequence([
-    line(sequence([label, str(/(?!\S)[^\r\n]*\r?\n/y)])),
+    line(sequence([label, str(/(?!\S)[^\r\n]*\r?\n/y)]), false),
     inits([
       block(union([
         ulist,
@@ -62,13 +62,13 @@ export const figure: FigureParser = block(fallback(rewrite(segment, fmap(
         table,
         blockquote,
         placeholder,
-        line(media),
-        line(lineshortmedia),
+        line(media, false),
+        line(lineshortmedia, false),
       ])),
       emptyline,
       block(visualize(trimBlank(some(inline)))),
     ]),
-  ])),
+  ]), false),
   nodes => {
     const [label, param, content, ...caption] = unwrap(nodes) as [HTMLAnchorElement, string, ...HTMLElement[]];
     return new List([
@@ -83,10 +83,10 @@ export const figure: FigureParser = block(fallback(rewrite(segment, fmap(
         ]))
     ]);
   })),
-  fmap(
-    fence(/(~{3,})(?:figure(?=$|[ \r\n])|\[?\$)[^\r\n]*(?:$|\r?\n)/y, 300),
-    (nodes, context) => {
-      const [body, overflow, closer, opener, delim] = unwrap<string>(nodes);
+  inits([
+    fence(/(~{3,})(?:figure(?=$|[ \r\n])|\[?\$)[^\r\n]*(?:$|\r?\n)/y, true, 300),
+    (_, output) => {
+      const [body, overflow, closer, opener, delim] = unwrap(output.pop()) as string[];
       const violation =
         !closer && [
           'fence',
@@ -96,7 +96,7 @@ export const figure: FigureParser = block(fallback(rewrite(segment, fmap(
           'fence',
           `Invalid trailing line after the closing delimiter "${delim}"`,
         ] ||
-        !seg_label(subinput(opener.match(/^~+(?:figure )?(\[?\$\S+)/)?.[1] ?? '', context)) && [
+        !test_label(opener.match(/^~+(?:figure )?(\[?\$\S+)/)?.[1] ?? '') && [
           'label',
           'Invalid label',
         ] ||
@@ -108,14 +108,16 @@ export const figure: FigureParser = block(fallback(rewrite(segment, fmap(
           'content',
           'Invalid content',
         ];
-      return new List([
-        new Node(html('pre', {
-          class: 'invalid',
-          translate: 'no',
-          ...invalid('figure', violation[0], violation[1]),
-        }, `${opener}${body}${overflow || closer}`)),
-      ]);
-    })));
+      return output.append(
+        new Node(html('pre',
+          {
+            class: 'invalid',
+            translate: 'no',
+            ...invalid('figure', violation[0], violation[1]),
+          },
+          `${opener}${body}${overflow || closer}`)));
+    },
+  ])));
 
 function attributes(label: string, param: string, content: HTMLElement, caption: readonly HTMLElement[]): Record<string, string | undefined> {
   const group = label.split('-', 1)[0];

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

@@ -1,7 +1,6 @@
 import { message } from './message';
 import { some } from '../../../combinator';
-import { input } from '../../../combinator/data/parser';
-import { Context } from '../../context';
+import { input } from '../../context';
 import { inspect } from '../../../debug.test';
 
 describe('Unit: parser/block/extension/message', () => {
@@ -9,21 +8,21 @@ describe('Unit: parser/block/extension/message', () => {
     const parser = some(message);
 
     it('invalid', () => {
-      assert.deepStrictEqual(inspect(parser, input('~~~message\n~~~', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('~~~message/\n~~~', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('~~~message/a\n~~~', new Context())), [['<pre class="invalid" translate="no">~~~message/a\n~~~</pre>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~~~message/note a\n~~~', new Context())), [['<pre class="invalid" translate="no">~~~message/note a\n~~~</pre>'], '']);
-      assert.deepStrictEqual(inspect(parser, input(`~~~message/note\n0${'\n'.repeat(301)}~~~`, new Context()), '>'), [['<pre class="invalid" translate="no">'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~~message\n~~~')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('~~~message/\n~~~')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('~~~message/a\n~~~')), [['<pre class="invalid" translate="no">~~~message/a\n~~~</pre>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~~message/note a\n~~~')), [['<pre class="invalid" translate="no">~~~message/note a\n~~~</pre>'], '']);
+      assert.deepStrictEqual(inspect(parser, input(`~~~message/note\n0${'\n'.repeat(301)}~~~`), '>'), [['<pre class="invalid" translate="no">'], '']);
     });
 
     it('valid', () => {
-      assert.deepStrictEqual(inspect(parser, input('~~~message/note\n~~~', new Context())), [['<section class="message" data-type="note"><h1>Note</h1></section>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~~~message/note\n\n~~~', new Context())), [['<section class="message" data-type="note"><h1>Note</h1></section>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~~~message/note\na\n~~~', new Context())), [['<section class="message" data-type="note"><h1>Note</h1><p>a</p></section>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~~~message/note\na\n\n- \n~~~', new Context())), [['<section class="message" data-type="note"><h1>Note</h1><p>a</p><ul><li></li></ul></section>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~~~message/note\n# a\n~~~', new Context())), [['<section class="message" data-type="note"><h1>Note</h1><p># a</p></section>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~~~message/caution\n~~~', new Context())), [['<section class="message" data-type="caution"><h1>Caution!</h1></section>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('~~~message/warning\n~~~', new Context())), [['<section class="message" data-type="warning"><h1>WARNING!!</h1></section>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~~message/note\n~~~')), [['<section class="message" data-type="note"><h1>Note</h1></section>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~~message/note\n\n~~~')), [['<section class="message" data-type="note"><h1>Note</h1></section>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~~message/note\na\n~~~')), [['<section class="message" data-type="note"><h1>Note</h1><p>a</p></section>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~~message/note\na\n\n- \n~~~')), [['<section class="message" data-type="note"><h1>Note</h1><p>a</p><ul><li></li></ul></section>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~~message/note\n# a\n~~~')), [['<section class="message" data-type="note"><h1>Note</h1><p># a</p></section>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~~message/caution\n~~~')), [['<section class="message" data-type="caution"><h1>Caution!</h1></section>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('~~~message/warning\n~~~')), [['<section class="message" data-type="warning"><h1>WARNING!!</h1></section>'], '']);
     });
 
   });

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

@@ -1,8 +1,9 @@
 import { ExtensionParser } from '../../block';
-import { List, Node, subinput } from '../../../combinator/data/parser';
-import { union, block, fence, fmap } from '../../../combinator';
-import { segment } from '../../segment';
-import { emptyline } from '../../source';
+import { Node } from '../../../combinator/parser';
+import { union, inits, force, block, fence, lazy } from '../../../combinator';
+import { build } from '../../parser';
+import { parser as segment } from '../../segment';
+import { emptysegment } from '../../source';
 import { ulist } from '../ulist';
 import { olist } from '../olist';
 import { ilist } from '../ilist';
@@ -14,54 +15,66 @@ import { blockquote } from '../blockquote';
 import { mediablock } from '../mediablock';
 import { paragraph } from '../paragraph';
 import { unwrap, invalid } from '../../util';
-import { push } from 'spica/array';
 import { html } from 'typed-dom/dom';
 
 import MessageParser = ExtensionParser.MessageParser;
 
-export const message: MessageParser = block(fmap(
-  fence(/(~{3,})message\/(\S+)(?!\S)([^\r\n]*)(?:$|\r?\n)/y, 300),
-  // Bug: Type mismatch between outer and inner.
-  (nodes: List<Node<string>>, context) => {
-    const [body, overflow, closer, opener, delim, type, param] = unwrap(nodes);
-    if (!closer || overflow || param.trimStart()) return new List([
-      new Node(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}`))
-    ]);
+export const message: MessageParser = block(inits([
+  fence(/(~{3,})message\/(\S+)(?!\S)([^\r\n]*)(?:$|\r?\n)/y, true, 300),
+  (input, output) => {
+    const [body, overflow, closer, opener, delim, type, param] = unwrap(output.pop()) as string[];
+    if (!closer || overflow || param.trimStart()) {
+      output.append(
+        new Node(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}`)));
+      return;
+    }
     switch (type) {
       case 'note':
       case 'caution':
       case 'warning':
         break;
       default:
-        return new List([
-          new Node(html('pre', {
-            class: 'invalid',
-            translate: 'no',
-            ...invalid('message', 'type', 'Invalid message type'),
-          }, `${opener}${body}${closer}`))
-        ]);
+        output.append(
+          new Node(html('pre',
+            {
+              class: 'invalid',
+              translate: 'no',
+              ...invalid('message', 'type', 'Invalid message type'),
+            },
+            `${opener}${body}${closer}`)));
+        return;
     }
-    return new List([
+    output.append(
       new Node(html('section',
         {
           class: `message`,
           'data-type': type,
         },
-        [...segment(body, false)].reduce(
-          (acc, [seg]) =>
-            push(acc, unwrap(content(subinput(seg, context)))),
-          [html('h1', title(type))])))
-    ]);
-  }));
+        [html('h1', title(type))])));
+    const src = body.slice(0, body.at(-2) === '\r' ? -2 : -1);
+    input.scope.focus(src);
+    output.push();
+    return output.context;
+  },
+  force(() => cont),
+  (input, output) => {
+    input.scope.unfocus();
+    const content = output.pop();
+    output.peek().last!.value.append(...unwrap(content));
+    return output.context;
+  },
+]));
 
 function title(type: string): string {
   switch (type) {
@@ -75,8 +88,8 @@ function title(type: string): string {
 }
 
 // Must not have indexed blocks.
-const content: MessageParser.ContentParser = union([
-  emptyline,
+const cont = build(lazy(() => segment), lazy(() => union([
+  emptysegment,
   ulist,
   olist,
   ilist,
@@ -87,4 +100,4 @@ const content: MessageParser.ContentParser = union([
   blockquote,
   mediablock,
   paragraph,
-]);
+])));

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

@@ -1,27 +1,27 @@
 import { placeholder } from './placeholder';
 import { some } from '../../../combinator';
-import { input } from '../../../combinator/data/parser';
-import { Context } from '../../context';
+import { input } from '../../context';
+import { inspect } from '../../../debug.test';
 
 describe('Unit: parser/block/extension/placeholder', () => {
   describe('placeholder', () => {
     const parser = some(placeholder);
 
     it('invalid', () => {
-      assert(!parser(input('', new Context())));
-      assert(!parser(input('\n', new Context())));
-      assert(!parser(input('~~~', new Context())));
-      assert(!parser(input('~~~\n', new Context())));
-      assert(!parser(input('~~~a ~~~\n~~~', new Context())));
+      assert(!inspect(parser, input('')));
+      assert(!inspect(parser, input('\n')));
+      assert(!inspect(parser, input('~~~')));
+      assert(!inspect(parser, input('~~~\n')));
+      assert(!inspect(parser, input('~~~a ~~~\n~~~')));
     });
 
     it('valid', () => {
-      assert(parser(input('~~~\n~~~', new Context())));
-      assert(parser(input('~~~a\n~~~', new Context())));
-      assert(parser(input('~~~a \n~~~', new Context())));
-      assert(parser(input('~~~a b \n~~~', new Context())));
-      assert(parser(input('~~~~a\n~~~~', new Context())));
-      assert(parser(input('~~~~a\n~~~~\n', new Context())));
+      assert(inspect(parser, input('~~~\n~~~')));
+      assert(inspect(parser, input('~~~a\n~~~')));
+      assert(inspect(parser, input('~~~a \n~~~')));
+      assert(inspect(parser, input('~~~a b \n~~~')));
+      assert(inspect(parser, input('~~~~a\n~~~~')));
+      assert(inspect(parser, input('~~~~a\n~~~~\n')));
     });
 
   });

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

@@ -1,31 +1,33 @@
 import { ExtensionParser } from '../../block';
-import { List, Node } from '../../../combinator/data/parser';
-import { block, fence, clear, fmap } from '../../../combinator';
+import { Node } from '../../../combinator/parser';
+import { inits, block, fence } from '../../../combinator';
 import { unwrap, invalid } from '../../util';
 import { html } from 'typed-dom/dom';
 
 const opener = /(~{3,})(?!~)[^\r\n]*(?:$|\r?\n)/y;
 
 export const segment: ExtensionParser.PlaceholderParser.SegmentParser = block(
-  clear(fence(opener, 300)));
+  fence(opener, false, 300));
 
 export const segment_: ExtensionParser.PlaceholderParser.SegmentParser = block(
-  clear(fence(opener, 300, false)), false);
+  fence(opener, false, 300, false), false);
 
-export const placeholder: ExtensionParser.PlaceholderParser = block(fmap(
-  fence(opener, Infinity),
-  nodes => {
-    const [body, overflow, closer, opener, delim] = unwrap(nodes);
-    return new List([
-      new Node(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}`)),
-    ]);
-  }));
+export const placeholder: ExtensionParser.PlaceholderParser = block(inits([
+  fence(opener, true, 300),
+  (_, output) => {
+    const [body, overflow, closer, opener, delim] = unwrap(output.pop()) as string[];
+    return output.append(
+      new Node(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}`)));
+  },
+]));