securemark 0.293.1 → 0.293.3

package/package.json

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

package/src/combinator/control/manipulation/indent.test.ts

@@ -12,12 +12,17 @@ describe('Unit: combinator/indent', () => {
       assert.deepStrictEqual(inspect(parser(input(' ', ctx)), ctx), undefined);
       assert.deepStrictEqual(inspect(parser(input('  ', ctx)), ctx), undefined);
       assert.deepStrictEqual(inspect(parser(input('a ', ctx)), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser(input(' a\n', ctx)), ctx), [['a'], '']);
+      assert.deepStrictEqual(inspect(parser(input(' a', ctx)), ctx), [['a'], '']);
       assert.deepStrictEqual(inspect(parser(input(' a ', ctx)), ctx), [['a '], '']);
+      assert.deepStrictEqual(inspect(parser(input(' a\n', ctx)), ctx), [['a'], '']);
       assert.deepStrictEqual(inspect(parser(input(' a \n', ctx)), ctx), [['a '], '']);
       assert.deepStrictEqual(inspect(parser(input('  a', ctx)), ctx), [['a'], '']);
+      assert.deepStrictEqual(inspect(parser(input('   a', ctx)), ctx), [['a'], '']);
+      assert.deepStrictEqual(inspect(parser(input('    a', ctx)), ctx), [['a'], '']);
+      assert.deepStrictEqual(inspect(parser(input('     a', ctx)), ctx), [[' a'], '']);
       assert.deepStrictEqual(inspect(parser(input(' a\n a', ctx)), ctx), [['a\na'], '']);
       assert.deepStrictEqual(inspect(parser(input(' a\n  a', ctx)), ctx), [['a\n a'], '']);
+      assert.deepStrictEqual(inspect(parser(input('    a\n        a', ctx)), ctx), [['a\n    a'], '']);
       assert.deepStrictEqual(inspect(parser(input('  a\n a', ctx)), ctx), [['a'], ' a']);
       assert.deepStrictEqual(inspect(parser(input(' \ta', ctx)), ctx), [['\ta'], '']);
       assert.deepStrictEqual(inspect(parser(input('\ta', ctx)), ctx), [['a'], '']);

package/src/combinator/control/manipulation/indent.ts

@@ -13,7 +13,7 @@ export function indent<N>(opener: RegExp | Parser<N>, parser: Parser<N> | boolea
   if (typeof opener === 'function') {
     separation = parser as boolean;
     parser = opener;
-    opener = /([ \t])\1*/y;
+    opener = / {1,4}|\t{1,2}/y;
   }
   assert(!opener.flags.match(/[gm]/) && opener.sticky && !opener.source.startsWith('^'));
   assert(parser);

package/src/combinator/control/manipulation/scope.ts

@@ -1,8 +1,8 @@
 import { Parser, Context, input, eval, failsafe } from '../../data/parser';
-import { consume, matcher } from '../../../combinator';
+import { matcher } from '../../../combinator';
 
-export function focus<P extends Parser<unknown>>(scope: string | RegExp, parser: P, cost?: boolean): P;
-export function focus<N>(scope: string | RegExp, parser: Parser<N>, cost = true): Parser<N> {
+export function focus<P extends Parser<unknown>>(scope: string | RegExp, parser: P): P;
+export function focus<N>(scope: string | RegExp, parser: Parser<N>): Parser<N> {
   assert(parser);
   const match = matcher(scope, false);
   return failsafe(({ context }) => {
@@ -11,7 +11,6 @@ export function focus<N>(scope: string | RegExp, parser: Parser<N>, cost = true)
     const src = eval(match({ context }))?.[0] ?? '';
     assert(source.startsWith(src, position));
     if (src === '') return;
-    cost && consume(src.length, context);
     context.range = src.length;
     context.offset ??= 0;
     context.offset += position;

package/src/combinator/control/manipulation/surround.ts

@@ -157,7 +157,8 @@ export function setBacktrack(
   position: number,
   length: number = 1,
 ): void {
-  const { source } = context;
+  const { source, state = 0 } = context;
+  if (state === 0) return;
   if (position === source.length) return;
   if (length === 0) return;
   for (const backtrack of backtracks) {

package/src/combinator/data/parser/context/delimiter.ts

@@ -7,26 +7,24 @@ interface Delimiter {
   readonly signature: number | string;
   readonly matcher: (input: Input) => boolean | undefined;
   readonly precedence: number;
-  readonly linebreakable: boolean;
   state: boolean;
 }
 
 export class Delimiters {
   // 手間を惜しまなければ規定のパターンはすべて配列のインデクスに変換可能。
-  public static signature(pattern: string | RegExp | undefined, linebreakable: boolean): number | string {
+  public static signature(pattern: string | RegExp | undefined): number | string {
     switch (typeof pattern) {
       case 'undefined':
-        return +linebreakable;
+        return 1 << 7;
       case 'string':
         assert(pattern !== '\x00');
         if (pattern.length === 1) {
           const code = pattern.charCodeAt(0);
-          // 使用中のパターンの8ビット目が空いてるのでひとまずこうしとく
-          if ((code & 1 << 7) === 0) return code | +linebreakable << 7;
+          return code;
         }
-        return `s:${pattern}:${+linebreakable}`;
+        return `s:${pattern}`;
       case 'object':
-        return `r/${pattern.source}/${+linebreakable}`;
+        return `r/${pattern.source}`;
     }
   }
   public static matcher(pattern: string | RegExp | undefined): (input: Input<Ctx>) => true | undefined {
@@ -61,14 +59,13 @@ export class Delimiters {
       readonly signature: number | string;
       readonly matcher: (input: Input) => boolean | undefined;
       readonly precedence: number;
-      readonly linebreakable: boolean;
     }[]
   ): void {
     const { delimiters, stack } = this;
     // シグネチャ数以下
     assert(delimiters.length < 100);
     for (let i = 0; i < delims.length; ++i) {
-      const { signature, matcher, precedence, linebreakable } = delims[i];
+      const { signature, matcher, precedence } = delims[i];
       const memory = this.registry(signature);
       const index = memory[0]?.index ?? delimiters.length;
       assert(memory.length === 0 || precedence === delimiters[index].precedence);
@@ -79,7 +76,6 @@ export class Delimiters {
           signature,
           matcher,
           precedence,
-          linebreakable,
           state: true,
         };
         delimiters[index] = delimiter;
@@ -134,14 +130,13 @@ export class Delimiters {
     }
   }
   public match(input: Input): boolean {
-    const { precedence = 0, linebreak = 0 } = input.context;
+    const { precedence = 0 } = input.context;
     const { delimiters } = this;
     for (let i = delimiters.length; i--;) {
       const delimiter = delimiters[i];
       if (delimiter.precedence <= precedence || !delimiter.state) continue;
       switch (delimiter.matcher(input)) {
         case true:
-          if (!delimiter.linebreakable && linebreak > 0) return false;
           return true;
         case false:
           return false;

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

@@ -1,8 +1,7 @@
 import { Parser, eval } from '../parser';
 import { Delimiters } from './context/delimiter';
-import { unshift, push } from 'spica/array';
 
-type DelimiterOption = readonly [delimiter: string | RegExp, precedence: number, linebreak?: boolean];
+type DelimiterOption = readonly [delimiter: string | RegExp, precedence: number];
 
 export function some<P extends Parser<unknown>>(parser: P, limit?: number): P;
 export function some<P extends Parser<unknown>>(parser: P, end?: string | RegExp, delimiters?: readonly DelimiterOption[], limit?: number): P;
@@ -10,11 +9,10 @@ export function some<N>(parser: Parser<N>, end?: string | RegExp | number, delim
   if (typeof end === 'number') return some(parser, undefined, delimiters, end);
   assert(parser);
   const match = Delimiters.matcher(end);
-  const delims = delimiters.map(([delimiter, precedence, linebreakable = true]) => ({
-    signature: Delimiters.signature(delimiter, linebreakable),
+  const delims = delimiters.map(([delimiter, precedence]) => ({
+    signature: Delimiters.signature(delimiter),
     matcher: Delimiters.matcher(delimiter),
     precedence,
-    linebreakable,
   }));
   return input => {
     const { context } = input;
@@ -32,9 +30,7 @@ export function some<N>(parser: Parser<N>, end?: string | RegExp | number, delim
       const result = parser(input);
       if (result === undefined) break;
       nodes = nodes
-        ? nodes.length < eval(result).length / 8
-          ? unshift(nodes, eval(result))
-          : push(nodes, eval(result))
+        ? (nodes.push(...eval(result)), nodes)
         : eval(result);
       if (limit >= 0 && context.position - position > limit) break;
     }

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

@@ -363,7 +363,7 @@ describe('Unit: parser/api/parse', () => {
       this.timeout(5000);
       // 最悪計算量での実行速度はCommonMarkの公式JS実装の32nに対して3倍遅い程度。
       // 5n = annotation/reference + link + url/math + ruby + text
-      const source = `${'.'.repeat(0 + 0)}((([[[[#$[${'.'.repeat(19998)}`;
+      const source = `${'.'.repeat(0 + 0)}((([[[[#$[${'&'.repeat(19998)}`;
       assert.deepStrictEqual(
         [...parse(source, {}, { resources: { clock: 100000, recursions: [100] } }).children]
           .map(el => el.tagName),
@@ -372,7 +372,7 @@ describe('Unit: parser/api/parse', () => {
 
     it('backtrack error', function () {
       this.timeout(5000);
-      const source = `${'.'.repeat(0 + 1)}((([[[[#$[${'.'.repeat(19998)}`;
+      const source = `${'.'.repeat(0 + 1)}((([[[[#$[${'&'.repeat(19998)}`;
       assert.deepStrictEqual(
         [...parse(source, {}, { resources: { clock: 100000, recursions: [100] } }).children]
           .map(el => el.tagName),

package/src/parser/block/olist.test.ts

@@ -32,6 +32,8 @@ describe('Unit: parser/block/olist', () => {
       assert.deepStrictEqual(inspect(parser('(1)'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('(1)\n'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('(1)\n(1) a'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('I. '), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('A. '), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('(I) '), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('(A) '), ctx), undefined);
       assert.deepStrictEqual(inspect(parser(' 1. '), ctx), undefined);
@@ -117,12 +119,12 @@ describe('Unit: parser/block/olist', () => {
     });
 
     it('type', () => {
-      assert.deepStrictEqual(inspect(parser('i. '), ctx), [['<ol type="i" data-type="lower-roman"><li></li></ol>'], '']);
-      assert.deepStrictEqual(inspect(parser('a. '), ctx), [['<ol type="a" data-type="lower-alpha"><li></li></ol>'], '']);
-      assert.deepStrictEqual(inspect(parser('I. '), ctx), [['<ol type="I" data-type="upper-roman"><li></li></ol>'], '']);
-      assert.deepStrictEqual(inspect(parser('A. '), ctx), [['<ol type="A" data-type="upper-alpha"><li></li></ol>'], '']);
-      assert.deepStrictEqual(inspect(parser('a. \n1.\nc'), ctx), [['<ol type="a" data-type="lower-alpha"><li></li><li data-marker="1."></li><li data-marker="c."></li></ol>'], '']);
-      assert.deepStrictEqual(inspect(parser('i. 1'), ctx), [['<ol type="i" data-type="lower-roman"><li id="index::1">1</li></ol>'], '']);
+      assert.deepStrictEqual(inspect(parser('1. \n i. '), ctx), [['<ol><li><br><ol type="i" data-type="lower-roman"><li></li></ol></li></ol>'], '']);
+      assert.deepStrictEqual(inspect(parser('1. \n a. '), ctx), [['<ol><li><br><ol type="a" data-type="lower-alpha"><li></li></ol></li></ol>'], '']);
+      assert.deepStrictEqual(inspect(parser('1. \n I. '), ctx), [['<ol><li><br><ol type="I" data-type="upper-roman"><li></li></ol></li></ol>'], '']);
+      assert.deepStrictEqual(inspect(parser('1. \n A. '), ctx), [['<ol><li><br><ol type="A" data-type="upper-alpha"><li></li></ol></li></ol>'], '']);
+      assert.deepStrictEqual(inspect(parser('1. \n a. \n 1.\n c'), ctx), [['<ol><li><br><ol type="a" data-type="lower-alpha"><li></li><li data-marker="1."></li><li data-marker="c."></li></ol></li></ol>'], '']);
+      assert.deepStrictEqual(inspect(parser('1. \n i. 1'), ctx), [['<ol><li><br><ol type="i" data-type="lower-roman"><li id="index::1">1</li></ol></li></ol>'], '']);
     });
 
     it('checkbox', () => {

package/src/parser/block/olist.ts

@@ -16,8 +16,8 @@ const openers = {
 
 export const olist: OListParser = lazy(() => block(validate(
   new RegExp([
-    /([0-9]+|[a-z]+|[A-Z]+)(?:-[0-9]+)*\. /y.source,
-    /\(([0-9]+|[a-z]+)\)(?:-[0-9]+)* /y.source,
+    /(?:[0-9]+)(?:-[0-9]+)*\. /y.source,
+    /\((?:[0-9]+)\)(?:-[0-9]+)* /y.source,
   ].join('|'), 'y'),
   olist_)));
 

package/src/parser/block/sidefence.ts

@@ -8,7 +8,7 @@ import { html, define, defrag } from 'typed-dom/dom';
 
 export const sidefence: SidefenceParser = lazy(() => block(fmap(focus(
   /(?=\|+(?:[^\S\n]|\n\|))(?:\|+(?:[^\S\n][^\n]*)?(?:$|\n))+$/y,
-  union([source]), false),
+  union([source])),
   ([el]) => [
     define(el, {
       class: 'invalid',
@@ -23,7 +23,7 @@ const source: SidefenceParser.SourceParser = lazy(() => fmap(
   some(recursion(Recursion.block, union([
     focus(
       /(?:\|\|+(?:[^\S\n][^\n]*)?(?:$|\n))+/y,
-      convert(unindent, source, false, true), false),
+      convert(unindent, source, false, true)),
     rewrite(
       some(contentline, opener),
       convert(unindent, fmap(autolink, ns => [html('pre', defrag(ns))]), false, true)),

package/src/parser/block/table.ts

@@ -40,9 +40,9 @@ const align: AlignParser = fmap(open(
   '|',
   union([
     focus(/:-+:?/y, ({ context: { source } }) =>
-      [[source.at(-1) === ':' ? 'center' : 'start']], false),
+      [[source.at(-1) === ':' ? 'center' : 'start']]),
     focus(/-+:?/y, ({ context: { source } }) =>
-      [[source.at(-1) === ':' ? 'end' : '']], false),
+      [[source.at(-1) === ':' ? 'end' : '']]),
   ])),
   ns => [html('td', defrag(ns))]);
 

package/src/parser/block.ts

@@ -58,51 +58,53 @@ export const block: BlockParser = reset(
     input => {
       const { context: { source, position } } = input;
       if (position === source.length) return;
-      switch (source.slice(position, position + 3)) {
-        case '===':
-          return pagebreak(input);
-        case '~~~':
-          return extension(input);
-        case '```':
-          return codeblock(input);
-      }
-      switch (source.slice(position, position + 2)) {
-        case '$$':
-          return mathblock(input);
-        case '[$':
-          return extension(input);
-        case '[!':
+      const fst = source[position];
+      switch (fst) {
+        case '=':
+          if (source.startsWith('===', position)) return pagebreak(input);
+          break;
+        case '`':
+          if (source.startsWith('```', position)) return codeblock(input);
+          break;
+        case '~':
+          if (source.startsWith('~~~', position)) return extension(input);
+          if (source[position + 1] === ' ') return dlist(input);
+          break;
+        case '-':
+          if (source[position + 1] === ' ') return ulist(input) || ilist(input);
+          break;
+        case '+':
+        case '*':
+          if (source[position + 1] === ' ') return ilist(input);
+          break;
+        case '[':
+          switch (source[position + 1]) {
+            case '$':
+              return extension(input);
+            case '!':
+              return mediablock(input);
+          }
+          break;
+        case '!':
+          if (source[position + 1] === '>') return blockquote(input);
           return mediablock(input);
-        case '!>':
+        case '>':
+          if (source[position + 1] === '>') return blockquote(input) || reply(input);
           return blockquote(input);
-        case '>>':
-          return blockquote(input)
-              || reply(input);
-        case '- ':
-          return ulist(input)
-              || ilist(input);
-        case '+ ':
-        case '* ':
-          return ilist(input);
-        case '~ ':
-          return dlist(input);
-      }
-      switch (source[position]) {
         case '#':
           return heading(input);
-        case '|':
-          return table(input)
-              || sidefence(input);
         case '$':
+          if (source[position + 1] === '$') return mathblock(input);
           return extension(input);
-        case '>':
-          return blockquote(input);
-        case '!':
-          return mediablock(input);
+        case '|':
+          return table(input) || sidefence(input);
+        case '(':
+          return olist(input);
+        default:
+          if ('0' <= fst && fst <= '9') return olist(input);
       }
     },
     emptyline,
-    olist,
     paragraph
   ]) as any));
 

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

@@ -17,7 +17,7 @@ describe('Unit: parser/inline/annotation', () => {
       assert.deepStrictEqual(inspect(parser('(()))'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('(("))'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('(([))'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('((<bdi>))'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('(([%))'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('(( ))'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('(( (a'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('((\n))'), ctx), undefined);

package/src/parser/inline/autolink/url.test.ts

@@ -12,10 +12,10 @@ describe('Unit: parser/inline/autolink/url', () => {
       assert.deepStrictEqual(inspect(parser(''), ctx), undefined);
       assert.deepStrictEqual(inspect(parser(' http'), ctx), [[' http'], '']);
       assert.deepStrictEqual(inspect(parser(' ttp'), ctx), [[' ttp'], '']);
-      assert.deepStrictEqual(inspect(parser(' http://'), ctx), [[' ', 'http:', '/', '/'], '']);
-      assert.deepStrictEqual(inspect(parser(' http://['), ctx), [[' ', 'http:', '/', '/', '['], '']);
-      assert.deepStrictEqual(inspect(parser(' http://]'), ctx), [[' ', 'http:', '/', '/', ']'], '']);
-      assert.deepStrictEqual(inspect(parser(' Http://host'), ctx), [[' ', 'Http:', '/', '/host'], '']);
+      assert.deepStrictEqual(inspect(parser(' http://'), ctx), [[' ', 'http:', '//'], '']);
+      assert.deepStrictEqual(inspect(parser(' http://['), ctx), [[' ', 'http:', '//', '['], '']);
+      assert.deepStrictEqual(inspect(parser(' http://]'), ctx), [[' ', 'http:', '//', ']'], '']);
+      assert.deepStrictEqual(inspect(parser(' Http://host'), ctx), [[' ', 'Http:', '//host'], '']);
       assert.deepStrictEqual(inspect(parser(' http://[::ffff:0:0%1]'), ctx), [[' ', '<a class="invalid">http://[::ffff:0:0%1]</a>'], '']);
       assert.deepStrictEqual(inspect(parser(' http://[::ffff:0:0/96]'), ctx), [[' ', '<a class="invalid">http://[::ffff:0:0/96]</a>'], '']);
     });
@@ -59,7 +59,7 @@ describe('Unit: parser/inline/autolink/url', () => {
       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(' 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>', '`'], '']);

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

@@ -41,6 +41,7 @@ describe('Unit: parser/inline/bracket', () => {
       assert.deepStrictEqual(inspect(parser('(ABBR, ABBR)'), ctx), [['(', 'ABBR, ABBR', ')'], '']);
       assert.deepStrictEqual(inspect(parser('(\\a)'), ctx), [['<span class="paren">(a)</span>'], '']);
       assert.deepStrictEqual(inspect(parser('(==)'), ctx), [['<span class="paren">(==)</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('("(\n))"(")'), ctx), [['<span class="paren">("(<br>)</span>'], ')"(")']);
       assert.deepStrictEqual(inspect(parser('($)$'), ctx), [['(', '<span class="math" translate="no" data-src="$)$">$)$</span>'], '']);
       assert.deepStrictEqual(inspect(parser(')'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('（１，２）'), ctx), [['（', '１，２', '）'], '']);
@@ -60,7 +61,7 @@ describe('Unit: parser/inline/bracket', () => {
       assert.deepStrictEqual(inspect(parser('[]'), ctx), [['[', ']'], '']);
       assert.deepStrictEqual(inspect(parser('[a'), ctx), [['[', 'a'], '']);
       assert.deepStrictEqual(inspect(parser('[a]'), ctx), [['[', 'a', ']'], '']);
-      assert.deepStrictEqual(inspect(parser('[==]'), ctx), [['[', '=', '=', ']'], '']);
+      assert.deepStrictEqual(inspect(parser('[==]'), ctx), [['[', '==', ']'], '']);
       assert.deepStrictEqual(inspect(parser('[$]$'), ctx), [['[', '<span class="math" translate="no" data-src="$]$">$]$</span>'], '']);
       assert.deepStrictEqual(inspect(parser(']'), ctx), undefined);
     });
@@ -70,7 +71,7 @@ describe('Unit: parser/inline/bracket', () => {
       assert.deepStrictEqual(inspect(parser('{}'), ctx), [['{', '}'], '']);
       assert.deepStrictEqual(inspect(parser('{a'), ctx), [['{', 'a'], '']);
       assert.deepStrictEqual(inspect(parser('{a}'), ctx), [['{', 'a', '}'], '']);
-      assert.deepStrictEqual(inspect(parser('{==}'), ctx), [['{', '=', '=', '}'], '']);
+      assert.deepStrictEqual(inspect(parser('{==}'), ctx), [['{', '==', '}'], '']);
       assert.deepStrictEqual(inspect(parser('}'), ctx), undefined);
     });
 
@@ -82,8 +83,9 @@ describe('Unit: parser/inline/bracket', () => {
       assert.deepStrictEqual(inspect(parser('"(")"'), ctx), [['"', '(', '"'], ')"']);
       assert.deepStrictEqual(inspect(parser('"(("'), ctx), [['"', '(', '(', '"'], '']);
       assert.deepStrictEqual(inspect(parser('"(\\")"'), ctx), [['"', '<span class="paren">(")</span>', '"'], '']);
-      assert.deepStrictEqual(inspect(parser('"\n"'), ctx), [['"', '<br>', '"'], '']);
-      assert.deepStrictEqual(inspect(parser('"\n"(")'), ctx), [['"', '<br>', '"', '(', '"'], ')']);
+      assert.deepStrictEqual(inspect(parser('"(\n)"(")'), ctx), [['"', '('], '\n)"(")']);
+      assert.deepStrictEqual(inspect(parser('"\n"'), ctx), [['"'], '\n"']);
+      assert.deepStrictEqual(inspect(parser('"\n"(")'), ctx), [['"'], '\n"(")']);
     });
 
   });