securemark 0.293.2 → 0.293.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "securemark",
-  "version": "0.293.2",
+  "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/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/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.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/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), [['（', '１，２', '）'], '']);
@@ -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"(")']);
     });
 
   });

package/src/parser/inline/bracket.ts

@@ -1,6 +1,6 @@
 import { BracketParser } from '../inline';
 import { State, Recursion, Backtrack } from '../context';
-import { union, some, recursion, precedence, validate, surround, isBacktrack, setBacktrack, lazy } from '../../combinator';
+import { union, some, recursion, precedence, surround, isBacktrack, setBacktrack, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { textlink } from './link';
 import { str } from '../source';
@@ -11,93 +11,119 @@ const indexA = /^[0-9A-Za-z]+(?:(?:[.-]|, )[0-9A-Za-z]+)*$/;
 const indexF = new RegExp(indexA.source.replace(', ', '[，、]')
   .replace(/[09AZaz.]|\-(?!\w)/g, c => String.fromCodePoint(c.codePointAt(0)! + 0xFEE0)));
 
-export const bracket: BracketParser = lazy(() => validate(/[([{（［｛"]/y, union([
-  surround(
-    str('('),
-    precedence(1, recursion(Recursion.bracket, some(inline, ')', [[')', 1]]))),
-    str(')'),
-    true,
-    ([as, bs = [], cs], { source, position, range = 0 }) => {
-      const str = source.slice(position - range + 1, position - 1);
-      return indexA.test(str)
-        ? [[as[0], str, cs[0]]]
-        : [[html('span', { class: 'paren' }, defrag(push(unshift(as, bs), cs)))]];
-    },
-    ([as, bs = []]) => [unshift(as, bs)],
-    [2 | Backtrack.bracket]),
-  surround(
-    str('（'),
-    precedence(1, recursion(Recursion.bracket, some(inline, '）', [['）', 1]]))),
-    str('）'),
-    true,
-    ([as, bs = [], cs], { source, position, range = 0 }) => {
-      const str = source.slice(position - range + 1, position - 1);
-      return indexF.test(str)
-        ? [[as[0], str, cs[0]]]
-        : [[html('span', { class: 'paren' }, defrag(push(unshift(as, bs), cs)))]];
-    },
-    ([as, bs = []]) => [unshift(as, bs)]),
-  surround(
-    str('['),
-    precedence(1, recursion(Recursion.bracket, some(inline, ']', [[']', 1]]))),
-    str(']'),
-    true,
-    ([as, bs = [], cs], context) => {
-      if (context.state! & State.link) {
-        const { source, position, range = 0 } = context;
-        const head = position - range;
-        if (context.linebreak !== 0 || source[position] !== '{') {
+export const bracket: BracketParser = lazy(() => union([
+  input => {
+    const { context: { source, position } } = input;
+    switch (source[position]) {
+      case '(':
+        return p1(input);
+      case '（':
+        return p2(input);
+      case '[':
+        return s1(input);
+      case '［':
+        return s2(input);
+      case '{':
+        return c1(input);
+      case '｛':
+        return c2(input);
+      case '"':
+        return d1(input);
+    }
+  }
+])) as any;
+
+const p1 = lazy(() => surround(
+  str('('),
+  precedence(1, recursion(Recursion.bracket, some(inline, ')', [[')', 1]]))),
+  str(')'),
+  true,
+  ([as, bs = [], cs], { source, position, range = 0 }) => {
+    const str = source.slice(position - range + 1, position - 1);
+    return indexA.test(str)
+      ? [[as[0], str, cs[0]]]
+      : [[html('span', { class: 'paren' }, defrag(push(unshift(as, bs), cs)))]];
+  },
+  ([as, bs = []]) => [unshift(as, bs)],
+  [2 | Backtrack.bracket]));
+
+const p2 = lazy(() => surround(
+  str('（'),
+  precedence(1, recursion(Recursion.bracket, some(inline, '）', [['）', 1]]))),
+  str('）'),
+  true,
+  ([as, bs = [], cs], { source, position, range = 0 }) => {
+    const str = source.slice(position - range + 1, position - 1);
+    return indexF.test(str)
+      ? [[as[0], str, cs[0]]]
+      : [[html('span', { class: 'paren' }, defrag(push(unshift(as, bs), cs)))]];
+  },
+  ([as, bs = []]) => [unshift(as, bs)],
+  [2 | Backtrack.bracket]));
+
+const s1 = lazy(() => surround(
+  str('['),
+  precedence(1, recursion(Recursion.bracket, some(inline, ']', [[']', 1]]))),
+  str(']'),
+  true,
+  ([as, bs = [], cs], context) => {
+    if (context.state! & State.link) {
+      const { source, position, range = 0 } = context;
+      const head = position - range;
+      if (context.linebreak !== 0 || source[position] !== '{') {
+        setBacktrack(context, [2 | Backtrack.link], head);
+      }
+      else {
+        context.state! ^= State.link;
+        const result = !isBacktrack(context, [1 | Backtrack.link])
+          ? textlink({ context })
+          : undefined;
+        context.position = position;
+        if (!result) {
           setBacktrack(context, [2 | Backtrack.link], head);
         }
-        else {
-          context.state! ^= State.link;
-          const result = !isBacktrack(context, [1 | Backtrack.link])
-            ? textlink({ context })
-            : undefined;
-          context.position = position;
-          if (!result) {
-            setBacktrack(context, [2 | Backtrack.link], head);
-          }
-          context.state! ^= State.link;
-          context.range = range;
-        }
+        context.state! ^= State.link;
+        context.range = range;
       }
-      return [push(unshift(as, bs), cs)];
-    },
-    ([as, bs = []]) => [unshift(as, bs)],
-    [2 | Backtrack.bracket]),
-  surround(
-    str('［'),
-    precedence(1, recursion(Recursion.bracket, some(inline, '］', [['］', 1]]))),
-    str('］'),
-    true,
-    undefined,
-    ([as, bs = []]) => [unshift(as, bs)]),
-  surround(
-    str('{'),
-    precedence(1, recursion(Recursion.bracket, some(inline, '}', [['}', 1]]))),
-    str('}'),
-    true,
-    undefined,
-    ([as, bs = []]) => [unshift(as, bs)],
-    [2 | Backtrack.bracket]),
-  surround(
-    str('｛'),
-    precedence(1, recursion(Recursion.bracket, some(inline, '｝', [['｝', 1]]))),
-    str('｝'),
-    true,
-    undefined,
-    ([as, bs = []]) => [unshift(as, bs)]),
-  // 同一行内でしか閉じない以外括弧と同じ挙動
-  surround(
-    str('"'),
-    precedence(2, recursion(Recursion.bracket, some(inline, '"', [['"', 2, false]]))),
-    str('"'),
-    true,
-    ([as, bs = [], cs], context) =>
-      context.linebreak === 0
-        ? [push(unshift(as, bs), cs)]
-        : (context.position -= 1, [unshift(as, bs)]),
-    ([as, bs = []]) => [unshift(as, bs)],
-    [2 | Backtrack.bracket]),
-])));
+    }
+    return [push(unshift(as, bs), cs)];
+  },
+  ([as, bs = []]) => [unshift(as, bs)],
+  [2 | Backtrack.bracket]));
+
+const s2 = lazy(() => surround(
+  str('［'),
+  precedence(1, recursion(Recursion.bracket, some(inline, '］', [['］', 1]]))),
+  str('］'),
+  true,
+  undefined,
+  ([as, bs = []]) => [unshift(as, bs)],
+  [2 | Backtrack.bracket]));
+
+const c1 = lazy(() => surround(
+  str('{'),
+  precedence(1, recursion(Recursion.bracket, some(inline, '}', [['}', 1]]))),
+  str('}'),
+  true,
+  undefined,
+  ([as, bs = []]) => [unshift(as, bs)],
+  [2 | Backtrack.bracket]));
+
+const c2 = lazy(() => surround(
+  str('｛'),
+  precedence(1, recursion(Recursion.bracket, some(inline, '｝', [['｝', 1]]))),
+  str('｝'),
+  true,
+  undefined,
+  ([as, bs = []]) => [unshift(as, bs)],
+  [2 | Backtrack.bracket]));
+
+const d1 = lazy(() => surround(
+  str('"'),
+  // 改行の優先度を構文ごとに変える場合シグネチャの優先度対応が必要
+  precedence(2, recursion(Recursion.bracket, some(inline, /["\n]/y, [['"', 2], ['\n', 3]]))),
+  str('"'),
+  true,
+  undefined,
+  ([as, bs = []]) => [unshift(as, bs)],
+  [2 | Backtrack.bracket]));

package/src/parser/inline/html.ts

@@ -7,7 +7,7 @@ import { str } from '../source';
 import { isLooseNodeStart, blankWith } from '../visibility';
 import { invalid } from '../util';
 import { memoize } from 'spica/memoize';
-import { unshift, push, splice } from 'spica/array';
+import { unshift, push } from 'spica/array';
 import { html as h, defrag } from 'typed-dom/dom';
 
 const tags: readonly string[] = ['wbr', 'bdo', 'bdi'];
@@ -42,10 +42,14 @@ export const html: HTMLParser = lazy(() => validate(/<[a-z]+(?=[^\S\n]|>)/yi,
             true,
             ([as, bs = [], cs]) => [push(unshift(as, bs), cs)],
             ([as, bs = []]) => [unshift(as, bs)]),
-          precedence(3, recursion(Recursion.inline,
+          // 不可視のHTML構造が可視構造を変化させるべきでない。
+          // 可視のHTMLは優先度変更を検討する。
+          // このため<>は将来的に共通構造を変化させる可能性があり
+          // 共通構造を変更させない非構造文字列としては依然としてエスケープを要する。
+          precedence(0, recursion(Recursion.inline,
           some(union([
-            some(inline, blankWith('\n', `</${tag}>`), [[blankWith('\n', `</${tag}>`), 3]]),
-            open('\n', some(inline, `</${tag}>`, [[`</${tag}>`, 3]]), true),
+            some(inline, blankWith('\n', `</${tag}>`)),
+            open('\n', some(inline, `</${tag}>`), true),
           ])))),
           str(`</${tag}>`),
           true,
@@ -81,7 +85,7 @@ function elem(tag: string, content: boolean, as: string[], bs: (HTMLElement | st
     if (bs.length === 0) return ielem('content', `Missing the content`, context);
     if (!isLooseNodeStart(bs)) return ielem('content', `Missing the visible content in the same line`, context);
   }
-  const attrs = attributes('html', attrspecs[tag], as.slice(1, as.at(-1) === '>' ? -1 : as.length));
+  const [attrs] = attributes('html', attrspecs[tag], as.slice(1, as.at(-1) === '>' ? -1 : as.length));
   if (/(?<!\S)invalid(?!\S)/.test(attrs['class'] ?? '')) return ielem('attribute', 'Invalid HTML attribute', context)
   if (as.at(-1) !== '>') return ielem('tag', `Missing the closing symbol ">"`, context);
   return h(tag as 'span', attrs, defrag(bs));
@@ -101,11 +105,12 @@ const requiredAttributes = memoize(
 export function attributes(
   syntax: string,
   spec: Readonly<Record<string, readonly (string | undefined)[] | undefined>> | undefined,
-  params: string[],
-): Record<string, string | undefined> {
+  params: readonly string[],
+): [Record<string, string | undefined>, string[]] {
   assert(spec instanceof Object === false);
   assert(!spec?.['__proto__']);
   assert(!spec?.toString);
+  const remains = [];
   let invalidation = false;
   const attrs: Record<string, string | undefined> = {};
   for (let i = 0; i < params.length; ++i) {
@@ -116,19 +121,25 @@ export function attributes(
       ? param.slice(name.length + 2, -1).replace(/\\(.?)/g, '$1')
       : undefined;
     invalidation ||= name === '' || !spec || name in attrs;
-    if (name === '' || spec && name in spec && !spec[name]) continue;
-    spec?.[name]?.includes(value) || spec?.[name]?.length === 0 && value !== undefined
-      ? attrs[name] = value ?? ''
-      : invalidation ||= !!spec;
+    if (name === '')continue;
+    if (spec && name in spec && !spec[name]) {
+      remains.push(params[i]);
+      continue;
+    }
+    if (spec?.[name]?.includes(value) || spec?.[name]?.length === 0 && value !== undefined) {
+      attrs[name] = value ?? ''
+    }
+    else {
+      invalidation ||= !!spec;
+    }
     assert(!(name in {} && attrs.hasOwnProperty(name)));
-    splice(params, i--, 1);
   }
   invalidation ||= !!spec && !requiredAttributes(spec).every(name => name in attrs);
   if (invalidation) {
     attrs['class'] = 'invalid';
     Object.assign(attrs, invalid(syntax, 'argument', 'Invalid argument'));
   }
-  return attrs;
+  return [attrs, remains];
 }
 
 // https://developer.mozilla.org/en-US/docs/Web/HTML/Element

package/src/parser/inline/link.ts

@@ -135,7 +135,7 @@ function parse(
     context.host?.origin || location.origin);
   return el.classList.contains('invalid')
     ? el
-    : define(el, attributes('link', optspec, params));
+    : define(el, attributes('link', optspec, params)[0]);
 }
 
 function elem(