securemark 0.294.6 → 0.294.8

package/markdown.d.ts

@@ -614,7 +614,6 @@ export namespace MarkdownParser {
         Parser<HTMLSpanElement | HTMLBRElement, Context, [
           InlineParser.MathParser,
           InlineParser.AutolinkParser,
-          SourceParser.LinebreakParser,
           SourceParser.UnescapableSourceParser,
         ]> {
       }
@@ -808,13 +807,6 @@ export namespace MarkdownParser {
           LinkParser.ParameterParser,
         ]> {
       }
-      export interface UnsafeLinkParser extends
-        Inline<'link/unsafelink'>,
-        Parser<HTMLAnchorElement, Context, [
-          LinkParser.TextParser,
-          LinkParser.ParameterParser,
-        ]> {
-      }
       export interface ContentParser extends
         Inline<'link/content'>,
         Parser<List<Data<string | HTMLElement>>, Context, [
@@ -1098,7 +1090,6 @@ export namespace MarkdownParser {
         AutolinkParser.UrlParser.LineUrlParser,
         AutolinkParser.UrlParser,
         AutolinkParser.EmailParser,
-        AutolinkParser.ChannelParser,
         AutolinkParser.AccountParser,
         AutolinkParser.HashtagParser,
         AutolinkParser.HashnumParser,
@@ -1110,7 +1101,7 @@ export namespace MarkdownParser {
         // https://host
         Inline<'url'>,
         Parser<string | HTMLElement, Context, [
-          LinkParser.UnsafeLinkParser,
+          Parser<HTMLAnchorElement, Context, []>,
           InlineParser,
         ]> {
       }
@@ -1120,7 +1111,7 @@ export namespace MarkdownParser {
           Parser<string | HTMLElement, Context, [
             SourceParser.StrParser,
             Parser<string | HTMLElement, Context, [
-              InlineParser.LinkParser.UnsafeLinkParser,
+              Parser<HTMLAnchorElement, Context, []>,
               InlineParser,
             ]>,
           ]> {
@@ -1147,43 +1138,37 @@ export namespace MarkdownParser {
       export interface EmailParser extends
         // user@host
         Inline<'email'>,
-        Parser<string | HTMLAnchorElement, Context, [
-          Parser<HTMLAnchorElement, Context, []>,
-        ]> {
-      }
-      export interface ChannelParser extends
-        // @user#tag
-        Inline<'channel'>,
-        Parser<string | HTMLAnchorElement, Context, [
-          LinkParser.UnsafeLinkParser,
+        Parser<HTMLAnchorElement, Context, [
+          SourceParser.StrParser,
         ]> {
       }
       export interface AccountParser extends
         // @user
+        // @user#tag
         Inline<'account'>,
-        Parser<string | HTMLAnchorElement, Context, [
-          LinkParser.UnsafeLinkParser,
+        Parser<HTMLAnchorElement, Context, [
+          SourceParser.StrParser,
         ]> {
       }
       export interface HashtagParser extends
         // #tag
         Inline<'hashtag'>,
-        Parser<string | HTMLAnchorElement, Context, [
-          LinkParser.UnsafeLinkParser,
+        Parser<HTMLAnchorElement, Context, [
+          SourceParser.StrParser,
         ]> {
       }
       export interface HashnumParser extends
         // #1
         Inline<'hashnum'>,
-        Parser<string | HTMLAnchorElement, Context, [
-          LinkParser.UnsafeLinkParser,
+        Parser<HTMLAnchorElement, Context, [
+          SourceParser.StrParser,
         ]> {
       }
       export interface AnchorParser extends
         // >>1
         Inline<'anchor'>,
-        Parser<string | HTMLAnchorElement, Context, [
-          LinkParser.UnsafeLinkParser,
+        Parser<HTMLAnchorElement, Context, [
+          SourceParser.StrParser,
         ]> {
       }
     }
@@ -1192,7 +1177,6 @@ export namespace MarkdownParser {
     Markdown<'autolink'>,
     Parser<string | HTMLElement, Context, [
       InlineParser.AutolinkParser,
-      SourceParser.LinebreakParser,
       SourceParser.UnescapableSourceParser,
     ]> {
   }
@@ -1210,13 +1194,6 @@ export namespace MarkdownParser {
         TextParser,
       ]> {
     }
-    export interface LinebreakParser extends
-      // \n
-      Source<'linebreak'>,
-      Parser<HTMLBRElement, Context, [
-        TextParser,
-      ]> {
-    }
     export interface EscapableSourceParser extends
       // abc
       Source<'escsource'>,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "securemark",
-  "version": "0.294.6",
+  "version": "0.294.8",
   "description": "Secure markdown renderer working on browsers for user input data.",
   "private": false,
   "homepage": "https://github.com/falsandtru/securemark",

package/src/combinator/control/constraint/block.ts

@@ -1,5 +1,5 @@
 import { Parser, failsafe } from '../../data/parser';
-import { firstline, isBlank } from './line';
+import { isBlankline } from './line';
 
 export function block<P extends Parser<unknown>>(parser: P, separation?: boolean): P;
 export function block<N>(parser: Parser<N>, separation = true): Parser<N> {
@@ -10,7 +10,7 @@ export function block<N>(parser: Parser<N>, separation = true): Parser<N> {
     if (position === source.length) return;
     const result = parser(input);
     if (result === undefined) return;
-    if (separation && !isBlank(firstline(source, context.position))) return;
+    if (separation && !isBlankline(source, context.position)) return;
     assert(context.position === source.length || source[context.position - 1] === '\n');
     return context.position === source.length || source[context.position - 1] === '\n'
       ? result

package/src/combinator/control/constraint/line.ts

@@ -16,7 +16,7 @@ export function line<N>(parser: Parser<N>): Parser<N> {
     context.source = source;
     context.offset -= position;
     if (result === undefined) return;
-    if (!isBlank(source.slice(context.position, position + line.length))) return;
+    if (context.position < position + line.length && !isBlankline(source, context.position)) return;
     context.position = position + line.length;
     return result;
   });
@@ -29,8 +29,10 @@ export function firstline(source: string, position: number): string {
     : source.slice(position, i + 1);
 }
 
-export function isBlank(line: string): boolean {
-  return line === ''
-      || line === '\n'
-      || line.trimStart() === '';
+const blankline = /[^\S\n]*(?:$|\n)/y;
+export function isBlankline(source: string, position: number): boolean {
+  blankline.lastIndex = position;
+  return source.length === position
+      || source[position] === '\n'
+      || blankline.test(source);
 }

package/src/combinator/control/manipulation/convert.ts

@@ -8,6 +8,7 @@ export function convert<N>(conv: (source: string, context: Ctx) => string, parse
     const { source, position } = context;
     if (position === source.length) return;
     const src = conv(source.slice(position), context);
+    assert(context.position === position);
     if (src === '') {
       if (!empty) return;
       context.position = source.length;
@@ -22,7 +23,7 @@ export function convert<N>(conv: (source: string, context: Ctx) => string, parse
       return result;
     }
     else {
-    const { offset, backtracks } = context;
+      const { offset, backtracks } = context;
       const result = parser(subinput(src, context));
       context.position = context.source.length
       assert(context.offset === offset);

package/src/combinator/control/manipulation/fence.ts

@@ -1,6 +1,6 @@
 import { Parser, List, Data, Ctx, failsafe } from '../../data/parser';
 import { consume } from '../../../combinator';
-import { firstline, isBlank } from '../constraint/line';
+import { firstline, isBlankline } from '../constraint/line';
 import { push } from 'spica/array';
 
 export function fence<C extends Ctx, D extends Parser<unknown, C>[]>(opener: RegExp, limit: number, separation = true): Parser<string, C, D> {
@@ -20,20 +20,20 @@ export function fence<C extends Ctx, D extends Parser<unknown, C>[]>(opener: Reg
     context.position += matches[0].length;
     // Prevent annoying parsing in editing.
     const secondline = firstline(source, context.position);
-    if (isBlank(secondline) && firstline(source, context.position + secondline.length).trimEnd() !== delim) return;
+    if (isBlankline(secondline, 0) && firstline(source, context.position + secondline.length).trimEnd() !== delim) return;
     let block = '';
     let closer = '';
     let overflow = '';
     for (let count = 1; ; ++count) {
       if (context.position === source.length) break;
       const line = firstline(source, context.position);
-      if ((closer || count > limit + 1) && isBlank(line)) break;
+      if ((closer || count > limit + 1) && isBlankline(line, 0)) break;
       if(closer) {
         overflow += line;
       }
       if (!closer && count <= limit + 1 && line.slice(0, delim.length) === delim && line.trimEnd() === delim) {
         closer = line;
-        if (isBlank(firstline(source, context.position + line.length))) {
+        if (isBlankline(source, context.position + line.length)) {
           context.position += line.length;
           break;
         }

package/src/combinator/control/manipulation/indent.ts

@@ -16,7 +16,7 @@ export function indent<N>(opener: RegExp | Parser<N>, parser: Parser<N> | boolea
     opener = / {1,4}|\t{1,2}/y;
   }
   assert(!opener.flags.match(/[gm]/) && opener.sticky && !opener.source.startsWith('^'));
-  assert(parser);
+  assert(parser = parser as Parser<N>);
   return failsafe(bind(block(match(
     opener,
     memoize(
@@ -27,10 +27,8 @@ export function indent<N>(opener: RegExp | Parser<N>, parser: Parser<N> | boolea
         return new List([new Data(source.slice(position))]);
       }))),
     ([indent]) => indent.length * 2 + -(indent[0] === ' '), [], 2 ** 4 - 1)), separation),
-    (lines, context) => {
-      assert(parser = parser as Parser<N>);
-      return parser(subinput(trimBlockEnd(lines.foldl((acc, node) => acc + node.value, '')), context));
-    }));
+    (lines, context) =>
+      parser(subinput(trimBlockEnd(lines.foldl((acc, node) => acc + node.value, '')), context))));
 }
 
 function trimBlockEnd(block: string): string {

package/src/combinator/control/manipulation/surround.ts

@@ -4,48 +4,70 @@ import { matcher, clear } from '../../../combinator';
 export function surround<P extends Parser<unknown>, S = string>(
   opener: string | RegExp | Parser<S, Context<P>>, parser: IntermediateParser<P>, closer: string | RegExp | Parser<S, Context<P>>,
   optional?: false,
+  backtracks?: readonly number[],
   f?: (rss: [List<Data<S>>, List<Data<SubNode<P>>>, List<Data<S>>], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
   g?: (rss: [List<Data<S>>, List<Data<SubNode<P>>> | undefined], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
-  backtracks?: readonly number[],
 ): P;
 export function surround<P extends Parser<unknown>, S = string>(
   opener: string | RegExp | Parser<S, Context<P>>, parser: IntermediateParser<P>, closer: string | RegExp | Parser<S, Context<P>>,
   optional?: boolean,
+  backtracks?: readonly number[],
   f?: (rss: [List<Data<S>>, List<Data<SubNode<P>>> | undefined, List<Data<S>>], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
   g?: (rss: [List<Data<S>>, List<Data<SubNode<P>>> | undefined], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
-  backtracks?: readonly number[],
 ): P;
 export function surround<P extends Parser<unknown>, S = string>(
   opener: string | RegExp | Parser<S, Context<P>>, parser: P, closer: string | RegExp | Parser<S, Context<P>>,
   optional?: false,
+  backtracks?: readonly number[],
   f?: (rss: [List<Data<S>>, List<Data<Node<P>>>, List<Data<S>>], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
   g?: (rss: [List<Data<S>>, List<Data<Node<P>>> | undefined], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
-  backtracks?: readonly number[],
 ): P;
 export function surround<P extends Parser<unknown>, S = string>(
   opener: string | RegExp | Parser<S, Context<P>>, parser: P, closer: string | RegExp | Parser<S, Context<P>>,
   optional?: boolean,
+  backtracks?: readonly number[],
   f?: (rss: [List<Data<S>>, List<Data<Node<P>>> | undefined, List<Data<S>>], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
   g?: (rss: [List<Data<S>>, List<Data<Node<P>>> | undefined], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
+): P;
+export function surround<P extends Parser<string>, S = string>(
+  opener: string | RegExp | Parser<S, Context<P>>, parser: string | RegExp | P, closer: string | RegExp | Parser<S, Context<P>>,
+  optional?: false,
   backtracks?: readonly number[],
+  f?: (rss: [List<Data<S>>, List<Data<Node<P>>>, List<Data<S>>], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
+  g?: (rss: [List<Data<S>>, List<Data<Node<P>>> | undefined], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
+): P;
+export function surround<P extends Parser<string>, S = string>(
+  opener: string | RegExp | Parser<S, Context<P>>, parser: string | RegExp | P, closer: string | RegExp | Parser<S, Context<P>>,
+  optional?: boolean,
+  backtracks?: readonly number[],
+  f?: (rss: [List<Data<S>>, List<Data<Node<P>>> | undefined, List<Data<S>>], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
+  g?: (rss: [List<Data<S>>, List<Data<Node<P>>> | undefined], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
 ): P;
 export function surround<N>(
-  opener: string | RegExp | Parser<N>, parser: Parser<N>, closer: string | RegExp | Parser<N>,
+  opener: string | RegExp | Parser<N>, parser: string | RegExp | Parser<N>, closer: string | RegExp | Parser<N>,
   optional: boolean = false,
+  backtracks: readonly number[] = [],
   f?: (rss: [List<Data<N>>, List<Data<N>>, List<Data<N>>], context: Ctx) => Result<N>,
   g?: (rss: [List<Data<N>>, List<Data<N>> | undefined], context: Ctx) => Result<N>,
-  backtracks: readonly number[] = [],
 ): Parser<N> {
   switch (typeof opener) {
     case 'string':
     case 'object':
       opener = clear(matcher(opener, true));
   }
+  assert(opener);
+  switch (typeof parser) {
+    case 'string':
+    case 'object':
+      parser = clear(matcher(parser, true));
+  }
+  assert(parser);
   switch (typeof closer) {
     case 'string':
     case 'object':
       closer = clear(matcher(closer, true));
   }
+  assert(closer);
   return failsafe(input => {
     const { context } = input;
     const { source, position } = context;
@@ -66,8 +88,7 @@ export function surround<N>(
     if (!nodesM && !optional) {
       setBacktrack(context, backtracks, position);
       const result = g?.([nodesO, nodesM], context);
-      revert(context, linebreak);
-      return result;
+      return result || void revert(context, linebreak);
     }
     const nodesC = nodesM || optional ? closer(input) : undefined;
     assert(context.position >= position);
@@ -75,8 +96,7 @@ export function surround<N>(
     if (!nodesC) {
       setBacktrack(context, backtracks, position);
       const result = g?.([nodesO, nodesM], context);
-      revert(context, linebreak);
-      return result;
+      return result || void revert(context, linebreak);
     }
     if (context.position === position) {
       return void revert(context, linebreak);
@@ -88,10 +108,7 @@ export function surround<N>(
     if (result) {
       context.linebreak ||= linebreak;
     }
-    else {
-      revert(context, linebreak);
-    }
-    return result;
+    return result || void revert(context, linebreak);
   });
 }
 export function open<P extends Parser<unknown>>(
@@ -100,13 +117,19 @@ export function open<P extends Parser<unknown>>(
   optional?: boolean,
   backtracks?: readonly number[],
 ): P;
+export function open<P extends Parser<string>>(
+  opener: string | RegExp | Parser<Node<P>, Context<P>>,
+  parser: string | RegExp | P,
+  optional?: boolean,
+  backtracks?: readonly number[],
+): P;
 export function open<N>(
   opener: string | RegExp | Parser<N, Ctx>,
-  parser: Parser<N>,
+  parser: string | RegExp | Parser<N>,
   optional?: boolean,
   backtracks?: readonly number[],
 ): Parser<N> {
-  return surround(opener, parser, '', optional, undefined, undefined, backtracks);
+  return surround(opener, parser as Parser<N>, '', optional, backtracks);
 }
 export function close<P extends Parser<unknown>>(
   parser: P,
@@ -114,13 +137,19 @@ export function close<P extends Parser<unknown>>(
   optional?: boolean,
   backtracks?: readonly number[],
 ): P;
+export function close<P extends Parser<string>>(
+  parser: string | RegExp | P,
+  closer: string | RegExp | Parser<Node<P>, Context<P>>,
+  optional?: boolean,
+  backtracks?: readonly number[],
+): P;
 export function close<N>(
-  parser: Parser<N>,
+  parser: string | RegExp | Parser<N>,
   closer: string | RegExp | Parser<N, Ctx>,
   optional?: boolean,
   backtracks?: readonly number[],
 ): Parser<N> {
-  return surround('', parser, closer, optional, undefined, undefined, backtracks);
+  return surround('', parser as Parser<N>, closer, optional, backtracks);
 }
 
 const statesize = 2;
@@ -153,7 +182,7 @@ export function setBacktrack(
   position: number,
   length: number = 1,
 ): void {
-  // 以降バックトラックの可能性がなく記録不要の場合もあるが判別が面倒なので省略
+  // バックトラックの可能性がなく記録不要の場合もあるが判別が面倒なので省略
   const { source } = context;
   if (position === source.length) return;
   if (length === 0) return;

package/src/combinator/data/parser/some.ts

@@ -24,7 +24,7 @@ export function some<N>(parser: Parser<N>, end?: string | RegExp | number, delim
       context.delimiters.push(delims);
     }
     // whileは数倍遅い
-    for (; context.position < source.length;) {
+    for (const len = source.length; context.position < len;) {
       if (match(input)) break;
       if (context.delimiters?.match(input)) break;
       const result = parser(input);

package/src/combinator/data/parser/union.ts

@@ -10,8 +10,12 @@ export function union<N, D extends Parser<N>[]>(parsers: D): Parser<N, Ctx, D> {
       return parsers[0];
     default:
       return eval([
+        '((',
+        parsers.map((_, i) => `parser${i},`).join(''),
+        ') =>',
         'input =>',
-        parsers.map((_, i) => `|| parsers[${i}](input)`).join('').slice(2),
-      ].join(''));
+        parsers.map((_, i) => `|| parser${i}(input)`).join('').slice(2),
+        ')',
+      ].join(''))(...parsers);
   }
 }

package/src/parser/api/bind.test.ts

@@ -48,7 +48,6 @@ describe('Unit: parser/api/bind', () => {
         [
           '<h1 class="error">Error: Too large segment over 100,000 bytes.</h1>',
           `<pre class="error" translate="no">${'\n'.repeat(997)}...</pre>`,
-          '<h1 class="error">Error: Too large segment over 100,000 bytes.</h1>',
         ]);
     });
 

package/src/parser/api/normalize.test.ts

@@ -2,10 +2,6 @@ import { normalize, escape } from './normalize';
 
 describe('Unit: parser/normalize', () => {
   describe('normalize', () => {
-    it('invalid surrogate pairs', () => {
-      assert(normalize('\uDC00\uD800') === '\uFFFD\uFFFD');
-    });
-
     it('controls', () => {
       assert(normalize('\r') === '\n');
       assert(normalize('\r\n') === '\n');
@@ -50,10 +46,11 @@ describe('Unit: parser/normalize', () => {
       assert(normalize('\u202A') === '\uFFFD');
       assert(normalize('\u202F') === '\uFFFD');
       assert(normalize('\uFEFF') === '\uFFFD');
-      assert(normalize('\u180E') === '\uFFFD');
-      assert(normalize('\u1820\u180E') === '\u1820\u180E');
-      assert(normalize('\u1821\u180E') === '\u1821\u180E');
-      assert(normalize('\u1822\u180E') === '\u1822\uFFFD');
+      //assert(normalize('\u180E') === '\uFFFD');
+      //assert(normalize('\u1820\u180E') === '\u1820\u180E');
+      //assert(normalize('\u1821\u180E') === '\u1821\u180E');
+      //assert(normalize('\u1822\u180E') === '\u1822\uFFFD');
+      //assert(normalize('\uDC00\uD800') === '\uFFFD\uFFFD');
     });
 
     it('header', () => {

package/src/parser/api/normalize.ts

@@ -9,17 +9,18 @@ export function normalize(source: string): string {
 }
 
 function format(source: string): string {
-  return source
-    .replace(/\r\n?/g, '\n');
+  return source.replace(/\r\n?/g, '\n');
 }
 
+const invalid = new RegExp([
+  /(?![\t\r\n])[\x00-\x1F\x7F]/g.source,
+  /(?!\u200D)[\u2006\u200B-\u200F\u202A-\u202F\u2060\uFEFF]/g.source,
+  // 後読みが重い
+  ///(?<![\u1820\u1821])\u180E/g.source,
+  ///[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g.source,
+].join('|'), 'g');
 function sanitize(source: string): string {
-  return source
-    .replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]|(?!\u200D)[\u2006\u200B-\u200F\u202A-\u202F\u2060\uFEFF]|(?<![\u1820\u1821])\u180E/g, UNICODE_REPLACEMENT_CHARACTER)
-    .replace(/[\uD800-\uDBFF][\uDC00-\uDFFF]?|[\uDC00-\uDFFF]/g, char =>
-      char.length === 1
-        ? UNICODE_REPLACEMENT_CHARACTER
-        : char);
+  return source.replace(invalid, UNICODE_REPLACEMENT_CHARACTER);
 }
 
 // https://dev.w3.org/html5/html-author/charref
@@ -110,7 +111,6 @@ assert(unreadableSpecialCharacters.every(c => sanitize(c) === UNICODE_REPLACEMEN
 
 // 特殊不可視文字はエディタおよびソースビューアでは等幅および強調表示により可視化する
 export function escape(source: string): string {
-  return source
-    .replace(unreadableEscapeCharacter, char =>
-      `&${unreadableEscapeHTMLEntityNames[unreadableEscapeCharacters.indexOf(char)]};`);
+  return source.replace(unreadableEscapeCharacter, char =>
+    `&${unreadableEscapeHTMLEntityNames[unreadableEscapeCharacters.indexOf(char)]};`);
 }

package/src/parser/api/parse.test.ts

@@ -361,9 +361,9 @@ describe('Unit: parser/api/parse', () => {
 
     it('backtrack', function () {
       this.timeout(5000);
-      // 最悪計算量での実行速度はCommonMarkの公式JS実装の32nより速い。
+      // 最悪計算量での実行速度はCommonMarkの公式JS実装の32nに対して3倍遅い程度。
       // 5n = annotation/reference + link + url/math + ruby + text
-      const source = `((([[[[#$[${'.'.repeat(19997)}`;
+      const source = `((([[[[#$[${'.'.repeat(19998)}`;
       assert.deepStrictEqual(
         [...parse(source, {}, { resources: { clock: 100000, recursions: [100] } }).children]
           .map(el => el.tagName),
@@ -372,7 +372,7 @@ describe('Unit: parser/api/parse', () => {
 
     it('backtrack error', function () {
       this.timeout(5000);
-      const source = `((([[[[#$[${'.'.repeat(19997 + 1)}`;
+      const source = `((([[[[#$[${'.'.repeat(19998 + 1)}`;
       assert.deepStrictEqual(
         [...parse(source, {}, { resources: { clock: 100000, recursions: [100] } }).children]
           .map(el => el.tagName),

package/src/parser/autolink.ts

@@ -1,13 +1,12 @@
 import { MarkdownParser } from '../../markdown';
 import { union, some, lazy } from '../combinator';
 import { autolink as autolink_ } from './inline/autolink';
-import { linebreak, unescsource } from './source';
+import { unescsource } from './source';
 
 export import AutolinkParser = MarkdownParser.AutolinkParser;
 
 export const autolink: AutolinkParser = lazy(() =>
   some(union([
     autolink_,
-    linebreak,
     unescsource,
   ])));

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

@@ -30,7 +30,10 @@ export const fig: FigParser = block(rewrite(segment, verify(convert(
     // Bug: TypeScript
     const fence = (/^[^\n]*\n!?>+ /.test(source) && source.match(/^~{3,}(?=[^\S\n]*$)/mg) as string[] || [])
       .reduce((max, fence) => fence > max ? fence : max, '~~') + '~';
-    return parser({ context })
+    const { position } = context;
+    const result = parser({ context });
+    context.position = position;
+    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/heading.ts

@@ -1,7 +1,7 @@
 import { HeadingParser } from '../block';
 import { State } from '../context';
 import { List, Data } from '../../combinator/data/parser';
-import { union, some, state, block, line, focus, rewrite, open, fmap } from '../../combinator';
+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 { visualize, trimBlank } from '../visibility';
@@ -10,7 +10,17 @@ import { html, defrag } from 'typed-dom/dom';
 
 export const segment: HeadingParser.SegmentParser = block(focus(
   /#+ +\S[^\n]*(?:\n#+(?=$|[ \n])[^\n]*)*(?:$|\n)/y,
-  some(line(({ context: { source } }) => new List([new Data(source)])))));
+  input => {
+    const { context } = input;
+    const { source } = context;
+    const acc = new List<Data<string>>();
+    for (; context.position < source.length;) {
+      const line = firstline(source, context.position);
+      acc.push(new Data(line));
+      context.position += line.length;
+    }
+    return acc;
+  }));
 
 export const heading: HeadingParser = block(rewrite(segment,
   // その他の表示制御は各所のCSSで行う。

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

@@ -3,7 +3,7 @@ import { List, Data } from '../../../combinator/data/parser';
 import { union, some, block, validate, rewrite, convert, lazy, fmap } from '../../../combinator';
 import { math } from '../../inline/math';
 import { autolink } from '../../inline/autolink';
-import { linebreak, unescsource, anyline } from '../../source';
+import { unescsource, anyline } from '../../source';
 import { unwrap } from '../../util';
 import { html, defrag } from 'typed-dom/dom';
 
@@ -19,7 +19,6 @@ export const quote: ReplyParser.QuoteParser = lazy(() => block(fmap(
         // quote補助関数が残した数式をパースする。
         math,
         autolink,
-        linebreak,
         unescsource,
       ])),
       false)),

package/src/parser/block/ulist.ts

@@ -10,7 +10,7 @@ import { unwrap } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 export const ulist: UListParser = lazy(() => block(validate(
-  /- /y,
+  '- ',
   ulist_)));
 
 export const ulist_: UListParser = lazy(() => block(fmap(validate(

package/src/parser/block.ts

@@ -62,10 +62,6 @@ export const block: BlockParser = reset(
       if (position === source.length) return;
       const fst = source[position];
       switch (fst) {
-        case '\n':
-          assert(source.trim() === '');
-          input.context.position = source.length;
-          return new List();
         case '=':
           if (source.startsWith('===', position)) return pagebreak(input);
           break;