rehype-han 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025
+
+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,43 @@
+# rehype-han
+
+Rehype plugin that wraps punctuation marks in an element with the class `cjk-punc`.
+
+## Install
+
+```sh
+npm install rehype-han
+```
+
+## Usage
+
+```js
+import { unified } from 'unified';
+import rehypeParse from 'rehype-parse';
+import rehypeStringify from 'rehype-stringify';
+import rehypeHan from 'rehype-han';
+
+const file = await unified()
+  .use(rehypeParse, { fragment: true })
+  .use(rehypeHan)
+  .use(rehypeStringify)
+  .process("<p>Mom's note——“中文”</p>");
+
+console.log(String(file));
+// => <p>Mom's note——</span><span class="cjk-punc">“</span>中文<span class="cjk-punc">”</span></p>
+```
+
+## Options
+
+- `className` (string, default: `cjk-punc`): base class applied to punctuation wrappers.
+- `tagName` (string, default: `span`): element used for punctuation wrappers.
+- `ignoreTags` (string[], default: `['script', 'style', 'noscript', 'code', 'pre', 'kbd', 'samp']`): tags whose descendants are left unchanged.
+
+## Behavior
+
+- Wrapping targets punctuation from Unicode `\p{P}` (including ASCII and full-width/CJK variants).
+- Exactly two consecutive em dashes (`——`) are wrapped as one token.
+- Exactly two consecutive CJK ellipsis characters (`……`) are wrapped as one token.
+- Single `-`, `–`, and `—` are intentionally excluded and never wrapped.
+- Percent-like signs `%`, `％`, `﹪`, `‰`, and `‱` are excluded from wrapping.
+- Latin-word apostrophes are excluded for `Latin + (' or ’) + Latin` and trailing possessives `Latin + (' or ’) + (space, punctuation, or end)` (for example `Mom’s`, `I’d`, `we’re`, `students' work`).
+- Punctuation already inside an existing configured wrapper is not wrapped again.

package/index.js

@@ -0,0 +1,322 @@
+import { visitParents } from 'unist-util-visit-parents';
+
+const DEFAULT_IGNORE_TAGS = [
+  'script',
+  'style',
+  'noscript',
+  'code',
+  'pre',
+  'kbd',
+  'samp',
+];
+
+const PUNCTUATION_REGEX = /\p{P}/u;
+const LATIN_LETTER_REGEX = /\p{Script=Latin}/u;
+const WHITESPACE_REGEX = /\s/u;
+const EXCLUDED_PUNCTUATION = new Set([
+  '-',
+  '–',
+  '—',
+  '%',
+  '％',
+  '﹪',
+  '‰',
+  '‱',
+]);
+const ENGLISH_IN_WORD_APOSTROPHES = new Set(["'", '’']);
+const EM_DASH = '—';
+const DOUBLE_EM_DASH = '——';
+const ELLIPSIS = '…';
+const DOUBLE_ELLIPSIS = '……';
+const LEFT_COMPRESSION_MARKS = new Set(['“', '‘', '《', '「', '『', '（']);
+const RIGHT_COMPRESSION_MARKS = new Set(['”', '’', '》', '」', '』', '）']);
+const ADJACENCY_TARGET_MARKS = new Set([
+  '，',
+  '。',
+  '？',
+  '！',
+  '；',
+  '：',
+  '、',
+]);
+const ADJ_LEFT_CLASS = 'adj-l';
+const ADJ_RIGHT_CLASS = 'adj-r';
+const ADJ_MIDDLE_CLASS = 'adj-m';
+
+function isWrappablePunctuation(ch) {
+  return PUNCTUATION_REGEX.test(ch) && !EXCLUDED_PUNCTUATION.has(ch);
+}
+
+function isLatinLetter(ch) {
+  return Boolean(ch) && LATIN_LETTER_REGEX.test(ch);
+}
+
+function isEnglishWordApostrophe(chars, index) {
+  const ch = chars[index];
+  const previousChar = chars[index - 1];
+  const nextChar = chars[index + 1];
+
+  if (!ENGLISH_IN_WORD_APOSTROPHES.has(ch)) {
+    return false;
+  }
+
+  if (!isLatinLetter(previousChar)) {
+    return false;
+  }
+
+  if (isLatinLetter(nextChar)) {
+    return true;
+  }
+
+  return (
+    !nextChar ||
+    WHITESPACE_REGEX.test(nextChar) ||
+    PUNCTUATION_REGEX.test(nextChar)
+  );
+}
+
+function splitPunctuationChunks(value) {
+  const chars = Array.from(value);
+  const parts = [];
+  let textBuffer = '';
+
+  for (let index = 0; index < chars.length; index += 1) {
+    const ch = chars[index];
+
+    if (ch === EM_DASH && chars[index + 1] === EM_DASH) {
+      if (textBuffer) {
+        parts.push({ type: 'text', value: textBuffer });
+        textBuffer = '';
+      }
+
+      parts.push({ type: 'punctuation', value: DOUBLE_EM_DASH });
+      index += 1;
+      continue;
+    }
+
+    if (ch === ELLIPSIS && chars[index + 1] === ELLIPSIS) {
+      if (textBuffer) {
+        parts.push({ type: 'text', value: textBuffer });
+        textBuffer = '';
+      }
+
+      parts.push({ type: 'punctuation', value: DOUBLE_ELLIPSIS });
+      index += 1;
+      continue;
+    }
+
+    if (isWrappablePunctuation(ch) && !isEnglishWordApostrophe(chars, index)) {
+      if (textBuffer) {
+        parts.push({ type: 'text', value: textBuffer });
+        textBuffer = '';
+      }
+
+      parts.push({ type: 'punctuation', value: ch });
+      continue;
+    }
+
+    textBuffer += ch;
+  }
+
+  if (textBuffer) {
+    parts.push({ type: 'text', value: textBuffer });
+  }
+
+  return parts;
+}
+
+function getAdjacencyClasses(parts) {
+  const adjacencyClasses = new Map();
+
+  function addAdjacencyClass(index, className) {
+    const classes = adjacencyClasses.get(index);
+
+    if (classes) {
+      classes.add(className);
+      return;
+    }
+
+    adjacencyClasses.set(index, new Set([className]));
+  }
+
+  function isQuoteBracketWrapper(value) {
+    return (
+      LEFT_COMPRESSION_MARKS.has(value) || RIGHT_COMPRESSION_MARKS.has(value)
+    );
+  }
+
+  for (let index = 0; index < parts.length; index += 1) {
+    const part = parts[index];
+
+    if (part.type !== 'punctuation') {
+      continue;
+    }
+
+    if (LEFT_COMPRESSION_MARKS.has(part.value)) {
+      const leftNeighbor = parts[index - 1];
+
+      if (
+        leftNeighbor &&
+        leftNeighbor.type === 'punctuation' &&
+        ADJACENCY_TARGET_MARKS.has(leftNeighbor.value)
+      ) {
+        addAdjacencyClass(index - 1, ADJ_LEFT_CLASS);
+      }
+    }
+
+    if (RIGHT_COMPRESSION_MARKS.has(part.value)) {
+      const rightNeighbor = parts[index + 1];
+      let leftNeighborIndex = index - 1;
+
+      while (leftNeighborIndex >= 0) {
+        const leftNeighbor = parts[leftNeighborIndex];
+
+        if (leftNeighbor.type !== 'punctuation') {
+          break;
+        }
+
+        if (isQuoteBracketWrapper(leftNeighbor.value)) {
+          leftNeighborIndex -= 1;
+          continue;
+        }
+
+        if (ADJACENCY_TARGET_MARKS.has(leftNeighbor.value)) {
+          addAdjacencyClass(leftNeighborIndex, ADJ_LEFT_CLASS);
+        }
+
+        break;
+      }
+
+      if (
+        rightNeighbor &&
+        rightNeighbor.type === 'punctuation' &&
+        ADJACENCY_TARGET_MARKS.has(rightNeighbor.value)
+      ) {
+        addAdjacencyClass(index + 1, ADJ_RIGHT_CLASS);
+      }
+    }
+  }
+
+  for (const [index, classes] of adjacencyClasses) {
+    if (classes.has(ADJ_LEFT_CLASS) && classes.has(ADJ_RIGHT_CLASS)) {
+      adjacencyClasses.set(index, new Set([ADJ_MIDDLE_CLASS]));
+    }
+  }
+
+  return adjacencyClasses;
+}
+
+function toClassList(className) {
+  return className
+    .split(/\s+/)
+    .map((entry) => entry.trim())
+    .filter(Boolean);
+}
+
+function hasClassName(properties, className) {
+  if (!properties || !properties.className) {
+    return false;
+  }
+
+  const expectedClassNames = toClassList(className);
+  const classList = Array.isArray(properties.className)
+    ? properties.className
+    : String(properties.className).split(/\s+/);
+
+  return expectedClassNames.every((entry) => classList.includes(entry));
+}
+
+function hasIgnoredAncestor(ancestors, ignoreTags) {
+  return ancestors.some(
+    (node) => node.type === 'element' && ignoreTags.has(node.tagName)
+  );
+}
+
+function hasWrapperAncestor(ancestors, tagName, className) {
+  return ancestors.some(
+    (node) =>
+      node.type === 'element' &&
+      node.tagName === tagName &&
+      hasClassName(node.properties, className)
+  );
+}
+
+export default function rehypeLangEn(options = {}) {
+  const className =
+    typeof options.className === 'string' && options.className.trim()
+      ? options.className.trim()
+      : 'cjk-punc';
+
+  const tagName =
+    typeof options.tagName === 'string' && options.tagName.trim()
+      ? options.tagName.trim()
+      : 'span';
+
+  const ignoreTags = new Set(
+    Array.isArray(options.ignoreTags) && options.ignoreTags.length > 0
+      ? options.ignoreTags.map((tag) => String(tag))
+      : DEFAULT_IGNORE_TAGS
+  );
+
+  const classList = toClassList(className);
+
+  return (tree) => {
+    visitParents(tree, 'text', (node, ancestors) => {
+      const parent = ancestors[ancestors.length - 1];
+
+      if (!parent || parent.type !== 'element') {
+        return;
+      }
+
+      if (hasIgnoredAncestor(ancestors, ignoreTags)) {
+        return;
+      }
+
+      if (hasWrapperAncestor(ancestors, tagName, className)) {
+        return;
+      }
+
+      if (!node.value || typeof node.value !== 'string') {
+        return;
+      }
+
+      const parts = splitPunctuationChunks(node.value);
+      const adjacencyClasses = getAdjacencyClasses(parts);
+
+      if (parts.length === 1 && parts[0].type === 'text') {
+        return;
+      }
+
+      const replacement = parts.map((part, partIndex) => {
+        if (part.type === 'text') {
+          return { type: 'text', value: part.value };
+        }
+
+        const markClassList = classList.slice();
+        const extraClasses = adjacencyClasses.get(partIndex);
+
+        if (extraClasses) {
+          for (const entry of extraClasses) {
+            if (!markClassList.includes(entry)) {
+              markClassList.push(entry);
+            }
+          }
+        }
+
+        return {
+          type: 'element',
+          tagName,
+          properties: { className: markClassList },
+          children: [{ type: 'text', value: part.value }],
+        };
+      });
+
+      const nodeIndex = parent.children.indexOf(node);
+      if (nodeIndex === -1) {
+        return;
+      }
+
+      parent.children.splice(nodeIndex, 1, ...replacement);
+    });
+  };
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "rehype-han",
+  "version": "0.1.0",
+  "description": "Rehype plugin to wrap text segments with proper tags.",
+  "type": "module",
+  "main": "./index.js",
+  "exports": "./index.js",
+  "files": [
+    "index.js",
+    "README.md"
+  ],
+  "keywords": [
+    "rehype",
+    "rehype-plugin",
+    "unist",
+    "hast",
+    "latin",
+    "cjk"
+  ],
+  "license": "MIT",
+  "author": "ivorkchan",
+  "engines": {
+    "node": ">=16"
+  },
+  "scripts": {
+    "test": "node --test",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "format": "prettier . --write --ignore-unknown",
+    "format:check": "prettier . --check --ignore-unknown"
+  },
+  "dependencies": {
+    "unist-util-visit-parents": "^6.0.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "eslint": "^10.0.0",
+    "prettier": "^3.8.1",
+    "rehype-parse": "^9.0.0",
+    "rehype-stringify": "^9.0.0",
+    "unified": "^11.0.0"
+  }
+}