securemark 0.296.3 → 0.296.4

package/src/combinator/data/parser.ts

@@ -33,6 +33,7 @@ export class Context {
     {
       source,
       position,
+      segment,
       resources,
       delimiters,
       precedence,
@@ -45,6 +46,7 @@ export class Context {
   ) {
     this.source = source ?? '';
     this.position = position ?? 0;
+    this.segment = segment ?? 0;
     this.resources = resources;
     this.precedence = precedence ?? 0;
     this.delimiters = delimiters ?? new Delimiters();
@@ -56,6 +58,7 @@ export class Context {
   }
   public source: string;
   public position: number;
+  public segment: number;
   public readonly resources?: {
     clock: number;
     recursions: number[];
@@ -103,6 +106,10 @@ export class Context {
   public backtracks: Record<number, number>;
 }
 export type Options = Partial<Context>;
+export const enum Segment {
+  unknown = 0,
+  write = 1,
+}
 
 export function input<C extends Context>(source: string, context: C): Input<C> {
   context.source = source;

package/src/parser/api/bind.ts

@@ -1,5 +1,5 @@
 import { ParserSettings, Progress } from '../../..';
-import { Context } from '../context';
+import { Context, Segment } from '../context';
 import { input } from '../../combinator/data/parser';
 import { segment } from '../segment';
 import { block } from '../block';
@@ -47,8 +47,10 @@ export function bind(target: DocumentFragment | HTMLElement | ShadowRoot, settin
     context.url = url ? new ReadonlyURL(url as ':') : undefined;
     const rev = revision = Symbol();
     const sourceSegments: string[] = [];
-    for (const seg of segment(source)) {
+    const sourceSegmentAttrs: Segment[] = [];
+    for (const [seg, attr] of segment(source)) {
       sourceSegments.push(seg);
+      sourceSegmentAttrs.push(attr);
       yield { type: 'segment', value: seg };
     }
     const targetSegments = blocks.map(([seg]) => seg);
@@ -74,12 +76,15 @@ export function bind(target: DocumentFragment | HTMLElement | ShadowRoot, settin
     context.header = true;
     for (; index < sourceSegments.length - last; ++index) {
       assert(rev === revision);
-      const seg = sourceSegments[index];
-      const es = block(input(seg, new Context(context)))
+      const src = sourceSegments[index];
+      context.segment = sourceSegmentAttrs[index] | Segment.write;
+      const es = block(input(src, new Context(context)))
         ?.foldl<HTMLElement[]>((acc, { value }) => void acc.push(value) || acc, []) ?? [];
       // @ts-expect-error
       context.header = false;
-      blocks.splice(index, 0, [seg, es, url]);
+      blocks.length === index
+        ? blocks.push([src, es, url])
+        : blocks.splice(index, 0, [src, es, url]);
       if (es.length === 0) continue;
       // All deletion processes always run after all addition processes have done.
       // Therefore any `base` node will never be unavailable by deletions until all the dependent `el` nodes are added.

package/src/parser/api/parse.ts

@@ -1,6 +1,6 @@
 import { ParserOptions } from '../../..';
 import { input } from '../../combinator/data/parser';
-import { Context } from '../context';
+import { Context, Segment } from '../context';
 import { segment } from '../segment';
 import { block } from '../block';
 import { normalize } from './normalize';
@@ -32,7 +32,8 @@ export function parse(source: string, options: Options = {}, context?: Context):
   const node = frag();
   // @ts-expect-error
   context.header = true;
-  for (const seg of segment(source)) {
+  for (const [seg, attr] of segment(source)) {
+    context.segment = attr | Segment.write;
     node.append(
       ...block(input(seg, new Context(context)))
         ?.foldl<HTMLElement[]>((acc, { value }) => void acc.push(value) || acc, []) ?? []);

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

@@ -1,4 +1,5 @@
 import { ExtensionParser } from '../../block';
+import { Segment } from '../../context';
 import { union, sequence, some, block, line, verify, rewrite, close, convert } from '../../../combinator';
 import { contentline } from '../../source';
 import { figure } from './figure';
@@ -23,7 +24,7 @@ export const segment: FigParser.SegmentParser = block(
       seg_placeholder,
       some(contentline),
     ]),
-  ]));
+  ]), true, Segment.fig);
 
 export const fig: FigParser = block(rewrite(segment, verify(convert(
   (source, context) => {
@@ -33,6 +34,7 @@ export const fig: FigParser = block(rewrite(segment, verify(convert(
     const { position } = context;
     const result = parser({ context });
     context.position = position;
+    context.segment = Segment.figure | Segment.write;
     return result
       ? `${fence}figure ${source.replace(/^(.+\n.+\n)([\S\s]+?)\n?$/, '$1\n$2')}\n${fence}`
       : `${fence}figure ${source}\n\n${fence}`;

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

@@ -1,4 +1,5 @@
 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 { str, contentline, emptyline } from '../../source';
@@ -44,7 +45,7 @@ export const segment: FigureParser.SegmentParser = block(match(
       ]),
     ]),
     closer),
-  ([, fence]) => fence.length - 1, [], 2 ** 4 - 1)));
+  ([, 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')),

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

@@ -57,7 +57,7 @@ export const message: MessageParser = block(fmap(
           'data-type': type,
         },
         [...segment(body)].reduce(
-          (acc, seg) =>
+          (acc, [seg]) =>
             push(acc, unwrap(content(subinput(seg, context)))),
           [html('h1', title(type))])))
     ]);

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

@@ -30,9 +30,9 @@ describe('Unit: parser/block/extension', () => {
       assert(parser(input('~~~\na\n~~~', new Context())));
       assert(parser(input('~~~a\n~~~', new Context())));
       assert(parser(input('~~~a\nb\n~~~', new Context())));
-      assert(parser(input('$-0', new Context())));
-      assert(parser(input('$-0\n', new Context())));
-      assert(parser(input('$-0\n\n', new Context())));
+      //assert(parser(input('$-0', new Context())));
+      //assert(parser(input('$-0\n', new Context())));
+      //assert(parser(input('$-0\n\n', new Context())));
     });
 
   });

package/src/parser/block/extension.ts

@@ -1,7 +1,6 @@
 import { ExtensionParser } from '../block';
 import { union } from '../../combinator';
-import { figbase } from './extension/figbase';
-import { fig, segment as seg_fig } from './extension/fig';
+import { segment as seg_fig } from './extension/fig';
 import { figure, segment as seg_figure } from './extension/figure';
 import { table, segment as seg_table } from './extension/table';
 import { message } from './extension/message';
@@ -17,8 +16,8 @@ export const segment: ExtensionParser.SegmentParser = union([
 ]);
 
 export const extension: ExtensionParser = union([
-  figbase,
-  fig,
+  //figbase,
+  //fig,
   figure,
   table,
   message,

package/src/parser/block/heading.ts

@@ -1,9 +1,9 @@
 import { HeadingParser } from '../block';
-import { State } from '../context';
+import { Segment, State } from '../context';
 import { List, Node } from '../../combinator/data/parser';
 import { union, some, state, block, line, focus, rewrite, open, fmap, firstline } from '../../combinator';
 import { inline, indexee, indexer, dataindex } from '../inline';
-import { str } from '../source';
+import { str, strs } from '../source';
 import { visualize, trimBlank } from '../visibility';
 import { unwrap, invalid } from '../util';
 import { html, defrag } from 'typed-dom/dom';
@@ -20,14 +20,14 @@ export const segment: HeadingParser.SegmentParser = block(focus(
       context.position += line.length;
     }
     return acc;
-  }, false));
+  }, false), true, Segment.heading);
 
 export const heading: HeadingParser = block(rewrite(segment,
   // その他の表示制御は各所のCSSで行う。
   state(State.annotation | State.reference | State.index | State.label | State.link,
   line(indexee(fmap(union([
     open(
-      str(/##+/y),
+      strs('#', 2),
       visualize(trimBlank(some(union([indexer, inline])))), true),
     open(
       str('#'),

package/src/parser/block.ts

@@ -1,10 +1,10 @@
 import { MarkdownParser } from '../../markdown';
-import { Recursion, Command } from './context';
+import { Segment, Recursion, Command } from './context';
 import { List, Node } from '../combinator/data/parser';
-import { union, reset, open, fallback, recover } from '../combinator';
+import { union, reset, firstline, recover } from '../combinator';
 import { MAX_SEGMENT_SIZE } from './segment';
 import { header } from './header';
-import { emptyline } from './source';
+import { emptysegment } from './source';
 import { pagebreak } from './block/pagebreak';
 import { heading } from './block/heading';
 import { ulist } from './block/ulist';
@@ -15,6 +15,9 @@ import { table } from './block/table';
 import { codeblock } from './block/codeblock';
 import { mathblock } from './block/mathblock';
 import { extension } from './block/extension';
+import { figbase } from './block/extension/figbase';
+import { fig } from './block/extension/fig';
+import { figure } from './block/extension/figure';
 import { sidefence } from './block/sidefence';
 import { blockquote } from './block/blockquote';
 import { mediablock } from './block/mediablock';
@@ -57,12 +60,22 @@ export const block: BlockParser = reset(
     backtracks: {},
   },
   error(union([
-    emptyline,
+    emptysegment,
     input => {
-      const { context: { source, position } } = input;
+      const { context: { source, position, segment } } = input;
       if (position === source.length) return;
+      switch (segment ^ Segment.write) {
+        case Segment.heading:
+          return heading(input);
+        case Segment.fig:
+          return fig(input);
+        case Segment.figure:
+          return figure(input);
+      }
       const fst = source[position];
       switch (fst) {
+        case Command.Error:
+          throw new Error(firstline(source, position + 1).trimEnd());
         case '=':
           if (source.startsWith('===', position)) return pagebreak(input);
           break;
@@ -84,7 +97,7 @@ export const block: BlockParser = reset(
         case '[':
           switch (source[position + 1]) {
             case '$':
-              return extension(input);
+              return figbase(input);
             case '!':
               return mediablock(input);
           }
@@ -95,11 +108,9 @@ export const block: BlockParser = reset(
         case '>':
           if (source[position + 1] === '>') return blockquote(input) || reply(input);
           return blockquote(input);
-        case '#':
-          return heading(input);
         case '$':
           if (source[position + 1] === '$') return mathblock(input);
-          return extension(input);
+          return figbase(input);
         case '|':
           return table(input) || sidefence(input);
         case '(':
@@ -113,9 +124,8 @@ export const block: BlockParser = reset(
 
 function error(parser: BlockParser): BlockParser {
   const reg = new RegExp(String.raw`^${Command.Error}[^\n]*\n`)
-  return recover<BlockParser>(fallback(
-    open(Command.Error, ({ context: { source, position } }) => { throw new Error(source.slice(position).split('\n', 1)[0]); }),
-    parser),
+  return recover<BlockParser>(
+    parser,
     ({ context: { source, position, id } }, reason) => new List([
       new Node(html('h1',
         {

package/src/parser/context.ts

@@ -7,6 +7,7 @@ export class Context extends Ctx {
   ) {
     super(options);
     const {
+      segment,
       buffer,
       sequential,
       header,
@@ -15,6 +16,7 @@ export class Context extends Ctx {
       id,
       caches,
     } = options;
+    this.segment = segment ?? Segment.unknown;
     this.buffer = buffer ?? new List();
     this.sequential = sequential ?? false;
     this.header = header ?? true;
@@ -23,6 +25,7 @@ export class Context extends Ctx {
     this.id = id;
     this.caches = caches;
   }
+  public override segment: Segment;
   public buffer: List<Node<(string | HTMLElement)>>;
   public sequential: boolean;
   public readonly header: boolean;
@@ -37,6 +40,16 @@ export class Context extends Ctx {
 }
 export type Options = Partial<Context>;
 
+export const enum Segment {
+  unknown = 0,
+  write = 1,
+  nonempty = 0,
+  empty = 1 << 1,
+  heading = 3 << 1,
+  fig = 4 << 1,
+  figure = 5 << 1,
+}
+
 export const enum State {
   annotation = 1 << 7,
   reference = 1 << 6,

package/src/parser/inline/emstrong.ts

@@ -26,7 +26,7 @@ export const emstrong: EmStrongParser = lazy(() =>
   precedence(0, recursion(Recursion.inline, repeat('***', beforeNonblank, surround(
     '',
     some(union([some(inline, '*', afterNonblank)])),
-    strs('*', 3),
+    strs('*', 1, 3),
     false, [],
     ([, bs, cs], context): Result<Parser.Node<EmStrongParser>, Parser.Context<EmStrongParser>> => {
       assert(cs.length === 1);

package/src/parser/segment.test.ts

@@ -4,108 +4,108 @@ import { Command } from './context';
 describe('Unit: parser/segment', () => {
   describe('segment', () => {
     it('huge input', () => {
-      const result = segment(`${'\n'.repeat(1e6 + 1)}`).next().value?.split('\n', 1)[0];
+      const result = segment(`${'\n'.repeat(1e6 + 1)}`).next().value?.[0].split('\n', 1)[0];
       assert(result?.startsWith(`${Command.Error}Too large input`));
     });
 
     it('huge segment', () => {
-      const result = segment(`${'\n'.repeat(1e5 + 1)}`).next().value?.split('\n', 1)[0];
+      const result = segment(`${'\n'.repeat(1e5 + 1)}`).next().value?.[0].split('\n', 1)[0];
       assert(result?.startsWith(`${Command.Error}Too large segment`));
     });
 
     it('basic', () => {
-      assert.deepStrictEqual([...segment('')], []);
-      assert.deepStrictEqual([...segment('a')], ['a']);
-      assert.deepStrictEqual([...segment('a\n')], ['a\n']);
-      assert.deepStrictEqual([...segment('a\n\n')], ['a\n', '\n']);
-      assert.deepStrictEqual([...segment('a\n\n\n')], ['a\n', '\n\n']);
-      assert.deepStrictEqual([...segment('a\nb')], ['a\nb']);
-      assert.deepStrictEqual([...segment('a\nb\n')], ['a\nb\n']);
-      assert.deepStrictEqual([...segment('a\nb\n\n')], ['a\nb\n', '\n']);
-      assert.deepStrictEqual([...segment('a\nb\n\n\n')], ['a\nb\n', '\n\n']);
-      assert.deepStrictEqual([...segment('a\nb\n\nc\n\nd')], ['a\nb\n', '\n', 'c\n', '\n', 'd']);
-      assert.deepStrictEqual([...segment('a\n\\\nb')], ['a\n\\\nb']);
-      assert.deepStrictEqual([...segment('a ')], ['a ']);
-      assert.deepStrictEqual([...segment(' a')], [' a']);
-      assert.deepStrictEqual([...segment(' a ')], [' a ']);
+      assert.deepStrictEqual([...segment('')].map(t => t[0]), []);
+      assert.deepStrictEqual([...segment('a')].map(t => t[0]), ['a']);
+      assert.deepStrictEqual([...segment('a\n')].map(t => t[0]), ['a\n']);
+      assert.deepStrictEqual([...segment('a\n\n')].map(t => t[0]), ['a\n', '\n']);
+      assert.deepStrictEqual([...segment('a\n\n\n')].map(t => t[0]), ['a\n', '\n\n']);
+      assert.deepStrictEqual([...segment('a\nb')].map(t => t[0]), ['a\nb']);
+      assert.deepStrictEqual([...segment('a\nb\n')].map(t => t[0]), ['a\nb\n']);
+      assert.deepStrictEqual([...segment('a\nb\n\n')].map(t => t[0]), ['a\nb\n', '\n']);
+      assert.deepStrictEqual([...segment('a\nb\n\n\n')].map(t => t[0]), ['a\nb\n', '\n\n']);
+      assert.deepStrictEqual([...segment('a\nb\n\nc\n\nd')].map(t => t[0]), ['a\nb\n', '\n', 'c\n', '\n', 'd']);
+      assert.deepStrictEqual([...segment('a\n\\\nb')].map(t => t[0]), ['a\n\\\nb']);
+      assert.deepStrictEqual([...segment('a ')].map(t => t[0]), ['a ']);
+      assert.deepStrictEqual([...segment(' a')].map(t => t[0]), [' a']);
+      assert.deepStrictEqual([...segment(' a ')].map(t => t[0]), [' a ']);
     });
 
     it('linebreak', () => {
-      assert.deepStrictEqual([...segment('\n')], ['\n']);
-      assert.deepStrictEqual([...segment('\n\n')], ['\n\n']);
-      assert.deepStrictEqual([...segment('\n\n\n')], ['\n\n\n']);
-      assert.deepStrictEqual([...segment('\n\n\n\n')], ['\n\n\n\n']);
-      assert.deepStrictEqual([...segment(' ')], [' ']);
-      assert.deepStrictEqual([...segment(' \n')], [' \n']);
-      assert.deepStrictEqual([...segment(' \n \n \n ')], [' \n \n \n ']);
-      assert.deepStrictEqual([...segment('a\n')], ['a\n']);
-      assert.deepStrictEqual([...segment('a\n ')], ['a\n', ' ']);
-      assert.deepStrictEqual([...segment('a\n\n ')], ['a\n', '\n ']);
-      assert.deepStrictEqual([...segment('a\n\n\n ')], ['a\n', '\n\n ']);
-      assert.deepStrictEqual([...segment('a\n\n\n\n ')], ['a\n', '\n\n\n ']);
-      assert.deepStrictEqual([...segment('a\n\n\n\n\n ')], ['a\n', '\n\n\n\n ']);
-      assert.deepStrictEqual([...segment('a\n\n\n\n\n\n ')], ['a\n', '\n\n\n\n\n ']);
+      assert.deepStrictEqual([...segment('\n')].map(t => t[0]), ['\n']);
+      assert.deepStrictEqual([...segment('\n\n')].map(t => t[0]), ['\n\n']);
+      assert.deepStrictEqual([...segment('\n\n\n')].map(t => t[0]), ['\n\n\n']);
+      assert.deepStrictEqual([...segment('\n\n\n\n')].map(t => t[0]), ['\n\n\n\n']);
+      assert.deepStrictEqual([...segment(' ')].map(t => t[0]), [' ']);
+      assert.deepStrictEqual([...segment(' \n')].map(t => t[0]), [' \n']);
+      assert.deepStrictEqual([...segment(' \n \n \n ')].map(t => t[0]), [' \n \n \n ']);
+      assert.deepStrictEqual([...segment('a\n')].map(t => t[0]), ['a\n']);
+      assert.deepStrictEqual([...segment('a\n ')].map(t => t[0]), ['a\n', ' ']);
+      assert.deepStrictEqual([...segment('a\n\n ')].map(t => t[0]), ['a\n', '\n ']);
+      assert.deepStrictEqual([...segment('a\n\n\n ')].map(t => t[0]), ['a\n', '\n\n ']);
+      assert.deepStrictEqual([...segment('a\n\n\n\n ')].map(t => t[0]), ['a\n', '\n\n\n ']);
+      assert.deepStrictEqual([...segment('a\n\n\n\n\n ')].map(t => t[0]), ['a\n', '\n\n\n\n ']);
+      assert.deepStrictEqual([...segment('a\n\n\n\n\n\n ')].map(t => t[0]), ['a\n', '\n\n\n\n\n ']);
     });
 
     it('codeblock', () => {
-      assert.deepStrictEqual([...segment('```')], ['```']);
-      assert.deepStrictEqual([...segment('```\n```')], ['```\n```']);
-      assert.deepStrictEqual([...segment('```\n\n```')], ['```\n\n```']);
-      assert.deepStrictEqual([...segment('```\n\n\n```')], ['```\n', '\n\n', '```']);
-      assert.deepStrictEqual([...segment('```\n\n0\n```')], ['```\n', '\n', '0\n```']);
-      assert.deepStrictEqual([...segment('```\n0\n\n```')], ['```\n0\n\n```']);
-      assert.deepStrictEqual([...segment('```\n````\n```')], ['```\n````\n```']);
-      assert.deepStrictEqual([...segment('````\n```\n````')], ['````\n```\n````']);
-      assert.deepStrictEqual([...segment('```\n\n```\n\n')], ['```\n\n```\n', '\n']);
+      assert.deepStrictEqual([...segment('```')].map(t => t[0]), ['```']);
+      assert.deepStrictEqual([...segment('```\n```')].map(t => t[0]), ['```\n```']);
+      assert.deepStrictEqual([...segment('```\n\n```')].map(t => t[0]), ['```\n\n```']);
+      assert.deepStrictEqual([...segment('```\n\n\n```')].map(t => t[0]), ['```\n', '\n\n', '```']);
+      assert.deepStrictEqual([...segment('```\n\n0\n```')].map(t => t[0]), ['```\n', '\n', '0\n```']);
+      assert.deepStrictEqual([...segment('```\n0\n\n```')].map(t => t[0]), ['```\n0\n\n```']);
+      assert.deepStrictEqual([...segment('```\n````\n```')].map(t => t[0]), ['```\n````\n```']);
+      assert.deepStrictEqual([...segment('````\n```\n````')].map(t => t[0]), ['````\n```\n````']);
+      assert.deepStrictEqual([...segment('```\n\n```\n\n')].map(t => t[0]), ['```\n\n```\n', '\n']);
     });
 
     it('mathblock', () => {
-      assert.deepStrictEqual([...segment('$$')], ['$$']);
-      assert.deepStrictEqual([...segment('$$\n$$')], ['$$\n$$']);
-      assert.deepStrictEqual([...segment('$$\n\n$$')], ['$$\n\n$$']);
-      assert.deepStrictEqual([...segment('$$\n\n\n$$')], ['$$\n', '\n\n', '$$']);
-      assert.deepStrictEqual([...segment('$$\n\n0\n$$')], ['$$\n', '\n', '0\n$$']);
-      assert.deepStrictEqual([...segment('$$\n0\n\n$$')], ['$$\n0\n\n$$']);
-      assert.deepStrictEqual([...segment('$$\n\n$$\n\n')], ['$$\n\n$$\n', '\n']);
+      assert.deepStrictEqual([...segment('$$')].map(t => t[0]), ['$$']);
+      assert.deepStrictEqual([...segment('$$\n$$')].map(t => t[0]), ['$$\n$$']);
+      assert.deepStrictEqual([...segment('$$\n\n$$')].map(t => t[0]), ['$$\n\n$$']);
+      assert.deepStrictEqual([...segment('$$\n\n\n$$')].map(t => t[0]), ['$$\n', '\n\n', '$$']);
+      assert.deepStrictEqual([...segment('$$\n\n0\n$$')].map(t => t[0]), ['$$\n', '\n', '0\n$$']);
+      assert.deepStrictEqual([...segment('$$\n0\n\n$$')].map(t => t[0]), ['$$\n0\n\n$$']);
+      assert.deepStrictEqual([...segment('$$\n\n$$\n\n')].map(t => t[0]), ['$$\n\n$$\n', '\n']);
     });
 
     it('extension', () => {
-      assert.deepStrictEqual([...segment('~~~')], ['~~~']);
-      assert.deepStrictEqual([...segment('~~~\n~~~')], ['~~~\n~~~']);
-      assert.deepStrictEqual([...segment('~~~\n\n~~~')], ['~~~\n\n~~~']);
-      assert.deepStrictEqual([...segment('~~~\n\n\n~~~')], ['~~~\n', '\n\n', '~~~']);
-      assert.deepStrictEqual([...segment('~~~\n\n0\n~~~')], ['~~~\n', '\n', '0\n~~~']);
-      assert.deepStrictEqual([...segment('~~~\n0\n\n~~~')], ['~~~\n0\n\n~~~']);
-      assert.deepStrictEqual([...segment('~~~\n~~~~\n~~~')], ['~~~\n~~~~\n~~~']);
-      assert.deepStrictEqual([...segment('~~~~\n~~~\n~~~~')], ['~~~~\n~~~\n~~~~']);
-      assert.deepStrictEqual([...segment('~~~\n\n~~~\n\n')], ['~~~\n\n~~~\n', '\n']);
-      assert.deepStrictEqual([...segment('~~~\n```\n~~~\n```\n~~~')], ['~~~\n```\n~~~\n```\n~~~']);
-      assert.deepStrictEqual([...segment('~~~\ninvalid\n~~~')], ['~~~\ninvalid\n~~~']);
-      assert.deepStrictEqual([...segment('~~~\ninvalid\n\ncaption\n~~~')], ['~~~\ninvalid\n\ncaption\n~~~']);
-      assert.deepStrictEqual([...segment('~~~figure [$-name]\n$$\n$$\n\n```\n~~~')], ['~~~figure [$-name]\n$$\n$$\n\n```\n~~~']);
+      assert.deepStrictEqual([...segment('~~~')].map(t => t[0]), ['~~~']);
+      assert.deepStrictEqual([...segment('~~~\n~~~')].map(t => t[0]), ['~~~\n~~~']);
+      assert.deepStrictEqual([...segment('~~~\n\n~~~')].map(t => t[0]), ['~~~\n\n~~~']);
+      assert.deepStrictEqual([...segment('~~~\n\n\n~~~')].map(t => t[0]), ['~~~\n', '\n\n', '~~~']);
+      assert.deepStrictEqual([...segment('~~~\n\n0\n~~~')].map(t => t[0]), ['~~~\n', '\n', '0\n~~~']);
+      assert.deepStrictEqual([...segment('~~~\n0\n\n~~~')].map(t => t[0]), ['~~~\n0\n\n~~~']);
+      assert.deepStrictEqual([...segment('~~~\n~~~~\n~~~')].map(t => t[0]), ['~~~\n~~~~\n~~~']);
+      assert.deepStrictEqual([...segment('~~~~\n~~~\n~~~~')].map(t => t[0]), ['~~~~\n~~~\n~~~~']);
+      assert.deepStrictEqual([...segment('~~~\n\n~~~\n\n')].map(t => t[0]), ['~~~\n\n~~~\n', '\n']);
+      assert.deepStrictEqual([...segment('~~~\n```\n~~~\n```\n~~~')].map(t => t[0]), ['~~~\n```\n~~~\n```\n~~~']);
+      assert.deepStrictEqual([...segment('~~~\ninvalid\n~~~')].map(t => t[0]), ['~~~\ninvalid\n~~~']);
+      assert.deepStrictEqual([...segment('~~~\ninvalid\n\ncaption\n~~~')].map(t => t[0]), ['~~~\ninvalid\n\ncaption\n~~~']);
+      assert.deepStrictEqual([...segment('~~~figure [$-name]\n$$\n$$\n\n```\n~~~')].map(t => t[0]), ['~~~figure [$-name]\n$$\n$$\n\n```\n~~~']);
     });
 
     it('mixed', () => {
-      assert.deepStrictEqual([...segment('```\n\n\n')], ['```\n', '\n\n']);
-      assert.deepStrictEqual([...segment('~~~\n\n\n')], ['~~~\n', '\n\n']);
-      assert.deepStrictEqual([...segment('```\n~~~\n```')], ['```\n~~~\n```']);
-      assert.deepStrictEqual([...segment('~~~\n```\n~~~')], ['~~~\n```\n~~~']);
-      assert.deepStrictEqual([...segment('```\n```\n\n~~~\n~~~')], ['```\n```\n', '\n', '~~~\n~~~']);
-      assert.deepStrictEqual([...segment('~~~\n~~~\n\n```\n```')], ['~~~\n~~~\n', '\n', '```\n```']);
-      assert.deepStrictEqual([...segment(' ```\n\n```')], [' ```\n', '\n', '```']);
-      assert.deepStrictEqual([...segment(' ~~~\n\n~~~')], [' ~~~\n', '\n', '~~~']);
+      assert.deepStrictEqual([...segment('```\n\n\n')].map(t => t[0]), ['```\n', '\n\n']);
+      assert.deepStrictEqual([...segment('~~~\n\n\n')].map(t => t[0]), ['~~~\n', '\n\n']);
+      assert.deepStrictEqual([...segment('```\n~~~\n```')].map(t => t[0]), ['```\n~~~\n```']);
+      assert.deepStrictEqual([...segment('~~~\n```\n~~~')].map(t => t[0]), ['~~~\n```\n~~~']);
+      assert.deepStrictEqual([...segment('```\n```\n\n~~~\n~~~')].map(t => t[0]), ['```\n```\n', '\n', '~~~\n~~~']);
+      assert.deepStrictEqual([...segment('~~~\n~~~\n\n```\n```')].map(t => t[0]), ['~~~\n~~~\n', '\n', '```\n```']);
+      assert.deepStrictEqual([...segment(' ```\n\n```')].map(t => t[0]), [' ```\n', '\n', '```']);
+      assert.deepStrictEqual([...segment(' ~~~\n\n~~~')].map(t => t[0]), [' ~~~\n', '\n', '~~~']);
     });
 
     it('blockquote', () => {
-      assert.deepStrictEqual([...segment('> ```\n\n```')], ['> ```\n', '\n', '```']);
-      assert.deepStrictEqual([...segment('!> ```\n\n```')], ['!> ```\n', '\n', '```']);
+      assert.deepStrictEqual([...segment('> ```\n\n```')].map(t => t[0]), ['> ```\n', '\n', '```']);
+      assert.deepStrictEqual([...segment('!> ```\n\n```')].map(t => t[0]), ['!> ```\n', '\n', '```']);
     });
 
     it('heading', () => {
-      assert.deepStrictEqual([...segment('# a\n\n# b\n')], ['# a\n', '\n', '# b\n']);
-      assert.deepStrictEqual([...segment('# a\n# b\n')], ['# a\n', '# b\n']);
-      assert.deepStrictEqual([...segment('# a\n# b')], ['# a\n', '# b']);
-      assert.deepStrictEqual([...segment('# a\n # b')], ['# a\n # b']);
+      assert.deepStrictEqual([...segment('# a\n\n# b\n')].map(t => t[0]), ['# a\n', '\n', '# b\n']);
+      assert.deepStrictEqual([...segment('# a\n# b\n')].map(t => t[0]), ['# a\n', '# b\n']);
+      assert.deepStrictEqual([...segment('# a\n# b')].map(t => t[0]), ['# a\n', '# b']);
+      assert.deepStrictEqual([...segment('# a\n # b')].map(t => t[0]), ['# a\n # b']);
     });
 
   });

package/src/parser/segment.ts

@@ -1,11 +1,11 @@
 import { MarkdownParser } from '../../markdown';
-import { Context, Command } from './context';
+import { Context, Segment, Command } from './context';
 import { union, some } from '../combinator';
 import { segment as heading } from './block/heading';
 import { segment as codeblock } from './block/codeblock';
 import { segment as mathblock } from './block/mathblock';
 import { segment as extension } from './block/extension';
-import { contentline, emptyline } from './source';
+import { contentline, emptysegment } from './source';
 
 import SegmentParser = MarkdownParser.SegmentParser;
 
@@ -13,7 +13,7 @@ export const MAX_SEGMENT_SIZE = 100_000; // 100,000 bytes (Max value size of FDB
 export const MAX_INPUT_SIZE = MAX_SEGMENT_SIZE * 10;
 
 const parser: SegmentParser = union([
-  some(emptyline, MAX_SEGMENT_SIZE + 1),
+  some(emptysegment, MAX_SEGMENT_SIZE + 1),
   input => {
     const { context: { source, position } } = input;
     if (position === source.length) return;
@@ -26,21 +26,19 @@ const parser: SegmentParser = union([
         break;
       case '$':
         if (source[position + 1] === '$') return mathblock(input);
-        break;
+        return extension(input);
       case '[':
         if (source[position + 1] === '$') return extension(input);
         break;
       case '#':
         return heading(input);
-      case '$':
-        return extension(input);
     }
   },
   some(contentline, MAX_SEGMENT_SIZE + 1),
 ]) as any;
 
-export function* segment(source: string): Generator<string, undefined, undefined> {
-  if (!validate(source, MAX_INPUT_SIZE)) return yield `${Command.Error}Too large input over ${MAX_INPUT_SIZE.toLocaleString('en')} bytes.\n${source.slice(0, 1001)}`;
+export function* segment(source: string): Generator<readonly [string, Segment], undefined, undefined> {
+  if (!validate(source, MAX_INPUT_SIZE)) return yield [`${Command.Error}Too large input over ${MAX_INPUT_SIZE.toLocaleString('en')} bytes.\n${source.slice(0, 1001)}`, Segment.unknown];
   assert(source.length < Number.MAX_SAFE_INTEGER);
   for (let position = 0; position < source.length;) {
     const context = new Context({ source, position });
@@ -51,13 +49,13 @@ export function* segment(source: string): Generator<string, undefined, undefined
       ? result.foldl<string[]>((acc, { value }) => void acc.push(value) || acc, [])
       : [source.slice(position, context.position)];
     assert(segs.join('') === source.slice(position, context.position));
+    position = context.position;
     for (let i = 0; i < segs.length; ++i) {
       const seg = segs[i];
       validate(seg, MAX_SEGMENT_SIZE)
-        ? yield seg
-        : yield `${Command.Error}Too large segment over ${MAX_SEGMENT_SIZE.toLocaleString('en')} bytes.\n${seg}`
+        ? yield [seg, context.segment]
+        : yield [`${Command.Error}Too large segment over ${MAX_SEGMENT_SIZE.toLocaleString('en')} bytes.\n${seg}`, Segment.unknown];
     }
-    position = context.position;
   }
 }
 

package/src/parser/source/line.ts

@@ -1,4 +1,5 @@
-import { AnyLineParser, EmptyLineParser, ContentLineParser } from '../source';
+import { AnyLineParser, EmptyLineParser, EmptySegmentParser, ContentLineParser } from '../source';
+import { Segment } from '../context';
 import { List } from '../../combinator/data/parser';
 
 export const anyline: AnyLineParser = input => {
@@ -14,14 +15,32 @@ export const emptyline: EmptyLineParser = input => {
   const { context } = input;
   const { source, position } = context;
   if (position === source.length) return;
-  if (source[position] === '\n') return ++context.position, new List();
-  regEmptyline.lastIndex = position;
-  regEmptyline.test(source);
-  const i = regEmptyline.lastIndex;
-  if (i === 0) return;
+  const i = eoel(source, position);
+  if (i === position) return;
+  context.position = i;
+  return new List();
+};
+export const emptysegment: EmptySegmentParser = input => {
+  const { context } = input;
+  const { source, position, segment } = context;
+  if (position === source.length) return;
+  if (segment & Segment.write) {
+    if (segment !== (Segment.empty | Segment.write)) return;
+    context.position = source.length;
+    return new List();
+  }
+  const i = eoel(source, position);
+  if (i === position) return;
   context.position = i;
+  context.segment = Segment.empty;
   return new List();
 };
+function eoel(source: string, position: number): number {
+  if (source[position] === '\n') return position + 1;
+  regEmptyline.lastIndex = position;
+  regEmptyline.test(source);
+  return regEmptyline.lastIndex || position;
+}
 
 const regContentline = /[^\S\n]*\S[^\n]*(?:$|\n)/y;
 export const contentline: ContentLineParser = input => {