@peaceroad/markdown-it-cjk-breaks-mod 0.1.0

package/LICENSE

@@ -0,0 +1,24 @@
+Copyright (c) 2018 Authors.
+Copyright (c) 2021 sup39[サポミク].
+Copyright (c) 2025 k_taka.
+
+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,128 @@
+# markdown-it-cjk-breaks
+
+## k_taka's additional features
+
+### Punctuation spacing options
+
+Fine-tune the trigger list with `spaceAfterPunctuationTargets`. Provide either a single string or an array and every exact match becomes eligible for automatic spacing. Defaults remain `['！', '？', '⁉', '！？', '？！', '!?', '?!']`.
+
+Use `spaceAfterPunctuation` to inject a space every time this plugin suppresses a line break after punctuation. Accepts `'half'` for ASCII space, `'full'` for an ideographic space, or any custom string via a literal value.
+
+```js
+import MarkdownIt from 'markdown-it';
+import cjkBreaks from '@peaceroad/markdown-it-cjk-breaks-mod';
+
+// Full-width spacing after default punctuation
+const mdFull = MarkdownIt({ html: true }).use(cjkBreaks, {
+  spaceAfterPunctuation: 'full',
+  either: true
+});
+mdFull.render('こんにちは！\nWorld');
+// <p>こんにちは！　World</p>
+
+// Half-width spacing for ASCII-friendly mixes
+const mdHalf = MarkdownIt({ html: true }).use(cjkBreaks, {
+  spaceAfterPunctuation: 'half',
+  either: true
+});
+mdHalf.render('こんにちは！\nWorld');
+// <p>こんにちは！ World</p>
+
+// Custom punctuation triggers
+const mdCustom = MarkdownIt({ html: true }).use(cjkBreaks, {
+  spaceAfterPunctuation: 'half',
+  spaceAfterPunctuationTargets: ['??']
+});
+mdCustom.render('Hello??\nWorld');
+// <p>Hello?? World</p>
+```
+
+### Softbreak normalization for other plugins
+Even with stock markdown-it, emphasis markers can leave inline `text` tokens that still embed `\n`. When `normalizeSoftBreaks: true`, those tokens are split back into proper `softbreak` entries before CJK suppression runs, so a trailing `***漢***\n字` behaves the same way regardless of how markdown-it represented it internally.
+
+```js
+// Normalize softbreaks emitted by other plugins first
+const mdStrongJaFriendly = MarkdownIt({ html: true }).use(cjkBreaks, {
+  normalizeSoftBreaks: true,
+  either: true
+});
+mdStrongJaFriendly.render('**漢**\nb');
+// <p><strong>漢</strong>b</p>
+```
+
+`@peaceroad/markdown-it-strong-ja` also emit newline-containing `text` nodes after their own rewrites. The same option keeps behavior consistent no matter which order you register plugins.
+
+## sup39's additional features
+
+- [@sup39/markdown-it-cjk-breaks](https://npmjs.com/package/@sup39/markdown-it-cjk-breaks)
+
+Provide an optional option `either`(default: false, which works as original version) to determine whether allowing removing linebreak when either the character before **OR** after the linebreak is east asian character.
+
+```js
+var md = require('markdown-it')();
+var cjk_breaks = require('markdown-it-cjk-breaks');
+
+md.use(cjk_breaks, {either: true}); // << set either to true
+
+md.render(`
+あおえ
+うい
+aoe
+ui
+`);
+
+// returns:
+//
+//<p>あおえういaoe <!-- linebreak between `い` and `a` is removed -->
+//ui</p>
+```
+
+## Original
+
+- [markdown-it-cjk-breaks](https://github.com/markdown-it/markdown-it-cjk-breaks)
+
+> Plugin for [markdown-it](https://github.com/markdown-it/markdown-it) that suppresses linebreaks between east asian characters.
+
+Normally newlines in a markdown text get rendered as newlines in output html text. Then browsers will usually render those newlines as whitespace (more smart behavior is included in w3c drafts, but not actually implemented by vendors).
+
+This plugin finds and removes newlines that cannot be converted to space, algorithm matches [CSS Text Module Level 3](https://www.w3.org/TR/css-text-3/#line-break-transform):
+
+- If the character immediately before or immediately after the segment break is the zero-width space character (U+200B), then the break is removed, leaving behind the zero-width space.
+- Otherwise, if the East Asian Width property [UAX11] of both the character before and after the segment break is F, W, or H (not A), and neither side is Hangul, then the segment break is removed.
+- Otherwise, the segment break is converted to a space (U+0020).
+
+## Install
+
+```bash
+yarn add markdown-it-cjk-breaks
+```
+
+
+## Usage
+
+```js
+var md = require('markdown-it')();
+var cjk_breaks = require('markdown-it-cjk-breaks');
+
+md.use(cjk_breaks);
+
+md.render(`
+あおえ
+うい
+aoe
+ui
+`);
+
+// returns:
+//
+//<p>あおえうい
+//aoe
+//ui</p>
+```
+
+
+## License
+
+- markdown-it/markdown-it-cjk-breaks: [MIT](https://github.com/markdown-it/markdown-it-cjk-breaks/blob/master/LICENSE)
+- @sup39/markdown-it-cjk-breaks: [MIT](https://www.npmjs.com/package/@sup39/markdown-it-cjk-breaks?activeTab=code)
+- @peaceroad/markdown-it-cjk-breaks-mod: [MIT](https://github.com/peaceroad/p7d-markdown-it-cjk-breaks-mod/blob/main/LICENSE

package/index.js

@@ -0,0 +1,463 @@
+import eastAsianWidthModule from 'eastasianwidth';
+
+const { eastAsianWidth } = eastAsianWidthModule;
+const ASCII_PRINTABLE_MIN = 0x21;
+const ASCII_PRINTABLE_MAX = 0x7E;
+const IDEOGRAPHIC_SPACE = '\u3000';
+const DEFAULT_PUNCTUATION_TARGETS = ['！', '？', '⁉', '！？', '？！', '!?', '?!'];
+const DEFAULT_PUNCTUATION_CONFIG = create_punctuation_config(DEFAULT_PUNCTUATION_TARGETS);
+
+
+function is_surrogate(c1, c2) {
+  return c1 >= 0xD800 && c1 <= 0xDBFF && c2 >= 0xDC00 && c2 <= 0xDFFF;
+}
+
+
+function is_hangul(c) {
+  // require('unicode-10.0.0/Script/Hangul/regex')
+  /* eslint-disable max-len */
+  return /[\u1100-\u11FF\u302E\u302F\u3131-\u318E\u3200-\u321E\u3260-\u327E\uA960-\uA97C\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uFFA0-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]/.test(c);
+  /* eslint-enable max-len */
+}
+
+
+function create_punctuation_config(targets) {
+  var sequences = new Set();
+  var maxLength = 0;
+
+  for (var i = 0; i < targets.length; i++) {
+    var value = targets[i];
+    if (typeof value !== 'string' || value.length === 0) continue;
+    sequences.add(value);
+    if (value.length > maxLength) maxLength = value.length;
+  }
+
+  return { sequences: sequences, maxLength: maxLength };
+}
+
+
+function resolve_punctuation_space_option(opts) {
+  if (!opts || !opts.spaceAfterPunctuation) return '';
+
+  var option = opts.spaceAfterPunctuation;
+  if (option === 'half') return ' ';
+  if (option === 'full') return IDEOGRAPHIC_SPACE;
+  if (typeof option === 'string' && option.length > 0) return option;
+  return '';
+}
+
+
+function resolve_punctuation_targets(opts) {
+  if (!opts || !opts.spaceAfterPunctuationTargets) return DEFAULT_PUNCTUATION_CONFIG;
+
+  var customTargets = opts.spaceAfterPunctuationTargets;
+  if (typeof customTargets === 'string') customTargets = [ customTargets ];
+  if (!Array.isArray(customTargets) || customTargets.length === 0) return DEFAULT_PUNCTUATION_CONFIG;
+
+  var config = create_punctuation_config(customTargets);
+  return config.sequences.size === 0 ? DEFAULT_PUNCTUATION_CONFIG : config;
+}
+
+
+function matches_punctuation_sequence(trailing, punctuationConfig) {
+  if (!trailing || !punctuationConfig || punctuationConfig.maxLength === 0) return false;
+
+  var sequences = punctuationConfig.sequences;
+  var maxLength = Math.min(trailing.length, punctuationConfig.maxLength);
+
+  for (var len = maxLength; len > 0; len--) {
+    var fragment = trailing.slice(-len);
+    if (sequences.has(fragment)) return true;
+  }
+  return false;
+}
+
+
+function is_printable_ascii(ch) {
+  if (!ch) return false;
+  var code = ch.charCodeAt(0);
+  return code >= ASCII_PRINTABLE_MIN && code <= ASCII_PRINTABLE_MAX;
+}
+
+
+function is_fullwidth_or_wide(ch) {
+  var width = get_cjk_width_class(ch);
+  return width === 'F' || width === 'W';
+}
+
+
+function get_cjk_width_class(ch) {
+  if (!ch) return '';
+  var codePoint = ch.codePointAt(0);
+  if (codePoint !== undefined && codePoint <= ASCII_PRINTABLE_MAX) return '';
+  var width = eastAsianWidth(ch);
+  return width === 'F' || width === 'W' || width === 'H' ? width : '';
+}
+
+
+function process_inlines(tokens, state, ctx, inlineToken) {
+  var i, j, last, trailing, next, c1, c2, remove_break;
+  var either = ctx.either;
+  var normalizeSoftBreaks = ctx.normalizeSoftBreaks;
+  var punctuationSpace = ctx.punctuationSpace;
+  var punctuationConfig = ctx.punctuationConfig;
+  var maxPunctuationLength = ctx.maxPunctuationLength;
+  var considerInlineBoundaries = ctx.considerInlineBoundaries;
+
+  if (normalizeSoftBreaks) normalize_text_tokens(tokens);
+
+  for (i = 0; i < tokens.length; i++) {
+    var isSoftbreakToken = tokens[i].type === 'softbreak';
+    var isTextBreakToken = tokens[i].type === 'text' && tokens[i].content === '\n';
+    if (!isSoftbreakToken && !isTextBreakToken) continue;
+
+    // default last/next character to space
+    last = next = ' ';
+    trailing = '';
+    var trailingMatchesPunctuation = false;
+
+    var skippedEmptyBefore = false;
+    var skippedEmptyAfter = false;
+
+    for (j = i - 1; j >= 0; j--) {
+      if (tokens[j].type !== 'text') continue;
+
+      var textContent = tokens[j].content;
+      if (!textContent) {
+        skippedEmptyBefore = true;
+        continue;
+      }
+      c1 = textContent.charCodeAt(textContent.length - 2);
+      c2 = textContent.charCodeAt(textContent.length - 1);
+
+      last = textContent.slice(is_surrogate(c1, c2) ? -2 : -1);
+      trailing = maxPunctuationLength > 0 ?
+        textContent.slice(-maxPunctuationLength) :
+        textContent.slice(-1);
+      if (!trailingMatchesPunctuation && punctuationSpace && punctuationConfig && maxPunctuationLength > 0 && trailing) {
+        trailingMatchesPunctuation = matches_punctuation_sequence(trailing, punctuationConfig);
+      }
+      break;
+    }
+
+    for (j = i + 1; j < tokens.length; j++) {
+      if (tokens[j].type !== 'text') continue;
+
+      if (!tokens[j].content) {
+        skippedEmptyAfter = true;
+        continue;
+      }
+
+      c1 = tokens[j].content.charCodeAt(0);
+      c2 = tokens[j].content.charCodeAt(1);
+
+      next = tokens[j].content.slice(0, is_surrogate(c1, c2) ? 2 : 1);
+      break;
+    }
+
+    remove_break = false;
+
+    // remove newline if it's adjacent to ZWSP
+    if (last === '\u200b' || next === '\u200b') remove_break = true;
+
+    var lastWidthClass = get_cjk_width_class(last);
+    var nextWidthClass = get_cjk_width_class(next);
+
+    // remove newline if both characters AND/OR fullwidth (F), wide (W) or
+    // halfwidth (H), but not Hangul
+    var tLast = lastWidthClass !== '';
+    var tNext = nextWidthClass !== '';
+
+    if (considerInlineBoundaries && (skippedEmptyBefore || skippedEmptyAfter) && tLast && tNext) {
+      tLast = false;
+      tNext = false;
+    }
+    if (either ? tLast || tNext : tLast && tNext) {
+      if (!is_hangul(last) && !is_hangul(next)) remove_break = true;
+    }
+
+    if (remove_break) {
+      var insertPunctuationSpace = false;
+      var nextIsFullwidthOrWide = nextWidthClass === 'F' || nextWidthClass === 'W';
+      if (punctuationSpace && punctuationConfig && trailingMatchesPunctuation && last && next && next !== '\u200b') {
+        if (is_printable_ascii(next) || nextIsFullwidthOrWide) insertPunctuationSpace = true;
+      }
+      tokens[i].type    = 'text';
+      tokens[i].content = insertPunctuationSpace ? punctuationSpace : '';
+    }
+  }
+
+  if (punctuationSpace && punctuationConfig) {
+    apply_missing_punctuation_spacing(tokens, inlineToken, punctuationSpace, punctuationConfig);
+  }
+}
+
+
+function normalize_text_tokens(tokens) {
+  for (var idx = 0; idx < tokens.length; idx++) {
+    var token = tokens[idx];
+    if (token.type !== 'text') continue;
+    if (!token.content || token.content.indexOf('\n') === -1) continue;
+
+    var replacement = split_text_token(token);
+    tokens.splice(idx, 1, replacement[0]);
+    if (replacement.length > 1) {
+      Array.prototype.splice.apply(tokens, [idx + 1, 0].concat(replacement.slice(1)));
+      idx += replacement.length - 1;
+    }
+  }
+}
+
+
+function split_text_token(token) {
+  var TokenConstructor = token.constructor;
+  var parts = [];
+  var content = token.content;
+  var start = 0;
+
+  for (var pos = 0; pos < content.length; pos++) {
+    if (content.charCodeAt(pos) !== 0x0A) continue;
+
+    if (pos > start) {
+      parts.push(clone_text_token(TokenConstructor, token, content.slice(start, pos)));
+    }
+
+    parts.push(create_softbreak_token(TokenConstructor, token));
+    start = pos + 1;
+  }
+
+  if (start < content.length) {
+    parts.push(clone_text_token(TokenConstructor, token, content.slice(start)));
+  }
+
+  if (parts.length === 0) parts.push(token);
+  return parts;
+}
+
+
+function clone_text_token(TokenConstructor, source, text) {
+  var cloned = new TokenConstructor('text', source.tag, 0);
+  copy_token_base(cloned, source);
+  cloned.content = text;
+  return cloned;
+}
+
+
+function create_softbreak_token(TokenConstructor, source) {
+  var softbreak = new TokenConstructor('softbreak', '', 0);
+  copy_token_base(softbreak, source);
+  softbreak.content = '';
+  softbreak.markup = '';
+  softbreak.info = '';
+  return softbreak;
+}
+
+
+function copy_token_base(target, source) {
+  target.level = source.level;
+  target.meta = source.meta ? Object.assign({}, source.meta) : source.meta;
+  target.block = source.block;
+  target.hidden = source.hidden;
+  target.markup = source.markup;
+  target.info = source.info;
+  target.children = source.children;
+  target.attrs = source.attrs ? source.attrs.slice() : source.attrs;
+  target.map = source.map ? source.map.slice() : source.map;
+}
+
+
+function apply_missing_punctuation_spacing(tokens, inlineToken, punctuationSpace, punctuationConfig) {
+  if (!inlineToken || !inlineToken.content) return;
+  if (inlineToken.content.indexOf('\n') === -1) return;
+  if (!tokens || tokens.length === 0) return;
+
+  var rawSearchState = { pos: 0 };
+
+  for (var idx = 0; idx < tokens.length; idx++) {
+    var current = tokens[idx];
+    if (!current || current.type !== 'text' || !current.content) continue;
+
+    var trailing = punctuationConfig.maxLength > 0 ?
+      current.content.slice(-punctuationConfig.maxLength) :
+      current.content.slice(-1);
+    if (!matches_punctuation_sequence(trailing, punctuationConfig)) continue;
+    if (/\s$/.test(current.content)) continue;
+
+    var nextInfo = find_next_visible_token(tokens, idx + 1);
+    if (!nextInfo) continue;
+    if (nextInfo.token.type === 'text' && /^\s/.test(nextInfo.token.content || '')) continue;
+
+    if (!raw_boundary_includes_newline(inlineToken.content, tokens, idx, nextInfo.index, nextInfo.fragment, rawSearchState)) {
+      continue;
+    }
+
+    insert_space_token(tokens, nextInfo.index, nextInfo.token, punctuationSpace);
+    idx = nextInfo.index;
+  }
+
+  apply_single_text_token_spacing(tokens, inlineToken, punctuationSpace, punctuationConfig);
+}
+
+
+function raw_boundary_includes_newline(source, tokens, fromIdx, nextIdx, afterFragment, state) {
+  if (!source || !afterFragment) return false;
+  var beforeFragment = tokens[fromIdx].content || '';
+  var betweenFragment = '';
+  for (var k = fromIdx + 1; k < nextIdx; k++) {
+    if (tokens[k].markup) betweenFragment += tokens[k].markup;
+  }
+  var candidate = beforeFragment + betweenFragment + '\n' + afterFragment;
+  if (!candidate) return false;
+  var startPos = source.indexOf(candidate, state.pos);
+  if (startPos === -1) return false;
+  state.pos = startPos + candidate.length - afterFragment.length;
+  return true;
+}
+
+
+function find_next_visible_token(tokens, startIdx) {
+  for (var idx = startIdx; idx < tokens.length; idx++) {
+    var token = tokens[idx];
+    if (!token) continue;
+    var fragment = derive_after_fragment(token);
+    if (!fragment) continue;
+    return { index: idx, token: token, fragment: fragment };
+  }
+  return null;
+}
+
+
+function derive_after_fragment(token) {
+  if (!token) return '';
+  if (token.type === 'text' || token.type === 'html_inline' || token.type === 'code_inline') {
+    return token.content || '';
+  }
+  if (token.type === 'image') return '![';
+  if (token.type === 'link_open') return '[';
+  if (token.type === 'inline') return token.content || '';
+  return '';
+}
+
+
+function insert_space_token(tokens, insertIndex, referenceToken, punctuationSpace) {
+  if (!punctuationSpace) return;
+  var TokenConstructor = (referenceToken && referenceToken.constructor) || (tokens[0] && tokens[0].constructor);
+  if (!TokenConstructor) return;
+  var spaceToken = new TokenConstructor('text', '', 0);
+  spaceToken.content = punctuationSpace;
+  spaceToken.markup = '';
+  spaceToken.info = '';
+  spaceToken.tag = '';
+  spaceToken.block = false;
+  spaceToken.hidden = false;
+  spaceToken.level = referenceToken ? referenceToken.level : 0;
+  spaceToken.meta = referenceToken && referenceToken.meta ? Object.assign({}, referenceToken.meta) : referenceToken ? referenceToken.meta : null;
+  spaceToken.children = null;
+  spaceToken.attrs = null;
+  spaceToken.map = null;
+  tokens.splice(insertIndex, 0, spaceToken);
+}
+
+
+function apply_single_text_token_spacing(tokens, inlineToken, punctuationSpace, punctuationConfig) {
+  if (!inlineToken || !inlineToken.content) return;
+  if (!tokens || tokens.length !== 1) return;
+  if (inlineToken.content.indexOf('\n') === -1) return;
+  var token = tokens[0];
+  if (!token || token.type !== 'text' || !token.content) return;
+
+  var segments = inlineToken.content.split('\n');
+  if (segments.length < 2) return;
+  var cumulativeLength = 0;
+  var offsetDelta = 0;
+  var updatedContent = token.content;
+  for (var segIdx = 0; segIdx < segments.length - 1; segIdx++) {
+    var leftRaw = segments[segIdx];
+    var rightRaw = segments[segIdx + 1];
+    var tail = extract_visible_tail(leftRaw, punctuationConfig.maxLength);
+    var nextChar = extract_visible_head(rightRaw);
+    var shouldInsert = tail &&
+      matches_punctuation_sequence(tail, punctuationConfig) &&
+      nextChar &&
+      (is_printable_ascii(nextChar) || is_fullwidth_or_wide(nextChar));
+
+    if (shouldInsert) {
+      var splitIndex = cumulativeLength + leftRaw.length + offsetDelta;
+      if (splitIndex >= 0 && splitIndex <= updatedContent.length) {
+        var existingChar = updatedContent.charAt(splitIndex);
+        if (existingChar && /\s/.test(existingChar)) {
+          // already has whitespace at this boundary
+          cumulativeLength += leftRaw.length;
+          continue;
+        }
+        updatedContent = updatedContent.slice(0, splitIndex) + punctuationSpace + updatedContent.slice(splitIndex);
+        offsetDelta += punctuationSpace.length;
+      }
+    }
+
+    cumulativeLength += leftRaw.length;
+  }
+
+  if (offsetDelta > 0) {
+    token.content = updatedContent;
+  }
+}
+
+
+function extract_visible_tail(raw, maxLength) {
+  if (!raw || !maxLength) return '';
+  var result = '';
+  for (var pos = raw.length; pos > 0 && result.length < maxLength;) {
+    var code = raw.codePointAt(pos - 1);
+    var charLen = code > 0xFFFF ? 2 : 1;
+    var ch = raw.slice(pos - charLen, pos);
+    pos -= charLen;
+    if (/\s/.test(ch)) continue;
+    if (is_markup_closer_char(ch)) continue;
+    result = ch + result;
+  }
+  return result;
+}
+
+
+function extract_visible_head(raw) {
+  if (!raw) return '';
+  for (var pos = 0; pos < raw.length;) {
+    var code = raw.codePointAt(pos);
+    var charLen = code > 0xFFFF ? 2 : 1;
+    var ch = raw.slice(pos, pos + charLen);
+    pos += charLen;
+    if (/\s/.test(ch)) continue;
+    return ch;
+  }
+  return '';
+}
+
+
+function is_markup_closer_char(ch) {
+  return ch === '*' || ch === '_' || ch === '~' || ch === '`';
+}
+
+
+export default function cjk_breaks_plugin(md, opts) {
+  var options = opts || {};
+  var punctuationSpace = resolve_punctuation_space_option(options);
+  var punctuationConfig = punctuationSpace ? resolve_punctuation_targets(options) : null;
+  var ctx = {
+    either: !!options.either,
+    normalizeSoftBreaks: !!options.normalizeSoftBreaks,
+    considerInlineBoundaries: !options.normalizeSoftBreaks,
+    punctuationSpace: punctuationSpace,
+    punctuationConfig: punctuationConfig,
+    maxPunctuationLength: punctuationConfig ? punctuationConfig.maxLength : 0
+  };
+
+  function cjk_breaks(state) {
+    for (var blkIdx = state.tokens.length - 1; blkIdx >= 0; blkIdx--) {
+      if (state.tokens[blkIdx].type !== 'inline') continue;
+      process_inlines(state.tokens[blkIdx].children, state, ctx, state.tokens[blkIdx]);
+    }
+  }
+  if (!md || !md.core || !md.core.ruler) return;
+  md.core.ruler.push('cjk_breaks', cjk_breaks);
+}

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@peaceroad/markdown-it-cjk-breaks-mod",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Suppress linebreaks between east asian (Especially Japanese) characters",
+  "repository": "https://github.com/peaceroad/markdown-it-cjk-breaks-mod.git",
+  "license": "MIT",
+  "scripts": {
+    "test": "node test/test.js"
+  },
+  "files": [
+    "index.js",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "eastasianwidth": "^0.3.0"
+  },
+  "devDependencies": {
+    "@peaceroad/markdown-it-strong-ja": "^0.5.3",
+    "markdown-it": "^14.1.0"
+  }
+}