securemark 0.288.2 → 0.289.0

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 0.289.0
+
+- Improve bracket parser.
+
 ## 0.288.2
 
 - Fix signature syntax.

package/README.md

@@ -67,7 +67,7 @@ Secure markdown renderer working on browsers for user input data.
 
 |P| Operators                    |
 |-|------------------------------|
-|9| \n, \\\n                     |
+|9| \n                           |
 |6| `                            |
 |5| ${}$                         |
 |4| [% %]                        |

package/design.md

@@ -290,8 +290,8 @@ CodeMirrorが素では速いがVimModeでは数万文字程度でも耐え難く
 ### バックトラック
 
 SecuremarkのAnnotation構文に典型的であるように文脈を変更する構文の中にその文脈に依存し変更される他の構文が存在する場合文脈の相違から解析結果を再利用不能(`αAβ | αA'B`)なバックトラックが生じる。またこの結果再帰的バックトラックが生じる可能性があり再帰的バックトラックは一般的にメモ化により解決されるがCommonMarkは実行性能追及のためメモ化を廃止しているためメモ化により性能を低下させてまで文脈依存構文の問題を解決するつもりはないと思われる(すなわちCommonMarkは機械を至上とし人間に制約を課す低水準の言語であり人間の需要を至上とするSecuremarkとは対極に位置する)。従って現在の再帰的バックトラックなしで解析可能な構文と最小計算量に制約されるCommonMarkにはこれ以上再帰的バックトラックが生じる可能性を増加させて文脈依存構文を追加できないという拡張性の欠陥が存在する。CommonMarkの仕様策定者が構文の拡張に(名称を維持するか否かにかかわらず)不自然なまでに消極的または進展がないのは正当な理由や怠慢からでなく文脈依存構文を追加するにつれて構文解析戦略の失敗が明白になっていくためおよび現在の高い実行性能を低下させたくないためであり陳腐な自尊心を守るためにこのような拡張性の欠陥を秘匿しCommonMarkとその仕様策定者である自分の評価が下がらないよう画策しているからである。でなければ何年も隠さず速やかにこの拡張性の欠陥を公表して助力を求めていなければならず不都合な事実を隠し全Markdown利用者および開発者を不必要に足止めした罪は重い。CommonMarkは`~~a~~`のような文脈自由構文は容易に追加できるがこうしたマージンを失えばもはや後はない。
-CommonMarkは小さく単純であるがゆえに正しくいられる象牙の塔であり仕様策定者はこの正しさを失わず正しいままでいたいがために象牙の塔に引きこもり小さな表面的完全性に固執し続けているに過ぎない。しかし実際にはCommonMarkはまったく完全ではなく本来文脈依存構文である構文を文脈自由構文として解析しているため破綻している部分があり実際のところCommonMarkは最初から現在までずっと壊れている。またCommonMarkはバックトラックなく最小計算量で解析するために文脈自由言語として設計されているが実際には文脈依存言語であるMarkdownから文脈依存構文を文脈自由構文に変換して除去することができずCommonMarkは最初の数年間は再帰的バックトラックに気づかず最悪計算量が指数関数計算量になっており修正後は最悪計算量が当初の想定の1nから32nへと32倍に劇的に悪化している。CommonMarkは未だにバックトラックを忌避し1nの最小計算量に固執しているがそんなものはとっくの昔に破綻してるのを未練がましく執着しているだけである。最悪計算量が32nにまで悪化するのであれば計算量が少ないよう適切に設計された文脈依存言語と大差なく最初から文脈依存言語として適切に設計するほうが自然で破綻がなく拡張性を確保できていた。文脈依存構文を強引に文脈自由構文として解析して最悪計算量が当初の想定の1nから32nに劇的に悪化し結局文脈依存言語の妥当な最悪計算量の水準に落ちていることから文脈自由言語として設計されたCommonMarkの破綻と失敗は明らかでありCommonMarkは文脈自由構文に固執せず最初から多少の文脈依存構文を許容するよう設計しなければならなかった。実際には文脈依存言語であるにもかかわらず文脈自由言語としてしか構文解析できなければ構文解析が破綻し構文が増えるほど破綻が拡大することは自明でありすでに破綻済みで失敗済みのCommonMarkに未来などない。文脈依存言語であるMarkdownに対して文脈自由構文解析器として作られたCommonMarkは最初から技術選択を間違え失敗しており最初から破綻していた。Markdownを文脈自由言語として解析しようとして行き詰ったCommonMarkとその閉塞に技術的合理性はなくCommonMarkは最初からの失敗していた過去の遺物であり廃棄すべき負債である。CommonMarkに動きがないのはすでに破綻しており死んでいることに気付かれないように死んでいるからに過ぎない。このようにCommonMarkは完全に破綻し失敗に終わっているためCommonMarkの拡張や発展を期待しても無駄であり既存の文脈依存構文による破綻がなく新たに文脈依存構文を追加可能な拡張性の高いMarkdown仕様は新しく作り直さなければ作れない。しかしCommonMarkの仕様策定者は独自の新しい仕様においてもMarkdownをバックトラックを排除した文脈自由言語として設計しているため救いようがない。しかもその構文と仕様は機械可読性を至上としているため非常に醜く人間が書くことも読むことも困難で実用性の欠如したものである。
-Securemarkはスーパークラス構文が解析に失敗した入力をサブクラス構文で解析しないことにより再帰的バックトラックを回避する(ここで解析中の構文自身はスーパークラスとサブクラスの両方に含まれるものとする)。スーパークラス構文A(`αAβ`)の解析が失敗すればサブクラス構文B(`α'A'β'`)の解析も失敗することは自明であり解析を試みるまでもなく省略できる。これは構文の文法が生成する言語空間がスーパーセットとサブセットの関係にあるならスーパーセットの言語空間の外にある文字列はサブセットの言語空間の内に入る余地がないことからも自明である(この解析法は事前処理によっても可能だが文脈内外のオートリンクURLの括弧解析などを高速に行うことは困難であるためMarkdownをこの事前処理により高速化することは難しい)。メモ化は解析結果を再利用することで結果的に副次的効果としてバックトラックを回避しているのでありメモ化はバックトラックを回避するだけなら過剰機能であり不要である(メモ化はバックトラックがなければ使用されないためバックトラックの少ないほとんどの入力に対してはほとんど使用されず無駄であり空間計算量を常に不必要に数倍以上に増加させてまで行う利益は少ないことから構文解析において必須ではない。バックトラック回避のためにメモ化するとバックトラックなしで解析可能な場合も常に不必要に空間計算量が増加することがメモ化の最大の欠点である(この問題は解析失敗時のみメモ化すれば解消可能のはずだが基本的にはこうなる)。特に文脈自由構文解析器におけるメモ化の使用は完全に無駄でありバグである。バックトラックが他の方法で解決されるならば最終的に文脈ごと破棄され使用されないメモ化も無駄であり複数の文脈で解析結果が同一である文脈独立性のある構文ならメモ化した解析結果を異なる文脈で再利用でき有用だがそのような構文は基本的に少数であるため効果が限定的であり最悪計算量は改善されない)。この独自の解析法によりSecuremarkはメモ化なしに線形時間で解析不能な文脈依存言語をメモ化なしでおおよそ12nの最悪時間計算量に改善しさらに一定時間内で解析不能な入力の影響を解析時間と解析範囲の局限することで解決している。この解析方法はほとんどの自然な入力に対して1nに近い時間で効率的に動作し、最悪計算量で低速に動作させる入力に対してもこの開発効率と安全性優先の低速な実装をサーバーで使用し多数のユーザーのリクエストに応じるには低速で脆弱性となる可能性があるがクライアントで個別のユーザーの操作に応じるには十分高速であるためクライアントで解析する限り解析の効率または速度が実用上問題となることはなく仕様が固まり実行効率優先の高速な実装に移れば速度面の懸念もないだろう。またSecuremarkはメモ化を行っていないため実装依存の非効率性を除けば空間計算量も小さく、異なる構文や状態の解析結果を利用して未知の入力に対してもバックトラックを回避できるためメモ化より時間計算量が小さい。時間計算量と空間計算量を合わせてO(n, n)と表記すると文脈依存言語の通常の最悪計算量はO(n^2, n)、メモ化により効率化できた場合もO(nm, nm)(解析結果の構文木等を記録するため空間使用量S(m)>=m byte)に過ぎないがSecuremarkの失敗単一化はO(nm, n + nm)(解析失敗のフラグしか記録しないためS(m)=m bit。また包含文字列を含め全体でn byteの構文1つに対してメモ化は少なくともn byteを消費するが失敗単一化のメモリ消費量は構文全体のサイズにかかわらず1 bit固定である。なお成功フラグによる解析は解析済みかの情報が追加で必要になり処理が複雑化かつほとんどの成功した解析に対してメモリ消費と追加処理が発生し解析効率が全体として悪化するが失敗フラグは少数の失敗した解析でしか解析効率が悪化しないため失敗フラグを記録するほうが全体として解析効率が高く優れている)と極めて効率的であり最も優れている。なお現在のSecuremarkは開発効率優先の実装により空間計算量が低下しているが時間計算量は低下せずメモ化より優れている。またSecuremarkの再帰数制限はパーサーコンビネーターの使用による実装依存の制限であるため再帰が生じないよう書き換えれば再帰数制限もない。SecuremarkをCommonMarkのような再帰数制限のない実装に変換することは設計上何の支障もないがCommonMarkをSecuremarkのような文脈依存言語解析器に変更することは根本的な設計変更なしに不可能である。例えば二重リンク`[[]()]()`を解析するときCommonMarkはバックトラックと計算量を最小化すべく文脈自由構文解析器として設計されているためリンク構文内を異なる文脈として解析せず外側のリンク構文の解析を破棄して内側のみリンクとして解析するがSecuremarkは文脈依存構文解析器とし設計されているため内側のリンク構文を無効化して外側のみリンクとして解析する。旧構文だけ従来通り文脈自由構文として解析し新構文を文脈依存構文として解析することも不可能ではないが構文としても解析器としてもキメラ的な非常に不自然で歪なものとなり解析規則の一貫性のなさによりユーザーを混乱させることになる。いずれにせよCommonMarkはこのような根本的設計変更なしに文脈依存構文解析器に変更して拡張性を確保することはできないためMarkdownは素直にCommonMarkの文脈自由言語特有の解析規則を捨てて素直な文脈依存構文言語として新しい仕様を作るのが賢明である。
+CommonMarkは小さく単純であるがゆえに正しくいられる象牙の塔であり仕様策定者はこの正しさを失わず正しいままでいたいがために象牙の塔に引きこもり小さな表面的完全性に固執し続けているに過ぎない。しかしCommonMarkは実際にはまったく完全ではなく本来文脈依存構文である構文を文脈自由構文として解析しているため破綻している部分があり実際のところCommonMarkは最初から現在までずっと壊れている。またCommonMarkはバックトラックなく最小計算量で解析するために文脈自由言語として設計されているが実際には文脈依存言語であるMarkdownから文脈依存構文を文脈自由構文に変換して除去することに失敗しているためCommonMarkは最初の数年間は再帰的バックトラックに気づかず最悪計算量が指数関数計算量になっており修正後は最悪計算量が当初の想定の2nから32nへと劇的に悪化している。CommonMarkが最初の数年間指数関数計算量であった事実はCommonMarkが初歩的な再帰的バックトラックの原理すら理解していない素人により設計された素人仕事である事実を証明している。一貫して素人により設計開発仕様策定されているCommonMarkは未だにバックトラックを忌避し2nの最小計算量に固執しているがそんなものはとっくの昔に破綻してるのを未練がましく執着しているだけである。最悪計算量が32nにまで悪化するのであれば計算量が少ないよう適切に設計された文脈依存言語と大差なく最初から文脈依存言語として適切に設計するほうが自然で破綻がなく拡張性を確保できていた。文脈依存構文を強引に文脈自由構文として解析して最悪計算量が当初の想定の2nから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ならば最悪時間計算量384nを要する拡張Markdown言語をSecuremarkはメモ化なしで12nの最悪時間計算量で解析しさらに一定時間内で解析不能な入力の影響を解析時間と解析範囲の制限により局限している。またSecuremarkはメモ化を行っていないため実装依存の非効率性を除けば空間計算量も小さい。時間計算量と空間計算量を合わせてO(n, n)と表記すると文脈依存言語の通常の最悪計算量はO(n^2, n)、メモ化により効率化できた場合もO(nm, nm)(S(m)>=m byte)(解析結果の構文木等を記録するため空間使用量S(m)>=m byte)に過ぎないが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の再帰数制限はパーサーコンビネーターの使用による実装依存の制限であるため再帰が生じないよう書き換えれば再帰数制限もない。SecuremarkをCommonMarkのような再帰数制限のない実装に変換することは設計上何の支障もないがCommonMarkをSecuremarkのような正常な文脈依存言語解析器に変更することは解析規則の破壊的変更なしに不可能である。具体的には二重リンク`[[]()]()`を解析するときCommonMarkはバックトラックと計算量を最小化すべく文脈自由構文解析器として設計されているためリンク構文内をリンク構文が定義されていない異なる文脈として解析せず外側のリンク構文の解析を破棄して内側のみリンク構文として解析するがSecuremarkは文脈依存構文解析器とし設計されているためリンク構文内にリンク構文が定義されておらず外側のみリンクとして解析する(ここでCommonMarkはリンク構文`[]()`の文脈自由化に角括弧`[]`に対しては成功したが丸括弧`()`に対しては失敗したことで最悪計算量が指数関数計算量ないし32nに悪化した)。多くのプログラミング言語を見ても明らかなように文脈依存言語は構文内で使用可能な構文を定義しその他の構文は構文内で使用できず例外処理するのが通常でありCommonMarkのように本来使用不能な構文を外側の構文を無効化して使用可能に変える異常な言語はほとんどの人間はCommonMark以外に見たことがないだろう。ほぼすべての人間において他のすべての言語が同じ一貫した規則を持ち同じ規則で統一的に使用できるのに対してCommonMarkだけが他と異なる異常な挙動をして認知的負荷をかけるのである。破壊的変更を避けるため旧構文で使用した苦肉の策を不必要に新構文でも使用して一貫させれば文脈依存言語なのに文脈自由言語の苦肉の策で解析される非常に不自然で理論的に設計ミスが明白で実用的にも認知的負荷の高い言語となり旧構文だけ従来通り文脈自由構文として解析し新構文を文脈依存構文として解析すればキメラ的な非常に不自然かつ歪で一貫性のない解析規則によりCommonMarkという一つの言語の中だけでもユーザーを混乱させるものとなる。そして構文エラーであることが明らかな二重リンクを意図的に入力することはほぼないためCommonMarkの異常な挙動はこれまであまり人目に付かなかったがMarkdownに文脈依存構文を追加して明らかでない構文エラーが頻発すると他の言語と逆に外側の構文を無効化していくCommonMarkの異常な挙動を頻繁に目撃し認知的負荷をかけられることになる。このようにCommonMarkは内部設計だけ文脈依存構文解析器に変更しても理論的齟齬が解析結果と使用感に明白に表れるためCommonMarkが失敗した言語である事実は到底隠し切れるものではない。Markdownはもはや負債以外の何物でもないCommonMarkの異常な解析規則を捨てて素直な文脈依存構文言語として新しい仕様を作り直すのが賢明である。
 
 ### 最適化
 
@@ -323,7 +323,7 @@ Markdownに本当に必要な仕様はSecuremarkのクラス化制約のよう
     - リンクのURLを効率的に解析不可能
       - altはまだしもURLは文脈依存構文としての解析を避けられないため再帰もまた避けられず公式デモページのCommonMarkで`[](`を1万文字程度繰り返しただけで解析時間が1秒を超える
       - この欠陥は入れ子数を制限することで回避可能だがこれはCommonmarkは文脈依存構文全般に入れ子数制限を要することを意味する
-      - CommonMarkは最初のバージョンから数年後にこの欠陥を入れ子数制限により修正しこれにより最悪計算量が当初の想定の1nから32nへと32倍に劇的に悪化したことから文脈自由言語および最小計算量としての設計と開発が破綻し失敗に終わったことが明らかである
+      - CommonMarkは最初のバージョンから数年後にこの欠陥を入れ子数制限により修正しこれにより最悪計算量が当初の想定の2nから32nへと32倍に劇的に悪化したことから文脈自由言語および最小計算量としての設計と開発が破綻し失敗に終わったことが明らかである
       - これほど計算量が悪ければ入れ子数制限付き文脈依存言語と大差ない計算量であり素直に文脈依存言語として作り直したほうが遥かに拡張性と発展性が高く優れている
       - 計算資源は使うためにあるにもかかわらず言語と一致しない不適切な解析方法を使用してまでこの程度の計算資源を惜しんで人間に不便と不自由を強いて生産性を下げるのは本末転倒である
       - 計算機は人間の生産性に奉仕しなければならない

package/dist/index.js

@@ -1,4 +1,4 @@
-/*! securemark v0.288.2 https://github.com/falsandtru/securemark | (c) 2017, falsandtru | UNLICENSED License */
+/*! securemark v0.289.0 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"));
@@ -3177,11 +3177,15 @@ function surround(opener, parser, closer, optional = false, f, g, backtracks = [
   }) => {
     const lmr_ = source;
     if (lmr_ === '') return;
+    const {
+      linebreak
+    } = context;
+    context.linebreak = undefined;
     const res1 = opener({
       source: lmr_,
       context
     });
-    if (res1 === undefined) return;
+    if (res1 === undefined) return void revert(context, linebreak);
     const rl = (0, parser_1.eval)(res1);
     const mr_ = (0, parser_1.exec)(res1);
     for (const backtrack of backtracks) {
@@ -3197,7 +3201,7 @@ function surround(opener, parser, closer, optional = false, f, g, backtracks = [
           if (!(pos in backtracks)) continue;
           // bracket only
           const shift = backtrack >>> 2 === state >>> 2 ? state & 3 : 0;
-          if (backtracks[pos] & 1 << (backtrack >>> 2) + shift) return;
+          if (backtracks[pos] & 1 << (backtrack >>> 2) + shift) return void revert(context, linebreak);
         }
       }
     }
@@ -3212,14 +3216,14 @@ function surround(opener, parser, closer, optional = false, f, g, backtracks = [
     context.backtrack = state;
     const rm = (0, parser_1.eval)(res2);
     const r_ = (0, parser_1.exec)(res2, mr_);
-    if (!rm && !optional) return;
+    if (!rm && !optional) return void revert(context, linebreak);
     const res3 = closer({
       source: r_,
       context
     });
     const rr = (0, parser_1.eval)(res3);
     const rest = (0, parser_1.exec)(res3, r_);
-    if (rest.length === lmr_.length) return;
+    if (rest.length === lmr_.length) return void revert(context, linebreak);
     for (const backtrack of backtracks) {
       if (backtrack & 2 && rr === undefined) {
         const {
@@ -3233,7 +3237,13 @@ function surround(opener, parser, closer, optional = false, f, g, backtracks = [
       }
     }
     context.recent = [lmr_.slice(0, lmr_.length - mr_.length), mr_.slice(0, mr_.length - r_.length), r_.slice(0, r_.length - rest.length)];
-    return rr ? f ? f([rl, rm, rr], rest, context) : [(0, array_1.push)((0, array_1.unshift)(rl, rm ?? []), rr), rest] : g ? g([rl, rm, mr_], rest, context) : undefined;
+    const result = rr ? f ? f([rl, rm, rr], rest, context) : [(0, array_1.push)((0, array_1.unshift)(rl, rm ?? []), rr), rest] : g ? g([rl, rm, mr_], rest, context) : undefined;
+    if (result) {
+      context.linebreak ??= linebreak;
+    } else {
+      revert(context, linebreak);
+    }
+    return result;
   };
 }
 exports.surround = surround;
@@ -3252,6 +3262,9 @@ function match(pattern) {
       };
   }
 }
+function revert(context, linebreak) {
+  context.linebreak = linebreak;
+}
 function open(opener, parser, optional = false) {
   return surround(opener, parser, '', optional);
 }
@@ -3570,7 +3583,8 @@ class Delimiters {
       const {
         signature,
         matcher,
-        precedence
+        precedence,
+        linebreakable
       } = delims[i];
       const memory = registry(signature);
       const index = memory[0]?.index ?? delimiters.length;
@@ -3580,6 +3594,7 @@ class Delimiters {
           signature,
           matcher,
           precedence,
+          linebreakable: linebreakable,
           state: true
         };
         delimiters[index] = delimiter;
@@ -3632,7 +3647,10 @@ class Delimiters {
       delimiters[indexes[i]].state = true;
     }
   }
-  match(source, precedence = 0) {
+  match(source, {
+    precedence = 0,
+    linebreak = 0
+  }) {
     const {
       delimiters
     } = this;
@@ -3641,6 +3659,7 @@ class Delimiters {
       if (delimiter.precedence <= precedence || !delimiter.state) continue;
       switch (delimiter.matcher(source)) {
         case true:
+          if (!delimiter.linebreakable && linebreak > 0) return false;
           return true;
         case false:
           return false;
@@ -3688,7 +3707,7 @@ function inits(parsers, resume) {
     let nodes;
     for (let len = parsers.length, i = 0; i < len; ++i) {
       if (rest === '') break;
-      if (context.delimiters?.match(rest, context.precedence)) break;
+      if (context.delimiters?.match(rest, context)) break;
       const result = parsers[i]({
         source: rest,
         context
@@ -3727,7 +3746,7 @@ function sequence(parsers, resume) {
     let nodes;
     for (let len = parsers.length, i = 0; i < len; ++i) {
       if (rest === '') return;
-      if (context.delimiters?.match(rest, context.precedence)) return;
+      if (context.delimiters?.match(rest, context)) return;
       const result = parsers[i]({
         source: rest,
         context
@@ -3760,10 +3779,11 @@ const array_1 = __webpack_require__(6876);
 function some(parser, end, delimiters = [], limit = -1) {
   if (typeof end === 'number') return some(parser, undefined, delimiters, end);
   const match = delimiter_1.Delimiters.matcher(end);
-  const delims = delimiters.map(([delimiter, precedence]) => ({
+  const delims = delimiters.map(([delimiter, precedence, linebreakable = true]) => ({
     signature: delimiter_1.Delimiters.signature(delimiter),
     matcher: delimiter_1.Delimiters.matcher(delimiter),
-    precedence
+    precedence,
+    linebreakable
   }));
   return ({
     source,
@@ -3779,7 +3799,7 @@ function some(parser, end, delimiters = [], limit = -1) {
     while (true) {
       if (rest === '') break;
       if (match(rest)) break;
-      if (context.delimiters?.match(rest, context.precedence)) break;
+      if (context.delimiters?.match(rest, context)) break;
       const result = parser({
         source: rest,
         context
@@ -6111,7 +6131,9 @@ exports.bracket = (0, combinator_1.lazy)(() => (0, combinator_1.union)([(0, comb
   class: 'paren'
 }, (0, dom_1.defrag)((0, array_1.push)((0, array_1.unshift)(as, bs), cs)))], rest], ([as, bs = []], rest) => [(0, array_1.unshift)(as, bs), rest]), (0, combinator_1.surround)((0, source_1.str)('['), (0, combinator_1.recursion)(5 /* Recursion.bracket */, (0, combinator_1.precedence)(1, (0, combinator_1.some)(inline_1.inline, ']', [[']', 1]]))), (0, source_1.str)(']'), true, undefined, ([as, bs = []], rest) => [(0, array_1.unshift)(as, bs), rest], [2 | 8 /* Backtrack.bracket */]), (0, combinator_1.surround)((0, source_1.str)('［'), (0, combinator_1.recursion)(5 /* Recursion.bracket */, (0, combinator_1.precedence)(1, (0, combinator_1.some)(inline_1.inline, '］', [['］', 1]]))), (0, source_1.str)('］'), true, undefined, ([as, bs = []], rest) => [(0, array_1.unshift)(as, bs), rest]), (0, combinator_1.surround)((0, source_1.str)('{'), (0, combinator_1.recursion)(5 /* Recursion.bracket */, (0, combinator_1.precedence)(1, (0, combinator_1.some)(inline_1.inline, '}', [['}', 1]]))), (0, source_1.str)('}'), true, undefined, ([as, bs = []], rest) => [(0, array_1.unshift)(as, bs), rest], [2 | 8 /* Backtrack.bracket */]), (0, combinator_1.surround)((0, source_1.str)('｛'), (0, combinator_1.recursion)(5 /* Recursion.bracket */, (0, combinator_1.precedence)(1, (0, combinator_1.some)(inline_1.inline, '｝', [['｝', 1]]))), (0, source_1.str)('｝'), true, undefined, ([as, bs = []], rest) => [(0, array_1.unshift)(as, bs), rest]),
 // 改行禁止はバックトラックなしでは内側の構文を破壊するため安易に行えない。
-(0, combinator_1.surround)((0, source_1.str)('"'), (0, combinator_1.recursion)(5 /* Recursion.bracket */, (0, combinator_1.precedence)(2, (0, combinator_1.some)(inline_1.inline, '"', [['\n', 9], ['"', 2]]))), (0, source_1.str)('"'), true, undefined, ([as, bs = []], rest) => [(0, array_1.unshift)(as, bs), rest], [2 | 8 /* Backtrack.bracket */])]));
+(0, combinator_1.surround)((0, source_1.str)('"'), (0, combinator_1.recursion)(5 /* Recursion.bracket */, (0, combinator_1.precedence)(2, (0, combinator_1.some)(inline_1.inline, '"', [['"', 2, false]]))), (0, source_1.str)('"'), true, ([as, bs = [], cs], rest, {
+  linebreak = 0
+}) => linebreak > rest.length ? [(0, array_1.unshift)(as, bs), cs[0] + rest] : [(0, array_1.push)((0, array_1.unshift)(as, bs), cs), rest], ([as, bs = []], rest) => [(0, array_1.unshift)(as, bs), rest], [2 | 8 /* Backtrack.bracket */])]));
 
 /***/ },
 
@@ -7650,6 +7672,7 @@ const escsource = ({
               return [[source.slice(0, 2)], source.slice(2)];
           }
         case '\n':
+          context.linebreak ??= source.length;
           return [[source[0]], source.slice(1)];
         default:
           const b = source[0].trimStart() === '';
@@ -7763,6 +7786,7 @@ const text = ({
               return [[source.slice(1, 2)], source.slice(2)];
           }
         case '\n':
+          context.linebreak ??= source.length;
           return [[(0, dom_1.html)('br')], source.slice(1)];
         case '*':
         case '`':
@@ -7825,6 +7849,7 @@ const unescsource = ({
             (0, combinator_1.consume)(1, context);
             return [[source.slice(1, 2)], source.slice(2)];
           case '\n':
+            context.linebreak ??= source.length;
             return [[source[0]], source.slice(1)];
           default:
             const b = source[0].trimStart() === '';

package/package.json

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

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

@@ -55,9 +55,11 @@ export function surround<T>(
   return ({ source, context }) => {
     const lmr_ = source;
     if (lmr_ === '') return;
+    const { linebreak } = context;
+    context.linebreak = undefined;
     const res1 = opener({ source: lmr_, context });
     assert(check(lmr_, res1, false));
-    if (res1 === undefined) return;
+    if (res1 === undefined) return void revert(context, linebreak);
     const rl = eval(res1);
     const mr_ = exec(res1);
     for (const backtrack of backtracks) {
@@ -69,7 +71,7 @@ export function surround<T>(
           if (!(pos in backtracks)) continue;
           // bracket only
           const shift = backtrack >>> 2 === state >>> 2 ? state & 3 : 0;
-          if (backtracks[pos] & 1 << (backtrack >>> 2) + shift) return;
+          if (backtracks[pos] & 1 << (backtrack >>> 2) + shift) return void revert(context, linebreak);
         }
       }
     }
@@ -80,12 +82,12 @@ export function surround<T>(
     context.backtrack = state;
     const rm = eval(res2);
     const r_ = exec(res2, mr_);
-    if (!rm && !optional) return;
+    if (!rm && !optional) return void revert(context, linebreak);
     const res3 = closer({ source: r_, context });
     assert(check(r_, res3, false));
     const rr = eval(res3);
     const rest = exec(res3, r_);
-    if (rest.length === lmr_.length) return;
+    if (rest.length === lmr_.length) return void revert(context, linebreak);
     for (const backtrack of backtracks) {
       if (backtrack & 2 && rr === undefined) {
         const { backtracks = {}, backtrack: state = 0, offset = 0 } = context;
@@ -99,13 +101,20 @@ export function surround<T>(
       mr_.slice(0, mr_.length - r_.length),
       r_.slice(0, r_.length - rest.length),
     ];
-    return rr
+    const result = rr
       ? f
         ? f([rl, rm!, rr], rest, context)
-        : [push(unshift(rl, rm ?? []), rr), rest]
+        : [push(unshift(rl, rm ?? []), rr), rest] satisfies [T[], string]
       : g
         ? g([rl, rm!, mr_], rest, context)
         : undefined;
+    if (result) {
+      context.linebreak ??= linebreak;
+    }
+    else {
+      revert(context, linebreak);
+    }
+    return result;
   };
 }
 
@@ -123,6 +132,10 @@ function match(pattern: string | RegExp): (input: Input) => [never[], string] |
   }
 }
 
+function revert(context: Ctx, linebreak: number | undefined): void {
+  context.linebreak = linebreak;
+}
+
 export function open<P extends Parser<unknown>>(opener: string | RegExp | Parser<Tree<P>, Context<P>>, parser: P, optional?: boolean): P;
 export function open<T>(opener: string | RegExp | Parser<T>, parser: Parser<T>, optional = false): Parser<T> {
   return surround(opener, parser, '', optional);

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

@@ -1,3 +1,4 @@
+import { Ctx } from '../../parser';
 import { memoize } from 'spica/memoize';
 
 interface Delimiter {
@@ -5,6 +6,7 @@ interface Delimiter {
   readonly signature: string;
   readonly matcher: (source: string) => boolean | undefined;
   readonly precedence: number;
+  readonly linebreakable: boolean;
   state: boolean;
 }
 
@@ -40,13 +42,14 @@ export class Delimiters {
       readonly signature: string;
       readonly matcher: (source: string) => boolean | undefined;
       readonly precedence: number;
+      readonly linebreakable: boolean;
     }[]
   ): void {
     const { registry, delimiters, stack } = this;
     // シグネチャ数以下
     assert(delimiters.length < 100);
     for (let i = 0; i < delims.length; ++i) {
-      const { signature, matcher, precedence } = delims[i];
+      const { signature, matcher, precedence, linebreakable } = delims[i];
       const memory = registry(signature);
       const index = memory[0]?.index ?? delimiters.length;
       if (memory.length === 0 || precedence > delimiters[index].precedence) {
@@ -55,6 +58,7 @@ export class Delimiters {
           signature,
           matcher,
           precedence,
+          linebreakable: linebreakable,
           state: true,
         };
         delimiters[index] = delimiter;
@@ -107,13 +111,14 @@ export class Delimiters {
       delimiters[indexes[i]].state = true;
     }
   }
-  public match(source: string, precedence = 0): boolean {
+  public match(source: string, { precedence = 0, linebreak = 0 }: Ctx): boolean {
     const { delimiters } = this;
     for (let i = delimiters.length; i--;) {
       const delimiter = delimiters[i];
       if (delimiter.precedence <= precedence || !delimiter.state) continue;
       switch (delimiter.matcher(source)) {
         case true:
+          if (!delimiter.linebreakable && linebreak > 0) return false;
           return true;
         case false:
           return false;

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

@@ -10,7 +10,7 @@ export function inits<T, D extends Parser<T>[]>(parsers: D, resume?: (nodes: T[]
     let nodes: T[] | undefined;
     for (let len = parsers.length, i = 0; i < len; ++i) {
       if (rest === '') break;
-      if (context.delimiters?.match(rest, context.precedence)) break;
+      if (context.delimiters?.match(rest, context)) break;
       const result = parsers[i]({ source: rest, context });
       assert(check(rest, result, false));
       if (result === undefined) break;

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

@@ -10,7 +10,7 @@ export function sequence<T, D extends Parser<T>[]>(parsers: D, resume?: (nodes:
     let nodes: T[] | undefined;
     for (let len = parsers.length, i = 0; i < len; ++i) {
       if (rest === '') return;
-      if (context.delimiters?.match(rest, context.precedence)) return;
+      if (context.delimiters?.match(rest, context)) return;
       const result = parsers[i]({ source: rest, context });
       assert(check(rest, result, false));
       if (result === undefined) return;

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

@@ -2,7 +2,7 @@ import { Parser, eval, exec, check } from '../parser';
 import { Delimiters } from './context/delimiter';
 import { unshift, push } from 'spica/array';
 
-type DelimiterOption = readonly [delimiter: string | RegExp, precedence: number];
+type DelimiterOption = readonly [delimiter: string | RegExp, precedence: number, linebreak?: boolean];
 
 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;
@@ -11,10 +11,11 @@ export function some<T>(parser: Parser<T>, end?: string | RegExp | number, delim
   assert(parser);
   assert([end].concat(delimiters.map(o => o[0])).every(d => d instanceof RegExp ? !d.flags.match(/[gmy]/) && d.source.startsWith('^') : true));
   const match = Delimiters.matcher(end);
-  const delims = delimiters.map(([delimiter, precedence]) => ({
+  const delims = delimiters.map(([delimiter, precedence, linebreakable = true]) => ({
     signature: Delimiters.signature(delimiter),
     matcher: Delimiters.matcher(delimiter),
     precedence,
+    linebreakable,
   }));
   return ({ source, context }) => {
     if (source === '') return;
@@ -28,7 +29,7 @@ export function some<T>(parser: Parser<T>, end?: string | RegExp | number, delim
     while (true) {
       if (rest === '') break;
       if (match(rest)) break;
-      if (context.delimiters?.match(rest, context.precedence)) break;
+      if (context.delimiters?.match(rest, context)) break;
       const result = parser({ source: rest, context });
       assert.doesNotThrow(() => limit < 0 && check(rest, result));
       if (result === undefined) break;

package/src/combinator/data/parser.ts

@@ -21,6 +21,7 @@ export interface Ctx {
   state?: number;
   backtracks?: Record<number, number>;
   backtrack?: number;
+  linebreak?: number;
   recent?: string[];
 }
 export type Tree<P extends Parser<unknown>> = P extends Parser<infer T> ? T : never;

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

@@ -79,6 +79,8 @@ describe('Unit: parser/inline/bracket', () => {
       assert.deepStrictEqual(inspect(parser('"(")"')), [['"', '(', '"'], ')"']);
       assert.deepStrictEqual(inspect(parser('"(("')), [['"', '(', '(', '"'], '']);
       assert.deepStrictEqual(inspect(parser('"(\\")"')), [['"', '<span class="paren">(")</span>', '"'], '']);
+      assert.deepStrictEqual(inspect(parser('"\n"')), [['"', '<br>', '"'], '']);
+      assert.deepStrictEqual(inspect(parser('"\n"(")')), [['"', '<br>', '"', '(', '"'], ')']);
     });
 
   });

package/src/parser/inline/bracket.ts

@@ -40,7 +40,10 @@ export const bracket: BracketParser = lazy(() => union([
     undefined,
     ([as, bs = []], rest) => [unshift(as, bs), rest]),
   // 改行禁止はバックトラックなしでは内側の構文を破壊するため安易に行えない。
-  surround(str('"'), recursion(Recursion.bracket, precedence(2, some(inline, '"', [['\n', 9], ['"', 2]]))), str('"'), true,
-    undefined,
+  surround(str('"'), recursion(Recursion.bracket, precedence(2, some(inline, '"', [['"', 2, false]]))), str('"'), true,
+    ([as, bs = [], cs], rest, { linebreak = 0 }) =>
+      linebreak > rest.length
+        ? [unshift(as, bs), cs[0] + rest]
+        : [push(unshift(as, bs), cs), rest],
     ([as, bs = []], rest) => [unshift(as, bs), rest], [2 | Backtrack.bracket]),
 ]));

package/src/parser/inline.test.ts

@@ -79,6 +79,14 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('*++ a ++*')), [['<em><ins> a </ins></em>'], '']);
       assert.deepStrictEqual(inspect(parser('*++  a  ++*')), [['<em><ins>  a  </ins></em>'], '']);
       assert.deepStrictEqual(inspect(parser('*<bdi>`a`</bdi>*')), [['<em><bdi><code data-src="`a`">a</code></bdi></em>'], '']);
+      assert.deepStrictEqual(inspect(parser('*a"\nb*')), [['*', 'a', '"', '<br>', 'b', '*'], '']);
+      assert.deepStrictEqual(inspect(parser('*a"\n"("b*')), [['<em>a"<br>"("b</em>'], '']);
+      assert.deepStrictEqual(inspect(parser('"*a\nb*')), [['"', '<em>a<br>b</em>'], '']);
+      assert.deepStrictEqual(inspect(parser('"*a\n""b*')), [['"', '<em>a<br>""b</em>'], '']);
+      assert.deepStrictEqual(inspect(parser('"a\n"*b"c*')), [['"', 'a', '<br>', '"', '*', 'b', '"', 'c', '*'], '']);
+      assert.deepStrictEqual(inspect(parser('"*a\n**b**"("c*')), [['"', '<em>a<br><strong>b</strong>"("c</em>'], '']);
+      assert.deepStrictEqual(inspect(parser('<bdi>a"\nb</bdi>')), [['<bdi>a"<br>b</bdi>'], '']);
+      assert.deepStrictEqual(inspect(parser('"<bdi>"a\n""b</bdi>"')), [['"', '<bdi>"a<br>""b</bdi>', '"'], '']);
       assert.deepStrictEqual(inspect(parser('<bdi>*<bdi>a</bdi>*</bdi>')), [['<bdi><em><bdi>a</bdi></em></bdi>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdi>((<bdi>((a))</bdi>))</bdi>')), [['<bdi><sup class="annotation"><span><bdi><span class="paren">((a))</span></bdi></span></sup></bdi>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdi>[[<bdi>[[a]]</bdi>]]</bdi>')), [['<bdi><sup class="reference"><span><bdi>[[a]]</bdi></span></sup></bdi>'], '']);

package/src/parser/source/escapable.ts

@@ -35,6 +35,7 @@ export const escsource: EscapableSourceParser = ({ source, context }) => {
           }
         case '\n':
           assert(false);
+          context.linebreak ??= source.length;
           return [[source[0]], source.slice(1)];
         default:
           assert(source[0] !== '\n');

package/src/parser/source/text.ts

@@ -36,6 +36,7 @@ export const text: TextParser = ({ source, context }) => {
               return [[source.slice(1, 2)], source.slice(2)];
           }
         case '\n':
+          context.linebreak ??= source.length;
           return [[html('br')], source.slice(1)];
         case '*':
         case '`':

package/src/parser/source/unescapable.ts

@@ -23,6 +23,7 @@ export const unescsource: UnescapableSourceParser = ({ source, context }) => {
           return [[source.slice(1, 2)], source.slice(2)];
         case '\n':
           assert(false);
+          context.linebreak ??= source.length;
           return [[source[0]], source.slice(1)];
         default:
           assert(source[0] !== '\n');