securemark 0.299.4 → 0.300.0

package/src/parser/block.ts

@@ -1,7 +1,7 @@
 import { MarkdownParser } from '../../markdown';
-import { Segment, Command } from './context';
-import { List, Node } from '../combinator/data/parser';
-import { union, firstline, recover } from '../combinator';
+import { Segment } from './context';
+import { List, Node } from '../combinator/parser';
+import { union, lazy, always } from '../combinator';
 import { header } from './header';
 import { emptysegment } from './source';
 import { pagebreak } from './block/pagebreak';
@@ -42,90 +42,102 @@ export import MediaBlockParser = BlockParser.MediaBlockParser;
 export import ReplyParser = BlockParser.ReplyParser;
 export import ParagraphParser = BlockParser.ParagraphParser;
 
-export const block: BlockParser = error(union([
+const p1 = lazy(() => union([
+  ulist,
+  ilist,
+]));
+const p2 = lazy(() => union([
+  blockquote,
+  reply,
+]));
+const p3 = lazy(() => union([
+  table,
+  sidefence,
+]));
+export const block: BlockParser = lazy(() => error(union([
   emptysegment,
-  input => {
+  (input, output) => {
     const { source, position, segment } = input;
     if (position === source.length) return;
-    switch (segment ^ Segment.write) {
+    switch (segment & ~Segment.write) {
       case Segment.heading:
-        return heading(input);
+        return heading(input, output);
       case Segment.fig:
-        return fig(input);
+        return fig(input, output);
       case Segment.figure:
-        return figure(input);
+        return figure(input, output);
     }
     const char = source[position];
     switch (char) {
-      case Command.Error:
-        throw new Error(firstline(source, position + 1).trimEnd());
       case '=':
-        if (source.startsWith('===', position)) return pagebreak(input);
+        if (source.startsWith('===', position)) return pagebreak(input, output);
         break;
       case '`':
-        if (source.startsWith('```', position)) return codeblock(input);
+        if (source.startsWith('```', position)) return codeblock(input, output);
         break;
       case '~':
-        if (source.startsWith('~~~', position)) return extension(input);
-        if (source[position + 1] === ' ') return dlist(input);
+        if (source.startsWith('~~~', position)) return extension(input, output);
+        if (source[position + 1] === ' ') return dlist(input, output);
         break;
       case '-':
-        if (source.startsWith('---', position)) return header(input);
-        if (source[position + 1] === ' ') return ulist(input) || ilist(input);
+        if (source.startsWith('---', position)) return header(input, output);
+        if (source[position + 1] === ' ') return p1(input, output);
         break;
       case '+':
       case '*':
-        if (source[position + 1] === ' ') return ilist(input);
+        if (source[position + 1] === ' ') return ilist(input, output);
         break;
       case '[':
         switch (source[position + 1]) {
           case '$':
-            return figbase(input);
+            return figbase(input, output);
           case '!':
-            return mediablock(input);
+            return mediablock(input, output);
         }
         break;
       case '!':
-        if (source[position + 1] === '>') return blockquote(input);
-        return mediablock(input);
+        if (source[position + 1] === '>') return blockquote(input, output);
+        return mediablock(input, output);
       case '>':
-        if (source[position + 1] === '>') return blockquote(input) || reply(input);
-        return blockquote(input);
+        if (source[position + 1] === '>') return p2(input, output);
+        return blockquote(input, output);
       case '$':
-        if (source[position + 1] === '$') return mathblock(input);
-        return figbase(input);
+        if (source[position + 1] === '$') return mathblock(input, output);
+        return figbase(input, output);
       case '|':
-        return table(input) || sidefence(input);
+        return p3(input, output);
       case '(':
-        return olist(input);
+        return olist(input, output);
       default:
-        if (char <= '9' && '0' <= char) return olist(input);
+        if (char <= '9' && '0' <= char) return olist(input, output);
     }
   },
   paragraph
-]));
+])));
 
 function error(parser: BlockParser): BlockParser {
-  const reg = new RegExp(String.raw`^${Command.Error}[^\r\n]*\r?\n`)
-  return recover<BlockParser>(
+  return always([
     parser,
-    ({ source, position, id }, reason) => new List([
-      new Node(html('h1',
-        {
-          id: id !== '' ? `error:${rnd0Z(8)}` : undefined,
-          class: 'error',
-        },
-        reason instanceof Error
-          ? `${reason.name}: ${reason.message}`
-          : `UnknownError: ${reason}`)),
-      new Node(html('pre',
-        {
-          class: 'error',
-          translate: 'no',
-        },
-        source.slice(position)
-          .replace(reg, '')
-          .slice(0, 1001)
-          .replace(/^(.{997}).{4}$/s, '$1...') || undefined)),
-    ]));
+    ({ source, position, id }, output) => {
+      const { error } = output;
+      if (!error) return output.context;
+      output.error = undefined;
+      return output.import(new List([
+        new Node(html('h1',
+          {
+            id: id !== '' ? `error:${rnd0Z(8)}` : undefined,
+            class: 'error',
+          },
+          `${error.name}: ${error.message}`)),
+        new Node(html('pre',
+          {
+            class: 'error',
+            translate: 'no',
+          },
+          source.slice(position)
+            .slice(0, 1001)
+            .replace(/^(.{997}).{4}$/s, '$1...') || undefined)),
+      ]));
+    },
+  ]);
 }

package/src/parser/context.ts

@@ -1,67 +1,72 @@
-import { List, Node, Context as Ctx } from '../../src/combinator/data/parser';
+import { Input as Ipt, input as ipt } from '../combinator/parser';
 import { Dict } from 'spica/dict';
 
-export const MAX_SEGMENT_SIZE = 100_000; // 100,000 bytes (Max value size of FDB)
-export const MAX_INPUT_SIZE = MAX_SEGMENT_SIZE * 10;
+export function input(source: string, input: Input = new Input()): Input {
+  return ipt(source, input);
+}
 
-export class Context extends Ctx {
+export class Input<M extends object = object> extends Ipt<M> {
   constructor(
-    options: Partial<Context> = {},
+    options: Partial<Input> = {},
   ) {
     super(options);
     const {
       segment,
+      header,
       local,
       sequential,
-      buffer,
-      header,
       host,
       url,
       id,
+      notes,
       caches,
+      test,
     } = options;
-    this.resources = options.resources ?? {
-      // バックトラックのせいで文字数制限を受けないようにする。
-      clock: MAX_SEGMENT_SIZE * (5 + 1),
+    this.resources ??= {
+      clock: -1,
+      interval: 200,
       recursions: [
-        5 || Recursion.block,
-        20 || Recursion.blockquote,
-        40 || Recursion.listitem,
-        20 || Recursion.inline,
-        20 || Recursion.bracket,
-        20 || Recursion.terminal,
+        10 || Recursion.scope,
+        100 || Recursion.block,
+        100 || Recursion.inline,
+        100 || Recursion.terminal,
       ],
     };
     this.segment = segment ?? Segment.unknown;
+    this.header = header ?? true;
     this.local = local ?? false;
     this.sequential = sequential ?? false;
-    this.buffer = buffer ?? new List();
-    this.header = header ?? true;
     this.host = host;
     this.url = url;
     this.id = id;
+    this.notes = notes;
     this.caches = caches;
+    this.test = test ?? false;
   }
   public override readonly resources: {
     clock: number;
     recursions: number[];
+    interval?: number;
   };
   public override segment: Segment;
+  public header: boolean;
   public local: boolean;
   public sequential: boolean;
-  public buffer: List<Node<(string | HTMLElement)>>;
   public recursion = new RecursionCounter(2);
-  public readonly header: boolean;
   public readonly host?: URL;
   public readonly url?: URL;
-  public readonly id?: string;
+  public id?: string;
+  public notes?: {
+    readonly references: HTMLOListElement;
+  };
   public readonly caches?: {
     readonly code?: Dict<string, HTMLElement>;
     readonly math?: Dict<string, HTMLElement>;
     readonly media?: Dict<string, HTMLElement>;
   };
+  public test: boolean;
 }
-export type Options = Partial<Context>;
+export type Options = Partial<Input>;
 
 class RecursionCounter {
   constructor(
@@ -70,11 +75,11 @@ class RecursionCounter {
   }
   private readonly stack: number[] = [];
   private index = 0;
-  public add(depth: number): void {
+  public add(depth: number): Error | undefined {
     const { stack } = this
-    for (; this.index > 0 && stack[this.index - 1] <= depth; --this.index);
+    for (; this.index > 0 && stack[this.index - 1] >= depth; --this.index);
     // 内側から数えるので無効化処理できずエラーを投げるしかない。
-    if (this.index === this.limit) throw new Error(`Too much recursion`);
+    if (this.index === this.limit) return new Error(`Too much recursion`);
     stack[this.index] = depth;
     ++this.index;
   }
@@ -82,12 +87,12 @@ class RecursionCounter {
 
 export const enum Segment {
   unknown = 0,
+  read = 0,
   write = 1,
-  nonempty = 0,
   empty = 1 << 1,
-  heading = 3 << 1,
-  fig = 4 << 1,
-  figure = 5 << 1,
+  heading = 2 << 1,
+  fig = 3 << 1,
+  figure = 4 << 1,
 }
 
 export const enum State {
@@ -110,11 +115,9 @@ export const enum State {
 }
 
 export const enum Recursion {
+  scope,
   block,
-  blockquote,
-  listitem,
   inline,
-  bracket,
   terminal,
 }
 

package/src/parser/document.ts

@@ -0,0 +1,48 @@
+import { MarkdownParser } from '../../markdown';
+import { Input, Recursion } from './context';
+import { Parser, Node } from '../combinator/parser';
+import { always, force, recursion } from '../combinator';
+import { build } from './parser';
+import { parser as segment } from './segment';
+import { block } from './block';
+import { unwrap, randomID } from './util';
+import { figure } from '../processor/figure';
+import { note } from '../processor/note';
+import { frag, html } from 'typed-dom/dom';
+
+export const document: MarkdownParser = (() => {
+  interface Memory {
+    readonly interpolation?: boolean;
+    readonly references: HTMLOListElement;
+  }
+  const loop = build(segment, block);
+  return always<Parser<DocumentFragment | HTMLElement, Input<Memory>>>([
+    (input, output) => {
+      input.id =
+        input.id === '' ? '' :
+        input.local ? randomID() :
+        input.id;
+      input.memory = input.notes ?? {
+        interpolation: true,
+        references: html('ol', { class: 'references' }),
+      };
+      output.push();
+      return output.context;
+    },
+    recursion(Recursion.scope, force(() => loop)),
+    (input, output) => {
+      assert(input.position === input.source.length);
+      const doc = frag(unwrap(output.pop()));
+      output.append(new Node(doc));
+      assert(input.id !== '' || !doc.querySelector('[id], .index[href], .label[href], .annotation > a[href], .reference > a[href]'));
+      if (input.test && !input.local) return output.context;
+      const { memory } = input;
+      const orphan = !memory.references.parentNode;
+      orphan && doc.appendChild(memory.references);
+      for (const _ of figure(doc, memory, input));
+      for (const _ of note(doc, memory, input));
+      orphan && !memory.interpolation && memory.references.remove();
+      return output.context;
+    },
+  ]);
+})();

package/src/parser/header.test.ts

@@ -1,6 +1,5 @@
 import { header } from './header';
-import { input } from '../combinator/data/parser';
-import { Context } from './context';
+import { input } from './context';
 import { inspect } from '../debug.test';
 
 describe('Unit: parser/header', () => {
@@ -8,27 +7,27 @@ describe('Unit: parser/header', () => {
     const parser = header;
 
     it('invalid', () => {
-      assert.deepStrictEqual(inspect(parser, input('', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('---', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('---\n', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('---\n---', new Context())), [['<pre class="invalid" translate="no">---\n---</pre>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('---\na: b\n', new Context())), [['<pre class="invalid" translate="no">---\na: b\n</pre>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('---\na: b\n---c', new Context())), [['<pre class="invalid" translate="no">---\na: b\n---c</pre>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('---\na: b\n---\nc', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('---\n\n---', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('---\n \n---', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('---\n-\n---', new Context())), [['<pre class="invalid" translate="no">---\n-\n---</pre>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('---\na: b\n----', new Context())), [['<pre class="invalid" translate="no">---\na: b\n----</pre>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('----\na: b\n---', new Context())), [['<pre class="invalid" translate="no">----\na: b\n---</pre>'], '']);
-      assert.deepStrictEqual(inspect(parser, input(`---\n${'a: b\n'.repeat(101)}---`, new Context())), [[`<pre class="invalid" translate="no">---\n${'a: b\n'.repeat(101)}---</pre>`], '']);
+      assert.deepStrictEqual(inspect(parser, input('')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('---')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('---\n')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('---\n---')), [['<pre class="invalid" translate="no">---\n---</pre>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('---\na: b\n')), [['<pre class="invalid" translate="no">---\na: b\n</pre>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('---\na: b\n---c')), [['<pre class="invalid" translate="no">---\na: b\n---c</pre>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('---\na: b\n---\nc')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('---\n\n---')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('---\n \n---')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('---\n-\n---')), [['<pre class="invalid" translate="no">---\n-\n---</pre>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('---\na: b\n----')), [['<pre class="invalid" translate="no">---\na: b\n----</pre>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('----\na: b\n---')), [['<pre class="invalid" translate="no">----\na: b\n---</pre>'], '']);
+      assert.deepStrictEqual(inspect(parser, input(`---\n${'a: b\n'.repeat(101)}---`)), [[`<pre class="invalid" translate="no">---\n${'a: b\n'.repeat(101)}---</pre>`], '']);
     });
 
     it('basic', () => {
-      assert.deepStrictEqual(inspect(parser, input('---\na: b\n---', new Context())), [['<aside class="header"><details open=""><summary>Header</summary><div class="field" data-name="a" data-value="b"><span class="field-name">a</span>: <span class="field-value">b</span></div></details></aside>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('---\na: b\n---\n', new Context())), [['<aside class="header"><details open=""><summary>Header</summary><div class="field" data-name="a" data-value="b"><span class="field-name">a</span>: <span class="field-value">b</span></div></details></aside>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('---\na: b\nC: D e\n---\n', new Context())), [['<aside class="header"><details open=""><summary>Header</summary><div class="field" data-name="a" data-value="b"><span class="field-name">a</span>: <span class="field-value">b</span></div><div class="field" data-name="c" data-value="D e"><span class="field-name">C</span>: <span class="field-value">D e</span></div></details></aside>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('---\r\na: b\r\nC: D e\r\n---\r\n', new Context())), [['<aside class="header"><details open=""><summary>Header</summary><div class="field" data-name="a" data-value="b"><span class="field-name">a</span>: <span class="field-value">b</span></div><div class="field" data-name="c" data-value="D e"><span class="field-name">C</span>: <span class="field-value">D e</span></div></details></aside>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('----\na: b\n----', new Context())), [['<aside class="header"><details open=""><summary>Header</summary><div class="field" data-name="a" data-value="b"><span class="field-name">a</span>: <span class="field-value">b</span></div></details></aside>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('---\na: b\n---')), [['<aside class="header"><details open=""><summary>Header</summary><div class="field" data-name="a" data-value="b"><span class="field-name">a</span>: <span class="field-value">b</span></div></details></aside>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('---\na: b\n---\n')), [['<aside class="header"><details open=""><summary>Header</summary><div class="field" data-name="a" data-value="b"><span class="field-name">a</span>: <span class="field-value">b</span></div></details></aside>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('---\na: b\nC: D e\n---\n')), [['<aside class="header"><details open=""><summary>Header</summary><div class="field" data-name="a" data-value="b"><span class="field-name">a</span>: <span class="field-value">b</span></div><div class="field" data-name="c" data-value="D e"><span class="field-name">C</span>: <span class="field-value">D e</span></div></details></aside>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('---\r\na: b\r\nC: D e\r\n---\r\n')), [['<aside class="header"><details open=""><summary>Header</summary><div class="field" data-name="a" data-value="b"><span class="field-name">a</span>: <span class="field-value">b</span></div><div class="field" data-name="c" data-value="D e"><span class="field-name">C</span>: <span class="field-value">D e</span></div></details></aside>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('----\na: b\n----')), [['<aside class="header"><details open=""><summary>Header</summary><div class="field" data-name="a" data-value="b"><span class="field-name">a</span>: <span class="field-value">b</span></div></details></aside>'], '']);
     });
 
   });

package/src/parser/header.ts

@@ -1,8 +1,9 @@
 import { MarkdownParser } from '../../markdown';
-import { List, Node } from '../combinator/data/parser';
-import { union, inits, some, block, line, validate, focus, clear, convert, lazy, fmap } from '../combinator';
+import { List, Node } from '../combinator/parser';
+import { union, inits, some, scope, block, line, validate, focus, clear, lazy, fmap } from '../combinator';
 import { str } from './source';
 import { unwrap, invalid } from './util';
+import { ReadonlyURL } from 'spica/url';
 import { html, defrag } from 'typed-dom/dom';
 
 export const header: MarkdownParser.HeaderParser = lazy(() => validate(
@@ -10,42 +11,47 @@ export const header: MarkdownParser.HeaderParser = lazy(() => validate(
   inits([
     block(
       union([
-        validate(context => context.header,
-        focus(/(---+)[^\S\r\n]*\r?\n(?:[a-z][0-9a-z]*(?:-[0-9a-z]+)*:[ \t]+\S[^\r\n]*\r?\n){1,32}\1[^\S\r\n]*(?:$|\r?\n)/yi,
-        convert(source =>
-          source.slice(source.indexOf('\n') + 1, source.trimEnd().lastIndexOf('\n')),
-          fmap(
-            some(union([field])),
-            ns => new List([
-              new Node(html('aside', { class: 'header' }, [
-                html('details',
-                  { open: '' },
-                  defrag(unwrap(ns.unshift(new Node(html('summary', 'Header'))) && ns))),
-              ])),
-            ]))))),
-        context => {
-          const { source, position } = context;
-          context.position += source.length;
-          return new List([
+        validate(
+          input => input.header,
+          focus(/(---+)[^\S\r\n]*\r?\n(?:[a-z][0-9a-z]*(?:-[0-9a-z]+)*:[ \t]+\S[^\r\n]*\r?\n){1,32}\1[^\S\r\n]*(?:$|\r?\n)/yi,
+            scope(
+              ({ source }) => source.slice(source.indexOf('\n') + 1, source.trimEnd().lastIndexOf('\n')),
+              fmap(
+                some(union([field])),
+                ns => new List([
+                  new Node(html('aside', { class: 'header' }, [
+                    html('details',
+                      { open: '' },
+                      defrag(unwrap(ns.unshift(new Node(html('summary', 'Header')))))),
+                  ])),
+                ])),
+              false))),
+        (input, output) => {
+          const { source, position } = input;
+          input.position += source.length;
+          return output.append(
             new Node(html('pre', {
               class: 'invalid',
               translate: 'no',
               ...invalid('header', 'syntax', 'Invalid syntax'),
-            }, source.slice(position))),
-          ]);
+            }, source.slice(position))));
         },
       ])),
     clear(str(/[^\S\r\n]*\r?\n/y)),
   ])));
 
-const field: MarkdownParser.HeaderParser.FieldParser = line(({ source, position }) => {
+const field: MarkdownParser.HeaderParser.FieldParser = line((input, output) => {
+  const { source, position } = input;
   const name = source.slice(position, source.indexOf(':', position));
   const value = source.slice(position + name.length + 1).trim();
-  return new List([
+  if (name.toLowerCase() === 'url') {
+    // @ts-expect-error
+    input.url = new ReadonlyURL(value as ':');
+  }
+  return output.append(
     new Node(html('div', { class: 'field', 'data-name': name.toLowerCase(), 'data-value': value }, [
       html('span', { class: 'field-name' }, name),
       ': ',
       html('span', { class: 'field-value' }, value),
-    ])),
-  ]);
+    ])));
 });