micromark-extension-cjk-friendly 0.1.0

package/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2024 Tatsunori Uchino, and authors and contributors of original packages
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,145 @@
+# micromark-extension-cjk-friendly
+
+[![Version](https://img.shields.io/npm/v/micromark-extension-cjk-friendly)](https://npmjs.com/package/micromark-extension-cjk-friendly) [![NPM Downloads](https://img.shields.io/npm/dw/micromark-extension-cjk-friendly)](https://npmjs.com/package/micromark-extension-cjk-friendly) [![NPM Last Update](https://img.shields.io/npm/last-update/micromark-extension-cjk-friendly)](https://npmjs.com/package/micromark-extension-cjk-friendly)
+
+A [micromark](https://github.com/micromark/micromark) extension to make Markdown emphasis (`**`) in CommonMark compatible with Chinese, Japanese, and Korean (CJK).
+
+<span lang="ja">CommonMarkの強調記号(`**`)を日本語・中国語・韓国語にきちんと対応させるための[micromark](https://github.com/micromark/micromark)拡張</span>
+
+<span lang="zh-Hans-CN">一个 [micromark](https://github.com/micromark/micromark) 扩展，用于使 CommonMark 的强调标记(`**`)能够正确支持中文、日语和韩语文本。</span>
+
+<span lang="ko">CommonMark의 강조 표시(`**`) 를 한국어, 중국어, 일본어와 호환되도록 만드는 [micromark](https://github.com/micromark/micromark) 확장</span>
+
+## Problem / <span lang="ja">問題</span> / <span lang="zh-Hans-CN">问题</span> / <span lang="ko">문제점</span>
+
+CommonMark has a problem that the following emphasis marks `**` are not recognized as emphasis marks in Japanese, Chinese, and Korean.
+
+<span lang="ja">CommonMarkには、日本語・中国語・韓国語内の次のような強調記号(`**`)が強調記号として認識されない問題があります。</span>
+
+<span lang="zh-Hans-CN">CommonMark存在以下问题：在中文、日语和韩语文本中，强调标记`**`不会被识别为强调标记。</span>
+
+<span lang="ko">CommonMark는 일본어와 중국어에서 다음과 같은 강조 표시 `**`가 강조 표시로 인식되지 않는 문제가 있습니다.</span>
+
+```md
+**このアスタリスクは強調記号として認識されず、そのまま表示されます。**この文のせいで。
+
+**该星号不会被识别，而是直接显示。**这是因为它没有被识别为强调符号。
+
+**이 별표는 강조 표시로 인식되지 않고 그대로 표시됩니다(이 괄호 때문에)**이 문장 때문에.
+```
+
+This problem occurs because the character just inside the `**` is a (Japanese or Chinese) punctuation mark (。) or parenthesis and the character just outside is not a space or punctuation mark.
+
+<span lang="ja">これが起こった原因は、終了側の`**`のすぐ内側が約物（。やカッコ）、かつ外側が約物や空白以外の文字であるためです。</span>
+
+<span lang="zh-Hans-CN">这个问题是因为在`**`的结束部分，内侧字符是标点符号（。）或括号，而外侧字符不是空格或标点符号。</span>
+
+<span lang="ko">이 문제는 `**` 바로 안쪽의 문자가 (일본어나 중국어) 문장 부호(。) 또는 괄호이고 바깥쪽 문자가 공백이나 문장 부호가 아니기 때문에 발생합니다.</span>
+
+Of course, not only the end side but also the start side has the same issue.
+
+<span lang="ja">もちろん終了側だけでなく、開始側も同様の問題が存在します。</span>
+
+<span lang="zh-Hans-CN">当然，不仅是结束侧，开始侧也存在同样的问题。</span>
+
+<span lang="ko">물론 끝나는 부분뿐만 아니라 시작하는 부분에서도 동일한 문제가 있습니다.</span>
+
+CommonMark issue: https://github.com/commonmark/commonmark-spec/issues/650
+
+## Runtime Requirements / <span lang="ja">実行環境の要件</span> / <span lang="zh-Hans-CN">运行环境要求</span> / <span lang="ko">업데이트 전략</span>
+
+This package uses the [`v` flag of the regular expression](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/unicodeSets) introduced in ES2024 to determine whether the character is an emoji or not.
+
+<span lang="ja">本パッケージは文字が絵文字かどうかを判定するために、ES2024で導入された[正規表現の`v`フラグ](https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/RegExp/unicodeSets)を使用しています。</span>
+
+<span lang="zh-CN">本包使用 ES2024 引入的[`v` 标志](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/unicodeSets) 来判断字符是否为 emoji。</span>
+
+<span lang="ko">이 패키지는 ES2024에서 도입된 [`v` 플래그](https://developer.mozilla.org/ko/docs/Web/JavaScript/Reference/Global_Objects/RegExp/unicodeSets)를 사용하여 문자가 이모지인지 여부를 판단합니다.</span>
+
+It makes this package compatible only with relatively recent browsers and Node.js:
+
+<span lang="ja">このため、本パッケージは、次のような比較的新しいブラウザやNode.jsでしか動作しません。</span>
+
+<span lang="zh-CN">因此，本包只兼容比较新的浏览器和 Node.js:</span>
+
+<span lang="ko">따라서, 이 패키지는 비교적 최신 브라우저와 Node.js에서만 작동합니다.</span>
+
+- Chrome / Edge 112 or later
+- Firefox 116 or later
+- Safari 17 or later
+- Node.js 20 or later
+
+## Installation / <span lang="ja">インストール</span> / <span lang="zh-Hans-CN">安装</span> / <span lang="ko">설치</span>
+
+Install `micromark-extension-cjk-friendly` via [npm](https://www.npmjs.com/):
+
+<span lang="ja">`micromark-extension-cjk-friendly`を[npm](https://www.npmjs.com/)でインストールしてください。</span>
+
+<span lang="zh-Hans-CN">通过 [npm](https://www.npmjs.com/) 安装 `micromark-extension-cjk-friendly`。</span>
+
+<span lang="ko">`micromark-extension-cjk-friendly`를 [npm](https://www.npmjs.com/)으로 설치하세요.</span>
+
+```bash
+npm install micromark-extension-cjk-friendly
+```
+
+If you use another package manager, please replace `npm install` with the command of the package manager you use (e.g. `pnpm add` or `yarn add`).
+
+<span lang="ja">npm以外のパッケージマネージャを使う場合は、`npm install`を当該パッケージマネージャのコマンド（例：`pnpm add`・`yarn add`）に置き換えてください。</span>
+
+<span lang="zh-Hans-CN">如果使用其他包管理器，请将 `npm install` 替换为当时包管理器的命令（例如：`pnpm add`、`yarn add`）。</span>
+
+<span lang="ko">다른 패키지 매니저를 사용하는 경우 `npm install`을 해당 패키지 매니저의 명령어(예: `pnpm add`, `yarn add`)로 바꾸어 주세요.</span>
+
+## Usage / <span lang="ja">使い方</span> / <span lang="zh-Hans-CN">用法</span> / <span lang="ko">사용법</span>
+
+Import `micromark` and `micromark-extension-cjk-friendly`, and use the extension as follows:
+
+<span lang="ja">`micromark`と`micromark-extension-cjk-friendly`をインポートし、次のように拡張を使用してください。</span>
+
+<span lang="zh-Hans-CN">通过 `micromark` 和 `micromark-extension-cjk-friendly` 导入，然后使用扩展如下：</span>
+
+<span lang="ko">`micromark`와 `micromark-extension-cjk-friendly`를 임포트하고 다음과 같이 확장을 사용하세요.</span>
+
+```js
+import { micromark } from "micromark";
+import { gfm, gfmHtml } from "micromark-extension-gfm";
+import { cjkFriendlyExtension } from "micromark-extension-cjk-friendly";
+
+// e.g. combine with GFM extension
+const htmlString = micromark(
+  markdownString,
+  {
+    extensions: [gfm(), cjkFriendlyExtension()], // in no particular order
+    htmlExtensions: [gfmHtml()],
+  }
+)
+```
+
+## Specification / <span lang="ja">規格書</span> / <span lang="zh-Hans-CN">规范</span> / <span lang="ko">규정서</span>
+
+https://github.com/tats-u/markdown-cjk-friendly/blob/main/specification.md (English)
+
+## Contributing / <span lang="ja">貢献</span> / <span lang="zh-Hans-CN">贡献</span> / <span lang="ko">기여</span>
+
+### Setup
+
+Install the dependencies:
+
+```bash
+pnpm install
+```
+
+### Get Started
+
+Build the library:
+
+```bash
+pnpm build
+```
+
+Build the library in watch mode:
+
+```bash
+pnpm dev
+```

package/dist/ext/attention.d.ts

@@ -0,0 +1,15 @@
+import type { Effects, Resolver, State, TokenizeContext } from "micromark-util-types";
+/** @type {Construct} */
+export declare const attention: {
+    name: string;
+    resolveAll: typeof resolveAllAttention;
+    tokenize: typeof tokenizeAttention;
+};
+declare function resolveAllAttention(events: Parameters<Resolver>[0], context: Parameters<Resolver>[1]): ReturnType<Resolver>;
+/**
+ * @this {TokenizeContext}
+ *   Context.
+ * @type {Tokenizer}
+ */
+declare function tokenizeAttention(this: TokenizeContext, effects: Effects, ok: State): State;
+export {};

package/dist/ext/characterWithNonBmp.d.ts

@@ -0,0 +1,55 @@
+import type { Code } from "micromark-util-types";
+/**
+ * Check if `uc` is CJK or IVS
+ *
+ * @param uc code point
+ * @returns `true` if `uc` is CJK, `null` if IVS, or `false` if neither
+ */
+export declare function cjkOrIvs(uc: Code): boolean | null;
+/**
+ * Check whether the character code represents Standard Variation Sequence that can follow an ideographic character.
+ *
+ * U+FE0E is used for some CJK symbols (e.g. U+3299) that can also be
+ */
+export declare const svsFollowingCjk: (code: Code) => boolean;
+/**
+ * Check whether the character code represents Unicode punctuation.
+ *
+ * A **Unicode punctuation** is a character in the Unicode `Pc` (Punctuation,
+ * Connector), `Pd` (Punctuation, Dash), `Pe` (Punctuation, Close), `Pf`
+ * (Punctuation, Final quote), `Pi` (Punctuation, Initial quote), `Po`
+ * (Punctuation, Other), or `Ps` (Punctuation, Open) categories, or an ASCII
+ * punctuation (see `asciiPunctuation`).
+ *
+ * See:
+ * **\[UNICODE]**:
+ * [The Unicode Standard](https://www.unicode.org/versions/).
+ * Unicode Consortium.
+ *
+ * @param code
+ *   Code.
+ * @returns
+ *   Whether it matches.
+ */
+export declare const unicodePunctuation: (code: Code) => boolean;
+/**
+ * Check whether the character code represents Unicode whitespace.
+ *
+ * Note that this does handle micromark specific markdown whitespace characters.
+ * See `markdownLineEndingOrSpace` to check that.
+ *
+ * A **Unicode whitespace** is a character in the Unicode `Zs` (Separator,
+ * Space) category, or U+0009 CHARACTER TABULATION (HT), U+000A LINE FEED (LF),
+ * U+000C (FF), or U+000D CARRIAGE RETURN (CR) (**\[UNICODE]**).
+ *
+ * See:
+ * **\[UNICODE]**:
+ * [The Unicode Standard](https://www.unicode.org/versions/).
+ * Unicode Consortium.
+ *
+ * @param code
+ *   Code.
+ * @returns
+ *   Whether it matches.
+ */
+export declare const unicodeWhitespace: (code: Code) => boolean;

package/dist/ext/classifyCharacter.d.ts

@@ -0,0 +1,26 @@
+import { constants } from "micromark-util-symbol";
+import type { Code } from "micromark-util-types";
+export declare namespace constantsEx {
+    const spaceOrPunctuation: 3;
+    const cjk: 4096;
+    const cjkPunctuation: 4098;
+    const ivs: 8192;
+    const cjkOrIvs: 12288;
+    const svsFollowingCjk: 16384;
+    const variationSelector: 28672;
+}
+/**
+ * Classify whether a code represents whitespace, punctuation, or something
+ * else.
+ *
+ * Used for attention (emphasis, strong), whose sequences can open or close
+ * based on the class of surrounding characters.
+ *
+ * > 👉 **Note**: eof (`null`) is seen as whitespace.
+ *
+ * @param code
+ *   Code.
+ * @returns
+ *   Group.
+ */
+export declare function classifyCharacter(code: Code): typeof constants.characterGroupWhitespace | typeof constants.characterGroupPunctuation | typeof constantsEx.cjk | typeof constantsEx.cjkPunctuation | typeof constantsEx.ivs | typeof constantsEx.svsFollowingCjk | 0;

package/dist/index.cjs

@@ -0,0 +1,346 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = function(exports1, definition) {
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = function(obj, prop) {
+        return Object.prototype.hasOwnProperty.call(obj, prop);
+    };
+})();
+(()=>{
+    __webpack_require__.r = function(exports1) {
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    cjkFriendlyExtension: ()=>cjkFriendlyExtension
+});
+const external_micromark_util_symbol_namespaceObject = require("micromark-util-symbol");
+const external_devlop_namespaceObject = require("devlop");
+const external_micromark_util_chunked_namespaceObject = require("micromark-util-chunked");
+const external_micromark_util_resolve_all_namespaceObject = require("micromark-util-resolve-all");
+const external_micromark_util_character_namespaceObject = require("micromark-util-character");
+const external_get_east_asian_width_namespaceObject = require("get-east-asian-width");
+function cjkOrIvs(uc) {
+    if (!uc || uc < 0) return false;
+    const eaw = (0, external_get_east_asian_width_namespaceObject.eastAsianWidthType)(uc);
+    switch(eaw){
+        case "fullwidth":
+        case "halfwidth":
+            return true;
+        case "wide":
+            return !/^\p{RGI_Emoji}/v.test(String.fromCodePoint(uc));
+        case "narrow":
+            return false;
+        case "ambiguous":
+            return 0xe0100 <= uc && uc <= 0xe01ef && null;
+        case "neutral":
+            return /^\p{sc=Hangul}/u.test(String.fromCodePoint(uc));
+    }
+}
+const svsFollowingCjk = regexCheck(/[\uFE00-\uFE02\uFE0E]/u);
+const unicodePunctuation = regexCheck(/\p{P}|\p{S}/u);
+const unicodeWhitespace = regexCheck(/\s/);
+function regexCheck(regex) {
+    return check;
+    function check(code) {
+        return null !== code && code > -1 && regex.test(String.fromCodePoint(code));
+    }
+}
+(function(constantsEx) {
+    constantsEx.spaceOrPunctuation = 3;
+    constantsEx.cjk = 0x1000;
+    constantsEx.cjkPunctuation = 0x1002;
+    constantsEx.ivs = 0x2000;
+    constantsEx.cjkOrIvs = 0x3000;
+    constantsEx.svsFollowingCjk = 0x4000;
+    constantsEx.variationSelector = 0x7000;
+})(classifyCharacter_constantsEx || (classifyCharacter_constantsEx = {}));
+function classifyCharacter(code) {
+    if (code === external_micromark_util_symbol_namespaceObject.codes.eof || (0, external_micromark_util_character_namespaceObject.markdownLineEndingOrSpace)(code) || unicodeWhitespace(code)) return external_micromark_util_symbol_namespaceObject.constants.characterGroupWhitespace;
+    let value = 0;
+    if (code >= 0x1100) {
+        if (svsFollowingCjk(code)) return classifyCharacter_constantsEx.svsFollowingCjk;
+        switch(cjkOrIvs(code)){
+            case null:
+                return classifyCharacter_constantsEx.ivs;
+            case true:
+                value |= classifyCharacter_constantsEx.cjk;
+                break;
+        }
+    }
+    if (unicodePunctuation(code)) value |= external_micromark_util_symbol_namespaceObject.constants.characterGroupPunctuation;
+    return value;
+}
+var classifyCharacter_constantsEx;
+const attention = {
+    name: "attention",
+    resolveAll: resolveAllAttention,
+    tokenize: tokenizeAttention
+};
+function resolveAllAttention(events, context) {
+    let index = -1;
+    let open;
+    let group;
+    let text;
+    let openingSequence;
+    let closingSequence;
+    let use;
+    let nextEvents;
+    let offset;
+    while(++index < events.length)if ("enter" === events[index][0] && "attentionSequence" === events[index][1].type && events[index][1]._close) {
+        open = index;
+        while(open--)if ("exit" === events[open][0] && "attentionSequence" === events[open][1].type && events[open][1]._open && context.sliceSerialize(events[open][1]).charCodeAt(0) === context.sliceSerialize(events[index][1]).charCodeAt(0)) {
+            if ((events[open][1]._close || events[index][1]._open) && (events[index][1].end.offset - events[index][1].start.offset) % 3 && !((events[open][1].end.offset - events[open][1].start.offset + events[index][1].end.offset - events[index][1].start.offset) % 3)) continue;
+            use = events[open][1].end.offset - events[open][1].start.offset > 1 && events[index][1].end.offset - events[index][1].start.offset > 1 ? 2 : 1;
+            const start = {
+                ...events[open][1].end
+            };
+            const end = {
+                ...events[index][1].start
+            };
+            movePoint(start, -use);
+            movePoint(end, use);
+            openingSequence = {
+                type: use > 1 ? external_micromark_util_symbol_namespaceObject.types.strongSequence : external_micromark_util_symbol_namespaceObject.types.emphasisSequence,
+                start,
+                end: {
+                    ...events[open][1].end
+                }
+            };
+            closingSequence = {
+                type: use > 1 ? external_micromark_util_symbol_namespaceObject.types.strongSequence : external_micromark_util_symbol_namespaceObject.types.emphasisSequence,
+                start: {
+                    ...events[index][1].start
+                },
+                end
+            };
+            text = {
+                type: use > 1 ? external_micromark_util_symbol_namespaceObject.types.strongText : external_micromark_util_symbol_namespaceObject.types.emphasisText,
+                start: {
+                    ...events[open][1].end
+                },
+                end: {
+                    ...events[index][1].start
+                }
+            };
+            group = {
+                type: use > 1 ? external_micromark_util_symbol_namespaceObject.types.strong : external_micromark_util_symbol_namespaceObject.types.emphasis,
+                start: {
+                    ...openingSequence.start
+                },
+                end: {
+                    ...closingSequence.end
+                }
+            };
+            events[open][1].end = {
+                ...openingSequence.start
+            };
+            events[index][1].start = {
+                ...closingSequence.end
+            };
+            nextEvents = [];
+            if (events[open][1].end.offset - events[open][1].start.offset) nextEvents = (0, external_micromark_util_chunked_namespaceObject.push)(nextEvents, [
+                [
+                    "enter",
+                    events[open][1],
+                    context
+                ],
+                [
+                    "exit",
+                    events[open][1],
+                    context
+                ]
+            ]);
+            nextEvents = (0, external_micromark_util_chunked_namespaceObject.push)(nextEvents, [
+                [
+                    "enter",
+                    group,
+                    context
+                ],
+                [
+                    "enter",
+                    openingSequence,
+                    context
+                ],
+                [
+                    "exit",
+                    openingSequence,
+                    context
+                ],
+                [
+                    "enter",
+                    text,
+                    context
+                ]
+            ]);
+            (0, external_devlop_namespaceObject.ok)(context.parser.constructs.insideSpan.null, "expected `insideSpan` to be populated");
+            nextEvents = (0, external_micromark_util_chunked_namespaceObject.push)(nextEvents, (0, external_micromark_util_resolve_all_namespaceObject.resolveAll)(context.parser.constructs.insideSpan.null, events.slice(open + 1, index), context));
+            nextEvents = (0, external_micromark_util_chunked_namespaceObject.push)(nextEvents, [
+                [
+                    "exit",
+                    text,
+                    context
+                ],
+                [
+                    "enter",
+                    closingSequence,
+                    context
+                ],
+                [
+                    "exit",
+                    closingSequence,
+                    context
+                ],
+                [
+                    "exit",
+                    group,
+                    context
+                ]
+            ]);
+            if (events[index][1].end.offset - events[index][1].start.offset) {
+                offset = 2;
+                nextEvents = (0, external_micromark_util_chunked_namespaceObject.push)(nextEvents, [
+                    [
+                        "enter",
+                        events[index][1],
+                        context
+                    ],
+                    [
+                        "exit",
+                        events[index][1],
+                        context
+                    ]
+                ]);
+            } else offset = 0;
+            (0, external_micromark_util_chunked_namespaceObject.splice)(events, open - 1, index - open + 3, nextEvents);
+            index = open + nextEvents.length - offset - 2;
+            break;
+        }
+    }
+    index = -1;
+    while(++index < events.length)if ("attentionSequence" === events[index][1].type) events[index][1].type = "data";
+    return events;
+}
+function tokenizeAttention(effects, ok) {
+    const attentionMarkers = this.parser.constructs.attentionMarkers.null;
+    let previous = this.previous;
+    const { now, sliceSerialize } = this;
+    if (previous && previous >= 0xdc00 && previous <= 0xdfff) {
+        const nowPoint = now();
+        if (nowPoint._bufferIndex >= 2) {
+            const previousBuffer = sliceSerialize({
+                start: {
+                    ...nowPoint,
+                    _bufferIndex: nowPoint._bufferIndex - 2
+                },
+                end: nowPoint
+            });
+            const previousCandidate = previousBuffer.codePointAt(0);
+            if (previousCandidate && previousCandidate >= 65536) previous = previousCandidate;
+        }
+    }
+    const before = classifyCharacter(previous);
+    let beforePrimary = before;
+    if (before === classifyCharacter_constantsEx.svsFollowingCjk) {
+        const nowPoint = now();
+        const previousWidth = previous >= 65536 ? 2 : 1;
+        if (nowPoint._bufferIndex >= 1 + previousWidth) {
+            const idealStart = nowPoint._bufferIndex - previousWidth - 2;
+            const twoPreviousBuffer = sliceSerialize({
+                start: {
+                    ...nowPoint,
+                    _bufferIndex: idealStart >= 0 ? idealStart : 0
+                },
+                end: {
+                    ...nowPoint,
+                    _bufferIndex: nowPoint._bufferIndex - previousWidth
+                }
+            });
+            const twoPreviousLast = twoPreviousBuffer.charCodeAt(twoPreviousBuffer.length - 1);
+            if (!Number.isNaN(twoPreviousLast)) {
+                let twoPrevious;
+                if (twoPreviousBuffer.length >= 2 && twoPreviousLast >= 0xdc00 && twoPreviousLast <= 0xdfff) {
+                    const twoPreviousCandidate = twoPreviousBuffer.codePointAt(0);
+                    twoPrevious = twoPreviousCandidate && twoPreviousCandidate >= 65536 ? twoPreviousCandidate : twoPreviousLast;
+                } else twoPrevious = twoPreviousLast;
+                beforePrimary = classifyCharacter(twoPrevious);
+            }
+        }
+    }
+    let marker;
+    return start;
+    function start(code) {
+        (0, external_devlop_namespaceObject.ok)(code === external_micromark_util_symbol_namespaceObject.codes.asterisk || code === external_micromark_util_symbol_namespaceObject.codes.underscore, "expected asterisk or underscore");
+        marker = code;
+        effects.enter("attentionSequence");
+        return inside(code);
+    }
+    function inside(code) {
+        if (code === marker) {
+            effects.consume(code);
+            return inside;
+        }
+        const token = effects.exit("attentionSequence");
+        let next = code;
+        if (next && next >= 0xd800 && next <= 0xdfff) {
+            const nowPoint = now();
+            const nextCandidate = sliceSerialize({
+                start: nowPoint,
+                end: {
+                    ...nowPoint,
+                    _bufferIndex: nowPoint._bufferIndex + 2
+                }
+            }).codePointAt(0);
+            if (nextCandidate && nextCandidate >= 65536) next = nextCandidate;
+        }
+        const after = classifyCharacter(next);
+        (0, external_devlop_namespaceObject.ok)(attentionMarkers, "expected `attentionMarkers` to be populated");
+        const beforeNonCjkPunctuation = Boolean((before & classifyCharacter_constantsEx.cjkPunctuation) === external_micromark_util_symbol_namespaceObject.constants.characterGroupPunctuation);
+        const beforeSpaceOrNonCjkPunctuation = Boolean(beforeNonCjkPunctuation || before & external_micromark_util_symbol_namespaceObject.constants.characterGroupWhitespace);
+        const afterNonCjkPunctuation = Boolean((after & classifyCharacter_constantsEx.cjkPunctuation) === external_micromark_util_symbol_namespaceObject.constants.characterGroupPunctuation);
+        const afterSpaceOrNonCjkPunctuation = Boolean(afterNonCjkPunctuation || after & external_micromark_util_symbol_namespaceObject.constants.characterGroupWhitespace);
+        const beforeCjkOrIvs = Boolean(beforePrimary & classifyCharacter_constantsEx.cjk || before & classifyCharacter_constantsEx.ivs);
+        const open = Boolean(!afterSpaceOrNonCjkPunctuation || afterNonCjkPunctuation && (beforeSpaceOrNonCjkPunctuation || beforeCjkOrIvs) || attentionMarkers.includes(code));
+        const close = Boolean(!beforeSpaceOrNonCjkPunctuation || beforeNonCjkPunctuation && (afterSpaceOrNonCjkPunctuation || after & classifyCharacter_constantsEx.cjk) || attentionMarkers.includes(previous));
+        token._open = Boolean(marker === external_micromark_util_symbol_namespaceObject.codes.asterisk ? open : open && (before & classifyCharacter_constantsEx.spaceOrPunctuation || !close));
+        token._close = Boolean(marker === external_micromark_util_symbol_namespaceObject.codes.asterisk ? close : close && (after & classifyCharacter_constantsEx.spaceOrPunctuation || !open));
+        return ok(code);
+    }
+}
+function movePoint(point, offset) {
+    point.column += offset;
+    point.offset += offset;
+    point._bufferIndex += offset;
+}
+function cjkFriendlyExtension() {
+    return {
+        text: {
+            [external_micromark_util_symbol_namespaceObject.codes.asterisk]: attention,
+            [external_micromark_util_symbol_namespaceObject.codes.underscore]: attention
+        },
+        insideSpan: {
+            null: [
+                attention
+            ]
+        }
+    };
+}
+var __webpack_export_target__ = exports;
+for(var __webpack_i__ in __webpack_exports__)__webpack_export_target__[__webpack_i__] = __webpack_exports__[__webpack_i__];
+if (__webpack_exports__.__esModule) Object.defineProperty(__webpack_export_target__, '__esModule', {
+    value: true
+});

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import type { Extension } from "micromark-util-types";
+/**
+ * Make Markdown emphasis (`**`) in CommonMark more friendly with Chinese, Japanese, and Korean (CJK).
+ */
+export declare function cjkFriendlyExtension(): Extension;

package/dist/index.js

@@ -0,0 +1,312 @@
+import * as __WEBPACK_EXTERNAL_MODULE_micromark_util_symbol_0f33a452__ from "micromark-util-symbol";
+import * as __WEBPACK_EXTERNAL_MODULE_devlop__ from "devlop";
+import * as __WEBPACK_EXTERNAL_MODULE_micromark_util_chunked_0c4f2f7c__ from "micromark-util-chunked";
+import * as __WEBPACK_EXTERNAL_MODULE_micromark_util_resolve_all_7bf88077__ from "micromark-util-resolve-all";
+import * as __WEBPACK_EXTERNAL_MODULE_micromark_util_character_bdee8a5c__ from "micromark-util-character";
+import * as __WEBPACK_EXTERNAL_MODULE_get_east_asian_width_c890dec0__ from "get-east-asian-width";
+function cjkOrIvs(uc) {
+    if (!uc || uc < 0) return false;
+    const eaw = (0, __WEBPACK_EXTERNAL_MODULE_get_east_asian_width_c890dec0__.eastAsianWidthType)(uc);
+    switch(eaw){
+        case "fullwidth":
+        case "halfwidth":
+            return true;
+        case "wide":
+            return !/^\p{RGI_Emoji}/v.test(String.fromCodePoint(uc));
+        case "narrow":
+            return false;
+        case "ambiguous":
+            return 0xe0100 <= uc && uc <= 0xe01ef && null;
+        case "neutral":
+            return /^\p{sc=Hangul}/u.test(String.fromCodePoint(uc));
+    }
+}
+const svsFollowingCjk = regexCheck(/[\uFE00-\uFE02\uFE0E]/u);
+const unicodePunctuation = regexCheck(/\p{P}|\p{S}/u);
+const unicodeWhitespace = regexCheck(/\s/);
+function regexCheck(regex) {
+    return check;
+    function check(code) {
+        return null !== code && code > -1 && regex.test(String.fromCodePoint(code));
+    }
+}
+(function(constantsEx) {
+    constantsEx.spaceOrPunctuation = 3;
+    constantsEx.cjk = 0x1000;
+    constantsEx.cjkPunctuation = 0x1002;
+    constantsEx.ivs = 0x2000;
+    constantsEx.cjkOrIvs = 0x3000;
+    constantsEx.svsFollowingCjk = 0x4000;
+    constantsEx.variationSelector = 0x7000;
+})(classifyCharacter_constantsEx || (classifyCharacter_constantsEx = {}));
+function classifyCharacter(code) {
+    if (code === __WEBPACK_EXTERNAL_MODULE_micromark_util_symbol_0f33a452__.codes.eof || (0, __WEBPACK_EXTERNAL_MODULE_micromark_util_character_bdee8a5c__.markdownLineEndingOrSpace)(code) || unicodeWhitespace(code)) return __WEBPACK_EXTERNAL_MODULE_micromark_util_symbol_0f33a452__.constants.characterGroupWhitespace;
+    let value = 0;
+    if (code >= 0x1100) {
+        if (svsFollowingCjk(code)) return classifyCharacter_constantsEx.svsFollowingCjk;
+        switch(cjkOrIvs(code)){
+            case null:
+                return classifyCharacter_constantsEx.ivs;
+            case true:
+                value |= classifyCharacter_constantsEx.cjk;
+                break;
+        }
+    }
+    if (unicodePunctuation(code)) value |= __WEBPACK_EXTERNAL_MODULE_micromark_util_symbol_0f33a452__.constants.characterGroupPunctuation;
+    return value;
+}
+var classifyCharacter_constantsEx;
+const attention = {
+    name: "attention",
+    resolveAll: resolveAllAttention,
+    tokenize: tokenizeAttention
+};
+function resolveAllAttention(events, context) {
+    let index = -1;
+    let open;
+    let group;
+    let text;
+    let openingSequence;
+    let closingSequence;
+    let use;
+    let nextEvents;
+    let offset;
+    while(++index < events.length)if ("enter" === events[index][0] && "attentionSequence" === events[index][1].type && events[index][1]._close) {
+        open = index;
+        while(open--)if ("exit" === events[open][0] && "attentionSequence" === events[open][1].type && events[open][1]._open && context.sliceSerialize(events[open][1]).charCodeAt(0) === context.sliceSerialize(events[index][1]).charCodeAt(0)) {
+            if ((events[open][1]._close || events[index][1]._open) && (events[index][1].end.offset - events[index][1].start.offset) % 3 && !((events[open][1].end.offset - events[open][1].start.offset + events[index][1].end.offset - events[index][1].start.offset) % 3)) continue;
+            use = events[open][1].end.offset - events[open][1].start.offset > 1 && events[index][1].end.offset - events[index][1].start.offset > 1 ? 2 : 1;
+            const start = {
+                ...events[open][1].end
+            };
+            const end = {
+                ...events[index][1].start
+            };
+            movePoint(start, -use);
+            movePoint(end, use);
+            openingSequence = {
+                type: use > 1 ? __WEBPACK_EXTERNAL_MODULE_micromark_util_symbol_0f33a452__.types.strongSequence : __WEBPACK_EXTERNAL_MODULE_micromark_util_symbol_0f33a452__.types.emphasisSequence,
+                start,
+                end: {
+                    ...events[open][1].end
+                }
+            };
+            closingSequence = {
+                type: use > 1 ? __WEBPACK_EXTERNAL_MODULE_micromark_util_symbol_0f33a452__.types.strongSequence : __WEBPACK_EXTERNAL_MODULE_micromark_util_symbol_0f33a452__.types.emphasisSequence,
+                start: {
+                    ...events[index][1].start
+                },
+                end
+            };
+            text = {
+                type: use > 1 ? __WEBPACK_EXTERNAL_MODULE_micromark_util_symbol_0f33a452__.types.strongText : __WEBPACK_EXTERNAL_MODULE_micromark_util_symbol_0f33a452__.types.emphasisText,
+                start: {
+                    ...events[open][1].end
+                },
+                end: {
+                    ...events[index][1].start
+                }
+            };
+            group = {
+                type: use > 1 ? __WEBPACK_EXTERNAL_MODULE_micromark_util_symbol_0f33a452__.types.strong : __WEBPACK_EXTERNAL_MODULE_micromark_util_symbol_0f33a452__.types.emphasis,
+                start: {
+                    ...openingSequence.start
+                },
+                end: {
+                    ...closingSequence.end
+                }
+            };
+            events[open][1].end = {
+                ...openingSequence.start
+            };
+            events[index][1].start = {
+                ...closingSequence.end
+            };
+            nextEvents = [];
+            if (events[open][1].end.offset - events[open][1].start.offset) nextEvents = (0, __WEBPACK_EXTERNAL_MODULE_micromark_util_chunked_0c4f2f7c__.push)(nextEvents, [
+                [
+                    "enter",
+                    events[open][1],
+                    context
+                ],
+                [
+                    "exit",
+                    events[open][1],
+                    context
+                ]
+            ]);
+            nextEvents = (0, __WEBPACK_EXTERNAL_MODULE_micromark_util_chunked_0c4f2f7c__.push)(nextEvents, [
+                [
+                    "enter",
+                    group,
+                    context
+                ],
+                [
+                    "enter",
+                    openingSequence,
+                    context
+                ],
+                [
+                    "exit",
+                    openingSequence,
+                    context
+                ],
+                [
+                    "enter",
+                    text,
+                    context
+                ]
+            ]);
+            (0, __WEBPACK_EXTERNAL_MODULE_devlop__.ok)(context.parser.constructs.insideSpan.null, "expected `insideSpan` to be populated");
+            nextEvents = (0, __WEBPACK_EXTERNAL_MODULE_micromark_util_chunked_0c4f2f7c__.push)(nextEvents, (0, __WEBPACK_EXTERNAL_MODULE_micromark_util_resolve_all_7bf88077__.resolveAll)(context.parser.constructs.insideSpan.null, events.slice(open + 1, index), context));
+            nextEvents = (0, __WEBPACK_EXTERNAL_MODULE_micromark_util_chunked_0c4f2f7c__.push)(nextEvents, [
+                [
+                    "exit",
+                    text,
+                    context
+                ],
+                [
+                    "enter",
+                    closingSequence,
+                    context
+                ],
+                [
+                    "exit",
+                    closingSequence,
+                    context
+                ],
+                [
+                    "exit",
+                    group,
+                    context
+                ]
+            ]);
+            if (events[index][1].end.offset - events[index][1].start.offset) {
+                offset = 2;
+                nextEvents = (0, __WEBPACK_EXTERNAL_MODULE_micromark_util_chunked_0c4f2f7c__.push)(nextEvents, [
+                    [
+                        "enter",
+                        events[index][1],
+                        context
+                    ],
+                    [
+                        "exit",
+                        events[index][1],
+                        context
+                    ]
+                ]);
+            } else offset = 0;
+            (0, __WEBPACK_EXTERNAL_MODULE_micromark_util_chunked_0c4f2f7c__.splice)(events, open - 1, index - open + 3, nextEvents);
+            index = open + nextEvents.length - offset - 2;
+            break;
+        }
+    }
+    index = -1;
+    while(++index < events.length)if ("attentionSequence" === events[index][1].type) events[index][1].type = "data";
+    return events;
+}
+function tokenizeAttention(effects, ok) {
+    const attentionMarkers = this.parser.constructs.attentionMarkers.null;
+    let previous = this.previous;
+    const { now, sliceSerialize } = this;
+    if (previous && previous >= 0xdc00 && previous <= 0xdfff) {
+        const nowPoint = now();
+        if (nowPoint._bufferIndex >= 2) {
+            const previousBuffer = sliceSerialize({
+                start: {
+                    ...nowPoint,
+                    _bufferIndex: nowPoint._bufferIndex - 2
+                },
+                end: nowPoint
+            });
+            const previousCandidate = previousBuffer.codePointAt(0);
+            if (previousCandidate && previousCandidate >= 65536) previous = previousCandidate;
+        }
+    }
+    const before = classifyCharacter(previous);
+    let beforePrimary = before;
+    if (before === classifyCharacter_constantsEx.svsFollowingCjk) {
+        const nowPoint = now();
+        const previousWidth = previous >= 65536 ? 2 : 1;
+        if (nowPoint._bufferIndex >= 1 + previousWidth) {
+            const idealStart = nowPoint._bufferIndex - previousWidth - 2;
+            const twoPreviousBuffer = sliceSerialize({
+                start: {
+                    ...nowPoint,
+                    _bufferIndex: idealStart >= 0 ? idealStart : 0
+                },
+                end: {
+                    ...nowPoint,
+                    _bufferIndex: nowPoint._bufferIndex - previousWidth
+                }
+            });
+            const twoPreviousLast = twoPreviousBuffer.charCodeAt(twoPreviousBuffer.length - 1);
+            if (!Number.isNaN(twoPreviousLast)) {
+                let twoPrevious;
+                if (twoPreviousBuffer.length >= 2 && twoPreviousLast >= 0xdc00 && twoPreviousLast <= 0xdfff) {
+                    const twoPreviousCandidate = twoPreviousBuffer.codePointAt(0);
+                    twoPrevious = twoPreviousCandidate && twoPreviousCandidate >= 65536 ? twoPreviousCandidate : twoPreviousLast;
+                } else twoPrevious = twoPreviousLast;
+                beforePrimary = classifyCharacter(twoPrevious);
+            }
+        }
+    }
+    let marker;
+    return start;
+    function start(code) {
+        (0, __WEBPACK_EXTERNAL_MODULE_devlop__.ok)(code === __WEBPACK_EXTERNAL_MODULE_micromark_util_symbol_0f33a452__.codes.asterisk || code === __WEBPACK_EXTERNAL_MODULE_micromark_util_symbol_0f33a452__.codes.underscore, "expected asterisk or underscore");
+        marker = code;
+        effects.enter("attentionSequence");
+        return inside(code);
+    }
+    function inside(code) {
+        if (code === marker) {
+            effects.consume(code);
+            return inside;
+        }
+        const token = effects.exit("attentionSequence");
+        let next = code;
+        if (next && next >= 0xd800 && next <= 0xdfff) {
+            const nowPoint = now();
+            const nextCandidate = sliceSerialize({
+                start: nowPoint,
+                end: {
+                    ...nowPoint,
+                    _bufferIndex: nowPoint._bufferIndex + 2
+                }
+            }).codePointAt(0);
+            if (nextCandidate && nextCandidate >= 65536) next = nextCandidate;
+        }
+        const after = classifyCharacter(next);
+        (0, __WEBPACK_EXTERNAL_MODULE_devlop__.ok)(attentionMarkers, "expected `attentionMarkers` to be populated");
+        const beforeNonCjkPunctuation = Boolean((before & classifyCharacter_constantsEx.cjkPunctuation) === __WEBPACK_EXTERNAL_MODULE_micromark_util_symbol_0f33a452__.constants.characterGroupPunctuation);
+        const beforeSpaceOrNonCjkPunctuation = Boolean(beforeNonCjkPunctuation || before & __WEBPACK_EXTERNAL_MODULE_micromark_util_symbol_0f33a452__.constants.characterGroupWhitespace);
+        const afterNonCjkPunctuation = Boolean((after & classifyCharacter_constantsEx.cjkPunctuation) === __WEBPACK_EXTERNAL_MODULE_micromark_util_symbol_0f33a452__.constants.characterGroupPunctuation);
+        const afterSpaceOrNonCjkPunctuation = Boolean(afterNonCjkPunctuation || after & __WEBPACK_EXTERNAL_MODULE_micromark_util_symbol_0f33a452__.constants.characterGroupWhitespace);
+        const beforeCjkOrIvs = Boolean(beforePrimary & classifyCharacter_constantsEx.cjk || before & classifyCharacter_constantsEx.ivs);
+        const open = Boolean(!afterSpaceOrNonCjkPunctuation || afterNonCjkPunctuation && (beforeSpaceOrNonCjkPunctuation || beforeCjkOrIvs) || attentionMarkers.includes(code));
+        const close = Boolean(!beforeSpaceOrNonCjkPunctuation || beforeNonCjkPunctuation && (afterSpaceOrNonCjkPunctuation || after & classifyCharacter_constantsEx.cjk) || attentionMarkers.includes(previous));
+        token._open = Boolean(marker === __WEBPACK_EXTERNAL_MODULE_micromark_util_symbol_0f33a452__.codes.asterisk ? open : open && (before & classifyCharacter_constantsEx.spaceOrPunctuation || !close));
+        token._close = Boolean(marker === __WEBPACK_EXTERNAL_MODULE_micromark_util_symbol_0f33a452__.codes.asterisk ? close : close && (after & classifyCharacter_constantsEx.spaceOrPunctuation || !open));
+        return ok(code);
+    }
+}
+function movePoint(point, offset) {
+    point.column += offset;
+    point.offset += offset;
+    point._bufferIndex += offset;
+}
+function cjkFriendlyExtension() {
+    return {
+        text: {
+            [__WEBPACK_EXTERNAL_MODULE_micromark_util_symbol_0f33a452__.codes.asterisk]: attention,
+            [__WEBPACK_EXTERNAL_MODULE_micromark_util_symbol_0f33a452__.codes.underscore]: attention
+        },
+        insideSpan: {
+            null: [
+                attention
+            ]
+        }
+    };
+}
+export { cjkFriendlyExtension };

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "micromark-extension-cjk-friendly",
+  "version": "0.1.0",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "module-sync": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": ["dist", "LICENSE", "README.md"],
+  "repository": {
+    "url": "https://github.com/tats-u/markdown-cjk-friendly"
+  },
+  "license": "MIT",
+  "author": "Tatsunori Uchino <tats.u@live.jp> (https://github.com/tats-u)",
+  "bugs": "https://github.com/tats-u/markdown-cjk-friendly/issues",
+  "keywords": [
+    "micromark-extension",
+    "micromark",
+    "markdown",
+    "japanese",
+    "chinese",
+    "korean",
+    "cjk"
+  ],
+  "description": "micromark extension to make Markdown emphasis (`**`) in CommonMark more friendly with Chinese, Japanese, and Korean (CJK)",
+  "sideEffects": false,
+  "scripts": {
+    "build": "rslib build",
+    "dev": "rslib build --watch",
+    "test": "vitest --run",
+    "test:up": "vitest -u",
+    "test:watch": "vitest watch",
+    "lint:type": "tsc --noEmit",
+    "prepack": "node -e \"require('fs').cpSync('../../LICENSE', './LICENSE')\""
+  },
+  "dependencies": {
+    "devlop": "^1.0.0",
+    "get-east-asian-width": "^1.3.0",
+    "micromark-util-character": "^2.0.0",
+    "micromark-util-chunked": "^2.0.0",
+    "micromark-util-resolve-all": "^2.0.0",
+    "micromark-util-symbol": "^2.0.0"
+  },
+  "devDependencies": {
+    "@rslib/core": "^0.3.1",
+    "micromark": "^4.0.1",
+    "micromark-extension-gfm": "^3.0.0",
+    "micromark-util-types": "^2.0.0"
+  },
+  "peerDependencies": {
+    "micromark": "^4.0.0",
+    "micromark-util-types": "^2.0.0"
+  },
+  "peerDependenciesMeta": {
+    "micromark-util-types": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}