securemark 0.300.5 → 0.300.6

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 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.6 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"));
@@ -6460,10 +6460,10 @@ class RecursionCounter {
       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;
+    // 内側から数えるので無効化処理できない。
+    return this.index <= this.limit;
   }
 }
 
@@ -6740,8 +6740,13 @@ 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;
+  if (!recursion.add(resources?.recursions[2 /* Recursion.inline */] ?? resources?.recursions.at(-1))) {
+    return new parser_1.List([new parser_1.Node((0, dom_1.html)('span', {
+      class: 'invalid',
+      ...(0, util_1.invalid)('annotation', 'syntax', 'Recursions must be two or fewer')
+    }, (0, dom_1.defrag)((0, util_1.unwrap)((0, visibility_1.trimBlankNodeEnd)(nodes)))))]);
+  }
   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))))]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "securemark",
-  "version": "0.300.5",
+  "version": "0.300.6",
   "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/parser/context.ts

@@ -79,13 +79,13 @@ class RecursionCounter {
   }
   private readonly stack: number[] = [];
   private index = 0;
-  public add(depth: number): Error | undefined {
+  public add(depth: number): boolean {
     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;
+    // 内側から数えるので無効化処理できない。
+    return this.index <= this.limit;
   }
 }
 

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

@@ -62,6 +62,30 @@ 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>'], '']);
     });
 
   });

package/src/parser/inline/annotation.ts

@@ -6,7 +6,7 @@ import { inline } from '../inline';
 import { bracketname } from './bracket';
 import { repeat } from '../repeat';
 import { beforeNonblank, trimBlankNodeEnd } from '../visibility';
-import { unwrap } from '../util';
+import { unwrap, invalid } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 // シグネチャ等生成のために構文木のツリーウォークを再帰的に行い指数計算量にならないよう
@@ -40,8 +40,15 @@ 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;
+      if (!recursion.add(resources?.recursions[Recursion.inline] ?? resources?.recursions.at(-1))) {
+        return new List([new Node(html('span',
+          {
+            class: 'invalid',
+            ...invalid('annotation', 'syntax', 'Recursions must be two or fewer')
+          },
+          defrag(unwrap(trimBlankNodeEnd(nodes)))))]);
+      }
       const el = html('sup', { class: 'annotation' }, [
         html('span', defrag(unwrap(trimBlankNodeEnd(nodes))))
       ]);