securemark 0.295.1 → 0.295.2

package/src/combinator/data/parser.ts

@@ -1,34 +1,68 @@
 import { List } from './data';
-import { Delimiters } from './parser/context/delimiter';
+import { Delimiters } from './delimiter';
 
-export type Parser<N = unknown, C extends Ctx = Ctx, D extends Parser<unknown, C>[] = any>
+export type Parser<N = unknown, C extends Context = Context, D extends Parser<unknown, C>[] = any>
   = (input: Input<C>) => Result<N, C, D>;
-export interface Input<C extends Ctx = Ctx> {
+export namespace Parser {
+  export type Node<P extends Parser> = P extends Parser<infer N> ? N : never;
+  export type SubParsers<P extends Parser> = P extends Parser<unknown, any, infer D> ? D : never;
+  export type Context<P extends Parser> = P extends Parser<unknown, infer C> ? C : never;
+  export type SubNode<P extends Parser> = ExtractSubNode<SubParsers<P>>;
+  export type IntermediateParser<P extends Parser> = Parser<SubNode<P>, Context<P>, SubParsers<P>>;
+  type ExtractSubNode<D extends Parser[]> = ExtractSubParser<D> extends infer N ? N extends Parser<infer U> ? U : never : never;
+  type ExtractSubParser<D extends Parser[]> = D extends (infer P)[] ? P extends Parser ? P : never : never;
+}
+export interface Input<C extends Context = Context> {
   readonly context: C;
 }
-export type Result<N, C extends Ctx = Ctx, D extends Parser<unknown, C>[] = any>
-  = List<Data<N>, C, D>
+export type Result<N, C extends Context = Context, D extends Parser<unknown, C>[] = any>
+  = List<Node<N>, C, D>
   | undefined;
 export { List };
-export class Data<N> implements List.Node {
+export class Node<N> implements List.Node {
   constructor(public value: N) {
   }
   public next?: this = undefined;
   public prev?: this = undefined;
 }
-export interface Ctx extends CtxOptions {
-  source: string;
-  position: number;
-}
-export interface CtxOptions {
-  readonly resources?: {
+export class Context {
+  constructor(
+    {
+      source,
+      position,
+      resources,
+      delimiters,
+      precedence,
+      state,
+      linebreak,
+      range,
+      offset,
+      backtracks,
+    }: Options = {},
+  ) {
+    this.source = source ?? '';
+    this.position = position ?? 0;
+    this.resources = resources;
+    this.precedence = precedence ?? 0;
+    this.delimiters = delimiters ?? new Delimiters();
+    this.state = state ?? 0;
+    this.linebreak = linebreak ?? 0;
+    this.range = range ?? 0;
+    this.offset = offset ?? 0;
+    this.backtracks = backtracks ?? {};
+  }
+  public source: string;
+  public position: number;
+  public readonly resources?: {
     clock: number;
     recursions: number[];
   };
-  offset?: number;
-  precedence?: number;
-  delimiters?: Delimiters;
-  state?: number;
+  public precedence: number;
+  public delimiters: Delimiters;
+  public state: number;
+  public linebreak: number;
+  public range: number;
+  public offset: number;
   // Objectの内部実装を利用する。
   // 探索木を直接使用する場合は探索速度が重要で挿入は相対的に少なく削除は不要かつ不確実であるため
   // AVL木が適当と思われる。
@@ -61,36 +95,25 @@ export interface CtxOptions {
   //     1段落数百文字あたり平均2、3か所以下が妥当な頻度でありこの場合の最大追加データサイズは
   //     入力内の最大セグメントサイズの10%前後である。
   //
-  backtracks?: Record<number, number>;
-  linebreak?: number;
-  range?: number;
+  public backtracks: Record<number, number>;
 }
-export type Node<P extends Parser> = P extends Parser<infer N> ? N : never;
-export type SubParsers<P extends Parser> = P extends Parser<unknown, Ctx, infer D> ? D : never;
-export type Context<P extends Parser> = P extends Parser<unknown, infer C> ? C : never;
-export type SubNode<P extends Parser> = ExtractSubNode<SubParsers<P>>;
-export type IntermediateParser<P extends Parser> = Parser<SubNode<P>, Context<P>, SubParsers<P>>;
-type ExtractSubNode<D extends Parser[]> = ExtractSubParser<D> extends infer N ? N extends Parser<infer U> ? U : never : never;
-type ExtractSubParser<D extends Parser[]> = D extends (infer P)[] ? P extends Parser ? P : never : never;
+export type Options = Partial<Context>;
 
-export function input<C extends CtxOptions>(source: string, context: C): Input<C & Ctx> {
-  // @ts-expect-error
+export function input<C extends Context>(source: string, context: C): Input<C> {
   context.source = source;
-  // @ts-expect-error
   context.position = 0;
   return {
-    // @ts-expect-error
     context,
   };
 }
 
-export function subinput<C extends Ctx>(source: string, context: C): Input<C> {
+export function subinput<C extends Context>(source: string, context: C): Input<C> {
   return {
     context: {
       ...context,
       source,
       position: 0,
-      offset: undefined,
+      offset: 0,
       backtracks: {},
     }
   };

package/src/debug.test.ts

@@ -1,8 +1,10 @@
-import { Result, Ctx } from './combinator/data/parser';
+import { Parser, Input } from './combinator/data/parser';
 import { html, define } from 'typed-dom/dom';
 import { querySelectorWith, querySelectorAllWith } from 'typed-dom/query';
 
-export function inspect(result: Result<DocumentFragment | HTMLElement | string>, ctx: Ctx, until: number | string = Infinity): [string[], string] | undefined {
+export function inspect(parser: Parser<DocumentFragment | HTMLElement | string>, input: Input, until: number | string = Infinity): [string[], string] | undefined {
+  const { context } = input;
+  const result = parser(input);
   return result && [
     result.foldl<string[]>((acc, { value: node }) => {
       assert(node);
@@ -34,7 +36,7 @@ export function inspect(result: Result<DocumentFragment | HTMLElement | string>,
       }
       return acc.push(normalize(node.outerHTML.slice(0, until))), acc;
     }, []),
-    ctx.source.slice(ctx.position),
+    context.source.slice(context.position),
   ];
 }
 

package/src/parser/api/bind.ts

@@ -1,8 +1,7 @@
 import { ParserSettings, Progress } from '../../..';
-import { MarkdownParser } from '../../../markdown';
+import { Context } from '../context';
 import { input } from '../../combinator/data/parser';
 import { segment } from '../segment';
-import { header } from '../header';
 import { block } from '../block';
 import { normalize } from './normalize';
 import { headers } from './header';
@@ -19,13 +18,12 @@ export function bind(target: DocumentFragment | HTMLElement | ShadowRoot, settin
   nearest: (position: number) => HTMLElement | undefined;
   index: (block: HTMLElement) => number;
 } {
-  const context: MarkdownParser.Options = {
+  const context = new Context({
     ...settings,
     host: settings.host ?? new ReadonlyURL(location.pathname, location.origin),
-  };
+  });
   assert(!context.offset);
   assert(!context.precedence);
-  assert(!context.delimiters);
   assert(!context.state);
   if (context.id?.match(/[^0-9a-z/-]/i)) throw new Error('Invalid ID: ID must be alphanumeric');
   if (context.host?.origin === 'null') throw new Error(`Invalid host: ${context.host.href}`);
@@ -72,11 +70,15 @@ export function bind(target: DocumentFragment | HTMLElement | ShadowRoot, settin
     assert(head + last <= targetSegments.length);
     const base = next(head);
     let index = head;
+    // @ts-expect-error
+    context.header = true;
     for (; index < sourceSegments.length - last; ++index) {
       assert(rev === revision);
       const seg = sourceSegments[index];
-      const es = (header(input(seg, { header: index === 0 } as MarkdownParser.Options)) || block(input(seg, context)))
+      const es = block(input(seg, context))
         ?.foldl<HTMLElement[]>((acc, { value }) => void acc.push(value) || acc, []) ?? [];
+      // @ts-expect-error
+      context.header = false;
       blocks.splice(index, 0, [seg, es, url]);
       if (es.length === 0) continue;
       // All deletion processes always run after all addition processes have done.

package/src/parser/api/header.ts

@@ -1,4 +1,4 @@
-import { input } from '../../combinator/data/parser';
+import { Context } from '../context';
 import { header as h } from '../header';
 
 export function header(source: string): string {
@@ -12,10 +12,10 @@ export function headers(source: string): string[] {
 }
 
 function parse(source: string): [HTMLElement, number] | [] {
-  const i = input(source, {});
-  const result = h(i);
+  const context = new Context({ source });
+  const result = h({ context });
   const el = result?.head?.value;
   return el?.tagName === 'ASIDE'
-    ? [el, i.context.position]
+    ? [el, context.position]
     : [];
 }

package/src/parser/api/normalize.ts

@@ -1,4 +1,5 @@
 import { input } from '../../combinator/data/parser';
+import { Context } from '../context';
 import { unsafehtmlentity } from '../inline/htmlentity';
 
 const UNICODE_REPLACEMENT_CHARACTER = '\uFFFD';
@@ -68,7 +69,7 @@ const unreadableEscapeHTMLEntityNames = invisibleHTMLEntityNames.filter(name =>
   'zwnj',
 ].includes(name));
 const unreadableEscapeCharacters = unreadableEscapeHTMLEntityNames
-  .map(name => unsafehtmlentity(input(`&${name};`, {}))!.head!.value);
+  .map(name => unsafehtmlentity(input(`&${name};`, new Context()))!.head!.value);
 assert(unreadableEscapeCharacters.length === unreadableEscapeHTMLEntityNames.length);
 assert(unreadableEscapeCharacters.every(c => c.length === 1));
 const unreadableEscapeCharacter = new RegExp(`[${unreadableEscapeCharacters.join('')}]`, 'g');

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

@@ -1,4 +1,5 @@
 import { parse } from './parse';
+import { Context } from '../context';
 import { html } from 'typed-dom/dom';
 
 describe('Unit: parser/api/parse', () => {
@@ -361,20 +362,20 @@ describe('Unit: parser/api/parse', () => {
 
     it('backtrack', function () {
       this.timeout(5000);
-      // 最悪計算量での実行速度はCommonMarkの公式JS実装の32nに対して3倍遅い程度。
-      // 5n = annotation/reference + link + url/math + ruby + text
-      const source = `((([[[[#$[${'.'.repeat(19998)}`;
+      // 最悪計算量での実行速度はCommonMarkの公式JS実装の32nに対して50-400%程度。
+      // 6n = annotation + reference + link + url/math + ruby + text
+      const source = `((([[[[#$[${'.'.repeat(16665)}`;
       assert.deepStrictEqual(
-        [...parse(source, {}, { resources: { clock: 100000, recursions: [100] } }).children]
+        [...parse(source, {}, new Context({ resources: { clock: 100000, recursions: [100] } })).children]
           .map(el => el.tagName),
         ['P']);
     });
 
     it('backtrack error', function () {
       this.timeout(5000);
-      const source = `((([[[[#$[${'.'.repeat(19998 + 1)}`;
+      const source = `((([[[[#$[${'.'.repeat(16665 + 1)}`;
       assert.deepStrictEqual(
-        [...parse(source, {}, { resources: { clock: 100000, recursions: [100] } }).children]
+        [...parse(source, {}, new Context({ resources: { clock: 100000, recursions: [100] } })).children]
           .map(el => el.tagName),
         ['H1', 'PRE']);
     });

package/src/parser/api/parse.ts

@@ -1,8 +1,7 @@
 import { ParserOptions } from '../../..';
-import { MarkdownParser } from '../../../markdown';
 import { input } from '../../combinator/data/parser';
+import { Context } from '../context';
 import { segment } from '../segment';
-import { header } from '../header';
 import { block } from '../block';
 import { normalize } from './normalize';
 import { headers } from './header';
@@ -15,28 +14,30 @@ interface Options extends ParserOptions {
   readonly test?: boolean;
 }
 
-export function parse(source: string, options: Options = {}, context?: MarkdownParser.Options): DocumentFragment {
+export function parse(source: string, options: Options = {}, context?: Context): DocumentFragment {
   const url = headers(source).find(field => field.toLowerCase().startsWith('url:'))?.slice(4).trim() ?? '';
   source = !context ? normalize(source) : source;
-  context = {
+  context = new Context({
     host: options.host ?? context?.host ?? new ReadonlyURL(location.pathname, location.origin),
     url: url ? new ReadonlyURL(url as ':') : context?.url,
     id: options.id ?? context?.id,
     caches: context?.caches,
     resources: context?.resources,
-  };
+  });
   assert(!context.offset);
   assert(!context.precedence);
-  assert(!context.delimiters);
   assert(!context.state);
   if (context.id?.match(/[^0-9a-z/-]/i)) throw new Error('Invalid ID: ID must be alphanumeric');
   if (context.host?.origin === 'null') throw new Error(`Invalid host: ${context.host.href}`);
   const node = frag();
-  let index = 0;
+  // @ts-expect-error
+  context.header = true;
   for (const seg of segment(source)) {
     node.append(
-      ...(header(input(seg, { header: index++ === 0 } as MarkdownParser.Context)) || block(input(seg, context)))
+      ...block(input(seg, context))
         ?.foldl<HTMLElement[]>((acc, { value }) => void acc.push(value) || acc, []) ?? []);
+    // @ts-expect-error
+    context.header = false;
   }
   assert(options.id !== '' || !node.querySelector('[id], .index[href], .label[href], .annotation > a[href], .reference > a[href]'));
   if (options.test) return node;

package/src/parser/autolink.test.ts

@@ -1,29 +1,29 @@
 import { autolink } from './autolink';
 import { input } from '../combinator/data/parser';
+import { Context } from './context';
 import { inspect } from '../debug.test';
 
 describe('Unit: parser/autolink', () => {
   describe('autolink', () => {
-    const parser = (source: string) => autolink(input(source, ctx));
-    const { context: ctx } = input('', {});
+    const parser = autolink;
 
     it('basic', () => {
-      assert.deepStrictEqual(inspect(parser('http://host)'), ctx), [['<a class="url" href="http://host)" target="_blank">http://host)</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('http://host\\'), ctx), [['<a class="url" href="http://host\\" target="_blank">http://host\\</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('!http://host)'), ctx), [['!', '<a class="url" href="http://host)" target="_blank">http://host)</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('!http://host\\'), ctx), [['!', '<a class="url" href="http://host\\" target="_blank">http://host\\</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('#a'), ctx), [['<a class="hashtag" href="/hashtags/a">#a</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('@a#b'), ctx), [['<a class="channel" href="/@a?ch=b">@a#b</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('\\\n'), ctx), [['\\', '<br>'], '']);
-      assert.deepStrictEqual(inspect(parser('a#b'), ctx), [['a', '#b'], '']);
-      assert.deepStrictEqual(inspect(parser('0a#b'), ctx), [['0a', '#b'], '']);
-      assert.deepStrictEqual(inspect(parser('あ#b'), ctx), [['あ', '#b'], '']);
-      assert.deepStrictEqual(inspect(parser('あい#b'), ctx), [['あい', '#b'], '']);
-      assert.deepStrictEqual(inspect(parser('0aあ#b'), ctx), [['0a', 'あ', '#b'], '']);
-      assert.deepStrictEqual(inspect(parser('0aあい#b'), ctx), [['0a', 'あい', '#b'], '']);
-      assert.deepStrictEqual(inspect(parser('a\n#b'), ctx), [['a', '<br>', '<a class="hashtag" href="/hashtags/b">#b</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('a\\\n#b'), ctx), [['a', '\\', '<br>', '<a class="hashtag" href="/hashtags/b">#b</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('0a>>b'), ctx), [['0a', '>', '>b'], '']);
+      assert.deepStrictEqual(inspect(parser, input('http://host)', new Context())), [['<a class="url" href="http://host)" target="_blank">http://host)</a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('http://host\\', new Context())), [['<a class="url" href="http://host\\" target="_blank">http://host\\</a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('!http://host)', new Context())), [['!', '<a class="url" href="http://host)" target="_blank">http://host)</a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('!http://host\\', new Context())), [['!', '<a class="url" href="http://host\\" target="_blank">http://host\\</a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('#a', new Context())), [['<a class="hashtag" href="/hashtags/a">#a</a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('@a#b', new Context())), [['<a class="channel" href="/@a?ch=b">@a#b</a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\\\n', new Context())), [['\\', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('a#b', new Context())), [['a', '#b'], '']);
+      assert.deepStrictEqual(inspect(parser, input('0a#b', new Context())), [['0a', '#b'], '']);
+      assert.deepStrictEqual(inspect(parser, input('あ#b', new Context())), [['あ', '#b'], '']);
+      assert.deepStrictEqual(inspect(parser, input('あい#b', new Context())), [['あい', '#b'], '']);
+      assert.deepStrictEqual(inspect(parser, input('0aあ#b', new Context())), [['0a', 'あ', '#b'], '']);
+      assert.deepStrictEqual(inspect(parser, input('0aあい#b', new Context())), [['0a', 'あい', '#b'], '']);
+      assert.deepStrictEqual(inspect(parser, input('a\n#b', new Context())), [['a', '<br>', '<a class="hashtag" href="/hashtags/b">#b</a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('a\\\n#b', new Context())), [['a', '\\', '<br>', '<a class="hashtag" href="/hashtags/b">#b</a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('0a>>b', new Context())), [['0a', '>', '>b'], '']);
     });
 
   });