@sutton-signwriting/unicode8/unicode8.js

/**
* Sutton SignWriting Unicode 8 Module v1.1.2 (https://github.com/sutton-signwriting/unicode8)
* Author: Steve Slevinski  (https://SteveSlevinski.me)
* unicode8.js is released under the MIT License.
*/

(function (global, factory) {
  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
  typeof define === 'function' && define.amd ? define(['exports'], factory) :
  (global = global || self, factory((global.ssw = global.ssw || {}, global.ssw.unicode8 = {})));
}(this, (function (exports) { 'use strict';

  /**
   * Function that appends font-face CSS for the Noto Sans SignWriting font for use with SignWriting in Unicode 8 (uni8) characters.
   * 
   * This font-face declaration will use a locally installed font if available.
   * If not found, the font will be loaded from a content delivery network.
   * 
   * The list of local names is currently a work in progress.
   * The font-face currently works for Windows and iOS.
   * This CSS is duplicated in the src/font/index.css file.
   * 
   * @function font.cssAppend
   * @param {string} dir - an optional relative directory for font location
   * @example
   * font.cssAppend('./font/')
   */
  const cssAppend = function (dir = '') {
    const id = "SgnwUnicode8FontCss";

    if (!document.getElementById(id)) {
      const style = document.createElement('style');
      style.setAttribute("id", "SgnwUnicode8FontCss");
      style.appendChild(document.createTextNode(`
    @font-face {
      font-family: "NotoSansSignWriting";
      src: 
        local('NotoSansSignWriting'),
        local('Noto Sans SignWriting'),
        local('Noto_Sans_SignWriting'),
        local('Noto Sans SignWriting Regular'),
        local('Noto_Sans_SignWriting_Regular'),
        ${dir ? `url('${dir}NotoSansSignWriting-Regular.otf') format('truetype'),` : ""}
        url('https://cdn.jsdelivr.net/gh/googlefonts/noto-fonts/unhinted/otf/NotoSansSignWriting/NotoSansSignWriting-Regular.otf') format('opentype');
    }
    `));
      document.head.appendChild(style);
    }
  };

  /** The font module contains functions for handing the font.
   * @module font
   */

  var index = /*#__PURE__*/Object.freeze({
    __proto__: null,
    cssAppend: cssAppend
  });

  /**
   * Object of regular expressions for symbol strings
   * 
   *   { base, fill, rotation, full }
   * @alias symbol.re
   * @type {object}
   */
  let re = {
    'base': '(?:\uD836[\uDC00-\uDE8B])',
    'fill': '(?:\uD836[\uDE9B-\uDE9F])',
    'rotation': '(?:\uD836[\uDEA1-\uDEAF])'
  };
  re.full = `(${re.base})(${re.fill})?(${re.rotation})?`;

  /**
   * Function to parse symbol string to object
   * @function symbol.parse
   * @param {string} symbolString - a symbol string
   * @returns {object} elements of symbol string
   * @example
   * symbol.parse('𝠀')
   * 
   * return {
   *  'base': '𝠀',
   *  'fill': undefined,
   *  'rotation': undefined
   * }
   */

  const parse = symbolString => {
    const regex = `^${re.full}`;
    const m = (typeof symbolString === 'string' ? symbolString.match(new RegExp(regex)) : []) || [];
    return {
      'base': !m[1] ? undefined : m[1],
      'fill': !m[2] ? undefined : m[2],
      'rotation': !m[3] ? undefined : m[3]
    };
  };

  /**
   * Function to compose symbol string from object
   * @function symbol.compose
   * @param {object} symbolObject - an object of symbol parts
   * @param {string} symbolObject.base - base character for symbol
   * @param {string} symbolObject.fill - fill character for symbol
   * @param {string} symbolObject.rotation - rotation character for symbol
   * @returns {string} symbol string 
   * @example 
   * symbol.compose({
   *  'base': '𝠀'
   * })
   *
   * return '𝠀'
   */

  const compose = symbolObject => {
    if (typeof symbolObject !== 'object' || symbolObject === null) return undefined;
    const sym = (symbolObject.base ? symbolObject.base : '') + (symbolObject.fill ? symbolObject.fill : '') + (symbolObject.rotation ? symbolObject.rotation : '');
    return sym ? sym : undefined;
  };

  /** The symbol module contains regular expressions and functions for parsing and composing SignWriting in Unicode 8 (uni8) characters.
   * @module symbol
   */

  var index$1 = /*#__PURE__*/Object.freeze({
    __proto__: null,
    re: re,
    parse: parse,
    compose: compose
  });

  /**
   * Object of regular expressions for string of symbols
   * 
   *   { full }
   * @alias string.re
   * @type {object}
   */
  let re$1 = {
    'full': `(?:${re.full})+`
  };

  /**
   * Function to parse string of uni8 symbols to array
   * @function string.parse
   * @param {string} uni8String - a string of uni8 symbols
   * @returns {array} array of uni8 symbols
   * @example
   * string.parse('𝠀𝠁')
   * 
   * return ['𝠀','𝠁']
   */

  const parse$1 = uni8String => {
    const regex = `^(${re$1.full})`;
    const m = (typeof uni8String === 'string' ? uni8String.match(new RegExp(regex)) : []) || [];
    return !m[1] ? [] : [...m[1].matchAll(new RegExp(re.full, 'g'))].map(mm => mm[0]);
  };

  /**
   * Function to compose uni8 string from array
   * @function string.compose
   * @param {array} stringArray - an array of uni8 symbols
   * @returns {string} string of uni8 symbols
   * @example 
   * string.compose(['𝠀','𝠁'])
   *
   * return '𝠀𝠁'
   */

  const compose$1 = stringArray => {
    if (!Array.isArray(stringArray)) return undefined;
    return stringArray.join('');
  };

  /** The string module contains regular expressions and functions for parsing and composing SignWriting in Unicode 8 (uni8) symbol strings.
   * @module string
   */

  var index$2 = /*#__PURE__*/Object.freeze({
    __proto__: null,
    re: re$1,
    parse: parse$1,
    compose: compose$1
  });

  /** The convert module contains functions to help process the various SignWriting Character sets. 
   * @module convert
   */
  /**
  * Function to convert a SignWriting in Unicode 8 (uni8) code point to a character
  * @function convert.code2uni
  * @param {integer} code - unicode code point
  * @returns {string} SignWriting in Unicode 8 character
  * @example
  * convert.code2uni(0x1D800)
  * 
  * return '𝠀'
  */

  const code2uni = code => String.fromCharCode(0xD800 + (code - 0x10000 >> 10), 0xDC00 + (code - 0x10000 & 0x3FF));
  /**
  * Function to convert a SignWriting in Unicode 8 (uni8) character to a code point
  * @function convert.uni2code
  * @param {string} uni8 - SignWriting in Unicode 8 character
  * @returns {integer} unicode code point
  * @example
  * convert.uni2code('𝠀')
  * 
  * return 0x1D800
  */


  const uni2code = uni8 => uni8.codePointAt(0);
  /**
  * Function to convert a SignWriting in Unicode 8 (uni8) character to hex values
  * @function convert.uni2hex
  * @param {string} uni8 - SignWriting in Unicode 8 character
  * @returns {string} hex value of unicode character
  * @example
  * convert.uni2hex('𝠀')
  * 
  * return "1D800"
  */


  const uni2hex = uni8 => uni8.codePointAt(0).toString(16).toUpperCase();
  /**
  * Function to convert a SignWriting in Unicode 8 (uni8) symbol to Formal SignWriting in ASCII (FSW)
  * @function convert.uni2fsw
  * @param {string} uni8 - SignWriting in Unicode 8 character(s)
  * @returns {string} an FSW symbol key
  * @example
  * convert.uni2fsw('𝠀')
  * 
  * return 'S10000'
  */


  const uni2fsw = uni8 => {
    let sym = parse(uni8);

    if (sym.base) {
      sym.base = sym.base.codePointAt(0) - 0x1D700;
      sym.fill = sym.fill ? sym.fill.codePointAt(0) - 0x1DA9A : 0;
      sym.rotation = sym.rotation ? sym.rotation.codePointAt(0) - 0x1DAA0 : 0;
      return "S" + sym.base.toString(16) + sym.fill.toString(16) + sym.rotation.toString(16);
    } else {
      return undefined;
    }
  };
  /**
  * Function to convert a SignWriting in Unicode 8 (uni8) symbol to SignWriting in Unicode (SWU)
  * @function convert.uni2swu
  * @param {string} uni8 - SignWriting in Unicode 8 character(s)
  * @returns {string} an SWU symbol
  * @example
  * convert.uni2swu('𝠀')
  * 
  * return '񀀁'
  */


  const uni2swu = uni8 => {
    let sym = parse(uni8);

    if (sym.base) {
      sym.base = sym.base.codePointAt(0) - 0x1D800;
      sym.fill = sym.fill ? sym.fill.codePointAt(0) - 0x1DA9A : 0;
      sym.rotation = sym.rotation ? sym.rotation.codePointAt(0) - 0x1DAA0 : 0;
      return code2uni(0x40001 + sym.base * 96 + sym.fill * 16 + sym.rotation);
    } else {
      return undefined;
    }
  };
  /**
  * Function to convert a Formal SignWriting in ASCII (FSW) to SignWriting in Unicode 8 (uni8)
  * @function convert.fsw2uni
  * @param {string} fswSym - an FSW symbol key
  * @returns {string} SignWriting in Unicode 8 character(s)
  * @example
  * convert.fsw2uni('S10000')
  * 
  * return '𝠀'
  */


  const fsw2uni = fswSym => {
    let base = parseInt(fswSym.slice(1, 4), 16);
    let fill = parseInt(fswSym.slice(4, 5), 16);
    let rotation = parseInt(fswSym.slice(5, 6), 16);
    return code2uni(base + 0x1D700) + (fill ? code2uni(fill + 0x1DA9A) : '') + (rotation ? code2uni(rotation + 0x1DAA0) : '');
  };
  /**
  * Function to convert a SignWriting in Unicode (SWU) to SignWriting in Unicode 8 (uni8)
  * @function convert.swu2uni
  * @param {string} swuSym - an SWU symbol
  * @returns {string} SignWriting in Unicode 8 character(s)
  * @example
  * convert.swu2uni('񀀁')
  * 
  * return '𝠀'
  */


  const swu2uni = swuSym => {
    const symcode = swuSym.codePointAt(0) - 0x40001;
    const base = parseInt(symcode / 96);
    const fill = parseInt((symcode - base * 96) / 16);
    const rotation = parseInt(symcode - base * 96 - fill * 16);
    return code2uni(base + 0x1D800) + (fill ? code2uni(fill + 0x1DA9A) : '') + (rotation ? code2uni(rotation + 0x1DAA0) : '');
  };

  var index$3 = /*#__PURE__*/Object.freeze({
    __proto__: null,
    code2uni: code2uni,
    uni2code: uni2code,
    uni2hex: uni2hex,
    uni2fsw: uni2fsw,
    uni2swu: uni2swu,
    fsw2uni: fsw2uni,
    swu2uni: swu2uni
  });

  exports.convert = index$3;
  exports.font = index;
  exports.string = index$2;
  exports.symbol = index$1;

  Object.defineProperty(exports, '__esModule', { value: true });

})));

/* support ongoing development on https://patreon.com/signwriting */