securemark 0.300.5 → 0.300.7

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 0.300.7
+
+- Refactoring.
+
+## 0.300.6
+
+- Refactoring.
+
 ## 0.300.5
 
 - Refactoring.

package/dist/index.js

@@ -1,4 +1,4 @@
-/*! securemark v0.300.5 https://github.com/falsandtru/securemark | (c) 2017, falsandtru | UNLICENSED License */
+/*! securemark v0.300.7 https://github.com/falsandtru/securemark | (c) 2017, falsandtru | UNLICENSED License */
 (function webpackUniversalModuleDefinition(root, factory) {
 	if(typeof exports === 'object' && typeof module === 'object')
 		module.exports = factory(require("Prism"), require("DOMPurify"));
@@ -6414,7 +6414,6 @@ exports.input = input;
 class Input extends parser_1.Input {
   constructor(options = {}, source) {
     super(options);
-    this.recursion = new RecursionCounter(2);
     const {
       segment,
       header,
@@ -6449,23 +6448,6 @@ class Input extends parser_1.Input {
   }
 }
 exports.Input = Input;
-class RecursionCounter {
-  constructor(limit) {
-    this.limit = limit;
-    this.stack = [];
-    this.index = 0;
-  }
-  add(depth) {
-    const {
-      stack
-    } = this;
-    for (; this.index > 0 && stack[this.index - 1] >= depth; --this.index);
-    // 内側から数えるので無効化処理できずエラーを投げるしかない。
-    if (this.index === this.limit) return new Error(`Too much recursion`);
-    stack[this.index] = depth;
-    ++this.index;
-  }
-}
 
 /***/ },
 
@@ -6729,9 +6711,7 @@ exports.annotation = (0, combinator_1.lazy)(() => (0, combinator_1.constraint)(1
   const {
     position,
     linebreak,
-    range,
-    recursion,
-    resources
+    range
   } = input;
   if (linebreak !== 0 || nodes.length === 0 || lead === 0 || follow % 2 === 0) {
     nodes.unshift(new parser_1.Node('('));
@@ -6740,14 +6720,20 @@ exports.annotation = (0, combinator_1.lazy)(() => (0, combinator_1.constraint)(1
       class: (0, bracket_1.bracketname)(input, 1, 1)
     }, (0, dom_1.defrag)((0, util_1.unwrap)(nodes))))]);
   }
-  output.error ??= recursion.add(resources?.recursions[2 /* Recursion.inline */] ?? resources?.recursions.at(-1));
   input.position += 1;
   const el = (0, dom_1.html)('sup', {
     class: 'annotation'
   }, [(0, dom_1.html)('span', (0, dom_1.defrag)((0, util_1.unwrap)((0, visibility_1.trimBlankNodeEnd)(nodes))))]);
   for (let list = output.annotations.at(-1), node = list.last, pos = position - range, i = 0;; node = node.prev, ++i) {
-    if (node && node.position > pos) continue;
-    i === list.length ? list.unshift(new parser_1.Node(el, pos)) : list.insert(new parser_1.Node(el, pos), node?.next);
+    if (node && node.position > pos) {
+      if (~node.flags & 2 /* Node.Flag.nested */) continue;
+      return new parser_1.List([new parser_1.Node((0, dom_1.define)(el.firstElementChild, {
+        class: 'invalid',
+        ...(0, util_1.invalid)('annotation', 'syntax', 'Recursions must be two or fewer')
+      }))]);
+    }
+    const flag = i === 0 ? 0 /* Node.Flag.none */ : 2 /* Node.Flag.nested */;
+    i === list.length ? list.unshift(new parser_1.Node(el, pos, flag)) : list.insert(new parser_1.Node(el, pos, flag), node?.next);
     break;
   }
   return new parser_1.List([new parser_1.Node(el)]);
@@ -8685,6 +8671,7 @@ function repeat(opener, after, closer, recursion, parser, cons, termination = (n
         input.position += closer.length;
         const pos = input.position;
         m.follow = m.follow > 0 ? m.follow : countFollows(source, pos, closer, lead / opener.length | 0);
+        input.range = input.position - m.position - m.i + opener.length;
         output.push(cons(output.pop(), input, output, lead, m.follow));
         if (input.position > pos) {
           const advance = input.position - pos;

package/package.json

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

package/src/api/parse.test.ts

@@ -314,33 +314,6 @@ describe('Unit: api/parse', () => {
       assert.deepStrictEqual(
         [...run(parse(`${'{  '.repeat(101)}0`)).children].map(el => el.tagName),
         ['H1', 'PRE', 'OL']);
-      assert.deepStrictEqual(
-        [...run(parse(`${'(('.repeat(2)}0${'))'.repeat(2)}`)).children].map(el => el.tagName),
-        ['P', 'OL', 'OL']);
-      assert.deepStrictEqual(
-        [...run(parse(`${'(('.repeat(3)}0${'))'.repeat(3)}`)).children].map(el => el.tagName),
-        ['H1', 'PRE', 'OL']);
-      assert.deepStrictEqual(
-        [...run(parse(`(${'(('.repeat(2)}0${'))'.repeat(2)}`)).children].map(el => el.tagName),
-        ['P', 'OL', 'OL']);
-      assert.deepStrictEqual(
-        [...run(parse(`(${'(('.repeat(3)}0${'))'.repeat(3)}`)).children].map(el => el.tagName),
-        ['H1', 'PRE', 'OL']);
-      assert.deepStrictEqual(
-        [...run(parse(`${'(('.repeat(2)}0${'))'.repeat(2)}${'(('.repeat(2)}0${'))'.repeat(2)}`)).children].map(el => el.tagName),
-        ['P', 'OL', 'OL']);
-      assert.deepStrictEqual(
-        [...run(parse(`${'(('.repeat(2)}0${'))'.repeat(2)}${'(('.repeat(3)}0${'))'.repeat(3)}`)).children].map(el => el.tagName),
-        ['H1', 'PRE', 'OL']);
-      assert.deepStrictEqual(
-        [...run(parse(`${'(('.repeat(2)}0${'))'.repeat(2)}${'(('.repeat(9)}0${'))'.repeat(2)}`)).children].map(el => el.tagName),
-        ['P', 'OL', 'OL']);
-      assert.deepStrictEqual(
-        [...run(parse(`${'(('.repeat(2)}0${'))'.repeat(2)}${'(('.repeat(9)}0${'))'.repeat(3)}`)).children].map(el => el.tagName),
-        ['H1', 'PRE', 'OL']);
-      assert.deepStrictEqual(
-        [...run(parse(`${'(('.repeat(3)}0))((1))))))`)).children].map(el => el.tagName),
-        ['H1', 'PRE', 'OL']);
     });
 
     it('recovery', () => {

package/src/combinator/parser/list.ts

@@ -159,6 +159,7 @@ export class Node<T> implements List.Node {
 export namespace Node {
   export const enum Flag {
     none,
-    blank,
+    blank = 1 << 0,
+    nested = 1 << 1,
   }
 }

package/src/parser/context.ts

@@ -56,7 +56,6 @@ export class Input<M extends object = object> extends Ipt<M> {
   public header: boolean;
   public local: boolean;
   public whitespace: boolean;
-  public recursion = new RecursionCounter(2);
   public readonly host?: URL;
   public readonly url?: URL;
   public id?: string;
@@ -72,23 +71,6 @@ export class Input<M extends object = object> extends Ipt<M> {
 }
 export type Options = Partial<Input>;
 
-class RecursionCounter {
-  constructor(
-    private readonly limit: number,
-  ) {
-  }
-  private readonly stack: number[] = [];
-  private index = 0;
-  public add(depth: number): Error | undefined {
-    const { stack } = this
-    for (; this.index > 0 && stack[this.index - 1] >= depth; --this.index);
-    // 内側から数えるので無効化処理できずエラーを投げるしかない。
-    if (this.index === this.limit) return new Error(`Too much recursion`);
-    stack[this.index] = depth;
-    ++this.index;
-  }
-}
-
 export const enum Segment {
   unknown = 0,
   read = 0,

package/src/parser/inline/annotation.test.ts

@@ -62,6 +62,33 @@ describe('Unit: parser/inline/annotation', () => {
       assert.deepStrictEqual(inspect(parser, input('(((a)))')), [['<sup class="annotation"><span><span class="paren">(a)</span></span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser, input('((((a))))')), [['<sup class="annotation"><span><sup class="annotation"><span>a</span></sup></span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser, input('(([[a]]))')), [['<sup class="annotation"><span><sup class="reference"><span>a</span></sup></span></sup>'], '']);
+      assert.deepStrictEqual(
+        inspect(parser, input(`${'(('.repeat(2)}0${'))'.repeat(2)}`)),
+        [['<sup class="annotation"><span><sup class="annotation"><span>0</span></sup></span></sup>'], '']);
+      assert.deepStrictEqual(
+        inspect(parser, input(`${'(('.repeat(3)}0${'))'.repeat(3)}`)),
+        [['<span class="invalid"><sup class="annotation"><span><sup class="annotation"><span>0</span></sup></span></sup></span>'], '']);
+      assert.deepStrictEqual(
+        inspect(parser, input(`(${'(('.repeat(2)}0${'))'.repeat(2)}`)),
+        [['<span class="paren">(<sup class="annotation"><span><sup class="annotation"><span>0</span></sup></span></sup></span>'], '']);
+      assert.deepStrictEqual(
+        inspect(parser, input(`(${'(('.repeat(3)}0${'))'.repeat(3)}`)),
+        [['<span class="paren">(<span class="invalid"><sup class="annotation"><span><sup class="annotation"><span>0</span></sup></span></sup></span></span>'], '']);
+      assert.deepStrictEqual(
+        inspect(parser, input(`${'(('.repeat(2)}0${'))'.repeat(2)}${'(('.repeat(2)}0${'))'.repeat(2)}`)),
+        [['<sup class="annotation"><span><sup class="annotation"><span>0</span></sup></span></sup>', '<sup class="annotation"><span><sup class="annotation"><span>0</span></sup></span></sup>'], '']);
+      assert.deepStrictEqual(
+        inspect(parser, input(`${'(('.repeat(2)}0${'))'.repeat(2)}${'(('.repeat(3)}0${'))'.repeat(2)}`)),
+        [['<sup class="annotation"><span><sup class="annotation"><span>0</span></sup></span></sup>', '<span class="paren">(<span class="paren">(<sup class="annotation"><span><sup class="annotation"><span>0</span></sup></span></sup></span></span>'], '']);
+      assert.deepStrictEqual(
+        inspect(parser, input(`${'(('.repeat(2)}0${'))'.repeat(2)}${'(('.repeat(3)}0${'))'.repeat(3)}`)),
+        [['<sup class="annotation"><span><sup class="annotation"><span>0</span></sup></span></sup>', '<span class="invalid"><sup class="annotation"><span><sup class="annotation"><span>0</span></sup></span></sup></span>'], '']);
+      assert.deepStrictEqual(
+        inspect(parser, input(`${'(('.repeat(3)}0))((1))))))`)),
+        [['<span class="invalid"><sup class="annotation"><span><sup class="annotation"><span>0</span></sup><sup class="annotation"><span>1</span></sup></span></sup></span>'], '']);
+      assert.deepStrictEqual(
+        inspect(parser, input(`${'(0'.repeat(4)}((0${'))'.repeat(3)}${'(('.repeat(2)}0${'))'.repeat(2)}`)),
+        [['<span class="paren">(0<span class="paren">(0<span class="paren">(0<span class="paren">(0<sup class="annotation"><span>0</span></sup>)</span>)</span>)</span>)</span>', '<sup class="annotation"><span><sup class="annotation"><span>0</span></sup></span></sup>'], '']);
     });
 
   });

package/src/parser/inline/annotation.ts

@@ -6,8 +6,8 @@ import { inline } from '../inline';
 import { bracketname } from './bracket';
 import { repeat } from '../repeat';
 import { beforeNonblank, trimBlankNodeEnd } from '../visibility';
-import { unwrap } from '../util';
-import { html, defrag } from 'typed-dom/dom';
+import { unwrap, invalid } from '../util';
+import { html, define, defrag } from 'typed-dom/dom';
 
 // シグネチャ等生成のために構文木のツリーウォークを再帰的に行い指数計算量にならないよう
 // 動的計画法を適用するか再帰数を制限する必要がある。
@@ -32,7 +32,7 @@ export const annotation: AnnotationParser = lazy(() => constraint(State.annotati
     ([, bs], _, output) => output.import(bs),
     ([, bs], _, output) => bs && output.import(bs.push(new Node(Command.Cancel)))))),
     (nodes, input, output, lead, follow) => {
-      const { position, linebreak, range, recursion, resources } = input;
+      const { position, linebreak, range } = input;
       if (linebreak !== 0 || nodes.length === 0 || lead === 0 || follow % 2 === 0) {
         nodes.unshift(new Node('('));
         nodes.push(new Node(')'));
@@ -40,16 +40,25 @@ export const annotation: AnnotationParser = lazy(() => constraint(State.annotati
           new Node(html('span', { class: bracketname(input, 1, 1) }, defrag(unwrap(nodes))))
         ]);
       }
-      output.error ??= recursion.add(resources?.recursions[Recursion.inline] ?? resources?.recursions.at(-1));
       input.position += 1;
       const el = html('sup', { class: 'annotation' }, [
         html('span', defrag(unwrap(trimBlankNodeEnd(nodes))))
       ]);
       for (let list = output.annotations.at(-1)!, node = list.last, pos = position - range, i = 0; ; node = node!.prev, ++i) {
-        if (node && node.position > pos) continue;
+        if (node && node.position > pos) {
+          if (~node.flags & Node.Flag.nested) continue;
+          return new List([
+            new Node(define(el.firstElementChild as HTMLElement,
+              {
+                class: 'invalid',
+                ...invalid('annotation', 'syntax', 'Recursions must be two or fewer')
+              }))
+          ]);
+        }
+        const flag = i === 0 ? Node.Flag.none : Node.Flag.nested;
         i === list.length
-          ? list.unshift(new Node(el, pos))
-          : list.insert(new Node(el, pos), node?.next);
+          ? list.unshift(new Node(el, pos, flag))
+          : list.insert(new Node(el, pos, flag), node?.next);
         break;
       }
       return new List([new Node(el)]);

package/src/parser/repeat.ts

@@ -93,6 +93,7 @@ export function repeat<T extends HTMLElement | string>(
           input.position += closer.length;
           const pos = input.position;
           m.follow = m.follow > 0 ? m.follow : countFollows(source, pos, closer, lead / opener.length | 0);
+          input.range = input.position - m.position - m.i + opener.length;
           output.push(cons(output.pop(), input, output, lead, m.follow));
           if (input.position > pos) {
             const advance = input.position - pos;