securemark 0.297.0 → 0.297.2

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 0.297.2
+
+- Refactoring.
+
+## 0.297.1
+
+- Fix note processing.
+
 ## 0.297.0
 
 - Enhance annotation parser to allow nested annotations.

package/design.md

@@ -293,7 +293,7 @@ Securemarkはブロック単位の差分更新によりリアルタイムレン
 
 CommonMarkは初手設計ミスったせいで構文一つで最悪計算量32nを叩き出す最悪計算量O(n\*32^m)のクソ言語になり拡張性がなく終わってる。
 
-SecuremarkのAnnotation構文に典型的であるように文脈を変更する構文の中にその文脈に依存し変更される他の構文が存在する場合文脈の相違から解析結果を再利用不能(`αAβ | αA'B`)なバックトラックが生じる。またこの結果再帰的バックトラックが生じる可能性があり再帰的バックトラックは一般的にメモ化により解決されるがCommonMarkは最小計算量と実行性能を追及するためメモ化を廃止していることからメモ化により性能を低下させてまで文脈依存構文の問題を解決するつもりはないと思われる(すなわちCommonMarkは機械を至上とし人間に制約を課す低水準の言語であり人間の需要と生産性を至上とする高水準の言語であるSecuremarkの対極に位置する)。従ってCommonMarkは再帰的バックトラックなしで解析可能な構文と最小計算量に制約され基本的に再帰的バックトラックが生じるものである文脈依存構文を追加できないという拡張性の欠陥が存在する(CommonMarkは文脈を変えず`*A*`の記号と解釈を変更しただけの`~~A~~`のような文脈自由構文は容易に追加できるが他の構文を包含可能な文脈依存構文はリンク構文で発生している再帰的バックトラックまたはその修正のために激増した計算量を組み合わせ爆発により指数関数的に致命的に悪化させるため追加できない。例えばすでに最悪計算量32nであるリンク構文を包含した追加構文が1回バックトラックするだけで最悪計算量が32n\*2=64nに悪化し追加構文がリンク構文と同じく最悪計算量32nなら全体の最悪計算量は32n\*32=n\*32^2=1024nとなる。すなわちCommonMarkの最悪計算量は再帰的バックトラックが生じる構文の数mに対してO(n\*32^m)と驚異的かつ絶望的に劣悪な計算量であり構文数が一つであろうと自己再帰可能ならば入れ子数mに対して同じくO(n\*32^m)となる。なお一般的に実用可能な計算量の上限はO(n^3)であるためCommonMarkは文脈依存構文数または入れ子数m>3になるだけで実用可能な計算量の上限を超える。すなわちCommonMarkは自己再帰可能な文脈依存構文を定義することが不可能である。この事実に開発開始から数年後に直面し再帰数の上限を32回に制限することで指数計算量を防ぐも依然として32nという非常識な計算量になっているのがリンク構文とイメージ構文である。なおリンク構文とイメージ構文を入れ子にできているのはイメージ構文を入れる角括弧部分が文脈自由部分だからであり文脈依存部分である丸括弧部分は入れ子になっておらず文脈依存部分の入れ子が生じていないからである。しかし文脈依存構文を追加してリンク構文を包含すれば丸括弧部分を包含し文脈依存部分が入れ子になり計算量の爆発を避けられない)。CommonMarkの仕様策定者が構文の拡張に(名称を維持するか否かにかかわらず)不自然なまでに消極的であり進展がないのは正当な理由や単なる怠慢からでなく構文追加可否を議論すればCommonMarkは理論的欠陥により最悪計算量が絶望的に劣悪であるため文脈依存構文を追加できないというCommonMarkの設計の破綻と失敗が明らかになることが避けられないためおよび最小計算量を放棄して現在の高い実行性能を低下させたくないためであり陳腐な自尊心を守るためにこのような計算量と拡張性の根本的欠陥を秘匿しCommonMarkとその仕様策定者である自分の評価が下がらないよう画策しているからである。でなければこの計算量と拡張性の根本的欠陥を何年も隠蔽せず速やかに公表して助力を求めていなければならず不都合な事実を隠し陳腐な自尊心を守るために全Markdown利用者および開発者を不必要に足止めした罪は重い。
+SecuremarkのReference構文に典型的であるように文脈を変更する構文の中にその文脈に依存し変更される他の構文が存在する場合文脈の相違から解析結果を再利用不能(`αAβ | αA'B`)なバックトラックが生じる。またこの結果再帰的バックトラックが生じる可能性があり再帰的バックトラックは一般的にメモ化により解決されるがCommonMarkは最小計算量と実行性能を追及するためメモ化を廃止していることからメモ化により性能を低下させてまで文脈依存構文の問題を解決するつもりはないと思われる(すなわちCommonMarkは機械を至上とし人間に制約を課す低水準の言語であり人間の需要と生産性を至上とする高水準の言語であるSecuremarkの対極に位置する)。従ってCommonMarkは再帰的バックトラックなしで解析可能な構文と最小計算量に制約され基本的に再帰的バックトラックが生じるものである文脈依存構文を追加できないという拡張性の欠陥が存在する(CommonMarkは文脈を変えず`*A*`の記号と解釈を変更しただけの`~~A~~`のような文脈自由構文は容易に追加できるが他の構文を包含可能な文脈依存構文はリンク構文で発生している再帰的バックトラックまたはその修正のために激増した計算量を組み合わせ爆発により指数関数的に致命的に悪化させるため追加できない。例えばすでに最悪計算量32nであるリンク構文を包含した追加構文が1回バックトラックするだけで最悪計算量が32n\*2=64nに悪化し追加構文がリンク構文と同じく最悪計算量32nなら全体の最悪計算量は32n\*32=n\*32^2=1024nとなる。すなわちCommonMarkの最悪計算量は再帰的バックトラックが生じる構文の数mに対してO(n\*32^m)と驚異的かつ絶望的に劣悪な計算量であり構文数が一つであろうと自己再帰可能ならば入れ子数mに対して同じくO(n\*32^m)となる。なお一般的に実用可能な計算量の上限はO(n^3)であるためCommonMarkは文脈依存構文数または入れ子数m>3になるだけで実用可能な計算量の上限を超える。すなわちCommonMarkは自己再帰可能な文脈依存構文を定義することが不可能である。この事実に開発開始から数年後に直面し再帰数の上限を32回に制限することで指数計算量を防ぐも依然として32nという非常識な計算量になっているのがリンク構文とイメージ構文である。なおリンク構文とイメージ構文を入れ子にできているのはイメージ構文を入れる角括弧部分が文脈自由部分だからであり文脈依存部分である丸括弧部分は入れ子になっておらず文脈依存部分の入れ子が生じていないからである。しかし文脈依存構文を追加してリンク構文を包含すれば丸括弧部分を包含し文脈依存部分が入れ子になり計算量の爆発を避けられない)。CommonMarkの仕様策定者が構文の拡張に(名称を維持するか否かにかかわらず)不自然なまでに消極的であり進展がないのは正当な理由や単なる怠慢からでなく構文追加可否を議論すればCommonMarkは理論的欠陥により最悪計算量が絶望的に劣悪であるため文脈依存構文を追加できないというCommonMarkの設計の破綻と失敗が明らかになることが避けられないためおよび最小計算量を放棄して現在の高い実行性能を低下させたくないためであり陳腐な自尊心を守るためにこのような計算量と拡張性の根本的欠陥を秘匿しCommonMarkとその仕様策定者である自分の評価が下がらないよう画策しているからである。でなければこの計算量と拡張性の根本的欠陥を何年も隠蔽せず速やかに公表して助力を求めていなければならず不都合な事実を隠し陳腐な自尊心を守るために全Markdown利用者および開発者を不必要に足止めした罪は重い。
 CommonMarkは小さく単純であるうちだけ破綻せずに正しく見せかけられる象牙の塔であり仕様策定者はこの見せかけの正しさを失わず正しいままでいたいがために象牙の塔に引きこもり小さな表面的正しさに固執し続けているに過ぎない。しかしCommonMarkは実際にはすでに致命的に破綻しており本来文脈依存言語であるMarkdownを文脈自由言語として解析しようとして失敗したことで指数計算量(正確には指数計算量より悪い階乗計算量)になっており実際のところCommonMarkは最初から最後までずっと壊れている。CommonMarkは可能な限り文脈自由言語として設計することでバックトラックなく最小計算量で解析しようとしているが実際には文脈依存言語であるMarkdownから文脈依存構文を文脈自由構文に変換して再帰的バックトラックを除去することに失敗しているためCommonMarkは最初の数年間は再帰的バックトラックに気づかず最悪計算量が指数計算量になっており修正後も依然として最悪計算量が当初の想定の1nから32nへと劇的に悪化している(より正確にはCommonMarkは少なくともCode構文とHTML構文により+2nされるが説明の簡略化のため省略しこれら以外のInline構文のみを比較する)。CommonMarkが最初の数年間他人に指摘され修正されるまで指数計算量であった事実(https://github.com/commonmark/cmark/commit/45f4fc9b917c11221aa03e70a41e3046335a235d)はCommonMarkが初歩的な再帰的バックトラックの原理すら理解していないド素人により設計された素人仕事である事実を証明しておりたかが強調構文の解析のためにメモ化を行い(https://github.com/commonmark/commonmark.js/commit/6d7d6cf150dedb53b7f0972b79313df3364ebbed https://github.com/commonmark/commonmark.js/blob/ac8529c9f55da7fdc1186e3f34313cf411de6e71/js/stmd.js )他人にメモ化を使わない正しい実装に修正された事実(https://github.com/commonmark/commonmark.js/commit/8837f199608ac2e321f75653736747b1e692072f)もまたCommonMarkの仕様策定者がその任に堪える能力のないド素人である事実を証明している。スタックを使う代わりにメモ化するド素人の能力を誰が擁護できるのか？ド素人が作った結果初歩的な再帰的バックトラックすら他人に指摘されるまで気づかず修正後も最悪計算量が32nにまで著しく悪化した設計が正しいと言えるのか？不可能である。一貫してド素人により設計開発仕様策定されているCommonMarkは仕様策定が停滞し未だに1nの最小計算量に固執しているがそんなものはCommonMarkの破綻と失敗が露呈するを恐れて隠蔽しまたとっくの昔に破綻している最小計算量のための設計に未練がましく執着しているだけである。32nという最悪計算量は適切に設計し計算量が抑制された文脈依存言語の最悪計算量より悪く最初から文脈依存言語として適切に設計するほうが自然で破綻がなく拡張性を確保できていた。たった一つの構文だけで最悪計算量が32nも増加するクソ言語に拡張性がないことは明らかである。さらにSecuremarkは再帰的バックトラックを予め対策して設計されているため文脈依存構文数が増えても最悪計算量はたかだか構文数に比例して線形にしか増加しないのに対してCommonMarkは再帰的バックトラックに根本的対策を取れないため文脈依存構文数が増えると最悪計算量が指数関数的に致命的に爆発する。または計算量を組み合わせ爆発させないために文脈依存構文の入れ子使用を制限する、存在自体が破綻と失敗の宣言に等しい制限が必要になる。文脈依存構文を強引に文脈自由構文として解析しようとして失敗したために最悪計算量が当初の想定の1nから32nに劇的に悪化し結局文脈依存言語の妥当な最悪計算量より悪い水準に落ちていることおよび文脈依存構文を追加すると最悪計算量が指数関数的に悪化することから文脈自由化に失敗したCommonMarkの破綻と失敗は明らかでありCommonMarkは文脈自由構文に固執せず最初から多少の文脈依存構文を許容するよう設計しなければならなかった。実際には文脈依存言語であるにもかかわらず文脈自由言語の範囲でしか構文解析できなければ構文解析が破綻し構文が増えるほど破綻が拡大することは自明でありすでに破綻済みで失敗済みのCommonMarkに未来などない。文脈依存言語であるMarkdownに対して文脈自由構文解析器として作られたCommonMarkは最初から開発戦略と技術選択を間違え失敗しており最初から破綻していた。CommonMarkが文脈依存言語を文脈自由言語として最小計算量で解析するために使用した手法は邪道の小手先の技術に過ぎずCommonMarkは邪道を選んだ挙句失敗に終わったのである。文脈依存言語を文脈依存言語のまま解析する正道を選んだSecuremarkが正着し文脈依存言語を文脈自由言語に歪める邪道を選んだCommonMarkが失着に終わったのは当然の帰結であり最初の解析戦略時選択の時点で決まっていたことである。文脈依存言語であるMarkdownを文脈自由言語として解析しようとした結果行き詰ったCommonMarkとその閉塞に技術的合理性はなくCommonMarkは最初からの失敗していた過去の遺物であり廃棄すべき負債である。CommonMarkに動きがないのはすでに破綻しており死んでいることに気付かれないように死んでいるからに過ぎない。このようにCommonMarkは完全に破綻し失敗に終わっているためCommonMarkの拡張や発展を期待しても無駄であり既存の文脈依存構文の最悪計算量を健全化し新たに文脈依存構文を追加可能な拡張性の高いMarkdown仕様は新しく作り直さなければ作れない。しかしCommonMarkの仕様策定者は独自の新しい仕様においても依然としてMarkdownを文脈自由化して文脈自由言語として設計しているため文脈依存構文を追加すると指数計算量になり救いようがない。しかもその構文と仕様は機械可読性を至上としているため非常に醜く人間が書くことも読むことも困難で人間に対する実用性が欠如している。
 Securemarkはスーパークラス構文が解析に失敗した入力をサブクラス構文で解析しないことにより再帰的バックトラックを回避する(解析中の構文自身はスーパークラスとサブクラスの両方に含まれるものとする)。スーパークラス構文A(`αAβ`)の解析が失敗すればサブクラス構文B(`α'Aβ'`)の解析も失敗することは自明であり試みるまでもなく解析を省略できる。これは二つの構文の文法が生成する各言語空間がスーパーセットとサブセットの関係にあるならスーパーセットの言語空間の外にある文字列はサブセットの言語空間の内に入る余地がないことからも自明である(この解析法は事前解析によっても可能だが文脈内外のオートリンクURLの括弧解析などを高速に行うこともバックトラックなしで解析することも困難であり本解析に近い解析コストを要するためMarkdownをこの事前解析により高速化することは難しい)。メモ化は解析結果の再利用による高速化の副次的または追加的効果として再帰的バックトラックを回避しているのでありメモ化は再帰的バックトラックを回避するだけなら過剰であり不要である(メモ化はバックトラックがなければ使用されないためバックトラックが少ないほとんどの入力に対してはほとんど使用されず無駄であり空間計算量を不必要に常時数倍以上増加させることから構文解析において必須にも標準にもできない。再帰的バックトラック回避のためにメモ化するとバックトラックなしで解析可能な場合も常に不必要に空間計算量が増加し平均計算量が有意に悪化することがメモ化の最大の欠点である(この問題は解析失敗時のみメモ化すれば解消可能のはずだが基本的にはこうなる)。特に文脈自由構文解析器におけるメモ化の使用は完全に無駄でありバグである。バックトラックが発生しないか他の方法で解決されるならば使用されず破棄されるメモ化は無駄である。複数の文脈で解析結果が同一である文脈独立性のある構文ならメモ化した解析結果を異なる文脈で再利用でき有用だがそのような構文は基本的に少数であるため効果が限定的であり最悪計算量は改善されない。文脈依存構文の解析を困難にするメモ化のコストの重さは解析に本来不要な高速化のために生じておりメモ化からバックトラックがない通常時も常時高コストで低速化し平均実行速度とスループットを低下させるバックトラック時限定の不要な高速化とこのためのコストを除去すれば再帰的バックトラック回避機能だけを低コストで標準的に使用しこれまで高コストであったため敷居が高く使用困難であった文脈依存言語を低コストで手軽に定義および解析できるようになる。もうCommonMarkのように低機能のくせに最悪計算量が劣悪で拡張不能なクソ言語を我慢して使い続けなくてよくなるのである)。この解析法により、CommonMarkならば最悪計算量がn\*32^5=33,554,432nとなる拡張Markdown言語をSecuremarkはメモ化なしで5nの最悪時間計算量で解析している。言語差を考慮せず直接比較してさえ単純なCommonMarkの最悪計算量32nに対して複雑なSecuremarkは5nに過ぎずSecuremarkはCommonMarkより最悪計算量が非常に小さい。またSecuremarkはメモ化を行っていないため空間計算量も小さい。時間計算量と空間計算量を合わせてO(n, n)と表記すると文脈依存言語の通常の最悪計算量はO(n^2, n)、メモ化により効率化できた場合もO(nm, nm)(S(m)>=m byte)(解析結果の位置や構文木等を記録するため空間使用量S(m)>はm byte以上となり数値一つやポインタ一つだけでも8byteを消費する)に過ぎないがSecuremarkのマーキング法はO(nm, nm)(S(m)=m bit)(解析の失敗フラグしか記録しないためS(m)=m bit。また包含文字列を含め全体でn byteの構文1つに対して解析結果の構文木を保持するメモ化は少なくとも構文木のサイズn byteを消費するがマーキング法のメモリ消費量は構文全体のサイズにかかわらず1bit固定である。よって100KBの構文1つに対してメモ化は100KB以上消費するがこの場合もマーキング法は1bitしか消費しない。なお成功フラグによる解析は成功フラグがないのが失敗したからか未到達だからかを判別するための情報と処理が追加で必要になり処理が複雑化しさらに成功フラグは解析のほとんどを占める成功した解析に対してメモリ消費と追加処理が発生し解析効率が全体として悪化するが失敗フラグは少数の失敗した解析でしか解析効率が悪化しないため失敗フラグを記録するほうが全体および平均として解析効率が高く優れている)と極めて効率的であり最も優れている。以上のようにSecuremarkの構文解析アルゴリズムの優位性は理論と実践いずれにおいても圧倒的である。現在のSecuremarkは開発効率と安全性優先の実装により実行性能が大きく低下しているがクライアントで個別のユーザーの操作に応じるには十分高速であるためクライアントで解析するなら解析の効率または速度が実用上問題となることはなく仕様が固まり実行効率優先の高速な実装に移れば他の環境での懸念もないだろう。またSecuremarkの再帰数制限はパーサーコンビネーターの使用による再帰的関数呼び出しに対する実装方式依存の制限であるため計算量と無関係であり再帰的関数呼び出しが生じないよう書き換えれば再帰数制限もない。従ってCommonMarkは再帰上限数と最悪計算量が一致し再帰上限数32回と最悪計算量32nが一致するがSecuremarkの最悪計算量は再帰上限数が100回だろうと100万回だろうと5n固定である。SecuremarkをCommonMarkのような再帰数制限のない実装に変換することは設計上および理論的に何の問題もないがCommonMarkをSecuremarkのような正常な文脈依存言語解析器に変更することは現在の異常な解析規則の破壊的変更による修正なしに不可能である。具体的には二重リンク`[[]()]()`を解析するときCommonMarkはバックトラックと計算量を最小化すべく文脈自由構文解析器として設計されているためリンク構文内をリンク構文が定義されていない異なる文脈として解析せず外側のリンク構文の解析を破棄して内側のみリンク構文として解析するがSecuremarkは文脈依存構文解析器とし設計されているためリンク構文内にリンク構文が定義されておらず外側のみリンクとして解析し他のMarkdown構文解析器もこのように解析しなければならない(ここでCommonMarkはリンク構文`[]()`のバックトラック除去ひいては文脈自由化に角括弧部分`[]`に対しては成功したが丸括弧部分`()`に対しては失敗したことで最悪計算量が指数計算量ないし32nに悪化した。リンク構文を本来通り文脈依存構文として解析すればリンク構文の最悪計算量が2nとなり角括弧部分に限っては1nから2nに悪化するが丸括弧部分は32nから2nに著しく改善する。ここがCommonMarkの根本的な欠陥と失敗が最も明瞭に表出している部分である)。この問題はイメージ構文においてさらに顕著でありリンク構文と同じ問題が正当な表現`![![]()]()`で発生しさらにHTMLのaltはプレーンテキストとして表示されるためMarkdownのaltもプレーンテキストとしてそのまま表示されなければならないにもかかわらず文脈を一致させ再帰的バックトラックを防ぐためにMarkdown文字列として解析しaltに`*a*`と書かれたものを`a`に不正に変換して表示する。無論新しい文脈依存構文を追加する場合も同じ制約が永遠についてまわり構文内文字列をMarkdownとして解析する文脈依存構文においてこの制約を破ると最悪計算量が32\*2^mないし32^mで指数関数的に増加する。すなわちCommonMarkは文脈依存構文を追加すると最悪計算量が32\*2^mないし32^mで指数関数的に悪化するという拡張性の致命的欠陥が存在する。こんな最悪計算量が32^mで組み合わせ爆発する欠陥言語を拡張できるわけがないことはもはや明白である。また大多数のプログラミング言語を見ても明らかなように文脈依存言語は構文内で使用可能な構文を定義しその他の構文は使用できず例外処理するのが通常でありCommonMarkのように本来使用不能な構文を外側の構文を無効化して使用可能に変える異常な言語はほとんどの人間はCommonMark以外に見たことがないだろう。ほぼすべての人間において他のすべての言語が同じ一貫した規則を持ち同じ規則で統一的に使用できるのに対してCommonMarkだけが他と異なる異常な挙動をして使用者に認知的負荷をかけるのである。破壊的変更を避けるため旧構文だけ従来通り文脈自由構文として解析し新構文を文脈依存構文として解析すればキメラ的な非常に不自然かつ歪で一貫性のない解析規則によりCommonMarkという一つの言語の中だけでもユーザーを混乱させるものとなり旧構文で使用した苦肉の策を不必要に新構文でも使用して一貫させれば文脈依存言語なのに文脈自由言語の苦肉の策の解析規則で解析されるこれもまたキメラ的な非常に不自然かつ理論的に設計ミスが明白で実用的にも認知的負荷の高い言語となる。正しく設計された言語と解析器にはありえないこのような解析規則の根本的不整合はその不整合の存在そのものが言語と解析器が誤った設計による失敗作であることを証明しており不整合が存在する限りその不整合により自らが失敗作であることを宣言し続けることになる。CommonMarkとはそういう失敗した言語と解析器なのである。このようにCommonMarkは新構文だけまたは解析器だけ文脈依存に変更しても理論的齟齬が解析結果と使用感の不自然さと違和感に明白に表れるためCommonMarkが失敗した言語である事実は到底隠し切れるものではない。Markdownはもはや負債以外の何物でもないCommonMarkの異常な解析規則を捨てて素直な文脈依存構文言語として新しい仕様を作り直すのが賢明である。
 文脈依存言語を再帰的バックトラックなしで解析可能な方法は2つある。一つは解釈を予言的に決定する方法、もう一つは予備的または中間的その他事前の解析結果に対する解釈を事後に決定する方法である。前者は構文を峻別するための制約が強く後者は共通構造の適切な設計が必要でありいずれも再帰的バックトラックを防ぐために未終端の構文も受理する必要がある。しかし予言的解析は類似の異文脈構文へのバックトラックが不可能になるため共通構造についての事前解析結果のような追加情報を利用できるのでなければ類似の異文脈構文の定義が不可能になる。また共通構造をバックトラックなしで解析するにはそのための言語設計が必要であることに変わりなく任意の文字列を使用可能である必要があるURL、コード、数式などに含まれる任意の文字列が他の構文と文脈で解釈される際に共通構造を破壊するためこのような文字列を構造的に決定的に解釈する基本構造(バックトラック可能だが入力に対する解析結果がすべての文脈で構造的に共通すなわち決定的でなければならない。構文が解析されない場合も構文全体が包含されれば問題ない)を共通構造に定義しなければ構造的共通化は不可能であり分離構造は終端不要な開放可能構文としての予言的構文でなければバックトラックが不可避となる。共通構造の事前解析は一見すると最悪計算量を2nに削減できるように見えるが実際には共通構造をバックトラックなしで解析することが元の言語より容易にはなっても依然として難しくバックトラックなしで解析できたとしてもすべての解析ひいては平均計算量が+1nされるため平均的にはむしろ計算量を悪化させる方法であり仮に最悪計算量32nを事前解析により2nに抑えられたとしても平均計算量が1nならば平均計算量が2nに倍加し実行性能が半減および実行コストが倍加するため明らかに事前解析を行うべきでない。実用的なアルゴリズムの計算量において重要なのは最悪計算量がO(n^3)相当以下の実用的な計算量であるかと平均計算量でありその他は重要ではない。メモ化が空間計算量を代償に悪化させる最悪時間計算量線形化手法であるのに対して事前解析は平均時間計算量を代償に悪化させる最悪時間計算量線形化手法でありマーキング法は何も代償に悪化させない最悪時間計算量線形化手法である(無論ゼロコストではないが解析の他の部分やASTに要するコストより小さいため無視できる。空間計算量は実際にはASTにより容易に数倍になりメモリ使用量は入力サイズと並列数に制約されるため空間計算量自体はさほど重要ではなく空間計算量を増加させる処理により生じる時間オーバーヘッドのほうが本質的に重要となる。メモ化が常時記録かつ実データ記録ゆえデータ数もデータサイズも大きいのに対してマーキング法は失敗時記録かつフラグのみ記録ゆえデータ数もデータサイズも小さいことでオーバーヘッドが最小化されバックトラック率の低い入力が大多数を占める場合の平均実行速度が高速化される。平均性能すなわち重要指標が向上するならばその他の指標は許容範囲内で悪化させることができ不要な指標値を必要な指標値に変換できるならばそうしなければならない)。なおマーキング法を使用するSecuremarkは本来の構文解析と共通構造解析を統合し同時解析することで計算量の増加なく共通構造解析を行い共通構造を利用して最悪時間計算量を指数計算量から5nへ削減している。

package/dist/index.js

@@ -1,4 +1,4 @@
-/*! securemark v0.297.0 https://github.com/falsandtru/securemark | (c) 2017, falsandtru | UNLICENSED License */
+/*! securemark v0.297.2 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"));
@@ -4302,6 +4302,12 @@ function bind(target, settings) {
         type: 'cancel'
       };
     }
+    yield {
+      type: 'break'
+    };
+    if (rev !== revision) return yield {
+      type: 'cancel'
+    };
     for (const el of (0, figure_1.figure)(next(0)?.parentNode ?? target, settings.notes, context)) {
       el ? yield {
         type: 'figure',
@@ -6323,7 +6329,7 @@ const bracket_1 = __webpack_require__(4526);
 const visibility_1 = __webpack_require__(6364);
 const util_1 = __webpack_require__(4992);
 const dom_1 = __webpack_require__(394);
-exports.annotation = (0, combinator_1.lazy)(() => (0, combinator_1.constraint)(128 /* State.annotation */, (0, combinator_1.surround)((0, combinator_1.close)('((', visibility_1.beforeNonblank), (0, combinator_1.precedence)(1, (0, combinator_1.recursion)(4 /* Recursion.inline */, (0, combinator_1.recursion)(5 /* Recursion.bracket */, (0, combinator_1.recursion)(5 /* Recursion.bracket */, (0, combinator_1.some)((0, combinator_1.union)([inline_1.inline]), ')', [[')', 1]]))))), '))', false, [], ([, ns], context) => {
+exports.annotation = (0, combinator_1.lazy)(() => (0, combinator_1.constraint)(128 /* State.annotation */, (0, combinator_1.surround)((0, combinator_1.open)('((', visibility_1.beforeNonblank), (0, combinator_1.precedence)(1, (0, combinator_1.recursion)(4 /* Recursion.inline */, (0, combinator_1.recursion)(5 /* Recursion.bracket */, (0, combinator_1.recursion)(5 /* Recursion.bracket */, (0, combinator_1.some)((0, combinator_1.union)([inline_1.inline]), ')', [[')', 1]]))))), '))', false, [], ([, ns], context) => {
   const {
     linebreak
   } = context;
@@ -7123,22 +7129,8 @@ function baseR(n, r) {
   return acc;
 }
 function signature(target) {
-  for (let es = target.querySelectorAll('code[data-src], .math[data-src], .remark, rt, rp, br, .annotation, .reference, .checkbox, ul, ol, .label[data-label]'), len = es.length, i = 0; i < len; ++i) {
+  for (let es = target.querySelectorAll('code[data-src], .math[data-src], .remark, rt, rp, br, .annotation, .reference, :is(.annotation, .reference) > a, .checkbox, ul, ol, .label[data-label]'), len = es.length, i = 0; i < len; ++i) {
     const el = es[i];
-    switch (el.tagName) {
-      case 'CODE':
-        el.replaceWith(el.getAttribute('data-src'));
-        continue;
-      case 'RT':
-      case 'RP':
-      case 'UL':
-      case 'OL':
-        el.remove();
-        continue;
-      case 'BR':
-        el.replaceWith('\n');
-        continue;
-    }
     switch (el.className) {
       case 'math':
         el.replaceWith(el.getAttribute('data-src'));
@@ -7153,25 +7145,28 @@ function signature(target) {
         el.remove();
         continue;
     }
-  }
-  return target.textContent.trim();
-}
-exports.signature = signature;
-function text(target) {
-  for (let es = target.querySelectorAll('code[data-src], .math[data-src], .remark, rt, rp, br, .annotation, .reference, .checkbox, ul, ol'), len = es.length, i = 0; i < len; ++i) {
-    const el = es[i];
     switch (el.tagName) {
       case 'CODE':
         el.replaceWith(el.getAttribute('data-src'));
         continue;
-      case 'RT':
-      case 'RP':
-      case 'BR':
       case 'UL':
       case 'OL':
+      case 'RT':
+      case 'RP':
+      case 'A':
         el.remove();
         continue;
+      case 'BR':
+        el.replaceWith('\n');
+        continue;
     }
+  }
+  return target.textContent.trim();
+}
+exports.signature = signature;
+function text(target) {
+  for (let es = target.querySelectorAll('code[data-src], .math[data-src], .remark, rt, rp, br, .annotation, .reference, :is(.annotation, .reference) > a, .checkbox, ul, ol'), len = es.length, i = 0; i < len; ++i) {
+    const el = es[i];
     switch (el.className) {
       case 'math':
         el.replaceWith(el.getAttribute('data-src'));
@@ -7183,6 +7178,19 @@ function text(target) {
         el.remove();
         continue;
     }
+    switch (el.tagName) {
+      case 'CODE':
+        el.replaceWith(el.getAttribute('data-src'));
+        continue;
+      case 'UL':
+      case 'OL':
+      case 'RT':
+      case 'RP':
+      case 'A':
+      case 'BR':
+        el.remove();
+        continue;
+    }
   }
   return target.textContent;
 }
@@ -7484,7 +7492,7 @@ const optspec = {
   rel: ['nofollow']
 };
 Object.setPrototypeOf(optspec, null);
-exports.textlink = (0, combinator_1.lazy)(() => (0, combinator_1.bind)((0, combinator_1.subsequence)([(0, combinator_1.constraint)(8 /* State.link */, (0, combinator_1.state)(251 /* State.linkers */, (0, combinator_1.dup)((0, combinator_1.surround)((0, combinator_1.close)('[', visibility_1.beforeNonblank), (0, combinator_1.precedence)(1, (0, combinator_1.some)((0, combinator_1.union)([inline_1.inline]), ']', [[']', 1]])), ']', true, [3 | 4 /* Backtrack.common */ | 64 /* Backtrack.link */, 2 | 32 /* Backtrack.ruby */], ([, ns = new parser_1.List()], context) => {
+exports.textlink = (0, combinator_1.lazy)(() => (0, combinator_1.bind)((0, combinator_1.subsequence)([(0, combinator_1.constraint)(8 /* State.link */, (0, combinator_1.state)(251 /* State.linkers */, (0, combinator_1.dup)((0, combinator_1.surround)((0, combinator_1.open)('[', visibility_1.beforeNonblank), (0, combinator_1.precedence)(1, (0, combinator_1.some)((0, combinator_1.union)([inline_1.inline]), ']', [[']', 1]])), ']', true, [3 | 4 /* Backtrack.common */ | 64 /* Backtrack.link */, 2 | 32 /* Backtrack.ruby */], ([, ns = new parser_1.List()], context) => {
   if (context.linebreak !== 0) {
     const head = context.position - context.range;
     return void (0, combinator_1.setBacktrack)(context, 2 | 64 /* Backtrack.link */ | 32 /* Backtrack.ruby */, head);
@@ -8273,19 +8281,19 @@ function* note(target, notes, opts = {}, bottom = null) {
   yield* (0, exports.reference)(target, notes?.references, opts, bottom);
 }
 exports.note = note;
-exports.annotation = build('annotation', 'sup.annotation:not(.annotations .annotation)', n => `*${n}`, 'h1, h2, h3, h4, h5, h6, aside.aside, hr');
-exports.reference = build('reference', 'sup.reference:not(.references .reference)', (n, abbr) => `[${abbr || n}]`);
+exports.annotation = build('annotation', 'annotations', n => `*${n}`, 'h1, h2, h3, h4, h5, h6, aside.aside, hr');
+exports.reference = build('reference', 'references', (n, abbr) => `[${abbr || n}]`);
 // Referenceを含むAnnotationの重複排除は両構文が互いに処理済みであることを必要とするため
 // 構文ごとに各1回の処理では不可能
-function build(syntax, query, marker, splitter = '') {
-  splitter &&= `${splitter}, .${syntax}s`;
+function build(syntax, plural, marker, splitter = '') {
+  splitter &&= `${splitter}, .${plural}`;
   const refMemoryCaller = (0, memoize_1.memoize)(target => new Map() ?? target, new WeakMap());
   return function* (target, note, opts = {}, bottom = null) {
     const refMemory = refMemoryCaller(target);
     const refInfoCaller = (0, memoize_1.memoize)(ref => {
       const content = ref.firstElementChild;
       const abbr = ref.getAttribute('data-abbr') ?? '';
-      const clone = content.cloneNode(true);
+      const clone = ref.cloneNode(true);
       const txt = (0, indexee_1.text)(clone).trim();
       const identifier = abbr ? (0, indexee_1.identity)('', undefined, abbr.match(/^(?:\S+ )+?(?:(?:January|February|March|April|May|June|August|September|October|November|December) \d{1,2}(?:-\d{0,2})?, \d{1,4}(?:-\d{0,4})?[a-z]?|n\.d\.)(?=,|$)/)?.[0] ?? abbr.match(/^[^,\s]+(?:,? [^,\s]+)*?(?: \d{1,4}(?:-\d{0,4})?[a-z]?(?=,|$)|(?=,(?: [a-z]+\.?)? [0-9]))/)?.[0] ?? abbr)?.slice(2) || '' : (0, indexee_1.identity)('mark', undefined, (0, indexee_1.signature)(clone))?.slice(6) || '';
       return {
@@ -8298,12 +8306,11 @@ function build(syntax, query, marker, splitter = '') {
     for (const [ref, {
       content
     }] of refMemory) {
-      content.replaceWith(content.cloneNode(true));
-      ref.prepend(content);
-      refMemory.delete(ref);
+      ref.replaceChildren(content);
     }
+    refMemory.clear();
     const defs = new Map();
-    const refs = target.querySelectorAll(`${query}:not(.disabled)`);
+    const refs = target.querySelectorAll(`.${syntax}:not(.disabled)`);
     const identifierInfoCaller = (0, memoize_1.memoize)(identifier => ({
       defIndex: 0,
       defSubindex: 0,
@@ -8329,7 +8336,7 @@ function build(syntax, query, marker, splitter = '') {
         if (defs.size > 0) {
           total += defs.size;
           const note = el.tagName === 'OL' ? el : target.insertBefore((0, dom_1.html)('ol', {
-            class: `${syntax}s`
+            class: plural
           }), el);
           yield* proc(defs, note);
         }
@@ -8394,7 +8401,7 @@ function build(syntax, query, marker, splitter = '') {
     if (note || defs.size > 0) {
       const el = splitters[iSplitters];
       note ??= el?.tagName === 'OL' && el.nextElementSibling == splitters[iSplitters + 1] ? (++iSplitters, el) : target.insertBefore((0, dom_1.html)('ol', {
-        class: `${syntax}s`
+        class: plural
       }), splitters[iSplitters] ?? bottom);
       yield* proc(defs, note);
     }
@@ -8411,30 +8418,13 @@ function* proc(defs, note) {
   const {
     children
   } = note;
-  const size = defs.size;
-  let count = 0;
-  let length = children.length;
-  I: for (const [key, def] of defs) {
-    defs.delete(key);
-    ++count;
-    for (; length > size;) {
-      const node = children[count - 1];
-      if (equal(node, def)) continue I;
-      yield note.removeChild(node);
-      --length;
-    }
-    const node = count <= length ? children[count - 1] : null;
-    if (node && equal(node, def)) continue;
-    yield note.insertBefore(def, node);
-    ++length;
-  }
-  for (; length > size;) {
-    yield note.removeChild(children[size]);
-    --length;
+  for (let defs = note.children, i = defs.length; i--;) {
+    yield note.removeChild(children[i]);
   }
-}
-function equal(a, b) {
-  return a.id === b.id && a.innerHTML === b.innerHTML;
+  for (const [, def] of defs) {
+    yield note.appendChild(def);
+  }
+  defs.clear();
 }
 
 /***/ },

package/package.json

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

package/src/parser/api/bind.ts

@@ -124,6 +124,8 @@ export function bind(target: DocumentFragment | HTMLElement | ShadowRoot, settin
       yield { type: 'block', value: el };
       if (rev !== revision) return yield { type: 'cancel' };
     }
+    yield { type: 'break' };
+    if (rev !== revision) return yield { type: 'cancel' };
     for (const el of figure(next(0)?.parentNode ?? target, settings.notes, context)) {
       assert(rev === revision);
       el

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

@@ -12,7 +12,7 @@ describe('Unit: parser/inline/annotation', () => {
       assert.deepStrictEqual(inspect(parser, input('', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('(', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('()', new Context())), undefined);
-      assert.deepStrictEqual(inspect(parser, input('((', new Context())), [['<span class="paren">(<span class="paren">(</span></span>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('((', new Context())), undefined);
       assert.deepStrictEqual(inspect(parser, input('(())', new Context())), [['<span class="paren">(<span class="paren">(</span></span>'], '))']);
       assert.deepStrictEqual(inspect(parser, input('(()))', new Context())), [['<span class="paren">(<span class="paren">(</span></span>'], ')))']);
       assert.deepStrictEqual(inspect(parser, input('(("))', new Context())), [['<span class="paren">(<span class="paren">("))</span></span>'], '']);

package/src/parser/inline/annotation.ts

@@ -1,7 +1,7 @@
 import { AnnotationParser } from '../inline';
 import { State, Recursion } from '../context';
 import { List, Node } from '../../combinator/data/parser';
-import { union, some, recursion, precedence, constraint, surround, close, lazy } from '../../combinator';
+import { union, some, recursion, precedence, constraint, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { indexA } from './bracket';
 import { beforeNonblank, trimBlankNodeEnd } from '../visibility';
@@ -9,7 +9,7 @@ import { unwrap } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 export const annotation: AnnotationParser = lazy(() => constraint(State.annotation, surround(
-  close('((', beforeNonblank),
+  open('((', beforeNonblank),
   precedence(1, recursion(Recursion.inline, recursion(Recursion.bracket, recursion(Recursion.bracket,
   some(union([inline]), ')', [[')', 1]]))))),
   '))',

package/src/parser/inline/extension/indexee.ts

@@ -109,23 +109,9 @@ assert(baseR(62, 62) === '10');
 export function signature(target: Element | DocumentFragment): string {
   assert(!target.parentNode);
   assert(!target.querySelector('br:not(:has(+ :is(ul, ol)))') || target.nodeName === 'MARK');
-  for (let es = target.querySelectorAll('code[data-src], .math[data-src], .remark, rt, rp, br, .annotation, .reference, .checkbox, ul, ol, .label[data-label]'),
+  for (let es = target.querySelectorAll('code[data-src], .math[data-src], .remark, rt, rp, br, .annotation, .reference, :is(.annotation, .reference) > a, .checkbox, ul, ol, .label[data-label]'),
            len = es.length, i = 0; i < len; ++i) {
     const el = es[i];
-    switch (el.tagName) {
-      case 'CODE':
-        el.replaceWith(el.getAttribute('data-src')!);
-        continue;
-      case 'RT':
-      case 'RP':
-      case 'UL':
-      case 'OL':
-        el.remove();
-        continue;
-      case 'BR':
-        el.replaceWith('\n');
-        continue;
-    }
     switch (el.className) {
       case 'math':
         el.replaceWith(el.getAttribute('data-src')!);
@@ -140,28 +126,31 @@ export function signature(target: Element | DocumentFragment): string {
         el.remove();
         continue;
     }
-  }
-  return target.textContent!.trim();
-}
-
-export function text(target: Element | DocumentFragment): string {
-  assert(!target.parentNode);
-  assert(!target.querySelector('br:not(:has(+ :is(ul, ol)))'));
-  for (let es = target.querySelectorAll('code[data-src], .math[data-src], .remark, rt, rp, br, .annotation, .reference, .checkbox, ul, ol'),
-           len = es.length, i = 0; i < len; ++i) {
-    const el = es[i];
     switch (el.tagName) {
       case 'CODE':
         el.replaceWith(el.getAttribute('data-src')!);
         continue;
-      case 'RT':
-      case 'RP':
-      case 'BR':
       case 'UL':
       case 'OL':
+      case 'RT':
+      case 'RP':
+      case 'A':
         el.remove();
         continue;
+      case 'BR':
+        el.replaceWith('\n');
+        continue;
     }
+  }
+  return target.textContent!.trim();
+}
+
+export function text(target: Element | DocumentFragment): string {
+  assert(!target.parentNode);
+  assert(!target.querySelector('br:not(:has(+ :is(ul, ol)))'));
+  for (let es = target.querySelectorAll('code[data-src], .math[data-src], .remark, rt, rp, br, .annotation, .reference, :is(.annotation, .reference) > a, .checkbox, ul, ol'),
+           len = es.length, i = 0; i < len; ++i) {
+    const el = es[i];
     switch (el.className) {
       case 'math':
         el.replaceWith(el.getAttribute('data-src')!);
@@ -173,6 +162,19 @@ export function text(target: Element | DocumentFragment): string {
         el.remove();
         continue;
     }
+    switch (el.tagName) {
+      case 'CODE':
+        el.replaceWith(el.getAttribute('data-src')!);
+        continue;
+      case 'UL':
+      case 'OL':
+      case 'RT':
+      case 'RP':
+      case 'A':
+      case 'BR':
+        el.remove();
+        continue;
+    }
   }
   return target.textContent!;
 }

package/src/parser/inline/link.ts

@@ -1,7 +1,7 @@
 import { LinkParser } from '../inline';
 import { Context, State, Backtrack, Command } from '../context';
 import { List, Node } from '../../combinator/data/parser';
-import { union, inits, sequence, subsequence, some, consume, precedence, state, constraint, surround, open, close, setBacktrack, dup, lazy, fmap, bind } from '../../combinator';
+import { union, inits, sequence, subsequence, some, consume, precedence, state, constraint, surround, open, setBacktrack, dup, lazy, fmap, bind } from '../../combinator';
 import { inline, media, shortmedia } from '../inline';
 import { attributes } from './html';
 import { str } from '../source';
@@ -18,7 +18,7 @@ Object.setPrototypeOf(optspec, null);
 export const textlink: LinkParser.TextLinkParser = lazy(() => bind(
   subsequence([
     constraint(State.link, state(State.linkers, dup(surround(
-      close('[', beforeNonblank),
+      open('[', beforeNonblank),
       precedence(1,
       some(union([inline]), ']', [[']', 1]])),
       ']',

package/src/parser/processor/note.test.ts

@@ -17,7 +17,7 @@ describe('Unit: parser/processor/note', () => {
     it('1', () => {
       const target = parse('((a b))');
       for (let i = 0; i < 3; ++i) {
-        assert.deepStrictEqual([...annotation(target)].length, i === 0 ? 2 : 1);
+        assert.deepStrictEqual([...annotation(target)].length, i === 0 ? 2 : 3);
         assert.deepStrictEqual(
           [...target.children].map(el => el.outerHTML),
           [
@@ -39,7 +39,7 @@ describe('Unit: parser/processor/note', () => {
     it('2', () => {
       const target = parse('((1))((12345678901234567890))');
       for (let i = 0; i < 3; ++i) {
-        assert.deepStrictEqual([...annotation(target)].length, i === 0 ? 4 : 2);
+        assert.deepStrictEqual([...annotation(target)].length, i === 0 ? 4 : 6);
         assert.deepStrictEqual(
           [...target.children].map(el => el.outerHTML),
           [
@@ -202,7 +202,7 @@ describe('Unit: parser/processor/note', () => {
     it('id', () => {
       const target = parse('((a b))');
       for (let i = 0; i < 3; ++i) {
-        assert.deepStrictEqual([...annotation(target, undefined, { id: '0' })].length, i === 0 ? 2 : 1);
+        assert.deepStrictEqual([...annotation(target, undefined, { id: '0' })].length, i === 0 ? 2 : 3);
         assert.deepStrictEqual(
           [...target.children].map(el => el.outerHTML),
           [
@@ -222,7 +222,7 @@ describe('Unit: parser/processor/note', () => {
     });
 
     it('nest', () => {
-      const target = parse('((a((b))))((a))((b))');
+      const target = parse('((a((b((c))))))((a))((b))');
       for (let i = 0; i < 3; ++i) {
         [...annotation(target)];
         assert.deepStrictEqual(
@@ -249,21 +249,31 @@ describe('Unit: parser/processor/note', () => {
                 ]),
                 html('sup', [
                   html('a', { href: '#annotation::ref:a:1' }, '^1'),
-                  html('a', { href: '#annotation::ref:a:2' }, '^3'),
+                  html('a', { href: '#annotation::ref:a:2' }, '^4'),
                 ])
               ]),
               html('li', { id: 'annotation::def:b:1', 'data-marker': '*2' }, [
                 html('span', [
                   'b',
+                  html('sup', { class: 'annotation', id: 'annotation::ref:c:1', title: 'c' }, [
+                    html('a', { href: '#annotation::def:c:1' }, '*3')
+                  ]),
                 ]),
                 html('sup', [
                   html('a', { href: '#annotation::ref:b:1' }, '^2'),
-                  html('a', { href: '#annotation::ref:b:2' }, '^4'),
+                  html('a', { href: '#annotation::ref:b:2' }, '^5'),
+                ])
+              ]),
+              html('li', { id: 'annotation::def:c:1', 'data-marker': '*3' }, [
+                html('span', [
+                  'c',
+                ]),
+                html('sup', [
+                  html('a', { href: '#annotation::ref:c:1' }, '^3'),
                 ])
               ]),
             ]).outerHTML,
           ]);
-        target.lastChild?.remove();
       }
     });
 
@@ -376,7 +386,6 @@ describe('Unit: parser/processor/note', () => {
               ]),
             ]).outerHTML,
           ]);
-        target.lastChild?.remove();
       }
     });
 

package/src/parser/processor/note.ts

@@ -18,24 +18,24 @@ export function* note(
 
 export const annotation = build(
   'annotation',
-  'sup.annotation:not(.annotations .annotation)',
+  'annotations',
   n => `*${n}`,
   'h1, h2, h3, h4, h5, h6, aside.aside, hr');
 export const reference = build(
   'reference',
-  'sup.reference:not(.references .reference)',
+  'references',
   (n, abbr) => `[${abbr || n}]`);
 
 // Referenceを含むAnnotationの重複排除は両構文が互いに処理済みであることを必要とするため
 // 構文ごとに各1回の処理では不可能
 function build(
-  syntax: 'annotation' | 'reference',
-  query: `${keyof HTMLElementTagNameMap}.${string}`,
+  syntax: string,
+  plural: string,
   marker: (index: number, abbr: string) => string,
   splitter: string = '',
 ) {
   assert(syntax.match(/^[a-z]+$/));
-  splitter &&= `${splitter}, .${syntax}s`;
+  splitter &&= `${splitter}, .${plural}`;
   const refMemoryCaller = memoize((target: Node) =>
     new Map<HTMLElement, {
       readonly content: Element;
@@ -54,7 +54,7 @@ function build(
     const refInfoCaller = memoize((ref: HTMLElement) => {
       const content = ref.firstElementChild!;
       const abbr = ref.getAttribute('data-abbr') ?? '';
-      const clone = content.cloneNode(true);
+      const clone = ref.cloneNode(true);
       const txt = text(clone).trim();
       const identifier = abbr
         ? identity(
@@ -74,13 +74,11 @@ function build(
       };
     }, refMemory);
     for (const [ref, { content }] of refMemory) {
-      content.replaceWith(content.cloneNode(true));
-      ref.prepend(content);
-      refMemory.delete(ref);
+      ref.replaceChildren(content);
     }
-    assert(refMemory.size === 0);
+    refMemory.clear();
     const defs = new Map<string, HTMLLIElement>();
-    const refs = target.querySelectorAll(`${query}:not(.disabled)`);
+    const refs = target.querySelectorAll<HTMLElement>(`.${syntax}:not(.disabled)`);
     const identifierInfoCaller = memoize((identifier: string) => ({
       defIndex: 0,
       defSubindex: 0,
@@ -104,7 +102,7 @@ function build(
         if (~iSplitters << 32 - 8 === 0) yield;
         if (!scope && el.parentNode !== target) continue;
         if (el.tagName === 'OL' && (el.nextElementSibling !== splitters[iSplitters + 1] || defs.size === 0)) {
-          assert(el.matches(`.${syntax}s`));
+          assert(el.matches(`.${plural}`));
           el.remove();
           continue;
         }
@@ -112,7 +110,7 @@ function build(
           total += defs.size;
           const note = el.tagName === 'OL'
             ? el as HTMLOListElement
-            : target.insertBefore(html('ol', { class: `${syntax}s` }), el);
+            : target.insertBefore(html('ol', { class: plural }), el);
           assert(note.parentNode);
           yield* proc(defs, note);
           assert(defs.size === 0);
@@ -188,7 +186,7 @@ function build(
       const el = splitters[iSplitters];
       note ??= el?.tagName === 'OL' && el.nextElementSibling == splitters[iSplitters + 1]
         ? (++iSplitters, el as HTMLOListElement)
-        : target.insertBefore(html('ol', { class: `${syntax}s` }), splitters[iSplitters] ?? bottom);
+        : target.insertBefore(html('ol', { class: plural }), splitters[iSplitters] ?? bottom);
       yield* proc(defs, note);
       assert(defs.size === 0);
     }
@@ -196,7 +194,7 @@ function build(
       if (~iSplitters << 32 - 8 === 0) yield;
       if (!scope && el.parentNode !== target) continue;
       if (el.tagName === 'OL') {
-        assert(el.matches(`.${syntax}s`));
+        assert(el.matches(`.${plural}`));
         el.remove();
       }
     }
@@ -205,37 +203,11 @@ function build(
 
 function* proc(defs: Map<string, HTMLLIElement>, note: HTMLOListElement): Generator<HTMLLIElement | undefined, undefined, undefined> {
   const { children } = note;
-  const size = defs.size;
-  let count = 0;
-  let length = children.length;
-  I:
-  for (const [key, def] of defs) {
-    defs.delete(key);
-    ++count;
-    for (; length > size;) {
-      const node = children[count - 1] as HTMLLIElement;
-      if (equal(node, def)) continue I;
-      yield note.removeChild(node);
-      --length;
-      assert(children.length === length);
-    }
-    const node = count <= length
-      ? children[count - 1]
-      : null;
-    if (node && equal(node, def)) continue;
-    assert(def.parentNode !== note);
-    yield note.insertBefore(def, node);
-    ++length;
-    assert(children.length === length);
+  for (let defs = note.children, i = defs.length; i--;) {
+    yield note.removeChild(children[i] as HTMLLIElement);
   }
-  for (; length > size;) {
-    yield note.removeChild(children[size] as HTMLLIElement);
-    --length;
-    assert(children.length === length);
+  for (const [, def] of defs) {
+    yield note.appendChild(def);
   }
-}
-
-function equal(a: Element, b: HTMLElement): boolean {
-  return a.id === b.id
-      && a.innerHTML === b.innerHTML;
+  defs.clear();
 }