securemark 0.298.7 → 0.299.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "securemark",
-  "version": "0.298.7",
+  "version": "0.299.0",
   "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,10 +1,10 @@
-import { Parser, List, Segment, failsafe } from '../../data/parser';
+import { Parser, List, Segment } from '../../data/parser';
 import { isEmptyline } from './line';
 
 export function block<P extends Parser>(parser: P, separation?: boolean, segment?: number): P;
 export function block<N>(parser: Parser<N>, separation = true, segment = 0): Parser<N> {
   assert(parser);
-  return failsafe(input => {
+  return input => {
     const context = input;
     const { source, position } = context;
     if (position === source.length) return;
@@ -14,12 +14,15 @@ export function block<N>(parser: Parser<N>, separation = true, segment = 0): Par
       return new List();
     }
     const result = parser(input);
-    if (result === undefined) return;
-    if (separation && !isEmptyline(source, context.position)) return;
+    if (result === undefined ||
+        separation && !isEmptyline(source, context.position)) {
+      context.position = position;
+      return;
+    }
     assert(context.position === source.length || source[context.position - 1] === '\n');
     if (segment !== 0 && context.segment & Segment.write ^ Segment.write) {
       context.segment = segment;
     }
     return result;
-  });
+  };
 }

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

@@ -1,23 +1,29 @@
-import { Parser, input, failsafe } from '../../data/parser';
+import { Parser, input } from '../../data/parser';
 
 export function line<P extends Parser>(parser: P): P;
 export function line<N>(parser: Parser<N>): Parser<N> {
   assert(parser);
-  return failsafe(context => {
+  return context => {
     const { source, position } = context;
     if (position === source.length) return;
     const line = firstline(source, position);
     context.offset += position;
     const result = parser(input(line, context));
-    context.position += position;
-    context.position += result && context.position === position ? line.length : 0;
     context.source = source;
+    context.position = result
+      ? context.position === 0
+        ? position + line.length
+        : position + context.position
+      : position;
     context.offset -= position;
-    if (result === undefined) return;
-    if (context.position < position + line.length && !isEmptyline(source, context.position)) return;
+    if (result === undefined ||
+        context.position < position + line.length && !isEmptyline(source, context.position)) {
+      context.position = position;
+      return;
+    }
     context.position = position + line.length;
     return result;
-  });
+  };
 }
 
 export function firstline(source: string, position: number): string {

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

@@ -1,25 +1,22 @@
-import { Parser, List, Context, subinput, failsafe } from '../../data/parser';
+import { Parser, List, Context, subinput } from '../../data/parser';
 
-export function convert<P extends Parser>(conv: (source: string, context: Parser.Context<P>) => string, parser: P, empty?: boolean): P;
-export function convert<N>(conv: (source: string, context: Context) => string, parser: Parser<N>, empty = false): Parser<N> {
+export function convert<P extends Parser>(conv: (source: string, context: Parser.Context<P>) => string, parser: P): P;
+export function convert<N>(conv: (source: string, context: Context) => string, parser: Parser<N>): Parser<N> {
   assert(parser);
-  return failsafe(input => {
+  return input => {
     const context = input;
-    const { source, position } = context;
+    const { source, position, offset } = 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;
       return new List();
     }
-    const { offset, backtracks } = context;
     const result = parser(subinput(src, context));
-    context.position = context.source.length
-    assert(context.offset === offset);
+    context.position = result ? context.source.length : position;
     assert(context.source === source);
-    assert(context.backtracks === backtracks);
+    assert(context.offset === offset);
     return result;
-  });
+  };
 }

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

@@ -1,4 +1,4 @@
-import { Parser, failsafe } from '../../data/parser';
+import { Parser } from '../../data/parser';
 import { consume } from '../../../combinator';
 
 export function match<P extends Parser>(pattern: RegExp, f: (matched: RegExpMatchArray) => P): P;
@@ -7,7 +7,7 @@ export function match<N>(pattern: RegExp, f: (matched: RegExpMatchArray) => Pars
   const count = typeof pattern === 'object'
     ? /[^^\\*+][*+]|{\d+,}/.test(pattern.source)
     : false;
-  return failsafe(input => {
+  return input => {
     const context = input;
     const { source, position } = context;
     if (position === source.length) return;
@@ -17,7 +17,11 @@ export function match<N>(pattern: RegExp, f: (matched: RegExpMatchArray) => Pars
     assert(source.startsWith(params[0], position));
     count && consume(params[0].length, context);
     const result = f(params)(input);
-    context.position += result && context.position === position ? params[0].length : 0;
+    context.position += result
+      ? context.position === position
+        ? params[0].length
+        : 0
+      : context.position - position;
     return result;
-  });
+  };
 }

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

@@ -6,7 +6,7 @@ export function focus<N>(scope: string | RegExp, parser: Parser<N>, slice = true
   assert(parser);
   const match = matcher(scope, false);
   return failsafe(context => {
-    const { source, position } = context;
+    const { SID, source, position } = context;
     if (position === source.length) return;
     const src = match(context)?.head?.value ?? '';
     assert(source.startsWith(src, position));
@@ -19,9 +19,10 @@ export function focus<N>(scope: string | RegExp, parser: Parser<N>, slice = true
     }
     context.offset += position;
     const result = parser(input(src, context));
+    context.source = source;
+    context.SID = SID;
     context.position += position;
     context.position += result && context.position === position ? src.length : 0;
-    context.source = source;
     context.offset -= position;
     return result;
   });
@@ -33,7 +34,7 @@ export function rewrite<N>(scope: Parser, parser: Parser<N>, slice = true): Pars
   assert(scope);
   assert(parser);
   return failsafe(context => {
-    const { source, position } = context;
+    const { SID, source, position } = context;
     if (position === source.length) return;
     const res1 = scope(context);
     assert(context.position > position || !res1);
@@ -50,9 +51,10 @@ export function rewrite<N>(scope: Parser, parser: Parser<N>, slice = true): Pars
     assert(source.startsWith(src, position));
     context.offset += position;
     const res2 = parser(input(src, context));
+    context.SID = SID;
+    context.source = source;
     context.position += position;
     context.position += res2 && context.position === position ? src.length : 0;
-    context.source = source;
     context.offset -= position;
     return res2;
   });

package/src/combinator/control/monad/bind.ts

@@ -1,4 +1,4 @@
-import { Parser, Result, List, Node, Context, failsafe } from '../../data/parser';
+import { Parser, Result, List, Node, Context } from '../../data/parser';
 
 export function bind<P extends Parser>(parser: Parser.IntermediateParser<P>, f: (nodes: List<Node<Parser.SubNode<P>>>, context: Parser.Context<P>) => Result<Parser.Node<P>, Parser.Context<P>, Parser.SubParsers<P>>): P;
 export function bind<P extends Parser>(parser: P, f: (nodes: List<Node<Parser.Node<P>>>, context: Parser.Context<P>) => Result<Parser.Node<P>, Parser.Context<P>, Parser.SubParsers<P>>): P;
@@ -6,13 +6,21 @@ export function bind<N, P extends Parser>(parser: Parser<N, Parser.Context<P>, P
 export function bind<U, P extends Parser>(parser: P, f: (nodes: List<Node<Parser.Node<P>>>, context: Parser.Context<P>) => Result<U, Parser.Context<P>, Parser.SubParsers<P>>): Parser<U, Parser.Context<P>, Parser.SubParsers<P>>;
 export function bind<N, U>(parser: Parser<N>, f: (nodes: List<Node<N>>, context: Context) => Result<U>): Parser<U> {
   assert(parser);
-  return failsafe(input => {
+  return input => {
     const context = input;
     const { source, position } = context;
     if (position === source.length) return;
-    const result = parser(input);
-    if (result === undefined) return;
+    const res1 = parser(input);
+    if (res1 === undefined) {
+      context.position = position;
+      return;
+    }
     context.range = context.position - position;
-    return f(result, context);
-  });
+    const res2 = f(res1, context);
+    if (res2 === undefined) {
+      context.position = position;
+      return;
+    }
+    return res2;
+  };
 }

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

@@ -1,78 +1,5 @@
-import { Parser, Result, Context, Options } from '../../data/parser';
+import { Parser, Context } from '../../data/parser';
 import { min } from 'spica/alias';
-import { clone } from 'spica/assign';
-
-export function reset<P extends Parser>(base: Options, parser: P): P;
-export function reset<N>(base: Context, parser: Parser<N>): Parser<N> {
-  const clock = base.resources?.clock;
-  const recursions = base.resources?.recursions;
-  return input => {
-    const context = input;
-    // @ts-expect-error
-    context.resources ??= {
-      clock,
-      recursions: recursions?.slice(),
-    };
-    context.backtracks = {};
-    return parser(input);
-  };
-  assert(Object.getPrototypeOf(base) === Object.prototype);
-  assert(Object.freeze(base));
-  const changes = Object.entries(base);
-  const values = Array(changes.length);
-  return context =>
-    apply(parser, context, changes, values, true);
-}
-
-export function context<P extends Parser>(base: Options, parser: P): P;
-export function context<N>(base: Context, parser: Parser<N>): Parser<N> {
-  assert(Object.getPrototypeOf(base) === Object.prototype);
-  assert(Object.freeze(base));
-  const changes = Object.entries(base);
-  const values = Array(changes.length);
-  return context =>
-    apply(parser, context, changes, values);
-}
-
-function apply<P extends Parser>(parser: P, context: Parser.Context<P>, changes: readonly [string, unknown][], values: unknown[], reset?: boolean): Result<Parser.Node<P>>;
-function apply<N>(parser: Parser<N>, context: Context, changes: readonly [string, unknown][], values: unknown[], reset = false): Result<N> {
-  for (let i = 0; i < changes.length; ++i) {
-    const change = changes[i];
-    const prop = change[0];
-    switch (prop) {
-      case 'source':
-      case 'position':
-        continue;
-      case 'resources':
-        assert(reset);
-        assert(!context.offset);
-        assert(!context.precedence);
-        assert(!context.state);
-        values[i] = context[prop];
-        context[prop as string] ??= clone({}, change[1] as object);
-        continue;
-      case 'backtracks':
-        change[1] = {};
-    }
-    values[i] = context[prop];
-    context[prop] = change[1];
-  }
-  const result = parser(context);
-  for (let i = 0; i < changes.length; ++i) {
-    const change = changes[i];
-    const prop = change[0];
-    switch (prop) {
-      case 'source':
-      case 'position':
-        continue;
-      case 'resources':
-        assert(reset);
-    }
-    context[prop] = values[i];
-    values[i] = undefined;
-  }
-  return result;
-}
 
 export function creation<P extends Parser>(cost: number, parser: P): P;
 export function creation(cost: number, parser: Parser): Parser {

package/src/combinator/data/parser.ts

@@ -107,6 +107,10 @@ export class Context {
   //     入力内の最大セグメントサイズの10%前後である。
   //
   public backtracks: Record<number, number>;
+  public clone(): this {
+    // @ts-ignore
+    return new this.constructor(this);
+  }
 }
 export type Options = Partial<Context>;
 export const enum Segment {
@@ -122,14 +126,12 @@ export function input<C extends Context>(source: string, context: C): Input<C> {
 }
 
 export function subinput<C extends Context>(source: string, context: C): Input<C> {
-  return {
-    ...context,
-    SID: sid(),
-    source,
-    position: 0,
-    offset: 0,
-    backtracks: {},
-  };
+  const c = context.clone();
+  c.source = source;
+  c.position = 0;
+  c.offset = 0;
+  c.backtracks = {};
+  return c;
 }
 
 export function failsafe<P extends Parser>(parser: P): P;

package/src/parser/api/normalize.ts

@@ -65,6 +65,8 @@ const parser = (el => (entity: string): string => {
 })(html('span'));
 export const invisibleBlankHTMLEntityNames: readonly string[] = invisibleHTMLEntityNames
   .filter(name => parser(`&${name};`).trimStart() === '');
+export const invisibleBlankCharacters: readonly string[] = invisibleBlankHTMLEntityNames
+  .map(name => parser(`&${name};`));
 export const invisibleGraphHTMLEntityNames: readonly string[] = invisibleHTMLEntityNames
   .filter(name => parser(`&${name};`).trimStart() !== '');
 const unreadableEscapeHTMLEntityNames = invisibleHTMLEntityNames.filter(name => ![

package/src/parser/block/blockquote.ts

@@ -17,18 +17,18 @@ export const blockquote: BlockquoteParser = lazy(() => block(rewrite(segment, un
   open(/!(?=>)/y, markdown),
 ]))));
 
-const opener = /(?=>>+(?:$|[ \n]))/y;
-const indent = open(opener, some(contentline, />(?:$|[ \n])/y));
-const unindent = (source: string) => source.replace(/(?<=^|\n)>(?: |(?=>*(?:$|[ \n])))|\n$/g, '');
+const opener = /(?=>>+(?:$|[ \r\n]))/y;
+const indent = open(opener, some(contentline, />(?:$|[ \r\n])/y));
+const unindent = (source: string) => source.replace(/(?<=^|\n)>(?: |(?=>*(?:$|[ \r\n])))|\r?\n$/g, '');
 
 const source: BlockquoteParser.SourceParser = lazy(() => fmap(
   recursion(Recursion.blockquote, some(union([
     rewrite(
       indent,
-      convert(unindent, source, true)),
+      convert(unindent, source)),
     rewrite(
       some(contentline, opener),
-      convert(unindent, fmap(autolink, ns => new List([new Node(html('pre', defrag(unwrap(ns))))])), true)),
+      convert(unindent, fmap(autolink, ns => new List([new Node(html('pre', defrag(unwrap(ns))))])))),
   ]))),
   ns => new List([new Node(html('blockquote', unwrap(ns)))])));
 
@@ -36,7 +36,7 @@ const markdown: BlockquoteParser.MarkdownParser = lazy(() => fmap(
   recursion(Recursion.blockquote, some(union([
     rewrite(
       indent,
-      convert(unindent, markdown, true)),
+      convert(unindent, markdown)),
     rewrite(
       some(contentline, opener),
       convert(unindent, context => {
@@ -52,6 +52,6 @@ const markdown: BlockquoteParser.MarkdownParser = lazy(() => fmap(
         }, context);
         context.position = source.length;
         return new List([new Node(html('section', [document, html('h2', 'References'), references]))]);
-      }, true)),
+      })),
   ]))),
   ns => new List([new Node(html('blockquote', unwrap(ns)))])));

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

@@ -8,7 +8,7 @@ import { parse } from '../../api/parse';
 import { html } from 'typed-dom/dom';
 
 export const aside: ExtensionParser.AsideParser = block(recursion(Recursion.block, fmap(
-  fence(/(~{3,})aside(?!\S)([^\n]*)(?:$|\n)/y, 300),
+  fence(/(~{3,})aside(?!\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, param] = unwrap(nodes);

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

@@ -8,7 +8,7 @@ import { parse } from '../../api/parse';
 import { html } from 'typed-dom/dom';
 
 export const example: ExtensionParser.ExampleParser = block(recursion(Recursion.block, fmap(
-  fence(/(~{3,})(?:example\/(\S+))?(?!\S)([^\n]*)(?:$|\n)/y, 300),
+  fence(/(~{3,})(?:example\/(\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 = 'markdown', param] = unwrap(nodes);

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

@@ -15,7 +15,7 @@ import FigParser = ExtensionParser.FigParser;
 
 export const segment: FigParser.SegmentParser = block(
   sequence([
-    line(close(seg_label, /(?!\S).*\r?\n/y)),
+    line(close(seg_label, /(?!\S)[^\r\n]*\r?\n/y)),
     union([
       seg_code,
       seg_math,
@@ -29,21 +29,21 @@ export const segment: FigParser.SegmentParser = block(
 export const fig: FigParser = block(rewrite(segment, verify(convert(
   (source, context) => {
     // Bug: TypeScript
-    const fence = (/^[^\n]*\n!?>+ /.test(source) && source.match(/^~{3,}(?=[^\S\n]*$)/gm) as string[] || [])
+    const fence = (/^[^\r\n]*\r?\n!?>+ /.test(source) && source.match(/^~{3,}(?=[^\S\r\n]*$)/gm) as string[] || [])
       .reduce((max, fence) => fence > max ? fence : max, '~~') + '~';
     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.replace(/^([^\r\n]+\r?\n[^\r\n]+\r?\n)(.+?)\r?\n?$/s, '$1\n$2')}\n${fence}`
       : `${fence}figure ${source}\n\n${fence}`;
   },
   union([figure])),
   ([{ value: el }]) => el.tagName === 'FIGURE')));
 
 const parser = sequence([
-  line(close(seg_label, /(?!\S).*\n/y)),
+  line(close(seg_label, /(?!\S)[^\r\n]*\r?\n/y)),
   line(union([
     media,
     lineshortmedia,

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

@@ -5,7 +5,7 @@ import { label } from '../../inline/extension/label';
 import { html } from 'typed-dom/dom';
 
 export const figbase: ExtensionParser.FigbaseParser = block(fmap(
-  validate(/\[?\$-(?:[0-9]+\.)*0\]?[^\S\n]*(?:$|\n)/y,
+  validate(/\[?\$-(?:[0-9]+\.)*0\]?[^\S\r\n]*(?:$|\r?\n)/y,
   line(union([label]))),
   ([{ value: el }]) => {
     const label = el.getAttribute('data-label')!;

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

@@ -50,7 +50,7 @@ export const segment: FigureParser.SegmentParser = block(match(
 export const figure: FigureParser = block(fallback(rewrite(segment, fmap(
   convert(source => source.slice(source.match(/^~+(?:\w+\s+)?/)![0].length, source.trimEnd().lastIndexOf('\n')),
   sequence([
-    line(sequence([label, str(/(?!\S).*\n/y)])),
+    line(sequence([label, str(/(?!\S)[^\r\n]*\r?\n/y)])),
     inits([
       block(union([
         ulist,
@@ -84,7 +84,7 @@ export const figure: FigureParser = block(fallback(rewrite(segment, fmap(
     ]);
   })),
   fmap(
-    fence(/(~{3,})(?:figure(?=$|[ \n])|\[?\$)[^\n]*(?:$|\n)/y, 300),
+    fence(/(~{3,})(?:figure(?=$|[ \r\n])|\[?\$)[^\r\n]*(?:$|\r?\n)/y, 300),
     (nodes, context) => {
       const [body, overflow, closer, opener, delim] = unwrap<string>(nodes);
       const violation =
@@ -100,7 +100,7 @@ export const figure: FigureParser = block(fallback(rewrite(segment, fmap(
           'label',
           'Invalid label',
         ] ||
-        /^~+(?:figure )?(\[?\$\S+)[^\S\n]+\S/.test(opener) && [
+        /^~+(?:figure )?(\[?\$\S+)[^\S\r\n]+\S/.test(opener) && [
           'argument',
           'Invalid argument',
         ] ||

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

@@ -20,7 +20,7 @@ import { html } from 'typed-dom/dom';
 import MessageParser = ExtensionParser.MessageParser;
 
 export const message: MessageParser = block(fmap(
-  fence(/(~{3,})message\/(\S+)(?!\S)([^\n]*)(?:$|\n)/y, 300),
+  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);

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

@@ -77,16 +77,16 @@ const row: RowParser = lazy(() => dup(fmap(
   ]),
   ns => Array.isArray(ns.head?.value) ? ns : ns.unshift(new Node([[]])) && ns)));
 
-const alignment = /[-=<>]+(?:\/[-=^v]*)?(?=[^\S\n]*\n)/y;
+const alignment = /[-=<>]+(?:\/[-=^v]*)?(?=[^\S\r\n]*\r?\n)/y;
 
 const align: AlignParser = line(fmap(
   union([str(alignment)]),
   ([{ value }]) => new List([new Node(value.split('/').map(s => s.split('')) as [string[], string[]?])])));
 
-const delimiter = /[-=<>]+(?:\/[-=^v]*)?(?=[^\S\n]*\n)|[#:](?:(?!:\D|0)\d*:(?!0)\d*)?(?:!+[+]?)?(?=[ \n])/y;
+const delimiter = /[-=<>]+(?:\/[-=^v]*)?(?=[^\S\r\n]*\r?\n)|[#:](?:(?!:\D|0)\d*:(?!0)\d*)?(?:!+[+]?)?(?=[ \r\n])/y;
 
 const head: CellParser.HeadParser = block(fmap(open(
-  str(/#(?:(?!:\D|0)\d*:(?!0)\d*)?(?:!+[+]?)?(?=[ \n])/y),
+  str(/#(?:(?!:\D|0)\d*:(?!0)\d*)?(?:!+[+]?)?(?=[ \r\n])/y),
   rewrite(
     inits([
       anyline,
@@ -100,15 +100,15 @@ const head: CellParser.HeadParser = block(fmap(open(
           media,
           lineshortmedia,
         ]),
-        /[^\S\n]*(?:$|\n)/y)),
-      open(/(?:[^\S\n]*\n|\s)/y, visualize(trimBlank(some(inline))), true),
+        /[^\S\r\n]*(?:$|\r?\n)/y)),
+      open(/(?:[^\S\r\n]*\r?\n|\s)/y, visualize(trimBlank(some(inline))), true),
     ])),
   true),
   ns => new List([new Node(html('th', attributes(ns.shift()!.value as string), defrag(unwrap(ns))))])),
   false);
 
 const data: CellParser.DataParser = block(fmap(open(
-  str(/:(?:(?!:\D|0)\d*:(?!0)\d*)?(?:!+[+]?)?(?=[ \n])/y),
+  str(/:(?:(?!:\D|0)\d*:(?!0)\d*)?(?:!+[+]?)?(?=[ \r\n])/y),
   rewrite(
     inits([
       anyline,
@@ -122,8 +122,8 @@ const data: CellParser.DataParser = block(fmap(open(
           media,
           lineshortmedia,
         ]),
-        /[^\S\n]*(?:$|\n)/y)),
-      open(/(?:[^\S\n]*\n|\s)/y, visualize(trimBlankEnd(some(inline))), true),
+        /[^\S\r\n]*(?:$|\r?\n)/y)),
+      open(/(?:[^\S\r\n]*\r?\n|\s)/y, visualize(trimBlankEnd(some(inline))), true),
     ])),
   true),
   ns => new List([new Node(html('td', attributes(ns.shift()!.value as string), defrag(unwrap(ns))))])),

package/src/parser/block/heading.ts

@@ -9,7 +9,7 @@ import { unwrap, invalid } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 export const segment: HeadingParser.SegmentParser = block(focus(
-  /#+ +\S[^\r\n]*(?:\r?\n#+(?=$| |\r?\n)[^\r\n]*)*(?:$|\r?\n)/y,
+  /#+ +\S[^\r\n]*(?:\r?\n#+(?=$|[ \r\n])[^\r\n]*)*(?:$|\r?\n)/y,
   input => {
     const context = input;
     const { source, range } = context;

package/src/parser/block/ilist.ts

@@ -16,11 +16,11 @@ export const ilist: IListParser = lazy(() => block(validate(
   ilist_)));
 
 export const ilist_: IListParser = lazy(() => block(fmap(validate(
-  /[-+*](?:$|[ \n])/y,
+  /[-+*](?:$|[ \r\n])/y,
   recursion(Recursion.listitem, some(union([
     fmap(fallback(
       inits([
-        line(open(/[-+*](?:$|[ \n])/y, visualize(trimBlank(some(inline))), true)),
+        line(open(/[-+*](?:$|[ \r\n])/y, visualize(trimBlank(some(inline))), true)),
         indent(union([ulist_, olist_, ilist_])),
       ]),
       ilistitem),
@@ -40,5 +40,5 @@ export const ilistitem = rewrite(
     new Node(html('span', {
       class: 'invalid',
       ...invalid('list', 'syntax', 'Fix the indent or the head of the list item'),
-    }, source.replace('\n', '')))
+    }, source.replace(/\r?\n/, '')))
   ]));

package/src/parser/block/mediablock.ts

@@ -20,6 +20,6 @@ export const mediablock: MediaBlockParser = block(fmap(
       new Node(html('span', {
       class: 'invalid',
       ...invalid('mediablock', 'syntax', 'Not media syntax'),
-    }, source.replace('\n', '')))
+    }, source.replace(/\r?\n/, '')))
     ]))))]),
   ns => new List([new Node(html('div', unwrap(ns)))])));

package/src/parser/block/olist.ts

@@ -11,8 +11,8 @@ import { memoize } from 'spica/memoize';
 import { html, define, defrag } from 'typed-dom/dom';
 
 const openers = {
-  '.': /([0-9]+|[a-z]+|[A-Z]+)(?:-(?=$|[0-9\n])[0-9]*)*(?:\.?(?:$|[\n])|\. )/y,
-  '(': /\((?=$|[0-9a-z\n])([0-9]*|[a-z]*)(?=$|[)\n])\)?(?:-(?=$|[0-9\n])[0-9]*)*(?:$|[ \n])/y,
+  '.': /([0-9]+|[a-z]+|[A-Z]+)(?:-(?=$|[0-9\r\n])[0-9]*)*(?:\.?(?:$|[\r\n])|\. )/y,
+  '(': /\((?=$|[0-9a-z\r\n])([0-9]*|[a-z]*)(?=$|[)\r\n])\)?(?:-(?=$|[0-9\r\n])[0-9]*)*(?:$|[ \r\n])/y,
 } as const;
 
 export const olist: OListParser = lazy(() => block(validate(

package/src/parser/block/pagebreak.ts

@@ -4,5 +4,5 @@ import { block, line, focus } from '../../combinator';
 import { html } from 'typed-dom/dom';
 
 export const pagebreak: PagebreakParser = block(line(focus(
-  /={3,}[^\S\n]*(?:$|\n)/y,
+  /={3,}[^\S\r\n]*(?:$|\r?\n)/y,
   () => new List([new Node(html('hr'))]))));

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

@@ -7,7 +7,7 @@ import { str } from '../../source';
 import { invalid } from '../../util';
 import { html, define, defrag } from 'typed-dom/dom';
 
-export const syntax = />*(?=>>[^>\s]\S*[^\S\n]*(?:$|\n))/y;
+export const syntax = />*(?=>>[^>\s]\S*[^\S\r\n]*(?:$|\r?\n))/y;
 
 export const cite: ReplyParser.CiteParser = line(fmap(
   open(

package/src/parser/block/sidefence.ts

@@ -8,7 +8,7 @@ import { unwrap, invalid } from '../util';
 import { html, define, defrag } from 'typed-dom/dom';
 
 export const sidefence: SidefenceParser = lazy(() => block(fmap(focus(
-  /\|+ [^\n]*(?:\n\|+(?=$|[ \n])[^\n]*)*(?:$|\n)/y,
+  /\|+ [^\r\n]*(?:\r?\n\|+(?=$|[ \r\n])[^\r\n]*)*(?:$|\r?\n)/y,
   union([source])),
   ([{ value }]) => new List([
     new Node(define(value, {
@@ -17,17 +17,17 @@ export const sidefence: SidefenceParser = lazy(() => block(fmap(focus(
     })),
   ]))));
 
-const opener = /(?=\|\|+(?:$|[ \n]))/y;
-const indent = open(opener, some(contentline, /\|(?:$|[ \n])/y));
-const unindent = (source: string) => source.replace(/(?<=^|\n)\|(?: |(?=\|*(?:$|[ \n])))|\n$/g, '');
+const opener = /(?=\|\|+(?:$|[ \r\n]))/y;
+const indent = open(opener, some(contentline, /\|(?:$|[ \r\n])/y));
+const unindent = (source: string) => source.replace(/(?<=^|\n)\|(?: |(?=\|*(?:$|[ \r\n])))|\r?\n$/g, '');
 
 const source: SidefenceParser.SourceParser = lazy(() => fmap(
   recursion(Recursion.block, some(union([
     rewrite(
       indent,
-      convert(unindent, source, true)),
+      convert(unindent, source)),
     rewrite(
       some(contentline, opener),
-      convert(unindent, fmap(autolink, ns => new List([new Node(html('pre', defrag(unwrap(ns))))])), true)),
+      convert(unindent, fmap(autolink, ns => new List([new Node(html('pre', defrag(unwrap(ns))))])))),
   ]))),
   ns => new List([new Node(html('blockquote', unwrap(ns)))])));