securemark 0.294.1 → 0.294.2

package/src/combinator/data/data.ts

@@ -1,6 +1,6 @@
-import { CtxOptions, Parser } from './parser';
+import { Parser, Ctx } from './parser';
 
-export class List<N extends List.Node = List.Node, C extends CtxOptions = CtxOptions, D extends Parser<unknown, C>[] = any> {
+export class List<N extends List.Node = List.Node, C extends Ctx = Ctx, D extends Parser<unknown, C>[] = any> {
   constructor(nodes?: ArrayLike<N>) {
     if (nodes === undefined) return;
     for (let i = 0; i < nodes.length; ++i) {
@@ -9,47 +9,55 @@ export class List<N extends List.Node = List.Node, C extends CtxOptions = CtxOpt
   }
   public length = 0;
   public head?: N = undefined;
+  public last?: N = undefined;
   public get tail(): N | undefined {
     return this.head?.next;
   }
-  public get last(): N | undefined {
-    return this.head?.prev;
-  }
   public insert(node: N, before?: N): N {
-    assert(!node.next);
+    assert(!node.next && !node.prev);
+    if (before === undefined) return this.push(node);
+    if (before === this.head) return this.unshift(node);
     if (++this.length === 1) {
-      return this.head = node.next = node.prev = node;
+      return this.head = this.last = node;
     }
     assert(node !== before);
-    const next = node.next = before ?? this.head!;
+    const next = node.next = before;
     const prev = node.prev = next.prev!;
     return next.prev = prev.next = node;
   }
   public delete(node: N): N {
-    assert(node.next);
+    assert(node.next || node.prev || this.head === this.last);
     assert(this.length > 0);
     if (--this.length === 0) {
-      this.head = undefined;
+      this.head = this.last = undefined;
     }
     else {
       const { next, prev } = node;
-      if (node === this.head) {
-        this.head = next;
-      }
-      // Error if not used.
-      prev!.next = next;
-      next!.prev = prev;
+      prev === undefined
+        ? this.head = next
+        : prev.next = next;
+      next === undefined
+        ? this.last = prev
+        : next.prev = prev;
     }
     node.next = node.prev = undefined;
     return node;
   }
   public unshift(node: N): N {
-    assert(!node.next);
-    return this.head = this.insert(node, this.head);
+    assert(!node.next && !node.prev);
+    if (++this.length === 1) {
+      return this.head = this.last = node;
+    }
+    node.next = this.head;
+    return this.head = this.head!.prev = node;
   }
   public push(node: N): N {
-    assert(!node.next);
-    return this.insert(node, this.head);
+    assert(!node.next && !node.prev);
+    if (++this.length === 1) {
+      return this.head = this.last = node;
+    }
+    node.prev = this.last;
+    return this.last = this.last!.next = node;
   }
   public shift(): N | undefined {
     if (this.length === 0) return;
@@ -57,22 +65,25 @@ export class List<N extends List.Node = List.Node, C extends CtxOptions = CtxOpt
   }
   public pop(): N | undefined {
     if (this.length === 0) return;
-    return this.delete(this.head!.prev!);
+    return this.delete(this.last!);
   }
   public import(list: List<N>, before?: N): this {
     assert(list !== this);
     if (list.length === 0) return this;
     if (this.length === 0) {
       this.head = list.head;
-      this.length += list.length;
+      this.last = list.last;
+      this.length = list.length;
       list.clear();
       return this;
     }
     const head = list.head!;
     const last = list.last!;
-    const next = last.next = before ?? this.head!;
-    const prev = head.prev = next.prev!;
-    next.prev = last;
+    const next = last.next = before;
+    const prev = head.prev = before?.prev ?? this.last!;
+    next === undefined
+      ? this.last = last
+      : next.prev = last;
     prev.next = head;
     this.length += list.length;
     list.clear();
@@ -80,14 +91,13 @@ export class List<N extends List.Node = List.Node, C extends CtxOptions = CtxOpt
   }
   public clear(): void {
     this.length = 0;
-    this.head = undefined;
+    this.head = this.last = undefined;
   }
   public *[Symbol.iterator](): Iterator<N, undefined, undefined> {
     for (let node = this.head; node && this.head;) {
       const next = node.next;
       yield node;
       node = next;
-      if (node === this.head) break;
     }
   }
   public flatMap<T extends List.Node>(f: (node: N) => List<T>): List<T> {
@@ -96,7 +106,6 @@ export class List<N extends List.Node = List.Node, C extends CtxOptions = CtxOpt
       const next = node.next;
       acc.import(f(node));
       node = next;
-      if (node === this.head) break;
     }
     return acc;
   }
@@ -105,15 +114,13 @@ export class List<N extends List.Node = List.Node, C extends CtxOptions = CtxOpt
       const next = node.next;
       acc = f(acc, node);
       node = next;
-      if (node === this.head) break;
     }
     return acc;
   }
   public foldr<T>(f: (node: N, acc: T) => T, acc: T): T {
-    for (let node = this.head?.prev; node && this.head;) {
+    for (let node = this.last; node && this.head;) {
       const prev = node.prev;
       acc = f(node, acc);
-      if (node === this.head) break;
       node = prev;
     }
     return acc;
@@ -123,7 +130,6 @@ export class List<N extends List.Node = List.Node, C extends CtxOptions = CtxOpt
       const next = node.next;
       if (f(node)) return node;
       node = next;
-      if (node === this.head) break;
     }
   }
 }

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

@@ -1,7 +1,7 @@
-import { Parser, List, Data, CtxOptions, Node, Context, SubParsers, SubNode, Ctx } from '../parser';
+import { Parser, List, Data, Ctx, Node, Context, SubParsers, SubNode } from '../parser';
 
-export function inits<P extends Parser<unknown, Ctx>>(parsers: SubParsers<P>, resume?: (nodes: List<Data<SubNode<P>>>) => boolean): SubNode<P> extends Node<P> ? P : Parser<SubNode<P>, Context<P>, SubParsers<P>>;
-export function inits<N, D extends Parser<N>[]>(parsers: D, resume?: (nodes: List<Data<N>>) => boolean): Parser<N, CtxOptions, D> {
+export function inits<P extends Parser<unknown>>(parsers: SubParsers<P>, resume?: (nodes: List<Data<SubNode<P>>>) => boolean): SubNode<P> extends Node<P> ? P : Parser<SubNode<P>, Context<P>, SubParsers<P>>;
+export function inits<N, D extends Parser<N>[]>(parsers: D, resume?: (nodes: List<Data<N>>) => boolean): Parser<N, Ctx, D> {
   assert(parsers.every(f => f));
   if (parsers.length === 1) return parsers[0];
   return input => {

package/src/combinator/data/parser/sequence.test.ts

@@ -1,4 +1,4 @@
-import { Parser, List, Data, input } from '../parser';
+import { Parser, List, Data, Ctx, input } from '../parser';
 import { sequence } from './sequence';
 import { inspect } from '../../../debug.test';
 
@@ -14,7 +14,7 @@ describe('Unit: combinator/data/parser/sequence', () => {
         ? void ++context.position || new List([new Data('B')])
         : undefined;
     };
-    const ab = sequence<Parser<string, {}, [typeof a, typeof b]>>([a, b]);
+    const ab = sequence<Parser<string, Ctx, [typeof a, typeof b]>>([a, b]);
     const { context: ctx } = input('', {});
 
     it('basic', () => {

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

@@ -1,7 +1,7 @@
-import { Parser, List, Data, CtxOptions, Node, Context, SubParsers, SubNode } from '../parser';
+import { Parser, List, Data, Ctx, Node, Context, SubParsers, SubNode } from '../parser';
 
 export function sequence<P extends Parser<unknown>>(parsers: SubParsers<P>, resume?: (nodes: List<Data<SubNode<P>>>) => boolean): SubNode<P> extends Node<P> ? P : Parser<SubNode<P>, Context<P>, SubParsers<P>>;
-export function sequence<N, D extends Parser<N>[]>(parsers: D, resume?: (nodes: List<Data<N>>) => boolean): Parser<N, CtxOptions, D> {
+export function sequence<N, D extends Parser<N>[]>(parsers: D, resume?: (nodes: List<Data<N>>) => boolean): Parser<N, Ctx, D> {
   assert(parsers.every(f => f));
   if (parsers.length === 1) return parsers[0];
   return input => {

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

@@ -1,4 +1,4 @@
-import { Parser, List, Data, input } from '../parser';
+import { Parser, List, Data, Ctx, input } from '../parser';
 import { union } from './union';
 import { some } from './some';
 import { inspect } from '../../../debug.test';
@@ -15,7 +15,7 @@ describe('Unit: combinator/data/parser/some', () => {
         ? void ++context.position || new List([new Data('B')])
         : undefined;
     };
-    const ab = union<Parser<string, {}, [typeof a, typeof b]>>([a, b]);
+    const ab = union<Parser<string, Ctx, [typeof a, typeof b]>>([a, b]);
     const { context: ctx } = input('', {});
 
     it('basic', () => {

package/src/combinator/data/parser/subsequence.test.ts

@@ -1,4 +1,4 @@
-import { Parser, List, Data, input } from '../parser';
+import { Parser, List, Data, Ctx, input } from '../parser';
 import { subsequence } from './subsequence';
 import { inspect } from '../../../debug.test';
 
@@ -19,7 +19,7 @@ describe('Unit: combinator/data/parser/subsequence', () => {
         ? void ++context.position || new List([new Data('C')])
         : undefined;
     };
-    const abc = subsequence<Parser<string, {}, [typeof a, typeof b, typeof c]>>([a, b, c]);
+    const abc = subsequence<Parser<string, Ctx, [typeof a, typeof b, typeof c]>>([a, b, c]);
     const { context: ctx } = input('', {});
 
     it('basic', () => {

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

@@ -1,9 +1,9 @@
-import { Parser, List, Data, CtxOptions, Node, Context, SubParsers, SubNode } from '../parser';
+import { Parser, List, Data, Ctx, Node, Context, SubParsers, SubNode } from '../parser';
 import { union } from './union';
 import { inits } from './inits';
 
 export function subsequence<P extends Parser<unknown>>(parsers: SubParsers<P>, resume?: (nodes: List<Data<SubNode<P>>>) => boolean): SubNode<P> extends Node<P> ? P : Parser<SubNode<P>, Context<P>, SubParsers<P>>;
-export function subsequence<N, D extends Parser<N>[]>(parsers: D, resume?: (nodes: List<Data<N>>) => boolean): Parser<N, CtxOptions, D> {
+export function subsequence<N, D extends Parser<N>[]>(parsers: D, resume?: (nodes: List<Data<N>>) => boolean): Parser<N, Ctx, D> {
   assert(parsers.every(f => f));
   return union(
     parsers.map((_, i) =>

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

@@ -1,8 +1,8 @@
-import { Parser, List, Data, CtxOptions, Node, Context, SubParsers, SubNode } from '../parser';
+import { Parser, List, Data, Ctx, Node, Context, SubParsers, SubNode } from '../parser';
 import { union } from './union';
 import { sequence } from './sequence';
 
 export function tails<P extends Parser<unknown>>(parsers: SubParsers<P>, resume?: (nodes: List<Data<SubNode<P>>>) => boolean): SubNode<P> extends Node<P> ? P : Parser<SubNode<P>, Context<P>, SubParsers<P>>;
-export function tails<N, D extends Parser<N>[]>(parsers: D, resume?: (nodes: List<Data<N>>) => boolean): Parser<N, CtxOptions, D> {
+export function tails<N, D extends Parser<N>[]>(parsers: D, resume?: (nodes: List<Data<N>>) => boolean): Parser<N, Ctx, D> {
   return union(parsers.map((_, i) => sequence(parsers.slice(i), resume)) as D);
 }

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

@@ -1,4 +1,4 @@
-import { Parser, List, Data, input } from '../parser';
+import { Parser, List, Data, Ctx, input } from '../parser';
 import { union } from './union';
 import { inspect } from '../../../debug.test';
 
@@ -14,7 +14,7 @@ describe('Unit: combinator/data/parser/union', () => {
         ? void ++context.position || new List([new Data('B')])
         : undefined;
     };
-    const ab = union<Parser<string, {}, [typeof a, typeof b]>>([a, b]);
+    const ab = union<Parser<string, Ctx, [typeof a, typeof b]>>([a, b]);
     const { context: ctx } = input('', {});
 
     it('basic', () => {

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

@@ -1,7 +1,7 @@
-import { Parser, CtxOptions, Node, Context, SubParsers, SubNode } from '../parser';
+import { Parser, Ctx, Node, Context, SubParsers, SubNode } from '../parser';
 
 export function union<P extends Parser<unknown>>(parsers: SubParsers<P>): SubNode<P> extends Node<P> ? P : Parser<SubNode<P>, Context<P>, SubParsers<P>>;
-export function union<N, D extends Parser<N>[]>(parsers: D): Parser<N, CtxOptions, D> {
+export function union<N, D extends Parser<N>[]>(parsers: D): Parser<N, Ctx, D> {
   assert(parsers.every(f => f));
   switch (parsers.length) {
     case 0:

package/src/combinator/data/parser.ts

@@ -1,12 +1,12 @@
 import { List } from './data';
 import { Delimiters } from './parser/context/delimiter';
 
-export type Parser<N, C extends CtxOptions = CtxOptions, D extends Parser<unknown, C>[] = any>
-  = (input: Input<C & Ctx>) => Result<N, C, D>;
-export interface Input<C extends CtxOptions = CtxOptions> {
-  readonly context: C & Ctx;
+export type Parser<N, C extends Ctx = Ctx, D extends Parser<unknown, C>[] = any>
+  = (input: Input<C>) => Result<N, C, D>;
+export interface Input<C extends Ctx = Ctx> {
+  readonly context: C;
 }
-export type Result<N, C extends CtxOptions = CtxOptions, D extends Parser<unknown, C>[] = any>
+export type Result<N, C extends Ctx = Ctx, D extends Parser<unknown, C>[] = any>
   = List<Data<N>, C, D>
   | undefined;
 export { List };
@@ -32,19 +32,44 @@ export interface CtxOptions {
   // Objectの内部実装を利用する。
   // 探索木を直接使用する場合は探索速度が重要で挿入は相対的に少なく削除は不要かつ不確実であるため
   // AVL木が適当と思われる。
+  // 最大セグメントサイズ10KB内で探索コストが平均実行性能を圧迫するほど大きくなるとは考えにくいが
+  // 探索コストを減らすにはバックトラック位置数が規定数を超えた場合一定区間ごとに探索木を分割する方法が考えられる。
+  // 10KBの入力すべてを保持する探索木を1024文字ごとに分割するために必要なテーブルサイズは64bit*98=784byteとなる。
+  // 探索木のポインタによるオーバーヘッドを考慮すれば一定サイズ以上ではテーブルのほうが効率的となる。
+  // 区間別テーブルは固定サイズであるためプールして再使用できる。
+  // 従って分割時のデータ構造は区間ごとに探索木を動的に生成しデータ数に応じてテーブルに移行するのが最も効率的である。
+  // これにより最悪時間計算量線形化に要する最悪空間計算量が+1nに局限される。
+  // 木とテーブルいずれにおいてもバックトラックデータとオーバーヘッドを合わせた追加データサイズの最大値は
+  // セグメントサイズに制約されるため入力サイズに対する最大追加データサイズの平均比率はかなり小さくなる。
+  //
+  // 1. データ数が規定数を超えたら区間テーブルを生成しデータを振り分ける。
+  //   - 子ノードのポインタだけ保持するとしても1ノード複数データ保持で圧縮できるかは微妙。
+  //     - 1ノードに2データ保持すれば2連続データを1/2の確率で捕捉し1バックトラックあたりの平均追加データサイズは
+  //       -7byte(((16+1)*2-(16+2))*2+((16+1)*2-(16+2)*2)*2)/4=(32-4)/4=7の10byteに減少する。
+  //       2連続データの発生確率が1/5なら-3.2byteの13.8byte、1/10なら+0.4byteの17.4byteに増加する。
+  //     - 1ノードに4データ保持すれば2連続データを3/4の確率で捕捉し1バックトラックあたりの平均追加データサイズは
+  //       -9byte(((16+1)*2-(16+4))*3+((16+1)*2-(16+4)*2))/4=(42-6)/4=9の8byteに減少する。
+  //       2連続データの発生確率が1/5なら-3.6byteの13.4byte、1/10なら+1.2byteの18.2byteに増加する。
+  // 2. 区間内のデータ構造は探索木から開始しデータ数が規定数を超えたらテーブルに変換する。
+  //   - 1ノード1データ1区間1024文字ならば1024<(64/8*2+1)*61から1区間61データ以上でテーブルのほうが小さくなる。
+  //   - 64/8*2+1=17文字に1か所以下のバックトラックでテーブル以上の効率となる。
+  //   - 通常の入力でバックトラックが17文字に平均1か所以上となることは考えられず
+  //     1段落数百文字あたり平均2、3か所以下が妥当な頻度でありこの場合の最大追加データサイズは
+  //     入力内の最大セグメントサイズの10%前後である。
+  //
   backtracks?: Record<number, number>;
   linebreak?: number;
   range?: number;
 }
 export type Node<P extends Parser<unknown>> = P extends Parser<infer N> ? N : never;
-export type SubParsers<P extends Parser<unknown>> = P extends Parser<unknown, CtxOptions, infer D> ? D : never;
-export type Context<P extends Parser<unknown>> = P extends Parser<unknown, infer C> ? C & Ctx : never;
+export type SubParsers<P extends Parser<unknown>> = P extends Parser<unknown, Ctx, infer D> ? D : never;
+export type Context<P extends Parser<unknown>> = P extends Parser<unknown, infer C> ? C : never;
 export type SubNode<P extends Parser<unknown>> = ExtractSubNode<SubParsers<P>>;
 export type IntermediateParser<P extends Parser<unknown>> = Parser<SubNode<P>, Context<P>, SubParsers<P>>;
 type ExtractSubNode<D extends Parser<unknown>[]> = ExtractSubParser<D> extends infer N ? N extends Parser<infer U> ? U : never : never;
 type ExtractSubParser<D extends Parser<unknown>[]> = D extends (infer P)[] ? P extends Parser<unknown> ? P : never : never;
 
-export function input(source: string, context: CtxOptions): Input<Ctx> {
+export function input<C extends CtxOptions>(source: string, context: C): Input<C & Ctx> {
   // @ts-expect-error
   context.source = source;
   // @ts-expect-error
@@ -67,16 +92,6 @@ export function subinput<C extends Ctx>(source: string, context: C): Input<C> {
   };
 }
 
-export function clean<C extends Ctx>(context: C): C {
-  const { source, position } = context;
-  for (const p of Object.keys(context)) {
-    context[p] = undefined;
-  }
-  context.source = source;
-  context.position = position;
-  return context;
-}
-
 export function failsafe<P extends Parser<unknown>>(parser: P): P;
 export function failsafe<N>(parser: Parser<N>): Parser<N> {
   assert(parser);

package/src/parser/api/bind.ts

@@ -19,7 +19,7 @@ export function bind(target: DocumentFragment | HTMLElement | ShadowRoot, settin
   nearest: (position: number) => HTMLElement | undefined;
   index: (block: HTMLElement) => number;
 } {
-  let context: MarkdownParser.Options = {
+  const context: MarkdownParser.Options = {
     ...settings,
     host: settings.host ?? new ReadonlyURL(location.pathname, location.origin),
   };

package/src/parser/api/parse.ts

@@ -15,13 +15,13 @@ interface Options extends ParserOptions {
   readonly test?: boolean;
 }
 
-export function parse(source: string, opts: Options = {}, context?: MarkdownParser.Options | MarkdownParser.Context): DocumentFragment {
+export function parse(source: string, options: Options = {}, context?: MarkdownParser.Options): DocumentFragment {
   const url = headers(source).find(field => field.toLowerCase().startsWith('url:'))?.slice(4).trim() ?? '';
   source = !context ? normalize(source) : source;
   context = {
-    host: opts.host ?? context?.host ?? new ReadonlyURL(location.pathname, location.origin),
+    host: options.host ?? context?.host ?? new ReadonlyURL(location.pathname, location.origin),
     url: url ? new ReadonlyURL(url as ':') : context?.url,
-    id: opts.id ?? context?.id,
+    id: options.id ?? context?.id,
     caches: context?.caches,
     resources: context?.resources,
   };
@@ -38,11 +38,11 @@ export function parse(source: string, opts: Options = {}, context?: MarkdownPars
       ...(header(input(seg, { header: index++ === 0 } as MarkdownParser.Context)) || block(input(seg, context)))
         ?.foldl<HTMLElement[]>((acc, { value }) => void acc.push(value) || acc, []) ?? []);
   }
-  assert(opts.id !== '' || !node.querySelector('[id], .index[href], .label[href], .annotation > a[href], .reference > a[href]'));
-  if (opts.test) return node;
-  for (const _ of figure(node, opts.notes, context));
-  for (const _ of note(node, opts.notes, context));
-  assert(opts.id !== '' || !node.querySelector('[id], .index[href], .label[href], .annotation > a[href], .reference > a[href]'));
-  assert(opts.id !== '' || !opts.notes?.references.querySelector('[id], .index[href], .label[href]'));
+  assert(options.id !== '' || !node.querySelector('[id], .index[href], .label[href], .annotation > a[href], .reference > a[href]'));
+  if (options.test) return node;
+  for (const _ of figure(node, options.notes, context));
+  for (const _ of note(node, options.notes, context));
+  assert(options.id !== '' || !node.querySelector('[id], .index[href], .label[href], .annotation > a[href], .reference > a[href]'));
+  assert(options.id !== '' || !options.notes?.references.querySelector('[id], .index[href], .label[href]'));
   return node;
 }

package/src/parser/block.ts

@@ -56,6 +56,7 @@ export const block: BlockParser = reset(
     backtracks: {},
   },
   error(union([
+    emptyline,
     input => {
       const { context: { source, position } } = input;
       if (position === source.length) return;
@@ -109,7 +110,6 @@ export const block: BlockParser = reset(
           if ('0' <= fst && fst <= '9') return olist(input);
       }
     },
-    emptyline,
     paragraph
   ]) as any));