palt-typesetting 0.2.1 → 0.4.0

package/dist/index.js

@@ -1,73 +1,109 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const html_processor_1 = __importDefault(require("./html-processor"));
-const insert_separators_1 = __importDefault(require("./insert-separators"));
-const apply_style_1 = require("./apply-style");
-const win_1 = __importDefault(require("./win"));
-class Typesetter extends html_processor_1.default {
-    constructor(options = {}) {
-        const transformFunctions = [apply_style_1.applyStyleToText, insert_separators_1.default, apply_style_1.applyStyleToSegment];
-        const validatedOptions = Typesetter.validateOptions(options);
-        super(transformFunctions, validatedOptions);
-        this.isIntlSegmenterSupported = typeof Intl.Segmenter !== 'undefined';
-        if (!this.isIntlSegmenterSupported) {
-            console.warn(`
+import HTMLProcessor from "./html-processor";
+import insertSeparatorsToText from "./insert-separators";
+import { applyStyleToText, applyStyleToSegment, applyKerningToSegment } from "./apply-style";
+import win from "./win";
+class Typesetter extends HTMLProcessor {
+  /**
+   * Typesetter のデフォルトの設定を返します。
+   */
+  static getDefaultOptions() {
+    return {
+      useWordBreak: true,
+      wrapLatin: true,
+      noSpaceBetweenNoBreaks: true,
+      insertThinSpaces: true,
+      thinSpaceWidth: "0.2em",
+      kerningRules: []
+    };
+  }
+  constructor(options = {}) {
+    const transformFunctions = [applyStyleToText, insertSeparatorsToText, applyStyleToSegment, applyKerningToSegment];
+    const validatedOptions = Typesetter.validateOptions(options);
+    super(transformFunctions, validatedOptions);
+    this.isIntlSegmenterSupported = typeof Intl.Segmenter !== "undefined";
+    if (!this.isIntlSegmenterSupported) {
+      console.warn(`
         Intl.Segmenter is not supported in this environment. 
         The original HTML string will be returned. 
         For more information, see: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter
         `);
-        }
     }
-    static validateOptions(options) {
-        if (options.kerningRules) {
-            options.kerningRules = options.kerningRules.filter(Typesetter.isValidKerningRule);
-        }
-        return Object.assign(Object.assign({}, Typesetter.defaultOptions), options);
+  }
+  /**
+   * 与えられたオプションを検証し、修正されたオプションを返します。
+   *
+   * @param options - 検証するオプション。
+   * @return 修正されたオプション。
+   */
+  static validateOptions(options) {
+    if (options.kerningRules) {
+      options.kerningRules = options.kerningRules.filter(Typesetter.isValidKerningRule);
+    }
+    return {
+      ...Typesetter.getDefaultOptions(),
+      ...options
+    };
+  }
+  /**
+   * カーニングルールが適切かどうかを検証します。
+   *
+   * @param kerningRule - 検証するカーニングルール。
+   * @return ルールが有効な場合はtrue、そうでない場合はfalse。
+   */
+  static isValidKerningRule(kerningRule) {
+    if (kerningRule.between[0].length !== 1 || kerningRule.between[1].length !== 1) {
+      console.warn(
+        `Kerning rule between '${kerningRule.between[0]}' and '${kerningRule.between[1]}' must be single characters.`
+      );
+      return false;
     }
-    static isValidKerningRule(kerningRule) {
-        if (kerningRule.between[0].length !== 1 || kerningRule.between[1].length !== 1) {
-            console.warn(`Kerning rule between '${kerningRule.between[0]}' and '${kerningRule.between[1]}' must be single characters.`);
-            return false;
-        }
-        return true;
+    return true;
+  }
+  /**
+   * 与えられたHTML文字列を処理し、指定されたスタイルと区切り文字を適用した結果を返します。
+   *
+   * @param srcHtml - 処理するHTML文字列。
+   * @return 処理後のHTML文字列。
+   */
+  render(srcHtml) {
+    if (!this.isIntlSegmenterSupported || !srcHtml) {
+      return srcHtml;
     }
-    render(srcHtml) {
-        if (!this.isIntlSegmenterSupported || !srcHtml) {
-            return srcHtml;
-        }
-        return this.processHtmlWithFunctions(srcHtml);
+    return this.processHtmlWithFunctions(srcHtml);
+  }
+  /**
+   * 与えられたElementまたはElementの配列に対して、スタイルと区切り文字を適用します。
+   * 各要素のinnerHTMLを取得し、変換処理を適用した後、変換されたHTMLで元の内容を置き換えます。
+   *
+   * @param elements - スタイルを適用するElementまたはHTMLElementの配列。
+   */
+  renderToElements(elements) {
+    if (!this.isIntlSegmenterSupported || !elements) {
+      return;
     }
-    renderToElements(elements) {
-        if (!this.isIntlSegmenterSupported || !elements) {
-            return;
-        }
-        if (!Array.isArray(elements)) {
-            elements = [elements];
-        }
-        elements.forEach(element => {
-            const processedHtml = this.render(element.innerHTML);
-            element.innerHTML = processedHtml;
-        });
+    if (!Array.isArray(elements)) {
+      elements = [elements];
     }
-    renderToSelector(selector) {
-        if (!this.isIntlSegmenterSupported || !selector) {
-            return;
-        }
-        const elements = win_1.default.document.querySelectorAll(selector);
-        this.renderToElements(Array.from(elements));
+    elements.forEach((element) => {
+      const processedHtml = this.render(element.innerHTML);
+      element.innerHTML = processedHtml;
+    });
+  }
+  /**
+   * 指定されたCSSセレクタに一致するすべての要素にスタイルを適用します。
+   * document.querySelectorAllを使用して要素を取得し、それぞれに対してスタイル適用処理を行います。
+   *
+   * @param selector - スタイルを適用する要素を選択するCSSセレクタ。
+   */
+  renderToSelector(selector) {
+    if (!this.isIntlSegmenterSupported || !selector) {
+      return;
     }
+    const elements = win.document.querySelectorAll(selector);
+    this.renderToElements(Array.from(elements));
+  }
 }
-Typesetter.defaultOptions = {
-    classNamePrefix: 'typeset',
-    useWordBreak: true,
-    wrapLatin: true,
-    noSpaceBetweenNoBreaks: true,
-    insertThinSpaces: true,
-    thinSpaceWidth: '50%',
-    kerningRules: [],
+var src_default = Typesetter;
+export {
+  src_default as default
 };
-exports.default = Typesetter;
-//# sourceMappingURL=index.js.map

package/dist/insert-separators.d.ts

@@ -1,9 +1,9 @@
-import { TypesettingOptions } from './types';
+import { TypesettingOptions } from '../types';
 declare const insertSeparatorsToText: (currentText: string, nextText: string, options: TypesettingOptions) => string;
 declare const createSegments: (src: string) => string[];
 declare const addSeparatorsToSegment: (current: string, next: string | undefined, options: TypesettingOptions) => string;
-declare const shouldAddWbr: (current: string, next: string) => boolean | null;
 declare const shouldAddThinSpace: (current: string, next: string) => boolean;
+declare const isBreakable: (current: string, next: string) => boolean;
 export default insertSeparatorsToText;
-export { createSegments, addSeparatorsToSegment, shouldAddWbr, shouldAddThinSpace };
+export { createSegments, addSeparatorsToSegment, shouldAddThinSpace, isBreakable };
 //# sourceMappingURL=insert-separators.d.ts.map

package/dist/insert-separators.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"insert-separators.d.ts","sourceRoot":"","sources":["../src/insert-separators.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAA;AAQ5C,QAAA,MAAM,sBAAsB,gBAAiB,MAAM,YAAY,MAAM,WAAW,kBAAkB,KAAG,MAWpG,CAAA;AAOD,QAAA,MAAM,cAAc,QAAS,MAAM,KAAG,MAAM,EAG3C,CAAA;AAQD,QAAA,MAAM,sBAAsB,YAAa,MAAM,qCAAsB,kBAAkB,KAAG,MAUzF,CAAA;AAQD,QAAA,MAAM,YAAY,YAAa,MAAM,QAAQ,MAAM,KAAG,OAAO,GAAG,IAK/D,CAAA;AAQD,QAAA,MAAM,kBAAkB,YAAa,MAAM,QAAQ,MAAM,KAAG,OAE3D,CAAA;AAED,eAAe,sBAAsB,CAAA;AACrC,OAAO,EAAE,cAAc,EAAE,sBAAsB,EAAE,YAAY,EAAE,kBAAkB,EAAE,CAAA"}
+{"version":3,"file":"insert-separators.d.ts","sourceRoot":"","sources":["../src/insert-separators.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAA;AAQ7C,QAAA,MAAM,sBAAsB,gBAAiB,MAAM,YAAY,MAAM,WAAW,kBAAkB,KAAG,MAWpG,CAAA;AAOD,QAAA,MAAM,cAAc,QAAS,MAAM,KAAG,MAAM,EAG3C,CAAA;AAQD,QAAA,MAAM,sBAAsB,YAAa,MAAM,qCAAsB,kBAAkB,KAAG,MAezF,CAAA;AAQD,QAAA,MAAM,kBAAkB,YAAa,MAAM,QAAQ,MAAM,KAAG,OAE3D,CAAA;AAQD,QAAA,MAAM,WAAW,YAAa,MAAM,QAAQ,MAAM,KAAG,OAKpD,CAAA;AAED,eAAe,sBAAsB,CAAA;AACrC,OAAO,EAAE,cAAc,EAAE,sBAAsB,EAAE,kBAAkB,EAAE,WAAW,EAAE,CAAA"}

package/dist/insert-separators.js

@@ -1,47 +1,47 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.shouldAddThinSpace = exports.shouldAddWbr = exports.addSeparatorsToSegment = exports.createSegments = void 0;
-const linebreak_1 = __importDefault(require("linebreak"));
-const utils_text_classes_1 = require("./utils-text-classes");
-const utils_tags_1 = require("./utils-tags");
+import LineBreaker from "linebreak";
+import { CharClass, LanguageClass } from "./util-text-classes";
+import { createWbr, createThinSpace } from "./util-tags";
 const insertSeparatorsToText = (currentText, nextText, options) => {
-    const currentSegments = createSegments(currentText);
-    const nextSegments = createSegments(nextText);
-    const formattedText = currentSegments.reduce((accumulatedText, segment, index, array) => {
-        const current = segment;
-        const next = array[index + 1] || nextSegments[0];
-        return accumulatedText + addSeparatorsToSegment(current, next, options);
-    }, '');
-    return formattedText;
+  const currentSegments = createSegments(currentText);
+  const nextSegments = createSegments(nextText);
+  const formattedText = currentSegments.reduce((accumulatedText, segment, index, array) => {
+    const current = segment;
+    const next = array[index + 1] || nextSegments[0];
+    return accumulatedText + addSeparatorsToSegment(current, next, options);
+  }, "");
+  return formattedText;
 };
 const createSegments = (src) => {
-    const segmenter = new Intl.Segmenter('ja-JP', { granularity: 'word' });
-    return Array.from(segmenter.segment(src), ({ segment }) => segment);
-};
-exports.createSegments = createSegments;
-const addSeparatorsToSegment = (current, next = '', options) => {
-    if (!next)
-        return current;
-    const addWbr = options.useWordBreak && shouldAddWbr(current, next);
-    const addSpace = options.insertThinSpaces && shouldAddThinSpace(current, next);
-    return (current +
-        (addSpace ? (0, utils_tags_1.createThinSpaceSpan)(options.thinSpaceWidth, options.classNamePrefix) : '') +
-        (addWbr ? utils_tags_1.wbr : ''));
+  const segmenter = new Intl.Segmenter("ja-JP", { granularity: "word" });
+  return Array.from(segmenter.segment(src), ({ segment }) => segment);
 };
-exports.addSeparatorsToSegment = addSeparatorsToSegment;
-const shouldAddWbr = (current, next) => {
-    const combinedText = current.slice(-1) + next.slice(0, 1);
-    const lb = new linebreak_1.default(combinedText);
-    const breakOpportunity = lb.nextBreak();
-    return breakOpportunity && breakOpportunity.position === 1;
+const addSeparatorsToSegment = (current, next = "", options) => {
+  if (!next)
+    return current;
+  const addThinSpace = options.insertThinSpaces && shouldAddThinSpace(current, next);
+  const breakable = isBreakable(current, next);
+  if (addThinSpace) {
+    return current + createThinSpace(options.thinSpaceWidth, breakable);
+  }
+  if (options.useWordBreak && breakable) {
+    return current + createWbr();
+  }
+  return current;
 };
-exports.shouldAddWbr = shouldAddWbr;
 const shouldAddThinSpace = (current, next) => {
-    return utils_text_classes_1.LanguageClass.shouldAddThinSpace(current, next) || utils_text_classes_1.CharClass.shouldAddThinSpace(current, next);
+  return LanguageClass.shouldAddThinSpace(current, next) || CharClass.shouldAddThinSpace(current, next);
+};
+const isBreakable = (current, next) => {
+  const combinedText = current.slice(-1) + next.slice(0, 1);
+  const lb = new LineBreaker(combinedText);
+  const breakOpportunity = lb.nextBreak();
+  return breakOpportunity ? breakOpportunity.position === 1 : false;
+};
+var insert_separators_default = insertSeparatorsToText;
+export {
+  addSeparatorsToSegment,
+  createSegments,
+  insert_separators_default as default,
+  isBreakable,
+  shouldAddThinSpace
 };
-exports.shouldAddThinSpace = shouldAddThinSpace;
-exports.default = insertSeparatorsToText;
-//# sourceMappingURL=insert-separators.js.map

package/dist/style/typesetting.css

@@ -0,0 +1,27 @@
+@font-face {
+  /* 
+   * カスタムフォント: 1/10000 UPM 幅のスペースとノンブレーキングスペースを定義。
+   * 注意：完全なゼロ幅スペースを使用すると、Safari では letter-spacing が無視される。
+   * @sharapeco による貢献に感謝します。{@link https://gist.github.com/sharapeco/1dd7f4433dad07648e1325e1fa5926ee}
+   */
+  font-family: ling-one;
+  src: url('data:font/woff2;base64,AAEAAAAKAIAAAwAgT1MvMhG03xcAAAEoAAAAYGNtYXAADABzAAABkAAAADRnbHlmJAM2GwAAAcwAAAAYaGVhZCLbfFwAAACsAAAANmhoZWEnEvkrAAAA5AAAACRobXR4AAEAAAAAAYgAAAAIbG9jYQAMABgAAAHEAAAACG1heHAAcQAiAAABCAAAACBuYW1lBbsdPAAAAeQAAACKcG9zdHQrY6cAAAJwAAAALQABAAAAAQAAsWqD8F8PPPUAAycQAAAAAOHcugAAAAAA4edeTwAAAAAAAQABAAAABwACAAAAAAAAAAEAACcQ+DAAAAB9AAAAfAABAAEAAAAAAAAAAAAAAAAAAAABAAEAAAADAAMAAQAAAAAAAQACAB4ABgAAAGQAAAAAAAAAAwB9AZAABQAIGWQXcAAAAu4ZZBdwAAANrAAyC7gAAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAc3N6bQBAACAAIB9A+DAH0CcQB9AAAAABAAAAABOIG1gAAAAgAAAAAQAAAAAAAAAAAAIAAAADAAAAFAADAAEAAAAUAAQAIAAAAAQABAABAAAAIP//AAAAIP///+EAAQAAAAAAAAAMAAwADAABAAAAAAABAAEAAgAANRcjAQEBAQAAAAAAAAYATgADAAEECQABAAgAAAADAAEECQACAAIACAADAAEECQADAB4ACgADAAEECQAEAAwAKAADAAEECQAFAAgANAADAAEECQAGAAwAKABMAGkAbgBnADEAMQAuADAAOwBzAHMAegBtADsATABpAG4AZwAtADEATABpAG4AZwAtADEAdgAxAC4AMAAAAAIAAAAAAAD/tQAyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAMBAgRuYnNwAAAA')
+    format('woff2');
+}
+
+.typeset-word-break {
+  word-break: keep-all;
+  overflow-wrap: anywhere;
+}
+
+.typeset-thin-space,
+.typeset-kerning {
+  font-family: ling-one; /* カスタムフォントのスペースを使用します。 */
+  line-height: 0; /* 空白による行の高さの影響を無視します。 */
+  letter-spacing: 0; /* 親要素から継承される letter-spacing の影響を無視します。 */
+  user-select: none; /* ユーザーによるテキストのコピーを無効にします。 */
+}
+
+.typeset-no-breaks {
+  letter-spacing: 0; /* 親要素から継承される letter-spacing の影響を無視します。 */
+}

package/dist/{utils-regex.d.ts → util-regex.d.ts}

@@ -3,5 +3,7 @@ export declare const japaneseRegex: RegExp;
 export declare const openingsRegex: RegExp;
 export declare const closingsRegex: RegExp;
 export declare const middleDotsRegex: RegExp;
+export declare const commasRegex: RegExp;
+export declare const periodsRegex: RegExp;
 export declare const noBreakRulesRegex: RegExp;
-//# sourceMappingURL=utils-regex.d.ts.map
+//# sourceMappingURL=util-regex.d.ts.map

package/dist/util-regex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util-regex.d.ts","sourceRoot":"","sources":["../src/util-regex.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,UAAU,QAC4E,CAAA;AAKnG,eAAO,MAAM,aAAa,QAAwD,CAAA;AAKlF,eAAO,MAAM,aAAa,QAA8B,CAAA;AAKxD,eAAO,MAAM,aAAa,QAA8B,CAAA;AAKxD,eAAO,MAAM,eAAe,QAAU,CAAA;AAKtC,eAAO,MAAM,WAAW,QAAQ,CAAA;AAKhC,eAAO,MAAM,YAAY,QAAQ,CAAA;AAKjC,eAAO,MAAM,iBAAiB,QAE7B,CAAA"}

package/dist/util-regex.js

@@ -0,0 +1,20 @@
+const latinRegex = /[\p{scx=Latin}0-9⁰¹²³⁴-⁾₀-₎¢¤$€£¥+−×÷=≠><≥≤±≈~¬∅∞∫∏∑√∂%‰@&.,:;!¡?¿'"‘’“”\-(){}[\]|/\\^_`*#\s]+/u;
+const japaneseRegex = /[\p{scx=Hiragana}\p{scx=Katakana}|ｦ-ﾟ\p{scx=Han}]+/u;
+const openingsRegex = /（|［|｛|〔|〈|《|「|『|【|〘|〖|“|‘/;
+const closingsRegex = /）|］|｝|〕|〉|》|」|』|】|〙|〗|”|’/;
+const middleDotsRegex = /・|：|；/;
+const commasRegex = /、|，/;
+const periodsRegex = /。|．/;
+const noBreakRulesRegex = new RegExp(
+  `[${"\u2014\u2025\u2026\uFF3F"}${String.fromCharCode(9472)}-${String.fromCharCode(9599)}]+`
+);
+export {
+  closingsRegex,
+  commasRegex,
+  japaneseRegex,
+  latinRegex,
+  middleDotsRegex,
+  noBreakRulesRegex,
+  openingsRegex,
+  periodsRegex
+};

package/dist/util-tags.d.ts

@@ -0,0 +1,9 @@
+import './style/typesetting.css';
+declare const createWbr: () => string;
+declare const createThinSpace: (thisSpaceWidth: string, breakable?: boolean) => string;
+declare const createKerning: (kerningValue: number, breakable?: boolean) => string;
+declare const applyWrapperStyle: (text: string, useWordBreak: boolean) => string;
+declare const applyLatinStyle: (segment: string) => string;
+declare const applyNoBreaksStyle: (segment: string) => string;
+export { createWbr, createThinSpace, createKerning, applyWrapperStyle, applyLatinStyle, applyNoBreaksStyle };
+//# sourceMappingURL=util-tags.d.ts.map

package/dist/util-tags.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util-tags.d.ts","sourceRoot":"","sources":["../src/util-tags.ts"],"names":[],"mappings":"AAAA,OAAO,yBAAyB,CAAA;AAMhC,QAAA,MAAM,SAAS,QAAO,MAErB,CAAA;AAQD,QAAA,MAAM,eAAe,mBAAoB,MAAM,cAAc,OAAO,KAAG,MAMtE,CAAA;AASD,QAAA,MAAM,aAAa,iBAAkB,MAAM,cAAc,OAAO,KAAG,MAiBlE,CAAA;AAQD,QAAA,MAAM,iBAAiB,SAAU,MAAM,gBAAgB,OAAO,KAAG,MAKhE,CAAA;AAOD,QAAA,MAAM,eAAe,YAAa,MAAM,KAAG,MAG1C,CAAA;AAOD,QAAA,MAAM,kBAAkB,YAAa,MAAM,KAAG,MAG7C,CAAA;AAuBD,OAAO,EAAE,SAAS,EAAE,eAAe,EAAE,aAAa,EAAE,iBAAiB,EAAE,eAAe,EAAE,kBAAkB,EAAE,CAAA"}

package/dist/util-tags.js

@@ -0,0 +1,55 @@
+import "./style/typesetting.css";
+const createWbr = () => {
+  return "<wbr>";
+};
+const createThinSpace = (thisSpaceWidth, breakable) => {
+  const content = breakable ? " " : "&nbsp;";
+  const className = "typeset-thin-space";
+  const style = `letter-spacing: ${thisSpaceWidth};`;
+  const uiIgnored = true;
+  return createStyledSpan(content, className, style, uiIgnored);
+};
+const createKerning = (kerningValue, breakable) => {
+  if (kerningValue === 0)
+    return "";
+  const className = "typeset-kerning";
+  const uiIgnored = true;
+  if (kerningValue < 0) {
+    const content = "";
+    const emValue = kerningValue / 1e3 / 2 + "em";
+    const style = `margin: ${emValue};`;
+    return createStyledSpan(content, className, style, uiIgnored);
+  } else {
+    const content = breakable ? " " : "&nbsp;";
+    const emValue = kerningValue / 1e3 + "em";
+    const style = `letter-spacing: ${emValue};`;
+    return createStyledSpan(content, className, style, uiIgnored);
+  }
+};
+const applyWrapperStyle = (text, useWordBreak) => {
+  const wrapperName = "typeset";
+  const wordBreakName = "typeset-word-break";
+  const className = useWordBreak ? `${wrapperName} ${wordBreakName}` : wrapperName;
+  return createStyledSpan(text, className);
+};
+const applyLatinStyle = (segment) => {
+  const className = "typeset-latin";
+  return createStyledSpan(segment, className);
+};
+const applyNoBreaksStyle = (segment) => {
+  const className = "typeset-no-breaks";
+  return createStyledSpan(segment, className);
+};
+const createStyledSpan = (content, className, style = "", uiIgnored = false) => {
+  const styleAttr = style ? ` style="${style}"` : "";
+  const extraAttrs = uiIgnored ? ' aria-hidden="true" data-nosnippet=""' : "";
+  return `<span class="${className}"${styleAttr}${extraAttrs}>${content}</span>`;
+};
+export {
+  applyLatinStyle,
+  applyNoBreaksStyle,
+  applyWrapperStyle,
+  createKerning,
+  createThinSpace,
+  createWbr
+};

package/dist/{utils-text-classes.d.ts → util-text-classes.d.ts}

@@ -1,12 +1,13 @@
 declare const CharClass: {
     shouldNotBreak: (segment: string) => boolean;
     shouldAddThinSpace: (current: string, next: string) => boolean;
+    startsWithPunctuation: (segment: string) => boolean;
 };
 declare const LanguageClass: {
     isLatin: (segment: string) => boolean;
     isJapanese: (segment: string) => boolean;
-    isDifferentLanguageClass: (current: string, next: string) => boolean;
+    hasLanguageTransition: (current: string, next: string) => boolean;
     shouldAddThinSpace: (current: string, next: string) => boolean;
 };
 export { CharClass, LanguageClass };
-//# sourceMappingURL=utils-text-classes.d.ts.map
+//# sourceMappingURL=util-text-classes.d.ts.map

package/dist/util-text-classes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util-text-classes.d.ts","sourceRoot":"","sources":["../src/util-text-classes.ts"],"names":[],"mappings":"AAOA,QAAA,MAAM,SAAS;8BAMa,MAAM,KAAG,OAAO;kCAUZ,MAAM,QAAQ,MAAM,KAAG,OAAO;qCA0C3B,MAAM,KAAG,OAAO;CAKlD,CAAA;AAOD,QAAA,MAAM,aAAa;uBAME,MAAM,KAAG,OAAO;0BASb,MAAM,KAAG,OAAO;qCAWL,MAAM,QAAQ,MAAM,KAAG,OAAO;kCAUjC,MAAM,QAAQ,MAAM,KAAG,OAAO;CAG7D,CAAA;AAED,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,CAAA"}

package/dist/util-text-classes.js

@@ -0,0 +1,98 @@
+import * as util from "./util-regex";
+const CharClass = {
+  /**
+   * セグメントが分離禁則文字で構成されているかどうかを判定します。
+   * @param segment - 判定するテキストセグメント
+   * @return 分離禁則文字で構成されている場合はtrue、そうでない場合はfalse
+   */
+  shouldNotBreak: (segment) => {
+    return util.noBreakRulesRegex.test(segment);
+  },
+  /**
+   * 2つのセグメント間に四分アキを追加すべきかを判断します。
+   * @param current - 現在のセグメント
+   * @param next - 次のセグメント
+   * @return 四分アキを追加すべきかどうか
+   */
+  shouldAddThinSpace: (current, next) => {
+    const spaceAfterRegex = new RegExp(
+      `(${util.closingsRegex.source}|${util.commasRegex.source}|${util.periodsRegex.source})`
+    );
+    const settings = {
+      spaceBefore: {
+        regex: util.openingsRegex,
+        hasSpaceBefore: true,
+        hasSpaceAfter: false
+      },
+      spaceAfter: {
+        regex: spaceAfterRegex,
+        hasSpaceBefore: false,
+        hasSpaceAfter: true
+      },
+      spaceBoth: {
+        regex: util.middleDotsRegex,
+        hasSpaceBefore: true,
+        hasSpaceAfter: true
+      }
+    };
+    for (const { regex, hasSpaceBefore, hasSpaceAfter } of Object.values(settings)) {
+      if (hasSpaceBefore && regex.test(next) && !regex.test(current)) {
+        return true;
+      }
+      if (hasSpaceAfter && regex.test(current) && !regex.test(next)) {
+        return true;
+      }
+    }
+    return false;
+  },
+  /**
+   * 与えられた文字列の最初の文字が句読点に一致するかどうか判断します。
+   * @param {string} segment - 判断対象の文字列
+   * @return {boolean} 最初の文字が句読点であればtrueを返します。
+   */
+  startsWithPunctuation: (segment) => {
+    const combinedRegex = new RegExp(`^[${util.periodsRegex.source}${util.commasRegex.source}]`);
+    return combinedRegex.test(segment);
+  }
+};
+const LanguageClass = {
+  /**
+   * セグメントがラテン文字で構成されているかどうかを判定します。
+   * @param segment - 判定するテキストセグメント
+   * @return ラテン文字で構成されている場合はtrue、そうでない場合はfalse
+   */
+  isLatin: (segment) => {
+    return util.latinRegex.test(segment);
+  },
+  /**
+   * セグメントが日本語文字で構成されているかどうかを判定します。
+   * @param segment - 判定するテキストセグメント
+   * @return 日本語文字で構成されている場合はtrue、そうでない場合はfalse
+   */
+  isJapanese: (segment) => {
+    return util.japaneseRegex.test(segment);
+  },
+  /**
+   * 現在のセグメントと次のセグメントの言語が異なるかどうかを判定します。
+   * この関数は、一方が日本語で他方が非日本語の場合にtrueを返します。
+   * @param current - 現在のテキストセグメント
+   * @param next - 次のテキストセグメント
+   * @return 両セグメント間で言語が異なる場合にtrueを返す
+   */
+  hasLanguageTransition: (current, next) => {
+    return LanguageClass.isJapanese(current) !== LanguageClass.isJapanese(next);
+  },
+  /**
+   * 2つのセグメント間に四分アキを追加すべきかを判断します。
+   * @param current - 現在のセグメント
+   * @param next - 次のセグメント
+   * @return 四分アキを追加すべきかどうか
+   */
+  shouldAddThinSpace: (current, next) => {
+    return LanguageClass.hasLanguageTransition(current, next) && !CharClass.startsWithPunctuation(next);
+  }
+};
+export {
+  CharClass,
+  LanguageClass
+};

package/dist/win-browser.js

@@ -1,5 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
 const win = window;
-exports.default = win;
-//# sourceMappingURL=win-browser.js.map
+var win_browser_default = win;
+export {
+  win_browser_default as default
+};

package/dist/win.js

@@ -1,6 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const jsdom_1 = require("jsdom");
-const win = new jsdom_1.JSDOM().window;
-exports.default = win;
-//# sourceMappingURL=win.js.map
+import { JSDOM } from "jsdom";
+const win = new JSDOM().window;
+var win_default = win;
+export {
+  win_default as default
+};

package/package.json

@@ -1,9 +1,11 @@
 {
   "name": "palt-typesetting",
-  "version": "0.2.1",
+  "version": "0.4.0",
   "description": "A typesetting library.",
   "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "files": [
+    "types/**/*",
     "dist/**/*",
     "bundle/**/*"
   ],
@@ -13,12 +15,10 @@
   },
   "scripts": {
     "clean:dist": "rm -rf ./dist",
-    "copy:types": "mkdir -p ./dist/types && cp -R ./src/types/* ./dist/types",
-    "prebuild": "npm run clean:dist && npm run copy:types",
-    "build": "tsc && npm run bundle",
-    "postbuild": "rm -rf ./dist/bundle.js",
-    "bundle": "esbuild ./dist/bundle.js --bundle --outfile=./bundle/typesetter.min.js --minify --sourcemap --platform=browser --target=es2016 --global-name=Typesetter",
-    "test": "jest",
+    "copy:css": "mkdir -p ./dist/style && cp -R ./src/style/* ./dist/style",
+    "prebuild": "npm run clean:dist && npm run copy:css",
+    "build": "node ./scripts/build.js && webpack",
+    "test": "vitest",
     "lint": "eslint ./src/** --no-error-on-unmatched-pattern",
     "lint:fix": "eslint ./src/** --fix"
   },
@@ -35,16 +35,21 @@
     "linebreak": "^1.1.0"
   },
   "devDependencies": {
-    "@types/jest": "^29.5.11",
+    "@babel/core": "^7.23.9",
+    "@babel/preset-env": "^7.23.9",
     "@types/jsdom": "^21.1.6",
     "@types/node": "^20",
     "@typescript-eslint/eslint-plugin": "^6.18.0",
     "@typescript-eslint/parser": "^6.18.0",
     "babel-jest": "^29.7.0",
+    "babel-loader": "^9.1.3",
+    "css-loader": "^6.10.0",
     "esbuild": "^0.19.11",
     "eslint": "^8",
-    "jest": "^29.7.0",
-    "ts-jest": "^29.1.1",
-    "typescript": "^5"
+    "style-loader": "^3.3.4",
+    "typescript": "^5",
+    "vitest": "^1.2.2",
+    "webpack": "^5.90.3",
+    "webpack-cli": "^5.1.4"
   }
 }

package/{dist/types → types}/index.d.ts

@@ -48,11 +48,6 @@ export interface TypesettingOptions {
    * 各ルールは、特定の文字ペア間に適用されるカーニング値を指定します。
    */
   kerningRules: KerningRule[]
-
-  /**
-   * ライブラリで使用されるCSSクラス名のプレフィックスを指定します。
-   */
-  classNamePrefix: string
 }
 
 /**