# -*- coding: utf-8 -*-

from __future__ import print_function, division, absolute_import

from __future__ import unicode_literals

from fontTools.misc.py23 import *

from fontTools.misc import sstruct

from fontTools.misc.textTools import safeEval

from fontTools.misc.encodingTools import getEncoding

from fontTools.ttLib import newTable

from . import DefaultTable

import struct

import logging

log = logging.getLogger(__name__)

nameRecordFormat = """

		>	# big endian

		platformID:	H

		platEncID:	H

		langID:		H

		nameID:		H

		length:		H

		offset:		H

"""

nameRecordSize = sstruct.calcsize(nameRecordFormat)

class table__n_a_m_e(DefaultTable.DefaultTable):

	dependencies = ["ltag"]

	def decompile(self, data, ttFont):

		format, n, stringOffset = struct.unpack(b">HHH", data[:6])

		expectedStringOffset = 6 + n * nameRecordSize

		if stringOffset != expectedStringOffset:

			log.error(

				"'name' table stringOffset incorrect. Expected: %s; Actual: %s",

				expectedStringOffset, stringOffset)

		stringData = data[stringOffset:]

		data = data[6:]

		self.names = []

		for i in range(n):

			if len(data) < 12:

				log.error('skipping malformed name record #%d', i)

				continue

			name, data = sstruct.unpack2(nameRecordFormat, data, NameRecord())

			name.string = stringData[name.offset:name.offset+name.length]

			if name.offset + name.length > len(stringData):

				log.error('skipping malformed name record #%d', i)

				continue

			assert len(name.string) == name.length

			#if (name.platEncID, name.platformID) in ((0, 0), (1, 3)):

			#	if len(name.string) % 2:

			#		print "2-byte string doesn't have even length!"

			#		print name.__dict__

			del name.offset, name.length

			self.names.append(name)

	def compile(self, ttFont):

		if not hasattr(self, "names"):

			# only happens when there are NO name table entries read

			# from the TTX file

			self.names = []

		names = self.names

		names.sort() # sort according to the spec; see NameRecord.__lt__()

		stringData = b""

		format = 0

		n = len(names)

		stringOffset = 6 + n * sstruct.calcsize(nameRecordFormat)

		data = struct.pack(b">HHH", format, n, stringOffset)

		lastoffset = 0

		done = {}  # remember the data so we can reuse the "pointers"

		for name in names:

			string = name.toBytes()

			if string in done:

				name.offset, name.length = done[string]

			else:

				name.offset, name.length = done[string] = len(stringData), len(string)

				stringData = bytesjoin([stringData, string])

			data = data + sstruct.pack(nameRecordFormat, name)

		return data + stringData

	def toXML(self, writer, ttFont):

		for name in self.names:

			name.toXML(writer, ttFont)

	def fromXML(self, name, attrs, content, ttFont):

		if name != "namerecord":

			return # ignore unknown tags

		if not hasattr(self, "names"):

			self.names = []

		name = NameRecord()

		self.names.append(name)

		name.fromXML(name, attrs, content, ttFont)

	def getName(self, nameID, platformID, platEncID, langID=None):

		for namerecord in self.names:

			if (	namerecord.nameID == nameID and

					namerecord.platformID == platformID and

					namerecord.platEncID == platEncID):

				if langID is None or namerecord.langID == langID:

					return namerecord

		return None # not found

	def getDebugName(self, nameID):

		englishName = someName = None

		for name in self.names:

			if name.nameID != nameID:

				continue

			try:

				unistr = name.toUnicode()

			except UnicodeDecodeError:

				continue

			someName = unistr

			if (name.platformID, name.langID) in ((1, 0), (3, 0x409)):

				englishName = unistr

				break

		if englishName:

			return englishName

		elif someName:

			return someName

		else:

			return None

	def setName(self, string, nameID, platformID, platEncID, langID):

		""" Set the 'string' for the name record identified by 'nameID', 'platformID',

		'platEncID' and 'langID'. If a record with that nameID doesn't exist, create it

		and append to the name table.

		'string' can be of type `str` (`unicode` in PY2) or `bytes`. In the latter case,

		it is assumed to be already encoded with the correct plaform-specific encoding

		identified by the (platformID, platEncID, langID) triplet. A warning is issued

		to prevent unexpected results.

		"""

		if not hasattr(self, 'names'):

			self.names = []

		if not isinstance(string, unicode):

			if isinstance(string, bytes):

				log.warning(

					"name string is bytes, ensure it's correctly encoded: %r", string)

			else:

				raise TypeError(

					"expected unicode or bytes, found %s: %r" % (

						type(string).__name__, string))

		namerecord = self.getName(nameID, platformID, platEncID, langID)

		if namerecord:

			namerecord.string = string

		else:

			self.names.append(makeName(string, nameID, platformID, platEncID, langID))

	def _findUnusedNameID(self, minNameID=256):

		"""Finds an unused name id.

		The nameID is assigned in the range between 'minNameID' and 32767 (inclusive),

		following the last nameID in the name table.

		"""

		names = getattr(self, 'names', [])

		nameID = 1 + max([n.nameID for n in names] + [minNameID - 1])

		if nameID > 32767:

			raise ValueError("nameID must be less than 32768")

		return nameID

	def addMultilingualName(self, names, ttFont=None, nameID=None):

		"""Add a multilingual name, returning its name ID

		'names' is a dictionary with the name in multiple languages,

		such as {'en': 'Pale', 'de': 'Blaß', 'de-CH': 'Blass'}.

		The keys can be arbitrary IETF BCP 47 language codes;

		the values are Unicode strings.

		'ttFont' is the TTFont to which the names are added, or None.

		If present, the font's 'ltag' table can get populated

		to store exotic language codes, which allows encoding

		names that otherwise cannot get encoded at all.

		'nameID' is the name ID to be used, or None to let the library

		pick an unused name ID.

		"""

		if not hasattr(self, 'names'):

			self.names = []

		if nameID is None:

			nameID = self._findUnusedNameID()

		# TODO: Should minimize BCP 47 language codes.

		# https://github.com/fonttools/fonttools/issues/930

		for lang, name in sorted(names.items()):

			# Apple platforms have been recognizing Windows names

			# since early OSX (~2001), so we only add names

			# for the Macintosh platform when we cannot not make

			# a Windows name. This can happen for exotic BCP47

			# language tags that have no Windows language code.

			windowsName = _makeWindowsName(name, nameID, lang)

			if windowsName is not None:

				self.names.append(windowsName)

			else:

				macName = _makeMacName(name, nameID, lang, ttFont)

				if macName is not None:

					self.names.append(macName)

		return nameID

	def addName(self, string, platforms=((1, 0, 0), (3, 1, 0x409)), minNameID=255):

		""" Add a new name record containing 'string' for each (platformID, platEncID,

		langID) tuple specified in the 'platforms' list.

		The nameID is assigned in the range between 'minNameID'+1 and 32767 (inclusive),

		following the last nameID in the name table.

		If no 'platforms' are specified, two English name records are added, one for the

		Macintosh (platformID=0), and one for the Windows platform (3).

		The 'string' must be a Unicode string, so it can be encoded with different,

		platform-specific encodings.

		Return the new nameID.

		"""

		assert len(platforms) > 0, \

			"'platforms' must contain at least one (platformID, platEncID, langID) tuple"

		if not hasattr(self, 'names'):

			self.names = []

		if not isinstance(string, unicode):

			raise TypeError(

				"expected %s, found %s: %r" % (

					unicode.__name__, type(string).__name__,string ))

		nameID = self._findUnusedNameID(minNameID + 1)

		for platformID, platEncID, langID in platforms:

			self.names.append(makeName(string, nameID, platformID, platEncID, langID))

		return nameID

def makeName(string, nameID, platformID, platEncID, langID):

	name = NameRecord()

	name.string, name.nameID, name.platformID, name.platEncID, name.langID = (

		string, nameID, platformID, platEncID, langID)

	return name

def _makeWindowsName(name, nameID, language):

	"""Create a NameRecord for the Microsoft Windows platform

	'language' is an arbitrary IETF BCP 47 language identifier such

	as 'en', 'de-CH', 'de-AT-1901', or 'fa-Latn'. If Microsoft Windows

	does not support the desired language, the result will be None.

	Future versions of fonttools might return a NameRecord for the

	OpenType 'name' table format 1, but this is not implemented yet.

	"""

	langID = _WINDOWS_LANGUAGE_CODES.get(language.lower())

	if langID is not None:

		return makeName(name, nameID, 3, 1, langID)

	else:

		log.warning("cannot add Windows name in language %s "

		            "because fonttools does not yet support "

		            "name table format 1" % language)

		return None

def _makeMacName(name, nameID, language, font=None):

	"""Create a NameRecord for Apple platforms

	'language' is an arbitrary IETF BCP 47 language identifier such

	as 'en', 'de-CH', 'de-AT-1901', or 'fa-Latn'. When possible, we

	create a Macintosh NameRecord that is understood by old applications

	(platform ID 1 and an old-style Macintosh language enum). If this

	is not possible, we create a Unicode NameRecord (platform ID 0)

	whose language points to the font’s 'ltag' table. The latter

	can encode any string in any language, but legacy applications

	might not recognize the format (in which case they will ignore

	those names).

	'font' should be the TTFont for which you want to create a name.

	If 'font' is None, we only return NameRecords for legacy Macintosh;

	in that case, the result will be None for names that need to

	be encoded with an 'ltag' table.

	See the section “The language identifier” in Apple’s specification:

	https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6name.html

	"""

	macLang = _MAC_LANGUAGE_CODES.get(language.lower())

	macScript = _MAC_LANGUAGE_TO_SCRIPT.get(macLang)

	if macLang is not None and macScript is not None:

		encoding = getEncoding(1, macScript, macLang, default="ascii")

		# Check if we can actually encode this name. If we can't,

		# for example because we have no support for the legacy

		# encoding, or because the name string contains Unicode

		# characters that the legacy encoding cannot represent,

		# we fall back to encoding the name in Unicode and put

		# the language tag into the ltag table.

		try:

			_ = tobytes(name, encoding, errors="strict")

			return makeName(name, nameID, 1, macScript, macLang)

		except UnicodeEncodeError:

			pass

	if font is not None:

		ltag = font.tables.get("ltag")

		if ltag is None:

			ltag = font["ltag"] = newTable("ltag")

		# 0 = Unicode; 4 = “Unicode 2.0 or later semantics (non-BMP characters allowed)”

		# “The preferred platform-specific code for Unicode would be 3 or 4.”

		# https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6name.html

		return makeName(name, nameID, 0, 4, ltag.addTag(language))

	else:

		log.warning("cannot store language %s into 'ltag' table "

		            "without having access to the TTFont object" %

		            language)

		return None

class NameRecord(object):

	def getEncoding(self, default='ascii'):

		"""Returns the Python encoding name for this name entry based on its platformID,

		platEncID, and langID.  If encoding for these values is not known, by default

		'ascii' is returned.  That can be overriden by passing a value to the default

		argument.

		"""

		return getEncoding(self.platformID, self.platEncID, self.langID, default)

	def encodingIsUnicodeCompatible(self):

		return self.getEncoding(None) in ['utf_16_be', 'ucs2be', 'ascii', 'latin1']

	def __str__(self):

		return self.toStr(errors='backslashreplace')

	def isUnicode(self):

		return (self.platformID == 0 or

			(self.platformID == 3 and self.platEncID in [0, 1, 10]))

	def toUnicode(self, errors='strict'):

		"""

		If self.string is a Unicode string, return it; otherwise try decoding the

		bytes in self.string to a Unicode string using the encoding of this

		entry as returned by self.getEncoding(); Note that  self.getEncoding()

		returns 'ascii' if the encoding is unknown to the library.

		Certain heuristics are performed to recover data from bytes that are

		ill-formed in the chosen encoding, or that otherwise look misencoded

		(mostly around bad UTF-16BE encoded bytes, or bytes that look like UTF-16BE

		but marked otherwise).  If the bytes are ill-formed and the heuristics fail,

		the error is handled according to the errors parameter to this function, which is

		passed to the underlying decode() function; by default it throws a

		UnicodeDecodeError exception.

		Note: The mentioned heuristics mean that roundtripping a font to XML and back

		to binary might recover some misencoded data whereas just loading the font

		and saving it back will not change them.

		"""

		def isascii(b):

			return (b >= 0x20 and b <= 0x7E) or b in [0x09, 0x0A, 0x0D]

		encoding = self.getEncoding()

		string = self.string

		if encoding == 'utf_16_be' and len(string) % 2 == 1:

			# Recover badly encoded UTF-16 strings that have an odd number of bytes:

			# - If the last byte is zero, drop it.  Otherwise,

			# - If all the odd bytes are zero and all the even bytes are ASCII,

			#   prepend one zero byte.  Otherwise,

			# - If first byte is zero and all other bytes are ASCII, insert zero

			#   bytes between consecutive ASCII bytes.

			#

			# (Yes, I've seen all of these in the wild... sigh)

			if byteord(string[-1]) == 0:

				string = string[:-1]

			elif all(byteord(b) == 0 if i % 2 else isascii(byteord(b)) for i,b in enumerate(string)):

				string = b'\0' + string

			elif byteord(string[0]) == 0 and all(isascii(byteord(b)) for b in string[1:]):

				string = bytesjoin(b'\0'+bytechr(byteord(b)) for b in string[1:])

		string = tounicode(string, encoding=encoding, errors=errors)

		# If decoded strings still looks like UTF-16BE, it suggests a double-encoding.

		# Fix it up.

		if all(ord(c) == 0 if i % 2 == 0 else isascii(ord(c)) for i,c in enumerate(string)):

			# If string claims to be Mac encoding, but looks like UTF-16BE with ASCII text,

			# narrow it down.

			string = ''.join(c for c in string[1::2])

		return string

	def toBytes(self, errors='strict'):

		""" If self.string is a bytes object, return it; otherwise try encoding

		the Unicode string in self.string to bytes using the encoding of this

		entry as returned by self.getEncoding(); Note that self.getEncoding()

		returns 'ascii' if the encoding is unknown to the library.

		If the Unicode string cannot be encoded to bytes in the chosen encoding,

		the error is handled according to the errors parameter to this function,

		which is passed to the underlying encode() function; by default it throws a

		UnicodeEncodeError exception.

		"""

		return tobytes(self.string, encoding=self.getEncoding(), errors=errors)

	def toStr(self, errors='strict'):

		if str == bytes:

			# python 2

			return self.toBytes(errors)

		else:

			# python 3

			return self.toUnicode(errors)

	def toXML(self, writer, ttFont):

		try:

			unistr = self.toUnicode()

		except UnicodeDecodeError:

			unistr = None

		attrs = [

				("nameID", self.nameID),

				("platformID", self.platformID),

				("platEncID", self.platEncID),

				("langID", hex(self.langID)),

			]

		if unistr is None or not self.encodingIsUnicodeCompatible():

			attrs.append(("unicode", unistr is not None))

		writer.begintag("namerecord", attrs)

		writer.newline()

		if unistr is not None:

			writer.write(unistr)

		else:

			writer.write8bit(self.string)

		writer.newline()

		writer.endtag("namerecord")

		writer.newline()

	def fromXML(self, name, attrs, content, ttFont):

		self.nameID = safeEval(attrs["nameID"])

		self.platformID = safeEval(attrs["platformID"])

		self.platEncID = safeEval(attrs["platEncID"])

		self.langID =  safeEval(attrs["langID"])

		s = strjoin(content).strip()

		encoding = self.getEncoding()

		if self.encodingIsUnicodeCompatible() or safeEval(attrs.get("unicode", "False")):

			self.string = s.encode(encoding)

		else:

			# This is the inverse of write8bit...

			self.string = s.encode("latin1")

	def __lt__(self, other):

		if type(self) != type(other):

			return NotImplemented

		# implemented so that list.sort() sorts according to the spec.

		selfTuple = (

			getattr(self, "platformID", None),

			getattr(self, "platEncID", None),

			getattr(self, "langID", None),

			getattr(self, "nameID", None),

			getattr(self, "string", None),

		)

		otherTuple = (

			getattr(other, "platformID", None),

			getattr(other, "platEncID", None),

			getattr(other, "langID", None),

			getattr(other, "nameID", None),

			getattr(other, "string", None),

		)

		return selfTuple < otherTuple

	def __repr__(self):

		return "<NameRecord NameID=%d; PlatformID=%d; LanguageID=%d>" % (

				self.nameID, self.platformID, self.langID)

# Windows language ID → IETF BCP-47 language tag

#

# While Microsoft indicates a region/country for all its language

# IDs, we follow Unicode practice by omitting “most likely subtags”

# as per Unicode CLDR. For example, English is simply “en” and not

# “en-Latn” because according to Unicode, the default script

# for English is Latin.

#

# http://www.unicode.org/cldr/charts/latest/supplemental/likely_subtags.html

# http://www.iana.org/assignments/language-subtag-registry/language-subtag-registry

_WINDOWS_LANGUAGES = {

    0x0436: 'af',

    0x041C: 'sq',

    0x0484: 'gsw',

    0x045E: 'am',

    0x1401: 'ar-DZ',

    0x3C01: 'ar-BH',

    0x0C01: 'ar',

    0x0801: 'ar-IQ',

    0x2C01: 'ar-JO',

    0x3401: 'ar-KW',

    0x3001: 'ar-LB',

    0x1001: 'ar-LY',

    0x1801: 'ary',

    0x2001: 'ar-OM',

    0x4001: 'ar-QA',

    0x0401: 'ar-SA',

    0x2801: 'ar-SY',

    0x1C01: 'aeb',

    0x3801: 'ar-AE',

    0x2401: 'ar-YE',

    0x042B: 'hy',

    0x044D: 'as',

    0x082C: 'az-Cyrl',

    0x042C: 'az',

    0x046D: 'ba',

    0x042D: 'eu',

    0x0423: 'be',

    0x0845: 'bn',

    0x0445: 'bn-IN',

    0x201A: 'bs-Cyrl',

    0x141A: 'bs',

    0x047E: 'br',

    0x0402: 'bg',

    0x0403: 'ca',

    0x0C04: 'zh-HK',

    0x1404: 'zh-MO',

    0x0804: 'zh',

    0x1004: 'zh-SG',

    0x0404: 'zh-TW',

    0x0483: 'co',

    0x041A: 'hr',

    0x101A: 'hr-BA',

    0x0405: 'cs',

    0x0406: 'da',

    0x048C: 'prs',

    0x0465: 'dv',

    0x0813: 'nl-BE',

    0x0413: 'nl',

    0x0C09: 'en-AU',

    0x2809: 'en-BZ',

    0x1009: 'en-CA',

    0x2409: 'en-029',

    0x4009: 'en-IN',

    0x1809: 'en-IE',

    0x2009: 'en-JM',

    0x4409: 'en-MY',

    0x1409: 'en-NZ',

    0x3409: 'en-PH',

    0x4809: 'en-SG',

    0x1C09: 'en-ZA',

    0x2C09: 'en-TT',

    0x0809: 'en-GB',

    0x0409: 'en',

    0x3009: 'en-ZW',

    0x0425: 'et',

    0x0438: 'fo',

    0x0464: 'fil',

    0x040B: 'fi',

    0x080C: 'fr-BE',

    0x0C0C: 'fr-CA',

    0x040C: 'fr',

    0x140C: 'fr-LU',

    0x180C: 'fr-MC',

    0x100C: 'fr-CH',

    0x0462: 'fy',

    0x0456: 'gl',

    0x0437: 'ka',

    0x0C07: 'de-AT',

    0x0407: 'de',

    0x1407: 'de-LI',

    0x1007: 'de-LU',

    0x0807: 'de-CH',

    0x0408: 'el',

    0x046F: 'kl',

    0x0447: 'gu',

    0x0468: 'ha',

    0x040D: 'he',

    0x0439: 'hi',

    0x040E: 'hu',

    0x040F: 'is',

    0x0470: 'ig',

    0x0421: 'id',

    0x045D: 'iu',

    0x085D: 'iu-Latn',

    0x083C: 'ga',

    0x0434: 'xh',

    0x0435: 'zu',

    0x0410: 'it',

    0x0810: 'it-CH',

    0x0411: 'ja',

    0x044B: 'kn',

    0x043F: 'kk',

    0x0453: 'km',

    0x0486: 'quc',

    0x0487: 'rw',

    0x0441: 'sw',

    0x0457: 'kok',

    0x0412: 'ko',

    0x0440: 'ky',

    0x0454: 'lo',

    0x0426: 'lv',

    0x0427: 'lt',

    0x082E: 'dsb',

    0x046E: 'lb',

    0x042F: 'mk',

    0x083E: 'ms-BN',

    0x043E: 'ms',

    0x044C: 'ml',

    0x043A: 'mt',

    0x0481: 'mi',

    0x047A: 'arn',

    0x044E: 'mr',

    0x047C: 'moh',

    0x0450: 'mn',

    0x0850: 'mn-CN',

    0x0461: 'ne',

    0x0414: 'nb',

    0x0814: 'nn',

    0x0482: 'oc',

    0x0448: 'or',

    0x0463: 'ps',

    0x0415: 'pl',

    0x0416: 'pt',

    0x0816: 'pt-PT',

    0x0446: 'pa',

    0x046B: 'qu-BO',

    0x086B: 'qu-EC',

    0x0C6B: 'qu',

    0x0418: 'ro',

    0x0417: 'rm',

    0x0419: 'ru',

    0x243B: 'smn',

    0x103B: 'smj-NO',

    0x143B: 'smj',

    0x0C3B: 'se-FI',

    0x043B: 'se',

    0x083B: 'se-SE',

    0x203B: 'sms',

    0x183B: 'sma-NO',

    0x1C3B: 'sms',

    0x044F: 'sa',

    0x1C1A: 'sr-Cyrl-BA',

    0x0C1A: 'sr',

    0x181A: 'sr-Latn-BA',

    0x081A: 'sr-Latn',

    0x046C: 'nso',

    0x0432: 'tn',

    0x045B: 'si',

    0x041B: 'sk',

    0x0424: 'sl',

    0x2C0A: 'es-AR',

    0x400A: 'es-BO',

    0x340A: 'es-CL',

    0x240A: 'es-CO',

    0x140A: 'es-CR',

    0x1C0A: 'es-DO',

    0x300A: 'es-EC',

    0x440A: 'es-SV',

    0x100A: 'es-GT',

    0x480A: 'es-HN',

    0x080A: 'es-MX',

    0x4C0A: 'es-NI',

    0x180A: 'es-PA',

    0x3C0A: 'es-PY',

    0x280A: 'es-PE',

    0x500A: 'es-PR',

    # Microsoft has defined two different language codes for

    # “Spanish with modern sorting” and “Spanish with traditional

    # sorting”. This makes sense for collation APIs, and it would be

    # possible to express this in BCP 47 language tags via Unicode

    # extensions (eg., “es-u-co-trad” is “Spanish with traditional

    # sorting”). However, for storing names in fonts, this distinction

    # does not make sense, so we use “es” in both cases.

    0x0C0A: 'es',

    0x040A: 'es',

    0x540A: 'es-US',

    0x380A: 'es-UY',

    0x200A: 'es-VE',

    0x081D: 'sv-FI',

    0x041D: 'sv',

    0x045A: 'syr',

    0x0428: 'tg',

    0x085F: 'tzm',

    0x0449: 'ta',

    0x0444: 'tt',

    0x044A: 'te',

    0x041E: 'th',

    0x0451: 'bo',

    0x041F: 'tr',

    0x0442: 'tk',

    0x0480: 'ug',

    0x0422: 'uk',

    0x042E: 'hsb',

    0x0420: 'ur',

    0x0843: 'uz-Cyrl',

    0x0443: 'uz',

    0x042A: 'vi',

    0x0452: 'cy',

    0x0488: 'wo',

    0x0485: 'sah',

    0x0478: 'ii',

    0x046A: 'yo',

}

_MAC_LANGUAGES = {

    0: 'en',

    1: 'fr',

    2: 'de',

    3: 'it',

    4: 'nl',

    5: 'sv',

    6: 'es',

    7: 'da',

    8: 'pt',

    9: 'no',

    10: 'he',

    11: 'ja',

    12: 'ar',

    13: 'fi',

    14: 'el',

    15: 'is',

    16: 'mt',

    17: 'tr',

    18: 'hr',

    19: 'zh-Hant',

    20: 'ur',

    21: 'hi',

    22: 'th',

    23: 'ko',

    24: 'lt',

    25: 'pl',

    26: 'hu',

    27: 'es',

    28: 'lv',

    29: 'se',

    30: 'fo',

    31: 'fa',

    32: 'ru',

    33: 'zh',

    34: 'nl-BE',

    35: 'ga',

    36: 'sq',

    37: 'ro',

    38: 'cz',

    39: 'sk',

    40: 'sl',

    41: 'yi',

    42: 'sr',

    43: 'mk',

    44: 'bg',

    45: 'uk',

    46: 'be',

    47: 'uz',

    48: 'kk',

    49: 'az-Cyrl',

    50: 'az-Arab',

    51: 'hy',

    52: 'ka',

    53: 'mo',

    54: 'ky',

    55: 'tg',

    56: 'tk',

    57: 'mn-CN',

    58: 'mn',

    59: 'ps',

    60: 'ks',

    61: 'ku',

    62: 'sd',

    63: 'bo',

    64: 'ne',

    65: 'sa',

    66: 'mr',

    67: 'bn',

    68: 'as',

    69: 'gu',

    70: 'pa',

    71: 'or',

    72: 'ml',

    73: 'kn',

    74: 'ta',

    75: 'te',

    76: 'si',

    77: 'my',

    78: 'km',

    79: 'lo',

    80: 'vi',

    81: 'id',

    82: 'tl',

    83: 'ms',

    84: 'ms-Arab',

    85: 'am',

    86: 'ti',

    87: 'om',

    88: 'so',

    89: 'sw',

    90: 'rw',

    91: 'rn',

    92: 'ny',

    93: 'mg',

    94: 'eo',

    128: 'cy',

    129: 'eu',

    130: 'ca',

    131: 'la',

    132: 'qu',

    133: 'gn',

    134: 'ay',

    135: 'tt',

    136: 'ug',

    137: 'dz',

    138: 'jv',

    139: 'su',

    140: 'gl',

    141: 'af',

    142: 'br',

    143: 'iu',

    144: 'gd',

    145: 'gv',

    146: 'ga',

    147: 'to',

    148: 'el-polyton',

    149: 'kl',

    150: 'az',

    151: 'nn',

}

_WINDOWS_LANGUAGE_CODES = {lang.lower(): code for code, lang in _WINDOWS_LANGUAGES.items()}

_MAC_LANGUAGE_CODES = {lang.lower(): code for code, lang in _MAC_LANGUAGES.items()}

# MacOS language ID → MacOS script ID

#

# Note that the script ID is not sufficient to determine what encoding

# to use in TrueType files. For some languages, MacOS used a modification

# of a mainstream script. For example, an Icelandic name would be stored

# with smRoman in the TrueType naming table, but the actual encoding

# is a special Icelandic version of the normal Macintosh Roman encoding.

# As another example, Inuktitut uses an 8-bit encoding for Canadian Aboriginal

# Syllables but MacOS had run out of available script codes, so this was

# done as a (pretty radical) “modification” of Ethiopic.

#

# http://unicode.org/Public/MAPPINGS/VENDORS/APPLE/Readme.txt

_MAC_LANGUAGE_TO_SCRIPT = {

    0: 0,  # langEnglish → smRoman

    1: 0,  # langFrench → smRoman

    2: 0,  # langGerman → smRoman

    3: 0,  # langItalian → smRoman

    4: 0,  # langDutch → smRoman

    5: 0,  # langSwedish → smRoman

    6: 0,  # langSpanish → smRoman

    7: 0,  # langDanish → smRoman

    8: 0,  # langPortuguese → smRoman

    9: 0,  # langNorwegian → smRoman

    10: 5,  # langHebrew → smHebrew

    11: 1,  # langJapanese → smJapanese

    12: 4,  # langArabic → smArabic

    13: 0,  # langFinnish → smRoman

    14: 6,  # langGreek → smGreek

    15: 0,  # langIcelandic → smRoman (modified)

    16: 0,  # langMaltese → smRoman

    17: 0,  # langTurkish → smRoman (modified)

    18: 0,  # langCroatian → smRoman (modified)

    19: 2,  # langTradChinese → smTradChinese

    20: 4,  # langUrdu → smArabic

    21: 9,  # langHindi → smDevanagari

    22: 21,  # langThai → smThai

    23: 3,  # langKorean → smKorean

    24: 29,  # langLithuanian → smCentralEuroRoman

    25: 29,  # langPolish → smCentralEuroRoman

    26: 29,  # langHungarian → smCentralEuroRoman

    27: 29,  # langEstonian → smCentralEuroRoman

    28: 29,  # langLatvian → smCentralEuroRoman

    29: 0,  # langSami → smRoman

    30: 0,  # langFaroese → smRoman (modified)

    31: 4,  # langFarsi → smArabic (modified)

    32: 7,  # langRussian → smCyrillic

    33: 25,  # langSimpChinese → smSimpChinese

    34: 0,  # langFlemish → smRoman

    35: 0,  # langIrishGaelic → smRoman (modified)

    36: 0,  # langAlbanian → smRoman

    37: 0,  # langRomanian → smRoman (modified)

    38: 29,  # langCzech → smCentralEuroRoman

    39: 29,  # langSlovak → smCentralEuroRoman

    40: 0,  # langSlovenian → smRoman (modified)

    41: 5,  # langYiddish → smHebrew

    42: 7,  # langSerbian → smCyrillic

    43: 7,  # langMacedonian → smCyrillic

    44: 7,  # langBulgarian → smCyrillic

    45: 7,  # langUkrainian → smCyrillic (modified)

    46: 7,  # langByelorussian → smCyrillic

    47: 7,  # langUzbek → smCyrillic

    48: 7,  # langKazakh → smCyrillic

    49: 7,  # langAzerbaijani → smCyrillic