harfbuzz 2.6.2

git-svn-id: svn://tug.org/texlive/trunk@52233 c570f23f-e606-0410-a88d-b1316a301751
author: Akira Kakuto <kakuto@fuk.kindai.ac.jp> 2019-09-30 22:08:36 +0000
committer: Akira Kakuto <kakuto@fuk.kindai.ac.jp> 2019-09-30 22:08:36 +0000
commit: 883a87cde515fcdd076708f212ebb66ed32b145f (patch)
tree: ac0fce4c70597596bb267f760197a09232b219b1 /Build/source/libs
parent: 6c0fed440c27ba0d6856feeb1000320320cf8a96 (diff)
116 files changed, 4478 insertions, 1423 deletions
diff --git a/Build/source/libs/README b/Build/source/libs/README
index 08341cc7513..3fbd6a47e65 100644
--- a/Build/source/libs/README
+++ b/Build/source/libs/README
@@ -25,7 +25,7 @@ graphite2 1.3.13 - checked 21dec18
   http://sourceforge.net/projects/silgraphite/files/graphite2/
   (requires C++11)
 
-harfbuzz 2.6.1 - checked 24aug19
+harfbuzz 2.6.2 - checked 01oct19
   http://www.freedesktop.org/software/harfbuzz/release/
 
 icu 63.1 - checked 8jan19
diff --git a/Build/source/libs/harfbuzz/ChangeLog b/Build/source/libs/harfbuzz/ChangeLog
index 6b3b2466b16..737ad49db32 100644
--- a/Build/source/libs/harfbuzz/ChangeLog
+++ b/Build/source/libs/harfbuzz/ChangeLog
@@ -1,3 +1,8 @@
+2019-10-01  Akira Kakuto  <kakuto@w32tex.org>
+
+	Import harfbuzz-2.6.2.
+	* Makefile.am, version.ac: Adjusted.
+
 2019-08-24  Akira Kakuto  <kakuto@w32tex.org>
 
 	Import harfbuzz-2.6.1.
diff --git a/Build/source/libs/harfbuzz/Makefile.am b/Build/source/libs/harfbuzz/Makefile.am
index 787fcc32d74..071afb227eb 100644
--- a/Build/source/libs/harfbuzz/Makefile.am
+++ b/Build/source/libs/harfbuzz/Makefile.am
@@ -64,6 +64,9 @@ libharfbuzz_a_SOURCES =  \
 	@HARFBUZZ_TREE@/src/hb-meta.hh \
 	@HARFBUZZ_TREE@/src/hb-mutex.hh \
 	@HARFBUZZ_TREE@/src/hb-null.hh \
+	@HARFBUZZ_TREE@/src/hb-number-parser.hh \
+	@HARFBUZZ_TREE@/src/hb-number.cc \
+	@HARFBUZZ_TREE@/src/hb-number.hh \
 	@HARFBUZZ_TREE@/src/hb-object.hh \
 	@HARFBUZZ_TREE@/src/hb-open-file.hh \
 	@HARFBUZZ_TREE@/src/hb-open-type.hh \
diff --git a/Build/source/libs/harfbuzz/Makefile.in b/Build/source/libs/harfbuzz/Makefile.in
index fbcb774ae8b..861fbbae639 100644
--- a/Build/source/libs/harfbuzz/Makefile.in
+++ b/Build/source/libs/harfbuzz/Makefile.in
@@ -126,6 +126,7 @@ am_libharfbuzz_a_OBJECTS = @HARFBUZZ_TREE@/src/hb-blob.$(OBJEXT) \
 	@HARFBUZZ_TREE@/src/hb-face.$(OBJEXT) \
 	@HARFBUZZ_TREE@/src/hb-font.$(OBJEXT) \
 	@HARFBUZZ_TREE@/src/hb-map.$(OBJEXT) \
+	@HARFBUZZ_TREE@/src/hb-number.$(OBJEXT) \
 	@HARFBUZZ_TREE@/src/hb-ot-cff1-table.$(OBJEXT) \
 	@HARFBUZZ_TREE@/src/hb-ot-cff2-table.$(OBJEXT) \
 	@HARFBUZZ_TREE@/src/hb-ot-face.$(OBJEXT) \
@@ -204,6 +205,7 @@ am__depfiles_remade = ./$(DEPDIR)/hbtest-dummy.Po \
 	@HARFBUZZ_TREE@/src/$(DEPDIR)/hb-font.Po \
 	@HARFBUZZ_TREE@/src/$(DEPDIR)/hb-graphite2.Po \
 	@HARFBUZZ_TREE@/src/$(DEPDIR)/hb-map.Po \
+	@HARFBUZZ_TREE@/src/$(DEPDIR)/hb-number.Po \
 	@HARFBUZZ_TREE@/src/$(DEPDIR)/hb-ot-cff1-table.Po \
 	@HARFBUZZ_TREE@/src/$(DEPDIR)/hb-ot-cff2-table.Po \
 	@HARFBUZZ_TREE@/src/$(DEPDIR)/hb-ot-color.Po \
@@ -733,6 +735,9 @@ libharfbuzz_a_SOURCES = @HARFBUZZ_TREE@/src/hb-algs.hh \
 	@HARFBUZZ_TREE@/src/hb-machinery.hh \
 	@HARFBUZZ_TREE@/src/hb-meta.hh @HARFBUZZ_TREE@/src/hb-mutex.hh \
 	@HARFBUZZ_TREE@/src/hb-null.hh \
+	@HARFBUZZ_TREE@/src/hb-number-parser.hh \
+	@HARFBUZZ_TREE@/src/hb-number.cc \
+	@HARFBUZZ_TREE@/src/hb-number.hh \
 	@HARFBUZZ_TREE@/src/hb-object.hh \
 	@HARFBUZZ_TREE@/src/hb-open-file.hh \
 	@HARFBUZZ_TREE@/src/hb-open-type.hh \
@@ -983,6 +988,9 @@ clean-noinstLIBRARIES:
 @HARFBUZZ_TREE@/src/hb-map.$(OBJEXT):  \
 	@HARFBUZZ_TREE@/src/$(am__dirstamp) \
 	@HARFBUZZ_TREE@/src/$(DEPDIR)/$(am__dirstamp)
+@HARFBUZZ_TREE@/src/hb-number.$(OBJEXT):  \
+	@HARFBUZZ_TREE@/src/$(am__dirstamp) \
+	@HARFBUZZ_TREE@/src/$(DEPDIR)/$(am__dirstamp)
 @HARFBUZZ_TREE@/src/hb-ot-cff1-table.$(OBJEXT):  \
 	@HARFBUZZ_TREE@/src/$(am__dirstamp) \
 	@HARFBUZZ_TREE@/src/$(DEPDIR)/$(am__dirstamp)
@@ -1142,6 +1150,7 @@ distclean-compile:
 @AMDEP_TRUE@@am__include@ @am__quote@@HARFBUZZ_TREE@/src/$(DEPDIR)/hb-font.Po@am__quote@ # am--include-marker
 @AMDEP_TRUE@@am__include@ @am__quote@@HARFBUZZ_TREE@/src/$(DEPDIR)/hb-graphite2.Po@am__quote@ # am--include-marker
 @AMDEP_TRUE@@am__include@ @am__quote@@HARFBUZZ_TREE@/src/$(DEPDIR)/hb-map.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@@HARFBUZZ_TREE@/src/$(DEPDIR)/hb-number.Po@am__quote@ # am--include-marker
 @AMDEP_TRUE@@am__include@ @am__quote@@HARFBUZZ_TREE@/src/$(DEPDIR)/hb-ot-cff1-table.Po@am__quote@ # am--include-marker
 @AMDEP_TRUE@@am__include@ @am__quote@@HARFBUZZ_TREE@/src/$(DEPDIR)/hb-ot-cff2-table.Po@am__quote@ # am--include-marker
 @AMDEP_TRUE@@am__include@ @am__quote@@HARFBUZZ_TREE@/src/$(DEPDIR)/hb-ot-color.Po@am__quote@ # am--include-marker
@@ -1785,6 +1794,7 @@ distclean: distclean-recursive
 	-rm -f @HARFBUZZ_TREE@/src/$(DEPDIR)/hb-font.Po
 	-rm -f @HARFBUZZ_TREE@/src/$(DEPDIR)/hb-graphite2.Po
 	-rm -f @HARFBUZZ_TREE@/src/$(DEPDIR)/hb-map.Po
+	-rm -f @HARFBUZZ_TREE@/src/$(DEPDIR)/hb-number.Po
 	-rm -f @HARFBUZZ_TREE@/src/$(DEPDIR)/hb-ot-cff1-table.Po
 	-rm -f @HARFBUZZ_TREE@/src/$(DEPDIR)/hb-ot-cff2-table.Po
 	-rm -f @HARFBUZZ_TREE@/src/$(DEPDIR)/hb-ot-color.Po
@@ -1884,6 +1894,7 @@ maintainer-clean: maintainer-clean-recursive
 	-rm -f @HARFBUZZ_TREE@/src/$(DEPDIR)/hb-font.Po
 	-rm -f @HARFBUZZ_TREE@/src/$(DEPDIR)/hb-graphite2.Po
 	-rm -f @HARFBUZZ_TREE@/src/$(DEPDIR)/hb-map.Po
+	-rm -f @HARFBUZZ_TREE@/src/$(DEPDIR)/hb-number.Po
 	-rm -f @HARFBUZZ_TREE@/src/$(DEPDIR)/hb-ot-cff1-table.Po
 	-rm -f @HARFBUZZ_TREE@/src/$(DEPDIR)/hb-ot-cff2-table.Po
 	-rm -f @HARFBUZZ_TREE@/src/$(DEPDIR)/hb-ot-color.Po
diff --git a/Build/source/libs/harfbuzz/TLpatches/ChangeLog b/Build/source/libs/harfbuzz/TLpatches/ChangeLog
index 38e801f899e..29bc18d0ddd 100644
--- a/Build/source/libs/harfbuzz/TLpatches/ChangeLog
+++ b/Build/source/libs/harfbuzz/TLpatches/ChangeLog
@@ -1,3 +1,8 @@
+2019-10-01  Akira Kakuto  <kakuto@w32tex.org>
+
+	Imported harfbuzz-2.6.2 source tree from:
+	  http://www.freedesktop.org/software/harfbuzz/release/
+
 2019-08-24  Akira Kakuto  <kakuto@w32tex.org>
 
 	Imported harfbuzz-2.6.1 source tree from:
diff --git a/Build/source/libs/harfbuzz/TLpatches/TL-Changes b/Build/source/libs/harfbuzz/TLpatches/TL-Changes
index 5c4f4e2d6ed..0151695d887 100644
--- a/Build/source/libs/harfbuzz/TLpatches/TL-Changes
+++ b/Build/source/libs/harfbuzz/TLpatches/TL-Changes
@@ -1,4 +1,4 @@
-Changes applied to the harfbuzz-2.6.1/ tree as obtained from:
+Changes applied to the harfbuzz-2.6.2/ tree as obtained from:
 	http://www.freedesktop.org/software/harfbuzz/release/
 
 Removed:
diff --git a/Build/source/libs/harfbuzz/configure b/Build/source/libs/harfbuzz/configure
index 425ecf3d5df..ebf0c8f118c 100755
--- a/Build/source/libs/harfbuzz/configure
+++ b/Build/source/libs/harfbuzz/configure
@@ -1,6 +1,6 @@
 #! /bin/sh
 # Guess values for system-dependent variables and create Makefiles.
-# Generated by GNU Autoconf 2.69 for harfbuzz (TeX Live) 2.6.1.
+# Generated by GNU Autoconf 2.69 for harfbuzz (TeX Live) 2.6.2.
 #
 # Report bugs to <tex-k@tug.org>.
 #
@@ -580,8 +580,8 @@ MAKEFLAGS=
 # Identity of this package.
 PACKAGE_NAME='harfbuzz (TeX Live)'
 PACKAGE_TARNAME='harfbuzz--tex-live-'
-PACKAGE_VERSION='2.6.1'
-PACKAGE_STRING='harfbuzz (TeX Live) 2.6.1'
+PACKAGE_VERSION='2.6.2'
+PACKAGE_STRING='harfbuzz (TeX Live) 2.6.2'
 PACKAGE_BUGREPORT='tex-k@tug.org'
 PACKAGE_URL=''
 
@@ -1311,7 +1311,7 @@ if test "$ac_init_help" = "long"; then
   # Omit some internal or obsolete options to make the list less imposing.
   # This message is too long to be a string in the A/UX 3.1 sh.
   cat <<_ACEOF
-\`configure' configures harfbuzz (TeX Live) 2.6.1 to adapt to many kinds of systems.
+\`configure' configures harfbuzz (TeX Live) 2.6.2 to adapt to many kinds of systems.
 
 Usage: $0 [OPTION]... [VAR=VALUE]...
 
@@ -1382,7 +1382,7 @@ fi
 
 if test -n "$ac_init_help"; then
   case $ac_init_help in
-     short | recursive ) echo "Configuration of harfbuzz (TeX Live) 2.6.1:";;
+     short | recursive ) echo "Configuration of harfbuzz (TeX Live) 2.6.2:";;
    esac
   cat <<\_ACEOF
 
@@ -1487,7 +1487,7 @@ fi
 test -n "$ac_init_help" && exit $ac_status
 if $ac_init_version; then
   cat <<\_ACEOF
-harfbuzz (TeX Live) configure 2.6.1
+harfbuzz (TeX Live) configure 2.6.2
 generated by GNU Autoconf 2.69
 
 Copyright (C) 2012 Free Software Foundation, Inc.
@@ -2123,7 +2123,7 @@ cat >config.log <<_ACEOF
 This file contains any messages produced by compilers while
 running configure, to aid debugging if configure makes a mistake.
 
-It was created by harfbuzz (TeX Live) $as_me 2.6.1, which was
+It was created by harfbuzz (TeX Live) $as_me 2.6.2, which was
 generated by GNU Autoconf 2.69.  Invocation command line was
 
   $ $0 $@
@@ -4047,7 +4047,7 @@ fi
 
 # Define the identity of the package.
  PACKAGE='harfbuzz--tex-live-'
- VERSION='2.6.1'
+ VERSION='2.6.2'
 
 
 # Some tools Automake needs.
@@ -4241,8 +4241,8 @@ WARNING_CFLAGS=$kpse_cv_warning_cflags
 
 HB_VERSION_MAJOR=2
 HB_VERSION_MINOR=6
-HB_VERSION_MICRO=1
-HB_VERSION=2.6.1
+HB_VERSION_MICRO=2
+HB_VERSION=2.6.2
 
 ac_ext=c
 ac_cpp='$CPP $CPPFLAGS'
@@ -7919,7 +7919,7 @@ cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
 # report actual input values of CONFIG_FILES etc. instead of their
 # values after options handling.
 ac_log="
-This file was extended by harfbuzz (TeX Live) $as_me 2.6.1, which was
+This file was extended by harfbuzz (TeX Live) $as_me 2.6.2, which was
 generated by GNU Autoconf 2.69.  Invocation command line was
 
   CONFIG_FILES    = $CONFIG_FILES
@@ -7985,7 +7985,7 @@ _ACEOF
 cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
 ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
 ac_cs_version="\\
-harfbuzz (TeX Live) config.status 2.6.1
+harfbuzz (TeX Live) config.status 2.6.2
 configured by $0, generated by GNU Autoconf 2.69,
   with options \\"\$ac_cs_config\\"
 
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/CMakeLists.txt b/Build/source/libs/harfbuzz/harfbuzz-src/CMakeLists.txt
index 66e4a838834..2a8fd8b9797 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/CMakeLists.txt
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/CMakeLists.txt
@@ -108,7 +108,7 @@ endmacro ()
 if (UNIX)
   list(APPEND CMAKE_REQUIRED_LIBRARIES m)
 endif ()
-check_funcs(atexit mprotect sysconf getpagesize mmap isatty newlocale strtod_l)
+check_funcs(atexit mprotect sysconf getpagesize mmap isatty newlocale strtod_l roundf)
 check_include_file(unistd.h HAVE_UNISTD_H)
 if (${HAVE_UNISTD_H})
   add_definitions(-DHAVE_UNISTD_H)
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/ChangeLog b/Build/source/libs/harfbuzz/harfbuzz-src/ChangeLog
index 481fb20dbd6..5432e12cb63 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/ChangeLog
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/ChangeLog
@@ -1,3 +1,1688 @@
+commit e48ef0804ad7e4abd35ff3646fa6ed10ad32f1ef
+Author: Behdad Esfahbod <behdad@behdad.org>
+Date:   Mon Sep 30 12:39:06 2019 -0700
+
+    2.6.2
+
+ NEWS             | 6 ++++++
+ configure.ac     | 2 +-
+ src/hb-version.h | 4 ++--
+ 3 files changed, 9 insertions(+), 3 deletions(-)
+
+commit d6ad613159aabce42fc21d57f6f1a4762c5617bf
+Author: Behdad Esfahbod <behdad@behdad.org>
+Date:   Tue Sep 10 15:31:44 2019 -0700
+
+    [docs] Misc fixes
+
+ docs/harfbuzz-sections.txt | 4 ++--
+ src/hb-gdi.cc              | 2 +-
+ src/hb-ot-layout.cc        | 2 +-
+ 3 files changed, 4 insertions(+), 4 deletions(-)
+
+commit 2dce85ed06a8cc7ca20900c65662af659c53e717
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Thu Sep 26 21:15:59 2019 +0330
+
+    [icu] Remove HB_ICU_STMT (#1993)
+    
+    And ignore extra semicolon error to ICU versions < 65
+
+ src/hb-icu.cc | 43 ++++++++++++++++++++++++-------------------
+ 1 file changed, 24 insertions(+), 19 deletions(-)
+
+commit d6a83abd6a0c684bd9a27f593d5be388819022b7
+Author: Iceflower <iceflower@gmx.de>
+Date:   Thu Sep 26 11:42:11 2019 +0200
+
+    Define HB_UNUSED for clang
+
+ src/hb.hh | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+commit c4567968cd175dc367ab951c9e3141ab5c03c2d6
+Author: Iceflower <iceflower@gmx.de>
+Date:   Thu Sep 26 11:35:27 2019 +0200
+
+    [dwrite] Fix extra semicolon issue
+
+ src/hb-directwrite.cc | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+commit b0c3eb06b64dcfcfee09a25dde8250804484f77d
+Author: Qunxin Liu <qxliu@google.com>
+Date:   Wed Sep 18 16:11:44 2019 -0700
+
+    [subset] GPOS Lookup Type 3: CursivePos
+
+ src/hb-ot-layout-common.hh                         |  33 ++++++++
+ src/hb-ot-layout-gpos-table.hh                     |  87 ++++++++++++++++++++-
+ test/subset/data/Makefile.am                       |   1 +
+ test/subset/data/Makefile.sources                  |   1 +
+ .../gpos3_font3.keep-layout-retain-gids.28,29.otf  | Bin 0 -> 1712 bytes
+ .../gpos3_font3.keep-layout-retain-gids.28,2B.otf  | Bin 0 -> 1860 bytes
+ .../gpos3_font3.keep-layout-retain-gids.29,2B.otf  | Bin 0 -> 1772 bytes
+ ...eep-layout-retain-gids.retain-all-codepoint.otf | Bin 0 -> 3692 bytes
+ .../layout.gpos3/gpos3_font3.keep-layout.28,29.otf | Bin 0 -> 1328 bytes
+ .../layout.gpos3/gpos3_font3.keep-layout.28,2B.otf | Bin 0 -> 1456 bytes
+ .../layout.gpos3/gpos3_font3.keep-layout.29,2B.otf | Bin 0 -> 1368 bytes
+ ...pos3_font3.keep-layout.retain-all-codepoint.otf | Bin 0 -> 3692 bytes
+ test/subset/data/fonts/gpos3_font3.otf             | Bin 0 -> 4624 bytes
+ test/subset/data/tests/layout.gpos3.tests          |  12 +++
+ 14 files changed, 132 insertions(+), 2 deletions(-)
+
+commit 68d39ea4866a9d2bae60107619aad25dac6da241
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Tue Sep 24 13:52:46 2019 +0330
+
+    Revert previous change and fix -Wrange-loop-analysis complains
+
+ src/hb-ot-layout-gpos-table.hh | 6 +++---
+ src/hb-ot-vorg-table.hh        | 2 +-
+ 2 files changed, 4 insertions(+), 4 deletions(-)
+
+commit cbc0646a6cfc0f6a04804d6888636f12130cd51b
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Tue Sep 24 12:08:12 2019 +0330
+
+    Minor, normalize for each calls
+
+ src/hb-ot-glyf-table.hh        |  5 +----
+ src/hb-ot-layout-gpos-table.hh | 10 +++++-----
+ src/hb-ot-name-table.hh        |  3 +--
+ src/hb-ot-vorg-table.hh        |  3 +--
+ 4 files changed, 8 insertions(+), 13 deletions(-)
+
+commit 22b6c6a5c7b9bebe123822c702b9661e144ebd6b
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Tue Sep 24 12:06:28 2019 +0330
+
+    [serialize] use for each as #resolve_links, format
+
+ src/hb-serialize.hh | 22 +++++++---------------
+ 1 file changed, 7 insertions(+), 15 deletions(-)
+
+commit 512551f27600adac875de3381533b52d78f6b22d
+Author: Qunxin Liu <48925186+qxliu76@users.noreply.github.com>
+Date:   Mon Sep 23 17:28:16 2019 -0700
+
+    memory leak fix in serializer (#1988)
+
+ src/hb-serialize.hh | 1 +
+ 1 file changed, 1 insertion(+)
+
+commit f0a7677993e51ba4076a0f9a0e7d032d99917d34
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Mon Sep 23 21:09:39 2019 +0330
+
+    [gpos] minor
+
+ src/hb-ot-layout-gpos-table.hh | 8 ++++----
+ 1 file changed, 4 insertions(+), 4 deletions(-)
+
+commit 035ec3d1b46b8e60bea3aa8dcf29cf47a5a42d57
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Mon Sep 23 20:51:43 2019 +0330
+
+    [cmap] remove has_format14, minor format
+    
+    fixes #1986
+
+ src/hb-ot-cmap-table.hh | 9 ++++-----
+ 1 file changed, 4 insertions(+), 5 deletions(-)
+
+commit c1a585fab0c17fe47b0728cf67920791c2173019
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Sat Sep 21 23:30:52 2019 +0430
+
+    [gpos] minor
+
+ src/hb-ot-layout-gpos-table.hh | 22 +++++++---------------
+ 1 file changed, 7 insertions(+), 15 deletions(-)
+
+commit d87d38998a4ff7bec3d8fb658dc9299f144a2fcb
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Sat Sep 21 17:27:39 2019 +0430
+
+    Fix clang -Wrange-loop-analysis complains
+    
+    ./hb-ot-layout-gpos-table.hh:674:43: error: loop variable '_' is always a copy because the range of type 'hb_zip_iter_t<hb_iter_type<hb_array_t<const OT::IntType<unsigned short, 2> > &>, hb_iter_type<hb_array_t<const OT::IntType<unsigned short, 2> > &> >' (aka 'hb_zip_iter_t<hb_array_t<const OT::IntType<unsigned short, 2> >, hb_array_t<const OT::IntType<unsigned short, 2> > >') does not return a reference [-Werror,-Wrange-loop-analysis]
+          for (const hb_pair_t<Value, Value>& _ : hb_zip (val_iter, first_val_iter))
+                                              ^
+    ./hb-ot-layout-gpos-table.hh:674:12: note: use non-reference type 'hb_pair_t<OT::Value, OT::Value>' (aka 'hb_pair_t<IntType<unsigned short, 2>, IntType<unsigned short, 2> >')
+          for (const hb_pair_t<Value, Value>& _ : hb_zip (val_iter, first_val_iter))
+    
+    and
+    
+    In file included from hb-subset.cc:44:
+    ./hb-ot-vorg-table.hh:87:34: error: loop variable '_' is always a copy because the range of type 'hb_map_iter_t<hb_filter_iter_t<hb_sorted_array_t<const OT::VertOriginMetric>, const hb_set_t *, OT::HBGlyphID OT::VertOriginMetric::*, nullptr>, (lambda at ./hb-ot-vorg-table.hh:100:15), hb_function_sortedness_t::NOT_SORTED, nullptr>' does not return a reference [-Werror,-Wrange-loop-analysis]
+        for (const VertOriginMetric& _ : it)
+                                     ^
+    ./hb-ot-vorg-table.hh:113:17: note: in instantiation of function template specialization 'OT::VORG::serialize<hb_map_iter_t<hb_filter_iter_t<hb_sorted_array_t<const OT::VertOriginMetric>, const hb_set_t *, OT::HBGlyphID OT::VertOriginMetric::*, nullptr>, (lambda at ./hb-ot-vorg-table.hh:100:15), hb_function_sortedness_t::NOT_SORTED, nullptr>, nullptr>' requested here
+        vorg_prime->serialize (c->serializer, it, defaultVertOriginY);
+                    ^
+    ./hb-ot-vorg-table.hh:87:10: note: use non-reference type 'OT::VertOriginMetric'
+        for (const VertOriginMetric& _ : it)
+             ^~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+ src/hb-ot-layout-gpos-table.hh | 2 +-
+ src/hb-ot-vorg-table.hh        | 2 +-
+ 2 files changed, 2 insertions(+), 2 deletions(-)
+
+commit 6e42a418c8fe4231c3cc080bc771455578b0cce0
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Sat Sep 21 16:25:54 2019 +0430
+
+    Minor, turn more of hb_apply to for each
+
+ src/hb-ot-glyf-table.hh        |  5 ++---
+ src/hb-ot-layout-gpos-table.hh | 42 ++++++++++++++----------------------------
+ src/hb-ot-name-table.hh        |  5 ++---
+ src/hb-ot-vorg-table.hh        |  5 ++---
+ 4 files changed, 20 insertions(+), 37 deletions(-)
+
+commit 0665dce1163317390adbed9394cce2b1325ddb6c
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Sat Sep 21 17:22:02 2019 +0430
+
+    [fuzzer] Don't process output in debug mode as it causes timeout
+
+ test/fuzzing/run-shape-fuzzer-tests.py  | 7 ++++++-
+ test/fuzzing/run-subset-fuzzer-tests.py | 7 ++++++-
+ 2 files changed, 12 insertions(+), 2 deletions(-)
+
+commit dc886f6638f50e45e73d01e49db77b4bcefc85e1
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Sat Sep 14 11:18:47 2019 +0430
+
+    [ci] Re-enable debug builds on fedora bot
+
+ .circleci/config.yml | 4 ++--
+ 1 file changed, 2 insertions(+), 2 deletions(-)
+
+commit 70228f68ac413ee19281861e3039a82d90c17f2a
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Sat Sep 21 16:24:41 2019 +0430
+
+    [ci] Enable HB_WITH_WIN1256 on -Weverything bot
+    
+    To catch its compile warnings, #1969 related
+
+ .circleci/config.yml | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+commit 385741d565de1cc90de23664f8e66fc77c31efae
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Sat Sep 21 15:26:14 2019 +0430
+
+    [cmap] Turn hb_apply into foreach where possible
+
+ src/hb-ot-cmap-table.hh | 151 +++++++++++++++++++-----------------------------
+ 1 file changed, 61 insertions(+), 90 deletions(-)
+
+commit 1023c2cc6de0f33602df8709134bef8cdb66ba0c
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Sat Sep 21 14:33:43 2019 +0430
+
+    [cmap] minor
+
+ src/hb-ot-cmap-table.hh | 62 ++++++++++++++++++-------------------------------
+ 1 file changed, 22 insertions(+), 40 deletions(-)
+
+commit ead46eefe3bf2bea61c86689f4c5a1da9b7e446b
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Sat Sep 21 14:25:11 2019 +0430
+
+    minor, use internal API instead public hb_set_has
+
+ src/hb-ot-cmap-table.hh | 4 ++--
+ src/hb-subset-plan.cc   | 2 +-
+ 2 files changed, 3 insertions(+), 3 deletions(-)
+
+commit d8af4e7701fe63d63f6669706ce7a5bb3a15a19d
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Sat Sep 21 14:19:14 2019 +0430
+
+    [cmap] minor, turn 8 spaces to tab
+
+ src/hb-ot-cmap-table.hh | 228 ++++++++++++++++++++++++------------------------
+ src/hb-subset-plan.cc   |   6 +-
+ 2 files changed, 117 insertions(+), 117 deletions(-)
+
+commit 4315666283a7d1b175d1c3ed43b5ac85fdc84a50
+Author: Qunxin Liu <qxliu@google.com>
+Date:   Thu Aug 29 11:17:20 2019 -0700
+
+    [subset] updates according to review comments
+
+ src/hb-ot-cmap-table.hh | 95 ++++++++++++++++++++++++-------------------------
+ 1 file changed, 47 insertions(+), 48 deletions(-)
+
+commit bf66d1bf589b6af2ceb30c18619f210b718c9db9
+Author: Qunxin Liu <qxliu@google.com>
+Date:   Wed Aug 21 14:24:33 2019 -0700
+
+    [subset] Add integration tests for cmap14
+
+ test/subset/data/Makefile.am                       |   1 +
+ test/subset/data/Makefile.sources                  |   1 +
+ .../cmap14/cmap14_font1.default.4E00,4E02,4E03.otf | Bin 0 -> 1360 bytes
+ .../cmap14/cmap14_font1.default.4E00,4E03.otf      | Bin 0 -> 1236 bytes
+ .../cmap14/cmap14_font1.default.4E00,4E05,4E07.otf | Bin 0 -> 1328 bytes
+ .../cmap14/cmap14_font1.default.4E02,4E03,4E08.otf | Bin 0 -> 1576 bytes
+ .../expected/cmap14/cmap14_font1.default.4E02.otf  | Bin 0 -> 996 bytes
+ .../expected/cmap14/cmap14_font1.default.4E03.otf  | Bin 0 -> 1080 bytes
+ .../cmap14_font1.default.4E05,4E07,4E08,4E09.otf   | Bin 0 -> 1848 bytes
+ .../cmap14/cmap14_font1.default.4E08,4E09.otf      | Bin 0 -> 1720 bytes
+ .../expected/cmap14/cmap14_font1.default.4E08.otf  | Bin 0 -> 1384 bytes
+ .../cmap14_font1.default.retain-all-codepoint.otf  | Bin 0 -> 2348 bytes
+ ...font1.drop-hints-retain-gids.4E00,4E02,4E03.otf | Bin 0 -> 1388 bytes
+ ...ap14_font1.drop-hints-retain-gids.4E00,4E03.otf | Bin 0 -> 1272 bytes
+ ...font1.drop-hints-retain-gids.4E00,4E05,4E07.otf | Bin 0 -> 1396 bytes
+ ...font1.drop-hints-retain-gids.4E02,4E03,4E08.otf | Bin 0 -> 1720 bytes
+ .../cmap14_font1.drop-hints-retain-gids.4E02.otf   | Bin 0 -> 1028 bytes
+ .../cmap14_font1.drop-hints-retain-gids.4E03.otf   | Bin 0 -> 1124 bytes
+ ....drop-hints-retain-gids.4E05,4E07,4E08,4E09.otf | Bin 0 -> 1984 bytes
+ ...ap14_font1.drop-hints-retain-gids.4E08,4E09.otf | Bin 0 -> 1872 bytes
+ .../cmap14_font1.drop-hints-retain-gids.4E08.otf   | Bin 0 -> 1544 bytes
+ ...drop-hints-retain-gids.retain-all-codepoint.otf | Bin 0 -> 2436 bytes
+ .../cmap14_font1.drop-hints.4E00,4E02,4E03.otf     | Bin 0 -> 1292 bytes
+ .../cmap14/cmap14_font1.drop-hints.4E00,4E03.otf   | Bin 0 -> 1168 bytes
+ .../cmap14_font1.drop-hints.4E00,4E05,4E07.otf     | Bin 0 -> 1260 bytes
+ .../cmap14_font1.drop-hints.4E02,4E03,4E08.otf     | Bin 0 -> 1512 bytes
+ .../cmap14/cmap14_font1.drop-hints.4E02.otf        | Bin 0 -> 928 bytes
+ .../cmap14/cmap14_font1.drop-hints.4E03.otf        | Bin 0 -> 1012 bytes
+ ...cmap14_font1.drop-hints.4E05,4E07,4E08,4E09.otf | Bin 0 -> 1780 bytes
+ .../cmap14/cmap14_font1.drop-hints.4E08,4E09.otf   | Bin 0 -> 1652 bytes
+ .../cmap14/cmap14_font1.drop-hints.4E08.otf        | Bin 0 -> 1316 bytes
+ ...map14_font1.drop-hints.retain-all-codepoint.otf | Bin 0 -> 2280 bytes
+ .../cmap14_font1.name-ids.4E00,4E02,4E03.otf       | Bin 0 -> 1292 bytes
+ .../cmap14/cmap14_font1.name-ids.4E00,4E03.otf     | Bin 0 -> 1168 bytes
+ .../cmap14_font1.name-ids.4E00,4E05,4E07.otf       | Bin 0 -> 1260 bytes
+ .../cmap14_font1.name-ids.4E02,4E03,4E08.otf       | Bin 0 -> 1508 bytes
+ .../expected/cmap14/cmap14_font1.name-ids.4E02.otf | Bin 0 -> 928 bytes
+ .../expected/cmap14/cmap14_font1.name-ids.4E03.otf | Bin 0 -> 1012 bytes
+ .../cmap14_font1.name-ids.4E05,4E07,4E08,4E09.otf  | Bin 0 -> 1780 bytes
+ .../cmap14/cmap14_font1.name-ids.4E08,4E09.otf     | Bin 0 -> 1652 bytes
+ .../expected/cmap14/cmap14_font1.name-ids.4E08.otf | Bin 0 -> 1316 bytes
+ .../cmap14_font1.name-ids.retain-all-codepoint.otf | Bin 0 -> 2280 bytes
+ .../cmap14_font1.retain-gids.4E00,4E02,4E03.otf    | Bin 0 -> 1452 bytes
+ .../cmap14/cmap14_font1.retain-gids.4E00,4E03.otf  | Bin 0 -> 1340 bytes
+ .../cmap14_font1.retain-gids.4E00,4E05,4E07.otf    | Bin 0 -> 1464 bytes
+ .../cmap14_font1.retain-gids.4E02,4E03,4E08.otf    | Bin 0 -> 1788 bytes
+ .../cmap14/cmap14_font1.retain-gids.4E02.otf       | Bin 0 -> 1096 bytes
+ .../cmap14/cmap14_font1.retain-gids.4E03.otf       | Bin 0 -> 1192 bytes
+ ...map14_font1.retain-gids.4E05,4E07,4E08,4E09.otf | Bin 0 -> 2048 bytes
+ .../cmap14/cmap14_font1.retain-gids.4E08,4E09.otf  | Bin 0 -> 1940 bytes
+ .../cmap14/cmap14_font1.retain-gids.4E08.otf       | Bin 0 -> 1608 bytes
+ ...ap14_font1.retain-gids.retain-all-codepoint.otf | Bin 0 -> 2500 bytes
+ test/subset/data/fonts/cmap14_font1.otf            | Bin 0 -> 4484 bytes
+ test/subset/data/tests/cmap14.tests                |  21 +++++++++++++++++++++
+ 54 files changed, 23 insertions(+)
+
+commit 2583afa0eb90134274ddd92864ea5270eeebc52e
+Author: Qunxin Liu <qxliu@google.com>
+Date:   Fri Aug 16 13:54:24 2019 -0700
+
+    [subset] subsetting cmap14
+
+ src/hb-ot-cmap-table.hh | 295 +++++++++++++++++++++++++++++++++++++++++++-----
+ 1 file changed, 265 insertions(+), 30 deletions(-)
+
+commit 078ddbd0f6ad660e740809b7f4c067e02309b98d
+Author: Qunxin Liu <qxliu@google.com>
+Date:   Wed Aug 7 13:17:26 2019 -0700
+
+    [subset] glyph closure for CMAP14
+
+ src/hb-ot-cmap-table.hh | 34 +++++++++++++++++++++++++++++++++-
+ src/hb-subset-plan.cc   | 10 ++++++++++
+ 2 files changed, 43 insertions(+), 1 deletion(-)
+
+commit bbe878006d347893fc70e282c2aaafef5dd622b4
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Wed Sep 18 22:22:01 2019 +0430
+
+    Avoid bitwise negate of enum value
+    
+    Fixes this -fno-sanitize-recover=undefined fail,
+    
+    hb-ot-map.hh:188:1: runtime error: load of value 4294967294, which is not a valid value for type 'hb_ot_map_feature_flags_t'
+        #0 0x7f62bfa9b227 in operator&=(hb_ot_map_feature_flags_t&, hb_ot_map_feature_flags_t) /home/ebrahim/Desktop/harfbuzz/src/./hb-ot-map.hh:188:1
+        #1 0x7f62bfa9b227 in hb_ot_map_builder_t::compile(hb_ot_map_t&, hb_ot_shape_plan_key_t const&) /home/ebrahim/Desktop/harfbuzz/src/hb-ot-map.cc:194
+        #2 0x7f62bface650 in hb_ot_shape_planner_t::compile(hb_ot_shape_plan_t&, hb_ot_shape_plan_key_t const&) /home/ebrahim/Desktop/harfbuzz/src/hb-ot-shape.cc:108:7
+        #3 0x7f62bfacec1e in hb_ot_shape_plan_t::init0(hb_face_t*, hb_shape_plan_key_t const*) /home/ebrahim/Desktop/harfbuzz/src/hb-ot-shape.cc:225:11
+        #4 0x7f62bfae1318 in hb_shape_plan_create2 /home/ebrahim/Desktop/harfbuzz/src/hb-shape-plan.cc:232:7
+        #5 0x7f62bfae1d2a in hb_shape_plan_create_cached2 /home/ebrahim/Desktop/harfbuzz/src/hb-shape-plan.cc:489:33
+        #6 0x7f62bfae2527 in hb_shape_full /home/ebrahim/Desktop/harfbuzz/src/hb-shape.cc:135:33
+        #7 0x55ed360b6588 in shape_options_t::shape(hb_font_t*, hb_buffer_t*, char const**) /home/ebrahim/Desktop/harfbuzz/util/./options.hh:242:10
+        #8 0x55ed360b5d9c in shape_consumer_t<output_buffer_t>::consume_line(char const*, unsigned int, char const*, char const*) /home/ebrahim/Desktop/harfbuzz/util/./shape-consumer.hh:67:19
+        #9 0x55ed360b549f in main_font_text_t<shape_consumer_t<output_buffer_t>, 2147483647, 0>::main(int, char**) /home/ebrahim/Desktop/harfbuzz/util/./main-font-text.hh:81:16
+        #10 0x55ed360b4e23 in main /home/ebrahim/Desktop/harfbuzz/util/hb-shape.cc:189:17
+        #11 0x7f62bf104ee2 in __libc_start_main (/usr/lib/libc.so.6+0x26ee2)
+        #12 0x55ed3608f7ad in _start (/home/ebrahim/Desktop/harfbuzz/util/.libs/lt-hb-shape+0xd7ad)
+
+ src/hb-ot-map.cc | 3 ++-
+ 1 file changed, 2 insertions(+), 1 deletion(-)
+
+commit e6909ee58d0f7b954f3bb227c2f90ca4cfd0c858
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Wed Sep 18 22:12:25 2019 +0430
+
+    minor
+
+ src/hb-buffer.cc | 2 +-
+ src/hb-common.cc | 2 +-
+ 2 files changed, 2 insertions(+), 2 deletions(-)
+
+commit bb41b74fd1fb42b08e9069c22ee046daeee98e6b
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Wed Sep 18 00:55:24 2019 +0430
+
+    Don't rely on undefined left shift of negative value behavior
+    
+    Fixes this -fno-sanitize-recover=undefined check,
+    
+    hb-ft.cc:869:27: runtime error: left shift of negative value -16384
+        #0 0x7ff8f47da843 in hb_ft_font_set_funcs /home/ebrahim/Desktop/harfbuzz/src/hb-ft.cc:869:27
+        #1 0x55f20a66c7d6 in font_options_t::get_font() const /home/ebrahim/Desktop/harfbuzz/util/options.cc:731:3
+        #2 0x55f20a668c1f in shape_consumer_t<output_buffer_t>::init(hb_buffer_t*, font_options_t const*) /home/ebrahim/Desktop/harfbuzz/util/./shape-consumer.hh:47:42
+        #3 0x55f20a668441 in main_font_text_t<shape_consumer_t<output_buffer_t>, 2147483647, 0>::main(int, char**) /home/ebrahim/Desktop/harfbuzz/util/./main-font-text.hh:75:14
+        #4 0x55f20a667f91 in main /home/ebrahim/Desktop/harfbuzz/util/hb-shape.cc:180:21
+        #5 0x7ff8f3df7ee2 in __libc_start_main (/usr/lib/libc.so.6+0x26ee2)
+        #6 0x55f20a6427ad in _start (/home/ebrahim/Desktop/harfbuzz/util/.libs/lt-hb-shape+0xd7ad)
+
+ src/hb-ft.cc | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+commit b73313ade75130bf86ad1efbd312ce4106166089
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Wed Sep 18 00:50:32 2019 +0430
+
+    Don't seek of out-of-bound value even if the result is not used
+    
+    Fixes this -fno-sanitize-recover=undefined fail,
+    
+    /set/iter: hb-algs.hh:1016:60: runtime error: index 4294967295 out of bounds for type 'unsigned long long const[8]'
+        #0 0x4d1e09 in hb_vector_size_t<unsigned long long, 64u>::operator[](unsigned int) const /home/user/code/harfbuzz/src/./hb-algs.hh:1016:60
+        #1 0x4d8b5f in hb_set_t::page_t::previous(unsigned int*) const /home/user/code/harfbuzz/src/./hb-set.hh:139:53
+        #2 0x4d0ada in hb_set_t::previous(unsigned int*) const /home/user/code/harfbuzz/src/./hb-set.hh:602:36
+        #3 0x4cd76f in hb_set_previous /home/user/code/harfbuzz/src/hb-set.cc:494:15
+        #4 0x4ca8af in test_set_iter /home/user/code/harfbuzz/test/api/test-set.c:310:3
+        #5 0x7f3a4f3e0f49  (/usr/lib/x86_64-linux-gnu/libglib-2.0.so.0+0x72f49)
+        #6 0x7f3a4f3e0e7a  (/usr/lib/x86_64-linux-gnu/libglib-2.0.so.0+0x72e7a)
+        #7 0x7f3a4f3e1121 in g_test_run_suite (/usr/lib/x86_64-linux-gnu/libglib-2.0.so.0+0x73121)
+        #8 0x7f3a4f3e1140 in g_test_run (/usr/lib/x86_64-linux-gnu/libglib-2.0.so.0+0x73140)
+        #9 0x4c8894 in hb_test_run /home/user/code/harfbuzz/test/api/./hb-test.h:88:10
+        #10 0x4c8894 in main /home/user/code/harfbuzz/test/api/test-set.c:408:10
+        #11 0x7f3a4e3d2b96 in __libc_start_main /build/glibc-OTsEL5/glibc-2.27/csu/../csu/libc-start.c:310
+        #12 0x41e7d9 in _start (/home/user/code/harfbuzz/test/api/test-set+0x41e7d9)
+
+ src/hb-set.hh | 7 ++++++-
+ 1 file changed, 6 insertions(+), 1 deletion(-)
+
+commit d8af9ee017ed1018343d30272f55b90dd03a3559
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Wed Sep 18 00:47:55 2019 +0430
+
+    Don't rely on nullptr deref recovery
+    
+    Fixes this -fno-sanitize-recover=undefined fail,
+    
+    /types/language: hb-common.cc:385:20: runtime error: member access within null pointer of type 'const struct hb_language_impl_t'
+        #0 0x4caa34 in hb_language_to_string /home/user/code/harfbuzz/src/hb-common.cc:385:20
+        #1 0x4c9be8 in test_types_language /home/user/code/harfbuzz/test/api/test-common.c:205:3
+        #2 0x7f9557e72f49  (/usr/lib/x86_64-linux-gnu/libglib-2.0.so.0+0x72f49)
+        #3 0x7f9557e72e7a  (/usr/lib/x86_64-linux-gnu/libglib-2.0.so.0+0x72e7a)
+        #4 0x7f9557e73121 in g_test_run_suite (/usr/lib/x86_64-linux-gnu/libglib-2.0.so.0+0x73121)
+        #5 0x7f9557e73140 in g_test_run (/usr/lib/x86_64-linux-gnu/libglib-2.0.so.0+0x73140)
+        #6 0x4c88a3 in hb_test_run /home/user/code/harfbuzz/test/api/./hb-test.h:88:10
+        #7 0x4c88a3 in main /home/user/code/harfbuzz/test/api/test-common.c:224:10
+        #8 0x7f9556e64b96 in __libc_start_main /build/glibc-OTsEL5/glibc-2.27/csu/../csu/libc-start.c:310
+        #9 0x41e7d9 in _start (/home/user/code/harfbuzz/test/api/test-common+0x41e7d9)
+
+ src/hb-common.cc | 3 ++-
+ 1 file changed, 2 insertions(+), 1 deletion(-)
+
+commit bfb155a5f19b26f9dcff667a76a24cd5c3b83234
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Wed Sep 18 00:44:52 2019 +0430
+
+    Don't call memset when length is zero
+    
+    Fixes this -fno-sanitize-recover=undefined check,
+    
+    /buffer/positions/empty: hb-buffer.cc:327:11: runtime error: null pointer passed as argument 1, which is declared to never be null
+    
+    /usr/include/string.h:60:62: note: nonnull attribute specified here
+        #0 0x4cf31c in hb_buffer_t::clear_positions() /home/user/code/harfbuzz/src/hb-buffer.cc:327:3
+        #1 0x4d4dd4 in hb_buffer_get_glyph_positions /home/user/code/harfbuzz/src/hb-buffer.cc:1418:13
+        #2 0x4cb553 in test_buffer_positions /home/user/code/harfbuzz/test/api/test-buffer.c:305:3
+        #3 0x7f324187bf49  (/usr/lib/x86_64-linux-gnu/libglib-2.0.so.0+0x72f49)
+        #4 0x7f324187be7a  (/usr/lib/x86_64-linux-gnu/libglib-2.0.so.0+0x72e7a)
+        #5 0x7f324187be7a  (/usr/lib/x86_64-linux-gnu/libglib-2.0.so.0+0x72e7a)
+        #6 0x7f324187c121 in g_test_run_suite (/usr/lib/x86_64-linux-gnu/libglib-2.0.so.0+0x73121)
+        #7 0x7f324187c140 in g_test_run (/usr/lib/x86_64-linux-gnu/libglib-2.0.so.0+0x73140)
+        #8 0x4c8bd3 in hb_test_run /home/user/code/harfbuzz/test/api/./hb-test.h:88:10
+        #9 0x4c8bd3 in main /home/user/code/harfbuzz/test/api/test-buffer.c:884:10
+        #10 0x7f324086db96 in __libc_start_main /build/glibc-OTsEL5/glibc-2.27/csu/../csu/libc-start.c:310
+        #11 0x41e919 in _start (/home/user/code/harfbuzz/test/api/test-buffer+0x41e919)
+
+ src/hb-buffer.cc | 3 ++-
+ 1 file changed, 2 insertions(+), 1 deletion(-)
+
+commit 5a1cc199ab7b619935af04584ecc650216a83d66
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Wed Sep 18 00:43:44 2019 +0430
+
+    [ci] Run -fno-sanitize-recover=undefined checks
+
+ .circleci/config.yml | 4 ++--
+ 1 file changed, 2 insertions(+), 2 deletions(-)
+
+commit c930ae2bd8b6f626ddec0628ae6b38e3134e3c97
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Mon Sep 16 14:04:34 2019 +0430
+
+    Avoid stdint.h in Kernel module compiles
+
+ src/hb-common.h | 2 ++
+ 1 file changed, 2 insertions(+)
+
+commit 412d6cac3a46d710159ed4b3cc3bb59fd5876d5f
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Mon Sep 16 13:50:11 2019 +0430
+
+    Extract an avoid errno compile flag
+
+ src/hb-blob.cc   | 1 -
+ src/hb-config.hh | 1 +
+ src/hb.hh        | 9 +++++++--
+ 3 files changed, 8 insertions(+), 3 deletions(-)
+
+commit 8a16d6f1c13388e6d9ca844a309632ec583ee1a2
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Sun Sep 15 20:43:33 2019 +0430
+
+    [doc] fix minor typo
+
+ src/hb-ot-layout.cc | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+commit aab279b33dda45ae0e45c887f2fad6381b5138dc
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Sat Sep 14 11:20:09 2019 +0430
+
+    [ci] Install cmake on macOS cmake/amalgam tester
+
+ .circleci/config.yml | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+commit f3214df6f63919ebe73c713b1e80bba1097a0cea
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Sat Sep 14 10:56:00 2019 +0430
+
+    [coretext] Fix double promotion warnings by making casts explicit
+
+ src/hb-coretext.cc | 4 ++--
+ 1 file changed, 2 insertions(+), 2 deletions(-)
+
+commit cbbb6fa45519a8670870c784841d7b9e1ab71dd1
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Sat Sep 14 10:53:12 2019 +0430
+
+    [ci] Don't build cmake tests in macOS bot
+
+ .circleci/config.yml | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+commit 6e4736a3c5acc0eea1b16c79b95d1a3082baa320
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Sat Sep 14 10:38:52 2019 +0430
+
+    [name] Undef entry_{index,score} to avoid collision in amalgam builds
+
+ src/hb-ot-name-table.hh | 3 +++
+ 1 file changed, 3 insertions(+)
+
+commit d512087e4dfb5d9483b78eaf8443b4fa8724b8e1
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Sat Sep 14 10:36:29 2019 +0430
+
+    Rename GlyphID to HBGlyphID
+    
+    Avoid collision with macOS's ATSUnicodeTypes.h GlyphID
+
+ src/hb-aat-layout-bsln-table.hh            |  4 +-
+ src/hb-aat-layout-common.hh                | 16 +++----
+ src/hb-aat-layout-just-table.hh            |  8 ++--
+ src/hb-aat-layout-kerx-table.hh            |  4 +-
+ src/hb-aat-layout-morx-table.hh            | 32 ++++++-------
+ src/hb-open-type.hh                        |  4 +-
+ src/hb-ot-cmap-table.hh                    |  4 +-
+ src/hb-ot-color-cbdt-table.hh              |  8 ++--
+ src/hb-ot-color-colr-table.hh              |  4 +-
+ src/hb-ot-glyf-table.hh                    |  2 +-
+ src/hb-ot-layout-base-table.hh             |  2 +-
+ src/hb-ot-layout-common.hh                 | 22 ++++-----
+ src/hb-ot-layout-gpos-table.hh             |  2 +-
+ src/hb-ot-layout-gsub-table.hh             | 72 +++++++++++++++---------------
+ src/hb-ot-layout-jstf-table.hh             |  2 +-
+ src/hb-ot-math-table.hh                    |  4 +-
+ src/hb-ot-shape-complex-arabic-fallback.hh | 14 +++---
+ src/hb-ot-vorg-table.hh                    |  2 +-
+ 18 files changed, 103 insertions(+), 103 deletions(-)
+
+commit bf08611044d83b6f5d6dec443f5216db259b4085
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Sat Sep 14 10:35:08 2019 +0430
+
+    [ci] Update and compile cmake/amalgam on macOS bot
+
+ .circleci/config.yml | 7 ++++---
+ 1 file changed, 4 insertions(+), 3 deletions(-)
+
+commit 229ef1d29d5c7a370ebb10a1131c04719f34dc81
+Author: Behdad Esfahbod <behdad@behdad.org>
+Date:   Tue Sep 10 10:31:07 2019 -0700
+
+    Rename Fixed to HBFixed
+    
+    Fixes(!!) https://github.com/harfbuzz/harfbuzz/issues/1966
+
+ src/hb-aat-fdsc-table.hh        |  4 ++--
+ src/hb-aat-layout-just-table.hh | 20 ++++++++++----------
+ src/hb-aat-layout-trak-table.hh |  8 ++++----
+ src/hb-open-type.hh             |  4 ++--
+ src/hb-ot-post-table.hh         |  2 +-
+ src/hb-ot-stat-table.hh         | 14 +++++++-------
+ src/hb-ot-var-fvar-table.hh     | 16 ++++++++--------
+ 7 files changed, 34 insertions(+), 34 deletions(-)
+
+commit 170b5dd856b1ba8f26e79863fe0c64a52eb68951
+Author: Behdad Esfahbod <behdad@behdad.org>
+Date:   Sun Sep 8 16:34:11 2019 -0400
+
+    [aat] Minor
+
+ src/hb-aat-layout-morx-table.hh | 14 +++++---------
+ 1 file changed, 5 insertions(+), 9 deletions(-)
+
+commit a0695687eb03bcf80c4dec19917127cdd8d8797d
+Author: Behdad Esfahbod <behdad@behdad.org>
+Date:   Sun Sep 8 16:32:12 2019 -0400
+
+    [aat] Minor
+
+ src/hb-aat-layout-morx-table.hh | 2 --
+ 1 file changed, 2 deletions(-)
+
+commit 4905a2198b4c47c12c6356f72ae0d2b178630d25
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Mon Sep 9 12:36:12 2019 +0430
+
+    [number] Add static to hb-number-parser.hh functions
+
+ src/hb-number-parser.hh | 4 ++--
+ src/hb-number-parser.rl | 4 ++--
+ 2 files changed, 4 insertions(+), 4 deletions(-)
+
+commit 30e5cdfbf1ce2aadadf29ccfd0733355ced2d065
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Mon Sep 9 00:28:16 2019 +0430
+
+    [number] Optimize _pow10 constants (#1963)
+
+ src/hb-number-parser.hh | 43 +++++++++++++++++++------------------------
+ src/hb-number-parser.rl | 31 +++++++++++++------------------
+ 2 files changed, 32 insertions(+), 42 deletions(-)
+
+commit 3f2cdf07a417f81aeeb1e296db493b6e02d76ba8
+Author: Behdad Esfahbod <behdad@behdad.org>
+Date:   Sun Sep 8 15:08:02 2019 -0400
+
+    Change HB_VAR_ARRAY to 1 again
+    
+    To fix MSVC bots, while I work on changing this to 0 permanently.
+
+ src/hb.hh | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+commit 39cf8e21be2bf69717cf60a339b3ad26c6f7985b
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Sat Sep 7 15:27:30 2019 +0430
+
+    [number] Add overflow checks used to be done in parse_bcd
+    
+    Which were removed in 1083df8
+
+ src/hb-number-parser.hh | 60 +++++++++++++++++++++++++++++++++----------------
+ src/hb-number-parser.rl | 38 ++++++++++++++++++++++++-------
+ 2 files changed, 71 insertions(+), 27 deletions(-)
+
+commit 47d82713a144e06e00a486b3aa7d3934d62d68fd
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Fri Sep 6 20:33:10 2019 +0430
+
+    Replace strtod with a ragel implementation
+    
+    Use a ragel based number parser when strtod_l couldn't be found
+    as libc's strtod may is locale sensetivity which we need to not.
+
+ src/Makefile.sources    |   2 +
+ src/hb-number-parser.hh | 223 ++++++++++++++++++++++++++++++++++++++++++++++++
+ src/hb-number-parser.rl | 122 ++++++++++++++++++++++++++
+ src/hb-number.cc        |   3 +-
+ src/test-number.cc      |  30 +++++++
+ 5 files changed, 379 insertions(+), 1 deletion(-)
+
+commit 80613e5b9ee31125f4390012719e6f39970118d3
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Sat Sep 7 14:25:54 2019 +0430
+
+    Minor, remove unused header
+
+ src/hb-common.cc | 3 ---
+ 1 file changed, 3 deletions(-)
+
+commit 5902198cee9b9939ae310f459f9f18f5f1b07424
+Author: Behdad Esfahbod <behdad@behdad.org>
+Date:   Fri Sep 6 21:36:31 2019 -0400
+
+    [kerx] Fix offset issue in kern format 2
+    
+    Fixes tests with HB_VAR_ARRAY != 1, as done in previous commit.
+
+ src/hb-aat-layout-common.hh     | 2 +-
+ src/hb-aat-layout-kerx-table.hh | 2 +-
+ 2 files changed, 2 insertions(+), 2 deletions(-)
+
+commit 861547d5315be4cb22f3a1e7cd59696d8657ca49
+Author: Behdad Esfahbod <behdad@behdad.org>
+Date:   Fri Sep 6 16:55:00 2019 -0400
+
+    Change HB_VAR_ARRAY from 1 to 0
+    
+    Going to see which compilers it breaks and special-case those...
+
+ src/hb.hh | 4 +++-
+ 1 file changed, 3 insertions(+), 1 deletion(-)
+
+commit 0e294c455e7f2e50172f65463ab016f1372d4c59
+Author: Behdad Esfahbod <behdad@behdad.org>
+Date:   Fri Sep 6 16:54:27 2019 -0400
+
+    Rename VAR to HB_VAR_ARRAY
+
+ src/hb-machinery.hh        | 2 +-
+ src/hb-open-type.hh        | 8 ++++----
+ src/hb-ot-cff-common.hh    | 6 +++---
+ src/hb-ot-cff1-table.hh    | 4 ++--
+ src/hb-ot-layout-common.hh | 2 +-
+ src/hb-ot-maxp-table.hh    | 2 +-
+ src/hb-string-array.hh     | 2 +-
+ src/hb.hh                  | 2 +-
+ 8 files changed, 14 insertions(+), 14 deletions(-)
+
+commit c379faed2bcca1cc1a81b0de132fc3c4f7f7a080
+Author: Behdad Esfahbod <behdad@behdad.org>
+Date:   Fri Sep 6 16:41:12 2019 -0400
+
+    Fix a few struct size declarations
+    
+    Was wrong.  As excercised by defining VAR to other than 1 in hb.hh.
+
+ src/hb-aat-layout-feat-table.hh | 2 +-
+ src/hb-ot-cff-common.hh         | 2 +-
+ src/hb-ot-color-sbix-table.hh   | 2 +-
+ src/hb-ot-layout-common.hh      | 2 +-
+ 4 files changed, 4 insertions(+), 4 deletions(-)
+
+commit 7d4da8b86242d5a541e501937ddf321716b43f07
+Author: Evgeniy Reizner <razrfalcon@gmail.com>
+Date:   Fri Sep 6 19:24:32 2019 +0300
+
+    Remove duplicated tests from test-ot-tag (#1958)
+
+ test/api/test-ot-tag.c | 3 ---
+ 1 file changed, 3 deletions(-)
+
+commit 3aceee2527ad921e0d589e42a1fe451e0fc67ee0
+Author: Behdad Esfahbod <behdad@behdad.org>
+Date:   Fri Sep 6 12:17:18 2019 -0400
+
+    Revert "[null] Silence undefined-behavior complaints with too-small null bytes"
+    
+    This reverts commit 911c76abcdfe89770b252eb0d4eb621c0db00ad5.
+    
+    Broke tests.  I'm not sure I understand why.  At any rate, this was a
+    bad way to fix.  I'll look into understanding as well as better fix.
+
+ src/hb-null.hh | 6 ------
+ 1 file changed, 6 deletions(-)
+
+commit 911c76abcdfe89770b252eb0d4eb621c0db00ad5
+Author: Behdad Esfahbod <behdad@behdad.org>
+Date:   Fri Sep 6 11:53:11 2019 -0400
+
+    [null] Silence undefined-behavior complaints with too-small null bytes
+    
+    Fixes https://bugzilla.mozilla.org/show_bug.cgi?id=1577584
+
+ src/hb-null.hh | 6 ++++++
+ 1 file changed, 6 insertions(+)
+
+commit 3c81246f66585edd8ee4515d226b133c290e9d7c
+Author: Behdad Esfahbod <behdad@behdad.org>
+Date:   Sun Sep 1 19:25:50 2019 -0500
+
+    [subset] Use newer iter tools in SinglePosFormat1
+
+ src/hb-ot-layout-gpos-table.hh | 8 ++------
+ 1 file changed, 2 insertions(+), 6 deletions(-)
+
+commit 9510e918f72d2496f5e2ec84c58e79af944c8a0b
+Author: Behdad Esfahbod <behdad@behdad.org>
+Date:   Sun Sep 1 16:25:33 2019 -0500
+
+    [iter] Partialize hb_zip()
+
+ src/hb-iter.hh | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+commit 52d19ba4591e822708e52a8fc96d9821fe2668f4
+Author: Behdad Esfahbod <behdad@behdad.org>
+Date:   Sun Sep 1 19:42:08 2019 -0500
+
+    Minor
+
+ test/subset/Makefile.am | 3 ++-
+ 1 file changed, 2 insertions(+), 1 deletion(-)
+
+commit cad698568a36ea6c929b4c888bd5e8aafe8d39e3
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Wed Sep 4 10:59:19 2019 +0430
+
+    Use roundf to fix cast to int difference of msys2 w64
+
+ src/test-number.cc | 14 +++++++-------
+ 1 file changed, 7 insertions(+), 7 deletions(-)
+
+commit 88c73359da3f7078d02f27087790c7109ab4d248
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Wed Sep 4 11:16:18 2019 +0430
+
+    Check roundf availibity in autotools
+    
+    Hmm, not sure how I missed it.
+
+ configure.ac | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+commit 1083df8b80b08aa1a4f2dabfe414aaa4a0ec8aa1
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Wed Sep 4 01:22:21 2019 +0430
+
+    Use hb_parse_double in CFF::dict_opset_t::parse_bcd
+
+ src/Makefile.sources             |   2 +
+ src/hb-cff-interp-dict-common.hh | 136 +++++++++------------------------------
+ 2 files changed, 31 insertions(+), 107 deletions(-)
+
+commit 57f88e11d4c48f40a2e56625a54bdfed4aae601a
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Wed Sep 4 01:20:50 2019 +0430
+
+    [number] Turn hb_parse_float into hb_parse_double
+
+ src/hb-common.cc   |  6 +++++-
+ src/hb-number.cc   | 16 ++++++++--------
+ src/hb-number.hh   |  4 ++--
+ src/test-number.cc | 44 ++++++++++++++++++++++----------------------
+ 4 files changed, 37 insertions(+), 33 deletions(-)
+
+commit 65690b5a4bf1186a072e8e918c5e01464f918d46
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Tue Sep 3 23:09:47 2019 +0430
+
+    [number] Add whole buffer check and test it
+
+ src/hb-algs.hh             |  6 ++----
+ src/hb-buffer-serialize.cc | 12 ++++--------
+ src/hb-number.cc           | 39 ++++++++++++++++++++++++---------------
+ src/hb-number.hh           |  9 ++++++---
+ src/test-number.cc         | 19 ++++++++++++++++---
+ 5 files changed, 52 insertions(+), 33 deletions(-)
+
+commit 3661eb6105a33a763736d8dc4a2cd95c01aa4332
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Tue Sep 3 19:43:14 2019 +0430
+
+    Don't check null terminaion of source in hb_codepoint_parse
+    
+    This isn't what intended originally, just checking if consumed
+    all the buffer is enough.
+
+ src/hb-algs.hh     |  4 ++--
+ src/test-number.cc | 32 +++++++++++++++++++++++++++++++-
+ 2 files changed, 33 insertions(+), 3 deletions(-)
+
+commit 3a162727501ad0c56d5d6561cace115d858eacb7
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Tue Sep 3 17:19:33 2019 +0430
+
+    [test] resolve msvc complain on signedness comparing
+
+ src/test-number.cc | 14 +++++++-------
+ 1 file changed, 7 insertions(+), 7 deletions(-)
+
+commit 005389beb5a28e2a94b40d0bb8229e9598b84b1d
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Tue Sep 3 17:00:46 2019 +0430
+
+    Use hb_parse_uint in deserializer token parser
+
+ src/hb-buffer-serialize.cc | 9 ++++++---
+ 1 file changed, 6 insertions(+), 3 deletions(-)
+
+commit 3d5b1df7ab689871db37ec9a2f5b1ff1665fdb20
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Tue Sep 3 16:58:16 2019 +0430
+
+    [number] Add test
+
+ src/Makefile.am    |   6 +-
+ src/test-number.cc | 180 +++++++++++++++++++++++++++++++++++++++++++++++++++++
+ 2 files changed, 185 insertions(+), 1 deletion(-)
+
+commit b5e6805ee777347ae13ba0133ca0d64252ef9d55
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Tue Sep 3 15:23:40 2019 +0430
+
+    [number] Minor tweak on parser related codes
+
+ src/hb-algs.hh             |  6 +++---
+ src/hb-buffer-serialize.cc |  6 ++----
+ src/hb-common.cc           | 14 ++++++--------
+ src/hb-number.cc           |  6 ++----
+ 4 files changed, 13 insertions(+), 19 deletions(-)
+
+commit e2cecf1f34fe1cc62fd8260172f9bd694a17fac5
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Tue Sep 3 15:14:21 2019 +0430
+
+    [number] Remove parsing code duplication of the calls using lambda
+
+ src/hb-number.cc | 57 +++++++++++++++++++-------------------------------------
+ 1 file changed, 19 insertions(+), 38 deletions(-)
+
+commit a77bb7eb41d34b19a672bb4ede038cc1b19a3945
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Tue Sep 3 14:49:14 2019 +0430
+
+    Move hb_codepoint_parse to hb_parse_uint
+
+ src/hb-algs.hh             | 20 +++++++++-----------
+ src/hb-buffer-serialize.cc |  1 -
+ src/hb-common.cc           |  1 -
+ src/hb-number.cc           | 26 +++++++++++++++++++++++---
+ src/hb-number.hh           |  3 +++
+ src/hb.hh                  |  3 ++-
+ 6 files changed, 37 insertions(+), 17 deletions(-)
+
+commit 43372fbb5afe31ea1e66d450f29de718b6190828
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Tue Sep 3 01:02:40 2019 +0430
+
+    Merge and aggregate number parsing logics to form hb-number
+
+ src/Makefile.sources       |   2 +
+ src/harfbuzz.cc            |   1 +
+ src/hb-buffer-serialize.cc |  41 +++++---------
+ src/hb-common.cc           | 121 +++------------------------------------
+ src/hb-number.cc           | 138 +++++++++++++++++++++++++++++++++++++++++++++
+ src/hb-number.hh           |  35 ++++++++++++
+ 6 files changed, 197 insertions(+), 141 deletions(-)
+
+commit d50d2fcbc7233f0473493e17ab3fb243d8d30edd
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Tue Sep 3 05:02:06 2019 +0430
+
+    Fallback if roundf didn't exist, like in dietlibc (#1953)
+
+ CMakeLists.txt | 2 +-
+ src/hb.hh      | 9 +++++++++
+ 2 files changed, 10 insertions(+), 1 deletion(-)
+
+commit d3b984d3790d61931d4427ad7c0ae6547f8f1076
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Mon Sep 2 18:18:25 2019 +0430
+
+    Revert in-house pow10 (d80a3ea) and fix oss-fuzz/16922
+    
+    Probably can be fixed but merging it was wrong so let's revert.
+
+ src/hb-cff-interp-dict-common.hh                   |  37 ++-------------------
+ ...ase-minimized-hb-subset-fuzzer-5728664968232960 | Bin 0 -> 28 bytes
+ 2 files changed, 3 insertions(+), 34 deletions(-)
+
+commit 41d6e95b0d47c874b73b314cd147e6ea8ec5ddfb
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Mon Sep 2 01:41:48 2019 +0430
+
+    [subset] Use internal API of hb_set_t
+
+ src/hb-subset.cc | 7 +++----
+ 1 file changed, 3 insertions(+), 4 deletions(-)
+
+commit 8ccf328d548a51140e22fe61ba6fdae3f7194aa2
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Mon Sep 2 00:02:06 2019 +0430
+
+    [subset] Run once for a tag
+
+ src/hb-subset.cc | 5 ++++-
+ 1 file changed, 4 insertions(+), 1 deletion(-)
+
+commit 0954c8f7a003b4130cfdc1b3f29db8c57953a78f
+Author: Khaled Hosny <khaledhosny@eglug.org>
+Date:   Sun Sep 1 17:09:08 2019 +0200
+
+    [ft] Prefer symbol cmap subtable if found (#1948)
+    
+    Similar to commit d304d60e4d49df14ed85d6646680085f27bafbf2 for ot-font.
+
+ src/hb-ft.cc | 4 ++--
+ 1 file changed, 2 insertions(+), 2 deletions(-)
+
+commit 4375858792f3e3cc2fae72c3ae3327f52884f780
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Sun Sep 1 15:13:05 2019 +0430
+
+    [editorconfig] Treat Ragel files also as C sources
+
+ .editorconfig | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+commit d80a3ea983534e291aee273dba5b1c6e889dadfa
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Sun Sep 1 14:05:16 2019 +0430
+
+    [cff] Implement in-house power of 10
+    
+    A minimal power only for natural numbers exponents of ten, for portability.
+    
+    Found the idea in Tcl/Tk but wrote it myself after weeks and it turned out
+    being a different implementation, reverse direction, constexpr, etc.
+
+ src/hb-cff-interp-dict-common.hh | 37 ++++++++++++++++++++++++++++++++++---
+ 1 file changed, 34 insertions(+), 3 deletions(-)
+
+commit f441a7c00837fbe7843df6faedd5f6383c2258c3
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Sun Sep 1 02:18:09 2019 +0430
+
+    Don't allow reference blob be accessed using empty tag in hb_face_reference_table (#1947)
+
+ src/hb-face.cc   | 3 +++
+ src/hb-subset.cc | 5 -----
+ 2 files changed, 3 insertions(+), 5 deletions(-)
+
+commit c9eb913f4cf3d9d4a28059c7ecf7145ad3c49c65
+Author: Behdad Esfahbod <behdad@behdad.org>
+Date:   Sat Aug 31 15:21:02 2019 -0500
+
+    [iter] Simplify hb_chop()
+
+ src/hb-iter.hh | 4 ++--
+ 1 file changed, 2 insertions(+), 2 deletions(-)
+
+commit 67ec9fa9e48714f595ab17bb8a673b5ee7c73aa8
+Author: Behdad Esfahbod <behdad@behdad.org>
+Date:   Sat Aug 31 14:51:49 2019 -0500
+
+    [iter] Add hb_chop()
+
+ src/hb-iter.hh   | 14 ++++++++++++++
+ src/test-iter.cc |  2 +-
+ 2 files changed, 15 insertions(+), 1 deletion(-)
+
+commit 5828d8e83c023547f0add77b6413967056c2a13c
+Author: Behdad Esfahbod <behdad@behdad.org>
+Date:   Sat Aug 31 14:36:44 2019 -0500
+
+    [iter] Add hb_take() specialization for arrays
+
+ src/hb-iter.hh | 11 +++++++++++
+ 1 file changed, 11 insertions(+)
+
+commit 398b296f3b205daa8964de1a63957efeb59f6bdf
+Author: Behdad Esfahbod <behdad@behdad.org>
+Date:   Sat Aug 31 12:44:24 2019 -0500
+
+    [iter] Add hb_len()
+
+ src/hb-iter.hh   | 8 ++++++++
+ src/test-iter.cc | 2 +-
+ 2 files changed, 9 insertions(+), 1 deletion(-)
+
+commit 875131d47854c162c1d0a39a5c0f8f8d0c5f24e0
+Author: Behdad Esfahbod <behdad@behdad.org>
+Date:   Sat Aug 31 12:42:52 2019 -0500
+
+    [iter] Add hb_take()
+
+ src/hb-iter.hh   | 12 ++++++++++--
+ src/test-iter.cc |  1 +
+ 2 files changed, 11 insertions(+), 2 deletions(-)
+
+commit 1f88dae9f54d18cd740f149d020b2bb435dc9378
+Author: Behdad Esfahbod <behdad@behdad.org>
+Date:   Sat Aug 31 12:24:42 2019 -0500
+
+    [iter] Make iota() accept invokable for increasing to next item
+
+ src/hb-iter.hh   | 21 ++++++++++++++++-----
+ src/test-iter.cc |  1 +
+ 2 files changed, 17 insertions(+), 5 deletions(-)
+
+commit 3bc86fb237b668e738a78397be04c603e7cf083b
+Author: Behdad Esfahbod <behdad@behdad.org>
+Date:   Fri Aug 30 16:39:52 2019 -0500
+
+    [algs] Fix hb_inc/dec signature
+
+ src/hb-algs.hh   | 5 +++--
+ src/test-algs.cc | 4 ++++
+ 2 files changed, 7 insertions(+), 2 deletions(-)
+
+commit b1378d8a217a53e17562abebee22276e09528f8c
+Author: Behdad Esfahbod <behdad@behdad.org>
+Date:   Fri Aug 30 12:10:45 2019 -0500
+
+    [iter] Add hb_repeat()
+
+ src/hb-iter.hh   | 37 +++++++++++++++++++++++++++++++++----
+ src/test-iter.cc |  3 +++
+ 2 files changed, 36 insertions(+), 4 deletions(-)
+
+commit 966a18b92a8b95d8024ae67bc237eeffe5019711
+Author: Behdad Esfahbod <behdad@behdad.org>
+Date:   Fri Aug 30 12:07:17 2019 -0500
+
+    [iter] Remove some &&
+
+ src/hb-iter.hh | 4 ++--
+ 1 file changed, 2 insertions(+), 2 deletions(-)
+
+commit de45775c37873dd5818058dfe316cc0e98590334
+Author: Behdad Esfahbod <behdad@behdad.org>
+Date:   Fri Aug 30 12:02:46 2019 -0500
+
+    [iter] Use hb_ridentity instead of lazy +
+
+ src/hb-iter.hh | 4 ++--
+ 1 file changed, 2 insertions(+), 2 deletions(-)
+
+commit ce4d63beec08995aaa6b8b45f7986f074a73f295
+Author: Behdad Esfahbod <behdad@behdad.org>
+Date:   Fri Aug 30 11:59:50 2019 -0500
+
+    [iter] Separate hb_iota implementation from hb_range
+
+ src/hb-iter.hh | 29 +++++++++++++++++++++++++++--
+ 1 file changed, 27 insertions(+), 2 deletions(-)
+
+commit 814dc3cbe5a5e51b48cb962a6f7053797bbb8e0d
+Author: Behdad Esfahbod <behdad@behdad.org>
+Date:   Fri Aug 30 10:20:30 2019 -0500
+
+    [iter] Rename
+    
+    Moving towards making iota useful for non-integers.
+
+ src/hb-iter.hh | 35 ++++++++++++++++++-----------------
+ 1 file changed, 18 insertions(+), 17 deletions(-)
+
+commit 2d5643aed4a5a4bc3ea129d4af3dcbe7af7b9995
+Author: Behdad Esfahbod <behdad@behdad.org>
+Date:   Fri Aug 30 09:51:22 2019 -0500
+
+    [algs] Add hb_inc() and hb_dec())
+
+ src/hb-algs.hh | 12 ++++++++++++
+ 1 file changed, 12 insertions(+)
+
+commit 7eafe94705bb818aac71fbc142158a22da622d19
+Author: Behdad Esfahbod <behdad@behdad.org>
+Date:   Fri Aug 30 09:40:40 2019 -0500
+
+    Revert "[array] Add chop()"
+    
+    This reverts commit 545fe9d9f0870568c40c17591f3f224c228feba6.
+    
+    Breaks gcc 4.8 and MSVC all versions.
+    
+    Will add hb_chop() that works on all iterators instead.
+
+ src/hb-array.hh | 14 --------------
+ 1 file changed, 14 deletions(-)
+
+commit 28c8dcb53f0af0dd3f4e7909285e67865a10b67b
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Sat Aug 31 12:27:14 2019 +0430
+
+    [subset] minor
+
+ src/hb-subset.cc | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+commit 545fe9d9f0870568c40c17591f3f224c228feba6
+Author: Behdad Esfahbod <behdad@behdad.org>
+Date:   Thu Aug 29 15:48:21 2019 -0700
+
+    [array] Add chop()
+    
+    Takes n, and returns iterator of iterators that contain up to
+    n items each.  Basically cuts the array into subarrays of size n.
+    The last sub-array might contain fewer.
+    
+    Ideally this should become a generic iter tool, not array-specific,
+    so we can use it in GPOS to chop a value matrix into rows and elements.
+
+ src/hb-array.hh | 14 ++++++++++++++
+ 1 file changed, 14 insertions(+)
+
+commit c72589f13f24ca24a0613f7d9bc28b7fe1ef25c0
+Author: Behdad Esfahbod <behdad@behdad.org>
+Date:   Thu Aug 29 15:45:21 2019 -0700
+
+    [iter] Change item_size to get_item_size()
+    
+    By moving access to hb_static_size(Type) into a function instead of
+    a class-const, we can refer to iter types of incomplete types, which
+    come handy when a method of hb_array_t wants to return iterator
+    of hb_array_t.  That kind of stuff.   Next commit needs this to
+    build on clang...
+
+ src/hb-array.hh | 8 ++++----
+ src/hb-iter.hh  | 4 ++--
+ 2 files changed, 6 insertions(+), 6 deletions(-)
+
+commit d58e248df62457bdc8a5bab743e5de26c6fc57be
+Author: Behdad Esfahbod <behdad@behdad.org>
+Date:   Thu Aug 29 15:23:48 2019 -0700
+
+    [array] Add truncate() method
+
+ src/hb-array.hh | 4 ++++
+ 1 file changed, 4 insertions(+)
+
+commit a06edf1430ba73d24104fce5406f2bc787ce5f11
+Author: Behdad Esfahbod <behdad@behdad.org>
+Date:   Thu Aug 29 15:21:18 2019 -0700
+
+    [array] Use injected class name more
+
+ src/hb-array.hh | 24 ++++++++++++------------
+ 1 file changed, 12 insertions(+), 12 deletions(-)
+
+commit e0e0c8c10948212e97426e987b6f296dc4270c43
+Author: Behdad Esfahbod <behdad@behdad.org>
+Date:   Thu Aug 29 14:58:16 2019 -0700
+
+    Minor
+
+ src/hb-ot-layout-gpos-table.hh | 6 ++++--
+ 1 file changed, 4 insertions(+), 2 deletions(-)
+
+commit 0313ef86e32a217e14950d46a3c3b98362a53dee
+Author: qxliu76 <48925186+qxliu76@users.noreply.github.com>
+Date:   Thu Aug 29 14:09:05 2019 -0700
+
+    bug fix in optimizing coverage table format (#1942)
+    
+    We are comparing number of shorts, NOT number of bytes.
+
+ src/hb-ot-layout-common.hh | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+commit 38f95baf6b7a74547906e8e813c826ee8f8c272f
+Author: Behdad Esfahbod <behdad@behdad.org>
+Date:   Thu Aug 29 13:40:46 2019 -0700
+
+    [subset] in SingleSubst subsetting, check for substitute in glyphset
+    
+    That matches what fonttools does and allows for specifying exact
+    glyphset for subset.
+
+ src/hb-ot-layout-gsub-table.hh | 8 ++++++--
+ 1 file changed, 6 insertions(+), 2 deletions(-)
+
+commit 499029644f35be7feedca7edf4610b2594855f01
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Thu Aug 29 15:09:39 2019 +0430
+
+    [gsub] Fix clang's semicolon complains
+
+ src/hb-ot-layout-gsub-table.hh | 8 ++++----
+ 1 file changed, 4 insertions(+), 4 deletions(-)
+
+commit 28620310b8a86092074d5a1c40c87fdc9a91ba61
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Thu Aug 29 14:55:54 2019 +0430
+
+    [test] Avoid alloca use as clang complain
+    
+    Fixes https://circleci.com/gh/harfbuzz/harfbuzz/108171 complain
+
+ test/api/test-ot-color.c | 4 +++-
+ 1 file changed, 3 insertions(+), 1 deletion(-)
+
+commit 875985cd481f1609d10ad0472f1e77af075c93bc
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Thu Aug 29 14:51:22 2019 +0430
+
+    [subset] Don't allow malicious fonts to insert unlimited table headers
+    
+    Fixes https://crbug.com/oss-fuzz/16810
+
+ src/hb-subset.cc                                       |   5 +++++
+ ...estcase-minimized-hb-subset-fuzzer-5675720390475776 | Bin 0 -> 299037 bytes
+ 2 files changed, 5 insertions(+)
+
+commit dc9222b1dd197ba50f7b63eb97f3fe0891a7b7b5
+Author: Behdad Esfahbod <behdad@behdad.org>
+Date:   Wed Aug 28 15:38:46 2019 -0700
+
+    [subset] Implement AlternateSubst subsetting
+
+ src/hb-ot-layout-gsub-table.hh | 61 +++++++++++++++++++++++++++++++++++++-----
+ 1 file changed, 55 insertions(+), 6 deletions(-)
+
+commit 23681b6da4368895fc049beda5a79af58aad8d69
+Author: Behdad Esfahbod <behdad@behdad.org>
+Date:   Wed Aug 28 15:30:37 2019 -0700
+
+    Minor
+
+ src/hb-ot-layout-gsub-table.hh | 21 ++++++++-------------
+ 1 file changed, 8 insertions(+), 13 deletions(-)
+
+commit 33c8e2303c23e8dfacb79ac15d8a0e6c7f866c89
+Author: Behdad Esfahbod <behdad@behdad.org>
+Date:   Wed Aug 28 15:25:55 2019 -0700
+
+    [subset] Implement MultipleSubst subsetting
+
+ src/hb-ot-layout-gsub-table.hh | 50 ++++++++++++++++++++++++++++++++++++++++--
+ 1 file changed, 48 insertions(+), 2 deletions(-)
+
+commit 5c43a7ba7e4cac229593f9cbe1017d3c55b111ac
+Author: Behdad Esfahbod <behdad@behdad.org>
+Date:   Wed Aug 28 15:09:58 2019 -0700
+
+    [GSUB] Use dagger in Ligature::intersects()
+
+ src/hb-ot-layout-gsub-table.hh | 8 +-------
+ 1 file changed, 1 insertion(+), 7 deletions(-)
+
+commit b8c642c1f597fb28ef323ac3cd78541eb462a2f7
+Author: Behdad Esfahbod <behdad@behdad.org>
+Date:   Wed Aug 28 15:06:45 2019 -0700
+
+    Minor
+
+ src/hb-ot-layout-gsub-table.hh | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+commit dc2c9aa0c398ac068e1385fffe1fb2b28c80d099
+Author: Behdad Esfahbod <behdad@behdad.org>
+Date:   Wed Aug 28 15:05:49 2019 -0700
+
+    Rename
+
+ src/hb-open-type.hh | 10 +++++-----
+ 1 file changed, 5 insertions(+), 5 deletions(-)
+
+commit bc5ef765a874ecd9fc0634dccf0848d1ee839c9a
+Author: Behdad Esfahbod <behdad@behdad.org>
+Date:   Wed Aug 28 14:51:28 2019 -0700
+
+    [subset] Subset ligature substitutes!
+    
+    Test with:
+    
+    $ ./hb-subset -o out.ttf NotoSansArabic-Regular.ttf --drop-tables=  سلام && ./hb-view out.ttf سلام
+
+ src/hb-ot-layout-gsub-table.hh | 79 ++++++++++++++++++++++++++++++++++++++++--
+ 1 file changed, 76 insertions(+), 3 deletions(-)
+
+commit 42d887bd221879f57ef939838d4f72bf38268943
+Author: Behdad Esfahbod <behdad@behdad.org>
+Date:   Wed Aug 28 14:47:14 2019 -0700
+
+    Beef up HeadlessArrayOf<>
+    
+    Should be merged with ArrayOf...
+    https://github.com/harfbuzz/harfbuzz/issues/1937
+
+ src/hb-open-type.hh | 37 ++++++++++++++++++++++++++++++-------
+ 1 file changed, 30 insertions(+), 7 deletions(-)
+
+commit 3ca809e3623e59b9a99bc0b9e5d10b02238bba3c
+Author: Behdad Esfahbod <behdad@behdad.org>
+Date:   Wed Aug 28 13:49:35 2019 -0700
+
+    Add ArrayOf::pop()
+
+ src/hb-open-type.hh | 2 ++
+ 1 file changed, 2 insertions(+)
+
+commit 307bd6d79f11eb175f06c08c321947a447496291
+Author: Behdad Esfahbod <behdad@behdad.org>
+Date:   Wed Aug 28 13:49:17 2019 -0700
+
+    Add arithmetic operators to IntType<>
+
+ src/hb-open-type.hh | 8 ++++++++
+ 1 file changed, 8 insertions(+)
+
+commit 2e1d00c85bba98f08a728c4f6f8112d5a25d8062
+Author: Behdad Esfahbod <behdad@behdad.org>
+Date:   Wed Aug 28 13:49:04 2019 -0700
+
+    [debug] Minor
+
+ src/hb-debug.hh | 4 ++--
+ 1 file changed, 2 insertions(+), 2 deletions(-)
+
+commit 062cad5e28574f9f004f917afa7d010fa68fdad0
+Author: Behdad Esfahbod <behdad@behdad.org>
+Date:   Wed Aug 28 13:33:08 2019 -0700
+
+    Add ArrayOf::serialize_append
+
+ src/hb-open-type.hh | 12 ++++++++++++
+ 1 file changed, 12 insertions(+)
+
+commit b66076812d067f893a5a422af2656916ff479d8f
+Author: Adrian Wong <adrianwjw@gmail.com>
+Date:   Wed Aug 28 21:31:27 2019 +1000
+
+    Adjustments to the generated Indic table output (#1936)
+    
+    * Add empty parentheses after print call
+    
+    * Minor: newlines. Move #pragma pop down one; #endif up one
+    
+    * Adjust #define ISC/IMC output
+    
+    * Regenerate Indic table
+
+ src/gen-indic-table.py                 |  21 ++++---
+ src/hb-ot-shape-complex-indic-table.cc | 109 +++++++++++++++++----------------
+ 2 files changed, 70 insertions(+), 60 deletions(-)
+
+commit 4ef08dbce1a9acd7e941168245c96e010248ecb6
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Tue Aug 27 14:49:46 2019 +0430
+
+    Use hb_bytes_t as<T> in hb_blob_t
+
+ src/hb-blob.hh | 8 ++------
+ 1 file changed, 2 insertions(+), 6 deletions(-)
+
+commit dce42cef2b769379a0690053da0e7467ff086195
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Tue Aug 27 14:32:05 2019 +0430
+
+    [glyf] Move GlyphHeader::from_bytes to hb_bytes_t, introduce .as<T> ()
+
+ src/hb-array.hh         |  6 ++++++
+ src/hb-ot-glyf-table.hh | 24 +++++++++---------------
+ 2 files changed, 15 insertions(+), 15 deletions(-)
+
+commit 6e82d59b4f72e8f2ff1830fb384907dcba95962a
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Tue Aug 27 12:33:42 2019 +0430
+
+    [glyf] Revert the way indexToLocFormat is set
+
+ src/hb-ot-glyf-table.hh | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+commit 88e9db19d29480fadcd4f49f0f4d9029ac64b429
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Tue Aug 27 02:44:26 2019 +0430
+
+    [subset] Remove subset table size assertion
+    
+    As https://github.com/harfbuzz/harfbuzz/pull/1930#issuecomment-525036802
+
+ src/hb-subset.cc | 1 -
+ 1 file changed, 1 deletion(-)
+
+commit a0b4ac4dce392326284138fc47cf3741e2798e21
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Sat Aug 24 17:57:14 2019 +0430
+
+    Turn 8 spaces to tab across the project
+    
+    According to the current code style of the project
+
+ src/hb-aat-layout-kerx-table.hh    |  12 +-
+ src/hb-aat-layout-morx-table.hh    |  16 +--
+ src/hb-aat-layout-trak-table.hh    |   6 +-
+ src/hb-array.hh                    |   4 +-
+ src/hb-blob.cc                     |   4 +-
+ src/hb-buffer-serialize.cc         |   2 +-
+ src/hb-buffer.cc                   |  22 ++--
+ src/hb-buffer.h                    |   4 +-
+ src/hb-common.cc                   |   4 +-
+ src/hb-coretext.cc                 |  50 ++++----
+ src/hb-dispatch.hh                 |   2 +-
+ src/hb-font.cc                     |  16 +--
+ src/hb-ft.cc                       |   2 +-
+ src/hb-graphite2.cc                |  10 +-
+ src/hb-iter.hh                     |   4 +-
+ src/hb-kern.hh                     |   6 +-
+ src/hb-machinery.hh                |   2 +-
+ src/hb-object.hh                   |   2 +-
+ src/hb-open-file.hh                |   4 +-
+ src/hb-open-type.hh                |   2 +-
+ src/hb-ot-cmap-table.hh            | 252 ++++++++++++++++++-------------------
+ src/hb-ot-color-cbdt-table.hh      |   2 +-
+ src/hb-ot-color-cpal-table.hh      |   2 +-
+ src/hb-ot-color-sbix-table.hh      |   8 +-
+ src/hb-ot-font.cc                  |  16 +--
+ src/hb-ot-hmtx-table.hh            |  62 ++++-----
+ src/hb-ot-layout-common.hh         |  16 +--
+ src/hb-ot-layout-gdef-table.hh     |   4 +-
+ src/hb-ot-layout-gpos-table.hh     |  74 +++++------
+ src/hb-ot-layout.cc                |  26 ++--
+ src/hb-ot-layout.h                 |  18 +--
+ src/hb-ot-map.cc                   |   2 +-
+ src/hb-ot-maxp-table.hh            |   2 +-
+ src/hb-ot-name-table.hh            |   8 +-
+ src/hb-ot-name.cc                  |   2 +-
+ src/hb-ot-shape-complex-arabic.cc  |  14 +--
+ src/hb-ot-shape-complex-hangul.cc  |  12 +-
+ src/hb-ot-shape-complex-indic.cc   |  34 ++---
+ src/hb-ot-shape-complex-khmer.cc   |   2 +-
+ src/hb-ot-shape-complex-myanmar.cc |   2 +-
+ src/hb-ot-shape-complex-use.cc     |   2 +-
+ src/hb-ot-shape-fallback.cc        |  46 +++----
+ src/hb-ot-shape-normalize.cc       |   4 +-
+ src/hb-ot-shape.cc                 |  16 +--
+ src/hb-ot-stat-table.hh            |   4 +-
+ src/hb-ot-var-avar-table.hh        |   2 +-
+ src/hb-ot-var-fvar-table.hh        |   6 +-
+ src/hb-ot-vorg-table.hh            |  28 ++---
+ src/hb-pool.hh                     |   2 +-
+ src/hb-sanitize.hh                 |   6 +-
+ src/hb-set.hh                      |  36 +++---
+ src/hb-shape-plan.cc               |  50 ++++----
+ src/hb-subset-cff2.cc              |  18 +--
+ src/hb-subset-input.cc             |   2 +-
+ src/hb-subset-plan.cc              |  34 ++---
+ src/hb-subset-plan.hh              |   8 +-
+ src/hb-subset.h                    |   2 +-
+ src/hb-uniscribe.cc                |   8 +-
+ src/hb-utf.hh                      |   8 +-
+ src/hb-vector.hh                   |   2 +-
+ src/hb.hh                          |  12 +-
+ src/test-ot-color.cc               |   4 +-
+ src/test-unicode-ranges.cc         |   6 +-
+ test/api/hb-subset-test.h          |   6 +-
+ test/api/test-buffer.c             |   2 +-
+ test/api/test-object.c             |   2 +-
+ test/api/test-ot-math.c            | 132 +++++++++----------
+ test/api/test-unicode.c            |  16 +--
+ util/ansi-print.cc                 |  26 ++--
+ util/hb-fc-list.c                  |   2 +-
+ util/hb-fc.cc                      |   4 +-
+ util/hb-shape.cc                   |   2 +-
+ util/hb-subset.cc                  |  10 +-
+ util/helper-cairo-ansi.cc          |   4 +-
+ util/helper-cairo.cc               |   2 +-
+ util/options-subset.cc             |  26 ++--
+ util/options.cc                    |  50 ++++----
+ util/options.hh                    |   8 +-
+ 78 files changed, 662 insertions(+), 668 deletions(-)
+
+commit 269a120f137ca69ca83b6fa00bb6a0ff1a87ae3e
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Sun Aug 25 20:37:00 2019 +0430
+
+    [subset] Raise the bar in new vs old table size
+    
+    https://crbug.com/oss-fuzz/16740
+    
+    This is actually an interesting thing that {h,v}mtx allocates as
+    much as a font pretends to have glyphs but the solution is not
+    that obvious as regular fonts can have less than actually containing
+    metrics in their {h,v}mtx. This change raises the bar to consider this
+    hmtx 4 byte for every glyph case.
+    
+    Initially we wanted to just find things allocating crazy amount of
+    memory but having the assert has led to interesting findings also
+    so let's don't remove the assert and see what we can find elsewhere.
+
+ src/hb-subset.cc                                          |   2 +-
+ ...z-testcase-minimized-hb-subset-fuzzer-5667673584697344 | Bin 0 -> 178 bytes
+ 2 files changed, 1 insertion(+), 1 deletion(-)
+
+commit 2f8e823331aca2c73b940f057f4b149a89af0502
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Sun Aug 25 12:37:40 2019 +0430
+
+    [glyf] minor
+
+ src/hb-ot-glyf-table.hh | 5 ++---
+ 1 file changed, 2 insertions(+), 3 deletions(-)
+
+commit 07e467a30e2bab9731900d72dbf926dbe6fc6e1d
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Sun Aug 25 00:36:58 2019 +0430
+
+    [glyf] Move GlyphHeader size checking to a static method
+
+ src/hb-ot-glyf-table.hh | 69 ++++++++++++++++++++++++++-----------------------
+ 1 file changed, 36 insertions(+), 33 deletions(-)
+
+commit 139d14dc899250cf06a8d03b70504687184d5c7f
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Sat Aug 24 17:23:16 2019 +0430
+
+    [glyf] Move GlyphHeader related logics to its, making its fields protected
+
+ src/hb-ot-glyf-table.hh | 73 +++++++++++++++++++++++++------------------------
+ 1 file changed, 38 insertions(+), 35 deletions(-)
+
+commit d57819cbdbab18ccf20caa25cb72cd66efe30848
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Sat Aug 24 16:26:42 2019 +0430
+
+    [glyf] format source
+
+ src/hb-ot-glyf-table.hh | 282 ++++++++++++++++++++++++++----------------------
+ 1 file changed, 154 insertions(+), 128 deletions(-)
+
+commit 2aef3013f3e6d71eacd0123f4faa63445034c32b
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Sat Aug 24 02:59:18 2019 +0430
+
+    [subset] Consider instruction length place itself
+    
+    Now fixes https://crbug.com/oss-fuzz/16639 completely
+
+ src/hb-ot-glyf-table.hh | 4 +++-
+ 1 file changed, 3 insertions(+), 1 deletion(-)
+
+commit 922898c814b328712fac6c3259740804679dae11
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Fri Aug 23 22:04:14 2019 +0430
+
+    [subset] Fail on table grow more than 16x+4096
+
+ src/hb-subset.cc | 1 +
+ 1 file changed, 1 insertion(+)
+
+commit 28aba780c4035cc85a31b778db0f5553c896dd6a
+Author: Ebrahim Byagowi <ebrahim@gnu.org>
+Date:   Fri Aug 23 16:47:15 2019 +0430
+
+    [subset] Fix blob leak of _subset2 when returns early
+    
+    Fixes https://crbug.com/oss-fuzz/16639
+
+ src/hb-subset.cc                                          |   2 ++
+ ...z-testcase-minimized-hb-subset-fuzzer-5754526379802624 | Bin 0 -> 288 bytes
+ 2 files changed, 2 insertions(+)
+
+commit 541f3c2d7dcae47eb55650082e372286369d4a55
+Author: Behdad Esfahbod <behdad@behdad.org>
+Date:   Fri Aug 23 12:25:58 2019 -0700
+
+    [debug] Fix extra semicolon issue
+    
+    https://github.com/harfbuzz/harfbuzz/issues/1923
+
+ src/hb-debug.hh | 8 ++++----
+ 1 file changed, 4 insertions(+), 4 deletions(-)
+
+commit 4dcaca84115bf8de130fc2c9e03bd7e63fcf9607
+Author: Behdad Esfahbod <behdad@behdad.org>
+Date:   Fri Aug 23 12:24:15 2019 -0700
+
+    Whitespace
+
+ src/hb-debug.hh | 4 ++--
+ 1 file changed, 2 insertions(+), 2 deletions(-)
+
+commit 569426d861ac9336f4083e55f98284b4c647c795
+Author: Behdad Esfahbod <behdad@behdad.org>
+Date:   Fri Aug 23 11:54:20 2019 -0700
+
+    [debug] Fix build with HB_DEBUG
+    
+    Fixes https://github.com/harfbuzz/harfbuzz/issues/1923
+
+ src/hb-debug.hh | 5 +++--
+ 1 file changed, 3 insertions(+), 2 deletions(-)
+
+commit f233e6c8014cde9b2396c5350c29a3277cd3a657
+Author: Khaled Hosny <khaledhosny@eglug.org>
+Date:   Fri Aug 23 13:15:37 2019 +0200
+
+    [doc] Update list of default features in the manual
+    
+    Fixes https://github.com/harfbuzz/harfbuzz/issues/1921
+
+ docs/usermanual-opentype-features.xml | 8 +++++---
+ 1 file changed, 5 insertions(+), 3 deletions(-)
+
 commit be97e9d678017d4ec66625fa2b17ef3485552cad
 Author: Behdad Esfahbod <behdad@behdad.org>
 Date:   Thu Aug 22 15:52:24 2019 -0700
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/NEWS b/Build/source/libs/harfbuzz/harfbuzz-src/NEWS
index ef5f487af1d..30fa8c3976c 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/NEWS
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/NEWS
@@ -1,3 +1,9 @@
+Overview of changes leading to 2.6.2
+Monday, September 30, 2019
+====================================
+- Misc small fixes, mostly to build-related issues.
+
+
 Overview of changes leading to 2.6.1
 Thursday, August 22, 2019
 ====================================
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/config.h.in b/Build/source/libs/harfbuzz/harfbuzz-src/config.h.in
index 939c8198d84..381036e5928 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/config.h.in
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/config.h.in
@@ -90,6 +90,9 @@
 /* Have PTHREAD_PRIO_INHERIT. */
 #undef HAVE_PTHREAD_PRIO_INHERIT
 
+/* Define to 1 if you have the `roundf' function. */
+#undef HAVE_ROUNDF
+
 /* Define to 1 if you have the <sched.h> header file. */
 #undef HAVE_SCHED_H
 
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/configure.ac b/Build/source/libs/harfbuzz/harfbuzz-src/configure.ac
index ab079fc0583..c88cffea63c 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/configure.ac
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/configure.ac
@@ -1,6 +1,6 @@
 AC_PREREQ([2.64])
 AC_INIT([HarfBuzz],
-        [2.6.1],
+        [2.6.2],
         [https://github.com/harfbuzz/harfbuzz/issues/new],
         [harfbuzz],
         [http://harfbuzz.org/])
@@ -77,7 +77,7 @@ GTK_DOC_CHECK([1.15],[--flavour no-tmpl])
 ])
 
 # Functions and headers
-AC_CHECK_FUNCS(atexit mprotect sysconf getpagesize mmap isatty newlocale strtod_l)
+AC_CHECK_FUNCS(atexit mprotect sysconf getpagesize mmap isatty newlocale strtod_l roundf)
 AC_CHECK_HEADERS(unistd.h sys/mman.h xlocale.h stdbool.h)
 
 # Compiler flags
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/Makefile.am b/Build/source/libs/harfbuzz/harfbuzz-src/src/Makefile.am
index 7173f4b7de5..a76d9685839 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/Makefile.am
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/Makefile.am
@@ -411,7 +411,7 @@ dump_use_data_SOURCES = dump-use-data.cc hb-ot-shape-complex-use-table.cc
 dump_use_data_CPPFLAGS = $(HBCFLAGS)
 dump_use_data_LDADD = libharfbuzz.la $(HBLIBS)
 
-COMPILED_TESTS = test-algs test-iter test-meta test-ot-tag test-unicode-ranges test-bimap
+COMPILED_TESTS = test-algs test-iter test-meta test-number test-ot-tag test-unicode-ranges test-bimap
 COMPILED_TESTS_CPPFLAGS = $(HBCFLAGS) -DMAIN -UNDEBUG
 COMPILED_TESTS_LDADD = libharfbuzz.la $(HBLIBS)
 check_PROGRAMS += $(COMPILED_TESTS)
@@ -429,6 +429,10 @@ test_meta_SOURCES = test-meta.cc hb-static.cc
 test_meta_CPPFLAGS = $(COMPILED_TESTS_CPPFLAGS)
 test_meta_LDADD = $(COMPILED_TESTS_LDADD)
 
+test_number_SOURCES = test-number.cc hb-number.cc
+test_number_CPPFLAGS = $(COMPILED_TESTS_CPPFLAGS)
+test_number_LDADD = $(COMPILED_TESTS_LDADD)
+
 test_ot_tag_SOURCES = hb-ot-tag.cc
 test_ot_tag_CPPFLAGS = $(COMPILED_TESTS_CPPFLAGS)
 test_ot_tag_LDADD = $(COMPILED_TESTS_LDADD)
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/Makefile.sources b/Build/source/libs/harfbuzz/harfbuzz-src/src/Makefile.sources
index 6e29b3f9733..eff0ad347df 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/Makefile.sources
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/Makefile.sources
@@ -49,6 +49,8 @@ HB_BASE_sources = \
 	hb-meta.hh \
 	hb-mutex.hh \
 	hb-null.hh \
+	hb-number.cc \
+	hb-number.hh \
 	hb-object.hh \
 	hb-open-file.hh \
 	hb-open-type.hh \
@@ -167,6 +169,7 @@ HB_BASE_sources = \
 HB_BASE_RAGEL_GENERATED_sources = \
 	hb-buffer-deserialize-json.hh \
 	hb-buffer-deserialize-text.hh \
+	hb-number-parser.hh \
 	hb-ot-shape-complex-indic-machine.hh \
 	hb-ot-shape-complex-khmer-machine.hh \
 	hb-ot-shape-complex-myanmar-machine.hh \
@@ -175,6 +178,7 @@ HB_BASE_RAGEL_GENERATED_sources = \
 HB_BASE_RAGEL_sources = \
 	hb-buffer-deserialize-json.rl \
 	hb-buffer-deserialize-text.rl \
+	hb-number-parser.rl \
 	hb-ot-shape-complex-indic-machine.rl \
 	hb-ot-shape-complex-khmer-machine.rl \
 	hb-ot-shape-complex-myanmar-machine.rl \
@@ -241,6 +245,8 @@ HB_ICU_headers = hb-icu.h
 
 # Sources for libharfbuzz-subset
 HB_SUBSET_sources = \
+	hb-number.cc \
+	hb-number.hh \
 	hb-ot-cff1-table.cc \
 	hb-ot-cff2-table.cc \
 	hb-static.cc \
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/gen-indic-table.py b/Build/source/libs/harfbuzz/harfbuzz-src/src/gen-indic-table.py
index cdf81fe7524..912b1d7ea2c 100755
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/gen-indic-table.py
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/gen-indic-table.py
@@ -133,8 +133,8 @@ what = ["INDIC_SYLLABIC_CATEGORY", "INDIC_MATRA_CATEGORY"]
 what_short = ["ISC", "IMC"]
 print ('#pragma GCC diagnostic push')
 print ('#pragma GCC diagnostic ignored "-Wunused-macros"')
+cat_defs = []
 for i in range (2):
-	print ()
 	vv = sorted (values[i].keys ())
 	for v in vv:
 		v_no_and = v.replace ('_And_', '_')
@@ -146,10 +146,17 @@ for i in range (2):
 				raise Exception ("Duplicate short value alias", v, all_shorts[i][s])
 			all_shorts[i][s] = v
 			short[i][v] = s
-		print ("#define %s_%s	%s_%s	%s/* %3d chars; %s */" %
-			(what_short[i], s, what[i], v.upper (),
-			'	'* ((48-1 - len (what[i]) - 1 - len (v)) // 8),
-			values[i][v], v))
+		cat_defs.append ((what_short[i] + '_' + s, what[i] + '_' + v.upper (), str (values[i][v]), v))
+
+maxlen_s = max ([len (c[0]) for c in cat_defs])
+maxlen_l = max ([len (c[1]) for c in cat_defs])
+maxlen_n = max ([len (c[2]) for c in cat_defs])
+for s in what_short:
+	print ()
+	for c in [c for c in cat_defs if s in c[0]]:
+		print ("#define %s %s /* %s chars; %s */" %
+			(c[0].ljust (maxlen_s), c[1].ljust (maxlen_l), c[2].rjust (maxlen_n), c[3]))
+print ()
 print ('#pragma GCC diagnostic pop')
 print ()
 print ("#define _(S,M) INDIC_COMBINE_CATEGORIES (ISC_##S, IMC_##M)")
@@ -249,14 +256,14 @@ print ("}")
 print ()
 print ("#undef _")
 for i in range (2):
-	print
+	print ()
 	vv = sorted (values[i].keys ())
 	for v in vv:
 		print ("#undef %s_%s" %
 			(what_short[i], short[i][v]))
 print ()
-print ()
 print ('#endif')
+print ()
 print ("/* == End of generated table == */")
 
 # Maintain at least 30% occupancy in the table */
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/harfbuzz.cc b/Build/source/libs/harfbuzz/harfbuzz-src/src/harfbuzz.cc
index d338d1735cd..fe1c3602321 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/harfbuzz.cc
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/harfbuzz.cc
@@ -8,6 +8,7 @@
 #include "hb-fallback-shape.cc"
 #include "hb-font.cc"
 #include "hb-map.cc"
+#include "hb-number.cc"
 #include "hb-ot-cff1-table.cc"
 #include "hb-ot-cff2-table.cc"
 #include "hb-ot-color.cc"
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-aat-fdsc-table.hh b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-aat-fdsc-table.hh
index 1188e352f03..604d5bcf054 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-aat-fdsc-table.hh
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-aat-fdsc-table.hh
@@ -65,7 +65,7 @@ struct FontDescriptor
   protected:
   Tag		tag;		/* The 4-byte table tag name. */
   union {
-  Fixed		value;		/* The value for the descriptor tag. */
+  HBFixed		value;		/* The value for the descriptor tag. */
   HBUINT32	nalfType;	/* If the tag is `nalf`, see non_alphabetic_value_t */
   } u;
   public:
@@ -108,7 +108,7 @@ struct fdsc
   }
 
   protected:
-  Fixed		version;	/* Version number of the font descriptors
+  HBFixed		version;	/* Version number of the font descriptors
 				 * table (0x00010000 for the current version). */
   LArrayOf<FontDescriptor>
 		descriptors;	/* List of tagged-coordinate pairs style descriptors
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-aat-layout-bsln-table.hh b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-aat-layout-bsln-table.hh
index 9139d28183c..15ef2da6575 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-aat-layout-bsln-table.hh
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-aat-layout-bsln-table.hh
@@ -82,7 +82,7 @@ struct BaselineTableFormat2Part
   }
 
   protected:
-  GlyphID	stdGlyph;	/* The specific glyph index number in this
+  HBGlyphID	stdGlyph;	/* The specific glyph index number in this
 				 * font that is used to set the baseline values.
 				 * This is the standard glyph.
 				 * This glyph must contain a set of control points
@@ -105,7 +105,7 @@ struct BaselineTableFormat3Part
   }
 
   protected:
-  GlyphID	stdGlyph;	/* ditto */
+  HBGlyphID	stdGlyph;	/* ditto */
   HBUINT16	ctlPoints[32];	/* ditto */
   Lookup<HBUINT16>
 		lookupTable;	/* Lookup table that maps glyphs to their
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-aat-layout-common.hh b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-aat-layout-common.hh
index a8c4b763762..473f2cdcd27 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-aat-layout-common.hh
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-aat-layout-common.hh
@@ -93,8 +93,8 @@ struct LookupSegmentSingle
     return_trace (c->check_struct (this) && value.sanitize (c, base));
   }
 
-  GlyphID	last;		/* Last GlyphID in this segment */
-  GlyphID	first;		/* First GlyphID in this segment */
+  HBGlyphID	last;		/* Last GlyphID in this segment */
+  HBGlyphID	first;		/* First GlyphID in this segment */
   T		value;		/* The lookup value (only one) */
   public:
   DEFINE_SIZE_STATIC (4 + T::static_size);
@@ -162,8 +162,8 @@ struct LookupSegmentArray
 		  valuesZ.sanitize (c, base, last - first + 1, hb_forward<Ts> (ds)...));
   }
 
-  GlyphID	last;		/* Last GlyphID in this segment */
-  GlyphID	first;		/* First GlyphID in this segment */
+  HBGlyphID	last;		/* Last GlyphID in this segment */
+  HBGlyphID	first;		/* First GlyphID in this segment */
   NNOffsetTo<UnsizedArrayOf<T>>
 		valuesZ;	/* A 16-bit offset from the start of
 				 * the table to the data. */
@@ -222,7 +222,7 @@ struct LookupSingle
     return_trace (c->check_struct (this) && value.sanitize (c, base));
   }
 
-  GlyphID	glyph;		/* Last GlyphID */
+  HBGlyphID	glyph;		/* Last GlyphID */
   T		value;		/* The lookup value (only one) */
   public:
   DEFINE_SIZE_STATIC (2 + T::static_size);
@@ -284,7 +284,7 @@ struct LookupFormat8
 
   protected:
   HBUINT16	format;		/* Format identifier--format = 8 */
-  GlyphID	firstGlyph;	/* First glyph index included in the trimmed array. */
+  HBGlyphID	firstGlyph;	/* First glyph index included in the trimmed array. */
   HBUINT16	glyphCount;	/* Total number of glyphs (equivalent to the last
 				 * glyph minus the value of firstGlyph plus 1). */
   UnsizedArrayOf<T>
@@ -326,7 +326,7 @@ struct LookupFormat10
   protected:
   HBUINT16	format;		/* Format identifier--format = 8 */
   HBUINT16	valueSize;	/* Byte size of each value. */
-  GlyphID	firstGlyph;	/* First glyph index included in the trimmed array. */
+  HBGlyphID	firstGlyph;	/* First glyph index included in the trimmed array. */
   HBUINT16	glyphCount;	/* Total number of glyphs (equivalent to the last
 				 * glyph minus the value of firstGlyph plus 1). */
   UnsizedArrayOf<HBUINT8>
@@ -658,7 +658,7 @@ struct ClassTable
     return_trace (c->check_struct (this) && classArray.sanitize (c));
   }
   protected:
-  GlyphID		firstGlyph;	/* First glyph index included in the trimmed array. */
+  HBGlyphID		firstGlyph;	/* First glyph index included in the trimmed array. */
   ArrayOf<HBUCHAR>	classArray;	/* The class codes (indexed by glyph index minus
 					 * firstGlyph). */
   public:
@@ -678,7 +678,7 @@ struct ObsoleteTypes
 				     const void *base,
 				     const T *array)
   {
-    return (offset - ((const char *) array - (const char *) base)) / sizeof (T);
+    return (offset - ((const char *) array - (const char *) base)) / T::static_size;
   }
   template <typename T>
   static unsigned int byteOffsetToIndex (unsigned int offset,
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-aat-layout-feat-table.hh b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-aat-layout-feat-table.hh
index c8229940dc0..788d4084a1f 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-aat-layout-feat-table.hh
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-aat-layout-feat-table.hh
@@ -206,7 +206,7 @@ struct feat
   SortedUnsizedArrayOf<FeatureName>
 		namesZ;		/* The feature name array. */
   public:
-  DEFINE_SIZE_STATIC (24);
+  DEFINE_SIZE_ARRAY (12, namesZ);
 };
 
 } /* namespace AAT */
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-aat-layout-just-table.hh b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-aat-layout-just-table.hh
index e15c946a2db..e1787d10c67 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-aat-layout-just-table.hh
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-aat-layout-just-table.hh
@@ -70,9 +70,9 @@ struct DecompositionAction
 
   ActionSubrecordHeader
 		header;
-  Fixed		lowerLimit; 	/* If the distance factor is less than this value,
+  HBFixed		lowerLimit; 	/* If the distance factor is less than this value,
 				 * then the ligature is decomposed. */
-  Fixed		upperLimit; 	/* If the distance factor is greater than this value,
+  HBFixed		upperLimit; 	/* If the distance factor is greater than this value,
 				 * then the ligature is decomposed. */
   HBUINT16 	order;		/* Numerical order in which this ligature will
 				 * be decomposed; you may want infrequent ligatures
@@ -100,7 +100,7 @@ struct UnconditionalAddGlyphAction
   protected:
   ActionSubrecordHeader
 		header;
-  GlyphID	addGlyph;	/* Glyph that should be added if the distance factor
+  HBGlyphID	addGlyph;	/* Glyph that should be added if the distance factor
 				 * is growing. */
 
   public:
@@ -118,14 +118,14 @@ struct ConditionalAddGlyphAction
   protected:
   ActionSubrecordHeader
 		header;
-  Fixed 	substThreshold; /* Distance growth factor (in ems) at which
+  HBFixed 	substThreshold; /* Distance growth factor (in ems) at which
 				 * this glyph is replaced and the growth factor
 				 * recalculated. */
-  GlyphID 	addGlyph; 	/* Glyph to be added as kashida. If this value is
+  HBGlyphID 	addGlyph; 	/* Glyph to be added as kashida. If this value is
 				 * 0xFFFF, no extra glyph will be added. Note that
 				 * generally when a glyph is added, justification
 				 * will need to be redone. */
-  GlyphID 	substGlyph; 	/* Glyph to be substituted for this glyph if the
+  HBGlyphID 	substGlyph; 	/* Glyph to be substituted for this glyph if the
 				 * growth factor equals or exceeds the value of
 				 * substThreshold. */
   public:
@@ -146,13 +146,13 @@ struct DuctileGlyphAction
   HBUINT32 	variationAxis;	/* The 4-byte tag identifying the ductile axis.
 				 * This would normally be 0x64756374 ('duct'),
 				 * but you may use any axis the font contains. */
-  Fixed 	minimumLimit; 	/* The lowest value for the ductility axis tha
+  HBFixed 	minimumLimit; 	/* The lowest value for the ductility axis tha
 				 * still yields an acceptable appearance. Normally
 				 * this will be 1.0. */
-  Fixed 	noStretchValue; /* This is the default value that corresponds to
+  HBFixed 	noStretchValue; /* This is the default value that corresponds to
 				 * no change in appearance. Normally, this will
 				 * be 1.0. */
-  Fixed 	maximumLimit; 	/* The highest value for the ductility axis that
+  HBFixed 	maximumLimit; 	/* The highest value for the ductility axis that
 				 * still yields an acceptable appearance. */
   public:
   DEFINE_SIZE_STATIC (22);
@@ -170,7 +170,7 @@ struct RepeatedAddGlyphAction
   ActionSubrecordHeader
 		header;
   HBUINT16 	flags;		/* Currently unused; set to 0. */
-  GlyphID 	glyph;		/* Glyph that should be added if the distance factor
+  HBGlyphID 	glyph;		/* Glyph that should be added if the distance factor
 				 * is growing. */
   public:
   DEFINE_SIZE_STATIC (10);
@@ -271,14 +271,14 @@ struct JustWidthDeltaEntry
   };
 
   protected:
-  Fixed		beforeGrowLimit;/* The ratio by which the advance width of the
+  HBFixed		beforeGrowLimit;/* The ratio by which the advance width of the
 				 * glyph is permitted to grow on the left or top side. */
-  Fixed		beforeShrinkLimit;
+  HBFixed		beforeShrinkLimit;
 				/* The ratio by which the advance width of the
 				 * glyph is permitted to shrink on the left or top side. */
-  Fixed		afterGrowLimit;	/* The ratio by which the advance width of the glyph
+  HBFixed		afterGrowLimit;	/* The ratio by which the advance width of the glyph
 				 * is permitted to shrink on the left or top side. */
-  Fixed		afterShrinkLimit;
+  HBFixed		afterShrinkLimit;
 				/* The ratio by which the advance width of the glyph
 				 * is at most permitted to shrink on the right or
 				 * bottom side. */
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-aat-layout-kerx-table.hh b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-aat-layout-kerx-table.hh
index cec63ac6d1d..8026b4ef1a2 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-aat-layout-kerx-table.hh
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-aat-layout-kerx-table.hh
@@ -82,8 +82,8 @@ struct KernPair
   }
 
   protected:
-  GlyphID	left;
-  GlyphID	right;
+  HBGlyphID	left;
+  HBGlyphID	right;
   FWORD		value;
   public:
   DEFINE_SIZE_STATIC (6);
@@ -392,7 +392,7 @@ struct KerxSubTableFormat2
 
     const UnsizedArrayOf<FWORD> &arrayZ = this+array;
     unsigned int kern_idx = l + r;
-    kern_idx = Types::offsetToIndex (kern_idx, this, &arrayZ);
+    kern_idx = Types::offsetToIndex (kern_idx, this, arrayZ.arrayZ);
     const FWORD *v = &arrayZ[kern_idx];
     if (unlikely (!v->sanitize (&c->sanitizer))) return 0;
 
@@ -830,7 +830,7 @@ struct KerxTable
     for (unsigned int i = 0; i < count; i++)
     {
       if (st->get_type () == 1)
-        return true;
+	return true;
       st = &StructAfter<SubTable> (*st);
     }
     return false;
@@ -845,7 +845,7 @@ struct KerxTable
     for (unsigned int i = 0; i < count; i++)
     {
       if (st->u.header.coverage & st->u.header.CrossStream)
-        return true;
+	return true;
       st = &StructAfter<SubTable> (*st);
     }
     return false;
@@ -862,7 +862,7 @@ struct KerxTable
     {
       if ((st->u.header.coverage & (st->u.header.Variation | st->u.header.CrossStream)) ||
 	  !st->u.header.is_horizontal ())
-        continue;
+	continue;
       v += st->get_kerning (left, right);
       st = &StructAfter<SubTable> (*st);
     }
@@ -883,7 +883,7 @@ struct KerxTable
       bool reverse;
 
       if (!T::Types::extended && (st->u.header.coverage & st->u.header.Variation))
-        goto skip;
+	goto skip;
 
       if (HB_DIRECTION_IS_HORIZONTAL (c->buffer->props.direction) != st->u.header.is_horizontal ())
 	goto skip;
@@ -897,8 +897,8 @@ struct KerxTable
       if (!seenCrossStream &&
 	  (st->u.header.coverage & st->u.header.CrossStream))
       {
-        /* Attach all glyphs into a chain. */
-        seenCrossStream = true;
+	/* Attach all glyphs into a chain. */
+	seenCrossStream = true;
 	hb_glyph_position_t *pos = c->buffer->pos;
 	unsigned int count = c->buffer->len;
 	for (unsigned int i = 0; i < count; i++)
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-aat-layout-morx-table.hh b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-aat-layout-morx-table.hh
index 81d78972a22..d8df579f507 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-aat-layout-morx-table.hh
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-aat-layout-morx-table.hh
@@ -226,7 +226,7 @@ struct ContextualSubtable
       hb_buffer_t *buffer = driver->buffer;
 
       if (buffer->idx == buffer->len && !mark_set)
-        return false;
+	return false;
 
       return entry.data.markIndex != 0xFFFF || entry.data.currentIndex != 0xFFFF;
     }
@@ -238,23 +238,23 @@ struct ContextualSubtable
       /* Looks like CoreText applies neither mark nor current substitution for
        * end-of-text if mark was not explicitly set. */
       if (buffer->idx == buffer->len && !mark_set)
-        return;
+	return;
 
-      const GlyphID *replacement;
+      const HBGlyphID *replacement;
 
       replacement = nullptr;
       if (Types::extended)
       {
 	if (entry.data.markIndex != 0xFFFF)
 	{
-	  const Lookup<GlyphID> &lookup = subs[entry.data.markIndex];
+	  const Lookup<HBGlyphID> &lookup = subs[entry.data.markIndex];
 	  replacement = lookup.get_value (buffer->info[mark].codepoint, driver->num_glyphs);
 	}
       }
       else
       {
 	unsigned int offset = entry.data.markIndex + buffer->info[mark].codepoint;
-	const UnsizedArrayOf<GlyphID> &subs_old = (const UnsizedArrayOf<GlyphID> &) subs;
+	const UnsizedArrayOf<HBGlyphID> &subs_old = (const UnsizedArrayOf<HBGlyphID> &) subs;
 	replacement = &subs_old[Types::wordOffsetToIndex (offset, table, subs_old.arrayZ)];
 	if (!replacement->sanitize (&c->sanitizer) || !*replacement)
 	  replacement = nullptr;
@@ -272,14 +272,14 @@ struct ContextualSubtable
       {
 	if (entry.data.currentIndex != 0xFFFF)
 	{
-	  const Lookup<GlyphID> &lookup = subs[entry.data.currentIndex];
+	  const Lookup<HBGlyphID> &lookup = subs[entry.data.currentIndex];
 	  replacement = lookup.get_value (buffer->info[idx].codepoint, driver->num_glyphs);
 	}
       }
       else
       {
 	unsigned int offset = entry.data.currentIndex + buffer->info[idx].codepoint;
-	const UnsizedArrayOf<GlyphID> &subs_old = (const UnsizedArrayOf<GlyphID> &) subs;
+	const UnsizedArrayOf<HBGlyphID> &subs_old = (const UnsizedArrayOf<HBGlyphID> &) subs;
 	replacement = &subs_old[Types::wordOffsetToIndex (offset, table, subs_old.arrayZ)];
 	if (!replacement->sanitize (&c->sanitizer) || !*replacement)
 	  replacement = nullptr;
@@ -304,7 +304,7 @@ struct ContextualSubtable
     bool mark_set;
     unsigned int mark;
     const ContextualSubtable *table;
-    const UnsizedOffsetListOf<Lookup<GlyphID>, HBUINT, false> &subs;
+    const UnsizedOffsetListOf<Lookup<HBGlyphID>, HBUINT, false> &subs;
   };
 
   bool apply (hb_aat_apply_context_t *c) const
@@ -348,7 +348,7 @@ struct ContextualSubtable
   protected:
   StateTable<Types, EntryData>
 		machine;
-  NNOffsetTo<UnsizedOffsetListOf<Lookup<GlyphID>, HBUINT, false>, HBUINT>
+  NNOffsetTo<UnsizedOffsetListOf<Lookup<HBGlyphID>, HBUINT, false>, HBUINT>
 		substitutionTables;
   public:
   DEFINE_SIZE_STATIC (20);
@@ -488,7 +488,7 @@ struct LigatureSubtable
 
 	unsigned int ligature_idx = 0;
 	unsigned int action;
-        do
+	do
 	{
 	  if (unlikely (!cursor))
 	  {
@@ -520,7 +520,7 @@ struct LigatureSubtable
 	  if (action & (LigActionStore | LigActionLast))
 	  {
 	    ligature_idx = Types::offsetToIndex (ligature_idx, table, ligature.arrayZ);
-	    const GlyphID &ligatureData = ligature[ligature_idx];
+	    const HBGlyphID &ligatureData = ligature[ligature_idx];
 	    if (unlikely (!ligatureData.sanitize (&c->sanitizer))) break;
 	    hb_codepoint_t lig = ligatureData;
 
@@ -554,7 +554,7 @@ struct LigatureSubtable
     const LigatureSubtable *table;
     const UnsizedArrayOf<HBUINT32> &ligAction;
     const UnsizedArrayOf<HBUINT16> &component;
-    const UnsizedArrayOf<GlyphID> &ligature;
+    const UnsizedArrayOf<HBGlyphID> &ligature;
     unsigned int match_length;
     unsigned int match_positions[HB_MAX_CONTEXT_LENGTH];
   };
@@ -586,7 +586,7 @@ struct LigatureSubtable
 		ligAction;	/* Offset to the ligature action table. */
   NNOffsetTo<UnsizedArrayOf<HBUINT16>, HBUINT>
 		component;	/* Offset to the component table. */
-  NNOffsetTo<UnsizedArrayOf<GlyphID>, HBUINT>
+  NNOffsetTo<UnsizedArrayOf<HBGlyphID>, HBUINT>
 		ligature;	/* Offset to the actual ligature lists. */
   public:
   DEFINE_SIZE_STATIC (28);
@@ -606,7 +606,7 @@ struct NoncontextualSubtable
     unsigned int count = c->buffer->len;
     for (unsigned int i = 0; i < count; i++)
     {
-      const GlyphID *replacement = substitute.get_value (info[i].codepoint, num_glyphs);
+      const HBGlyphID *replacement = substitute.get_value (info[i].codepoint, num_glyphs);
       if (replacement)
       {
 	info[i].codepoint = *replacement;
@@ -624,7 +624,7 @@ struct NoncontextualSubtable
   }
 
   protected:
-  Lookup<GlyphID>	substitute;
+  Lookup<HBGlyphID>	substitute;
   public:
   DEFINE_SIZE_MIN (2);
 };
@@ -726,7 +726,7 @@ struct InsertionSubtable
       {
 	unsigned int count = (flags & MarkedInsertCount);
 	unsigned int start = entry.data.markedInsertIndex;
-	const GlyphID *glyphs = &insertionAction[start];
+	const HBGlyphID *glyphs = &insertionAction[start];
 	if (unlikely (!c->sanitizer.check_array (glyphs, count))) count = 0;
 
 	bool before = flags & MarkedInsertBefore;
@@ -754,7 +754,7 @@ struct InsertionSubtable
       {
 	unsigned int count = (flags & CurrentInsertCount) >> 5;
 	unsigned int start = entry.data.currentInsertIndex;
-	const GlyphID *glyphs = &insertionAction[start];
+	const HBGlyphID *glyphs = &insertionAction[start];
 	if (unlikely (!c->sanitizer.check_array (glyphs, count))) count = 0;
 
 	bool before = flags & CurrentInsertBefore;
@@ -793,7 +793,7 @@ struct InsertionSubtable
     private:
     hb_aat_apply_context_t *c;
     unsigned int mark;
-    const UnsizedArrayOf<GlyphID> &insertionAction;
+    const UnsizedArrayOf<HBGlyphID> &insertionAction;
   };
 
   bool apply (hb_aat_apply_context_t *c) const
@@ -819,7 +819,7 @@ struct InsertionSubtable
   protected:
   StateTable<Types, EntryData>
 		machine;
-  NNOffsetTo<UnsizedArrayOf<GlyphID>, HBUINT>
+  NNOffsetTo<UnsizedArrayOf<HBGlyphID>, HBUINT>
 		insertionAction;	/* Byte offset from stateHeader to the start of
 					 * the insertion glyph table. */
   public:
@@ -976,12 +976,12 @@ struct Chain
       bool reverse;
 
       if (!(subtable->subFeatureFlags & flags))
-        goto skip;
+	goto skip;
 
       if (!(subtable->get_coverage() & ChainSubtable<Types>::AllDirections) &&
 	  HB_DIRECTION_IS_VERTICAL (c->buffer->props.direction) !=
 	  bool (subtable->get_coverage() & ChainSubtable<Types>::Vertical))
-        goto skip;
+	goto skip;
 
       /* Buffer contents is always in logical direction.  Determine if
        * we need to reverse before applying this subtable.  We reverse
@@ -1016,15 +1016,15 @@ struct Chain
 		HB_DIRECTION_IS_BACKWARD (c->buffer->props.direction);
 
       if (!c->buffer->message (c->font, "start chain subtable %d", c->lookup_index))
-        goto skip;
+	goto skip;
 
       if (reverse)
-        c->buffer->reverse ();
+	c->buffer->reverse ();
 
       subtable->apply (c);
 
       if (reverse)
-        c->buffer->reverse ();
+	c->buffer->reverse ();
 
       (void) c->buffer->message (c->font, "end chain subtable %d", c->lookup_index);
 
@@ -1080,10 +1080,10 @@ struct Chain
  * The 'mort'/'morx' Table
  */
 
-template <typename Types>
+template <typename Types, hb_tag_t TAG>
 struct mortmorx
 {
-  static constexpr hb_tag_t tableTag = HB_AAT_TAG_morx;
+  static constexpr hb_tag_t tableTag = TAG;
 
   bool has_data () const { return version != 0; }
 
@@ -1143,14 +1143,8 @@ struct mortmorx
   DEFINE_SIZE_MIN (8);
 };
 
-struct morx : mortmorx<ExtendedTypes>
-{
-  static constexpr hb_tag_t tableTag = HB_AAT_TAG_morx;
-};
-struct mort : mortmorx<ObsoleteTypes>
-{
-  static constexpr hb_tag_t tableTag = HB_AAT_TAG_mort;
-};
+struct morx : mortmorx<ExtendedTypes, HB_AAT_TAG_morx> {};
+struct mort : mortmorx<ObsoleteTypes, HB_AAT_TAG_mort> {};
 
 
 } /* namespace AAT */
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-aat-layout-trak-table.hh b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-aat-layout-trak-table.hh
index e6b6d55e043..99dddd88268 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-aat-layout-trak-table.hh
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-aat-layout-trak-table.hh
@@ -62,7 +62,7 @@ struct TrackTableEntry
   }
 
   protected:
-  Fixed		track;		/* Track value for this record. */
+  HBFixed		track;		/* Track value for this record. */
   NameID	trackNameID;	/* The 'name' table index for this track.
 				 * (a short word or phrase like "loose"
 				 * or "very tight") */
@@ -82,7 +82,7 @@ struct TrackData
 			const void *base) const
   {
     unsigned int sizes = nSizes;
-    hb_array_t<const Fixed> size_table ((base+sizeTable).arrayZ, sizes);
+    hb_array_t<const HBFixed> size_table ((base+sizeTable).arrayZ, sizes);
 
     float s0 = size_table[idx].to_float ();
     float s1 = size_table[idx + 1].to_float ();
@@ -120,11 +120,11 @@ struct TrackData
     if (!sizes) return 0.;
     if (sizes == 1) return trackTableEntry->get_value (base, 0, sizes);
 
-    hb_array_t<const Fixed> size_table ((base+sizeTable).arrayZ, sizes);
+    hb_array_t<const HBFixed> size_table ((base+sizeTable).arrayZ, sizes);
     unsigned int size_index;
     for (size_index = 0; size_index < sizes - 1; size_index++)
       if (size_table[size_index].to_float () >= ptem)
-        break;
+	break;
 
     return roundf (interpolate_at (size_index ? size_index - 1 : 0, ptem,
 				   *trackTableEntry, base));
@@ -141,7 +141,7 @@ struct TrackData
   protected:
   HBUINT16	nTracks;	/* Number of separate tracks included in this table. */
   HBUINT16	nSizes;		/* Number of point sizes included in this table. */
-  LOffsetTo<UnsizedArrayOf<Fixed>, false>
+  LOffsetTo<UnsizedArrayOf<HBFixed>, false>
 		sizeTable;	/* Offset from start of the tracking table to
 				 * Array[nSizes] of size values.. */
   UnsizedArrayOf<TrackTableEntry>
@@ -176,7 +176,7 @@ struct trak
       hb_position_t advance_to_add = c->font->em_scalef_x (tracking);
       foreach_grapheme (buffer, start, end)
       {
-        if (!(buffer->info[start].mask & trak_mask)) continue;
+	if (!(buffer->info[start].mask & trak_mask)) continue;
 	buffer->pos[start].x_advance += advance_to_add;
 	buffer->pos[start].x_offset += offset_to_add;
       }
@@ -189,7 +189,7 @@ struct trak
       hb_position_t advance_to_add = c->font->em_scalef_y (tracking);
       foreach_grapheme (buffer, start, end)
       {
-        if (!(buffer->info[start].mask & trak_mask)) continue;
+	if (!(buffer->info[start].mask & trak_mask)) continue;
 	buffer->pos[start].y_advance += advance_to_add;
 	buffer->pos[start].y_offset += offset_to_add;
       }
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-algs.hh b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-algs.hh
index 788689478d2..c57481bfef0 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-algs.hh
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-algs.hh
@@ -32,6 +32,7 @@
 #include "hb.hh"
 #include "hb-meta.hh"
 #include "hb-null.hh"
+#include "hb-number.hh"
 
 
 /* Encodes three unsigned integers in one 64-bit number.  If the inputs have more than 21 bits,
@@ -82,6 +83,7 @@ HB_FUNCOBJ (hb_bool);
 struct
 {
   private:
+
   template <typename T> constexpr auto
   impl (const T& v, hb_priority<1>) const HB_RETURN (uint32_t, hb_deref (v).hash ())
 
@@ -895,17 +897,12 @@ hb_stable_sort (T *array, unsigned int len, int(*compar)(const T *, const T *))
 static inline hb_bool_t
 hb_codepoint_parse (const char *s, unsigned int len, int base, hb_codepoint_t *out)
 {
-  /* Pain because we don't know whether s is nul-terminated. */
-  char buf[64];
-  len = hb_min (ARRAY_LENGTH (buf) - 1, len);
-  strncpy (buf, s, len);
-  buf[len] = '\0';
-
-  char *end;
-  errno = 0;
-  unsigned long v = strtoul (buf, &end, base);
-  if (errno) return false;
-  if (*end) return false;
+  unsigned int v;
+  const char *p = s;
+  const char *end = p + len;
+  if (unlikely (!hb_parse_uint (&p, end, &v, true/* whole buffer */, base)))
+    return false;
+
   *out = v;
   return true;
 }
@@ -994,6 +991,18 @@ struct
   operator () (const T &a) const HB_AUTO_RETURN (-a)
 }
 HB_FUNCOBJ (hb_neg);
+struct
+{
+  template <typename T> constexpr auto
+  operator () (T &a) const HB_AUTO_RETURN (++a)
+}
+HB_FUNCOBJ (hb_inc);
+struct
+{
+  template <typename T> constexpr auto
+  operator () (T &a) const HB_AUTO_RETURN (--a)
+}
+HB_FUNCOBJ (hb_dec);
 
 
 /* Compiler-assisted vectorization. */
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-array.hh b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-array.hh
index d60c2494946..6efaf5fa558 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-array.hh
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-array.hh
@@ -50,7 +50,7 @@ struct hb_array_t : hb_iter_with_fallback_t<hb_array_t<Type>, Type&>
   template <typename U,
 	    hb_enable_if (hb_is_cr_convertible(U, Type))>
   hb_array_t (const hb_array_t<U> &o) :
-    hb_iter_with_fallback_t<hb_array_t<Type>, Type&> (),
+    hb_iter_with_fallback_t<hb_array_t, Type&> (),
     arrayZ (o.arrayZ), length (o.length), backwards_length (o.backwards_length) {}
   template <typename U,
 	    hb_enable_if (hb_is_cr_convertible(U, Type))>
@@ -106,7 +106,7 @@ struct hb_array_t : hb_iter_with_fallback_t<hb_array_t<Type>, Type&>
    */
 
   /* Note: our compare is NOT lexicographic; it also does NOT call Type::cmp. */
-  int cmp (const hb_array_t<Type> &a) const
+  int cmp (const hb_array_t &a) const
   {
     if (length != a.length)
       return (int) a.length - (int) length;
@@ -114,8 +114,8 @@ struct hb_array_t : hb_iter_with_fallback_t<hb_array_t<Type>, Type&>
   }
   HB_INTERNAL static int cmp (const void *pa, const void *pb)
   {
-    hb_array_t<Type> *a = (hb_array_t<Type> *) pa;
-    hb_array_t<Type> *b = (hb_array_t<Type> *) pb;
+    hb_array_t *a = (hb_array_t *) pa;
+    hb_array_t *b = (hb_array_t *) pb;
     return b->cmp (*a);
   }
 
@@ -141,13 +141,13 @@ struct hb_array_t : hb_iter_with_fallback_t<hb_array_t<Type>, Type&>
   hb_sorted_array_t<Type> qsort (int (*cmp_)(const void*, const void*))
   {
     if (likely (length))
-      hb_qsort (arrayZ, length, this->item_size, cmp_);
+      hb_qsort (arrayZ, length, this->get_item_size (), cmp_);
     return hb_sorted_array_t<Type> (*this);
   }
   hb_sorted_array_t<Type> qsort ()
   {
     if (likely (length))
-      hb_qsort (arrayZ, length, this->item_size, Type::cmp);
+      hb_qsort (arrayZ, length, this->get_item_size (), Type::cmp);
     return hb_sorted_array_t<Type> (*this);
   }
   void qsort (unsigned int start, unsigned int end)
@@ -155,16 +155,16 @@ struct hb_array_t : hb_iter_with_fallback_t<hb_array_t<Type>, Type&>
     end = hb_min (end, length);
     assert (start <= end);
     if (likely (start < end))
-      hb_qsort (arrayZ + start, end - start, this->item_size, Type::cmp);
+      hb_qsort (arrayZ + start, end - start, this->get_item_size (), Type::cmp);
   }
 
   /*
    * Other methods.
    */
 
-  unsigned int get_size () const { return length * this->item_size; }
+  unsigned int get_size () const { return length * this->get_item_size (); }
 
-  hb_array_t<Type> sub_array (unsigned int start_offset = 0, unsigned int *seg_count = nullptr /* IN/OUT */) const
+  hb_array_t sub_array (unsigned int start_offset = 0, unsigned int *seg_count = nullptr /* IN/OUT */) const
   {
     if (!start_offset && !seg_count)
       return *this;
@@ -176,11 +176,19 @@ struct hb_array_t : hb_iter_with_fallback_t<hb_array_t<Type>, Type&>
       count -= start_offset;
     if (seg_count)
       count = *seg_count = hb_min (count, *seg_count);
-    return hb_array_t<Type> (arrayZ + start_offset, count);
+    return hb_array_t (arrayZ + start_offset, count);
   }
-  hb_array_t<Type> sub_array (unsigned int start_offset, unsigned int seg_count) const
+  hb_array_t sub_array (unsigned int start_offset, unsigned int seg_count) const
   { return sub_array (start_offset, &seg_count); }
 
+  hb_array_t truncate (unsigned length) const { return sub_array (0, length); }
+
+  template <typename T,
+	    unsigned P = sizeof (Type),
+	    hb_enable_if (P == 1)>
+  const T *as () const
+  { return length < hb_null_size (T) ? &Null (T) : reinterpret_cast<const T *> (arrayZ); }
+
   /* Only call if you allocated the underlying array using malloc() or similar. */
   void free ()
   { ::free ((void *) arrayZ); arrayZ = nullptr; length = 0; }
@@ -228,7 +236,7 @@ struct hb_sorted_array_t :
 	hb_iter_t<hb_sorted_array_t<Type>, Type&>,
 	hb_array_t<Type>
 {
-  typedef hb_iter_t<hb_sorted_array_t<Type>, Type&> iter_base_t;
+  typedef hb_iter_t<hb_sorted_array_t, Type&> iter_base_t;
   HB_ITER_USING (iter_base_t);
   static constexpr bool is_random_access_iterator = true;
   static constexpr bool is_sorted_iterator = true;
@@ -241,7 +249,7 @@ struct hb_sorted_array_t :
   template <typename U,
 	    hb_enable_if (hb_is_cr_convertible(U, Type))>
   hb_sorted_array_t (const hb_array_t<U> &o) :
-    hb_iter_t<hb_sorted_array_t<Type>, Type&> (),
+    hb_iter_t<hb_sorted_array_t, Type&> (),
     hb_array_t<Type> (o) {}
   template <typename U,
 	    hb_enable_if (hb_is_cr_convertible(U, Type))>
@@ -252,11 +260,13 @@ struct hb_sorted_array_t :
   bool operator != (const hb_sorted_array_t& o) const
   { return this->arrayZ != o.arrayZ || this->length != o.length; }
 
-  hb_sorted_array_t<Type> sub_array (unsigned int start_offset, unsigned int *seg_count /* IN/OUT */) const
-  { return hb_sorted_array_t<Type> (((const hb_array_t<Type> *) (this))->sub_array (start_offset, seg_count)); }
-  hb_sorted_array_t<Type> sub_array (unsigned int start_offset, unsigned int seg_count) const
+  hb_sorted_array_t sub_array (unsigned int start_offset, unsigned int *seg_count /* IN/OUT */) const
+  { return hb_sorted_array_t (((const hb_array_t<Type> *) (this))->sub_array (start_offset, seg_count)); }
+  hb_sorted_array_t sub_array (unsigned int start_offset, unsigned int seg_count) const
   { return sub_array (start_offset, &seg_count); }
 
+  hb_sorted_array_t truncate (unsigned length) const { return sub_array (0, length); }
+
   template <typename T>
   Type *bsearch (const T &x, Type *not_found = nullptr)
   {
@@ -281,9 +291,9 @@ struct hb_sorted_array_t :
       int mid = ((unsigned int) min + (unsigned int) max) / 2;
       int c = array[mid].cmp (x);
       if (c < 0)
-        max = mid - 1;
+	max = mid - 1;
       else if (c > 0)
-        min = mid + 1;
+	min = mid + 1;
       else
       {
 	if (i)
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-blob.cc b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-blob.cc
index 9ed26bd2fa3..2e72683c8b9 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-blob.cc
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-blob.cc
@@ -48,7 +48,6 @@
 #endif /* HAVE_SYS_MMAN_H */
 
 #include <stdio.h>
-#include <errno.h>
 #include <stdlib.h>
 
 
@@ -592,7 +591,7 @@ fail_without_close:
     ceparams.lpSecurityAttributes = nullptr;
     ceparams.hTemplateFile = nullptr;
     fd = CreateFile2 (wchar_file_name, GENERIC_READ, FILE_SHARE_READ,
-                      OPEN_EXISTING, &ceparams);
+		      OPEN_EXISTING, &ceparams);
   }
 #else
   fd = CreateFileW (wchar_file_name, GENERIC_READ, FILE_SHARE_READ, nullptr,
@@ -669,7 +668,7 @@ fail_without_close:
   }
 
   return hb_blob_create (data, len, HB_MEMORY_MODE_WRITABLE, data,
-                         (hb_destroy_func_t) free);
+			 (hb_destroy_func_t) free);
 
 fread_fail:
   fclose (fp);
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-blob.hh b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-blob.hh
index cff492fa05a..d85bd823b00 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-blob.hh
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-blob.hh
@@ -54,13 +54,9 @@ struct hb_blob_t
   HB_INTERNAL bool try_make_writable_inplace ();
   HB_INTERNAL bool try_make_writable_inplace_unix ();
 
+  hb_bytes_t as_bytes () const { return hb_bytes_t (data, length); }
   template <typename Type>
-  const Type* as () const
-  {
-    return length < hb_null_size (Type) ? &Null(Type) : reinterpret_cast<const Type *> (data);
-  }
-  hb_bytes_t as_bytes () const
-  { return hb_bytes_t (data, length); }
+  const Type* as () const { return as_bytes ().as<Type> (); }
 
   public:
   hb_object_header_t header;
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-buffer-serialize.cc b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-buffer-serialize.cc
index 77d997c90fa..e64eb0ee650 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-buffer-serialize.cc
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-buffer-serialize.cc
@@ -135,7 +135,7 @@ _hb_buffer_serialize_glyphs_json (hb_buffer_t *buffer,
       hb_font_glyph_to_string (font, info[i].codepoint, g, sizeof (g));
       *p++ = '"';
       for (char *q = g; *q; q++) {
-        if (*q == '"')
+	if (*q == '"')
 	  *p++ = '\\';
 	*p++ = *q;
       }
@@ -379,43 +379,24 @@ hb_buffer_serialize_glyphs (hb_buffer_t *buffer,
   }
 }
 
-
-static hb_bool_t
-parse_uint (const char *pp, const char *end, uint32_t *pv)
+static bool
+parse_int (const char *pp, const char *end, int32_t *pv)
 {
-  char buf[32];
-  unsigned int len = hb_min (ARRAY_LENGTH (buf) - 1, (unsigned int) (end - pp));
-  strncpy (buf, pp, len);
-  buf[len] = '\0';
-
-  char *p = buf;
-  char *pend = p;
-  uint32_t v;
-
-  errno = 0;
-  v = strtol (p, &pend, 10);
-  if (errno || p == pend || pend - p != end - pp)
+  int v;
+  const char *p = pp;
+  if (unlikely (!hb_parse_int (&p, end, &v, true/* whole buffer */)))
     return false;
 
   *pv = v;
   return true;
 }
 
-static hb_bool_t
-parse_int (const char *pp, const char *end, int32_t *pv)
+static bool
+parse_uint (const char *pp, const char *end, uint32_t *pv)
 {
-  char buf[32];
-  unsigned int len = hb_min (ARRAY_LENGTH (buf) - 1, (unsigned int) (end - pp));
-  strncpy (buf, pp, len);
-  buf[len] = '\0';
-
-  char *p = buf;
-  char *pend = p;
-  int32_t v;
-
-  errno = 0;
-  v = strtol (p, &pend, 10);
-  if (errno || p == pend || pend - p != end - pp)
+  unsigned int v;
+  const char *p = pp;
+  if (unlikely (!hb_parse_uint (&p, end, &v, true/* whole buffer */)))
     return false;
 
   *pv = v;
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-buffer.cc b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-buffer.cc
index db1978e6df4..bb7f3c7c1d9 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-buffer.cc
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-buffer.cc
@@ -324,7 +324,8 @@ hb_buffer_t::clear_positions ()
   out_len = 0;
   out_info = info;
 
-  memset (pos, 0, sizeof (pos[0]) * len);
+  if (likely (len))
+    memset (pos, 0, sizeof (pos[0]) * len);
 }
 
 void
@@ -648,8 +649,8 @@ hb_buffer_t::guess_segment_properties ()
       if (likely (script != HB_SCRIPT_COMMON &&
 		  script != HB_SCRIPT_INHERITED &&
 		  script != HB_SCRIPT_UNKNOWN)) {
-        props.script = script;
-        break;
+	props.script = script;
+	break;
       }
     }
   }
@@ -1388,7 +1389,7 @@ hb_buffer_get_length (hb_buffer_t *buffer)
  **/
 hb_glyph_info_t *
 hb_buffer_get_glyph_infos (hb_buffer_t  *buffer,
-                           unsigned int *length)
+			   unsigned int *length)
 {
   if (length)
     *length = buffer->len;
@@ -1412,7 +1413,7 @@ hb_buffer_get_glyph_infos (hb_buffer_t  *buffer,
  **/
 hb_glyph_position_t *
 hb_buffer_get_glyph_positions (hb_buffer_t  *buffer,
-                               unsigned int *length)
+			       unsigned int *length)
 {
   if (!buffer->have_positions)
     buffer->clear_positions ();
@@ -1936,9 +1937,9 @@ hb_buffer_diff (hb_buffer_t *buffer,
     for (i = 0; i < count; i++)
     {
       if (contains && info[i].codepoint == dottedcircle_glyph)
-        result |= HB_BUFFER_DIFF_FLAG_DOTTED_CIRCLE_PRESENT;
+	result |= HB_BUFFER_DIFF_FLAG_DOTTED_CIRCLE_PRESENT;
       if (contains && info[i].codepoint == 0)
-        result |= HB_BUFFER_DIFF_FLAG_NOTDEF_PRESENT;
+	result |= HB_BUFFER_DIFF_FLAG_NOTDEF_PRESENT;
     }
     result |= HB_BUFFER_DIFF_FLAG_LENGTH_MISMATCH;
     return hb_buffer_diff_flags_t (result);
@@ -1973,12 +1974,12 @@ hb_buffer_diff (hb_buffer_t *buffer,
     for (unsigned int i = 0; i < count; i++)
     {
       if ((unsigned int) abs (buf_pos->x_advance - ref_pos->x_advance) > position_fuzz ||
-          (unsigned int) abs (buf_pos->y_advance - ref_pos->y_advance) > position_fuzz ||
-          (unsigned int) abs (buf_pos->x_offset - ref_pos->x_offset) > position_fuzz ||
-          (unsigned int) abs (buf_pos->y_offset - ref_pos->y_offset) > position_fuzz)
+	  (unsigned int) abs (buf_pos->y_advance - ref_pos->y_advance) > position_fuzz ||
+	  (unsigned int) abs (buf_pos->x_offset - ref_pos->x_offset) > position_fuzz ||
+	  (unsigned int) abs (buf_pos->y_offset - ref_pos->y_offset) > position_fuzz)
       {
-        result |= HB_BUFFER_DIFF_FLAG_POSITION_MISMATCH;
-        break;
+	result |= HB_BUFFER_DIFF_FLAG_POSITION_MISMATCH;
+	break;
       }
       buf_pos++;
       ref_pos++;
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-buffer.h b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-buffer.h
index ac1d4525a83..d5cb7468618 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-buffer.h
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-buffer.h
@@ -441,11 +441,11 @@ hb_buffer_get_length (hb_buffer_t *buffer);
 
 HB_EXTERN hb_glyph_info_t *
 hb_buffer_get_glyph_infos (hb_buffer_t  *buffer,
-                           unsigned int *length);
+			   unsigned int *length);
 
 HB_EXTERN hb_glyph_position_t *
 hb_buffer_get_glyph_positions (hb_buffer_t  *buffer,
-                               unsigned int *length);
+			       unsigned int *length);
 
 
 HB_EXTERN void
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-cff-interp-dict-common.hh b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-cff-interp-dict-common.hh
index ea0db13f85b..1f03d82399b 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-cff-interp-dict-common.hh
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-cff-interp-dict-common.hh
@@ -94,130 +94,52 @@ struct dict_opset_t : opset_t<number_t>
     }
   }
 
+  /* Turns CFF's BCD format into strtod understandable string */
   static double parse_bcd (byte_str_ref_t& str_ref)
   {
-    bool    neg = false;
-    double  int_part = 0;
-    uint64_t frac_part = 0;
-    uint32_t  frac_count = 0;
-    bool    exp_neg = false;
-    uint32_t  exp_part = 0;
-    bool    exp_overflow = false;
-    enum Part { INT_PART=0, FRAC_PART, EXP_PART } part = INT_PART;
+    if (unlikely (str_ref.in_error ())) return .0;
+
     enum Nibble { DECIMAL=10, EXP_POS, EXP_NEG, RESERVED, NEG, END };
-    const uint64_t MAX_FRACT = 0xFFFFFFFFFFFFFull; /* 1^52-1 */
-    const uint32_t MAX_EXP = 0x7FFu; /* 1^11-1 */
 
-    double  value = 0.0;
+    char buf[32];
     unsigned char byte = 0;
-    for (uint32_t i = 0;; i++)
+    for (unsigned i = 0, count = 0; count < ARRAY_LENGTH (buf); ++i, ++count)
     {
-      char d;
-      if ((i & 1) == 0)
+      unsigned nibble;
+      if (!(i & 1))
       {
-	if (!str_ref.avail ())
-	{
-	  str_ref.set_error ();
-	  return 0.0;
-	}
+	if (unlikely (!str_ref.avail ())) break;
+
 	byte = str_ref[0];
 	str_ref.inc ();
-	d = byte >> 4;
+	nibble = byte >> 4;
       }
       else
-	d = byte & 0x0F;
+	nibble = byte & 0x0F;
 
-      switch (d)
+      if (unlikely (nibble == RESERVED)) break;
+      else if (nibble == END)
       {
-	case RESERVED:
-	  str_ref.set_error ();
-	  return value;
-
-	case END:
-	  value = (double) (neg ? -int_part : int_part);
-	  if (frac_count > 0)
-	  {
-	    double frac = (frac_part / pow (10.0, (double) frac_count));
-	    if (neg) frac = -frac;
-	    value += frac;
-	  }
-	  if (unlikely (exp_overflow))
-	  {
-	    if (value == 0.0)
-	      return value;
-	    if (exp_neg)
-	      return neg ? -DBL_MIN : DBL_MIN;
-	    else
-	      return neg ? -DBL_MAX : DBL_MAX;
-	  }
-	  if (exp_part != 0)
-	  {
-	    if (exp_neg)
-	      value /= pow (10.0, (double) exp_part);
-	    else
-	      value *= pow (10.0, (double) exp_part);
-	  }
-	  return value;
-
-	case NEG:
-	  if (i != 0)
-	  {
-	    str_ref.set_error ();
-	    return 0.0;
-	  }
-	  neg = true;
-	  break;
-
-	case DECIMAL:
-	  if (part != INT_PART)
-	  {
-	    str_ref.set_error ();
-	    return value;
-	  }
-	  part = FRAC_PART;
+	const char *p = buf;
+	double pv;
+	if (unlikely (!hb_parse_double (&p, p + count, &pv, true/* whole buffer */)))
 	  break;
-
-	case EXP_NEG:
-	  exp_neg = true;
-	  HB_FALLTHROUGH;
-
-	case EXP_POS:
-	  if (part == EXP_PART)
-	  {
-	    str_ref.set_error ();
-	    return value;
-	  }
-	  part = EXP_PART;
-	  break;
-
-	default:
-	  switch (part) {
-	    default:
-	    case INT_PART:
-	      int_part = (int_part * 10) + d;
-	      break;
-
-	    case FRAC_PART:
-	      if (likely (frac_part <= MAX_FRACT / 10))
-	      {
-		frac_part = (frac_part * 10) + (unsigned)d;
-		frac_count++;
-	      }
-	      break;
-
-	    case EXP_PART:
-	      if (likely (exp_part * 10 + d <= MAX_EXP))
-	      {
-	      	exp_part = (exp_part * 10) + d;
-	      }
-	      else
-	      	exp_overflow = true;
-	      break;
-	  }
+	return pv;
+      }
+      else
+      {
+	buf[count] = "0123456789.EE?-?"[nibble];
+	if (nibble == EXP_NEG)
+	{
+	  ++count;
+	  if (unlikely (count == ARRAY_LENGTH (buf))) break;
+	  buf[count] = '-';
+	}
       }
     }
 
-    return value;
+    str_ref.set_error ();
+    return .0;
   }
 
   static bool is_hint_op (op_code_t op)
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-common.cc b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-common.cc
index 9035755a4e4..0ae0c05f488 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-common.cc
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-common.cc
@@ -27,13 +27,9 @@
  */
 
 #include "hb.hh"
-
 #include "hb-machinery.hh"
 
 #include <locale.h>
-#ifdef HAVE_XLOCALE_H
-#include <xlocale.h>
-#endif
 
 #ifdef HB_NO_SETLOCALE
 #define setlocale(Category, Locale) "C"
@@ -67,7 +63,7 @@ _hb_options_init ()
     {
       const char *p = strchr (c, ':');
       if (!p)
-        p = c + strlen (c);
+	p = c + strlen (c);
 
 #define OPTION(name, symbol) \
 	if (0 == strncmp (c, name, p - c) && strlen (name) == static_cast<size_t>(p - c)) do { u.opts.symbol = true; } while (0)
@@ -385,7 +381,8 @@ hb_language_from_string (const char *str, int len)
 const char *
 hb_language_to_string (hb_language_t language)
 {
-  /* This is actually nullptr-safe! */
+  if (unlikely (!language)) return nullptr;
+
   return language->s;
 }
 
@@ -722,131 +719,24 @@ parse_char (const char **pp, const char *end, char c)
 static bool
 parse_uint (const char **pp, const char *end, unsigned int *pv)
 {
-  char buf[32];
-  unsigned int len = hb_min (ARRAY_LENGTH (buf) - 1, (unsigned int) (end - *pp));
-  strncpy (buf, *pp, len);
-  buf[len] = '\0';
-
-  char *p = buf;
-  char *pend = p;
-  unsigned int v;
-
-  /* Intentionally use strtol instead of strtoul, such that
-   * -1 turns into "big number"... */
-  errno = 0;
-  v = strtol (p, &pend, 10);
-  if (errno || p == pend)
-    return false;
+  /* Intentionally use hb_parse_int inside instead of hb_parse_uint,
+   * such that -1 turns into "big number"... */
+  int v;
+  if (unlikely (!hb_parse_int (pp, end, &v))) return false;
 
   *pv = v;
-  *pp += pend - p;
   return true;
 }
 
 static bool
 parse_uint32 (const char **pp, const char *end, uint32_t *pv)
 {
-  char buf[32];
-  unsigned int len = hb_min (ARRAY_LENGTH (buf) - 1, (unsigned int) (end - *pp));
-  strncpy (buf, *pp, len);
-  buf[len] = '\0';
-
-  char *p = buf;
-  char *pend = p;
-  unsigned int v;
-
-  /* Intentionally use strtol instead of strtoul, such that
-   * -1 turns into "big number"... */
-  errno = 0;
-  v = strtol (p, &pend, 10);
-  if (errno || p == pend)
-    return false;
-
-  *pv = v;
-  *pp += pend - p;
-  return true;
-}
-
-#if defined (HAVE_NEWLOCALE) && defined (HAVE_STRTOD_L)
-#define USE_XLOCALE 1
-#define HB_LOCALE_T locale_t
-#define HB_CREATE_LOCALE(locName) newlocale (LC_ALL_MASK, locName, nullptr)
-#define HB_FREE_LOCALE(loc) freelocale (loc)
-#elif defined(_MSC_VER)
-#define USE_XLOCALE 1
-#define HB_LOCALE_T _locale_t
-#define HB_CREATE_LOCALE(locName) _create_locale (LC_ALL, locName)
-#define HB_FREE_LOCALE(loc) _free_locale (loc)
-#define strtod_l(a, b, c) _strtod_l ((a), (b), (c))
-#endif
-
-#ifdef USE_XLOCALE
-
-#if HB_USE_ATEXIT
-static void free_static_C_locale ();
-#endif
-
-static struct hb_C_locale_lazy_loader_t : hb_lazy_loader_t<hb_remove_pointer<HB_LOCALE_T>,
-							  hb_C_locale_lazy_loader_t>
-{
-  static HB_LOCALE_T create ()
-  {
-    HB_LOCALE_T C_locale = HB_CREATE_LOCALE ("C");
-
-#if HB_USE_ATEXIT
-    atexit (free_static_C_locale);
-#endif
-
-    return C_locale;
-  }
-  static void destroy (HB_LOCALE_T p)
-  {
-    HB_FREE_LOCALE (p);
-  }
-  static HB_LOCALE_T get_null ()
-  {
-    return nullptr;
-  }
-} static_C_locale;
-
-#if HB_USE_ATEXIT
-static
-void free_static_C_locale ()
-{
-  static_C_locale.free_instance ();
-}
-#endif
-
-static HB_LOCALE_T
-get_C_locale ()
-{
-  return static_C_locale.get_unconst ();
-}
-#endif /* USE_XLOCALE */
-
-static bool
-parse_float (const char **pp, const char *end, float *pv)
-{
-  char buf[32];
-  unsigned int len = hb_min (ARRAY_LENGTH (buf) - 1, (unsigned int) (end - *pp));
-  strncpy (buf, *pp, len);
-  buf[len] = '\0';
-
-  char *p = buf;
-  char *pend = p;
-  float v;
-
-  errno = 0;
-#ifdef USE_XLOCALE
-  v = strtod_l (p, &pend, get_C_locale ());
-#else
-  v = strtod (p, &pend);
-#endif
-  if (errno || p == pend)
-    return false;
+  /* Intentionally use hb_parse_int inside instead of hb_parse_uint,
+   * such that -1 turns into "big number"... */
+  int v;
+  if (unlikely (!hb_parse_int (pp, end, &v))) return false;
 
   *pv = v;
-  *pp += pend - p;
   return true;
 }
 
@@ -956,7 +846,7 @@ parse_feature_value_postfix (const char **pp, const char *end, hb_feature_t *fea
 {
   bool had_equal = parse_char (pp, end, '=');
   bool had_value = parse_uint32 (pp, end, &feature->value) ||
-                   parse_bool (pp, end, &feature->value);
+		   parse_bool (pp, end, &feature->value);
   /* CSS doesn't use equal-sign between tag and value.
    * If there was an equal-sign, then there *must* be a value.
    * A value without an equal-sign is ok, but not required. */
@@ -1099,7 +989,11 @@ static bool
 parse_variation_value (const char **pp, const char *end, hb_variation_t *variation)
 {
   parse_char (pp, end, '='); /* Optional. */
-  return parse_float (pp, end, &variation->value);
+  double v;
+  if (unlikely (!hb_parse_double (pp, end, &v))) return false;
+
+  variation->value = v;
+  return true;
 }
 
 static bool
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-common.h b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-common.h
index edd9ffb86a4..9f1764bdc83 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-common.h
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-common.h
@@ -63,6 +63,8 @@ typedef __int32 int32_t;
 typedef unsigned __int32 uint32_t;
 typedef __int64 int64_t;
 typedef unsigned __int64 uint64_t;
+#elif defined (__KERNEL__)
+#  include <linux/types.h>
 #else
 #  include <stdint.h>
 #endif
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-config.hh b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-config.hh
index b6db206a34c..14c5395952b 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-config.hh
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-config.hh
@@ -58,6 +58,7 @@
 #define HB_NO_BITMAP
 #define HB_NO_CFF
 #define HB_NO_COLOR
+#define HB_NO_ERRNO
 #define HB_NO_FACE_COLLECT_UNICODES
 #define HB_NO_GETENV
 #define HB_NO_HINTING
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-coretext.cc b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-coretext.cc
index 31aa00a1110..8885cfe7304 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-coretext.cc
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-coretext.cc
@@ -111,7 +111,7 @@ static void
 release_data (void *info, const void *data, size_t size)
 {
   assert (hb_blob_get_length ((hb_blob_t *) info) == size &&
-          hb_blob_get_data ((hb_blob_t *) info, nullptr) == data);
+	  hb_blob_get_data ((hb_blob_t *) info, nullptr) == data);
 
   hb_blob_destroy ((hb_blob_t *) info);
 }
@@ -233,21 +233,21 @@ create_ct_font (CGFontRef cg_font, CGFloat font_size)
       atsFont = CTFontGetPlatformFont (new_ct_font, NULL);
       status = ATSFontGetFileReference (atsFont, &fsref);
       if (status == noErr)
-        new_url = CFURLCreateFromFSRef (NULL, &fsref);
+	new_url = CFURLCreateFromFSRef (NULL, &fsref);
 #else
       new_url = (CFURLRef) CTFontCopyAttribute (new_ct_font, kCTFontURLAttribute);
 #endif
       // Keep reconfigured font if URL cannot be retrieved (seems to be the case
       // on Mac OS 10.12 Sierra), speculative fix for crbug.com/625606
       if (!original_url || !new_url || CFEqual (original_url, new_url)) {
-        CFRelease (ct_font);
-        ct_font = new_ct_font;
+	CFRelease (ct_font);
+	ct_font = new_ct_font;
       } else {
-        CFRelease (new_ct_font);
-        DEBUG_MSG (CORETEXT, ct_font, "Discarding reconfigured CTFont, location changed.");
+	CFRelease (new_ct_font);
+	DEBUG_MSG (CORETEXT, ct_font, "Discarding reconfigured CTFont, location changed.");
       }
       if (new_url)
-        CFRelease (new_url);
+	CFRelease (new_url);
     }
     else
       DEBUG_MSG (CORETEXT, ct_font, "Font copy with empty cascade list failed");
@@ -302,7 +302,7 @@ _hb_coretext_shaper_font_data_create (hb_font_t *font)
   if (unlikely (!face_data)) return nullptr;
   CGFontRef cg_font = (CGFontRef) (const void *) face->data.coretext;
 
-  CGFloat font_size = font->ptem <= 0.f ? HB_CORETEXT_DEFAULT_FONT_SIZE : font->ptem;
+  CGFloat font_size = (CGFloat) (font->ptem <= 0.f ? HB_CORETEXT_DEFAULT_FONT_SIZE : font->ptem);
   CTFontRef ct_font = create_ct_font (cg_font, font_size);
 
   if (unlikely (!ct_font))
@@ -327,7 +327,7 @@ retry:
   const hb_coretext_font_data_t *data = font->data.coretext;
   if (unlikely (!data)) return nullptr;
 
-  if (fabs (CTFontGetSize ((CTFontRef) data) - font->ptem) > .5)
+  if (fabs (CTFontGetSize ((CTFontRef) data) - (CGFloat) font->ptem) > .5)
   {
     /* XXX-MT-bug
      * Note that evaluating condition above can be dangerous if another thread
@@ -433,9 +433,9 @@ struct range_record_t {
 hb_bool_t
 _hb_coretext_shape (hb_shape_plan_t    *shape_plan,
 		    hb_font_t          *font,
-                    hb_buffer_t        *buffer,
-                    const hb_feature_t *features,
-                    unsigned int        num_features)
+		    hb_buffer_t        *buffer,
+		    const hb_feature_t *features,
+		    unsigned int        num_features)
 {
   hb_face_t *face = font->face;
   CGFontRef cg_font = (CGFontRef) (const void *) face->data.coretext;
@@ -477,7 +477,7 @@ _hb_coretext_shape (hb_shape_plan_t    *shape_plan,
     {
       const hb_aat_feature_mapping_t * mapping = hb_aat_layout_find_feature_mapping (features[i].tag);
       if (!mapping)
-        continue;
+	continue;
 
       active_feature_t feature;
       feature.rec.feature = mapping->aatFeatureType;
@@ -519,7 +519,7 @@ _hb_coretext_shape (hb_shape_plan_t    *shape_plan,
 
       if (event->index != last_index)
       {
-        /* Save a snapshot of active features and the range. */
+	/* Save a snapshot of active features and the range. */
 	range_record_t *range = range_records.push ();
 
 	if (active_features.length)
@@ -580,9 +580,9 @@ _hb_coretext_shape (hb_shape_plan_t    *shape_plan,
 
       if (event->start)
       {
-        active_features.push (event->feature);
+	active_features.push (event->feature);
       } else {
-        active_feature_t *feature = active_features.find (&event->feature);
+	active_feature_t *feature = active_features.find (&event->feature);
 	if (feature)
 	  active_features.remove (feature - active_features.arrayZ);
       }
@@ -700,15 +700,15 @@ resize_and_retry:
 #if !(defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE) && MAC_OS_X_VERSION_MIN_REQUIRED < 1090
 #  define kCTLanguageAttributeName CFSTR ("NSLanguage")
 #endif
-        CFStringRef lang = CFStringCreateWithCStringNoCopy (kCFAllocatorDefault,
+	CFStringRef lang = CFStringCreateWithCStringNoCopy (kCFAllocatorDefault,
 							    hb_language_to_string (buffer->props.language),
 							    kCFStringEncodingUTF8,
 							    kCFAllocatorNull);
 	if (unlikely (!lang))
-        {
+	{
 	  CFRelease (attr_string);
 	  FAIL ("CFStringCreateWithCStringNoCopy failed");
-        }
+	}
 	CFAttributedStringSetAttribute (attr_string, CFRangeMake (0, chars_len),
 					kCTLanguageAttributeName, lang);
 	CFRelease (lang);
@@ -757,7 +757,7 @@ resize_and_retry:
 	      feature.start < chars_len && feature.start < feature.end)
 	  {
 	    CFRange feature_range = CFRangeMake (feature.start,
-	                                         hb_min (feature.end, chars_len) - feature.start);
+						 hb_min (feature.end, chars_len) - feature.start);
 	    if (feature.value)
 	      CFAttributedStringRemoveAttribute (attr_string, feature_range, kCTKernAttributeName);
 	    else
@@ -781,8 +781,8 @@ resize_and_retry:
       CFRelease (level_number);
       if (unlikely (!options))
       {
-        CFRelease (attr_string);
-        FAIL ("CFDictionaryCreate failed");
+	CFRelease (attr_string);
+	FAIL ("CFDictionaryCreate failed");
       }
 
       CTTypesetterRef typesetter = CTTypesetterCreateWithAttributedStringAndOptions (attr_string, options);
@@ -893,7 +893,7 @@ resize_and_retry:
 	if (!matched)
 	{
 	  CFRange range = CTRunGetStringRange (run);
-          DEBUG_MSG (CORETEXT, run, "Run used fallback font: %ld..%ld",
+	  DEBUG_MSG (CORETEXT, run, "Run used fallback font: %ld..%ld",
 		     range.location, range.location + range.length);
 	  if (!buffer->ensure_inplace (buffer->len + range.length))
 	    goto resize_and_retry;
@@ -921,7 +921,7 @@ resize_and_retry:
 		  continue;
 	      }
 	      if (buffer->unicode->is_default_ignorable (ch))
-	        continue;
+		continue;
 
 	      info->codepoint = notdef;
 	      info->cluster = log_clusters[j];
@@ -966,7 +966,7 @@ resize_and_retry:
   scratch = scratch_saved
 
       { /* Setup glyphs */
-        SCRATCH_SAVE();
+	SCRATCH_SAVE();
 	const CGGlyph* glyphs = USE_PTR ? CTRunGetGlyphsPtr (run) : nullptr;
 	if (!glyphs) {
 	  ALLOCATE_ARRAY (CGGlyph, glyph_buf, num_glyphs, goto resize_and_retry);
@@ -989,12 +989,12 @@ resize_and_retry:
 	SCRATCH_RESTORE();
       }
       {
-        /* Setup positions.
+	/* Setup positions.
 	 * Note that CoreText does not return advances for glyphs.  As such,
 	 * for all but last glyph, we use the delta position to next glyph as
 	 * advance (in the advance direction only), and for last glyph we set
 	 * whatever is needed to make the whole run's advance add up. */
-        SCRATCH_SAVE();
+	SCRATCH_SAVE();
 	const CGPoint* positions = USE_PTR ? CTRunGetPositionsPtr (run) : nullptr;
 	if (!positions) {
 	  ALLOCATE_ARRAY (CGPoint, position_buf, num_glyphs, goto resize_and_retry);
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-debug.hh b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-debug.hh
index e6d06e3102b..a7e52c8cbe2 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-debug.hh
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-debug.hh
@@ -296,22 +296,23 @@ struct hb_auto_trace_t
     if (plevel) --*plevel;
   }
 
-  ret_t ret (ret_t v,
-	     const char *func = "",
-	     unsigned int line = 0)
+  template <typename T>
+  T ret (T&& v,
+	 const char *func = "",
+	 unsigned int line = 0)
   {
     if (unlikely (returned)) {
       fprintf (stderr, "OUCH, double calls to return_trace().  This is a bug, please report.\n");
-      return v;
+      return hb_forward<T> (v);
     }
 
     _hb_debug_msg<max_level> (what, obj, func, true, plevel ? *plevel : 1, -1,
 			      "return %s (line %d)",
-			      hb_printer_t<ret_t>().print (v), line);
+			      hb_printer_t<decltype (v)>().print (v), line);
     if (plevel) --*plevel;
     plevel = nullptr;
     returned = true;
-    return v;
+    return hb_forward<T> (v);
   }
 
   private:
@@ -413,7 +414,7 @@ struct hb_no_trace_t {
 #define TRACE_SANITIZE(this) \
 	hb_auto_trace_t<HB_DEBUG_SANITIZE, bool> trace \
 	(&c->debug_depth, c->get_name (), this, HB_FUNC, \
-	 " ");
+	 " ")
 #else
 #define TRACE_SANITIZE(this) hb_no_trace_t<bool> trace
 #endif
@@ -425,7 +426,7 @@ struct hb_no_trace_t {
 #define TRACE_SERIALIZE(this) \
 	hb_auto_trace_t<HB_DEBUG_SERIALIZE, bool> trace \
 	(&c->debug_depth, "SERIALIZE", c, HB_FUNC, \
-	 " ");
+	 " ")
 #else
 #define TRACE_SERIALIZE(this) hb_no_trace_t<bool> trace
 #endif
@@ -437,7 +438,7 @@ struct hb_no_trace_t {
 #define TRACE_SUBSET(this) \
   hb_auto_trace_t<HB_DEBUG_SUBSET, bool> trace \
   (&c->debug_depth, c->get_name (), this, HB_FUNC, \
-   " ");
+   " ")
 #else
 #define TRACE_SUBSET(this) hb_no_trace_t<bool> trace
 #endif
@@ -454,7 +455,7 @@ struct hb_no_trace_t {
 #define TRACE_DISPATCH(this, format) \
 	hb_auto_trace_t<context_t::max_debug_depth, typename context_t::return_t> trace \
 	(&c->debug_depth, c->get_name (), this, HB_FUNC, \
-	 "format %d", (int) format);
+	 "format %d", (int) format)
 #else
 #define TRACE_DISPATCH(this, format) hb_no_trace_t<typename context_t::return_t> trace
 #endif
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-directwrite.cc b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-directwrite.cc
index a079563af48..efb2029ec0c 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-directwrite.cc
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-directwrite.cc
@@ -625,7 +625,7 @@ _hb_directwrite_shape_full (hb_shape_plan_t    *shape_plan,
   HB_STMT_START { \
     DEBUG_MSG (DIRECTWRITE, nullptr, __VA_ARGS__); \
     return false; \
-  } HB_STMT_END;
+  } HB_STMT_END
 
   if (FAILED (hr))
     FAIL ("Analyzer failed to generate results.");
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-dispatch.hh b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-dispatch.hh
index be4a90f4f39..1ce3fac9364 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-dispatch.hh
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-dispatch.hh
@@ -41,7 +41,7 @@ struct hb_dispatch_context_t
   private:
   /* https://en.wikipedia.org/wiki/Curiously_recurring_template_pattern */
   const Context* thiz () const { return static_cast<const Context *> (this); }
-        Context* thiz ()       { return static_cast<      Context *> (this); }
+	Context* thiz ()       { return static_cast<      Context *> (this); }
   public:
   static constexpr unsigned max_debug_depth = MaxDebugDepth;
   typedef Return return_t;
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-face.cc b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-face.cc
index 1098adb33eb..0c9949fff19 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-face.cc
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-face.cc
@@ -367,6 +367,9 @@ hb_blob_t *
 hb_face_reference_table (const hb_face_t *face,
 			 hb_tag_t tag)
 {
+  if (unlikely (tag == HB_TAG_NONE))
+    return hb_blob_get_empty ();
+
   return face->reference_table (tag);
 }
 
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-font.cc b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-font.cc
index 445878bfe40..ee35966c1cc 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-font.cc
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-font.cc
@@ -667,22 +667,22 @@ hb_font_funcs_is_immutable (hb_font_funcs_t *ffuncs)
 
 
 #define HB_FONT_FUNC_IMPLEMENT(name) \
-                                                                         \
+									 \
 void                                                                     \
 hb_font_funcs_set_##name##_func (hb_font_funcs_t             *ffuncs,    \
-                                 hb_font_get_##name##_func_t  func,      \
-                                 void                        *user_data, \
-                                 hb_destroy_func_t            destroy)   \
+				 hb_font_get_##name##_func_t  func,      \
+				 void                        *user_data, \
+				 hb_destroy_func_t            destroy)   \
 {                                                                        \
   if (hb_object_is_immutable (ffuncs)) {                                 \
     if (destroy)                                                         \
       destroy (user_data);                                               \
     return;                                                              \
   }                                                                      \
-                                                                         \
+									 \
   if (ffuncs->destroy.name)                                              \
     ffuncs->destroy.name (ffuncs->user_data.name);                       \
-                                                                         \
+									 \
   if (func) {                                                            \
     ffuncs->get.f.name = func;                                           \
     ffuncs->user_data.name = user_data;                                  \
@@ -1676,8 +1676,8 @@ hb_font_set_funcs (hb_font_t         *font,
  **/
 void
 hb_font_set_funcs_data (hb_font_t         *font,
-		        void              *font_data,
-		        hb_destroy_func_t  destroy)
+			void              *font_data,
+			hb_destroy_func_t  destroy)
 {
   /* Destroy user_data? */
   if (hb_object_is_immutable (font))
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ft.cc b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ft.cc
index 2d7f2b959b9..e526bf40d56 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ft.cc
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ft.cc
@@ -471,7 +471,7 @@ hb_ft_get_glyph_from_name (hb_font_t *font HB_UNUSED,
     /* Check whether the given name was actually the name of glyph 0. */
     char buf[128];
     if (!FT_Get_Glyph_Name(ft_face, 0, buf, sizeof (buf)) &&
-        len < 0 ? !strcmp (buf, name) : !strncmp (buf, name, len))
+	len < 0 ? !strcmp (buf, name) : !strncmp (buf, name, len))
       return true;
   }
 
@@ -840,8 +840,8 @@ hb_ft_font_set_funcs (hb_font_t *font)
     return;
   }
 
-  if (FT_Select_Charmap (ft_face, FT_ENCODING_UNICODE))
-    FT_Select_Charmap (ft_face, FT_ENCODING_MS_SYMBOL);
+  if (FT_Select_Charmap (ft_face, FT_ENCODING_MS_SYMBOL))
+    FT_Select_Charmap (ft_face, FT_ENCODING_UNICODE);
 
   FT_Set_Char_Size (ft_face,
 		    abs (font->x_scale), abs (font->y_scale),
@@ -866,7 +866,7 @@ hb_ft_font_set_funcs (hb_font_t *font)
     if (ft_coords)
     {
       for (unsigned int i = 0; i < num_coords; i++)
-	ft_coords[i] = coords[i] << 2;
+	ft_coords[i] = coords[i] * 4;
       FT_Set_Var_Blend_Coordinates (ft_face, num_coords, ft_coords);
       free (ft_coords);
     }
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-gdi.cc b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-gdi.cc
index d55085cb442..f6306ef89fa 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-gdi.cc
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-gdi.cc
@@ -58,7 +58,7 @@ fail:
 
 /**
  * hb_gdi_face_create:
- * @hdc: a HFONT object.
+ * @hfont: a HFONT object.
  *
  * Return value: #hb_face_t object corresponding to the given input
  *
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-graphite2.cc b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-graphite2.cc
index 40ac9061ff2..f0f2f8c7361 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-graphite2.cc
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-graphite2.cc
@@ -340,14 +340,14 @@ _hb_graphite2_shape (hb_shape_plan_t    *shape_plan HB_UNUSED,
       c->num_glyphs = 0;
       if (HB_DIRECTION_IS_BACKWARD(buffer->props.direction))
       {
-        c->advance = curradv - gr_slot_origin_X(is) * xscale;
-        curradv -= c->advance;
+	c->advance = curradv - gr_slot_origin_X(is) * xscale;
+	curradv -= c->advance;
       }
       else
       {
-        c->advance = 0;
-        clusters[ci].advance += gr_slot_origin_X(is) * xscale - curradv;
-        curradv += clusters[ci].advance;
+	c->advance = 0;
+	clusters[ci].advance += gr_slot_origin_X(is) * xscale - curradv;
+	curradv += clusters[ci].advance;
       }
       ci++;
     }
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-icu.cc b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-icu.cc
index e98908de743..985ff02dcdf 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-icu.cc
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-icu.cc
@@ -41,6 +41,12 @@
 #include <unicode/utf16.h>
 #include <unicode/uversion.h>
 
+/* ICU extra semicolon, fixed since 65, https://github.com/unicode-org/icu/commit/480bec3 */
+#if U_ICU_VERSION_MAJOR_NUM < 65 && (defined(__GNUC__) || defined(__clang__))
+#define HB_ICU_EXTRA_SEMI_IGNORED
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wextra-semi-stmt"
+#endif
 
 /**
  * SECTION:hb-icu
@@ -51,10 +57,6 @@
  * Functions for using HarfBuzz with the ICU library to provide Unicode data.
  **/
 
-/* ICU doesn't do-while(0) around their statements.  Ugh!
- * https://unicode-org.atlassian.net/browse/CLDR-13027 */
-#define HB_ICU_STMT(S) do { S } while (0)
-
 hb_script_t
 hb_icu_script_to_script (UScriptCode script)
 {
@@ -188,9 +190,9 @@ hb_icu_unicode_compose (hb_unicode_funcs_t *ufuncs HB_UNUSED,
 
   len = 0;
   err = false;
-  HB_ICU_STMT (U16_APPEND (utf16, len, ARRAY_LENGTH (utf16), a, err));
+  U16_APPEND (utf16, len, ARRAY_LENGTH (utf16), a, err);
   if (err) return false;
-  HB_ICU_STMT (U16_APPEND (utf16, len, ARRAY_LENGTH (utf16), b, err));
+  U16_APPEND (utf16, len, ARRAY_LENGTH (utf16), b, err);
   if (err) return false;
 
   icu_err = U_ZERO_ERROR;
@@ -198,7 +200,7 @@ hb_icu_unicode_compose (hb_unicode_funcs_t *ufuncs HB_UNUSED,
   if (U_FAILURE (icu_err))
     return false;
   if (u_countChar32 (normalized, len) == 1) {
-    HB_ICU_STMT (U16_GET_UNSAFE (normalized, 0, *ab));
+    U16_GET_UNSAFE (normalized, 0, *ab);
     ret = true;
   } else {
     ret = false;
@@ -226,13 +228,13 @@ hb_icu_unicode_decompose (hb_unicode_funcs_t *ufuncs HB_UNUSED,
 
     len = u_countChar32 (decomposed, len);
     if (len == 1) {
-      HB_ICU_STMT (U16_GET_UNSAFE (decomposed, 0, *a));
+      U16_GET_UNSAFE (decomposed, 0, *a);
       *b = 0;
       return *a != ab;
     } else if (len == 2) {
-      len =0;
-      HB_ICU_STMT (U16_NEXT_UNSAFE (decomposed, len, *a));
-      HB_ICU_STMT (U16_NEXT_UNSAFE (decomposed, len, *b));
+      len = 0;
+      U16_NEXT_UNSAFE (decomposed, len, *a);
+      U16_NEXT_UNSAFE (decomposed, len, *b);
     }
     return true;
   }
@@ -252,7 +254,7 @@ hb_icu_unicode_decompose (hb_unicode_funcs_t *ufuncs HB_UNUSED,
 
   len = 0;
   err = false;
-  HB_ICU_STMT (U16_APPEND (utf16, len, ARRAY_LENGTH (utf16), ab, err));
+  U16_APPEND (utf16, len, ARRAY_LENGTH (utf16), ab, err);
   if (err) return false;
 
   icu_err = U_ZERO_ERROR;
@@ -263,13 +265,13 @@ hb_icu_unicode_decompose (hb_unicode_funcs_t *ufuncs HB_UNUSED,
   len = u_countChar32 (normalized, len);
 
   if (len == 1) {
-    HB_ICU_STMT (U16_GET_UNSAFE (normalized, 0, *a));
+    U16_GET_UNSAFE (normalized, 0, *a);
     *b = 0;
     ret = *a != ab;
   } else if (len == 2) {
-    len =0;
-    HB_ICU_STMT (U16_NEXT_UNSAFE (normalized, len, *a));
-    HB_ICU_STMT (U16_NEXT_UNSAFE (normalized, len, *b));
+    len = 0;
+    U16_NEXT_UNSAFE (normalized, len, *a);
+    U16_NEXT_UNSAFE (normalized, len, *b);
 
     /* Here's the ugly part: if ab decomposes to a single character and
      * that character decomposes again, we have to detect that and undo
@@ -280,7 +282,7 @@ hb_icu_unicode_decompose (hb_unicode_funcs_t *ufuncs HB_UNUSED,
     if (U_FAILURE (icu_err))
       return false;
     hb_codepoint_t c;
-    HB_ICU_STMT (U16_GET_UNSAFE (recomposed, 0, c));
+    U16_GET_UNSAFE (recomposed, 0, c);
     if (c != *a && c != ab) {
       *a = c;
       *b = 0;
@@ -289,7 +291,7 @@ hb_icu_unicode_decompose (hb_unicode_funcs_t *ufuncs HB_UNUSED,
   } else {
     /* If decomposed to more than two characters, take the last one,
      * and recompose the rest to get the first component. */
-    HB_ICU_STMT (U16_PREV_UNSAFE (normalized, len, *b)); /* Changes len in-place. */
+    U16_PREV_UNSAFE (normalized, len, *b); /* Changes len in-place. */
     UChar recomposed[18 * 2];
     icu_err = U_ZERO_ERROR;
     len = unorm2_normalize (unorm2_getNFCInstance (&icu_err), normalized, len, recomposed, ARRAY_LENGTH (recomposed), &icu_err);
@@ -298,7 +300,7 @@ hb_icu_unicode_decompose (hb_unicode_funcs_t *ufuncs HB_UNUSED,
     /* We expect that recomposed has exactly one character now. */
     if (unlikely (u_countChar32 (recomposed, len) != 1))
       return false;
-    HB_ICU_STMT (U16_GET_UNSAFE (recomposed, 0, *a));
+    U16_GET_UNSAFE (recomposed, 0, *a);
     ret = true;
   }
 
@@ -354,5 +356,8 @@ hb_icu_get_unicode_funcs ()
   return static_icu_funcs.get_unconst ();
 }
 
+#ifdef HB_ICU_EXTRA_SEMI_IGNORED
+#pragma GCC diagnostic pop
+#endif
 
 #endif
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-iter.hh b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-iter.hh
index 8d2ff80c218..981c5c218c4 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-iter.hh
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-iter.hh
@@ -64,7 +64,7 @@ template <typename iter_t, typename Item = typename iter_t::__item_t__>
 struct hb_iter_t
 {
   typedef Item item_t;
-  static constexpr unsigned item_size = hb_static_size (Item);
+  constexpr unsigned get_item_size () const { return hb_static_size (Item); }
   static constexpr bool is_iterator = true;
   static constexpr bool is_random_access_iterator = false;
   static constexpr bool is_sorted_iterator = false;
@@ -72,7 +72,7 @@ struct hb_iter_t
   private:
   /* https://en.wikipedia.org/wiki/Curiously_recurring_template_pattern */
   const iter_t* thiz () const { return static_cast<const iter_t *> (this); }
-        iter_t* thiz ()       { return static_cast<      iter_t *> (this); }
+	iter_t* thiz ()       { return static_cast<      iter_t *> (this); }
   public:
 
   /* TODO:
@@ -130,7 +130,7 @@ struct hb_iter_t
   using item_t = typename Name::item_t; \
   using Name::begin; \
   using Name::end; \
-  using Name::item_size; \
+  using Name::get_item_size; \
   using Name::is_iterator; \
   using Name::iter; \
   using Name::operator bool; \
@@ -156,6 +156,7 @@ using hb_item_type = decltype (*hb_deref (hb_declval (Iterable)).iter ());
 
 
 template <typename> struct hb_array_t;
+template <typename> struct hb_sorted_array_t;
 
 struct
 {
@@ -175,6 +176,14 @@ struct
 
 }
 HB_FUNCOBJ (hb_iter);
+struct
+{
+  template <typename T> unsigned
+  operator () (T&& c) const
+  { return c.len (); }
+
+}
+HB_FUNCOBJ (hb_len);
 
 /* Mixin to fill in what the subclass doesn't provide. */
 template <typename iter_t, typename item_t = typename iter_t::__item_t__>
@@ -183,7 +192,7 @@ struct hb_iter_fallback_mixin_t
   private:
   /* https://en.wikipedia.org/wiki/Curiously_recurring_template_pattern */
   const iter_t* thiz () const { return static_cast<const iter_t *> (this); }
-        iter_t* thiz ()       { return static_cast<      iter_t *> (this); }
+	iter_t* thiz ()       { return static_cast<      iter_t *> (this); }
   public:
 
   /* Access: Implement __item__(), or __item_at__() if random-access. */
@@ -563,7 +572,7 @@ struct hb_zip_iter_t :
   B b;
 };
 struct
-{
+{ HB_PARTIALIZE(2);
   template <typename A, typename B,
 	    hb_requires (hb_is_iterable (A) && hb_is_iterable (B))>
   hb_zip_iter_t<hb_iter_type<A>, hb_iter_type<B>>
@@ -602,18 +611,18 @@ struct
 }
 HB_FUNCOBJ (hb_apply);
 
-/* hb_iota()/hb_range() */
+/* hb_range()/hb_iota()/hb_repeat() */
 
 template <typename T, typename S>
-struct hb_counter_iter_t :
-  hb_iter_t<hb_counter_iter_t<T, S>, T>
+struct hb_range_iter_t :
+  hb_iter_t<hb_range_iter_t<T, S>, T>
 {
-  hb_counter_iter_t (T start, T end_, S step) : v (start), end_ (end_for (start, end_, step)), step (step) {}
+  hb_range_iter_t (T start, T end_, S step) : v (start), end_ (end_for (start, end_, step)), step (step) {}
 
   typedef T __item_t__;
   static constexpr bool is_random_access_iterator = true;
   static constexpr bool is_sorted_iterator = true;
-  __item_t__ __item__ () const { return +v; }
+  __item_t__ __item__ () const { return hb_ridentity (v); }
   __item_t__ __item_at__ (unsigned j) const { return v + j * step; }
   bool __more__ () const { return v != end_; }
   unsigned __len__ () const { return !step ? UINT_MAX : (end_ - v) / step; }
@@ -621,8 +630,8 @@ struct hb_counter_iter_t :
   void __forward__ (unsigned n) { v += n * step; }
   void __prev__ () { v -= step; }
   void __rewind__ (unsigned n) { v -= n * step; }
-  hb_counter_iter_t __end__ () const { return hb_counter_iter_t (end_, end_, step); }
-  bool operator != (const hb_counter_iter_t& o) const
+  hb_range_iter_t __end__ () const { return hb_range_iter_t (end_, end_, step); }
+  bool operator != (const hb_range_iter_t& o) const
   { return v != o.v; }
 
   private:
@@ -644,24 +653,91 @@ struct hb_counter_iter_t :
 };
 struct
 {
-  template <typename T = unsigned, typename S = unsigned> hb_counter_iter_t<T, S>
-  operator () (T start = 0u, S&& step = 1u) const
-  { return hb_counter_iter_t<T, S> (start, step >= 0 ? hb_int_max (T) : hb_int_min (T), step); }
+  template <typename T = unsigned> hb_range_iter_t<T, unsigned>
+  operator () (T end = (unsigned) -1) const
+  { return hb_range_iter_t<T, unsigned> (0, end, 1u); }
+
+  template <typename T, typename S = unsigned> hb_range_iter_t<T, S>
+  operator () (T start, T end, S step = 1u) const
+  { return hb_range_iter_t<T, S> (start, end, step); }
 }
-HB_FUNCOBJ (hb_iota);
+HB_FUNCOBJ (hb_range);
+
+template <typename T, typename S>
+struct hb_iota_iter_t :
+  hb_iter_with_fallback_t<hb_iota_iter_t<T, S>, T>
+{
+  hb_iota_iter_t (T start, S step) : v (start), step (step) {}
+
+  private:
+
+  template <typename S2 = S>
+  auto
+  inc (hb_type_identity<S2> s, hb_priority<1>)
+    -> hb_void_t<decltype (hb_invoke (hb_forward<S2> (s), hb_declval<T&> ()))>
+  { v = hb_invoke (hb_forward<S2> (s), v); }
+
+  void
+  inc (S s, hb_priority<0>)
+  { v += s; }
+
+  public:
+
+  typedef T __item_t__;
+  static constexpr bool is_random_access_iterator = true;
+  static constexpr bool is_sorted_iterator = true;
+  __item_t__ __item__ () const { return hb_ridentity (v); }
+  bool __more__ () const { return true; }
+  unsigned __len__ () const { return UINT_MAX; }
+  void __next__ () { inc (step, hb_prioritize); }
+  void __prev__ () { v -= step; }
+  hb_iota_iter_t __end__ () const { return *this; }
+  bool operator != (const hb_iota_iter_t& o) const { return true; }
+
+  private:
+  T v;
+  S step;
+};
 struct
 {
-  template <typename T = unsigned> hb_counter_iter_t<T, unsigned>
-  operator () (T end = (unsigned) -1) const
-  { return hb_counter_iter_t<T, unsigned> (0, end, 1u); }
+  template <typename T = unsigned, typename S = unsigned> hb_iota_iter_t<T, S>
+  operator () (T start = 0u, S step = 1u) const
+  { return hb_iota_iter_t<T, S> (start, step); }
+}
+HB_FUNCOBJ (hb_iota);
+
+template <typename T>
+struct hb_repeat_iter_t :
+  hb_iter_t<hb_repeat_iter_t<T>, T>
+{
+  hb_repeat_iter_t (T value) : v (value) {}
 
-  template <typename T, typename S = unsigned> hb_counter_iter_t<T, S>
-  operator () (T start, T end, S&& step = 1u) const
-  { return hb_counter_iter_t<T, S> (start, end, step); }
+  typedef T __item_t__;
+  static constexpr bool is_random_access_iterator = true;
+  static constexpr bool is_sorted_iterator = true;
+  __item_t__ __item__ () const { return v; }
+  __item_t__ __item_at__ (unsigned j) const { return v; }
+  bool __more__ () const { return true; }
+  unsigned __len__ () const { return UINT_MAX; }
+  void __next__ () {}
+  void __forward__ (unsigned) {}
+  void __prev__ () {}
+  void __rewind__ (unsigned) {}
+  hb_repeat_iter_t __end__ () const { return *this; }
+  bool operator != (const hb_repeat_iter_t& o) const { return true; }
+
+  private:
+  T v;
+};
+struct
+{
+  template <typename T> hb_repeat_iter_t<T>
+  operator () (T value) const
+  { return hb_repeat_iter_t<T> (value); }
 }
-HB_FUNCOBJ (hb_range);
+HB_FUNCOBJ (hb_repeat);
 
-/* hb_enumerate */
+/* hb_enumerate()/hb_take() */
 
 struct
 {
@@ -673,6 +749,37 @@ struct
 }
 HB_FUNCOBJ (hb_enumerate);
 
+struct
+{ HB_PARTIALIZE(2);
+  template <typename Iterable,
+	    hb_requires (hb_is_iterable (Iterable))>
+  auto operator () (Iterable&& it, unsigned count) const HB_AUTO_RETURN
+  ( hb_zip (hb_range (count), it) | hb_map (hb_second) )
+
+  /* Specialization arrays. */
+
+  template <typename Type> inline hb_array_t<Type>
+  operator () (hb_array_t<Type> array, unsigned count) const
+  { return array.sub_array (0, count); }
+
+  template <typename Type> inline hb_sorted_array_t<Type>
+  operator () (hb_sorted_array_t<Type> array, unsigned count) const
+  { return array.sub_array (0, count); }
+}
+HB_FUNCOBJ (hb_take);
+
+struct
+{ HB_PARTIALIZE(2);
+  template <typename Iter,
+	    hb_requires (hb_is_iterator (Iter))>
+  auto operator () (Iter it, unsigned count) const HB_AUTO_RETURN
+  (
+    + hb_iota (it, hb_add (count))
+    | hb_map (hb_take (count))
+    | hb_take ((hb_len (it) + count - 1) / count)
+  )
+}
+HB_FUNCOBJ (hb_chop);
 
 /* hb_sink() */
 
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-kern.hh b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-kern.hh
index fd5bb9e45ef..99d533c045c 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-kern.hh
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-kern.hh
@@ -82,11 +82,11 @@ struct hb_kern_machine_t
 
 
       if (likely (!kern))
-        goto skip;
+	goto skip;
 
       if (horizontal)
       {
-        if (scale)
+	if (scale)
 	  kern = font->em_scale_x (kern);
 	if (crossStream)
 	{
@@ -104,7 +104,7 @@ struct hb_kern_machine_t
       }
       else
       {
-        if (scale)
+	if (scale)
 	  kern = font->em_scale_y (kern);
 	if (crossStream)
 	{
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-machinery.hh b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-machinery.hh
index 5a2087e4aa9..15535d75bd4 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-machinery.hh
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-machinery.hh
@@ -135,7 +135,7 @@ static inline Type& StructAfter(TObject &X)
 
 #define DEFINE_SIZE_ARRAY(size, array) \
   DEFINE_COMPILES_ASSERTION ((void) (array)[0].static_size) \
-  DEFINE_INSTANCE_ASSERTION (sizeof (*this) == (size) + VAR * sizeof ((array)[0])) \
+  DEFINE_INSTANCE_ASSERTION (sizeof (*this) == (size) + HB_VAR_ARRAY * sizeof ((array)[0])) \
   static constexpr unsigned null_size = (size); \
   static constexpr unsigned min_size = (size)
 
@@ -225,7 +225,7 @@ struct hb_lazy_loader_t : hb_data_wrapper_t<Data, WheresData>
 
       if (unlikely (!cmpexch (nullptr, p)))
       {
-        do_destroy (p);
+	do_destroy (p);
 	goto retry;
       }
     }
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-number-parser.hh b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-number-parser.hh
new file mode 100644
index 00000000000..c78c85097e1
--- /dev/null
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-number-parser.hh
@@ -0,0 +1,240 @@
+
+#line 1 "hb-number-parser.rl"
+/*
+ * Copyright © 2019  Ebrahim Byagowi
+ *
+ *  This is part of HarfBuzz, a text shaping library.
+ *
+ * Permission is hereby granted, without written agreement and without
+ * license or royalty fees, to use, copy, modify, and distribute this
+ * software and its documentation for any purpose, provided that the
+ * above copyright notice and the following two paragraphs appear in
+ * all copies of this software.
+ *
+ * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
+ * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
+ * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
+ * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ *
+ * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
+ * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
+ * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
+ * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
+ *
+ */
+
+#ifndef HB_NUMBER_PARSER_HH
+#define HB_NUMBER_PARSER_HH
+
+#include "hb.hh"
+
+#include <float.h>
+
+
+#line 37 "hb-number-parser.hh"
+static const unsigned char _double_parser_trans_keys[] = {
+	0u, 0u, 43u, 57u, 46u, 57u, 48u, 57u, 43u, 57u, 48u, 57u, 48u, 101u, 48u, 57u, 
+	46u, 101u, 0
+};
+
+static const char _double_parser_key_spans[] = {
+	0, 15, 12, 10, 15, 10, 54, 10, 
+	56
+};
+
+static const unsigned char _double_parser_index_offsets[] = {
+	0, 0, 16, 29, 40, 56, 67, 122, 
+	133
+};
+
+static const char _double_parser_indicies[] = {
+	0, 1, 2, 3, 1, 4, 4, 
+	4, 4, 4, 4, 4, 4, 4, 4, 
+	1, 3, 1, 4, 4, 4, 4, 4, 
+	4, 4, 4, 4, 4, 1, 5, 5, 
+	5, 5, 5, 5, 5, 5, 5, 5, 
+	1, 6, 1, 7, 1, 1, 8, 8, 
+	8, 8, 8, 8, 8, 8, 8, 8, 
+	1, 8, 8, 8, 8, 8, 8, 8, 
+	8, 8, 8, 1, 5, 5, 5, 5, 
+	5, 5, 5, 5, 5, 5, 1, 1, 
+	1, 1, 1, 1, 1, 1, 1, 1, 
+	1, 9, 1, 1, 1, 1, 1, 1, 
+	1, 1, 1, 1, 1, 1, 1, 1, 
+	1, 1, 1, 1, 1, 1, 1, 1, 
+	1, 1, 1, 1, 1, 1, 1, 1, 
+	1, 9, 1, 8, 8, 8, 8, 8, 
+	8, 8, 8, 8, 8, 1, 3, 1, 
+	4, 4, 4, 4, 4, 4, 4, 4, 
+	4, 4, 1, 1, 1, 1, 1, 1, 
+	1, 1, 1, 1, 1, 9, 1, 1, 
+	1, 1, 1, 1, 1, 1, 1, 1, 
+	1, 1, 1, 1, 1, 1, 1, 1, 
+	1, 1, 1, 1, 1, 1, 1, 1, 
+	1, 1, 1, 1, 1, 9, 1, 0
+};
+
+static const char _double_parser_trans_targs[] = {
+	2, 0, 2, 3, 8, 6, 5, 5, 
+	7, 4
+};
+
+static const char _double_parser_trans_actions[] = {
+	0, 0, 1, 0, 2, 3, 0, 4, 
+	5, 0
+};
+
+static const int double_parser_start = 1;
+static const int double_parser_first_final = 6;
+static const int double_parser_error = 0;
+
+static const int double_parser_en_main = 1;
+
+
+#line 70 "hb-number-parser.rl"
+
+
+/* Works only for n < 512 */
+static inline double
+_pow10 (unsigned int exponent)
+{
+  static const double _powers_of_10[] =
+  {
+    1.0e+256,
+    1.0e+128,
+    1.0e+64,
+    1.0e+32,
+    1.0e+16,
+    1.0e+8,
+    10000.,
+    100.,
+    10.
+  };
+  unsigned int mask = 1 << (ARRAY_LENGTH (_powers_of_10) - 1);
+  double result = 1;
+  for (const double *power = _powers_of_10; mask; ++power, mask >>= 1)
+    if (exponent & mask) result *= *power;
+  return result;
+}
+
+static inline double
+strtod_rl (const char *buf, char **end_ptr)
+{
+  const char *p, *pe;
+  double value = 0;
+  double frac = 0;
+  double frac_count = 0;
+  unsigned int exp = 0;
+  bool neg = false, exp_neg = false, exp_overflow = false;
+  const unsigned long long MAX_FRACT = 0xFFFFFFFFFFFFFull; /* 1^52-1 */
+  const unsigned int MAX_EXP = 0x7FFu; /* 1^11-1 */
+  p = buf;
+  pe = p + strlen (p);
+
+  while (p < pe && ISSPACE (*p))
+    p++;
+
+  int cs;
+  
+#line 142 "hb-number-parser.hh"
+	{
+	cs = double_parser_start;
+	}
+
+#line 147 "hb-number-parser.hh"
+	{
+	int _slen;
+	int _trans;
+	const unsigned char *_keys;
+	const char *_inds;
+	if ( p == pe )
+		goto _test_eof;
+	if ( cs == 0 )
+		goto _out;
+_resume:
+	_keys = _double_parser_trans_keys + (cs<<1);
+	_inds = _double_parser_indicies + _double_parser_index_offsets[cs];
+
+	_slen = _double_parser_key_spans[cs];
+	_trans = _inds[ _slen > 0 && _keys[0] <=(*p) &&
+		(*p) <= _keys[1] ?
+		(*p) - _keys[0] : _slen ];
+
+	cs = _double_parser_trans_targs[_trans];
+
+	if ( _double_parser_trans_actions[_trans] == 0 )
+		goto _again;
+
+	switch ( _double_parser_trans_actions[_trans] ) {
+	case 1:
+#line 39 "hb-number-parser.rl"
+	{ neg = true; }
+	break;
+	case 4:
+#line 40 "hb-number-parser.rl"
+	{ exp_neg = true; }
+	break;
+	case 2:
+#line 42 "hb-number-parser.rl"
+	{
+	value = value * 10. + ((*p) - '0');
+}
+	break;
+	case 3:
+#line 45 "hb-number-parser.rl"
+	{
+	if (likely (frac <= MAX_FRACT / 10))
+	{
+	  frac = frac * 10. + ((*p) - '0');
+	  ++frac_count;
+	}
+}
+	break;
+	case 5:
+#line 52 "hb-number-parser.rl"
+	{
+	if (likely (exp * 10 + ((*p) - '0') <= MAX_EXP))
+	  exp = exp * 10 + ((*p) - '0');
+	else
+	  exp_overflow = true;
+}
+	break;
+#line 205 "hb-number-parser.hh"
+	}
+
+_again:
+	if ( cs == 0 )
+		goto _out;
+	if ( ++p != pe )
+		goto _resume;
+	_test_eof: {}
+	_out: {}
+	}
+
+#line 116 "hb-number-parser.rl"
+
+
+  *end_ptr = (char *) p;
+
+  if (frac_count) value += frac / _pow10 (frac_count);
+  if (neg) value *= -1.;
+
+  if (unlikely (exp_overflow))
+  {
+    if (value == 0) return value;
+    if (exp_neg)    return neg ? -DBL_MIN : DBL_MIN;
+    else            return neg ? -DBL_MAX : DBL_MAX;
+  }
+
+  if (exp)
+  {
+    if (exp_neg) value /= _pow10 (exp);
+    else         value *= _pow10 (exp);
+  }
+
+  return value;
+}
+
+#endif /* HB_NUMBER_PARSER_HH */
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-number-parser.rl b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-number-parser.rl
new file mode 100644
index 00000000000..8445fa22a13
--- /dev/null
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-number-parser.rl
@@ -0,0 +1,139 @@
+/*
+ * Copyright © 2019  Ebrahim Byagowi
+ *
+ *  This is part of HarfBuzz, a text shaping library.
+ *
+ * Permission is hereby granted, without written agreement and without
+ * license or royalty fees, to use, copy, modify, and distribute this
+ * software and its documentation for any purpose, provided that the
+ * above copyright notice and the following two paragraphs appear in
+ * all copies of this software.
+ *
+ * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
+ * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
+ * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
+ * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ *
+ * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
+ * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
+ * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
+ * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
+ *
+ */
+
+#ifndef HB_NUMBER_PARSER_HH
+#define HB_NUMBER_PARSER_HH
+
+#include "hb.hh"
+
+#include <float.h>
+
+%%{
+
+machine double_parser;
+alphtype unsigned char;
+write data;
+
+action see_neg { neg = true; }
+action see_exp_neg { exp_neg = true; }
+
+action add_int  {
+	value = value * 10. + (fc - '0');
+}
+action add_frac {
+	if (likely (frac <= MAX_FRACT / 10))
+	{
+	  frac = frac * 10. + (fc - '0');
+	  ++frac_count;
+	}
+}
+action add_exp  {
+	if (likely (exp * 10 + (fc - '0') <= MAX_EXP))
+	  exp = exp * 10 + (fc - '0');
+	else
+	  exp_overflow = true;
+}
+
+num = [0-9]+;
+
+main := (
+	(
+		(('+'|'-'@see_neg)? num @add_int) ('.' num @add_frac)?
+		|
+		(('+'|'-'@see_neg)? '.' num @add_frac)
+	)
+	(('e'|'E') (('+'|'-'@see_exp_neg)? num @add_exp))?
+);
+
+}%%
+
+/* Works only for n < 512 */
+static inline double
+_pow10 (unsigned int exponent)
+{
+  static const double _powers_of_10[] =
+  {
+    1.0e+256,
+    1.0e+128,
+    1.0e+64,
+    1.0e+32,
+    1.0e+16,
+    1.0e+8,
+    10000.,
+    100.,
+    10.
+  };
+  unsigned int mask = 1 << (ARRAY_LENGTH (_powers_of_10) - 1);
+  double result = 1;
+  for (const double *power = _powers_of_10; mask; ++power, mask >>= 1)
+    if (exponent & mask) result *= *power;
+  return result;
+}
+
+static inline double
+strtod_rl (const char *buf, char **end_ptr)
+{
+  const char *p, *pe;
+  double value = 0;
+  double frac = 0;
+  double frac_count = 0;
+  unsigned int exp = 0;
+  bool neg = false, exp_neg = false, exp_overflow = false;
+  const unsigned long long MAX_FRACT = 0xFFFFFFFFFFFFFull; /* 1^52-1 */
+  const unsigned int MAX_EXP = 0x7FFu; /* 1^11-1 */
+  p = buf;
+  pe = p + strlen (p);
+
+  while (p < pe && ISSPACE (*p))
+    p++;
+
+  int cs;
+  %%{
+    write init;
+    write exec;
+  }%%
+
+  *end_ptr = (char *) p;
+
+  if (frac_count) value += frac / _pow10 (frac_count);
+  if (neg) value *= -1.;
+
+  if (unlikely (exp_overflow))
+  {
+    if (value == 0) return value;
+    if (exp_neg)    return neg ? -DBL_MIN : DBL_MIN;
+    else            return neg ? -DBL_MAX : DBL_MAX;
+  }
+
+  if (exp)
+  {
+    if (exp_neg) value /= _pow10 (exp);
+    else         value *= _pow10 (exp);
+  }
+
+  return value;
+}
+
+#endif /* HB_NUMBER_PARSER_HH */
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-number.cc b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-number.cc
new file mode 100644
index 00000000000..4f84d4ad5cd
--- /dev/null
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-number.cc
@@ -0,0 +1,147 @@
+/*
+ * Copyright © 2019  Ebrahim Byagowi
+ *
+ *  This is part of HarfBuzz, a text shaping library.
+ *
+ * Permission is hereby granted, without written agreement and without
+ * license or royalty fees, to use, copy, modify, and distribute this
+ * software and its documentation for any purpose, provided that the
+ * above copyright notice and the following two paragraphs appear in
+ * all copies of this software.
+ *
+ * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
+ * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
+ * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
+ * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ *
+ * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
+ * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
+ * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
+ * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
+ *
+ */
+
+#include "hb.hh"
+#include "hb-machinery.hh"
+#include "hb-number-parser.hh"
+
+#include <locale.h>
+#ifdef HAVE_XLOCALE_H
+#include <xlocale.h>
+#endif
+
+template<typename T, typename Func>
+static bool
+_parse_number (const char **pp, const char *end, T *pv,
+	       bool whole_buffer, Func f)
+{
+  char buf[32];
+  unsigned int len = hb_min (ARRAY_LENGTH (buf) - 1,
+			     (unsigned int) (end - *pp));
+  strncpy (buf, *pp, len);
+  buf[len] = '\0';
+
+  char *p = buf;
+  char *pend = p;
+
+  errno = 0;
+  *pv = f (p, &pend);
+  if (unlikely (errno || p == pend ||
+		/* Check if consumed whole buffer if is requested */
+		(whole_buffer && pend - p != end - *pp))) return false;
+
+  *pp += pend - p;
+  return true;
+}
+
+bool
+hb_parse_int (const char **pp, const char *end, int *pv, bool whole_buffer)
+{
+  return _parse_number<int> (pp, end, pv, whole_buffer,
+			     [] (const char *p, char **end)
+			     { return strtol (p, end, 10); });
+}
+
+bool
+hb_parse_uint (const char **pp, const char *end, unsigned int *pv,
+	       bool whole_buffer, int base)
+{
+  return _parse_number<unsigned int> (pp, end, pv, whole_buffer,
+				      [base] (const char *p, char **end)
+				      { return strtoul (p, end, base); });
+}
+
+
+#if defined (HAVE_NEWLOCALE) && defined (HAVE_STRTOD_L)
+#define USE_XLOCALE 1
+#define HB_LOCALE_T locale_t
+#define HB_CREATE_LOCALE(locName) newlocale (LC_ALL_MASK, locName, nullptr)
+#define HB_FREE_LOCALE(loc) freelocale (loc)
+#elif defined(_MSC_VER)
+#define USE_XLOCALE 1
+#define HB_LOCALE_T _locale_t
+#define HB_CREATE_LOCALE(locName) _create_locale (LC_ALL, locName)
+#define HB_FREE_LOCALE(loc) _free_locale (loc)
+#define strtod_l(a, b, c) _strtod_l ((a), (b), (c))
+#endif
+
+#ifdef USE_XLOCALE
+
+#if HB_USE_ATEXIT
+static void free_static_C_locale ();
+#endif
+
+static struct hb_C_locale_lazy_loader_t : hb_lazy_loader_t<hb_remove_pointer<HB_LOCALE_T>,
+							  hb_C_locale_lazy_loader_t>
+{
+  static HB_LOCALE_T create ()
+  {
+    HB_LOCALE_T C_locale = HB_CREATE_LOCALE ("C");
+
+#if HB_USE_ATEXIT
+    atexit (free_static_C_locale);
+#endif
+
+    return C_locale;
+  }
+  static void destroy (HB_LOCALE_T p)
+  {
+    HB_FREE_LOCALE (p);
+  }
+  static HB_LOCALE_T get_null ()
+  {
+    return nullptr;
+  }
+} static_C_locale;
+
+#if HB_USE_ATEXIT
+static
+void free_static_C_locale ()
+{
+  static_C_locale.free_instance ();
+}
+#endif
+
+static HB_LOCALE_T
+get_C_locale ()
+{
+  return static_C_locale.get_unconst ();
+}
+#endif /* USE_XLOCALE */
+
+bool
+hb_parse_double (const char **pp, const char *end, double *pv,
+		 bool whole_buffer)
+{
+  return _parse_number<double> (pp, end, pv, whole_buffer,
+				[] (const char *p, char **end)
+				{
+#ifdef USE_XLOCALE
+				  return strtod_l (p, end, get_C_locale ());
+#else
+				  return strtod_rl (p, end);
+#endif
+				});
+}
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-number.hh b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-number.hh
new file mode 100644
index 00000000000..14d1260aa3d
--- /dev/null
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-number.hh
@@ -0,0 +1,41 @@
+/*
+ * Copyright © 2019  Ebrahim Byagowi
+ *
+ *  This is part of HarfBuzz, a text shaping library.
+ *
+ * Permission is hereby granted, without written agreement and without
+ * license or royalty fees, to use, copy, modify, and distribute this
+ * software and its documentation for any purpose, provided that the
+ * above copyright notice and the following two paragraphs appear in
+ * all copies of this software.
+ *
+ * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
+ * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
+ * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
+ * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ *
+ * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
+ * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
+ * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
+ * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
+ *
+ */
+
+#ifndef HB_NUMBER_HH
+#define HB_NUMBER_HH
+
+HB_INTERNAL bool
+hb_parse_int (const char **pp, const char *end, int *pv,
+	      bool whole_buffer = false);
+
+HB_INTERNAL bool
+hb_parse_uint (const char **pp, const char *end, unsigned int *pv,
+	       bool whole_buffer = false, int base = 10);
+
+HB_INTERNAL bool
+hb_parse_double (const char **pp, const char *end, double *pv,
+		 bool whole_buffer = false);
+
+#endif /* HB_NUMBER_HH */
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-object.hh b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-object.hh
index 68520f2a160..c470532aaca 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-object.hh
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-object.hh
@@ -62,7 +62,7 @@ struct hb_lockable_set_t
 	old.fini ();
       }
       else {
-        item = nullptr;
+	item = nullptr;
 	l.unlock ();
       }
     } else {
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-open-file.hh b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-open-file.hh
index f3f4dc07f50..b05393647ea 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-open-file.hh
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-open-file.hh
@@ -92,9 +92,9 @@ typedef struct OffsetTable
     if (table_count)
     {
       if (start_offset >= tables.len)
-        *table_count = 0;
+	*table_count = 0;
       else
-        *table_count = hb_min (*table_count, tables.len - start_offset);
+	*table_count = hb_min (*table_count, tables.len - start_offset);
 
       const TableRecord *sub_tables = tables.arrayZ + start_offset;
       unsigned int count = *table_count;
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-open-type.hh b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-open-type.hh
index ad995750b84..fce55910326 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-open-type.hh
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-open-type.hh
@@ -63,6 +63,14 @@ struct IntType
   operator wide_type () const { return v; }
   bool operator == (const IntType &o) const { return (Type) v == (Type) o.v; }
   bool operator != (const IntType &o) const { return !(*this == o); }
+
+  IntType& operator += (unsigned count) { *this = *this + count; return *this; }
+  IntType& operator -= (unsigned count) { *this = *this - count; return *this; }
+  IntType& operator ++ () { *this += 1; return *this; }
+  IntType& operator -- () { *this -= 1; return *this; }
+  IntType operator ++ (int) { IntType c (*this); ++*this; return c; }
+  IntType operator -- (int) { IntType c (*this); --*this; return c; }
+
   HB_INTERNAL static int cmp (const IntType *a, const IntType *b)
   { return b->cmp (*a); }
   template <typename Type2>
@@ -116,9 +124,9 @@ struct F2DOT14 : HBINT16
 };
 
 /* 32-bit signed fixed-point number (16.16). */
-struct Fixed : HBINT32
+struct HBFixed : HBINT32
 {
-  Fixed& operator = (uint32_t i) { HBINT32::operator= (i); return *this; }
+  HBFixed& operator = (uint32_t i) { HBINT32::operator= (i); return *this; }
   // 65536 means 1<<16
   float to_float () const  { return ((int32_t) v) / 65536.f; }
   void set_float (float f) { v = roundf (f * 65536.f); }
@@ -155,9 +163,9 @@ struct Tag : HBUINT32
 };
 
 /* Glyph index number, same as uint16 (length = 16 bits) */
-struct GlyphID : HBUINT16
+struct HBGlyphID : HBUINT16
 {
-  GlyphID& operator = (uint16_t i) { HBUINT16::operator= (i); return *this; }
+  HBGlyphID& operator = (uint16_t i) { HBUINT16::operator= (i); return *this; }
 };
 
 /* Script/language-system/feature index */
@@ -475,7 +483,7 @@ struct UnsizedArrayOf
   }
 
   public:
-  Type		arrayZ[VAR];
+  Type		arrayZ[HB_VAR_ARRAY];
   public:
   DEFINE_SIZE_UNBOUNDED (0);
 };
@@ -564,6 +572,8 @@ struct ArrayOf
 
   explicit operator bool () const { return len; }
 
+  void pop () { len--; }
+
   hb_array_t<      Type> as_array ()       { return hb_array (arrayZ, len); }
   hb_array_t<const Type> as_array () const { return hb_array (arrayZ, len); }
 
@@ -606,6 +616,18 @@ struct ArrayOf
     return_trace (true);
   }
 
+  Type* serialize_append (hb_serialize_context_t *c)
+  {
+    TRACE_SERIALIZE (this);
+    len++;
+    if (unlikely (!len || !c->extend (*this)))
+    {
+      len--;
+      return_trace (nullptr);
+    }
+    return_trace (&arrayZ[len - 1]);
+  }
+
   ArrayOf* copy (hb_serialize_context_t *c) const
   {
     TRACE_SERIALIZE (this);
@@ -647,7 +669,7 @@ struct ArrayOf
 
   public:
   LenType	len;
-  Type		arrayZ[VAR];
+  Type		arrayZ[HB_VAR_ARRAY];
   public:
   DEFINE_SIZE_ARRAY (sizeof (LenType), arrayZ);
 };
@@ -720,17 +742,40 @@ struct HeadlessArrayOf
     return arrayZ[i-1];
   }
   unsigned int get_size () const
-  { return lenP1.static_size + (lenP1 ? lenP1 - 1 : 0) * Type::static_size; }
+  { return lenP1.static_size + get_length () * Type::static_size; }
+
+  unsigned get_length () const { return lenP1 ? lenP1 - 1 : 0; }
+
+  hb_array_t<      Type> as_array ()       { return hb_array (arrayZ, get_length ()); }
+  hb_array_t<const Type> as_array () const { return hb_array (arrayZ, get_length ()); }
+
+  /* Iterator. */
+  typedef hb_array_t<const Type>   iter_t;
+  typedef hb_array_t<      Type> writer_t;
+    iter_t   iter () const { return as_array (); }
+  writer_t writer ()       { return as_array (); }
+  operator   iter_t () const { return   iter (); }
+  operator writer_t ()       { return writer (); }
 
-  bool serialize (hb_serialize_context_t *c,
-		  hb_array_t<const Type> items)
+  bool serialize (hb_serialize_context_t *c, unsigned int items_len)
   {
     TRACE_SERIALIZE (this);
     if (unlikely (!c->extend_min (*this))) return_trace (false);
-    c->check_assign (lenP1, items.length + 1);
+    c->check_assign (lenP1, items_len + 1);
     if (unlikely (!c->extend (*this))) return_trace (false);
-    for (unsigned int i = 0; i < items.length; i++)
-      arrayZ[i] = items[i];
+    return_trace (true);
+  }
+  template <typename Iterator,
+	    hb_requires (hb_is_source_of (Iterator, Type))>
+  bool serialize (hb_serialize_context_t *c, Iterator items)
+  {
+    TRACE_SERIALIZE (this);
+    unsigned count = items.len ();
+    if (unlikely (!serialize (c, count))) return_trace (false);
+    /* TODO Umm. Just exhaust the iterator instead?  Being extra
+     * cautious right now.. */
+    for (unsigned i = 0; i < count; i++, ++items)
+      arrayZ[i] = *items;
     return_trace (true);
   }
 
@@ -740,7 +785,7 @@ struct HeadlessArrayOf
     TRACE_SANITIZE (this);
     if (unlikely (!sanitize_shallow (c))) return_trace (false);
     if (!sizeof... (Ts) && hb_is_trivially_copyable (Type)) return_trace (true);
-    unsigned int count = lenP1 ? lenP1 - 1 : 0;
+    unsigned int count = get_length ();
     for (unsigned int i = 0; i < count; i++)
       if (unlikely (!c->dispatch (arrayZ[i], hb_forward<Ts> (ds)...)))
 	return_trace (false);
@@ -757,7 +802,7 @@ struct HeadlessArrayOf
 
   public:
   LenType	lenP1;
-  Type		arrayZ[VAR];
+  Type		arrayZ[HB_VAR_ARRAY];
   public:
   DEFINE_SIZE_ARRAY (sizeof (LenType), arrayZ);
 };
@@ -805,7 +850,7 @@ struct ArrayOfM1
 
   public:
   LenType	lenM1;
-  Type		arrayZ[VAR];
+  Type		arrayZ[HB_VAR_ARRAY];
   public:
   DEFINE_SIZE_ARRAY (sizeof (LenType), arrayZ);
 };
@@ -944,7 +989,7 @@ struct VarSizedBinSearchArrayOf
     unsigned int count = Type::TerminationWordCount;
     for (unsigned int i = 0; i < count; i++)
       if (words[i] != 0xFFFFu)
-        return false;
+	return false;
     return true;
   }
 
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-cff-common.hh b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-cff-common.hh
index aced77c83de..f4c4fe85778 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-cff-common.hh
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-cff-common.hh
@@ -237,8 +237,8 @@ struct CFFIndex
   public:
   COUNT		count;		/* Number of object data. Note there are (count+1) offsets */
   HBUINT8	offSize;	/* The byte size of each offset in the offsets array. */
-  HBUINT8	offsets[VAR];	/* The array of (count + 1) offsets into objects array (1-base). */
-  /* HBUINT8 data[VAR];	Object data */
+  HBUINT8	offsets[HB_VAR_ARRAY];	/* The array of (count + 1) offsets into objects array (1-base). */
+  /* HBUINT8 data[HB_VAR_ARRAY];	Object data */
   public:
   DEFINE_SIZE_ARRAY (COUNT::static_size + HBUINT8::static_size, offsets);
 };
@@ -514,9 +514,9 @@ struct FDSelect0 {
   unsigned int get_size (unsigned int num_glyphs) const
   { return HBUINT8::static_size * num_glyphs; }
 
-  HBUINT8     fds[VAR];
+  HBUINT8     fds[HB_VAR_ARRAY];
 
-  DEFINE_SIZE_MIN (1);
+  DEFINE_SIZE_MIN (0);
 };
 
 template <typename GID_TYPE, typename FD_TYPE>
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-cff1-table.hh b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-cff1-table.hh
index 4050b7d6fb9..882250f269d 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-cff1-table.hh
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-cff1-table.hh
@@ -357,7 +357,7 @@ struct Charset0 {
     return HBUINT16::static_size * (num_glyphs - 1);
   }
 
-  HBUINT16  sids[VAR];
+  HBUINT16  sids[HB_VAR_ARRAY];
 
   DEFINE_SIZE_ARRAY(0, sids);
 };
@@ -439,7 +439,7 @@ struct Charset1_2 {
     return size;
   }
 
-  Charset_Range<TYPE>   ranges[VAR];
+  Charset_Range<TYPE>   ranges[HB_VAR_ARRAY];
 
   DEFINE_SIZE_ARRAY (0, ranges);
 };
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-cmap-table.hh b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-cmap-table.hh
index 23ea4659d20..eb6f2406bd3 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-cmap-table.hh
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-cmap-table.hh
@@ -76,24 +76,24 @@ struct CmapSubtableFormat4
 {
 
   template<typename Iterator,
-           hb_requires (hb_is_iterator (Iterator))>
+	   hb_requires (hb_is_iterator (Iterator))>
   HBUINT16* serialize_endcode_array (hb_serialize_context_t *c,
-                                     Iterator it)
+				     Iterator it)
   {
     HBUINT16 *endCode = c->start_embed<HBUINT16> ();
     hb_codepoint_t prev_endcp = 0xFFFF;
 
     + it
     | hb_apply ([&] (const hb_item_type<Iterator> _)
-                {
-                  if (prev_endcp != 0xFFFF && prev_endcp + 1u != _.first)
-                  {
-                    HBUINT16 end_code;
-                    end_code = prev_endcp;
-                    c->copy<HBUINT16> (end_code);
-                  }
-                  prev_endcp = _.first;
-                })
+		{
+		  if (prev_endcp != 0xFFFF && prev_endcp + 1u != _.first)
+		  {
+		    HBUINT16 end_code;
+		    end_code = prev_endcp;
+		    c->copy<HBUINT16> (end_code);
+		  }
+		  prev_endcp = _.first;
+		})
     ;
 
     {
@@ -104,9 +104,9 @@ struct CmapSubtableFormat4
       // There must be a final entry with end_code == 0xFFFF.
       if (prev_endcp != 0xFFFF)
       {
-        HBUINT16 finalcode;
-        finalcode = 0xFFFF;
-        if (unlikely (!c->copy<HBUINT16> (finalcode))) return nullptr;
+	HBUINT16 finalcode;
+	finalcode = 0xFFFF;
+	if (unlikely (!c->copy<HBUINT16> (finalcode))) return nullptr;
       }
     }
 
@@ -114,25 +114,25 @@ struct CmapSubtableFormat4
   }
 
   template<typename Iterator,
-           hb_requires (hb_is_iterator (Iterator))>
+	   hb_requires (hb_is_iterator (Iterator))>
   HBUINT16* serialize_startcode_array (hb_serialize_context_t *c,
-                                       Iterator it)
+				       Iterator it)
   {
     HBUINT16 *startCode = c->start_embed<HBUINT16> ();
     hb_codepoint_t prev_cp = 0xFFFF;
-    
+
     + it
     | hb_apply ([&] (const hb_item_type<Iterator> _)
-                {
-                  if (prev_cp == 0xFFFF || prev_cp + 1u != _.first)
-                  {
-                    HBUINT16 start_code;
-                    start_code = _.first;
-                    c->copy<HBUINT16> (start_code);
-                  }
-
-                  prev_cp = _.first;
-                })
+		{
+		  if (prev_cp == 0xFFFF || prev_cp + 1u != _.first)
+		  {
+		    HBUINT16 start_code;
+		    start_code = _.first;
+		    c->copy<HBUINT16> (start_code);
+		  }
+
+		  prev_cp = _.first;
+		})
     ;
 
     // There must be a final entry with end_code == 0xFFFF.
@@ -147,44 +147,44 @@ struct CmapSubtableFormat4
   }
 
   template<typename Iterator,
-           hb_requires (hb_is_iterator (Iterator))>
+	   hb_requires (hb_is_iterator (Iterator))>
   HBINT16* serialize_idDelta_array (hb_serialize_context_t *c,
-                                     Iterator it,
-                                     HBUINT16 *endCode,
-                                     HBUINT16 *startCode,
-                                     unsigned segcount)
+				     Iterator it,
+				     HBUINT16 *endCode,
+				     HBUINT16 *startCode,
+				     unsigned segcount)
   {
     unsigned i = 0;
     hb_codepoint_t last_gid = 0, start_gid = 0, last_cp = 0xFFFF;
     bool use_delta = true;
-    
+
     HBINT16 *idDelta = c->start_embed<HBINT16> ();
     if ((char *)idDelta - (char *)startCode != (int) segcount * (int) HBINT16::static_size)
       return nullptr;
 
     + it
     | hb_apply ([&] (const hb_item_type<Iterator> _)
-                {
-                  if (_.first == startCode[i])
-                  {
-                    use_delta = true;
-                    start_gid = _.second;
-                  }
-                  else if (_.second != last_gid + 1) use_delta = false;
-
-                  if (_.first == endCode[i])
-                  {
-                    HBINT16 delta;
-                    if (use_delta) delta = (int)start_gid - (int)startCode[i];
-                    else delta = 0;
-                    c->copy<HBINT16> (delta);
-
-                    i++;
-                  }
-
-                  last_gid = _.second;
-                  last_cp = _.first;
-                })
+		{
+		  if (_.first == startCode[i])
+		  {
+		    use_delta = true;
+		    start_gid = _.second;
+		  }
+		  else if (_.second != last_gid + 1) use_delta = false;
+
+		  if (_.first == endCode[i])
+		  {
+		    HBINT16 delta;
+		    if (use_delta) delta = (int)start_gid - (int)startCode[i];
+		    else delta = 0;
+		    c->copy<HBINT16> (delta);
+
+		    i++;
+		  }
+
+		  last_gid = _.second;
+		  last_cp = _.first;
+		})
     ;
 
     if (it.len () == 0 || last_cp != 0xFFFF)
@@ -198,43 +198,43 @@ struct CmapSubtableFormat4
   }
 
   template<typename Iterator,
-           hb_requires (hb_is_iterator (Iterator))>
+	   hb_requires (hb_is_iterator (Iterator))>
   HBUINT16* serialize_rangeoffset_glyid (hb_serialize_context_t *c,
-                                     Iterator it,
-                                     HBUINT16 *endCode,
-                                     HBUINT16 *startCode,
-                                     HBINT16 *idDelta,
-                                     unsigned segcount)
+					 Iterator it,
+					 HBUINT16 *endCode,
+					 HBUINT16 *startCode,
+					 HBINT16 *idDelta,
+					 unsigned segcount)
   {
     HBUINT16 *idRangeOffset = c->allocate_size<HBUINT16> (HBUINT16::static_size * segcount);
     if (unlikely (!c->check_success (idRangeOffset))) return nullptr;
     if (unlikely ((char *)idRangeOffset - (char *)idDelta != (int) segcount * (int) HBINT16::static_size)) return nullptr;
- 
+
     + hb_range (segcount)
     | hb_filter ([&] (const unsigned _) { return idDelta[_] == 0; })
     | hb_apply ([&] (const unsigned i)
-                {
-                  idRangeOffset[i] = 2 * (c->start_embed<HBUINT16> () - idRangeOffset - i);
+		{
+		  idRangeOffset[i] = 2 * (c->start_embed<HBUINT16> () - idRangeOffset - i);
 
-                  + it
-                  | hb_filter ([&] (const hb_item_type<Iterator> _) { return _.first >= startCode[i] && _.first <= endCode[i]; })
-                  | hb_apply ([&] (const hb_item_type<Iterator> _)
-                              {
-                                HBUINT16 glyID;
-                                glyID = _.second;
-                                c->copy<HBUINT16> (glyID);
-                              })
-                  ;
+		  + it
+		  | hb_filter ([&] (const hb_item_type<Iterator> _) { return _.first >= startCode[i] && _.first <= endCode[i]; })
+		  | hb_apply ([&] (const hb_item_type<Iterator> _)
+			      {
+				HBUINT16 glyID;
+				glyID = _.second;
+				c->copy<HBUINT16> (glyID);
+			      })
+		  ;
 
 
-                })
+		})
     ;
 
     return idRangeOffset;
   }
 
   template<typename Iterator,
-           hb_requires (hb_is_iterator (Iterator))>
+	   hb_requires (hb_is_iterator (Iterator))>
   void serialize (hb_serialize_context_t *c,
 		  Iterator it)
   {
@@ -247,21 +247,21 @@ struct CmapSubtableFormat4
     if (unlikely (!endCode)) return;
 
     unsigned segcount = (c->length () - min_size) / HBUINT16::static_size;
-    
+
     // 2 bytes of padding.
     if (unlikely (!c->allocate_size<HBUINT16> (HBUINT16::static_size))) return; // 2 bytes of padding.
 
    // serialize startCode[]
     HBUINT16 *startCode = serialize_startcode_array (c, it);
     if (unlikely (!startCode)) return;
-    
+
     //serialize idDelta[]
     HBINT16 *idDelta = serialize_idDelta_array (c, it, endCode, startCode, segcount);
     if (unlikely (!idDelta)) return;
 
     HBUINT16 *idRangeOffset = serialize_rangeoffset_glyid (c, it, endCode, startCode, idDelta, segcount);
     if (unlikely (!c->check_success (idRangeOffset))) return;
- 
+
     if (unlikely (!c->check_assign(this->length, c->length () - table_initpos))) return;
     this->segCountX2 = segcount * 2;
     this->entrySelector = hb_max (1u, hb_bit_storage (segcount)) - 1;
@@ -334,9 +334,7 @@ struct CmapSubtableFormat4
       return true;
     }
     HB_INTERNAL static bool get_glyph_func (const void *obj, hb_codepoint_t codepoint, hb_codepoint_t *glyph)
-    {
-      return ((const accelerator_t *) obj)->get_glyph (codepoint, glyph);
-    }
+    { return ((const accelerator_t *) obj)->get_glyph (codepoint, glyph); }
     void collect_unicodes (hb_set_t *out) const
     {
       unsigned int count = this->segCount;
@@ -498,7 +496,7 @@ struct CmapSubtableTrimmed
   UINT		length;		/* Byte length of this subtable. */
   UINT		language;	/* Ignore. */
   UINT		startCharCode;	/* First character code covered. */
-  ArrayOf<GlyphID, UINT>
+  ArrayOf<HBGlyphID, UINT>
 		glyphIdArray;	/* Array of glyph index values for character
 				 * codes in the range. */
   public:
@@ -557,7 +555,7 @@ struct CmapSubtableFormat12 : CmapSubtableLongSegmented<CmapSubtableFormat12>
 
 
   template<typename Iterator,
-           hb_requires (hb_is_iterator (Iterator))>
+	   hb_requires (hb_is_iterator (Iterator))>
   void serialize (hb_serialize_context_t *c,
 		  Iterator it)
   {
@@ -570,30 +568,30 @@ struct CmapSubtableFormat12 : CmapSubtableLongSegmented<CmapSubtableFormat12>
 
     + it
     | hb_apply ([&] (const hb_item_type<Iterator> _)
-              {
-                if (startCharCode == 0xFFFF)
-                {
-                  startCharCode = _.first;
-                  endCharCode = _.first;
-                  glyphID = _.second;
-                }
-                else if (!_is_gid_consecutive (endCharCode, startCharCode, glyphID, _.first, _.second))
-                {
-                  CmapSubtableLongGroup  grouprecord;
-                  grouprecord.startCharCode = startCharCode;
-                  grouprecord.endCharCode = endCharCode;
-                  grouprecord.glyphID = glyphID;
-                  c->copy<CmapSubtableLongGroup> (grouprecord);
-
-                  startCharCode = _.first;
-                  endCharCode = _.first;
-                  glyphID = _.second;
-                }
-                else
-                {
-                  endCharCode = _.first;
-                }
-              })
+	      {
+		if (startCharCode == 0xFFFF)
+		{
+		  startCharCode = _.first;
+		  endCharCode = _.first;
+		  glyphID = _.second;
+		}
+		else if (!_is_gid_consecutive (endCharCode, startCharCode, glyphID, _.first, _.second))
+		{
+		  CmapSubtableLongGroup  grouprecord;
+		  grouprecord.startCharCode = startCharCode;
+		  grouprecord.endCharCode = endCharCode;
+		  grouprecord.glyphID = glyphID;
+		  c->copy<CmapSubtableLongGroup> (grouprecord);
+
+		  startCharCode = _.first;
+		  endCharCode = _.first;
+		  glyphID = _.second;
+		}
+		else
+		{
+		  endCharCode = _.first;
+		}
+	      })
     ;
 
     CmapSubtableLongGroup record;
@@ -609,14 +607,12 @@ struct CmapSubtableFormat12 : CmapSubtableLongSegmented<CmapSubtableFormat12>
   }
 
   static size_t get_sub_table_size (const hb_sorted_vector_t<CmapSubtableLongGroup> &groups_data)
-  {
-    return 16 + 12 * groups_data.length;
-  }
+  { return 16 + 12 * groups_data.length; }
 
- private:
+  private:
   static bool _is_gid_consecutive (hb_codepoint_t endCharCode,
-                                   hb_codepoint_t startCharCode,
-                                   hb_codepoint_t glyphID,
+				   hb_codepoint_t startCharCode,
+				   hb_codepoint_t glyphID,
 				   hb_codepoint_t cp,
 				   hb_codepoint_t new_gid)
   {
@@ -676,6 +672,63 @@ struct DefaultUVS : SortedArrayOf<UnicodeValueRange, HBUINT32>
     }
   }
 
+  DefaultUVS* copy (hb_serialize_context_t *c,
+		    const hb_set_t *unicodes) const
+  {
+    DefaultUVS *out = c->start_embed<DefaultUVS> ();
+    if (unlikely (!out)) return nullptr;
+    auto snap = c->snapshot ();
+
+    HBUINT32 len;
+    len = 0;
+    if (unlikely (!c->copy<HBUINT32> (len))) return nullptr;
+    unsigned init_len = c->length ();
+
+    hb_codepoint_t lastCode = HB_MAP_VALUE_INVALID;
+    int count = -1;
+
+    for (const UnicodeValueRange& _ : as_array ())
+    {
+      for (const unsigned addcnt : hb_range ((unsigned) _.additionalCount + 1))
+      {
+	unsigned curEntry = (unsigned) _.startUnicodeValue + addcnt;
+	if (!unicodes->has (curEntry)) continue;
+	count += 1;
+	if (lastCode == HB_MAP_VALUE_INVALID)
+	  lastCode = curEntry;
+	else if (lastCode + count != curEntry)
+	{
+	  UnicodeValueRange rec;
+	  rec.startUnicodeValue = lastCode;
+	  rec.additionalCount = count - 1;
+	  c->copy<UnicodeValueRange> (rec);
+
+	  lastCode = curEntry;
+	  count = 0;
+	}
+      }
+    }
+
+    if (lastCode != HB_MAP_VALUE_INVALID)
+    {
+      UnicodeValueRange rec;
+      rec.startUnicodeValue = lastCode;
+      rec.additionalCount = count;
+      c->copy<UnicodeValueRange> (rec);
+    }
+
+    if (c->length () - init_len == 0)
+    {
+      c->revert (snap);
+      return nullptr;
+    }
+    else
+    {
+      if (unlikely (!c->check_assign (out->len, (c->length () - init_len) / UnicodeValueRange::static_size))) return nullptr;
+      return out;
+    }
+  }
+
   public:
   DEFINE_SIZE_ARRAY (4, *this);
 };
@@ -694,7 +747,7 @@ struct UVSMapping
   }
 
   HBUINT24	unicodeValue;	/* Base Unicode value of the UVS */
-  GlyphID	glyphID;	/* Glyph ID of the UVS */
+  HBGlyphID	glyphID;	/* Glyph ID of the UVS */
   public:
   DEFINE_SIZE_STATIC (5);
 };
@@ -708,6 +761,49 @@ struct NonDefaultUVS : SortedArrayOf<UVSMapping, HBUINT32>
       out->add (arrayZ[i].glyphID);
   }
 
+  void closure_glyphs (const hb_set_t      *unicodes,
+		       hb_set_t            *glyphset) const
+  {
+    + as_array ()
+    | hb_filter (unicodes, &UVSMapping::unicodeValue)
+    | hb_map (&UVSMapping::glyphID)
+    | hb_sink (glyphset)
+    ;
+  }
+
+  NonDefaultUVS* copy (hb_serialize_context_t *c,
+		       const hb_set_t *unicodes,
+		       const hb_set_t *glyphs,
+		       const hb_map_t *glyph_map) const
+  {
+    NonDefaultUVS *out = c->start_embed<NonDefaultUVS> ();
+    if (unlikely (!out)) return nullptr;
+
+    auto it =
+    + as_array ()
+    | hb_filter ([&] (const UVSMapping& _)
+		 {
+		   return unicodes->has (_.unicodeValue) || glyphs->has (_.glyphID);
+		 })
+    ;
+
+    if (!it) return nullptr;
+
+    HBUINT32 len;
+    len = it.len ();
+    if (unlikely (!c->copy<HBUINT32> (len))) return nullptr;
+
+    for (const UVSMapping& _ : it)
+    {
+      UVSMapping mapping;
+      mapping.unicodeValue = _.unicodeValue;
+      mapping.glyphID = glyph_map->get (_.glyphID);
+      c->copy<UVSMapping> (mapping);
+    }
+
+    return out;
+  }
+
   public:
   DEFINE_SIZE_ARRAY (4, *this);
 };
@@ -736,9 +832,7 @@ struct VariationSelectorRecord
   }
 
   int cmp (const hb_codepoint_t &variation_selector) const
-  {
-    return varSelector.cmp (variation_selector);
-  }
+  { return varSelector.cmp (variation_selector); }
 
   bool sanitize (hb_sanitize_context_t *c, const void *base) const
   {
@@ -748,6 +842,52 @@ struct VariationSelectorRecord
 		  nonDefaultUVS.sanitize (c, base));
   }
 
+  VariationSelectorRecord* copy (hb_serialize_context_t *c,
+				 const hb_set_t *unicodes,
+				 const hb_set_t *glyphs,
+				 const hb_map_t *glyph_map,
+				 const void *src_base,
+				 const void *dst_base) const
+  {
+    auto snap = c->snapshot ();
+    auto *out = c->embed<VariationSelectorRecord> (*this);
+    if (unlikely (!out)) return nullptr;
+
+    out->defaultUVS = 0;
+    out->nonDefaultUVS = 0;
+
+    bool drop = true;
+
+    if (defaultUVS != 0)
+    {
+      c->push ();
+      if (c->copy (src_base+defaultUVS, unicodes))
+      {
+	c->add_link (out->defaultUVS, c->pop_pack (), dst_base);
+	drop = false;
+      }
+      else c->pop_discard ();
+    }
+
+    if (nonDefaultUVS != 0)
+    {
+      c->push ();
+      if (c->copy (src_base+nonDefaultUVS, unicodes, glyphs, glyph_map))
+      {
+	c->add_link (out->nonDefaultUVS, c->pop_pack (), dst_base);
+	drop = false;
+      }
+      else c->pop_discard ();
+    }
+
+    if (drop)
+    {
+      c->revert (snap);
+      return nullptr;
+    }
+    else return out;
+  }
+
   HBUINT24	varSelector;	/* Variation selector. */
   LOffsetTo<DefaultUVS>
 		defaultUVS;	/* Offset to Default UVS Table.  May be 0. */
@@ -762,9 +902,7 @@ struct CmapSubtableFormat14
   glyph_variant_t get_glyph_variant (hb_codepoint_t codepoint,
 				     hb_codepoint_t variation_selector,
 				     hb_codepoint_t *glyph) const
-  {
-    return record.bsearch (variation_selector).get_glyph (codepoint, glyph, this);
-  }
+  { return record.bsearch (variation_selector).get_glyph (codepoint, glyph, this); }
 
   void collect_variation_selectors (hb_set_t *out) const
   {
@@ -774,8 +912,44 @@ struct CmapSubtableFormat14
   }
   void collect_variation_unicodes (hb_codepoint_t variation_selector,
 				   hb_set_t *out) const
+  { record.bsearch (variation_selector).collect_unicodes (out, this); }
+
+  void serialize (hb_serialize_context_t *c,
+		  const hb_set_t *unicodes,
+		  const hb_set_t *glyphs,
+		  const hb_map_t *glyph_map,
+		  const void *src_base)
+  {
+    auto snap = c->snapshot ();
+    unsigned table_initpos = c->length ();
+    const char* init_tail = c->tail;
+
+    if (unlikely (!c->extend_min (*this))) return;
+    this->format = 14;
+
+    const CmapSubtableFormat14 *src_tbl = reinterpret_cast<const CmapSubtableFormat14*> (src_base);
+    for (const VariationSelectorRecord& _ : src_tbl->record)
+      c->copy (_, unicodes, glyphs, glyph_map, src_base, this);
+
+    if (c->length () - table_initpos == CmapSubtableFormat14::min_size)
+      c->revert (snap);
+    else
+    {
+      int tail_len = init_tail - c->tail;
+      c->check_assign (this->length, c->length () - table_initpos + tail_len);
+      c->check_assign (this->record.len, (c->length () - table_initpos - CmapSubtableFormat14::min_size) / VariationSelectorRecord::static_size);
+    }
+  }
+
+  void closure_glyphs (const hb_set_t      *unicodes,
+		       hb_set_t            *glyphset) const
   {
-    record.bsearch (variation_selector).collect_unicodes (out, this);
+    + hb_iter (record)
+    | hb_filter (hb_bool, &VariationSelectorRecord::nonDefaultUVS)
+    | hb_map (&VariationSelectorRecord::nonDefaultUVS)
+    | hb_map (hb_add (this))
+    | hb_apply ([=] (const NonDefaultUVS& _) { _.closure_glyphs (unicodes, glyphset); })
+    ;
   }
 
   bool sanitize (hb_sanitize_context_t *c) const
@@ -828,14 +1002,17 @@ struct CmapSubtable
   }
 
   template<typename Iterator,
-           hb_requires (hb_is_iterator (Iterator))>
+	   hb_requires (hb_is_iterator (Iterator))>
   void serialize (hb_serialize_context_t *c,
 		  Iterator it,
-                  unsigned format)
+		  unsigned format,
+		  const hb_subset_plan_t *plan,
+		  const void *src_base)
   {
     switch (format) {
     case  4: u.format4.serialize (c, it);  return;
     case 12: u.format12.serialize (c, it); return;
+    case 14: u.format14.serialize (c, plan->unicodes, plan->_glyphset, plan->glyph_map, src_base); return;
     default: return;
     }
   }
@@ -892,14 +1069,17 @@ struct EncodingRecord
   }
 
   template<typename Iterator,
-           hb_requires (hb_is_iterator (Iterator))>
+	   hb_requires (hb_is_iterator (Iterator))>
   EncodingRecord* copy (hb_serialize_context_t *c,
-                        Iterator it,
-                        unsigned format,
-                        void *base,
-                        /* INOUT */ unsigned *objidx) const
+			Iterator it,
+			unsigned format,
+			const void *src_base,
+			const void *dst_base,
+			const hb_subset_plan_t *plan,
+			/* INOUT */ unsigned *objidx) const
   {
     TRACE_SERIALIZE (this);
+    auto snap = c->snapshot ();
     auto *out = c->embed (this);
     if (unlikely (!out)) return_trace (nullptr);
     out->subtable = 0;
@@ -908,12 +1088,18 @@ struct EncodingRecord
     {
       CmapSubtable *cmapsubtable = c->push<CmapSubtable> ();
       unsigned origin_length = c->length ();
-      cmapsubtable->serialize (c, it, format);
+      cmapsubtable->serialize (c, it, format, plan, &(src_base+subtable));
       if (c->length () - origin_length > 0) *objidx = c->pop_pack ();
       else c->pop_discard ();
     }
 
-    c->add_link (out->subtable, *objidx, base);
+    if (*objidx == 0)
+    {
+      c->revert (snap);
+      return_trace (nullptr);
+    }
+
+    c->add_link (out->subtable, *objidx, dst_base);
     return_trace (out);
   }
 
@@ -929,27 +1115,40 @@ struct cmap
 {
   static constexpr hb_tag_t tableTag = HB_OT_TAG_cmap;
 
-  template<typename Iterator,
-           hb_requires (hb_is_iterator (Iterator))>
+  template<typename Iterator, typename EncodingRecIter,
+	   hb_requires (hb_is_iterator (Iterator))>
   void serialize (hb_serialize_context_t *c,
-                  Iterator it,
-                  const EncodingRecord *unicode_bmp,
-                  const EncodingRecord *unicode_ucs4,
-                  const EncodingRecord *ms_bmp,
-                  const EncodingRecord *ms_ucs4)
+		  Iterator it,
+		  EncodingRecIter encodingrec_iter,
+		  const void *src_base,
+		  const hb_subset_plan_t *plan)
   {
     if (unlikely (!c->extend_min ((*this))))  return;
     this->version = 0;
 
-    unsigned numTables = (unicode_bmp ? 1 : 0) + (unicode_ucs4 ? 1 : 0) + (ms_bmp ? 1 : 0) + (ms_ucs4 ? 1 : 0);
-    if (unlikely (!c->check_assign(this->encodingRecord.len, numTables))) return;
+    unsigned format4objidx = 0, format12objidx = 0, format14objidx = 0;
 
-    unsigned format4objidx = 0, format12objidx = 0;
-    if (unicode_bmp) c->copy (unicode_bmp, it, 4u, this, &format4objidx);
-    if (unicode_ucs4) c->copy (unicode_ucs4, it, 12u, this, &format12objidx);
-    if (ms_bmp) c->copy (ms_bmp, it, 4u, this, &format4objidx);
-    if (ms_ucs4) c->copy (ms_ucs4, it, 12u, this, &format12objidx);
+    for (const EncodingRecord& _ : encodingrec_iter)
+    {
+      unsigned format = (src_base+_.subtable).u.format;
 
+      if (format == 4) c->copy (_, it, 4u, src_base, this, plan, &format4objidx);
+      else if (format == 12) c->copy (_, it, 12u, src_base, this, plan, &format12objidx);
+      else if (format == 14) c->copy (_, it, 14u, src_base, this, plan, &format14objidx);
+    }
+
+    c->check_assign(this->encodingRecord.len, (c->length () - cmap::min_size)/EncodingRecord::static_size);
+  }
+
+  void closure_glyphs (const hb_set_t      *unicodes,
+		       hb_set_t            *glyphset) const
+  {
+    + hb_iter (encodingRecord)
+    | hb_map (&EncodingRecord::subtable)
+    | hb_map (hb_add (this))
+    | hb_filter ([&] (const CmapSubtable& _) { return _.u.format == 14; })
+    | hb_apply ([=] (const CmapSubtable& _) { _.u.format14.closure_glyphs (unicodes, glyphset); })
+    ;
   }
 
   bool subset (hb_subset_context_t *c) const
@@ -959,31 +1158,55 @@ struct cmap
     cmap *cmap_prime = c->serializer->start_embed<cmap> ();
     if (unlikely (!c->serializer->check_success (cmap_prime))) return_trace (false);
 
-    const EncodingRecord *unicode_bmp = find_encodingrec (0, 3);
-    const EncodingRecord *unicode_ucs4 = find_encodingrec (0, 4);
-    const EncodingRecord *ms_bmp = find_encodingrec (3, 1);
-    const EncodingRecord *ms_ucs4 = find_encodingrec (3, 10);
-    bool has_format12 = find_subtable (12);
+    auto encodingrec_iter =
+    + hb_iter (encodingRecord)
+    | hb_filter ([&] (const EncodingRecord& _)
+		{
+		  if ((_.platformID == 0 && _.encodingID == 3) ||
+		      (_.platformID == 0 && _.encodingID == 4) ||
+		      (_.platformID == 3 && _.encodingID == 1) ||
+		      (_.platformID == 3 && _.encodingID == 10) ||
+		      (this + _.subtable).u.format == 14)
+		    return true;
+
+		  return false;
+	        })
+    ;
+
+
+    if (unlikely (!encodingrec_iter.len ())) return_trace (false);
+
+    const EncodingRecord *unicode_bmp= nullptr, *unicode_ucs4 = nullptr, *ms_bmp = nullptr, *ms_ucs4 = nullptr;
+    bool has_format12 = false;
+
+    for (const EncodingRecord& _ : encodingrec_iter)
+    {
+      unsigned format = (this + _.subtable).u.format;
+      if (format == 12) has_format12 = true;
+
+      const EncodingRecord *table = hb_addressof (_);
+      if      (_.platformID == 0 && _.encodingID ==  3) unicode_bmp = table;
+      else if (_.platformID == 0 && _.encodingID ==  4) unicode_ucs4 = table;
+      else if (_.platformID == 3 && _.encodingID ==  1) ms_bmp = table;
+      else if (_.platformID == 3 && _.encodingID == 10) ms_ucs4 = table;
+    }
 
     if (unlikely (!unicode_bmp && !ms_bmp)) return_trace (false);
     if (unlikely (has_format12 && (!unicode_ucs4 && !ms_ucs4))) return_trace (false);
 
-
     auto it =
     + hb_iter (c->plan->unicodes)
     | hb_map ([&] (hb_codepoint_t _)
-                 {
-                   hb_codepoint_t new_gid = HB_MAP_VALUE_INVALID;
-                   c->plan->new_gid_for_codepoint (_, &new_gid);
-                   return hb_pair_t<hb_codepoint_t, hb_codepoint_t> (_, new_gid);
-                 })
+	      {
+		hb_codepoint_t new_gid = HB_MAP_VALUE_INVALID;
+		c->plan->new_gid_for_codepoint (_, &new_gid);
+		return hb_pair_t<hb_codepoint_t, hb_codepoint_t> (_, new_gid);
+	      })
     | hb_filter ([&] (const hb_pair_t<hb_codepoint_t, hb_codepoint_t> _)
-              {
-                return (_.second != HB_MAP_VALUE_INVALID);
-              })
+		 { return (_.second != HB_MAP_VALUE_INVALID); })
     ;
 
-    cmap_prime->serialize (c->serializer, it, unicode_bmp, unicode_ucs4, ms_bmp, ms_ucs4);
+    cmap_prime->serialize (c->serializer, it, encodingrec_iter, this, c->plan);
     return_trace (true);
   }
 
@@ -1034,9 +1257,9 @@ struct cmap
 
       this->get_glyph_data = subtable;
       if (unlikely (symbol))
-      {
 	this->get_glyph_funcZ = get_glyph_from_symbol<CmapSubtable>;
-      } else {
+      else
+      {
 	switch (subtable->u.format) {
 	/* Accelerate format 4 and format 12. */
 	default:
@@ -1046,20 +1269,20 @@ struct cmap
 	  this->get_glyph_funcZ = get_glyph_from<CmapSubtableFormat12>;
 	  break;
 	case  4:
-	  {
-	    this->format4_accel.init (&subtable->u.format4);
-	    this->get_glyph_data = &this->format4_accel;
-	    this->get_glyph_funcZ = this->format4_accel.get_glyph_func;
-	  }
+	{
+	  this->format4_accel.init (&subtable->u.format4);
+	  this->get_glyph_data = &this->format4_accel;
+	  this->get_glyph_funcZ = this->format4_accel.get_glyph_func;
 	  break;
 	}
+	}
       }
     }
 
     void fini () { this->table.destroy (); }
 
     bool get_nominal_glyph (hb_codepoint_t  unicode,
-				   hb_codepoint_t *glyph) const
+			    hb_codepoint_t *glyph) const
     {
       if (unlikely (!this->get_glyph_funcZ)) return false;
       return this->get_glyph_funcZ (this->get_glyph_data, unicode, glyph);
@@ -1103,18 +1326,12 @@ struct cmap
     }
 
     void collect_unicodes (hb_set_t *out) const
-    {
-      subtable->collect_unicodes (out);
-    }
+    { subtable->collect_unicodes (out); }
     void collect_variation_selectors (hb_set_t *out) const
-    {
-      subtable_uvs->collect_variation_selectors (out);
-    }
+    { subtable_uvs->collect_variation_selectors (out); }
     void collect_variation_unicodes (hb_codepoint_t variation_selector,
 				     hb_set_t *out) const
-    {
-      subtable_uvs->collect_variation_unicodes (variation_selector, out);
-    }
+    { subtable_uvs->collect_variation_unicodes (variation_selector, out); }
 
     protected:
     typedef bool (*hb_cmap_get_glyph_func_t) (const void *obj,
@@ -1161,6 +1378,7 @@ struct cmap
 
     CmapSubtableFormat4::accelerator_t format4_accel;
 
+    public:
     hb_blob_ptr_t<cmap> table;
   };
 
@@ -1181,7 +1399,7 @@ struct cmap
   }
 
   const EncodingRecord *find_encodingrec (unsigned int platform_id,
-                                    unsigned int encoding_id) const
+				    unsigned int encoding_id) const
   {
     EncodingRecord key;
     key.platformID = platform_id;
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-color-cbdt-table.hh b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-color-cbdt-table.hh
index 7955cf65162..2a873594a94 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-color-cbdt-table.hh
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-color-cbdt-table.hh
@@ -226,8 +226,8 @@ struct IndexSubtableRecord
 						   offset, length, format);
   }
 
-  GlyphID			firstGlyphIndex;
-  GlyphID			lastGlyphIndex;
+  HBGlyphID			firstGlyphIndex;
+  HBGlyphID			lastGlyphIndex;
   LOffsetTo<IndexSubtable>	offsetToSubtable;
   public:
   DEFINE_SIZE_STATIC(8);
@@ -251,7 +251,7 @@ struct IndexSubtableArray
       unsigned int firstGlyphIndex = indexSubtablesZ[i].firstGlyphIndex;
       unsigned int lastGlyphIndex = indexSubtablesZ[i].lastGlyphIndex;
       if (firstGlyphIndex <= glyph && glyph <= lastGlyphIndex)
-        return &indexSubtablesZ[i];
+	return &indexSubtablesZ[i];
     }
     return nullptr;
   }
@@ -290,8 +290,8 @@ struct BitmapSizeTable
   HBUINT32		colorRef;
   SBitLineMetrics	horizontal;
   SBitLineMetrics	vertical;
-  GlyphID		startGlyphIndex;
-  GlyphID		endGlyphIndex;
+  HBGlyphID		startGlyphIndex;
+  HBGlyphID		endGlyphIndex;
   HBUINT8		ppemX;
   HBUINT8		ppemY;
   HBUINT8		bitDepth;
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-color-colr-table.hh b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-color-colr-table.hh
index 3447b144dd6..e2ed7c65490 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-color-colr-table.hh
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-color-colr-table.hh
@@ -48,7 +48,7 @@ struct LayerRecord
   }
 
   protected:
-  GlyphID	glyphId;	/* Glyph ID of layer glyph */
+  HBGlyphID	glyphId;	/* Glyph ID of layer glyph */
   Index		colorIdx;	/* Index value to use with a
 				 * selected color palette.
 				 * An index value of 0xFFFF
@@ -75,7 +75,7 @@ struct BaseGlyphRecord
   }
 
   public:
-  GlyphID	glyphId;	/* Glyph ID of reference glyph */
+  HBGlyphID	glyphId;	/* Glyph ID of reference glyph */
   HBUINT16	firstLayerIdx;	/* Index (from beginning of
 				 * the Layer Records) to the
 				 * layer record. There will be
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-color-cpal-table.hh b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-color-cpal-table.hh
index 9ec2957ea2c..76df889517b 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-color-cpal-table.hh
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-color-cpal-table.hh
@@ -147,7 +147,7 @@ struct CPAL
       unsigned int count = hb_min ((unsigned) hb_max ((int) (numColors - start_offset), 0), *color_count);
       *color_count = count;
       for (unsigned int i = 0; i < count; i++)
-        colors[i] = segment_colors[i]; /* Bound-checked read. */
+	colors[i] = segment_colors[i]; /* Bound-checked read. */
     }
     return numColors;
   }
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-color-sbix-table.hh b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-color-sbix-table.hh
index 8a915a6619f..6089027f873 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-color-sbix-table.hh
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-color-sbix-table.hh
@@ -125,7 +125,7 @@ struct SBIXStrike
 		imageOffsetsZ;	/* Offset from the beginning of the strike data header
 				 * to bitmap data for an individual glyph ID. */
   public:
-  DEFINE_SIZE_STATIC (8);
+  DEFINE_SIZE_ARRAY (4, imageOffsetsZ);
 };
 
 struct sbix
@@ -173,11 +173,11 @@ struct sbix
     {
       unsigned count = table->strikes.len;
       if (unlikely (!count))
-        return Null(SBIXStrike);
+	return Null(SBIXStrike);
 
       unsigned int requested_ppem = hb_max (font->x_ppem, font->y_ppem);
       if (!requested_ppem)
-        requested_ppem = 1<<30; /* Choose largest strike. */
+	requested_ppem = 1<<30; /* Choose largest strike. */
       /* TODO Add DPI sensitivity as well? */
       unsigned int best_i = 0;
       unsigned int best_ppem = table->get_strike (0).ppem;
@@ -201,7 +201,7 @@ struct sbix
       HBUINT8	signature[8];
       struct
       {
-        struct
+	struct
 	{
 	  HBUINT32	length;
 	  Tag		type;
@@ -226,7 +226,7 @@ struct sbix
       /* Following code is safe to call even without data.
        * But faster to short-circuit. */
       if (!has_data ())
-        return false;
+	return false;
 
       int x_offset = 0, y_offset = 0;
       unsigned int strike_ppem = 0;
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-font.cc b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-font.cc
index 7d6213572b1..e6288b44545 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-font.cc
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-font.cc
@@ -208,20 +208,20 @@ hb_ot_get_glyph_extents (hb_font_t *font,
 #ifndef HB_NO_OT_FONT_GLYPH_NAMES
 static hb_bool_t
 hb_ot_get_glyph_name (hb_font_t *font HB_UNUSED,
-                      void *font_data,
-                      hb_codepoint_t glyph,
-                      char *name, unsigned int size,
-                      void *user_data HB_UNUSED)
+		      void *font_data,
+		      hb_codepoint_t glyph,
+		      char *name, unsigned int size,
+		      void *user_data HB_UNUSED)
 {
   const hb_ot_face_t *ot_face = (const hb_ot_face_t *) font_data;
   return ot_face->post->get_glyph_name (glyph, name, size);
 }
 static hb_bool_t
 hb_ot_get_glyph_from_name (hb_font_t *font HB_UNUSED,
-                           void *font_data,
-                           const char *name, int len,
-                           hb_codepoint_t *glyph,
-                           void *user_data HB_UNUSED)
+			   void *font_data,
+			   const char *name, int len,
+			   hb_codepoint_t *glyph,
+			   void *user_data HB_UNUSED)
 {
   const hb_ot_face_t *ot_face = (const hb_ot_face_t *) font_data;
   return ot_face->post->get_glyph_from_name (name, len, glyph);
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-glyf-table.hh b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-glyf-table.hh
index 76efdc9b8eb..9a791bbf031 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-glyf-table.hh
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-glyf-table.hh
@@ -1,5 +1,6 @@
 /*
  * Copyright © 2015  Google, Inc.
+ * Copyright © 2019  Ebrahim Byagowi
  *
  *  This is part of HarfBuzz, a text shaping library.
  *
@@ -53,11 +54,12 @@ struct loca
   }
 
   protected:
-  UnsizedArrayOf<HBUINT8>	dataZ;		/* Location data. */
+  UnsizedArrayOf<HBUINT8>
+		dataZ;	/* Location data. */
   public:
-  DEFINE_SIZE_MIN (0); /* In reality, this is UNBOUNDED() type; but since we always
-			* check the size externally, allow Null() object of it by
-			* defining it _MIN instead. */
+  DEFINE_SIZE_MIN (0);  /* In reality, this is UNBOUNDED() type; but since we always
+			 * check the size externally, allow Null() object of it by
+			 * defining it _MIN instead. */
 };
 
 
@@ -93,7 +95,9 @@ struct glyf
 
     if (unlikely (!loca_prime_data)) return false;
 
-    DEBUG_MSG(SUBSET, nullptr, "loca entry_size %d num_offsets %d max_offset %d size %d", entry_size, num_offsets, max_offset, entry_size * num_offsets);
+    DEBUG_MSG (SUBSET, nullptr, "loca entry_size %d num_offsets %d "
+				"max_offset %d size %d",
+	       entry_size, num_offsets, max_offset, entry_size * num_offsets);
 
     if (use_short_loca)
       _write_loca (padded_offsets, 1, hb_array ((HBUINT16*) loca_prime_data, num_offsets));
@@ -122,27 +126,24 @@ struct glyf
     unsigned int offset = 0;
     dest << 0;
     + it
-    | hb_map ([=, &offset] (unsigned int padded_size) {
-      offset += padded_size;
-      DEBUG_MSG(SUBSET, nullptr, "loca entry offset %d", offset);
-      return offset >> right_shift;
-    })
+    | hb_map ([=, &offset] (unsigned int padded_size)
+	      {
+		offset += padded_size;
+		DEBUG_MSG (SUBSET, nullptr, "loca entry offset %d", offset);
+		return offset >> right_shift;
+	      })
     | hb_sink (dest)
     ;
   }
 
   // requires source of SubsetGlyph complains the identifier isn't declared
   template <typename Iterator>
-  bool serialize(hb_serialize_context_t *c,
-		 Iterator it,
-		 const hb_subset_plan_t *plan)
+  bool serialize (hb_serialize_context_t *c,
+		  Iterator it,
+		  const hb_subset_plan_t *plan)
   {
     TRACE_SERIALIZE (this);
-
-    + it
-    | hb_apply ([=] (const SubsetGlyph& _) { _.serialize (c, plan); })
-    ;
-
+    for (const auto &_ : it) _.serialize (c, plan);
     return_trace (true);
   }
 
@@ -167,7 +168,8 @@ struct glyf
     ;
 
     if (c->serializer->in_error ()) return_trace (false);
-    return_trace (c->serializer->check_success (_add_loca_and_head (c->plan, padded_offsets)));
+    return_trace (c->serializer->check_success (_add_loca_and_head (c->plan,
+								    padded_offsets)));
   }
 
   template <typename SubsetGlyph>
@@ -179,23 +181,26 @@ struct glyf
     glyf.init (plan->source);
 
     + hb_range (plan->num_output_glyphs ())
-    | hb_map ([&] (hb_codepoint_t new_gid) {
-      SubsetGlyph subset_glyph = {0};
-      subset_glyph.new_gid = new_gid;
-
-      // should never fail: all old gids should be mapped
-      if (!plan->old_gid_for_new_gid (new_gid, &subset_glyph.old_gid)) return subset_glyph;
-
-      subset_glyph.source_glyph = glyf.bytes_for_glyph ((const char *) this, subset_glyph.old_gid);
-      if (plan->drop_hints) subset_glyph.drop_hints (glyf);
-      else subset_glyph.dest_start = subset_glyph.source_glyph;
-
-      return subset_glyph;
-    })
+    | hb_map ([&] (hb_codepoint_t new_gid)
+	      {
+		SubsetGlyph subset_glyph = {0};
+		subset_glyph.new_gid = new_gid;
+
+		// should never fail: all old gids should be mapped
+		if (!plan->old_gid_for_new_gid (new_gid, &subset_glyph.old_gid))
+		  return subset_glyph;
+
+		subset_glyph.source_glyph = glyf.bytes_for_glyph ((const char *) this,
+								  subset_glyph.old_gid);
+		if (plan->drop_hints) subset_glyph.drop_hints (glyf);
+		else subset_glyph.dest_start = subset_glyph.source_glyph;
+
+		return subset_glyph;
+	      })
     | hb_sink (glyphs)
     ;
 
-    glyf.fini();
+    glyf.fini ();
   }
 
   static void
@@ -221,30 +226,34 @@ struct glyf
   static void
   _zero_instruction_length (hb_bytes_t glyph)
   {
-    const GlyphHeader &glyph_header = StructAtOffset<GlyphHeader> (&glyph, 0);
-    int16_t num_contours = (int16_t) glyph_header.numberOfContours;
-    if (num_contours <= 0) return;  // only for simple glyphs
+    const GlyphHeader &glyph_header = *glyph.as<GlyphHeader> ();
+    if (!glyph_header.is_simple_glyph ()) return;  // only for simple glyphs
 
-    const HBUINT16 &instruction_length = StructAtOffset<HBUINT16> (&glyph, GlyphHeader::static_size + 2 * num_contours);
-    (HBUINT16 &) instruction_length = 0;
+    unsigned int instruction_len_offset = glyph_header.simple_instruction_len_offset ();
+    const HBUINT16 &instruction_len = StructAtOffset<HBUINT16> (&glyph,
+								instruction_len_offset);
+    (HBUINT16 &) instruction_len = 0;
   }
 
   static bool _remove_composite_instruction_flag (hb_bytes_t glyph)
   {
-    const GlyphHeader &glyph_header = StructAtOffset<GlyphHeader> (&glyph, 0);
-    if (glyph_header.numberOfContours >= 0) return true;  // only for composites
+    const GlyphHeader &glyph_header = *glyph.as<GlyphHeader> ();
+    if (!glyph_header.is_composite_glyph ()) return true;  // only for composites
 
     /* remove WE_HAVE_INSTRUCTIONS from flags in dest */
     OT::glyf::CompositeGlyphHeader::Iterator composite_it;
-    if (unlikely (!OT::glyf::CompositeGlyphHeader::get_iterator (&glyph, glyph.length, &composite_it))) return false;
+    if (unlikely (!OT::glyf::CompositeGlyphHeader::get_iterator (&glyph, glyph.length,
+								 &composite_it)))
+      return false;
     const OT::glyf::CompositeGlyphHeader *composite_header;
-    do {
+    do
+    {
       composite_header = composite_it.current;
       OT::HBUINT16 *flags = const_cast<OT::HBUINT16 *> (&composite_header->flags);
       *flags = (uint16_t) *flags & ~OT::glyf::CompositeGlyphHeader::WE_HAVE_INSTRUCTIONS;
     } while (composite_it.move_to_next ());
     return true;
-}
+  }
 
   static bool
   _add_head_and_set_loca_version (hb_subset_plan_t *plan, bool use_short_loca)
@@ -266,21 +275,42 @@ struct glyf
 
   struct GlyphHeader
   {
-    HBINT16		numberOfContours;	/* If the number of contours is
-						 * greater than or equal to zero,
-						 * this is a simple glyph; if negative,
-						 * this is a composite glyph. */
-    FWORD		xMin;			/* Minimum x for coordinate data. */
-    FWORD		yMin;			/* Minimum y for coordinate data. */
-    FWORD		xMax;			/* Maximum x for coordinate data. */
-    FWORD		yMax;			/* Maximum y for coordinate data. */
+    unsigned int simple_instruction_len_offset () const
+    { return static_size + 2 * numberOfContours; }
+
+    unsigned int simple_length (unsigned int instruction_len) const
+    { return simple_instruction_len_offset () + 2 + instruction_len; }
+
+    bool is_composite_glyph () const { return numberOfContours < 0; }
+    bool is_simple_glyph () const    { return numberOfContours > 0; }
+
+    void get_extents (hb_glyph_extents_t *extents) const
+    {
+      extents->x_bearing = hb_min (xMin, xMax);
+      extents->y_bearing = hb_max (yMin, yMax);
+      extents->width     = hb_max (xMin, xMax) - extents->x_bearing;
+      extents->height    = hb_min (yMin, yMax) - extents->y_bearing;
+    }
 
+    bool has_data () const { return numberOfContours; }
+
+    protected:
+    HBINT16	numberOfContours;/* If the number of contours is
+				  * greater than or equal to zero,
+				  * this is a simple glyph; if negative,
+				  * this is a composite glyph. */
+    FWORD	xMin;		 /* Minimum x for coordinate data. */
+    FWORD	yMin;		 /* Minimum y for coordinate data. */
+    FWORD	xMax;		 /* Maximum x for coordinate data. */
+    FWORD	yMax;		 /* Maximum y for coordinate data. */
+    public:
     DEFINE_SIZE_STATIC (10);
   };
 
   struct CompositeGlyphHeader
   {
-    enum composite_glyph_flag_t {
+    enum composite_glyph_flag_t
+    {
       ARG_1_AND_2_ARE_WORDS =      0x0001,
       ARGS_ARE_XY_VALUES =         0x0002,
       ROUND_XY_TO_GRID =           0x0004,
@@ -296,7 +326,7 @@ struct glyf
     };
 
     HBUINT16 flags;
-    GlyphID  glyphIndex;
+    HBGlyphID  glyphIndex;
 
     unsigned int get_size () const
     {
@@ -340,8 +370,8 @@ struct glyf
       bool in_range (const CompositeGlyphHeader *composite) const
       {
 	return (const char *) composite >= glyph_start
-	  && ((const char *) composite + CompositeGlyphHeader::min_size) <= glyph_end
-	  && ((const char *) composite + composite->get_size ()) <= glyph_end;
+	    && ((const char *) composite + CompositeGlyphHeader::min_size) <= glyph_end
+	    && ((const char *) composite + composite->get_size ()) <= glyph_end;
       }
     };
 
@@ -349,11 +379,10 @@ struct glyf
 			      unsigned int length,
 			      CompositeGlyphHeader::Iterator *iterator /* OUT */)
     {
-      if (length < GlyphHeader::static_size)
-	return false; /* Empty glyph; zero extents. */
+      const GlyphHeader &glyph_header = *hb_bytes_t (glyph_data, length).as<GlyphHeader> ();
+      if (!glyph_header.has_data ()) return false; /* Empty glyph; zero extents. */
 
-      const GlyphHeader &glyph_header = StructAtOffset<GlyphHeader> (glyph_data, 0);
-      if (glyph_header.numberOfContours < 0)
+      if (glyph_header.is_composite_glyph ())
       {
 	const CompositeGlyphHeader *possible =
 	  &StructAfter<CompositeGlyphHeader, GlyphHeader> (glyph_header);
@@ -416,7 +445,8 @@ struct glyf
 						 composite);
     }
 
-    enum simple_glyph_flag_t {
+    enum simple_glyph_flag_t
+    {
       FLAG_ON_CURVE = 0x01,
       FLAG_X_SHORT = 0x02,
       FLAG_Y_SHORT = 0x04,
@@ -431,21 +461,20 @@ struct glyf
     bool remove_padding (unsigned int start_offset,
 			 unsigned int *end_offset) const
     {
-      if (*end_offset - start_offset < GlyphHeader::static_size) return true;
-
       const char *glyph = ((const char *) glyf_table) + start_offset;
-      const char * const glyph_end = glyph + (*end_offset - start_offset);
-      const GlyphHeader &glyph_header = StructAtOffset<GlyphHeader> (glyph, 0);
-      int16_t num_contours = (int16_t) glyph_header.numberOfContours;
+      unsigned int glyph_length = *end_offset - start_offset;
+      const GlyphHeader &glyph_header = *hb_bytes_t (glyph, glyph_length).as<GlyphHeader> ();
+      if (!glyph_header.has_data ()) return true;
 
-      if (num_contours < 0)
+      const char *glyph_end = glyph + glyph_length;
+      if (glyph_header.is_composite_glyph ())
 	/* Trimming for composites not implemented.
 	 * If removing hints it falls out of that. */
 	return true;
-      else if (num_contours > 0)
+      else
       {
 	/* simple glyph w/contours, possibly trimmable */
-	glyph += GlyphHeader::static_size + 2 * num_contours;
+	glyph += glyph_header.simple_instruction_len_offset ();
 
 	if (unlikely (glyph + 2 >= glyph_end)) return false;
 	uint16_t nCoordinates = (uint16_t) StructAtOffset<HBUINT16> (glyph - 2, 0) + 1;
@@ -466,7 +495,7 @@ struct glyf
 	  {
 	    if (glyph >= glyph_end)
 	    {
-	      DEBUG_MSG(SUBSET, nullptr, "Bad flag");
+	      DEBUG_MSG (SUBSET, nullptr, "Bad flag");
 	      return false;
 	    }
 	    repeat = ((uint8_t) *glyph) + 1;
@@ -489,7 +518,8 @@ struct glyf
 
 	if (coordsWithFlags != nCoordinates)
 	{
-	  DEBUG_MSG(SUBSET, nullptr, "Expect %d coords to have flags, got flags for %d", nCoordinates, coordsWithFlags);
+	  DEBUG_MSG (SUBSET, nullptr, "Expect %d coords to have flags, got flags for %d",
+		     nCoordinates, coordsWithFlags);
 	  return false;
 	}
 	glyph += coordBytes;
@@ -530,52 +560,60 @@ struct glyf
     bool get_instruction_length (hb_bytes_t glyph,
 				 unsigned int * length /* OUT */) const
     {
+      const GlyphHeader &glyph_header = *glyph.as<GlyphHeader> ();
       /* Empty glyph; no instructions. */
-      if (glyph.length < GlyphHeader::static_size)
+      if (!glyph_header.has_data ())
       {
 	*length = 0;
 	// only 0 byte glyphs are healthy when missing GlyphHeader
 	return glyph.length == 0;
       }
-      const GlyphHeader &glyph_header = StructAtOffset<GlyphHeader> (&glyph, 0);
-      int16_t num_contours = (int16_t) glyph_header.numberOfContours;
-      if (num_contours < 0)
+      if (glyph_header.is_composite_glyph ())
       {
 	unsigned int start = glyph.length;
 	unsigned int end = glyph.length;
 	unsigned int glyph_offset = &glyph - glyf_table;
 	CompositeGlyphHeader::Iterator composite_it;
-	if (unlikely (!CompositeGlyphHeader::get_iterator (&glyph, glyph.length, &composite_it))) return false;
+	if (unlikely (!CompositeGlyphHeader::get_iterator (&glyph, glyph.length,
+							   &composite_it)))
+	  return false;
 	const CompositeGlyphHeader *last;
-	do {
+	do
+	{
 	  last = composite_it.current;
 	} while (composite_it.move_to_next ());
 
 	if ((uint16_t) last->flags & CompositeGlyphHeader::WE_HAVE_INSTRUCTIONS)
-	  start = ((char *) last - (char *) glyf_table->dataZ.arrayZ) + last->get_size () - glyph_offset;
+	  start = ((char *) last - (char *) glyf_table->dataZ.arrayZ)
+		+ last->get_size () - glyph_offset;
 	if (unlikely (start > end))
 	{
-	  DEBUG_MSG(SUBSET, nullptr, "Invalid instruction offset, %d is outside %d byte buffer", start, glyph.length);
+	  DEBUG_MSG (SUBSET, nullptr, "Invalid instruction offset, %d is outside "
+				      "%d byte buffer", start, glyph.length);
 	  return false;
 	}
 	*length = end - start;
       }
       else
       {
-	unsigned int instruction_length_offset = GlyphHeader::static_size + 2 * num_contours;
-	if (unlikely (instruction_length_offset + 2 > glyph.length))
+	unsigned int instruction_len_offset = glyph_header.simple_instruction_len_offset ();
+	if (unlikely (instruction_len_offset + 2 > glyph.length))
 	{
-	  DEBUG_MSG(SUBSET, nullptr, "Glyph size is too short, missing field instructionLength.");
+	  DEBUG_MSG (SUBSET, nullptr, "Glyph size is too short, missing field "
+				      "instructionLength.");
 	  return false;
 	}
 
-	const HBUINT16 &instruction_length = StructAtOffset<HBUINT16> (&glyph, instruction_length_offset);
-	if (unlikely (instruction_length_offset + instruction_length > glyph.length)) // Out of bounds of the current glyph
+	const HBUINT16 &instruction_len = StructAtOffset<HBUINT16> (&glyph,
+								    instruction_len_offset);
+	/* Out of bounds of the current glyph */
+	if (unlikely (glyph_header.simple_length (instruction_len) > glyph.length))
 	{
-	  DEBUG_MSG(SUBSET, nullptr, "The instructions array overruns the glyph's boundaries.");
+	  DEBUG_MSG (SUBSET, nullptr, "The instructions array overruns the "
+				      "glyph's boundaries.");
 	  return false;
 	}
-	*length = (uint16_t) instruction_length;
+	*length = (uint16_t) instruction_len;
       }
       return true;
     }
@@ -586,37 +624,28 @@ struct glyf
       if (!get_offsets (glyph, &start_offset, &end_offset))
 	return false;
 
-      if (end_offset - start_offset < GlyphHeader::static_size)
-	return true; /* Empty glyph; zero extents. */
-
-      const GlyphHeader &glyph_header = StructAtOffset<GlyphHeader> (glyf_table, start_offset);
-
-      extents->x_bearing = hb_min (glyph_header.xMin, glyph_header.xMax);
-      extents->y_bearing = hb_max (glyph_header.yMin, glyph_header.yMax);
-      extents->width     = hb_max (glyph_header.xMin, glyph_header.xMax) - extents->x_bearing;
-      extents->height    = hb_min (glyph_header.yMin, glyph_header.yMax) - extents->y_bearing;
-
+      hb_bytes_t ((const char *) glyf_table + start_offset,
+		  end_offset - start_offset).as<GlyphHeader> ()->get_extents (extents);
       return true;
     }
 
-  hb_bytes_t bytes_for_glyph (const char * glyf, hb_codepoint_t gid)
-  {
-    unsigned int start_offset, end_offset;
-    if (unlikely (!(get_offsets (gid, &start_offset, &end_offset) &&
-      remove_padding (start_offset, &end_offset))))
+    hb_bytes_t bytes_for_glyph (const char *glyf, hb_codepoint_t gid)
     {
-      DEBUG_MSG(SUBSET, nullptr, "Unable to get offset or remove padding for %d", gid);
-      return hb_bytes_t ();
-    }
-    hb_bytes_t glyph = hb_bytes_t (glyf + start_offset, end_offset - start_offset);
-    if (glyph.length == 0) return glyph;
-    if (unlikely (glyph.length < GlyphHeader::static_size))
-    {
-      DEBUG_MSG(SUBSET, nullptr, "Glyph size smaller than minimum header %d", gid);
-      return hb_bytes_t ();
+      unsigned int start_offset, end_offset;
+      if (unlikely (!(get_offsets (gid, &start_offset, &end_offset) &&
+		      remove_padding (start_offset, &end_offset))))
+      {
+	DEBUG_MSG (SUBSET, nullptr, "Unable to get offset or remove padding for %d", gid);
+	return hb_bytes_t ();
+      }
+      hb_bytes_t glyph_bytes = hb_bytes_t (glyf + start_offset, end_offset - start_offset);
+      if (!glyph_bytes.as<GlyphHeader> ()->has_data ())
+      {
+	DEBUG_MSG (SUBSET, nullptr, "Empty or invalid glyph size, %d", gid);
+	return hb_bytes_t ();
+      }
+      return glyph_bytes;
     }
-    return glyph;
-  }
 
     private:
     bool short_offset;
@@ -625,99 +654,93 @@ struct glyf
     hb_blob_ptr_t<glyf> glyf_table;
   };
 
-
   struct SubsetGlyph
   {
     hb_codepoint_t new_gid;
     hb_codepoint_t old_gid;
     hb_bytes_t source_glyph;
-    hb_bytes_t dest_start;  // region of source_glyph to copy first
-    hb_bytes_t dest_end;    // region of source_glyph to copy second
-
+    hb_bytes_t dest_start;  /* region of source_glyph to copy first */
+    hb_bytes_t dest_end;    /* region of source_glyph to copy second */
 
-  bool serialize (hb_serialize_context_t *c,
-		  const hb_subset_plan_t *plan) const
-  {
-    TRACE_SERIALIZE (this);
+    bool serialize (hb_serialize_context_t *c,
+		    const hb_subset_plan_t *plan) const
+    {
+      TRACE_SERIALIZE (this);
 
-    hb_bytes_t dest_glyph = dest_start.copy(c);
-    dest_glyph = hb_bytes_t (&dest_glyph, dest_glyph.length + dest_end.copy(c).length);
-    unsigned int pad_length = padding ();
-    DEBUG_MSG(SUBSET, nullptr, "serialize %d byte glyph, width %d pad %d", dest_glyph.length, dest_glyph.length  + pad_length, pad_length);
+      hb_bytes_t dest_glyph = dest_start.copy (c);
+      dest_glyph = hb_bytes_t (&dest_glyph, dest_glyph.length + dest_end.copy (c).length);
+      unsigned int pad_length = padding ();
+      DEBUG_MSG (SUBSET, nullptr, "serialize %d byte glyph, width %d pad %d",
+		 dest_glyph.length, dest_glyph.length  + pad_length, pad_length);
 
-    HBUINT8 pad;
-    pad = 0;
-    while (pad_length > 0)
-    {
-      c->embed(pad);
-      pad_length--;
-    }
+      HBUINT8 pad;
+      pad = 0;
+      while (pad_length > 0)
+      {
+	c->embed (pad);
+	pad_length--;
+      }
 
-    if (dest_glyph.length)
-    {
-      _fix_component_gids (plan, dest_glyph);
-      if (plan->drop_hints)
+      if (dest_glyph.length)
       {
-	_zero_instruction_length (dest_glyph);
-	c->check_success (_remove_composite_instruction_flag (dest_glyph));
+	_fix_component_gids (plan, dest_glyph);
+	if (plan->drop_hints)
+	{
+	  _zero_instruction_length (dest_glyph);
+	  c->check_success (_remove_composite_instruction_flag (dest_glyph));
+	}
       }
-    }
 
-    return_trace (true);
-  }
+      return_trace (true);
+    }
 
     void drop_hints (const OT::glyf::accelerator_t& glyf)
     {
       if (source_glyph.length == 0) return;
 
-      unsigned int instruction_length = 0;
-      if (!glyf.get_instruction_length (source_glyph, &instruction_length))
+      unsigned int instruction_len = 0;
+      if (!glyf.get_instruction_length (source_glyph, &instruction_len))
       {
-	 DEBUG_MSG(SUBSET, nullptr, "Unable to read instruction length for new_gid %d", new_gid);
+	DEBUG_MSG (SUBSET, nullptr, "Unable to read instruction length for new_gid %d",
+		   new_gid);
 	return ;
       }
 
-      const GlyphHeader& header = StructAtOffset<GlyphHeader> (&source_glyph, 0);
-      int16_t num_contours = (int16_t) header.numberOfContours;
-      DEBUG_MSG(SUBSET, nullptr, "new_gid %d (%d contours) drop %d instruction bytes from %d byte source glyph", new_gid, num_contours, instruction_length, source_glyph.length);
-      if (num_contours < 0)
+      const GlyphHeader& header = *source_glyph.as<GlyphHeader> ();
+      DEBUG_MSG (SUBSET, nullptr, "new_gid %d drop %d instruction bytes "
+				  "from %d byte source glyph",
+		 new_gid, instruction_len, source_glyph.length);
+      if (header.is_composite_glyph ())
       {
-	// composite, just chop instructions off the end
-	dest_start = hb_bytes_t (&source_glyph, source_glyph.length - instruction_length);
+	/* just chop instructions off the end for composite glyphs */
+	dest_start = hb_bytes_t (&source_glyph, source_glyph.length - instruction_len);
       }
       else
       {
-	// simple glyph
-	dest_start = hb_bytes_t (&source_glyph, GlyphHeader::static_size + 2 * header.numberOfContours + 2);
-	dest_end = hb_bytes_t (&source_glyph + dest_start.length + instruction_length,
-			       source_glyph.length - dest_start.length - instruction_length);
-DEBUG_MSG(SUBSET, nullptr, "source_len %d start len %d instruction_len %d end len %d", source_glyph.length, dest_start.length, instruction_length, dest_end.length);
+	unsigned int glyph_length = header.simple_length (instruction_len);
+	dest_start = hb_bytes_t (&source_glyph, glyph_length - instruction_len);
+	dest_end = hb_bytes_t (&source_glyph + glyph_length,
+			       source_glyph.length - glyph_length);
+	DEBUG_MSG (SUBSET, nullptr, "source_len %d start len %d glyph_len %d "
+				    "instruction_len %d end len %d",
+		   source_glyph.length, dest_start.length, glyph_length,
+		   instruction_len, dest_end.length);
       }
     }
 
-    unsigned int length () const
-    {
-      return dest_start.length + dest_end.length;
-    }
-
-    // pad to 2 to ensure 2-byte loca will be ok
-    unsigned int padding () const
-    {
-      return length () % 2;
-    }
-
-    unsigned int padded_size () const
-    {
-      return length () + padding ();
-    }
+    unsigned int length () const      { return dest_start.length + dest_end.length; }
+    /* pad to 2 to ensure 2-byte loca will be ok */
+    unsigned int padding () const     { return length () % 2; }
+    unsigned int padded_size () const { return length () + padding (); }
   };
 
   protected:
-  UnsizedArrayOf<HBUINT8>	dataZ;		/* Glyphs data. */
+  UnsizedArrayOf<HBUINT8>
+		dataZ;	/* Glyphs data. */
   public:
-  DEFINE_SIZE_MIN (0); /* In reality, this is UNBOUNDED() type; but since we always
-			* check the size externally, allow Null() object of it by
-			* defining it _MIN instead. */
+  DEFINE_SIZE_MIN (0);	/* In reality, this is UNBOUNDED() type; but since we always
+			 * check the size externally, allow Null() object of it by
+			 * defining it _MIN instead. */
 };
 
 struct glyf_accelerator_t : glyf::accelerator_t {};
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-hmtx-table.hh b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-hmtx-table.hh
index 11a588e3814..6b2cc866265 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-hmtx-table.hh
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-hmtx-table.hh
@@ -66,7 +66,7 @@ struct hmtxvmtx
 
 
   bool subset_update_header (hb_subset_plan_t *plan,
-                             unsigned int num_hmetrics) const
+			     unsigned int num_hmetrics) const
   {
     hb_blob_t *src_blob = hb_sanitize_context_t ().reference_table<H> (plan->source, H::tableTag);
     hb_blob_t *dest_blob = hb_blob_copy_writable_or_fail (src_blob);
@@ -87,30 +87,30 @@ struct hmtxvmtx
   }
 
   template<typename Iterator,
-           hb_requires (hb_is_iterator (Iterator))>
+	   hb_requires (hb_is_iterator (Iterator))>
   void serialize (hb_serialize_context_t *c,
-                  Iterator it,
-                  unsigned num_advances)
+		  Iterator it,
+		  unsigned num_advances)
   {
     unsigned idx = 0;
     + it
     | hb_apply ([c, &idx, num_advances] (const hb_item_type<Iterator>& _)
-                {
-                  if (idx < num_advances)
-                  {
-                    LongMetric lm;
-                    lm.advance = _.first;
-                    lm.sb = _.second;
-                    if (unlikely (!c->embed<LongMetric> (&lm))) return;
-                  }
-                  else
-                  {
-                    FWORD *sb = c->allocate_size<FWORD> (FWORD::static_size);
-                    if (unlikely (!sb)) return;
-                    *sb = _.second;
-                  }
-                  idx++;
-                })
+		{
+		  if (idx < num_advances)
+		  {
+		    LongMetric lm;
+		    lm.advance = _.first;
+		    lm.sb = _.second;
+		    if (unlikely (!c->embed<LongMetric> (&lm))) return;
+		  }
+		  else
+		  {
+		    FWORD *sb = c->allocate_size<FWORD> (FWORD::static_size);
+		    if (unlikely (!sb)) return;
+		    *sb = _.second;
+		  }
+		  idx++;
+		})
     ;
   }
 
@@ -131,8 +131,8 @@ struct hmtxvmtx
 	{
 	  hb_codepoint_t old_gid;
 	  if (c->plan->old_gid_for_new_gid (_, &old_gid))
-            return hb_pair (_mtx.get_advance (old_gid), _mtx.get_side_bearing (old_gid));
-          else
+	    return hb_pair (_mtx.get_advance (old_gid), _mtx.get_side_bearing (old_gid));
+	  else
 	    return hb_pair (0u, 0u);
 	})
     ;
@@ -158,7 +158,7 @@ struct hmtxvmtx
     friend struct hmtxvmtx;
 
     void init (hb_face_t *face,
-               unsigned int default_advance_ = 0)
+	       unsigned int default_advance_ = 0)
     {
       default_advance = default_advance_ ? default_advance_ : hb_face_get_upem (face);
 
@@ -194,10 +194,10 @@ struct hmtxvmtx
     unsigned int get_side_bearing (hb_codepoint_t glyph) const
     {
       if (glyph < num_advances)
-        return table->longMetricZ[glyph].sb;
+	return table->longMetricZ[glyph].sb;
 
       if (unlikely (glyph >= num_metrics))
-        return 0;
+	return 0;
 
       const FWORD *bearings = (const FWORD *) &table->longMetricZ[num_advances];
       return bearings[glyph - num_advances];
@@ -234,12 +234,12 @@ struct hmtxvmtx
     {
       unsigned int num_advances = plan->num_output_glyphs ();
       unsigned int last_advance = _advance_for_new_gid (plan,
-                                                        num_advances - 1);
+							num_advances - 1);
       while (num_advances > 1 &&
-             last_advance == _advance_for_new_gid (plan,
-                                                   num_advances - 2))
+	     last_advance == _advance_for_new_gid (plan,
+						   num_advances - 2))
       {
-        num_advances--;
+	num_advances--;
       }
 
       return num_advances;
@@ -247,11 +247,11 @@ struct hmtxvmtx
 
     private:
     unsigned int _advance_for_new_gid (const hb_subset_plan_t *plan,
-                                       hb_codepoint_t new_gid) const
+				       hb_codepoint_t new_gid) const
     {
       hb_codepoint_t old_gid;
       if (!plan->old_gid_for_new_gid (new_gid, &old_gid))
-        return 0;
+	return 0;
 
       return get_advance (old_gid);
     }
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-layout-base-table.hh b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-layout-base-table.hh
index 7c00a1313eb..02fe14fa062 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-layout-base-table.hh
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-layout-base-table.hh
@@ -73,7 +73,7 @@ struct BaseCoordFormat2
   protected:
   HBUINT16	format;		/* Format identifier--format = 2 */
   FWORD		coordinate;	/* X or Y value, in design units */
-  GlyphID	referenceGlyph;	/* Glyph ID of control glyph */
+  HBGlyphID	referenceGlyph;	/* Glyph ID of control glyph */
   HBUINT16	coordPoint;	/* Index of contour point on the
 				 * reference glyph */
   public:
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-layout-common.hh b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-layout-common.hh
index 0866760bdc7..73c28caabd5 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-layout-common.hh
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-layout-common.hh
@@ -172,8 +172,8 @@ struct RangeRecord
   bool add_coverage (set_t *glyphs) const
   { return glyphs->add_range (start, end); }
 
-  GlyphID	start;		/* First GlyphID in the range */
-  GlyphID	end;		/* Last GlyphID in the range */
+  HBGlyphID	start;		/* First GlyphID in the range */
+  HBGlyphID	end;		/* Last GlyphID in the range */
   HBUINT16	value;		/* Value */
   public:
   DEFINE_SIZE_STATIC (6);
@@ -540,7 +540,7 @@ struct FeatureParams
   FeatureParamsCharacterVariants	characterVariants;
   } u;
   public:
-  DEFINE_SIZE_STATIC (17);
+  DEFINE_SIZE_MIN (0);
 };
 
 struct Feature
@@ -780,7 +780,7 @@ struct Lookup
   HBUINT16	lookupFlag;		/* Lookup qualifiers */
   ArrayOf<Offset16>
 		subTable;		/* Array of SubTables */
-/*HBUINT16	markFilteringSetX[VAR];*//* Index (base 0) into GDEF mark glyph sets
+/*HBUINT16	markFilteringSetX[HB_VAR_ARRAY];*//* Index (base 0) into GDEF mark glyph sets
 					 * structure. This field is only present if bit
 					 * UseMarkFilteringSet of lookup flags is set. */
   public:
@@ -856,7 +856,7 @@ struct CoverageFormat1
 
   protected:
   HBUINT16	coverageFormat;	/* Format identifier--format = 1 */
-  SortedArrayOf<GlyphID>
+  SortedArrayOf<HBGlyphID>
 		glyphArray;	/* Array of GlyphIDs--in numerical order */
   public:
   DEFINE_SIZE_ARRAY (4, glyphArray);
@@ -895,7 +895,7 @@ struct CoverageFormat2
     for (auto g: glyphs)
     {
       if (last + 1 != g)
-        num_ranges++;
+	num_ranges++;
       last = g;
     }
 
@@ -908,7 +908,7 @@ struct CoverageFormat2
     {
       if (last + 1 != g)
       {
-        range++;
+	range++;
 	rangeRecord[range].start = g;
 	rangeRecord[range].value = count;
       }
@@ -1058,11 +1058,11 @@ struct Coverage
     for (auto g: glyphs)
     {
       if (last + 1 != g)
-        num_ranges++;
+	num_ranges++;
       last = g;
       count++;
     }
-    u.format = count * 2 < num_ranges * 3 ? 1 : 2;
+    u.format = count <= num_ranges * 3 ? 1 : 2;
 
     switch (u.format)
     {
@@ -1196,7 +1196,7 @@ struct Coverage
  */
 
 static inline void ClassDef_serialize (hb_serialize_context_t *c,
-				       hb_array_t<const GlyphID> glyphs,
+				       hb_array_t<const HBGlyphID> glyphs,
 				       hb_array_t<const HBUINT16> klasses);
 
 struct ClassDefFormat1
@@ -1210,7 +1210,7 @@ struct ClassDefFormat1
   }
 
   bool serialize (hb_serialize_context_t *c,
-		  hb_array_t<const GlyphID> glyphs,
+		  hb_array_t<const HBGlyphID> glyphs,
 		  hb_array_t<const HBUINT16> klasses)
   {
     TRACE_SERIALIZE (this);
@@ -1241,7 +1241,7 @@ struct ClassDefFormat1
     TRACE_SUBSET (this);
     const hb_set_t &glyphset = *c->plan->glyphset ();
     const hb_map_t &glyph_map = *c->plan->glyph_map;
-    hb_sorted_vector_t<GlyphID> glyphs;
+    hb_sorted_vector_t<HBGlyphID> glyphs;
     hb_vector_t<HBUINT16> klasses;
 
     hb_codepoint_t start = startGlyph;
@@ -1328,7 +1328,7 @@ struct ClassDefFormat1
 
   protected:
   HBUINT16	classFormat;	/* Format identifier--format = 1 */
-  GlyphID	startGlyph;	/* First GlyphID of the classValueArray */
+  HBGlyphID	startGlyph;	/* First GlyphID of the classValueArray */
   ArrayOf<HBUINT16>
 		classValue;	/* Array of Class Values--one per GlyphID */
   public:
@@ -1346,7 +1346,7 @@ struct ClassDefFormat2
   }
 
   bool serialize (hb_serialize_context_t *c,
-		  hb_array_t<const GlyphID> glyphs,
+		  hb_array_t<const HBGlyphID> glyphs,
 		  hb_array_t<const HBUINT16> klasses)
   {
     TRACE_SERIALIZE (this);
@@ -1390,7 +1390,7 @@ struct ClassDefFormat2
     TRACE_SUBSET (this);
     const hb_set_t &glyphset = *c->plan->glyphset ();
     const hb_map_t &glyph_map = *c->plan->glyph_map;
-    hb_vector_t<GlyphID> glyphs;
+    hb_vector_t<HBGlyphID> glyphs;
     hb_vector_t<HBUINT16> klasses;
 
     unsigned int count = rangeRecord.len;
@@ -1506,7 +1506,7 @@ struct ClassDef
   }
 
   bool serialize (hb_serialize_context_t *c,
-		  hb_array_t<const GlyphID> glyphs,
+		  hb_array_t<const HBGlyphID> glyphs,
 		  hb_array_t<const HBUINT16> klasses)
   {
     TRACE_SERIALIZE (this);
@@ -1526,7 +1526,7 @@ struct ClassDef
 	  num_ranges++;
 
       if (1 + (glyph_max - glyph_min + 1) < num_ranges * 3)
-        format = 1;
+	format = 1;
     }
     u.format = format;
 
@@ -1611,7 +1611,7 @@ struct ClassDef
 };
 
 static inline void ClassDef_serialize (hb_serialize_context_t *c,
-				       hb_array_t<const GlyphID> glyphs,
+				       hb_array_t<const HBGlyphID> glyphs,
 				       hb_array_t<const HBUINT16> klasses)
 { c->start_embed<ClassDef> ()->serialize (c, glyphs, klasses); }
 
@@ -1746,9 +1746,9 @@ struct VarData
   }
 
   void get_scalars (int *coords, unsigned int coord_count,
-                    const VarRegionList &regions,
-                    float *scalars /*OUT */,
-                    unsigned int num_scalars) const
+		    const VarRegionList &regions,
+		    float *scalars /*OUT */,
+		    unsigned int num_scalars) const
   {
     unsigned count = hb_min (num_scalars, regionIndices.len);
     for (unsigned int i = 0; i < count; i++)
@@ -1830,7 +1830,7 @@ struct VariationStore
 #endif
 
     (this+dataSets[ivs]).get_scalars (coords, coord_count, this+regions,
-                                      &scalars[0], num_scalars);
+				      &scalars[0], num_scalars);
   }
 
   protected:
@@ -2057,6 +2057,8 @@ struct HintingDevice
   hb_position_t get_y_delta (hb_font_t *font) const
   { return get_delta (font->y_ppem, font->y_scale); }
 
+  public:
+
   unsigned int get_size () const
   {
     unsigned int f = deltaFormat;
@@ -2070,6 +2072,12 @@ struct HintingDevice
     return_trace (c->check_struct (this) && c->check_range (this, this->get_size ()));
   }
 
+  HintingDevice* copy (hb_serialize_context_t *c) const
+  {
+    TRACE_SERIALIZE (this);
+    return_trace (c->embed<HintingDevice> (this));
+  }
+
   private:
 
   int get_delta (unsigned int ppem, int scale) const
@@ -2131,6 +2139,12 @@ struct VariationDevice
   hb_position_t get_y_delta (hb_font_t *font, const VariationStore &store) const
   { return font->em_scalef_y (get_delta (font, store)); }
 
+  VariationDevice* copy (hb_serialize_context_t *c) const
+  {
+    TRACE_SERIALIZE (this);
+    return_trace (c->embed<VariationDevice> (this));
+  }
+
   bool sanitize (hb_sanitize_context_t *c) const
   {
     TRACE_SANITIZE (this);
@@ -2216,6 +2230,25 @@ struct Device
     }
   }
 
+  Device* copy (hb_serialize_context_t *c) const
+  {
+    TRACE_SERIALIZE (this);
+    switch (u.b.format) {
+#ifndef HB_NO_HINTING
+    case 1:
+    case 2:
+    case 3:
+      return_trace (reinterpret_cast<Device *> (u.hinting.copy (c)));
+#endif
+#ifndef HB_NO_VAR
+    case 0x8000:
+      return_trace (reinterpret_cast<Device *> (u.variation.copy (c)));
+#endif
+    default:
+      return_trace (nullptr);
+    }
+  }
+
   protected:
   union {
   DeviceHeader		b;
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-layout-gdef-table.hh b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-layout-gdef-table.hh
index 0fca9947dd5..dc751d88ea9 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-layout-gdef-table.hh
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-layout-gdef-table.hh
@@ -149,8 +149,8 @@ struct CaretValueFormat3
 				 const VariationStore &var_store) const
   {
     return HB_DIRECTION_IS_HORIZONTAL (direction) ?
-           font->em_scale_x (coordinate) + (this+deviceTable).get_x_delta (font, var_store) :
-           font->em_scale_y (coordinate) + (this+deviceTable).get_y_delta (font, var_store);
+	   font->em_scale_x (coordinate) + (this+deviceTable).get_x_delta (font, var_store) :
+	   font->em_scale_y (coordinate) + (this+deviceTable).get_y_delta (font, var_store);
   }
 
   bool sanitize (hb_sanitize_context_t *c) const
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-layout-gpos-table.hh b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-layout-gpos-table.hh
index 7d57056d135..73107f490b5 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-layout-gpos-table.hh
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-layout-gpos-table.hh
@@ -238,8 +238,8 @@ struct ValueFormat : HBUINT16
 
 template<typename Iterator>
 static inline void SinglePos_serialize (hb_serialize_context_t *c,
-                                        Iterator it,
-                                        ValueFormat valFormat);
+					Iterator it,
+					ValueFormat valFormat);
 
 
 struct AnchorFormat1
@@ -257,6 +257,12 @@ struct AnchorFormat1
     TRACE_SANITIZE (this);
     return_trace (c->check_struct (this));
   }
+  
+  AnchorFormat1* copy (hb_serialize_context_t *c) const
+  {
+    TRACE_SERIALIZE (this);
+    return_trace (c->embed<AnchorFormat1> (this));
+  }
 
   protected:
   HBUINT16	format;			/* Format identifier--format = 1 */
@@ -296,6 +302,12 @@ struct AnchorFormat2
     return_trace (c->check_struct (this));
   }
 
+  AnchorFormat2* copy (hb_serialize_context_t *c) const
+  {
+    TRACE_SERIALIZE (this);
+    return_trace (c->embed<AnchorFormat2> (this));
+  }
+
   protected:
   HBUINT16	format;			/* Format identifier--format = 2 */
   FWORD		xCoordinate;		/* Horizontal value--in design units */
@@ -326,6 +338,17 @@ struct AnchorFormat3
     return_trace (c->check_struct (this) && xDeviceTable.sanitize (c, this) && yDeviceTable.sanitize (c, this));
   }
 
+  AnchorFormat3* copy (hb_serialize_context_t *c) const
+  {
+    TRACE_SERIALIZE (this);
+    auto *out = c->embed<AnchorFormat3> (this);
+    if (unlikely (!out)) return_trace (nullptr);
+
+    out->xDeviceTable.serialize_copy (c, xDeviceTable, this, out);
+    out->yDeviceTable.serialize_copy (c, yDeviceTable, this, out);
+    return_trace (out);
+  }
+
   protected:
   HBUINT16	format;			/* Format identifier--format = 3 */
   FWORD		xCoordinate;		/* Horizontal value--in design units */
@@ -368,6 +391,17 @@ struct Anchor
     }
   }
 
+  Anchor* copy (hb_serialize_context_t *c) const
+  {
+    TRACE_SERIALIZE (this);
+    switch (u.format) {
+    case 1: return_trace (reinterpret_cast<Anchor *> (u.format1.copy (c)));
+    case 2: return_trace (reinterpret_cast<Anchor *> (u.format2.copy (c)));
+    case 3: return_trace (reinterpret_cast<Anchor *> (u.format3.copy (c)));
+    default:return_trace (nullptr);
+    }
+  }
+
   protected:
   union {
   HBUINT16		format;		/* Format identifier */
@@ -510,14 +544,8 @@ struct SinglePosFormat1
     if (unlikely (!c->extend_min (*this))) return;
     if (unlikely (!c->check_assign (valueFormat, valFormat))) return;
 
-    auto vals = hb_second (*it);
-
-    + vals
-    | hb_apply ([=] (const Value& _)
-                {
-                  c->copy (_);
-                })
-    ;
+    for (const auto &_ : hb_second (*it))
+      c->copy (_);
 
     auto glyphs =
     + it
@@ -533,15 +561,11 @@ struct SinglePosFormat1
     const hb_set_t &glyphset = *c->plan->glyphset_gsub ();
     const hb_map_t &glyph_map = *c->plan->glyph_map;
 
-    unsigned length = valueFormat.get_len ();
-
     auto it =
     + hb_iter (this+coverage)
     | hb_filter (glyphset)
-    | hb_map_retains_sorting ([&] (hb_codepoint_t p)
-                              {
-                                return hb_pair (glyph_map[p], values.as_array (length));
-                              })
+    | hb_map_retains_sorting (glyph_map)
+    | hb_zip (hb_repeat (values.as_array (valueFormat.get_len ())))
     ;
 
     bool ret = bool (it);
@@ -602,30 +626,21 @@ struct SinglePosFormat2
 	   hb_requires (hb_is_iterator (Iterator))>
   void serialize (hb_serialize_context_t *c,
 		  Iterator it,
-                  ValueFormat valFormat)
+		  ValueFormat valFormat)
   {
     if (unlikely (!c->extend_min (*this))) return;
     if (unlikely (!c->check_assign (valueFormat, valFormat))) return;
     if (unlikely (!c->check_assign (valueCount, it.len ()))) return;
-    
-    + it
-    | hb_map (hb_second)
-    | hb_apply ([=] (hb_array_t<const Value> val_iter)
-                {
-                  + val_iter
-                  | hb_apply ([=] (const Value& _)
-                              {
-                                c->copy (_);
-                              })
-                  ;
-                })
-    ;
+
+    for (const auto iter : it)
+      for (const auto &_ : iter.second)
+	c->copy (_);
 
     auto glyphs =
     + it
     | hb_map_retains_sorting (hb_first)
     ;
-    
+
     coverage.serialize (c, this).serialize (c, glyphs);
   }
 
@@ -636,15 +651,17 @@ struct SinglePosFormat2
     const hb_map_t &glyph_map = *c->plan->glyph_map;
 
     unsigned sub_length = valueFormat.get_len ();
-    unsigned total_length = (unsigned)valueCount * sub_length;
+    auto values_array = values.as_array (valueCount * sub_length);
 
     auto it =
     + hb_zip (this+coverage, hb_range ((unsigned) valueCount))
     | hb_filter (glyphset, hb_first)
     | hb_map_retains_sorting ([&] (const hb_pair_t<hb_codepoint_t, unsigned>& _)
-                              {
-                                return hb_pair (glyph_map[_.first], values.as_array (total_length).sub_array (_.second * sub_length, sub_length));
-                              })
+			      {
+				return hb_pair (glyph_map[_.first],
+						values_array.sub_array (_.second * sub_length,
+									sub_length));
+			      })
     ;
 
     bool ret = bool (it);
@@ -680,27 +697,14 @@ struct SinglePos
 	   hb_requires (hb_is_iterator (Iterator))>
   unsigned get_format (Iterator glyph_val_iter_pairs)
   {
-    unsigned subset_format = 1;
     hb_array_t<const Value> first_val_iter = hb_second (*glyph_val_iter_pairs);
 
-    + glyph_val_iter_pairs
-    | hb_map (hb_second)
-    | hb_apply ([&] (hb_array_t<const Value> val_iter)
-                {
-                  + hb_zip (val_iter, first_val_iter)
-                  | hb_apply ([&] (const hb_pair_t<Value, Value>& _)
-                              {
-                                if (_.first != _.second)
-                                {
-                                  subset_format = 2;
-                                  return;
-                                }
-                              })
-                  ;
-                })
-    ;
+    for (const auto iter : glyph_val_iter_pairs)
+      for (const auto _ : hb_zip (iter.second, first_val_iter))
+	if (_.first != _.second)
+	  return 2;
 
-    return subset_format;
+    return 1;
   }
 
 
@@ -708,7 +712,7 @@ struct SinglePos
 	   hb_requires (hb_is_iterator (Iterator))>
   void serialize (hb_serialize_context_t *c,
 		  Iterator glyph_val_iter_pairs,
-                  ValueFormat valFormat)
+		  ValueFormat valFormat)
   {
     if (unlikely (!c->extend_min (u.format))) return;
     unsigned format = 2;
@@ -718,9 +722,9 @@ struct SinglePos
     u.format = format;
     switch (u.format) {
     case 1: u.format1.serialize (c, glyph_val_iter_pairs, valFormat);
-            return;
+	    return;
     case 2: u.format2.serialize (c, glyph_val_iter_pairs, valFormat);
-            return;
+	    return;
     default:return;
     }
   }
@@ -748,8 +752,8 @@ struct SinglePos
 template<typename Iterator>
 static inline void
 SinglePos_serialize (hb_serialize_context_t *c,
-                     Iterator it,
-                     ValueFormat valFormat)
+		     Iterator it,
+		     ValueFormat valFormat)
 { c->start_embed<SinglePos> ()->serialize (c, it, valFormat); }
 
 
@@ -758,7 +762,7 @@ struct PairValueRecord
   friend struct PairSet;
 
   protected:
-  GlyphID	secondGlyph;		/* GlyphID of second glyph in the
+  HBGlyphID	secondGlyph;		/* GlyphID of second glyph in the
 					 * pair--first glyph is listed in the
 					 * Coverage table */
   ValueRecord	values;			/* Positioning data for the first glyph
@@ -1094,6 +1098,19 @@ struct EntryExitRecord
     return_trace (entryAnchor.sanitize (c, base) && exitAnchor.sanitize (c, base));
   }
 
+  EntryExitRecord* copy (hb_serialize_context_t *c,
+			 const void *src_base,
+			 const void *dst_base) const
+  {
+    TRACE_SERIALIZE (this);
+    auto *out = c->embed (this);
+    if (unlikely (!out)) return_trace (nullptr);
+
+    out->entryAnchor.serialize_copy (c, entryAnchor, src_base, dst_base);
+    out->exitAnchor.serialize_copy (c, exitAnchor, src_base, dst_base);
+    return_trace (out);
+  }
+
   protected:
   OffsetTo<Anchor>
 		entryAnchor;		/* Offset to EntryAnchor table--from
@@ -1221,11 +1238,47 @@ struct CursivePosFormat1
     return_trace (true);
   }
 
+  template <typename Iterator,
+	    hb_requires (hb_is_iterator (Iterator))>
+  void serialize (hb_serialize_context_t *c,
+		  Iterator it,
+                  const void *src_base)
+  {
+    if (unlikely (!c->extend_min ((*this)))) return;
+    this->format = 1;
+    this->entryExitRecord.len = it.len ();
+
+    for (const EntryExitRecord& entry_record : + it
+					       | hb_map (hb_second))
+      c->copy (entry_record, src_base, this);
+
+    auto glyphs =
+    + it
+    | hb_map_retains_sorting (hb_first)
+    ;
+
+    coverage.serialize (c, this).serialize (c, glyphs);
+  }
+
   bool subset (hb_subset_context_t *c) const
   {
     TRACE_SUBSET (this);
-    // TODO(subset)
-    return_trace (false);
+    const hb_set_t &glyphset = *c->plan->glyphset ();
+    const hb_map_t &glyph_map = *c->plan->glyph_map;
+
+    auto *out = c->serializer->start_embed (*this);
+    if (unlikely (!out)) return_trace (false);
+
+    auto it =
+    + hb_zip (this+coverage, entryExitRecord)
+    | hb_filter (glyphset, hb_first)
+    | hb_map_retains_sorting ([&] (hb_pair_t<hb_codepoint_t, const EntryExitRecord&> p) -> hb_pair_t<hb_codepoint_t, const EntryExitRecord&>
+                              { return hb_pair (glyph_map[p.first], p.second);})
+    ;
+
+    bool ret = bool (it);
+    out->serialize (c->serializer, it, this);
+    return_trace (ret);
   }
 
   bool sanitize (hb_sanitize_context_t *c) const
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-layout-gsub-table.hh b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-layout-gsub-table.hh
index 84e1b15786a..a2722ade93d 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-layout-gsub-table.hh
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-layout-gsub-table.hh
@@ -111,8 +111,11 @@ struct SingleSubstFormat1
     + hb_iter (this+coverage)
     | hb_filter (glyphset)
     | hb_map_retains_sorting ([&] (hb_codepoint_t g) {
-				return hb_codepoint_pair_t (glyph_map[g],
-							    glyph_map[(g + delta) & 0xFFFF]); })
+				return hb_codepoint_pair_t (g,
+							    (g + delta) & 0xFFFF); })
+    | hb_filter (glyphset, hb_second)
+    | hb_map_retains_sorting ([&] (hb_codepoint_pair_t p) -> hb_codepoint_pair_t
+			      { return hb_pair (glyph_map[p.first], glyph_map[p.second]); })
     ;
 
     bool ret = bool (it);
@@ -208,7 +211,8 @@ struct SingleSubstFormat2
     auto it =
     + hb_zip (this+coverage, substitute)
     | hb_filter (glyphset, hb_first)
-    | hb_map_retains_sorting ([&] (hb_pair_t<hb_codepoint_t, const GlyphID &> p) -> hb_codepoint_pair_t
+    | hb_filter (glyphset, hb_second)
+    | hb_map_retains_sorting ([&] (hb_pair_t<hb_codepoint_t, const HBGlyphID &> p) -> hb_codepoint_pair_t
 			      { return hb_pair (glyph_map[p.first], glyph_map[p.second]); })
     ;
 
@@ -228,7 +232,7 @@ struct SingleSubstFormat2
   OffsetTo<Coverage>
 		coverage;		/* Offset to Coverage table--from
 					 * beginning of Substitution table */
-  ArrayOf<GlyphID>
+  ArrayOf<HBGlyphID>
 		substitute;		/* Array of substitute
 					 * GlyphIDs--ordered by Coverage Index */
   public:
@@ -296,12 +300,11 @@ SingleSubst_serialize (hb_serialize_context_t *c,
 
 struct Sequence
 {
+  bool intersects (const hb_set_t *glyphs) const
+  { return hb_all (substitute, glyphs); }
+
   void closure (hb_closure_context_t *c) const
-  {
-    unsigned int count = substitute.len;
-    for (unsigned int i = 0; i < count; i++)
-      c->output->add (substitute[i]);
-  }
+  { c->output->add_array (substitute.arrayZ, substitute.len); }
 
   void collect_glyphs (hb_collect_glyphs_context_t *c) const
   { c->output->add_array (substitute.arrayZ, substitute.len); }
@@ -347,6 +350,23 @@ struct Sequence
     return_trace (substitute.serialize (c, subst));
   }
 
+  bool subset (hb_subset_context_t *c) const
+  {
+    TRACE_SUBSET (this);
+    const hb_set_t &glyphset = *c->plan->glyphset ();
+    const hb_map_t &glyph_map = *c->plan->glyph_map;
+
+    if (!intersects (&glyphset)) return_trace (false);
+
+    auto it =
+      + hb_iter (substitute)
+      | hb_map (glyph_map)
+      ;
+
+    auto *out = c->serializer->start_embed (*this);
+    return_trace (out->serialize (c->serializer, it));
+  }
+
   bool sanitize (hb_sanitize_context_t *c) const
   {
     TRACE_SANITIZE (this);
@@ -354,7 +374,7 @@ struct Sequence
   }
 
   protected:
-  ArrayOf<GlyphID>
+  ArrayOf<HBGlyphID>
 		substitute;		/* String of GlyphIDs to substitute */
   public:
   DEFINE_SIZE_ARRAY (2, substitute);
@@ -401,9 +421,9 @@ struct MultipleSubstFormat1
   }
 
   bool serialize (hb_serialize_context_t *c,
-		  hb_sorted_array_t<const GlyphID> glyphs,
+		  hb_sorted_array_t<const HBGlyphID> glyphs,
 		  hb_array_t<const unsigned int> substitute_len_list,
-		  hb_array_t<const GlyphID> substitute_glyphs_list)
+		  hb_array_t<const HBGlyphID> substitute_glyphs_list)
   {
     TRACE_SERIALIZE (this);
     if (unlikely (!c->extend_min (*this))) return_trace (false);
@@ -422,8 +442,37 @@ struct MultipleSubstFormat1
   bool subset (hb_subset_context_t *c) const
   {
     TRACE_SUBSET (this);
-    // TODO(subset)
-    return_trace (false);
+    const hb_set_t &glyphset = *c->plan->glyphset ();
+    const hb_map_t &glyph_map = *c->plan->glyph_map;
+
+    auto *out = c->serializer->start_embed (*this);
+    if (unlikely (!c->serializer->extend_min (out))) return_trace (false);
+    out->format = format;
+
+    hb_sorted_vector_t<hb_codepoint_t> new_coverage;
+    + hb_zip (this+coverage, sequence)
+    | hb_filter (glyphset, hb_first)
+    | hb_filter ([this, c, out] (const OffsetTo<Sequence>& _)
+		 {
+		   auto *o = out->sequence.serialize_append (c->serializer);
+		   if (unlikely (!o)) return false;
+		   auto snap = c->serializer->snapshot ();
+		   bool ret = o->serialize_subset (c, _, this, out);
+		   if (!ret)
+		   {
+		     out->sequence.pop ();
+		     c->serializer->revert (snap);
+		   }
+		   return ret;
+		 },
+		 hb_second)
+    | hb_map (hb_first)
+    | hb_map (glyph_map)
+    | hb_sink (new_coverage)
+    ;
+    out->coverage.serialize (c->serializer, out)
+		 .serialize (c->serializer, new_coverage.iter ());
+    return_trace (bool (new_coverage));
   }
 
   bool sanitize (hb_sanitize_context_t *c) const
@@ -447,9 +496,9 @@ struct MultipleSubstFormat1
 struct MultipleSubst
 {
   bool serialize (hb_serialize_context_t *c,
-		  hb_sorted_array_t<const GlyphID> glyphs,
+		  hb_sorted_array_t<const HBGlyphID> glyphs,
 		  hb_array_t<const unsigned int> substitute_len_list,
-		  hb_array_t<const GlyphID> substitute_glyphs_list)
+		  hb_array_t<const HBGlyphID> substitute_glyphs_list)
   {
     TRACE_SERIALIZE (this);
     if (unlikely (!c->extend_min (u.format))) return_trace (false);
@@ -481,12 +530,11 @@ struct MultipleSubst
 
 struct AlternateSet
 {
+  bool intersects (const hb_set_t *glyphs) const
+  { return hb_any (alternates, glyphs); }
+
   void closure (hb_closure_context_t *c) const
-  {
-    unsigned int count = alternates.len;
-    for (unsigned int i = 0; i < count; i++)
-      c->output->add (alternates[i]);
-  }
+  { c->output->add_array (alternates.arrayZ, alternates.len); }
 
   void collect_glyphs (hb_collect_glyphs_context_t *c) const
   { c->output->add_array (alternates.arrayZ, alternates.len); }
@@ -525,6 +573,23 @@ struct AlternateSet
     return_trace (alternates.serialize (c, alts));
   }
 
+  bool subset (hb_subset_context_t *c) const
+  {
+    TRACE_SUBSET (this);
+    const hb_set_t &glyphset = *c->plan->glyphset ();
+    const hb_map_t &glyph_map = *c->plan->glyph_map;
+
+    auto it =
+      + hb_iter (alternates)
+      | hb_filter (glyphset)
+      | hb_map (glyph_map)
+      ;
+
+    auto *out = c->serializer->start_embed (*this);
+    return_trace (out->serialize (c->serializer, it) &&
+		  out->alternates);
+  }
+
   bool sanitize (hb_sanitize_context_t *c) const
   {
     TRACE_SANITIZE (this);
@@ -532,7 +597,7 @@ struct AlternateSet
   }
 
   protected:
-  ArrayOf<GlyphID>
+  ArrayOf<HBGlyphID>
 		alternates;		/* Array of alternate GlyphIDs--in
 					 * arbitrary order */
   public:
@@ -579,9 +644,9 @@ struct AlternateSubstFormat1
   }
 
   bool serialize (hb_serialize_context_t *c,
-		  hb_sorted_array_t<const GlyphID> glyphs,
+		  hb_sorted_array_t<const HBGlyphID> glyphs,
 		  hb_array_t<const unsigned int> alternate_len_list,
-		  hb_array_t<const GlyphID> alternate_glyphs_list)
+		  hb_array_t<const HBGlyphID> alternate_glyphs_list)
   {
     TRACE_SERIALIZE (this);
     if (unlikely (!c->extend_min (*this))) return_trace (false);
@@ -600,8 +665,37 @@ struct AlternateSubstFormat1
   bool subset (hb_subset_context_t *c) const
   {
     TRACE_SUBSET (this);
-    // TODO(subset)
-    return_trace (false);
+    const hb_set_t &glyphset = *c->plan->glyphset ();
+    const hb_map_t &glyph_map = *c->plan->glyph_map;
+
+    auto *out = c->serializer->start_embed (*this);
+    if (unlikely (!c->serializer->extend_min (out))) return_trace (false);
+    out->format = format;
+
+    hb_sorted_vector_t<hb_codepoint_t> new_coverage;
+    + hb_zip (this+coverage, alternateSet)
+    | hb_filter (glyphset, hb_first)
+    | hb_filter ([this, c, out] (const OffsetTo<AlternateSet>& _)
+		 {
+		   auto *o = out->alternateSet.serialize_append (c->serializer);
+		   if (unlikely (!o)) return false;
+		   auto snap = c->serializer->snapshot ();
+		   bool ret = o->serialize_subset (c, _, this, out);
+		   if (!ret)
+		   {
+		     out->alternateSet.pop ();
+		     c->serializer->revert (snap);
+		   }
+		   return ret;
+		 },
+		 hb_second)
+    | hb_map (hb_first)
+    | hb_map (glyph_map)
+    | hb_sink (new_coverage)
+    ;
+    out->coverage.serialize (c->serializer, out)
+		 .serialize (c->serializer, new_coverage.iter ());
+    return_trace (bool (new_coverage));
   }
 
   bool sanitize (hb_sanitize_context_t *c) const
@@ -625,9 +719,9 @@ struct AlternateSubstFormat1
 struct AlternateSubst
 {
   bool serialize (hb_serialize_context_t *c,
-		  hb_sorted_array_t<const GlyphID> glyphs,
+		  hb_sorted_array_t<const HBGlyphID> glyphs,
 		  hb_array_t<const unsigned int> alternate_len_list,
-		  hb_array_t<const GlyphID> alternate_glyphs_list)
+		  hb_array_t<const HBGlyphID> alternate_glyphs_list)
   {
     TRACE_SERIALIZE (this);
     if (unlikely (!c->extend_min (u.format))) return_trace (false);
@@ -661,13 +755,7 @@ struct AlternateSubst
 struct Ligature
 {
   bool intersects (const hb_set_t *glyphs) const
-  {
-    unsigned int count = component.lenP1;
-    for (unsigned int i = 1; i < count; i++)
-      if (!glyphs->has (component[i]))
-	return false;
-    return true;
-  }
+  { return hb_all (component, glyphs); }
 
   void closure (hb_closure_context_t *c) const
   {
@@ -677,7 +765,7 @@ struct Ligature
 
   void collect_glyphs (hb_collect_glyphs_context_t *c) const
   {
-    c->input->add_array (component.arrayZ, component.lenP1 ? component.lenP1 - 1 : 0);
+    c->input->add_array (component.arrayZ, component.get_length ());
     c->output->add (ligGlyph);
   }
 
@@ -735,7 +823,7 @@ struct Ligature
   template <typename Iterator,
 	    hb_requires (hb_is_source_of (Iterator, hb_codepoint_t))>
   bool serialize (hb_serialize_context_t *c,
-		  GlyphID ligature,
+		  hb_codepoint_t ligature,
 		  Iterator components /* Starting from second */)
   {
     TRACE_SERIALIZE (this);
@@ -745,6 +833,25 @@ struct Ligature
     return_trace (true);
   }
 
+  bool subset (hb_subset_context_t *c) const
+  {
+    TRACE_SUBSET (this);
+    const hb_set_t &glyphset = *c->plan->glyphset ();
+    const hb_map_t &glyph_map = *c->plan->glyph_map;
+
+    if (!intersects (&glyphset) || !glyphset.has (ligGlyph)) return_trace (false);
+
+    auto it =
+      + hb_iter (component)
+      | hb_map (glyph_map)
+      ;
+
+    auto *out = c->serializer->start_embed (*this);
+    return_trace (out->serialize (c->serializer,
+				   glyph_map[ligGlyph],
+				   it));
+  }
+
   public:
   bool sanitize (hb_sanitize_context_t *c) const
   {
@@ -753,8 +860,8 @@ struct Ligature
   }
 
   protected:
-  GlyphID	ligGlyph;		/* GlyphID of ligature to substitute */
-  HeadlessArrayOf<GlyphID>
+  HBGlyphID	ligGlyph;		/* GlyphID of ligature to substitute */
+  HeadlessArrayOf<HBGlyphID>
 		component;		/* Array of component GlyphIDs--start
 					 * with the second  component--ordered
 					 * in writing direction */
@@ -814,9 +921,9 @@ struct LigatureSet
   }
 
   bool serialize (hb_serialize_context_t *c,
-		  hb_array_t<const GlyphID> ligatures,
+		  hb_array_t<const HBGlyphID> ligatures,
 		  hb_array_t<const unsigned int> component_count_list,
-		  hb_array_t<const GlyphID> &component_list /* Starting from second for each ligature */)
+		  hb_array_t<const HBGlyphID> &component_list /* Starting from second for each ligature */)
   {
     TRACE_SERIALIZE (this);
     if (unlikely (!c->extend_min (*this))) return_trace (false);
@@ -834,6 +941,31 @@ struct LigatureSet
     return_trace (true);
   }
 
+  bool subset (hb_subset_context_t *c) const
+  {
+    TRACE_SUBSET (this);
+    auto *out = c->serializer->start_embed (*this);
+    if (unlikely (!c->serializer->extend_min (out))) return_trace (false);
+
+    + hb_iter (ligature)
+    | hb_filter ([this, c, out] (const OffsetTo<Ligature>& _)
+		 {
+		   auto *o = out->ligature.serialize_append (c->serializer);
+		   if (unlikely (!o)) return false;
+		   auto snap = c->serializer->snapshot ();
+		   bool ret = o->serialize_subset (c, _, this, out);
+		   if (!ret)
+		   {
+		     out->ligature.pop ();
+		     c->serializer->revert (snap);
+		   }
+		   return ret;
+		 })
+    | hb_drain
+    ;
+    return_trace (bool (out->ligature));
+  }
+
   bool sanitize (hb_sanitize_context_t *c) const
   {
     TRACE_SANITIZE (this);
@@ -906,11 +1038,11 @@ struct LigatureSubstFormat1
   }
 
   bool serialize (hb_serialize_context_t *c,
-		  hb_sorted_array_t<const GlyphID> first_glyphs,
+		  hb_sorted_array_t<const HBGlyphID> first_glyphs,
 		  hb_array_t<const unsigned int> ligature_per_first_glyph_count_list,
-		  hb_array_t<const GlyphID> ligatures_list,
+		  hb_array_t<const HBGlyphID> ligatures_list,
 		  hb_array_t<const unsigned int> component_count_list,
-		  hb_array_t<const GlyphID> component_list /* Starting from second for each ligature */)
+		  hb_array_t<const HBGlyphID> component_list /* Starting from second for each ligature */)
   {
     TRACE_SERIALIZE (this);
     if (unlikely (!c->extend_min (*this))) return_trace (false);
@@ -932,8 +1064,37 @@ struct LigatureSubstFormat1
   bool subset (hb_subset_context_t *c) const
   {
     TRACE_SUBSET (this);
-    // TODO(subset)
-    return_trace (false);
+    const hb_set_t &glyphset = *c->plan->glyphset ();
+    const hb_map_t &glyph_map = *c->plan->glyph_map;
+
+    auto *out = c->serializer->start_embed (*this);
+    if (unlikely (!c->serializer->extend_min (out))) return_trace (false);
+    out->format = format;
+
+    hb_sorted_vector_t<hb_codepoint_t> new_coverage;
+    + hb_zip (this+coverage, ligatureSet)
+    | hb_filter (glyphset, hb_first)
+    | hb_filter ([this, c, out] (const OffsetTo<LigatureSet>& _)
+		 {
+		   auto *o = out->ligatureSet.serialize_append (c->serializer);
+		   if (unlikely (!o)) return false;
+		   auto snap = c->serializer->snapshot ();
+		   bool ret = o->serialize_subset (c, _, this, out);
+		   if (!ret)
+		   {
+		     out->ligatureSet.pop ();
+		     c->serializer->revert (snap);
+		   }
+		   return ret;
+		 },
+		 hb_second)
+    | hb_map (hb_first)
+    | hb_map (glyph_map)
+    | hb_sink (new_coverage)
+    ;
+    out->coverage.serialize (c->serializer, out)
+		 .serialize (c->serializer, new_coverage.iter ());
+    return_trace (bool (new_coverage));
   }
 
   bool sanitize (hb_sanitize_context_t *c) const
@@ -957,11 +1118,11 @@ struct LigatureSubstFormat1
 struct LigatureSubst
 {
   bool serialize (hb_serialize_context_t *c,
-		  hb_sorted_array_t<const GlyphID> first_glyphs,
+		  hb_sorted_array_t<const HBGlyphID> first_glyphs,
 		  hb_array_t<const unsigned int> ligature_per_first_glyph_count_list,
-		  hb_array_t<const GlyphID> ligatures_list,
+		  hb_array_t<const HBGlyphID> ligatures_list,
 		  hb_array_t<const unsigned int> component_count_list,
-		  hb_array_t<const GlyphID> component_list /* Starting from second for each ligature */)
+		  hb_array_t<const HBGlyphID> component_list /* Starting from second for each ligature */)
   {
     TRACE_SERIALIZE (this);
     if (unlikely (!c->extend_min (u.format))) return_trace (false);
@@ -1038,7 +1199,7 @@ struct ReverseChainSingleSubstFormat1
     if (!intersects (c->glyphs)) return;
 
     const OffsetArrayOf<Coverage> &lookahead = StructAfter<OffsetArrayOf<Coverage>> (backtrack);
-    const ArrayOf<GlyphID> &substitute = StructAfter<ArrayOf<GlyphID>> (lookahead);
+    const ArrayOf<HBGlyphID> &substitute = StructAfter<ArrayOf<HBGlyphID>> (lookahead);
 
     + hb_zip (this+coverage, substitute)
     | hb_filter (*c->glyphs, hb_first)
@@ -1062,7 +1223,7 @@ struct ReverseChainSingleSubstFormat1
     for (unsigned int i = 0; i < count; i++)
       if (unlikely (!(this+lookahead[i]).add_coverage (c->after))) return;
 
-    const ArrayOf<GlyphID> &substitute = StructAfter<ArrayOf<GlyphID>> (lookahead);
+    const ArrayOf<HBGlyphID> &substitute = StructAfter<ArrayOf<HBGlyphID>> (lookahead);
     count = substitute.len;
     c->output->add_array (substitute.arrayZ, substitute.len);
   }
@@ -1082,7 +1243,7 @@ struct ReverseChainSingleSubstFormat1
     if (likely (index == NOT_COVERED)) return_trace (false);
 
     const OffsetArrayOf<Coverage> &lookahead = StructAfter<OffsetArrayOf<Coverage>> (backtrack);
-    const ArrayOf<GlyphID> &substitute = StructAfter<ArrayOf<GlyphID>> (lookahead);
+    const ArrayOf<HBGlyphID> &substitute = StructAfter<ArrayOf<HBGlyphID>> (lookahead);
 
   unsigned int start_index = 0, end_index = 0;
     if (match_backtrack (c,
@@ -1120,7 +1281,7 @@ struct ReverseChainSingleSubstFormat1
     const OffsetArrayOf<Coverage> &lookahead = StructAfter<OffsetArrayOf<Coverage>> (backtrack);
     if (!lookahead.sanitize (c, this))
       return_trace (false);
-    const ArrayOf<GlyphID> &substitute = StructAfter<ArrayOf<GlyphID>> (lookahead);
+    const ArrayOf<HBGlyphID> &substitute = StructAfter<ArrayOf<HBGlyphID>> (lookahead);
     return_trace (substitute.sanitize (c));
   }
 
@@ -1137,7 +1298,7 @@ struct ReverseChainSingleSubstFormat1
 		lookaheadX;		/* Array of coverage tables
 					 * in lookahead sequence, in glyph
 					 * sequence order */
-  ArrayOf<GlyphID>
+  ArrayOf<HBGlyphID>
 		substituteX;		/* Array of substitute
 					 * GlyphIDs--ordered by Coverage Index */
   public:
@@ -1292,8 +1453,8 @@ struct SubstLookup : Lookup
 
   bool serialize_single (hb_serialize_context_t *c,
 			 uint32_t lookup_props,
-			 hb_sorted_array_t<const GlyphID> glyphs,
-			 hb_array_t<const GlyphID> substitutes)
+			 hb_sorted_array_t<const HBGlyphID> glyphs,
+			 hb_array_t<const HBGlyphID> substitutes)
   {
     TRACE_SERIALIZE (this);
     if (unlikely (!Lookup::serialize (c, SubTable::Single, lookup_props, 1))) return_trace (false);
@@ -1303,9 +1464,9 @@ struct SubstLookup : Lookup
 
   bool serialize_multiple (hb_serialize_context_t *c,
 			   uint32_t lookup_props,
-			   hb_sorted_array_t<const GlyphID> glyphs,
+			   hb_sorted_array_t<const HBGlyphID> glyphs,
 			   hb_array_t<const unsigned int> substitute_len_list,
-			   hb_array_t<const GlyphID> substitute_glyphs_list)
+			   hb_array_t<const HBGlyphID> substitute_glyphs_list)
   {
     TRACE_SERIALIZE (this);
     if (unlikely (!Lookup::serialize (c, SubTable::Multiple, lookup_props, 1))) return_trace (false);
@@ -1318,9 +1479,9 @@ struct SubstLookup : Lookup
 
   bool serialize_alternate (hb_serialize_context_t *c,
 			    uint32_t lookup_props,
-			    hb_sorted_array_t<const GlyphID> glyphs,
+			    hb_sorted_array_t<const HBGlyphID> glyphs,
 			    hb_array_t<const unsigned int> alternate_len_list,
-			    hb_array_t<const GlyphID> alternate_glyphs_list)
+			    hb_array_t<const HBGlyphID> alternate_glyphs_list)
   {
     TRACE_SERIALIZE (this);
     if (unlikely (!Lookup::serialize (c, SubTable::Alternate, lookup_props, 1))) return_trace (false);
@@ -1333,11 +1494,11 @@ struct SubstLookup : Lookup
 
   bool serialize_ligature (hb_serialize_context_t *c,
 			   uint32_t lookup_props,
-			   hb_sorted_array_t<const GlyphID> first_glyphs,
+			   hb_sorted_array_t<const HBGlyphID> first_glyphs,
 			   hb_array_t<const unsigned int> ligature_per_first_glyph_count_list,
-			   hb_array_t<const GlyphID> ligatures_list,
+			   hb_array_t<const HBGlyphID> ligatures_list,
 			   hb_array_t<const unsigned int> component_count_list,
-			   hb_array_t<const GlyphID> component_list /* Starting from second for each ligature */)
+			   hb_array_t<const HBGlyphID> component_list /* Starting from second for each ligature */)
   {
     TRACE_SERIALIZE (this);
     if (unlikely (!Lookup::serialize (c, SubTable::Ligature, lookup_props, 1))) return_trace (false);
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-layout-jstf-table.hh b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-layout-jstf-table.hh
index 1dd31d5b0c5..53eb623cf5c 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-layout-jstf-table.hh
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-layout-jstf-table.hh
@@ -136,7 +136,7 @@ struct JstfLangSys : OffsetListOf<JstfPriority>
  * ExtenderGlyphs -- Extender Glyph Table
  */
 
-typedef SortedArrayOf<GlyphID> ExtenderGlyphs;
+typedef SortedArrayOf<HBGlyphID> ExtenderGlyphs;
 
 
 /*
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-layout.cc b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-layout.cc
index 72d65c95041..fba3ad1916a 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-layout.cc
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-layout.cc
@@ -567,7 +567,7 @@ hb_ot_layout_table_select_script (hb_face_t      *face,
     if (g.find_script_index (script_tags[i], script_index))
     {
       if (chosen_script)
-        *chosen_script = script_tags[i];
+	*chosen_script = script_tags[i];
       return true;
     }
   }
@@ -999,9 +999,9 @@ hb_ot_layout_table_get_lookup_count (hb_face_t    *face,
 
 struct hb_collect_features_context_t
 {
-  hb_collect_features_context_t (hb_face_t       *face,
-				 hb_tag_t         table_tag,
-				 hb_set_t        *feature_indexes_)
+  hb_collect_features_context_t (hb_face_t *face,
+				 hb_tag_t   table_tag,
+				 hb_set_t  *feature_indexes_)
     : g (get_gsubgpos_table (face, table_tag)),
       feature_indexes (feature_indexes_),
       script_count(0),langsys_count(0) {}
@@ -1147,11 +1147,11 @@ script_collect_features (hb_collect_features_context_t *c,
  **/
 void
 hb_ot_layout_collect_features (hb_face_t      *face,
-                               hb_tag_t        table_tag,
-                               const hb_tag_t *scripts,
-                               const hb_tag_t *languages,
-                               const hb_tag_t *features,
-                               hb_set_t       *feature_indexes /* OUT */)
+			       hb_tag_t        table_tag,
+			       const hb_tag_t *scripts,
+			       const hb_tag_t *languages,
+			       const hb_tag_t *features,
+			       hb_set_t       *feature_indexes /* OUT */)
 {
   hb_collect_features_context_t c (face, table_tag, feature_indexes);
   if (!scripts)
@@ -1227,7 +1227,7 @@ hb_ot_layout_collect_lookups (hb_face_t      *face,
  * @glyphs_output: (out): Array of glyphs that would be the substitued output of the lookup
  *
  * Fetches a list of all glyphs affected by the specified lookup in the
- * specified face's GSUB table of GPOS table.
+ * specified face's GSUB table or GPOS table.
  *
  * Since: 0.9.7
  **/
@@ -1482,8 +1482,8 @@ hb_ot_layout_lookup_substitute_closure (hb_face_t    *face,
  **/
 void
 hb_ot_layout_lookups_substitute_closure (hb_face_t      *face,
-                                         const hb_set_t *lookups,
-                                         hb_set_t       *glyphs /* OUT */)
+					 const hb_set_t *lookups,
+					 hb_set_t       *glyphs /* OUT */)
 {
   hb_map_t done_lookups;
   OT::hb_closure_context_t c (face, glyphs, &done_lookups);
@@ -1497,12 +1497,12 @@ hb_ot_layout_lookups_substitute_closure (hb_face_t      *face,
     if (lookups != nullptr)
     {
       for (hb_codepoint_t lookup_index = HB_SET_VALUE_INVALID; hb_set_next (lookups, &lookup_index);)
-        gsub.get_lookup (lookup_index).closure (&c, lookup_index);
+	gsub.get_lookup (lookup_index).closure (&c, lookup_index);
     }
     else
     {
       for (unsigned int i = 0; i < gsub.get_lookup_count (); i++)
-        gsub.get_lookup (i).closure (&c, i);
+	gsub.get_lookup (i).closure (&c, i);
     }
   } while (iteration_count++ <= HB_CLOSURE_MAX_STAGES &&
 	   glyphs_length != glyphs->get_population ());
@@ -1949,7 +1949,7 @@ hb_ot_layout_substitute_lookup (OT::hb_ot_apply_context_t *c,
 /**
  * hb_ot_layout_get_baseline:
  * @font: a font
- * @baseline: a baseline tag
+ * @baseline_tag: a baseline tag
  * @direction: text direction.
  * @script_tag:  script tag.
  * @language_tag: language tag.
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-layout.h b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-layout.h
index 5124c1e1f40..7e8a897cff5 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-layout.h
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-layout.h
@@ -249,11 +249,11 @@ hb_ot_layout_table_get_lookup_count (hb_face_t    *face,
 
 HB_EXTERN void
 hb_ot_layout_collect_features (hb_face_t      *face,
-                               hb_tag_t        table_tag,
-                               const hb_tag_t *scripts,
-                               const hb_tag_t *languages,
-                               const hb_tag_t *features,
-                               hb_set_t       *feature_indexes /* OUT */);
+			       hb_tag_t        table_tag,
+			       const hb_tag_t *scripts,
+			       const hb_tag_t *languages,
+			       const hb_tag_t *features,
+			       hb_set_t       *feature_indexes /* OUT */);
 
 HB_EXTERN void
 hb_ot_layout_collect_lookups (hb_face_t      *face,
@@ -333,14 +333,14 @@ hb_ot_layout_lookup_would_substitute (hb_face_t            *face,
 
 HB_EXTERN void
 hb_ot_layout_lookup_substitute_closure (hb_face_t    *face,
-				        unsigned int  lookup_index,
-				        hb_set_t     *glyphs
+					unsigned int  lookup_index,
+					hb_set_t     *glyphs
 					/*TODO , hb_bool_t  inclusive */);
 
 HB_EXTERN void
 hb_ot_layout_lookups_substitute_closure (hb_face_t      *face,
-                                         const hb_set_t *lookups,
-                                         hb_set_t       *glyphs);
+					 const hb_set_t *lookups,
+					 hb_set_t       *glyphs);
 
 
 #ifdef HB_NOT_IMPLEMENTED
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-map.cc b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-map.cc
index b0bc4726b38..d40c67af9c0 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-map.cc
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-map.cc
@@ -191,7 +191,8 @@ hb_ot_map_builder_t::compile (hb_ot_map_t                  &m,
 	  feature_infos[j].max_value = feature_infos[i].max_value;
 	  feature_infos[j].default_value = feature_infos[i].default_value;
 	} else {
-	  feature_infos[j].flags &= ~F_GLOBAL;
+	  if (feature_infos[j].flags & F_GLOBAL)
+	    feature_infos[j].flags ^= F_GLOBAL;
 	  feature_infos[j].max_value = hb_max (feature_infos[j].max_value, feature_infos[i].max_value);
 	  /* Inherit default_value from j */
 	}
@@ -297,7 +298,7 @@ hb_ot_map_builder_t::compile (hb_ot_map_t                  &m,
 		     global_bit_mask);
 
       for (unsigned i = 0; i < m.features.length; i++)
-        if (m.features[i].stage[table_index] == stage)
+	if (m.features[i].stage[table_index] == stage)
 	  add_lookups (m, table_index,
 		       m.features[i].index[table_index],
 		       key.variations_index[table_index],
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-math-table.hh b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-math-table.hh
index b4592ccdea2..7529e0c0800 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-math-table.hh
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-math-table.hh
@@ -423,7 +423,7 @@ struct MathGlyphVariantRecord
   }
 
   protected:
-  GlyphID variantGlyph;       /* Glyph ID for the variant. */
+  HBGlyphID variantGlyph;       /* Glyph ID for the variant. */
   HBUINT16  advanceMeasurement; /* Advance width/height, in design units, of the
 				 * variant, in the direction of requested
 				 * glyph extension. */
@@ -471,7 +471,7 @@ struct MathGlyphPartRecord
   }
 
   protected:
-  GlyphID   glyph;		  /* Glyph ID for the part. */
+  HBGlyphID   glyph;		  /* Glyph ID for the part. */
   HBUINT16    startConnectorLength; /* Advance width/ height of the straight bar
 				   * connector material, in design units, is at
 				   * the beginning of the glyph, in the
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-maxp-table.hh b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-maxp-table.hh
index 2ba2cf44d0d..1c25eda16b5 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-maxp-table.hh
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-maxp-table.hh
@@ -108,7 +108,7 @@ struct maxp
       if (unlikely (!dest_v1)) return_trace (false);
 
       if (c->plan->drop_hints)
-        drop_hint_fields (dest_v1);
+	drop_hint_fields (dest_v1);
     }
 
     return_trace (true);
@@ -129,7 +129,7 @@ struct maxp
   FixedVersion<>version;		/* Version of the maxp table (0.5 or 1.0),
 					 * 0x00005000u or 0x00010000u. */
   HBUINT16	numGlyphs;		/* The number of glyphs in the font. */
-/*maxpV1Tail	v1Tail[VAR]; */
+/*maxpV1Tail	v1Tail[HB_VAR_ARRAY]; */
   public:
   DEFINE_SIZE_STATIC (6);
 };
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-name-table.hh b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-name-table.hh
index 59bf4387f39..84be04c8bfd 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-name-table.hh
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-name-table.hh
@@ -191,9 +191,7 @@ struct name
 
     const void *dst_string_pool = &(this + this->stringOffset);
 
-    + it
-    | hb_apply ([=] (const NameRecord& _) { c->copy (_, src_string_pool, dst_string_pool); })
-    ;
+    for (const auto &_ : it) c->copy (_, src_string_pool, dst_string_pool);
 
     if (unlikely (c->ran_out_of_room)) return_trace (false);
 
@@ -265,10 +263,10 @@ struct name
       unsigned int j = 0;
       for (unsigned int i = 0; i < this->names.length; i++)
       {
-        if (this->names[i].entry_score == UNSUPPORTED ||
+	if (this->names[i].entry_score == UNSUPPORTED ||
 	    this->names[i].language == HB_LANGUAGE_INVALID)
 	  continue;
-        if (i &&
+	if (i &&
 	    this->names[i - 1].name_id  == this->names[i].name_id &&
 	    this->names[i - 1].language == this->names[i].language)
 	  continue;
@@ -295,10 +293,10 @@ struct name
 						    sizeof (key),
 						    _hb_ot_name_entry_cmp_key);
       if (!entry)
-        return -1;
+	return -1;
 
       if (width)
-        *width = entry->entry_score < 10 ? 2 : 1;
+	*width = entry->entry_score < 10 ? 2 : 1;
 
       return entry->entry_index;
     }
@@ -330,6 +328,9 @@ struct name
   DEFINE_SIZE_ARRAY (6, nameRecordZ);
 };
 
+#undef entry_index
+#undef entry_score
+
 struct name_accelerator_t : name::accelerator_t {};
 
 } /* namespace OT */
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-name.cc b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-name.cc
index 0b5ce810e2f..10122b8c2e9 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-name.cc
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-name.cc
@@ -90,7 +90,7 @@ hb_ot_name_convert_utf (hb_bytes_t                       bytes,
       const typename in_utf_t::codepoint_t *src_next = in_utf_t::next (src, src_end, &unicode, replacement);
       typename out_utf_t::codepoint_t *dst_next = out_utf_t::encode (dst, dst_end, unicode);
       if (dst_next == dst)
-        break; /* Out-of-room. */
+	break; /* Out-of-room. */
 
       dst = dst_next;
       src = src_next;
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-post-table.hh b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-post-table.hh
index fb826cd3511..38302f5518e 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-post-table.hh
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-post-table.hh
@@ -262,7 +262,7 @@ struct post
 					 * 0x00020000 for version 2.0
 					 * 0x00025000 for version 2.5 (deprecated)
 					 * 0x00030000 for version 3.0 */
-  Fixed		italicAngle;		/* Italic angle in counter-clockwise degrees
+  HBFixed		italicAngle;		/* Italic angle in counter-clockwise degrees
 					 * from the vertical. Zero for upright text,
 					 * negative for text that leans to the right
 					 * (forward). */
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-shape-complex-arabic-fallback.hh b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-shape-complex-arabic-fallback.hh
index ecf3450490c..bb0141d1093 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-shape-complex-arabic-fallback.hh
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-shape-complex-arabic-fallback.hh
@@ -49,8 +49,8 @@ arabic_fallback_synthesize_lookup_single (const hb_ot_shape_plan_t *plan HB_UNUS
 					  hb_font_t *font,
 					  unsigned int feature_index)
 {
-  OT::GlyphID glyphs[SHAPING_TABLE_LAST - SHAPING_TABLE_FIRST + 1];
-  OT::GlyphID substitutes[SHAPING_TABLE_LAST - SHAPING_TABLE_FIRST + 1];
+  OT::HBGlyphID glyphs[SHAPING_TABLE_LAST - SHAPING_TABLE_FIRST + 1];
+  OT::HBGlyphID substitutes[SHAPING_TABLE_LAST - SHAPING_TABLE_FIRST + 1];
   unsigned int num_glyphs = 0;
 
   /* Populate arrays */
@@ -78,7 +78,7 @@ arabic_fallback_synthesize_lookup_single (const hb_ot_shape_plan_t *plan HB_UNUS
   /* Bubble-sort or something equally good!
    * May not be good-enough for presidential candidate interviews, but good-enough for us... */
   hb_stable_sort (&glyphs[0], num_glyphs,
-		  (int(*)(const OT::HBUINT16*, const OT::HBUINT16 *)) OT::GlyphID::cmp,
+		  (int(*)(const OT::HBUINT16*, const OT::HBUINT16 *)) OT::HBGlyphID::cmp,
 		  &substitutes[0]);
 
 
@@ -99,15 +99,15 @@ static OT::SubstLookup *
 arabic_fallback_synthesize_lookup_ligature (const hb_ot_shape_plan_t *plan HB_UNUSED,
 					    hb_font_t *font)
 {
-  OT::GlyphID first_glyphs[ARRAY_LENGTH_CONST (ligature_table)];
+  OT::HBGlyphID first_glyphs[ARRAY_LENGTH_CONST (ligature_table)];
   unsigned int first_glyphs_indirection[ARRAY_LENGTH_CONST (ligature_table)];
   unsigned int ligature_per_first_glyph_count_list[ARRAY_LENGTH_CONST (first_glyphs)];
   unsigned int num_first_glyphs = 0;
 
   /* We know that all our ligatures are 2-component */
-  OT::GlyphID ligature_list[ARRAY_LENGTH_CONST (first_glyphs) * ARRAY_LENGTH_CONST(ligature_table[0].ligatures)];
+  OT::HBGlyphID ligature_list[ARRAY_LENGTH_CONST (first_glyphs) * ARRAY_LENGTH_CONST(ligature_table[0].ligatures)];
   unsigned int component_count_list[ARRAY_LENGTH_CONST (ligature_list)];
-  OT::GlyphID component_list[ARRAY_LENGTH_CONST (ligature_list) * 1/* One extra component per ligature */];
+  OT::HBGlyphID component_list[ARRAY_LENGTH_CONST (ligature_list) * 1/* One extra component per ligature */];
   unsigned int num_ligatures = 0;
 
   /* Populate arrays */
@@ -125,7 +125,7 @@ arabic_fallback_synthesize_lookup_ligature (const hb_ot_shape_plan_t *plan HB_UN
     num_first_glyphs++;
   }
   hb_stable_sort (&first_glyphs[0], num_first_glyphs,
-		  (int(*)(const OT::HBUINT16*, const OT::HBUINT16 *)) OT::GlyphID::cmp,
+		  (int(*)(const OT::HBUINT16*, const OT::HBUINT16 *)) OT::HBGlyphID::cmp,
 		  &first_glyphs_indirection[0]);
 
   /* Now that the first-glyphs are sorted, walk again, populate ligatures. */
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-shape-complex-arabic.cc b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-shape-complex-arabic.cc
index b24833b71b0..f92e6378a1f 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-shape-complex-arabic.cc
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-shape-complex-arabic.cc
@@ -476,13 +476,13 @@ apply_stch (const hb_ot_shape_plan_t *plan HB_UNUSED,
     {
       if (!hb_in_range<uint8_t> (info[i - 1].arabic_shaping_action(), STCH_FIXED, STCH_REPEATING))
       {
-        if (step == CUT)
+	if (step == CUT)
 	{
 	  --j;
 	  info[j] = info[i - 1];
 	  pos[j] = pos[i - 1];
 	}
-        continue;
+	continue;
       }
 
       /* Yay, justification! */
@@ -540,10 +540,10 @@ apply_stch (const hb_ot_shape_plan_t *plan HB_UNUSED,
       hb_position_t shortfall = sign * w_remaining - sign * w_repeating * (n_copies + 1);
       if (shortfall > 0 && n_repeating > 0)
       {
-        ++n_copies;
-        hb_position_t excess = (n_copies + 1) * sign * w_repeating - sign * w_remaining;
-        if (excess > 0)
-          extra_repeat_overlap = excess / (n_copies * n_repeating);
+	++n_copies;
+	hb_position_t excess = (n_copies + 1) * sign * w_repeating - sign * w_remaining;
+	if (excess > 0)
+	  extra_repeat_overlap = excess / (n_copies * n_repeating);
       }
 
       if (step == MEASURE)
@@ -583,7 +583,7 @@ apply_stch (const hb_ot_shape_plan_t *plan HB_UNUSED,
     if (step == MEASURE)
     {
       if (unlikely (!buffer->ensure (count + extra_glyphs_needed)))
-        break;
+	break;
     }
     else
     {
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-shape-complex-hangul.cc b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-shape-complex-hangul.cc
index 32e0e66123a..f5915f43ae4 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-shape-complex-hangul.cc
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-shape-complex-hangul.cc
@@ -204,7 +204,7 @@ preprocess_text_hangul (const hb_ot_shape_plan_t *plan HB_UNUSED,
       if (start < end && end == buffer->out_len)
       {
 	/* Tone mark follows a valid syllable; move it in front, unless it's zero width. */
-        buffer->unsafe_to_break_from_outbuffer (start, buffer->idx);
+	buffer->unsafe_to_break_from_outbuffer (start, buffer->idx);
 	buffer->next_glyph ();
 	if (!is_zero_width_char (font, u))
 	{
@@ -354,9 +354,9 @@ preprocess_text_hangul (const hb_ot_shape_plan_t *plan HB_UNUSED,
 	   */
 	  if (has_glyph && !tindex)
 	  {
-            buffer->next_glyph ();
-            s_len++;
-          }
+	    buffer->next_glyph ();
+	    s_len++;
+	  }
 
 	  if (unlikely (!buffer->successful))
 	    return;
@@ -365,7 +365,7 @@ preprocess_text_hangul (const hb_ot_shape_plan_t *plan HB_UNUSED,
 	   * that are now in buffer->out_info.
 	   */
 	  hb_glyph_info_t *info = buffer->out_info;
-          end = start + s_len;
+	  end = start + s_len;
 
 	  unsigned int i = start;
 	  info[i++].hangul_shaping_feature() = LJMO;
@@ -383,7 +383,7 @@ preprocess_text_hangul (const hb_ot_shape_plan_t *plan HB_UNUSED,
 
       if (has_glyph)
       {
-        /* We didn't decompose the S, so just advance past it. */
+	/* We didn't decompose the S, so just advance past it. */
 	end = start + 1;
 	buffer->next_glyph ();
 	continue;
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-shape-complex-indic-table.cc b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-shape-complex-indic-table.cc
index 419aae11e80..cc91f172c30 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-shape-complex-indic-table.cc
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-shape-complex-indic-table.cc
@@ -23,58 +23,59 @@
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wunused-macros"
 
-#define ISC_A	INDIC_SYLLABIC_CATEGORY_AVAGRAHA		/*  17 chars; Avagraha */
-#define ISC_Bi	INDIC_SYLLABIC_CATEGORY_BINDU			/*  86 chars; Bindu */
-#define ISC_BJN	INDIC_SYLLABIC_CATEGORY_BRAHMI_JOINING_NUMBER	/*  20 chars; Brahmi_Joining_Number */
-#define ISC_Ca	INDIC_SYLLABIC_CATEGORY_CANTILLATION_MARK	/*  59 chars; Cantillation_Mark */
-#define ISC_C	INDIC_SYLLABIC_CATEGORY_CONSONANT		/* 2160 chars; Consonant */
-#define ISC_CD	INDIC_SYLLABIC_CATEGORY_CONSONANT_DEAD		/*  12 chars; Consonant_Dead */
-#define ISC_CF	INDIC_SYLLABIC_CATEGORY_CONSONANT_FINAL		/*  67 chars; Consonant_Final */
-#define ISC_CHL	INDIC_SYLLABIC_CATEGORY_CONSONANT_HEAD_LETTER	/*   5 chars; Consonant_Head_Letter */
-#define ISC_CIP	INDIC_SYLLABIC_CATEGORY_CONSONANT_INITIAL_POSTFIXED	/*   1 chars; Consonant_Initial_Postfixed */
-#define ISC_CK	INDIC_SYLLABIC_CATEGORY_CONSONANT_KILLER	/*   2 chars; Consonant_Killer */
-#define ISC_CM	INDIC_SYLLABIC_CATEGORY_CONSONANT_MEDIAL	/*  29 chars; Consonant_Medial */
-#define ISC_CP	INDIC_SYLLABIC_CATEGORY_CONSONANT_PLACEHOLDER	/*  22 chars; Consonant_Placeholder */
-#define ISC_CPR	INDIC_SYLLABIC_CATEGORY_CONSONANT_PRECEDING_REPHA	/*   2 chars; Consonant_Preceding_Repha */
-#define ISC_CPrf	INDIC_SYLLABIC_CATEGORY_CONSONANT_PREFIXED	/*   9 chars; Consonant_Prefixed */
-#define ISC_CS	INDIC_SYLLABIC_CATEGORY_CONSONANT_SUBJOINED	/*  94 chars; Consonant_Subjoined */
-#define ISC_CSR	INDIC_SYLLABIC_CATEGORY_CONSONANT_SUCCEEDING_REPHA	/*   4 chars; Consonant_Succeeding_Repha */
-#define ISC_CWS	INDIC_SYLLABIC_CATEGORY_CONSONANT_WITH_STACKER	/*   6 chars; Consonant_With_Stacker */
-#define ISC_GM	INDIC_SYLLABIC_CATEGORY_GEMINATION_MARK		/*   3 chars; Gemination_Mark */
-#define ISC_IS	INDIC_SYLLABIC_CATEGORY_INVISIBLE_STACKER	/*  11 chars; Invisible_Stacker */
-#define ISC_ZWJ	INDIC_SYLLABIC_CATEGORY_JOINER			/*   1 chars; Joiner */
-#define ISC_ML	INDIC_SYLLABIC_CATEGORY_MODIFYING_LETTER	/*   1 chars; Modifying_Letter */
-#define ISC_ZWNJ	INDIC_SYLLABIC_CATEGORY_NON_JOINER		/*   1 chars; Non_Joiner */
-#define ISC_N	INDIC_SYLLABIC_CATEGORY_NUKTA			/*  30 chars; Nukta */
-#define ISC_Nd	INDIC_SYLLABIC_CATEGORY_NUMBER			/* 481 chars; Number */
-#define ISC_NJ	INDIC_SYLLABIC_CATEGORY_NUMBER_JOINER		/*   1 chars; Number_Joiner */
-#define ISC_x	INDIC_SYLLABIC_CATEGORY_OTHER			/*   1 chars; Other */
-#define ISC_PK	INDIC_SYLLABIC_CATEGORY_PURE_KILLER		/*  21 chars; Pure_Killer */
-#define ISC_RS	INDIC_SYLLABIC_CATEGORY_REGISTER_SHIFTER	/*   2 chars; Register_Shifter */
-#define ISC_SM	INDIC_SYLLABIC_CATEGORY_SYLLABLE_MODIFIER	/*  25 chars; Syllable_Modifier */
-#define ISC_TL	INDIC_SYLLABIC_CATEGORY_TONE_LETTER		/*   7 chars; Tone_Letter */
-#define ISC_TM	INDIC_SYLLABIC_CATEGORY_TONE_MARK		/*  42 chars; Tone_Mark */
-#define ISC_V	INDIC_SYLLABIC_CATEGORY_VIRAMA			/*  27 chars; Virama */
-#define ISC_Vs	INDIC_SYLLABIC_CATEGORY_VISARGA			/*  35 chars; Visarga */
-#define ISC_Vo	INDIC_SYLLABIC_CATEGORY_VOWEL			/*  30 chars; Vowel */
-#define ISC_M	INDIC_SYLLABIC_CATEGORY_VOWEL_DEPENDENT		/* 673 chars; Vowel_Dependent */
-#define ISC_VI	INDIC_SYLLABIC_CATEGORY_VOWEL_INDEPENDENT	/* 476 chars; Vowel_Independent */
-
-#define IMC_B	INDIC_MATRA_CATEGORY_BOTTOM			/* 349 chars; Bottom */
-#define IMC_BL	INDIC_MATRA_CATEGORY_BOTTOM_AND_LEFT		/*   1 chars; Bottom_And_Left */
-#define IMC_BR	INDIC_MATRA_CATEGORY_BOTTOM_AND_RIGHT		/*   2 chars; Bottom_And_Right */
-#define IMC_L	INDIC_MATRA_CATEGORY_LEFT			/*  61 chars; Left */
-#define IMC_LR	INDIC_MATRA_CATEGORY_LEFT_AND_RIGHT		/*  21 chars; Left_And_Right */
-#define IMC_x	INDIC_MATRA_CATEGORY_NOT_APPLICABLE		/*   1 chars; Not_Applicable */
-#define IMC_O	INDIC_MATRA_CATEGORY_OVERSTRUCK			/*  10 chars; Overstruck */
-#define IMC_R	INDIC_MATRA_CATEGORY_RIGHT			/* 281 chars; Right */
-#define IMC_T	INDIC_MATRA_CATEGORY_TOP			/* 398 chars; Top */
-#define IMC_TB	INDIC_MATRA_CATEGORY_TOP_AND_BOTTOM		/*  10 chars; Top_And_Bottom */
-#define IMC_TBR	INDIC_MATRA_CATEGORY_TOP_AND_BOTTOM_AND_RIGHT	/*   1 chars; Top_And_Bottom_And_Right */
-#define IMC_TL	INDIC_MATRA_CATEGORY_TOP_AND_LEFT		/*   6 chars; Top_And_Left */
-#define IMC_TLR	INDIC_MATRA_CATEGORY_TOP_AND_LEFT_AND_RIGHT	/*   4 chars; Top_And_Left_And_Right */
-#define IMC_TR	INDIC_MATRA_CATEGORY_TOP_AND_RIGHT		/*  13 chars; Top_And_Right */
-#define IMC_VOL	INDIC_MATRA_CATEGORY_VISUAL_ORDER_LEFT		/*  19 chars; Visual_Order_Left */
+#define ISC_A    INDIC_SYLLABIC_CATEGORY_AVAGRAHA                    /*   17 chars; Avagraha */
+#define ISC_Bi   INDIC_SYLLABIC_CATEGORY_BINDU                       /*   86 chars; Bindu */
+#define ISC_BJN  INDIC_SYLLABIC_CATEGORY_BRAHMI_JOINING_NUMBER       /*   20 chars; Brahmi_Joining_Number */
+#define ISC_Ca   INDIC_SYLLABIC_CATEGORY_CANTILLATION_MARK           /*   59 chars; Cantillation_Mark */
+#define ISC_C    INDIC_SYLLABIC_CATEGORY_CONSONANT                   /* 2160 chars; Consonant */
+#define ISC_CD   INDIC_SYLLABIC_CATEGORY_CONSONANT_DEAD              /*   12 chars; Consonant_Dead */
+#define ISC_CF   INDIC_SYLLABIC_CATEGORY_CONSONANT_FINAL             /*   67 chars; Consonant_Final */
+#define ISC_CHL  INDIC_SYLLABIC_CATEGORY_CONSONANT_HEAD_LETTER       /*    5 chars; Consonant_Head_Letter */
+#define ISC_CIP  INDIC_SYLLABIC_CATEGORY_CONSONANT_INITIAL_POSTFIXED /*    1 chars; Consonant_Initial_Postfixed */
+#define ISC_CK   INDIC_SYLLABIC_CATEGORY_CONSONANT_KILLER            /*    2 chars; Consonant_Killer */
+#define ISC_CM   INDIC_SYLLABIC_CATEGORY_CONSONANT_MEDIAL            /*   29 chars; Consonant_Medial */
+#define ISC_CP   INDIC_SYLLABIC_CATEGORY_CONSONANT_PLACEHOLDER       /*   22 chars; Consonant_Placeholder */
+#define ISC_CPR  INDIC_SYLLABIC_CATEGORY_CONSONANT_PRECEDING_REPHA   /*    2 chars; Consonant_Preceding_Repha */
+#define ISC_CPrf INDIC_SYLLABIC_CATEGORY_CONSONANT_PREFIXED          /*    9 chars; Consonant_Prefixed */
+#define ISC_CS   INDIC_SYLLABIC_CATEGORY_CONSONANT_SUBJOINED         /*   94 chars; Consonant_Subjoined */
+#define ISC_CSR  INDIC_SYLLABIC_CATEGORY_CONSONANT_SUCCEEDING_REPHA  /*    4 chars; Consonant_Succeeding_Repha */
+#define ISC_CWS  INDIC_SYLLABIC_CATEGORY_CONSONANT_WITH_STACKER      /*    6 chars; Consonant_With_Stacker */
+#define ISC_GM   INDIC_SYLLABIC_CATEGORY_GEMINATION_MARK             /*    3 chars; Gemination_Mark */
+#define ISC_IS   INDIC_SYLLABIC_CATEGORY_INVISIBLE_STACKER           /*   11 chars; Invisible_Stacker */
+#define ISC_ZWJ  INDIC_SYLLABIC_CATEGORY_JOINER                      /*    1 chars; Joiner */
+#define ISC_ML   INDIC_SYLLABIC_CATEGORY_MODIFYING_LETTER            /*    1 chars; Modifying_Letter */
+#define ISC_ZWNJ INDIC_SYLLABIC_CATEGORY_NON_JOINER                  /*    1 chars; Non_Joiner */
+#define ISC_N    INDIC_SYLLABIC_CATEGORY_NUKTA                       /*   30 chars; Nukta */
+#define ISC_Nd   INDIC_SYLLABIC_CATEGORY_NUMBER                      /*  481 chars; Number */
+#define ISC_NJ   INDIC_SYLLABIC_CATEGORY_NUMBER_JOINER               /*    1 chars; Number_Joiner */
+#define ISC_x    INDIC_SYLLABIC_CATEGORY_OTHER                       /*    1 chars; Other */
+#define ISC_PK   INDIC_SYLLABIC_CATEGORY_PURE_KILLER                 /*   21 chars; Pure_Killer */
+#define ISC_RS   INDIC_SYLLABIC_CATEGORY_REGISTER_SHIFTER            /*    2 chars; Register_Shifter */
+#define ISC_SM   INDIC_SYLLABIC_CATEGORY_SYLLABLE_MODIFIER           /*   25 chars; Syllable_Modifier */
+#define ISC_TL   INDIC_SYLLABIC_CATEGORY_TONE_LETTER                 /*    7 chars; Tone_Letter */
+#define ISC_TM   INDIC_SYLLABIC_CATEGORY_TONE_MARK                   /*   42 chars; Tone_Mark */
+#define ISC_V    INDIC_SYLLABIC_CATEGORY_VIRAMA                      /*   27 chars; Virama */
+#define ISC_Vs   INDIC_SYLLABIC_CATEGORY_VISARGA                     /*   35 chars; Visarga */
+#define ISC_Vo   INDIC_SYLLABIC_CATEGORY_VOWEL                       /*   30 chars; Vowel */
+#define ISC_M    INDIC_SYLLABIC_CATEGORY_VOWEL_DEPENDENT             /*  673 chars; Vowel_Dependent */
+#define ISC_VI   INDIC_SYLLABIC_CATEGORY_VOWEL_INDEPENDENT           /*  476 chars; Vowel_Independent */
+
+#define IMC_B    INDIC_MATRA_CATEGORY_BOTTOM                         /*  349 chars; Bottom */
+#define IMC_BL   INDIC_MATRA_CATEGORY_BOTTOM_AND_LEFT                /*    1 chars; Bottom_And_Left */
+#define IMC_BR   INDIC_MATRA_CATEGORY_BOTTOM_AND_RIGHT               /*    2 chars; Bottom_And_Right */
+#define IMC_L    INDIC_MATRA_CATEGORY_LEFT                           /*   61 chars; Left */
+#define IMC_LR   INDIC_MATRA_CATEGORY_LEFT_AND_RIGHT                 /*   21 chars; Left_And_Right */
+#define IMC_x    INDIC_MATRA_CATEGORY_NOT_APPLICABLE                 /*    1 chars; Not_Applicable */
+#define IMC_O    INDIC_MATRA_CATEGORY_OVERSTRUCK                     /*   10 chars; Overstruck */
+#define IMC_R    INDIC_MATRA_CATEGORY_RIGHT                          /*  281 chars; Right */
+#define IMC_T    INDIC_MATRA_CATEGORY_TOP                            /*  398 chars; Top */
+#define IMC_TB   INDIC_MATRA_CATEGORY_TOP_AND_BOTTOM                 /*   10 chars; Top_And_Bottom */
+#define IMC_TBR  INDIC_MATRA_CATEGORY_TOP_AND_BOTTOM_AND_RIGHT       /*    1 chars; Top_And_Bottom_And_Right */
+#define IMC_TL   INDIC_MATRA_CATEGORY_TOP_AND_LEFT                   /*    6 chars; Top_And_Left */
+#define IMC_TLR  INDIC_MATRA_CATEGORY_TOP_AND_LEFT_AND_RIGHT         /*    4 chars; Top_And_Left_And_Right */
+#define IMC_TR   INDIC_MATRA_CATEGORY_TOP_AND_RIGHT                  /*   13 chars; Top_And_Right */
+#define IMC_VOL  INDIC_MATRA_CATEGORY_VISUAL_ORDER_LEFT              /*   19 chars; Visual_Order_Left */
+
 #pragma GCC diagnostic pop
 
 #define _(S,M) INDIC_COMBINE_CATEGORIES (ISC_##S, IMC_##M)
@@ -439,6 +440,7 @@ hb_indic_get_categories (hb_codepoint_t u)
 }
 
 #undef _
+
 #undef ISC_A
 #undef ISC_Bi
 #undef ISC_BJN
@@ -475,6 +477,7 @@ hb_indic_get_categories (hb_codepoint_t u)
 #undef ISC_Vo
 #undef ISC_M
 #undef ISC_VI
+
 #undef IMC_B
 #undef IMC_BL
 #undef IMC_BR
@@ -491,6 +494,6 @@ hb_indic_get_categories (hb_codepoint_t u)
 #undef IMC_TR
 #undef IMC_VOL
 
-
 #endif
+
 /* == End of generated table == */
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-shape-complex-indic.cc b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-shape-complex-indic.cc
index a04c92074f5..26dc60ddc98 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-shape-complex-indic.cc
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-shape-complex-indic.cc
@@ -540,7 +540,7 @@ initial_reordering_consonant_syllable (const hb_ot_shape_plan_t *plan,
 
       case BASE_POS_LAST_SINHALA:
       {
-        /* Sinhala base positioning is slightly different from main Indic, in that:
+	/* Sinhala base positioning is slightly different from main Indic, in that:
 	 * 1. Its ZWJ behavior is different,
 	 * 2. We don't need to look into the font for consonant positions.
 	 */
@@ -669,8 +669,8 @@ initial_reordering_consonant_syllable (const hb_ot_shape_plan_t *plan,
     for (unsigned int i = base + 1; i < end; i++)
       if (info[i].indic_category() == OT_H)
       {
-        unsigned int j;
-        for (j = end - 1; j > i; j--)
+	unsigned int j;
+	for (j = end - 1; j > i; j--)
 	  if (is_consonant (info[j]) ||
 	      (disallow_double_halants && info[j].indic_category() == OT_H))
 	    break;
@@ -680,7 +680,7 @@ initial_reordering_consonant_syllable (const hb_ot_shape_plan_t *plan,
 	  memmove (&info[i], &info[i + 1], (j - i) * sizeof (info[0]));
 	  info[j] = t;
 	}
-        break;
+	break;
       }
   }
 
@@ -711,7 +711,7 @@ initial_reordering_consonant_syllable (const hb_ot_shape_plan_t *plan,
 	    }
 	}
       } else if (info[i].indic_position() != POS_SMVD) {
-        last_pos = (indic_position_t) info[i].indic_position();
+	last_pos = (indic_position_t) info[i].indic_position();
       }
     }
   }
@@ -727,7 +727,7 @@ initial_reordering_consonant_syllable (const hb_ot_shape_plan_t *plan,
 	    info[j].indic_position() = info[i].indic_position();
 	last = i;
       } else if (info[i].indic_category() == OT_M)
-        last = i;
+	last = i;
   }
 
 
@@ -764,7 +764,7 @@ initial_reordering_consonant_syllable (const hb_ot_shape_plan_t *plan,
     {
       /* Note!  syllable() is a one-byte field. */
       for (unsigned int i = base; i < end; i++)
-        if (info[i].syllable() != 255)
+	if (info[i].syllable() != 255)
 	{
 	  unsigned int max = i;
 	  unsigned int j = start + info[i].syllable();
@@ -852,7 +852,7 @@ initial_reordering_consonant_syllable (const hb_ot_shape_plan_t *plan,
     for (unsigned int i = base + 1; i + pref_len - 1 < end; i++) {
       hb_codepoint_t glyphs[2];
       for (unsigned int j = 0; j < pref_len; j++)
-        glyphs[j] = info[i + j].codepoint;
+	glyphs[j] = info[i + j].codepoint;
       if (indic_plan->pref.would_substitute (glyphs, pref_len, face))
       {
 	for (unsigned int j = 0; j < pref_len; j++)
@@ -983,7 +983,7 @@ insert_dotted_circles_indic (const hb_ot_shape_plan_t *plan HB_UNUSED,
       while (buffer->idx < buffer->len && buffer->successful &&
 	     last_syllable == buffer->cur().syllable() &&
 	     buffer->cur().indic_category() == OT_Repha)
-        buffer->next_glyph ();
+	buffer->next_glyph ();
 
       buffer->output_info (ginfo);
     }
@@ -1029,7 +1029,7 @@ final_reordering_syllable_indic (const hb_ot_shape_plan_t *plan,
 	  _hb_glyph_info_ligated (&info[i]) &&
 	  _hb_glyph_info_multiplied (&info[i]))
       {
-        /* This will make sure that this glyph passes is_halant() test. */
+	/* This will make sure that this glyph passes is_halant() test. */
 	info[i].indic_category() = OT_H;
 	_hb_glyph_info_clear_ligated_and_multiplied (&info[i]);
       }
@@ -1092,7 +1092,7 @@ final_reordering_syllable_indic (const hb_ot_shape_plan_t *plan,
       }
 
       if (start < base && info[base].indic_position() > POS_BASE_C)
-        base--;
+	base--;
       break;
     }
   if (base == end && start < base &&
@@ -1182,7 +1182,7 @@ final_reordering_syllable_indic (const hb_ot_shape_plan_t *plan,
 	}
       }
       else
-        new_pos = start; /* No move. */
+	new_pos = start; /* No move. */
     }
 
     if (start < new_pos && info[new_pos].indic_position () != POS_PRE_M)
@@ -1284,7 +1284,7 @@ final_reordering_syllable_indic (const hb_ot_shape_plan_t *plan,
       while (new_reph_pos + 1 < end && info[new_reph_pos + 1].indic_position() <= POS_AFTER_MAIN)
 	new_reph_pos++;
       if (new_reph_pos < end)
-        goto reph_move;
+	goto reph_move;
     }
 
     /*       4. If reph should be positioned before post-base consonant, find
@@ -1300,7 +1300,7 @@ final_reordering_syllable_indic (const hb_ot_shape_plan_t *plan,
 	     !( FLAG_UNSAFE (info[new_reph_pos + 1].indic_position()) & (FLAG (POS_POST_C) | FLAG (POS_AFTER_POST) | FLAG (POS_SMVD))))
 	new_reph_pos++;
       if (new_reph_pos < end)
-        goto reph_move;
+	goto reph_move;
     }
 
     /*       5. If no consonant is found in steps 3 or 4, move reph to a position
@@ -1382,7 +1382,7 @@ final_reordering_syllable_indic (const hb_ot_shape_plan_t *plan,
 	 *          of the <pref> feature. (Note that a font may shape a Ra consonant with
 	 *          the feature generally but block it in certain contexts.)
 	 */
-        /* Note: We just check that something got substituted.  We don't check that
+	/* Note: We just check that something got substituted.  We don't check that
 	 * the <pref> feature actually did it...
 	 *
 	 * Reorder pref only if it ligated. */
@@ -1428,7 +1428,7 @@ final_reordering_syllable_indic (const hb_ot_shape_plan_t *plan,
 	  }
 	}
 
-        break;
+	break;
       }
   }
 
@@ -1454,7 +1454,7 @@ final_reordering_syllable_indic (const hb_ot_shape_plan_t *plan,
     {
       case HB_SCRIPT_TAMIL:
       case HB_SCRIPT_SINHALA:
-        break;
+	break;
 
       default:
 	/* Uniscribe merges the entire syllable into a single cluster... Except for Tamil & Sinhala.
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-shape-complex-khmer.cc b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-shape-complex-khmer.cc
index cd82900ba11..fd8a9be978f 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-shape-complex-khmer.cc
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-shape-complex-khmer.cc
@@ -378,7 +378,7 @@ insert_dotted_circles_khmer (const hb_ot_shape_plan_t *plan HB_UNUSED,
       while (buffer->idx < buffer->len && buffer->successful &&
 	     last_syllable == buffer->cur().syllable() &&
 	     buffer->cur().khmer_category() == OT_Repha)
-        buffer->next_glyph ();
+	buffer->next_glyph ();
 
       buffer->output_info (ginfo);
     }
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-shape-complex-myanmar.cc b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-shape-complex-myanmar.cc
index 8b9afa503f2..dad1dba4adf 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-shape-complex-myanmar.cc
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-shape-complex-myanmar.cc
@@ -239,7 +239,7 @@ initial_reordering_consonant_syllable (hb_buffer_t *buffer,
       }
       if (pos == POS_BELOW_C && info[i].myanmar_category() != OT_A)
       {
-        pos = POS_AFTER_SUB;
+	pos = POS_AFTER_SUB;
 	info[i].myanmar_position() = pos;
 	continue;
       }
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-shape-complex-use.cc b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-shape-complex-use.cc
index ffef685babb..10f5822c003 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-shape-complex-use.cc
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-shape-complex-use.cc
@@ -534,7 +534,7 @@ insert_dotted_circles_use (const hb_ot_shape_plan_t *plan HB_UNUSED,
       while (buffer->idx < buffer->len && buffer->successful &&
 	     last_syllable == buffer->cur().syllable() &&
 	     buffer->cur().use_category() == USE_R)
-        buffer->next_glyph ();
+	buffer->next_glyph ();
 
       buffer->output_info (ginfo);
     }
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-shape-fallback.cc b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-shape-fallback.cc
index 03a42df6f68..024bcfe04fd 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-shape-fallback.cc
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-shape-fallback.cc
@@ -45,30 +45,30 @@ recategorize_combining_class (hb_codepoint_t u,
     {
       switch (u)
       {
-        case 0x0E31u:
-        case 0x0E34u:
-        case 0x0E35u:
-        case 0x0E36u:
-        case 0x0E37u:
-        case 0x0E47u:
-        case 0x0E4Cu:
-        case 0x0E4Du:
-        case 0x0E4Eu:
+	case 0x0E31u:
+	case 0x0E34u:
+	case 0x0E35u:
+	case 0x0E36u:
+	case 0x0E37u:
+	case 0x0E47u:
+	case 0x0E4Cu:
+	case 0x0E4Du:
+	case 0x0E4Eu:
 	  klass = HB_UNICODE_COMBINING_CLASS_ABOVE_RIGHT;
 	  break;
 
-        case 0x0EB1u:
-        case 0x0EB4u:
-        case 0x0EB5u:
-        case 0x0EB6u:
-        case 0x0EB7u:
-        case 0x0EBBu:
-        case 0x0ECCu:
-        case 0x0ECDu:
+	case 0x0EB1u:
+	case 0x0EB4u:
+	case 0x0EB5u:
+	case 0x0EB6u:
+	case 0x0EB7u:
+	case 0x0EBBu:
+	case 0x0ECCu:
+	case 0x0ECDu:
 	  klass = HB_UNICODE_COMBINING_CLASS_ABOVE;
 	  break;
 
-        case 0x0EBCu:
+	case 0x0EBCu:
 	  klass = HB_UNICODE_COMBINING_CLASS_BELOW;
 	  break;
       }
@@ -167,8 +167,8 @@ recategorize_combining_class (hb_codepoint_t u,
 
 void
 _hb_ot_shape_fallback_mark_position_recategorize_marks (const hb_ot_shape_plan_t *plan HB_UNUSED,
-						        hb_font_t *font HB_UNUSED,
-						        hb_buffer_t  *buffer)
+							hb_font_t *font HB_UNUSED,
+							hb_buffer_t  *buffer)
 {
 #ifdef HB_NO_OT_SHAPE_FALLBACK
   return;
@@ -232,10 +232,10 @@ position_mark (const hb_ot_shape_plan_t *plan HB_UNUSED,
     case HB_UNICODE_COMBINING_CLASS_DOUBLE_ABOVE:
       if (buffer->props.direction == HB_DIRECTION_LTR) {
 	pos.x_offset += base_extents.x_bearing + base_extents.width - mark_extents.width / 2 - mark_extents.x_bearing;
-        break;
+	break;
       } else if (buffer->props.direction == HB_DIRECTION_RTL) {
 	pos.x_offset += base_extents.x_bearing - mark_extents.width / 2 - mark_extents.x_bearing;
-        break;
+	break;
       }
       HB_FALLTHROUGH;
 
@@ -387,7 +387,7 @@ position_around_base (const hb_ot_shape_plan_t *plan,
       if (last_combining_class != this_combining_class)
       {
 	last_combining_class = this_combining_class;
-        cluster_extents = component_extents;
+	cluster_extents = component_extents;
       }
 
       position_mark (plan, font, buffer, cluster_extents, i, this_combining_class);
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-shape-normalize.cc b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-shape-normalize.cc
index 14c5bd4ac0c..553d5325749 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-shape-normalize.cc
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-shape-normalize.cc
@@ -233,7 +233,7 @@ handle_variation_selector_cluster (const hb_ot_shape_normalize_context_t *c,
       }
       else
       {
-        /* Just pass on the two characters separately, let GSUB do its magic. */
+	/* Just pass on the two characters separately, let GSUB do its magic. */
 	set_glyph (buffer->cur(), font);
 	buffer->next_glyph ();
 	set_glyph (buffer->cur(), font);
@@ -343,7 +343,7 @@ _hb_ot_shape_normalize (const hb_ot_shape_plan_t *plan,
       /* From idx to end are simple clusters. */
       if (might_short_circuit)
       {
-        unsigned int done = font->get_nominal_glyphs (end - buffer->idx,
+	unsigned int done = font->get_nominal_glyphs (end - buffer->idx,
 						      &buffer->cur().codepoint,
 						      sizeof (buffer->info[0]),
 						      &buffer->cur().glyph_index(),
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-shape.cc b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-shape.cc
index d0c66b44613..5d9a70cda2e 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-shape.cc
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-shape.cc
@@ -489,7 +489,7 @@ hb_set_unicode_props (hb_buffer_t *buffer)
       if (i + 1 < count &&
 	  _hb_unicode_is_emoji_Extended_Pictographic (info[i + 1].codepoint))
       {
-        i++;
+	i++;
 	_hb_glyph_info_set_unicode_props (&info[i], buffer);
 	_hb_glyph_info_set_continuation (&info[i]);
       }
@@ -650,19 +650,19 @@ hb_ot_shape_setup_masks_fraction (const hb_ot_shape_context_t *c)
       while (start &&
 	     _hb_glyph_info_get_general_category (&info[start - 1]) ==
 	     HB_UNICODE_GENERAL_CATEGORY_DECIMAL_NUMBER)
-        start--;
+	start--;
       while (end < count &&
 	     _hb_glyph_info_get_general_category (&info[end]) ==
 	     HB_UNICODE_GENERAL_CATEGORY_DECIMAL_NUMBER)
-        end++;
+	end++;
 
       buffer->unsafe_to_break (start, end);
 
       for (unsigned int j = start; j < i; j++)
-        info[j].mask |= pre_mask;
+	info[j].mask |= pre_mask;
       info[i].mask |= c->plan->frac_mask;
       for (unsigned int j = i + 1; j < end; j++)
-        info[j].mask |= post_mask;
+	info[j].mask |= post_mask;
 
       i = end - 1;
     }
@@ -869,7 +869,7 @@ zero_mark_widths_by_gdef (hb_buffer_t *buffer, bool adjust_offsets)
     if (_hb_glyph_info_is_mark (&info[i]))
     {
       if (adjust_offsets)
-        adjust_mark_offsets (&buffer->pos[i]);
+	adjust_mark_offsets (&buffer->pos[i]);
       zero_mark_width (&buffer->pos[i]);
     }
 }
@@ -885,7 +885,7 @@ hb_ot_position_default (const hb_ot_shape_context_t *c)
   if (HB_DIRECTION_IS_HORIZONTAL (direction))
   {
     c->font->get_glyph_h_advances (count, &info[0].codepoint, sizeof(info[0]),
-                                   &pos[0].x_advance, sizeof(pos[0]));
+				   &pos[0].x_advance, sizeof(pos[0]));
     /* The nil glyph_h_origin() func returns 0, so no need to apply it. */
     if (c->font->has_glyph_h_origin_func ())
       for (unsigned int i = 0; i < count; i++)
@@ -896,7 +896,7 @@ hb_ot_position_default (const hb_ot_shape_context_t *c)
   else
   {
     c->font->get_glyph_v_advances (count, &info[0].codepoint, sizeof(info[0]),
-                                   &pos[0].y_advance, sizeof(pos[0]));
+				   &pos[0].y_advance, sizeof(pos[0]));
     for (unsigned int i = 0; i < count; i++)
     {
       c->font->subtract_glyph_v_origin (info[i].codepoint,
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-stat-table.hh b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-stat-table.hh
index 98bdfa32469..2cdd3a488b3 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-stat-table.hh
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-stat-table.hh
@@ -77,7 +77,7 @@ struct AxisValueFormat1
   NameID	valueNameID;	/* The name ID for entries in the 'name' table
 				 * that provide a display string for this
 				 * attribute value. */
-  Fixed		value;		/* A numeric value for this attribute value. */
+  HBFixed		value;		/* A numeric value for this attribute value. */
   public:
   DEFINE_SIZE_STATIC (12);
 };
@@ -102,10 +102,10 @@ struct AxisValueFormat2
   NameID	valueNameID;	/* The name ID for entries in the 'name' table
 				 * that provide a display string for this
 				 * attribute value. */
-  Fixed		nominalValue;	/* A numeric value for this attribute value. */
-  Fixed		rangeMinValue;	/* The minimum value for a range associated
+  HBFixed		nominalValue;	/* A numeric value for this attribute value. */
+  HBFixed		rangeMinValue;	/* The minimum value for a range associated
 				 * with the specified name ID. */
-  Fixed		rangeMaxValue;	/* The maximum value for a range associated
+  HBFixed		rangeMaxValue;	/* The maximum value for a range associated
 				 * with the specified name ID. */
   public:
   DEFINE_SIZE_STATIC (20);
@@ -131,8 +131,8 @@ struct AxisValueFormat3
   NameID	valueNameID;	/* The name ID for entries in the 'name' table
 				 * that provide a display string for this
 				 * attribute value. */
-  Fixed		value;		/* A numeric value for this attribute value. */
-  Fixed		linkedValue;	/* The numeric value for a style-linked mapping
+  HBFixed		value;		/* A numeric value for this attribute value. */
+  HBFixed		linkedValue;	/* The numeric value for a style-linked mapping
 				 * from this value. */
   public:
   DEFINE_SIZE_STATIC (16);
@@ -150,7 +150,7 @@ struct AxisValueRecord
   HBUINT16	axisIndex;	/* Zero-base index into the axis record array
 				 * identifying the axis to which this value
 				 * applies. Must be less than designAxisCount. */
-  Fixed		value;		/* A numeric value for this attribute value. */
+  HBFixed		value;		/* A numeric value for this attribute value. */
   public:
   DEFINE_SIZE_STATIC (6);
 };
@@ -304,8 +304,8 @@ struct STAT
 
 
   protected:
-  FixedVersion<>version;        /* Version of the stat table
-                                 * initially set to 0x00010002u */
+  FixedVersion<>version;	/* Version of the stat table
+				 * initially set to 0x00010002u */
   HBUINT16	designAxisSize;	/* The size in bytes of each axis record. */
   HBUINT16	designAxisCount;/* The number of design axis records. In a
 				 * font with an 'fvar' table, this value must be
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-var-avar-table.hh b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-var-avar-table.hh
index 45f702dbd9e..ef8ba3f5a21 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-var-avar-table.hh
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-var-avar-table.hh
@@ -120,7 +120,7 @@ struct avar
     for (unsigned int i = 0; i < count; i++)
     {
       if (unlikely (!map->sanitize (c)))
-        return_trace (false);
+	return_trace (false);
       map = &StructAfter<SegmentMaps> (*map);
     }
 
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-var-fvar-table.hh b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-var-fvar-table.hh
index f1d024560e5..7ce3123819d 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-var-fvar-table.hh
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-var-fvar-table.hh
@@ -44,7 +44,7 @@ struct InstanceRecord
 {
   friend struct fvar;
 
-  hb_array_t<const Fixed> get_coordinates (unsigned int axis_count) const
+  hb_array_t<const HBFixed> get_coordinates (unsigned int axis_count) const
   { return coordinatesZ.as_array (axis_count); }
 
   bool sanitize (hb_sanitize_context_t *c, unsigned int axis_count) const
@@ -58,7 +58,7 @@ struct InstanceRecord
   NameID	subfamilyNameID;/* The name ID for entries in the 'name' table
 				 * that provide subfamily names for this instance. */
   HBUINT16	flags;		/* Reserved for future use — set to 0. */
-  UnsizedArrayOf<Fixed>
+  UnsizedArrayOf<HBFixed>
 		coordinatesZ;	/* The coordinates array for this instance. */
   //NameID	postScriptNameIDX;/*Optional. The name ID for entries in the 'name'
   //				  * table that provide PostScript names for this
@@ -83,9 +83,9 @@ struct AxisRecord
 
   public:
   Tag		axisTag;	/* Tag identifying the design variation for the axis. */
-  Fixed		minValue;	/* The minimum coordinate value for the axis. */
-  Fixed		defaultValue;	/* The default coordinate value for the axis. */
-  Fixed		maxValue;	/* The maximum coordinate value for the axis. */
+  HBFixed		minValue;	/* The minimum coordinate value for the axis. */
+  HBFixed		defaultValue;	/* The default coordinate value for the axis. */
+  HBFixed		maxValue;	/* The maximum coordinate value for the axis. */
   HBUINT16	flags;		/* Axis flags. */
   NameID	axisNameID;	/* The name ID for entries in the 'name' table that
 				 * provide a display name for this axis. */
@@ -199,7 +199,7 @@ struct fvar
     for (unsigned int i = 0; i < count; i++)
       if (axes[i].axisTag == tag)
       {
-        if (axis_index)
+	if (axis_index)
 	  *axis_index = i;
 	get_axis_deprecated (i, info);
 	return true;
@@ -280,16 +280,16 @@ struct fvar
     if (unlikely (!instance))
     {
       if (coords_length)
-        *coords_length = 0;
+	*coords_length = 0;
       return 0;
     }
 
     if (coords_length && *coords_length)
     {
-      hb_array_t<const Fixed> instanceCoords = instance->get_coordinates (axisCount)
+      hb_array_t<const HBFixed> instanceCoords = instance->get_coordinates (axisCount)
 							 .sub_array (0, *coords_length);
       for (unsigned int i = 0; i < instanceCoords.length; i++)
-        coords[i] = instanceCoords.arrayZ[i].to_float ();
+	coords[i] = instanceCoords.arrayZ[i].to_float ();
     }
     return axisCount;
   }
@@ -340,8 +340,8 @@ struct fvar
   HBUINT16	instanceCount;	/* The number of named instances defined in the font
 				 * (the number of records in the instances array). */
   HBUINT16	instanceSize;	/* The size in bytes of each InstanceRecord — set
-				 * to either axisCount * sizeof(Fixed) + 4, or to
-				 * axisCount * sizeof(Fixed) + 6. */
+				 * to either axisCount * sizeof(HBFixed) + 4, or to
+				 * axisCount * sizeof(HBFixed) + 6. */
 
   public:
   DEFINE_SIZE_STATIC (16);
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-vorg-table.hh b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-vorg-table.hh
index d9002f3d690..a4d6b0622b3 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-vorg-table.hh
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-vorg-table.hh
@@ -48,7 +48,7 @@ struct VertOriginMetric
   }
 
   public:
-  GlyphID	glyph;
+  HBGlyphID	glyph;
   FWORD		vertOriginY;
 
   public:
@@ -70,10 +70,10 @@ struct VORG
   }
 
   template <typename Iterator,
-            hb_requires (hb_is_iterator (Iterator))>
+	    hb_requires (hb_is_iterator (Iterator))>
   void serialize (hb_serialize_context_t *c,
-                  Iterator it,
-                  FWORD defaultVertOriginY)
+		  Iterator it,
+		  FWORD defaultVertOriginY)
   {
 
     if (unlikely (!c->extend_min ((*this))))  return;
@@ -84,9 +84,7 @@ struct VORG
     this->defaultVertOriginY = defaultVertOriginY;
     this->vertYOrigins.len = it.len ();
 
-    + it
-    | hb_apply ([c] (const VertOriginMetric& _) { c->copy (_); })
-    ;
+    for (const auto _ : it) c->copy (_);
   }
 
   bool subset (hb_subset_context_t *c) const
@@ -99,15 +97,15 @@ struct VORG
     + vertYOrigins.as_array ()
     | hb_filter (c->plan->glyphset (), &VertOriginMetric::glyph)
     | hb_map ([&] (const VertOriginMetric& _)
-              {
-                hb_codepoint_t new_glyph = HB_SET_VALUE_INVALID;
-                c->plan->new_gid_for_old_gid (_.glyph, &new_glyph);
-
-                VertOriginMetric metric;
-                metric.glyph = new_glyph;
-                metric.vertOriginY = _.vertOriginY;
-                return metric;
-              })
+	      {
+		hb_codepoint_t new_glyph = HB_SET_VALUE_INVALID;
+		c->plan->new_gid_for_old_gid (_.glyph, &new_glyph);
+
+		VertOriginMetric metric;
+		metric.glyph = new_glyph;
+		metric.vertOriginY = _.vertOriginY;
+		return metric;
+	      })
     ;
 
     /* serialize the new table */
@@ -119,8 +117,8 @@ struct VORG
   {
     TRACE_SANITIZE (this);
     return_trace (c->check_struct (this) &&
-                  version.major == 1 &&
-                  vertYOrigins.sanitize (c));
+		  version.major == 1 &&
+		  vertYOrigins.sanitize (c));
   }
 
   protected:
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-pool.hh b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-pool.hh
index 2dd84968e01..83875dbe13d 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-pool.hh
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-pool.hh
@@ -84,7 +84,7 @@ struct hb_pool_t
     T* thread ()
     {
       for (unsigned i = 0; i < ARRAY_LENGTH (arrayZ) - 1; i++)
-        * (T**) &arrayZ[i] = &arrayZ[i + 1];
+	* (T**) &arrayZ[i] = &arrayZ[i + 1];
 
       * (T**) &arrayZ[ARRAY_LENGTH (arrayZ) - 1] = nullptr;
 
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-sanitize.hh b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-sanitize.hh
index 5f5b4bdc988..7859c6a2c6b 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-sanitize.hh
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-sanitize.hh
@@ -326,8 +326,8 @@ struct hb_sanitize_context_t :
       {
 	DEBUG_MSG_FUNC (SANITIZE, start, "passed first round with %d edits; going for second round", edit_count);
 
-        /* sanitize again to ensure no toe-stepping */
-        edit_count = 0;
+	/* sanitize again to ensure no toe-stepping */
+	edit_count = 0;
 	sane = t->sanitize (this);
 	if (edit_count) {
 	  DEBUG_MSG_FUNC (SANITIZE, start, "requested %d edits in second round; FAILLING", edit_count);
@@ -338,7 +338,7 @@ struct hb_sanitize_context_t :
     else
     {
       if (edit_count && !writable) {
-        start = hb_blob_get_data_writable (blob, nullptr);
+	start = hb_blob_get_data_writable (blob, nullptr);
 	end = start + blob->length;
 
 	if (start)
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-serialize.hh b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-serialize.hh
index 5764a90f6eb..4c674b1b1a4 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-serialize.hh
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-serialize.hh
@@ -91,9 +91,7 @@ struct hb_serialize_context_t
 
   void fini ()
   {
-    ++ hb_iter (packed)
-    | hb_apply ([] (object_t *_) { _->fini (); })
-    ;
+    for (object_t *_ : ++hb_iter (packed)) _->fini ();
     packed.fini ();
     this->packed_map.fini ();
 
@@ -194,6 +192,7 @@ struct hb_serialize_context_t
     if (unlikely (!obj)) return;
     current = current->next;
     revert (*obj);
+    obj->fini ();
     object_pool.free (obj);
   }
   objidx_t pop_pack ()
@@ -291,7 +290,6 @@ struct hb_serialize_context_t
     assert (packed.length > 1);
 
     for (const object_t* parent : ++hb_iter (packed))
-    {
       for (const object_t::link_t &link : parent->links)
       {
 	const object_t* child = packed[link.objidx];
@@ -311,7 +309,6 @@ struct hb_serialize_context_t
 	  check_assign (off, offset);
 	}
       }
-    }
   }
 
   unsigned int length () const { return this->head - current->head; }
@@ -353,9 +350,7 @@ struct hb_serialize_context_t
 
   template <typename Type>
   Type *allocate_min ()
-  {
-    return this->allocate_size<Type> (Type::min_size);
-  }
+  { return this->allocate_size<Type> (Type::min_size); }
 
   template <typename Type>
   Type *embed (const Type *obj)
@@ -427,14 +422,12 @@ struct hb_serialize_context_t
     /* Copy both items from head side and tail side... */
     unsigned int len = (this->head - this->start)
 		     + (this->end  - this->tail);
+
     char *p = (char *) malloc (len);
-    if (p)
-    {
-      memcpy (p, this->start, this->head - this->start);
-      memcpy (p + (this->head - this->start), this->tail, this->end - this->tail);
-    }
-    else
-      return hb_bytes_t ();
+    if (unlikely (!p)) return hb_bytes_t ();
+
+    memcpy (p, this->start, this->head - this->start);
+    memcpy (p + (this->head - this->start), this->tail, this->end - this->tail);
     return hb_bytes_t (p, len);
   }
   template <typename Type>
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-set.hh b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-set.hh
index ad449d0ce7a..36d11c0319f 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-set.hh
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-set.hh
@@ -63,7 +63,7 @@ struct hb_set_t
     bool is_empty () const
     {
       for (unsigned int i = 0; i < len (); i++)
-        if (v[i])
+	if (v[i])
 	  return false;
       return true;
     }
@@ -77,7 +77,7 @@ struct hb_set_t
       elt_t *la = &elt (a);
       elt_t *lb = &elt (b);
       if (la == lb)
-        *la |= (mask (b) << 1) - mask(a);
+	*la |= (mask (b) << 1) - mask(a);
       else
       {
 	*la |= ~(mask (a) - 1);
@@ -98,7 +98,7 @@ struct hb_set_t
     {
       unsigned int pop = 0;
       for (unsigned int i = 0; i < len (); i++)
-        pop += hb_popcount (v[i]);
+	pop += hb_popcount (v[i]);
       return pop;
     }
 
@@ -136,12 +136,17 @@ struct hb_set_t
       unsigned int j = m & ELT_MASK;
 
       const elt_t vv = v[i] & ((elt_t (1) << (j + 1)) - 1);
-      for (const elt_t *p = &vv; (int) i >= 0; p = &v[--i])
+      const elt_t *p = &vv;
+      while (true)
+      {
 	if (*p)
 	{
 	  *codepoint = i * ELT_BITS + elt_get_max (*p);
 	  return true;
 	}
+	if ((int) i <= 0) break;
+	p = &v[--i];
+      }
 
       *codepoint = INVALID;
       return false;
@@ -149,14 +154,14 @@ struct hb_set_t
     hb_codepoint_t get_min () const
     {
       for (unsigned int i = 0; i < len (); i++)
-        if (v[i])
+	if (v[i])
 	  return i * ELT_BITS + elt_get_min (v[i]);
       return INVALID;
     }
     hb_codepoint_t get_max () const
     {
       for (int i = len () - 1; i >= 0; i--)
-        if (v[i])
+	if (v[i])
 	  return i * ELT_BITS + elt_get_max (v[i]);
       return 0;
     }
@@ -249,7 +254,7 @@ struct hb_set_t
     unsigned int count = pages.length;
     for (unsigned int i = 0; i < count; i++)
       if (!pages[i].is_empty ())
-        return false;
+	return false;
     return true;
   }
 
@@ -333,9 +338,9 @@ struct hb_set_t
       unsigned int end = major_start (m + 1);
       do
       {
-        /* If we try harder we can change the following comparison to <=;
+	/* If we try harder we can change the following comparison to <=;
 	 * Not sure if it's worth it. */
-        if (g < last_g) return false;
+	if (g < last_g) return false;
 	last_g = g;
 	page->add (g);
 
@@ -415,7 +420,7 @@ struct hb_set_t
       if (other->page_at (b).is_empty ()) { b++; continue; }
       if (page_map[a].major != other->page_map[b].major ||
 	  !page_at (a).is_equal (&other->page_at (b)))
-        return false;
+	return false;
       a++;
       b++;
     }
@@ -436,7 +441,7 @@ struct hb_set_t
     hb_codepoint_t c = INVALID;
     while (next (&c))
       if (!larger_set->has (c))
-        return false;
+	return false;
 
     return true;
   }
@@ -458,21 +463,21 @@ struct hb_set_t
     {
       if (page_map[a].major == other->page_map[b].major)
       {
-        count++;
+	count++;
 	a++;
 	b++;
       }
       else if (page_map[a].major < other->page_map[b].major)
       {
-        if (Op::passthru_left)
+	if (Op::passthru_left)
 	  count++;
-        a++;
+	a++;
       }
       else
       {
-        if (Op::passthru_right)
+	if (Op::passthru_right)
 	  count++;
-        b++;
+	b++;
       }
     }
     if (Op::passthru_left)
@@ -482,7 +487,7 @@ struct hb_set_t
 
     if (count > pages.length)
       if (!resize (count))
-        return;
+	return;
     newCount = count;
 
     /* Process in-place backward. */
@@ -673,7 +678,7 @@ struct hb_set_t
     unsigned int count = pages.length;
     for (unsigned int i = 0; i < count; i++)
       if (!page_at (i).is_empty ())
-        return page_map[i].major * page_t::PAGE_BITS + page_at (i).get_min ();
+	return page_map[i].major * page_t::PAGE_BITS + page_at (i).get_min ();
     return INVALID;
   }
   hb_codepoint_t get_max () const
@@ -681,7 +686,7 @@ struct hb_set_t
     unsigned int count = pages.length;
     for (int i = count - 1; i >= 0; i++)
       if (!page_at (i).is_empty ())
-        return page_map[(unsigned) i].major * page_t::PAGE_BITS + page_at (i).get_max ();
+	return page_map[(unsigned) i].major * page_t::PAGE_BITS + page_at (i).get_max ();
     return INVALID;
   }
 
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-shape-plan.cc b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-shape-plan.cc
index 2b23dee62ca..ffd723d0836 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-shape-plan.cc
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-shape-plan.cc
@@ -164,13 +164,13 @@ hb_shape_plan_key_t::equal (const hb_shape_plan_key_t *other)
 
 /**
  * hb_shape_plan_create: (Xconstructor)
- * @face: 
- * @props: 
+ * @face:
+ * @props:
  * @user_features: (array length=num_user_features):
- * @num_user_features: 
+ * @num_user_features:
  * @shaper_list: (array zero-terminated=1):
  *
- * 
+ *
  *
  * Return value: (transfer full):
  *
@@ -248,7 +248,7 @@ bail:
 /**
  * hb_shape_plan_get_empty:
  *
- * 
+ *
  *
  * Return value: (transfer full):
  *
@@ -264,7 +264,7 @@ hb_shape_plan_get_empty ()
  * hb_shape_plan_reference: (skip)
  * @shape_plan: a shape plan.
  *
- * 
+ *
  *
  * Return value: (transfer full):
  *
@@ -280,7 +280,7 @@ hb_shape_plan_reference (hb_shape_plan_t *shape_plan)
  * hb_shape_plan_destroy: (skip)
  * @shape_plan: a shape plan.
  *
- * 
+ *
  *
  * Since: 0.9.7
  **/
@@ -299,14 +299,14 @@ hb_shape_plan_destroy (hb_shape_plan_t *shape_plan)
 /**
  * hb_shape_plan_set_user_data: (skip)
  * @shape_plan: a shape plan.
- * @key: 
- * @data: 
- * @destroy: 
- * @replace: 
+ * @key:
+ * @data:
+ * @destroy:
+ * @replace:
+ *
  *
- * 
  *
- * Return value: 
+ * Return value:
  *
  * Since: 0.9.7
  **/
@@ -323,9 +323,9 @@ hb_shape_plan_set_user_data (hb_shape_plan_t    *shape_plan,
 /**
  * hb_shape_plan_get_user_data: (skip)
  * @shape_plan: a shape plan.
- * @key: 
+ * @key:
+ *
  *
- * 
  *
  * Return value: (transfer none):
  *
@@ -342,7 +342,7 @@ hb_shape_plan_get_user_data (hb_shape_plan_t    *shape_plan,
  * hb_shape_plan_get_shaper:
  * @shape_plan: a shape plan.
  *
- * 
+ *
  *
  * Return value: (transfer none):
  *
@@ -361,11 +361,11 @@ hb_shape_plan_get_shaper (hb_shape_plan_t *shape_plan)
  * @font: a font.
  * @buffer: a buffer.
  * @features: (array length=num_features):
- * @num_features: 
+ * @num_features:
  *
- * 
  *
- * Return value: 
+ *
+ * Return value:
  *
  * Since: 0.9.7
  **/
@@ -420,13 +420,13 @@ hb_shape_plan_execute (hb_shape_plan_t    *shape_plan,
 
 /**
  * hb_shape_plan_create_cached:
- * @face: 
- * @props: 
+ * @face:
+ * @props:
  * @user_features: (array length=num_user_features):
- * @num_user_features: 
+ * @num_user_features:
  * @shaper_list: (array zero-terminated=1):
  *
- * 
+ *
  *
  * Return value: (transfer full):
  *
@@ -481,8 +481,8 @@ retry:
     for (hb_face_t::plan_node_t *node = cached_plan_nodes; node; node = node->next)
       if (node->shape_plan->key.equal (&key))
       {
-        DEBUG_MSG_FUNC (SHAPE_PLAN, node->shape_plan, "fulfilled from cache");
-        return hb_shape_plan_reference (node->shape_plan);
+	DEBUG_MSG_FUNC (SHAPE_PLAN, node->shape_plan, "fulfilled from cache");
+	return hb_shape_plan_reference (node->shape_plan);
       }
   }
 
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-string-array.hh b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-string-array.hh
index c4cf666d721..1c67ab4d7c5 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-string-array.hh
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-string-array.hh
@@ -48,7 +48,7 @@ static const union HB_STRING_ARRAY_TYPE_NAME {
 #include HB_STRING_ARRAY_LIST
 #undef _S
   } st;
-  char str[VAR];
+  char str[HB_VAR_ARRAY];
 }
 HB_STRING_ARRAY_POOL_NAME =
 {
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-subset-cff2.cc b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-subset-cff2.cc
index e89ca695114..9bdd0ee7d6e 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-subset-cff2.cc
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-subset-cff2.cc
@@ -330,15 +330,15 @@ struct cff2_subset_plan {
       {
 	subset_localsubrs[fd].init ();
 	offsets.localSubrsInfos[fd].init ();
-        if (!subr_subsetter.encode_localsubrs (fd, subset_localsubrs[fd]))
-          return false;
-
-        unsigned int dataSize = subset_localsubrs[fd].total_size ();
-        if (dataSize > 0)
-        {
-          offsets.localSubrsInfos[fd].offset = final_size;
-          offsets.localSubrsInfos[fd].offSize = calcOffSize (dataSize);
-          offsets.localSubrsInfos[fd].size = CFF2Subrs::calculate_serialized_size (offsets.localSubrsInfos[fd].offSize, subset_localsubrs[fd].length, dataSize);
+	if (!subr_subsetter.encode_localsubrs (fd, subset_localsubrs[fd]))
+	  return false;
+
+	unsigned int dataSize = subset_localsubrs[fd].total_size ();
+	if (dataSize > 0)
+	{
+	  offsets.localSubrsInfos[fd].offset = final_size;
+	  offsets.localSubrsInfos[fd].offSize = calcOffSize (dataSize);
+	  offsets.localSubrsInfos[fd].size = CFF2Subrs::calculate_serialized_size (offsets.localSubrsInfos[fd].offSize, subset_localsubrs[fd].length, dataSize);
 	}
       }
     }
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-subset-input.cc b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-subset-input.cc
index 34f1cb86394..d92f33ffed0 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-subset-input.cc
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-subset-input.cc
@@ -172,7 +172,7 @@ hb_subset_input_get_drop_hints (hb_subset_input_t *subset_input)
 
 HB_EXTERN void
 hb_subset_input_set_desubroutinize (hb_subset_input_t *subset_input,
-        hb_bool_t desubroutinize)
+				    hb_bool_t desubroutinize)
 {
   subset_input->desubroutinize = desubroutinize;
 }
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-subset-plan.cc b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-subset-plan.cc
index e244da19994..65591136834 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-subset-plan.cc
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-subset-plan.cc
@@ -39,7 +39,7 @@ _add_gid_and_children (const OT::glyf::accelerator_t &glyf,
 		       hb_codepoint_t gid,
 		       hb_set_t *gids_to_retain)
 {
-  if (hb_set_has (gids_to_retain, gid))
+  if (gids_to_retain->has (gid))
     // Already visited this gid, ignore.
     return;
 
@@ -58,8 +58,8 @@ _add_gid_and_children (const OT::glyf::accelerator_t &glyf,
 #ifndef HB_NO_SUBSET_CFF
 static inline void
 _add_cff_seac_components (const OT::cff1::accelerator_t &cff,
-           hb_codepoint_t gid,
-           hb_set_t *gids_to_retain)
+	   hb_codepoint_t gid,
+	   hb_set_t *gids_to_retain)
 {
   hb_codepoint_t base_gid, accent_gid;
   if (cff.get_seac_components (gid, &base_gid, &accent_gid))
@@ -88,6 +88,14 @@ _gsub_closure (hb_face_t *face, hb_set_t *gids_to_retain)
 #endif
 
 static inline void
+_cmap_closure (hb_face_t           *face,
+	       const hb_set_t      *unicodes,
+	       hb_set_t            *glyphset)
+{
+  face->table.cmap->table->closure_glyphs (unicodes, glyphset);
+}
+
+static inline void
 _remove_invalid_gids (hb_set_t *glyphs,
 		      unsigned int num_glyphs)
 {
@@ -102,7 +110,7 @@ _remove_invalid_gids (hb_set_t *glyphs,
 static void
 _populate_gids_to_retain (hb_subset_plan_t* plan,
 			  const hb_set_t *unicodes,
-                          const hb_set_t *input_glyphs_to_retain,
+			  const hb_set_t *input_glyphs_to_retain,
 			  bool close_over_gsub)
 {
   OT::cmap::accelerator_t cmap;
@@ -129,6 +137,8 @@ _populate_gids_to_retain (hb_subset_plan_t* plan,
     plan->_glyphset_gsub->add (gid);
   }
 
+  _cmap_closure (plan->source, plan->unicodes, plan->_glyphset_gsub);
+
 #ifndef HB_NO_SUBSET_LAYOUT
   if (close_over_gsub)
     // Add all glyphs needed for GSUB substitutions.
@@ -157,11 +167,11 @@ _populate_gids_to_retain (hb_subset_plan_t* plan,
 
 static void
 _create_old_gid_to_new_gid_map (const hb_face_t *face,
-                                bool             retain_gids,
+				bool             retain_gids,
 				const hb_set_t  *all_gids_to_retain,
-                                hb_map_t        *glyph_map, /* OUT */
-                                hb_map_t        *reverse_glyph_map, /* OUT */
-                                unsigned int    *num_glyphs /* OUT */)
+				hb_map_t        *glyph_map, /* OUT */
+				hb_map_t        *reverse_glyph_map, /* OUT */
+				unsigned int    *num_glyphs /* OUT */)
 {
   if (!retain_gids)
   {
@@ -191,8 +201,8 @@ _create_old_gid_to_new_gid_map (const hb_face_t *face,
 }
 
 static void
-_nameid_closure (hb_face_t           *face,
-                 hb_set_t            *nameids)
+_nameid_closure (hb_face_t *face,
+		 hb_set_t  *nameids)
 {
 #ifndef HB_NO_STAT
   face->table.STAT->collect_name_ids (nameids);
@@ -213,8 +223,8 @@ _nameid_closure (hb_face_t           *face,
  * Since: 1.7.5
  **/
 hb_subset_plan_t *
-hb_subset_plan_create (hb_face_t           *face,
-		       hb_subset_input_t   *input)
+hb_subset_plan_create (hb_face_t         *face,
+		       hb_subset_input_t *input)
 {
   hb_subset_plan_t *plan = hb_object_create<hb_subset_plan_t> ();
 
@@ -235,16 +245,16 @@ hb_subset_plan_create (hb_face_t           *face,
   plan->reverse_glyph_map = hb_map_create ();
 
   _populate_gids_to_retain (plan,
-                            input->unicodes,
-                            input->glyphs,
-                            !input->drop_tables->has (HB_OT_TAG_GSUB));
+			    input->unicodes,
+			    input->glyphs,
+			    !input->drop_tables->has (HB_OT_TAG_GSUB));
 
   _create_old_gid_to_new_gid_map (face,
-                                  input->retain_gids,
+				  input->retain_gids,
 				  plan->_glyphset,
 				  plan->glyph_map,
-                                  plan->reverse_glyph_map,
-                                  &plan->_num_output_glyphs);
+				  plan->reverse_glyph_map,
+				  &plan->_num_output_glyphs);
 
   return plan;
 }
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-subset-plan.hh b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-subset-plan.hh
index ee44b63a467..af2337e4948 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-subset-plan.hh
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-subset-plan.hh
@@ -108,7 +108,7 @@ struct hb_subset_plan_t
   }
 
   inline bool new_gid_for_codepoint (hb_codepoint_t codepoint,
-                                     hb_codepoint_t *new_gid) const
+				     hb_codepoint_t *new_gid) const
   {
     hb_codepoint_t old_gid = codepoint_to_glyph->get (codepoint);
     if (old_gid == HB_MAP_VALUE_INVALID)
@@ -118,7 +118,7 @@ struct hb_subset_plan_t
   }
 
   inline bool new_gid_for_old_gid (hb_codepoint_t old_gid,
-                                   hb_codepoint_t *new_gid) const
+				   hb_codepoint_t *new_gid) const
   {
     hb_codepoint_t gid = glyph_map->get (old_gid);
     if (gid == HB_MAP_VALUE_INVALID)
@@ -129,7 +129,7 @@ struct hb_subset_plan_t
   }
 
   inline bool old_gid_for_new_gid (hb_codepoint_t  new_gid,
-                                   hb_codepoint_t *old_gid) const
+				   hb_codepoint_t *old_gid) const
   {
     hb_codepoint_t gid = reverse_glyph_map->get (new_gid);
     if (gid == HB_MAP_VALUE_INVALID)
@@ -157,7 +157,7 @@ typedef struct hb_subset_plan_t hb_subset_plan_t;
 
 HB_INTERNAL hb_subset_plan_t *
 hb_subset_plan_create (hb_face_t           *face,
-                       hb_subset_input_t   *input);
+		       hb_subset_input_t   *input);
 
 HB_INTERNAL void
 hb_subset_plan_destroy (hb_subset_plan_t *plan);
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-subset.cc b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-subset.cc
index 6235a5bf531..ec2f8892fde 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-subset.cc
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-subset.cc
@@ -82,6 +82,7 @@ _subset2 (hb_subset_plan_t *plan)
     if (unlikely (!buf.alloc (buf_size)))
     {
       DEBUG_MSG(SUBSET, nullptr, "OT::%c%c%c%c failed to allocate %u bytes.", HB_UNTAG (tag), buf_size);
+      hb_blob_destroy (source_blob);
       return false;
     }
   retry:
@@ -96,6 +97,7 @@ _subset2 (hb_subset_plan_t *plan)
       if (unlikely (!buf.alloc (buf_size)))
       {
 	DEBUG_MSG(SUBSET, nullptr, "OT::%c%c%c%c failed to reallocate %u bytes.", HB_UNTAG (tag), buf_size);
+	hb_blob_destroy (source_blob);
 	return false;
       }
       goto retry;
@@ -283,17 +285,19 @@ hb_subset (hb_face_t *source,
   hb_tag_t table_tags[32];
   unsigned int offset = 0, count;
   bool success = true;
+  hb_set_t tags_set;
   do {
     count = ARRAY_LENGTH (table_tags);
     hb_face_get_table_tags (source, offset, &count, table_tags);
     for (unsigned int i = 0; i < count; i++)
     {
       hb_tag_t tag = table_tags[i];
-      if (_should_drop_table (plan, tag))
+      if (_should_drop_table (plan, tag) && !tags_set.has (tag))
       {
 	DEBUG_MSG(SUBSET, nullptr, "drop %c%c%c%c", HB_UNTAG (tag));
 	continue;
       }
+      tags_set.add (tag);
       success = success && _subset_table (plan, tag);
     }
     offset += count;
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-subset.h b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-subset.h
index c778896a202..960afefa5bd 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-subset.h
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-subset.h
@@ -68,7 +68,7 @@ hb_subset_input_get_drop_hints (hb_subset_input_t *subset_input);
 
 HB_EXTERN void
 hb_subset_input_set_desubroutinize (hb_subset_input_t *subset_input,
-        hb_bool_t desubroutinize);
+				    hb_bool_t desubroutinize);
 HB_EXTERN hb_bool_t
 hb_subset_input_get_desubroutinize (hb_subset_input_t *subset_input);
 
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-uniscribe.cc b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-uniscribe.cc
index 289a3477fe5..e93cf7f419a 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-uniscribe.cc
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-uniscribe.cc
@@ -385,8 +385,8 @@ _hb_rename_font (hb_blob_t *blob, wchar_t *new_name)
   static const uint16_t name_IDs[] = { 1, 2, 3, 4, 6 };
 
   unsigned int name_table_length = OT::name::min_size +
-                                   ARRAY_LENGTH (name_IDs) * OT::NameRecord::static_size +
-                                   name_str_len * 2; /* for name data in UTF16BE form */
+				   ARRAY_LENGTH (name_IDs) * OT::NameRecord::static_size +
+				   name_str_len * 2; /* for name data in UTF16BE form */
   unsigned int padded_name_table_length = ((name_table_length + 3) & ~3);
   unsigned int name_table_offset = (length + 3) & ~3;
 
@@ -666,7 +666,7 @@ _hb_uniscribe_shape (hb_shape_plan_t    *shape_plan,
 
       if (event->index != last_index)
       {
-        /* Save a snapshot of active features and the range. */
+	/* Save a snapshot of active features and the range. */
 	range_record_t *range = range_records.push ();
 
 	unsigned int offset = feature_records.length;
@@ -701,7 +701,7 @@ _hb_uniscribe_shape (hb_shape_plan_t    *shape_plan,
       }
       else
       {
-        active_feature_t *feature = active_features.find (&event->feature);
+	active_feature_t *feature = active_features.find (&event->feature);
 	if (feature)
 	  active_features.remove (feature - active_features.arrayZ);
       }
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-utf.hh b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-utf.hh
index 59ec75ebc1e..ff5712d16dd 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-utf.hh
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-utf.hh
@@ -235,10 +235,10 @@ struct hb_utf16_xe_t
       hb_codepoint_t h = text[-1];
       if (likely (hb_in_range<hb_codepoint_t> (h, 0xD800u, 0xDBFFu)))
       {
-        /* High-surrogate in h */
-        *unicode = (h << 10) + c - ((0xD800u << 10) - 0x10000u + 0xDC00u);
-        text--;
-        return text;
+	/* High-surrogate in h */
+	*unicode = (h << 10) + c - ((0xD800u << 10) - 0x10000u + 0xDC00u);
+	text--;
+	return text;
       }
     }
 
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-vector.hh b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-vector.hh
index 035c6d0a862..288a5416dec 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-vector.hh
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-vector.hh
@@ -290,7 +290,7 @@ struct hb_sorted_vector_t : hb_vector_t<Type>
   typedef hb_sorted_array_t<      Type>       iter_t;
   const_iter_t  iter () const { return as_array (); }
   const_iter_t citer () const { return as_array (); }
-        iter_t  iter ()       { return as_array (); }
+	iter_t  iter ()       { return as_array (); }
   operator       iter_t ()       { return iter (); }
   operator const_iter_t () const { return iter (); }
 
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb.hh b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb.hh
index 8dcd5aa88f3..f3165121762 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb.hh
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb.hh
@@ -180,7 +180,6 @@
 #include <stddef.h>
 #include <string.h>
 #include <assert.h>
-#include <errno.h>
 #include <stdio.h>
 #include <stdarg.h>
 
@@ -242,7 +241,7 @@ extern "C" void  hb_free_impl(void *ptr);
 #define HB_CONST_FUNC
 #define HB_PRINTF_FUNC(format_idx, arg_idx)
 #endif
-#if defined(__GNUC__) && (__GNUC__ >= 4)
+#if defined(__GNUC__) && (__GNUC__ >= 4) || (__clang__)
 #define HB_UNUSED	__attribute__((unused))
 #elif defined(_MSC_VER) /* https://github.com/harfbuzz/harfbuzz/issues/635 */
 #define HB_UNUSED __pragma(warning(suppress: 4100 4101))
@@ -355,7 +354,7 @@ extern "C" void  hb_free_impl(void *ptr);
 #    endif
 #    if _WIN32_WCE < 0x800
 #      define HB_NO_SETLOCALE
-static int errno = 0; /* Use something better? */
+#      define HB_NO_ERRNO
 #    endif
 #  elif defined(WINAPI_FAMILY) && (WINAPI_FAMILY==WINAPI_FAMILY_PC_APP || WINAPI_FAMILY==WINAPI_FAMILY_PHONE_APP)
 #    ifndef HB_NO_GETENV
@@ -371,6 +370,12 @@ static int errno = 0; /* Use something better? */
 #define getenv(Name) nullptr
 #endif
 
+#ifdef HB_NO_ERRNO
+static int errno = 0; /* Use something better? */
+#else
+#include <errno.h>
+#endif
+
 #if defined(HAVE_ATEXIT) && !defined(HB_USE_ATEXIT)
 /* atexit() is only safe to be called from shared libraries on certain
  * platforms.  Whitelist.
@@ -475,7 +480,18 @@ static_assert ((sizeof (hb_var_int_t) == 4), "");
 
 
 /* Size signifying variable-sized array */
-#define VAR 1
+#ifndef HB_VAR_ARRAY
+#define HB_VAR_ARRAY 1
+#endif
+
+static inline double
+_hb_roundf (float x)
+{
+  return x >= 0 ? floor ((double) x + .5) : ceil ((double) x - .5);
+}
+#ifndef HAVE_ROUNDF
+#define roundf(x) _hb_roundf(x)
+#endif
 
 /* Endian swap, used in Windows related backends */
 static inline uint16_t hb_uint16_swap (const uint16_t v)
@@ -526,7 +542,7 @@ struct BEInt<Type, 2>
 #endif
 #endif
     return (v[0] <<  8)
-         + (v[1]      );
+	 + (v[1]      );
   }
   private: uint8_t v[2];
 };
@@ -544,8 +560,8 @@ struct BEInt<Type, 3>
   operator Type () const
   {
     return (v[0] << 16)
-         + (v[1] <<  8)
-         + (v[2]      );
+	 + (v[1] <<  8)
+	 + (v[2]      );
   }
   private: uint8_t v[3];
 };
@@ -564,9 +580,9 @@ struct BEInt<Type, 4>
   operator Type () const
   {
     return (v[0] << 24)
-         + (v[1] << 16)
-         + (v[2] <<  8)
-         + (v[3]      );
+	 + (v[1] << 16)
+	 + (v[2] <<  8)
+	 + (v[3]      );
   }
   private: uint8_t v[4];
 };
@@ -585,9 +601,10 @@ struct BEInt<Type, 4>
  * them directly.*/
 #include "hb-meta.hh"
 #include "hb-mutex.hh"
+#include "hb-number.hh"
 #include "hb-atomic.hh"	// Requires: hb-meta
 #include "hb-null.hh"	// Requires: hb-meta
-#include "hb-algs.hh"	// Requires: hb-meta hb-null
+#include "hb-algs.hh"	// Requires: hb-meta hb-null hb-number
 #include "hb-iter.hh"	// Requires: hb-algs hb-meta
 #include "hb-debug.hh"	// Requires: hb-algs hb-atomic
 #include "hb-array.hh"	// Requires: hb-algs hb-iter hb-null
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/test-algs.cc b/Build/source/libs/harfbuzz/harfbuzz-src/src/test-algs.cc
index 333a892429d..f8b8ff66682 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/test-algs.cc
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/test-algs.cc
@@ -87,5 +87,9 @@ main (int argc, char **argv)
   assert (hb_add (2) (5) == 7);
   assert (hb_add (5) (2) == 7);
 
+  x = 1;
+  assert (++hb_inc (x) == 3);
+  assert (x == 3);
+
   return 0;
 }
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/test-iter.cc b/Build/source/libs/harfbuzz/harfbuzz-src/src/test-iter.cc
index 156a5fcadda..b5a4c8695aa 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/test-iter.cc
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/test-iter.cc
@@ -267,7 +267,12 @@ main (int argc, char **argv)
   hb_iota ();
   hb_iota (3);
   hb_iota (3, 2);
+  assert ((&vl) + 1 == *++hb_iota (&vl, hb_inc));
   hb_range ();
+  hb_repeat (7u);
+  hb_repeat (nullptr);
+  hb_repeat (vl) | hb_chop (3);
+  assert (hb_len (hb_range (10) | hb_take (3)) == 3);
   assert (hb_range (9).len () == 9);
   assert (hb_range (2, 9).len () == 7);
   assert (hb_range (2, 9, 3).len () == 3);
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/test-number.cc b/Build/source/libs/harfbuzz/harfbuzz-src/src/test-number.cc
new file mode 100644
index 00000000000..3591b13f278
--- /dev/null
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/test-number.cc
@@ -0,0 +1,253 @@
+/*
+ * Copyright © 2019  Ebrahim Byagowi
+ *
+ *  This is part of HarfBuzz, a text shaping library.
+ *
+ * Permission is hereby granted, without written agreement and without
+ * license or royalty fees, to use, copy, modify, and distribute this
+ * software and its documentation for any purpose, provided that the
+ * above copyright notice and the following two paragraphs appear in
+ * all copies of this software.
+ *
+ * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
+ * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
+ * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
+ * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ *
+ * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
+ * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
+ * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
+ * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
+ *
+ */
+
+#include "hb.hh"
+#include "hb-number.hh"
+#include "hb-number-parser.hh"
+
+
+int
+main (int argc, char **argv)
+{
+  {
+    const char str[] = "123";
+    const char *pp = str;
+    const char *end = str + 3;
+
+    int pv;
+    assert (hb_parse_int (&pp, end, &pv));
+    assert (pv == 123);
+    assert (pp - str == 3);
+    assert (end - pp == 0);
+    assert (!*end);
+  }
+
+  {
+    const char str[] = "123";
+    const char *pp = str;
+    const char *end = str + strlen (str);
+
+    unsigned int pv;
+    assert (hb_parse_uint (&pp, end, &pv));
+    assert (pv == 123);
+    assert (pp - str == 3);
+    assert (end - pp == 0);
+    assert (!*end);
+  }
+
+  {
+    const char str[] = "12F";
+    const char *pp = str;
+    const char *end = str + 3;
+
+    unsigned int pv;
+    assert (hb_parse_uint (&pp, end, &pv, true, 16));
+    assert (pv == 0x12F);
+    assert (pp - str == 3);
+    assert (end - pp == 0);
+    assert (!*end);
+  }
+
+  {
+    const char str[] = "12Fq";
+    const char *pp = str;
+    const char *end = str + 4;
+
+    unsigned int pv;
+    assert (!hb_parse_uint (&pp, end, &pv, true, 16));
+    assert (hb_parse_uint (&pp, end, &pv, false, 16));
+    assert (pv == 0x12F);
+    assert (pp - str == 3);
+    assert (end - pp == 1);
+    assert (!*end);
+  }
+
+  {
+    const char str[] = "-123";
+    const char *pp = str;
+    const char *end = str + 4;
+
+    int pv;
+    assert (hb_parse_int (&pp, end, &pv));
+    assert (pv == -123);
+    assert (pp - str == 4);
+    assert (end - pp == 0);
+    assert (!*end);
+  }
+
+  {
+    const char str[] = "123";
+    const char *pp = str;
+    assert (ARRAY_LENGTH (str) == 4);
+    const char *end = str + ARRAY_LENGTH (str);
+
+    unsigned int pv;
+    assert (hb_parse_uint (&pp, end, &pv));
+    assert (pv == 123);
+    assert (pp - str == 3);
+    assert (end - pp == 1);
+  }
+
+  {
+    const char str[] = "123\0";
+    const char *pp = str;
+    assert (ARRAY_LENGTH (str) == 5);
+    const char *end = str + ARRAY_LENGTH (str);
+
+    unsigned int pv;
+    assert (hb_parse_uint (&pp, end, &pv));
+    assert (pv == 123);
+    assert (pp - str == 3);
+    assert (end - pp == 2);
+  }
+
+  {
+    const char str[] = "123V";
+    const char *pp = str;
+    assert (ARRAY_LENGTH (str) == 5);
+    const char *end = str + ARRAY_LENGTH (str);
+
+    unsigned int pv;
+    assert (hb_parse_uint (&pp, end, &pv));
+    assert (pv == 123);
+    assert (pp - str == 3);
+    assert (end - pp == 2);
+  }
+
+  {
+    const char str[] = ".123";
+    const char *pp = str;
+    const char *end = str + ARRAY_LENGTH (str);
+
+    double pv;
+    assert (hb_parse_double (&pp, end, &pv));
+    assert ((int) roundf (pv * 1000.) == 123);
+    assert (pp - str == 4);
+    assert (end - pp == 1);
+
+    /* Test strtod_rl even if libc's strtod_l is used */
+    char *pend;
+    assert ((int) roundf (strtod_rl (str, &pend) * 1000.) == 123);
+    assert (pend - str == 4);
+  }
+
+  {
+    const char str[] = "0.123";
+    const char *pp = str;
+    const char *end = str + ARRAY_LENGTH (str) - 1;
+
+    double pv;
+    assert (hb_parse_double (&pp, end, &pv));
+    assert ((int) roundf (pv * 1000.) == 123);
+    assert (pp - str == 5);
+    assert (end - pp == 0);
+
+    char *pend;
+    assert ((int) roundf (strtod_rl (str, &pend) * 1000.) == 123);
+    assert (pend - str == 5);
+  }
+
+  {
+    const char str[] = "0.123e0";
+    const char *pp = str;
+    const char *end = str + ARRAY_LENGTH (str) - 1;
+
+    double pv;
+    assert (hb_parse_double (&pp, end, &pv));
+    assert ((int) roundf (pv * 1000.) == 123);
+    assert (pp - str == 7);
+    assert (end - pp == 0);
+
+    char *pend;
+    assert ((int) roundf (strtod_rl (str, &pend) * 1000.) == 123);
+    assert (pend - str == 7);
+  }
+
+  {
+    const char str[] = "123e-3";
+    const char *pp = str;
+    const char *end = str + ARRAY_LENGTH (str) - 1;
+
+    double pv;
+    assert (hb_parse_double (&pp, end, &pv));
+    assert ((int) roundf (pv * 1000.) == 123);
+    assert (pp - str == 6);
+    assert (end - pp == 0);
+
+    char *pend;
+    assert ((int) roundf (strtod_rl (str, &pend) * 1000.) == 123);
+    assert (pend - str == 6);
+  }
+
+  {
+    const char str[] = ".000123e+3";
+    const char *pp = str;
+    const char *end = str + ARRAY_LENGTH (str) - 1;
+
+    double pv;
+    assert (hb_parse_double (&pp, end, &pv));
+    assert ((int) roundf (pv * 1000.) == 123);
+    assert (pp - str == 10);
+    assert (end - pp == 0);
+
+    char *pend;
+    assert ((int) roundf (strtod_rl (str, &pend) * 1000.) == 123);
+    assert (pend - str == 10);
+  }
+
+  {
+    const char str[] = "-.000000123e6";
+    const char *pp = str;
+    const char *end = str + ARRAY_LENGTH (str) - 1;
+
+    double pv;
+    assert (hb_parse_double (&pp, end, &pv));
+    assert ((int) roundf (pv * 1000.) == -123);
+    assert (pp - str == 13);
+    assert (end - pp == 0);
+
+    char *pend;
+    assert ((int) roundf (strtod_rl (str, &pend) * 1000.) == -123);
+    assert (pend - str == 13);
+  }
+
+  {
+    const char str[] = "-1.23E-1";
+    const char *pp = str;
+    const char *end = str + ARRAY_LENGTH (str) - 1;
+
+    double pv;
+    assert (hb_parse_double (&pp, end, &pv));
+    assert ((int) roundf (pv * 1000.) == -123);
+    assert (pp - str == 8);
+    assert (end - pp == 0);
+
+    char *pend;
+    assert ((int) roundf (strtod_rl (str, &pend) * 1000.) == -123);
+    assert (pend - str == 8);
+  }
+
+  return 0;
+}
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/test-ot-color.cc b/Build/source/libs/harfbuzz/harfbuzz-src/src/test-ot-color.cc
index 3b4c8b6c266..88924b44734 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/test-ot-color.cc
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/test-ot-color.cc
@@ -330,8 +330,8 @@ main (int argc, char **argv)
 
     // disabled when color font as cairo rendering of NotoColorEmoji is soooo slow
     if (!hb_ot_color_has_layers (face) &&
-        !hb_ot_color_has_png (face) &&
-        !hb_ot_color_has_svg (face))
+	!hb_ot_color_has_png (face) &&
+	!hb_ot_color_has_svg (face))
       dump_glyphs (cairo_face, upem, num_glyphs, face_index);
 
     hb_font_destroy (font);
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/test-unicode-ranges.cc b/Build/source/libs/harfbuzz/harfbuzz-src/src/test-unicode-ranges.cc
index 0eef8c24b50..33cac6b7157 100644
--- a/Build/source/libs/harfbuzz/harfbuzz-src/src/test-unicode-ranges.cc
+++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/test-unicode-ranges.cc
@@ -33,9 +33,9 @@ test (hb_codepoint_t cp, unsigned int bit)
   if (OT::_hb_ot_os2_get_unicode_range_bit (cp) != bit)
   {
     fprintf (stderr, "got incorrect bit (%d) for cp 0x%X. Should have been %d.",
-             OT::_hb_ot_os2_get_unicode_range_bit (cp),
-             cp,
-             bit);
+	     OT::_hb_ot_os2_get_unicode_range_bit (cp),
+	     cp,
+	     bit);
     abort();
   }
 }
diff --git a/Build/source/libs/harfbuzz/version.ac b/Build/source/libs/harfbuzz/version.ac
index 4604201932f..d261233f584 100644
--- a/Build/source/libs/harfbuzz/version.ac
+++ b/Build/source/libs/harfbuzz/version.ac
@@ -8,4 +8,4 @@ dnl
 dnl --------------------------------------------------------
 dnl
 dnl  m4-include this file to define the current harfbuzz version
-m4_define([harfbuzz_version], [2.6.1])
+m4_define([harfbuzz_version], [2.6.2])
author	Akira Kakuto <kakuto@fuk.kindai.ac.jp>	2019-09-30 22:08:36 +0000
committer	Akira Kakuto <kakuto@fuk.kindai.ac.jp>	2019-09-30 22:08:36 +0000
commit	883a87cde515fcdd076708f212ebb66ed32b145f (patch)
tree	ac0fce4c70597596bb267f760197a09232b219b1 /Build/source/libs
parent	6c0fed440c27ba0d6856feeb1000320320cf8a96 (diff)