md/libs/FuriganaMD.js

// 注音功能来自于
// https://github.com/amclees/furigana-markdown
// 详见上述文档

(function (global, factory) {
  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
    typeof define === 'function' && define.amd ? define(factory) :
      (global.FuriganaMD = factory());
}(this, (function () {
  'use strict';

// This function escapes special characters for use in a regex constructor.
  function escapeForRegex(string) {
    return string.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
  }

  function emptyStringFilter(block) {
    return block !== '';
  }

  const kanjiRange = '\\u4e00-\\u9faf';
  const kanjiBlockRegex = new RegExp(`[${kanjiRange}]+`, 'g');
  const nonKanjiBlockRegex = new RegExp(`[^${kanjiRange}]+`, 'g');
  const kanaWithAnnotations = '\\u3041-\\u3095\\u3099-\\u309c\\u3081-\\u30fa\\u30fc';
  const furiganaSeperators = '.．。・';
  const seperatorRegex = new RegExp(`[${furiganaSeperators}]`, 'g');

  const singleKanjiRegex = new RegExp(`^[${kanjiRange}]$`);

  function isKanji(character) {
    return character.match(singleKanjiRegex);
  }

  const innerRegexString = '(?:[^\\u0000-\\u007F]|\\w)+';

  let regexList = [];
  let previousFuriganaForms = '';

  function updateRegexList(furiganaForms) {
    previousFuriganaForms = furiganaForms;
    let formArray = furiganaForms.split('|');
    if (formArray.length === 0) {
      formArray = ['[]:^:()'];
    }
    regexList = formArray.map(form => {
      let furiganaComponents = form.split(':');
      if (furiganaComponents.length !== 3) {
        furiganaComponents = ['[]', '^', '()'];
      }
      const mainBrackets = furiganaComponents[0];
      const seperator = furiganaComponents[1];
      const furiganaBrackets = furiganaComponents[2];
      return new RegExp(
        escapeForRegex(mainBrackets[0]) +
        '(' + innerRegexString + ')' +
        escapeForRegex(mainBrackets[1]) +
        escapeForRegex(seperator) +
        escapeForRegex(furiganaBrackets[0]) +
        '(' + innerRegexString + ')' +
        escapeForRegex(furiganaBrackets[1]),
        'g'
      );
    });
  }

  let autoRegexList = [];
  let previousAutoBracketSets = '';

  function updateAutoRegexList(autoBracketSets) {
    previousAutoBracketSets = autoBracketSets;
    autoRegexList = autoBracketSets.split('|').map(brackets => {
      /*
        Sample built regex:
        /(^|[^\u4e00-\u9faf]|)([\u4e00-\u9faf]+)([\u3041-\u3095\u3099-\u309c\u3081-\u30fa\u30fc]*)【((?:[^【】\u4e00-\u9faf]|w)+)】/g
      */
      return new RegExp(
        `(^|[^${kanjiRange}]|)` +
        `([${kanjiRange}]+)` +
        `([${kanaWithAnnotations}]*)` +
        escapeForRegex(brackets[0]) +
        `((?:[^${escapeForRegex(brackets)}\\u0000-\\u007F]|\\w|[${furiganaSeperators}])+)` +
        escapeForRegex(brackets[1]),
        'g'
      );
    });
  }

  let replacementTemplate = '';
  let replacementBrackets = '';

  function updateReplacementTemplate(furiganaFallbackBrackets) {
    if (furiganaFallbackBrackets.length !== 2) {
      furiganaFallbackBrackets = '【】';
    }
    replacementBrackets = furiganaFallbackBrackets;
    replacementTemplate = `<ruby>$1<rp>${furiganaFallbackBrackets[0]}</rp><rt style="line-height:1;font-size:10px;">$2</rt><rp>${furiganaFallbackBrackets[1]}</rp></ruby>`;
  }

  updateReplacementTemplate('【】');

  function addFurigana(text, options) {
    if (options.furiganaForms !== previousFuriganaForms) {
      updateRegexList(options.furiganaForms);
    }
    if (options.furiganaFallbackBrackets !== replacementBrackets) {
      updateReplacementTemplate(options.furiganaFallbackBrackets);
    }
    regexList.forEach(regex => {
      text = text.replace(regex, (match, wordText, furiganaText, offset, mainText) => {
        if (match.indexOf('\\') === -1 && mainText[offset - 1] !== '\\') {
          if ((!options.furiganaPatternMatching) || wordText.search(kanjiBlockRegex) === -1 || wordText[0].search(kanjiBlockRegex) === -1) {
            return replacementTemplate.replace('$1', wordText).replace('$2', furiganaText);
          } else {
            let originalFuriganaText = (' ' + furiganaText).slice(1);
            let nonKanji = wordText.split(kanjiBlockRegex).filter(emptyStringFilter);
            let kanji = wordText.split(nonKanjiBlockRegex).filter(emptyStringFilter);
            let replacementText = '';
            let lastUsedKanjiIndex = 0;
            if (nonKanji.length === 0) {
              return replacementTemplate.replace('$1', wordText).replace('$2', furiganaText);
            }

            nonKanji.forEach((currentNonKanji, index) => {
              if (furiganaText === undefined) {
                if (index < kanji.length) {
                  replacementText += kanji[index];
                }

                replacementText += currentNonKanji;
                return;
              }
              let splitFurigana = furiganaText.split(new RegExp(escapeForRegex(currentNonKanji) + '(.*)')).filter(emptyStringFilter);

              lastUsedKanjiIndex = index;
              replacementText += replacementTemplate.replace('$1', kanji[index]).replace('$2', splitFurigana[0]);
              replacementText += currentNonKanji;

              furiganaText = splitFurigana[1];
            });
            if (furiganaText !== undefined && lastUsedKanjiIndex + 1 < kanji.length) {
              replacementText += replacementTemplate.replace('$1', kanji[lastUsedKanjiIndex + 1]).replace('$2', furiganaText);
            } else if (furiganaText !== undefined) {
              return replacementTemplate.replace('$1', wordText).replace('$2', originalFuriganaText);
            } else if (lastUsedKanjiIndex + 1 < kanji.length) {
              replacementText += kanji[lastUsedKanjiIndex + 1];
            }
            return replacementText;
          }
        } else {
          return match;
        }
      });
    });

    if (!options.furiganaStrictMode) {
      if (options.furiganaAutoBracketSets !== previousAutoBracketSets) {
        updateAutoRegexList(options.furiganaAutoBracketSets);
      }
      autoRegexList.forEach(regex => {
        text = text.replace(regex, (match, preWordTerminator, wordKanji, wordKanaSuffix, furiganaText, offset, mainText) => {
          if (match.indexOf('\\') === -1) {
            if (options.furiganaPatternMatching) {
              let rubies = [];

              let furigana = furiganaText;

              let stem = (' ' + wordKanaSuffix).slice(1);
              for (let i = furiganaText.length - 1; i >= 0; i--) {
                if (wordKanaSuffix.length === 0) {
                  furigana = furiganaText.substring(0, i + 1);
                  break;
                }
                if (furiganaText[i] !== wordKanaSuffix.slice(-1)) {
                  furigana = furiganaText.substring(0, i + 1);
                  break;
                }
                wordKanaSuffix = wordKanaSuffix.slice(0, -1);
              }

              if (furiganaSeperators.split('').reduce(
                (noSeperator, seperator) => {
                  return noSeperator && (furigana.indexOf(seperator) === -1);
                },
                true
              )) {
                rubies = [replacementTemplate.replace('$1', wordKanji).replace('$2', furigana)];
              } else {
                let kanaParts = furigana.split(seperatorRegex);
                let kanji = wordKanji.split('');
                if (kanaParts.length === 0 || kanaParts.length > kanji.length) {
                  rubies = [replacementTemplate.replace('$1', wordKanji).replace('$2', furigana)];
                } else {
                  for (let i = 0; i < kanaParts.length - 1; i++) {
                    if (kanji.length === 0) {
                      break;
                    }
                    rubies.push(replacementTemplate.replace('$1', kanji.shift()).replace('$2', kanaParts[i]));
                  }
                  let lastKanaPart = kanaParts.pop();
                  rubies.push(replacementTemplate.replace('$1', kanji.join('')).replace('$2', lastKanaPart));
                }
              }

              return preWordTerminator + rubies.join('') + stem;
            } else {
              return preWordTerminator + replacementTemplate.replace('$1', wordKanji).replace('$2', furiganaText) + wordKanaSuffix;
            }
          } else {
            return match;
          }
        });
      });
    }
    return text;
  }

  function handleEscapedSpecialBrackets(text) {
    // By default 【 and 】 cannot be escaped in markdown, this will remove backslashes from in front of them to give that effect.
    return text.replace(/\\([【】])/g, '$1');
  }

  let FuriganaMD = {};
  FuriganaMD.register = function (renderer) {
    renderer.text = function (text) {
      let options = {
        furigana: true,
        furiganaForms: "()::{}",
        furiganaFallbackBrackets: "{}",
        furiganaStrictMode: false,
        furiganaAutoBracketSets: "{}",
        furiganaPatternMatching: true,
      };
      // console.log('override text render',text);
      // console.log('after add',addFurigana(text, options));
      return handleEscapedSpecialBrackets(addFurigana(text, options));
    };
  };

  return FuriganaMD;

})));