diff --git a/README.md b/README.md
index 18381bb..8408ae3 100644
--- a/README.md
+++ b/README.md
@@ -60,7 +60,7 @@ pip install east-asian-spacing
 ### Clone and Install
 
 If you may need to diagnose fonts or the code,
-installing using [poetry] is recommended:
+cloning and installing using [poetry] is recommended:
 ```sh
 git clone https://github.com/kojiishi/east_asian_spacing
 cd east_asian_spacing
@@ -84,7 +84,7 @@ You can run [unit tests] to verify your installation if needed.
 [pipenv]: https://github.com/pypa/pipenv
 [poetry]: https://github.com/python-poetry/poetry
 
-## Adding the feature to your fonts
+## Adding the features to your fonts
 
 ### Usage
 
@@ -95,26 +95,32 @@ east-asian-spacing -o build input-font-file
 ```
 The `--help` option shows the full list of options.
 
-### Languages
+### Supported Fonts
 
-Because the glyph for a code point may vary by languages,
-different tables are desired for different languages.
+Following fonts are tested on each release:
+* [Noto CJK]
+* Meiryo
 
-In many cases, when the font supports multiple East Asian languages,
-this tool can detect the languages automatically.
-But it shows an error when it failed to detect.
-You need to specify the [OpenType language system tag] of the font in that case.
+Several more fonts were tested during the development.
+The [algorithm] is generic and is applicable to any fonts.
+The [chws_tool] package extends this package and
+covers fonts at [fonts.google.com].
 
-The following example specifies that the font is a Japanese font.
-```sh
-east-asian-spacing --language=JAN input-font-file
-```
+The [test HTML] is a handy tool to check the fonts you build.
+If you encounter any problems with your fonts,
+please report to [issues].
 
-[OpenType language system tag]: https://docs.microsoft.com/en-us/typography/opentype/spec/languagetags
+Please also see the [Advanced Topics] below
+if you want to customize the default behaviors of this package.
+
+[chws_tool]: https://github.com/googlefonts/chws_tool
+[fonts.google.com]: https://fonts.google.com
+[issues]: https://github.com/kojiishi/east_asian_spacing/issues
+[Noto CJK]: https://www.google.com/get/noto/help/cjk/
 
 ### TrueType Collection (TTC)
 
-When the `input-font-file` is a TrueType Collection (TTC),
+When the input font file is a TrueType Collection (TTC),
 this tool adds the feature to all fonts in the TTC by default.
 
 If you want to add the feature to only some of fonts in the TTC,
@@ -125,7 +131,45 @@ but not to other fonts in the TTC.
 east-asian-spacing --index=0,1 input-font-file.ttc
 ```
 
-The language option applies to all fonts in the TTC by default.
+## Advanced Topics
+[Advanced Topics]: #advanced-topics
+
+### Algorithm
+[Algorithm]: #algorithm
+
+This package determines the glyph pairs to adjust spacings
+by a pre-defined set of Unicode code points.
+
+Then for each pair, it computes if the spacings are applicable
+by examining glyph outlines and computing ink bounding boxes of glyphs.
+For example, when glyphs are very thick,
+glyphs may not have enough internal spacings,
+and applying the spacings may cause glyphs to collide.
+This package automatically detects such cases and
+stops applying spacings to such pairs.
+
+This automatic behavior can be disabled
+by specifying the [languages] below,
+or by setting `Config.use_ink_bounds` to `False` in your Python program.
+
+### Languages
+[languages]: #languages
+
+Because the glyph for a code point may vary by languages,
+different tables are desired for different languages.
+This package determines such differences by examining glyph outlines
+as described in the [algorithm] section above.
+
+Instead of using glyph outlines,
+you can specify the [OpenType language system tag] of the font.
+The following example specifies that the font is a Japanese font,
+and disables the automatic determination by glyph outlines.
+```sh
+east-asian-spacing --language=JAN input-font-file
+```
+
+For TrueType Collections (TTC),
+the language option applies to all fonts in the TTC by default.
 When you want to specify different languages to each font in the TTC,
 it accepts a comma-separated list.
 The following example specifies
@@ -145,27 +189,7 @@ Other fonts in the TTC are not changed.
 east-asian-spacing --index=2,3 --language=JAN,ZHS input-font-file.ttc
 ```
 
-### Noto CJK
-
-For [Noto CJK] fonts,
-this tool has a built-in support
-to determine the font indices and the languages automatically.
-
-When the first argument is `noto`, it
-a) computes the appropriate language for each font, and
-b) skips `Mono` fonts,
-both determined by the font name.
-```sh
-east-asian-spacing noto NotoSansCJK.ttc
-```
-You can also run it for a directory to find all font files recursively.
-```sh
-east-asian-spacing noto ~/googlefonts/noto-cjk
-```
-
-[Noto CJK]: https://www.google.com/get/noto/help/cjk/
-
-## Advanced Topics
+[OpenType language system tag]: https://docs.microsoft.com/en-us/typography/opentype/spec/languagetags
 
 ### Character-Pairs
 
@@ -174,15 +198,11 @@ in cases such as when
 your fonts may not have expected spacings for some characters.
 Currently, this is possible only from Python programs.
 
-The [chws_tool] is a project that
-extends the [`Config` class] to provide default languages and
-customized character-pairs for fonts at [fonts.google.com].
-
-For a simpler example, please see the `test_config` function
+For a simple example, please see the `test_config` function
 in [`tests/config_test.py`].
 
-[chws_tool]: https://github.com/googlefonts/chws_tool
-[fonts.google.com]: https://fonts.google.com
+The [chws_tool] project is another example
+of how to customize this package.
 
 [`Config` class]: east_asian_spacing/config.py
 [`tests/config_test.py`]: tests/config_test.py
@@ -190,7 +210,7 @@ in [`tests/config_test.py`].
 ### HarfBuzz
 
 This package uses the [HarfBuzz] shaping engine
-using a Cython bindings [uharfbuzz].
+by using a Cython bindings [uharfbuzz].
 
 If you want to use a specific build of the [HarfBuzz],
 this tool can invoke the external [hb-shape] command line tool instead
@@ -218,14 +238,17 @@ Instructions for other platforms may be available at
 ## Testing
 
 ### Test HTML
+[test HTML]: #test-html
 
 A [test HTML] is available
 to check the behavior of fonts on browsers.
 
 It can test fonts you built locally.
-Download it to your local drive and
-add your fonts to the "`fonts`" list
-at the beginning of the `<script>` block.
+1. Save the page to your local drive.
+   The HTML is a single file, saving the HTML file should work.
+2. Add your font files to the "`fonts`" list
+   at the beginning of the `<script>` block.
+3. Open it in your browser and choose your font.
 
 [test HTML]: https://kojiishi.github.io/chws/test.html
 
diff --git a/east_asian_spacing/__init__.py b/east_asian_spacing/__init__.py
index e91db86..e02ee83 100644
--- a/east_asian_spacing/__init__.py
+++ b/east_asian_spacing/__init__.py
@@ -3,7 +3,6 @@
 from east_asian_spacing.dump import *
 from east_asian_spacing.font import *
 from east_asian_spacing.log_utils import *
-from east_asian_spacing.noto_cjk_builder import *
 from east_asian_spacing.shaper import *
 from east_asian_spacing.spacing import *
 from east_asian_spacing.tester import *
diff --git a/east_asian_spacing/__main__.py b/east_asian_spacing/__main__.py
index ca095a2..036a12c 100644
--- a/east_asian_spacing/__main__.py
+++ b/east_asian_spacing/__main__.py
@@ -13,11 +13,6 @@ def main():
             asyncio.run(east_asian_spacing.Dump.main())
             return
 
-        if sub_command == 'noto':
-            del args[1]
-            asyncio.run(east_asian_spacing.NotoCJKBuilder.main())
-            return
-
     asyncio.run(east_asian_spacing.Builder.main())
 
 
diff --git a/east_asian_spacing/builder.py b/east_asian_spacing/builder.py
index b6b78ec..4c69634 100755
--- a/east_asian_spacing/builder.py
+++ b/east_asian_spacing/builder.py
@@ -62,6 +62,20 @@ def calc_output_path(input_path, output_path, stem_suffix=None):
         return (output_path.parent /
                 f'{output_path.stem}{stem_suffix}{output_path.suffix}')
 
+    async def _config_for_font(self, font):
+        config = self.config.for_font(font)
+        if config is None:
+            logger.info('Skipped by config: "%s"', font)
+            return None
+        if (config.skip_monospace_ascii
+                and await EastAsianSpacing.is_monospace_ascii(font)):
+            logger.info('Skipped because monospace: "%s"', font)
+            return None
+        if EastAsianSpacing.font_has_feature(font):
+            logger.info('Skipped because the features exist: "%s"', font)
+            return None
+        return config
+
     async def build(self):
         font = self.font
         config = self.config
@@ -70,17 +84,15 @@ async def build(self):
             return await self.build_collection()
 
         assert not font.is_collection
-        config = self.config.for_font(font)
+        config = await self._config_for_font(font)
         if config is None:
-            logger.info('Skipping by config: "%s"', font)
-            return
-        if EastAsianSpacing.font_has_feature(font):
             return
         spacing = EastAsianSpacing()
         await spacing.add_glyphs(font, config)
         if not spacing.can_add_to_font:
             logger.info('Skipping due to no pairs: "%s"', font)
             return
+        logger.info('Adding features to: "%s" %s', font, spacing)
         spacing.add_to_font(font)
         self._spacings.append(spacing)
 
@@ -91,13 +103,9 @@ async def build_collection(self):
         # font, make sure we add the same data so that the new GPOS is also shared.
         spacing_by_offset = {}
         for font in self.font.fonts_in_collection:
-            config = self.config.for_font(font)
+            config = await self._config_for_font(font)
             if config is None:
-                logger.info('Skipping by config: "%s"', font)
                 continue
-            if EastAsianSpacing.font_has_feature(font):
-                logger.info('Feature already exists: "%s"', font)
-                return
             reader_offset = font.reader_offset("GPOS")
             # If the font does not have `GPOS`, `reader_offset` is `None`.
             # Create a shared `GPOS` for all fonts in the case. e.g., BIZ-UD.
@@ -119,11 +127,11 @@ async def build_collection(self):
         built_fonts = []
         for spacing, fonts in spacing_by_offset.values():
             if not spacing.can_add_to_font:
-                logger.info('Skipping due to no pairs: "%s"',
+                logger.info('Skipping due to no pairs: %s',
                             list(font.font_index for font in fonts))
                 continue
-            logger.info('Adding feature to: %s',
-                        list(font.font_index for font in fonts))
+            logger.info('Adding features to: %s %s',
+                        list(font.font_index for font in fonts), spacing)
             for font in fonts:
                 spacing.add_to_font(font)
             self._spacings.append(spacing)
@@ -230,6 +238,8 @@ async def main():
                             default=0)
         args = parser.parse_args()
         init_logging(args.verbose, main=logger)
+        if args.glyph_out:
+            args.glyph_out.mkdir(exist_ok=True, parents=True)
         if args.output:
             args.output.mkdir(exist_ok=True, parents=True)
         for input in Builder.expand_paths(args.inputs):
@@ -246,7 +256,7 @@ async def main():
             builder = Builder(font, config)
             await builder.build()
             if not builder.has_spacings:
-                logger.warning('Skipped due to no changes: "%s"', input)
+                logger.warning('Skipped saving due to no changes: "%s"', input)
                 continue
             builder.save(args.output,
                          stem_suffix=args.suffix,
diff --git a/east_asian_spacing/config.py b/east_asian_spacing/config.py
index e1d70a6..8da3190 100644
--- a/east_asian_spacing/config.py
+++ b/east_asian_spacing/config.py
@@ -16,15 +16,20 @@ def __init__(self):
         }
         self.quotes_opening = {0x2018, 0x201C}
         self.quotes_closing = {0x2019, 0x201D}
-        self.cjk_middle = {0x3000, 0x30FB}
+        self.cjk_middle = {0x30FB}
+        self.fullwidth_space = {0x3000}
         self.cjk_period_comma = {0x3001, 0x3002, 0xFF0C, 0xFF0E}
-        self.cjk_column_semicolon = {0xFF1A, 0xFF1B}
+        self.cjk_colon_semicolon = {0xFF1A, 0xFF1B}
         self.cjk_exclam_question = {0xFF01, 0xFF1F}
+
+        # Skip adding the features to fonts with monospace ASCII
+        # because they are generally for code.
+        self.skip_monospace_ascii = True
+        # Determines the applicability by computing ink bounds.
+        self.use_ink_bounds = True
+        # Specify which language behavior the font is.
+        # Valid only when `use_ink_bounds` is `False`.
         self.language = None
-        # These code points are on the left-half of the glyph spaces only in
-        # ZHS fonts, though not all ZHS fonts follow the convention.
-        # Setting to `True` or `False` disables the heuristic detection.
-        self.is_colon_semicolon_middle = None
 
     default = None  # This will be set later in this file.
 
@@ -39,8 +44,9 @@ def _sets(self):
         yield self.quotes_opening
         yield self.quotes_closing
         yield self.cjk_middle
+        yield self.fullwidth_space
         yield self.cjk_period_comma
-        yield self.cjk_column_semicolon
+        yield self.cjk_colon_semicolon
         yield self.cjk_exclam_question
 
     def clear(self):
@@ -67,11 +73,14 @@ def for_font_name(self, name, is_vertical):
         return self
 
     def for_language(self, language):
-        """Returns a copy with the specified language."""
+        """Returns a copy with the specified language.
+
+        This also sets `use_ink_bounds` to `False`."""
         if language == self.language:
             return self
         clone = self.clone()
         clone.language = language
+        clone.use_ink_bounds = not language
         return clone
 
     def for_smoke_testing(self):
@@ -102,34 +111,7 @@ def _down_sample_to(input, max):
         return set(itertools.islice(input, 0, None, interval))
 
 
-class DefaultConfig(Config):
-    def for_font_name(self, name, is_vertical):
-        if name.startswith("Meiryo"):
-            config = self.for_language('JAN')
-            if is_vertical:
-                config = config.clone_if_is(self)
-                config.change_quotes_closing_to_opening(0x2019)
-                config.remove(0xFF0C, 0xFF0E)
-            return config
-        if name.startswith("Microsoft JhengHei"):
-            config = self.for_language('ZHT')
-            config = config.clone_if_is(self)
-            config.remove(0xFF08, 0xFF09, 0xFF3B, 0xFF3D, 0xFF5B, 0xFF5D,
-                          0xFF5F, 0xFF60)
-            if is_vertical:
-                config.change_quotes_closing_to_opening(0x2019, 0x201D)
-            return config
-        if name.startswith("Microsoft YaHei"):
-            config = self.for_language('ZHS')
-            if is_vertical:
-                config = config.clone_if_is(self)
-                config.remove(0x3001, 0x3002, 0x3018, 0x3019, 0x301A, 0x301B,
-                              0xFF08, 0xFF09, 0xFF0C, 0xFF0E)
-            return config
-        return self
-
-
-class CollectionConfig(DefaultConfig):
+class CollectionConfig(Config):
     def __init__(self, font, languages=None, indices=None):
         assert font.is_collection
         super().__init__()
@@ -164,4 +146,4 @@ def _calc_indices_and_languages(num_fonts, indices, languages):
         return itertools.zip_longest(indices, ())
 
 
-Config.default = DefaultConfig()
+Config.default = Config()
diff --git a/east_asian_spacing/font.py b/east_asian_spacing/font.py
index a8ba565..585eb85 100755
--- a/east_asian_spacing/font.py
+++ b/east_asian_spacing/font.py
@@ -8,6 +8,7 @@
 from fontTools.ttLib import TTFont
 from fontTools.ttLib.tables import otTables
 from fontTools.ttLib.ttCollection import TTCollection
+from fontTools.pens.boundsPen import BoundsPen
 import uharfbuzz as hb
 
 logger = logging.getLogger('font')
@@ -25,6 +26,7 @@ def __init__(self):
         self._path = None
         self.ttcollection = None
         self._ttfont = None
+        self._ttglyphset = None
         self._units_per_em = None
         self._vertical_font = None
 
@@ -52,6 +54,7 @@ def _create_vertical_font(self):
         font._hbfont = self._hbfont
         font.ttcollection = self.ttcollection
         font._ttfont = self.ttfont
+        self._ttglyphset = self._ttglyphset
         font._units_per_em = self._units_per_em
         # Setup a vertical font.
         font.is_vertical = True
@@ -157,8 +160,11 @@ def save(self, out_path=None):
     def _before_save(ttfont):
         # `TTFont.save()` compiles all loaded tables. Unload tables we know we did
         # not modify, so that it copies instead of re-compile.
-        for key in ("CFF ", "GSUB", "name"):
-            if ttfont.isLoaded(key):
+        loaded_keys = ttfont.tables.keys()
+        logger.debug("loaded_keys=%s", loaded_keys)
+        keys_to_save = set(('head', 'GPOS'))
+        for key in tuple(loaded_keys):
+            if key not in keys_to_save and ttfont.isLoaded(key):
                 del ttfont.tables[key]
 
     @property
@@ -169,6 +175,12 @@ def is_collection(self):
     def ttfont(self):
         return self._ttfont
 
+    @property
+    def ttglyphset(self):
+        if not self._ttglyphset:
+            self._ttglyphset = self.ttfont.getGlyphSet()
+        return self._ttglyphset
+
     @property
     def ttfonts(self):
         if self.ttcollection:
@@ -260,6 +272,27 @@ def fullwidth_advance(self, value):
             logger.debug('fullwidth_advance=%d for "%s"', value, self)
         self._fullwidth_advance = value
 
+    def glyph_name(self, glyph_id):
+        assert isinstance(glyph_id, int)
+        ttfont = self.ttfont
+        if ttfont:
+            return ttfont.getGlyphName(glyph_id)
+        return f'glyph{glyph_id:05}'
+
+    def glyph_names(self, glyph_ids):
+        ttfont = self.ttfont
+        if ttfont:
+            return (ttfont.getGlyphName(glyph_id) for glyph_id in glyph_ids)
+        return (f'glyph{glyph_id:05}' for glyph_id in glyph_ids)
+
+    def glyph_bounds(self, glyph):
+        glyph = self.glyph_name(glyph)
+        ttglyphset = self.ttglyphset
+        ttglyph = ttglyphset[glyph]
+        bounds = BoundsPen(ttglyphset)
+        ttglyph.draw(bounds)
+        return bounds.bounds
+
     @property
     def script_and_langsys_tags(self, tags=("GSUB", "GPOS")):
         result = ()
@@ -289,12 +322,6 @@ def raise_require_language(self):
                                 key=lambda t: t[0] +
                                 ("" if t[1] is None else t[1]))))
 
-    def glyph_names(self, glyph_ids):
-        ttfont = self.ttfont
-        if ttfont:
-            return (ttfont.getGlyphName(glyph_id) for glyph_id in glyph_ids)
-        return (f'glyph{glyph_id:05}' for glyph_id in glyph_ids)
-
     @staticmethod
     def _has_ottable_feature(ottable, feature_tag):
         if not ottable or not ottable.FeatureList:
diff --git a/east_asian_spacing/log_utils.py b/east_asian_spacing/log_utils.py
index 0793ab5..e81d144 100644
--- a/east_asian_spacing/log_utils.py
+++ b/east_asian_spacing/log_utils.py
@@ -3,17 +3,22 @@
 _log_shaper_logs = False
 
 
-def init_logging(verbose, main=None):
+def init_logging(verbose, loggers=None, main=None):
     if not verbose or verbose <= 0:
         return
 
     if main:
-        if verbose == 1:
-            console = logging.StreamHandler()
-            main.addHandler(console)
-            main.setLevel(logging.INFO)
+        assert loggers is None
+        loggers = [main]
+    if loggers:
+        if verbose <= len(loggers):
+            for logger in loggers[0:verbose]:
+                console = logging.StreamHandler()
+                logger.addHandler(console)
+                logger.setLevel(logging.INFO)
             return
-        verbose -= 1
+        verbose -= len(loggers)
+        assert verbose > 0
 
     if verbose <= 1:
         logging.basicConfig(level=logging.INFO)
diff --git a/east_asian_spacing/noto_cjk_builder.py b/east_asian_spacing/noto_cjk_builder.py
deleted file mode 100755
index 9e1de5a..0000000
--- a/east_asian_spacing/noto_cjk_builder.py
+++ /dev/null
@@ -1,114 +0,0 @@
-#!/usr/bin/env python3
-import argparse
-import asyncio
-import logging
-import pathlib
-import time
-
-from east_asian_spacing.builder import Builder
-from east_asian_spacing.builder import Font
-from east_asian_spacing.config import Config
-from east_asian_spacing.log_utils import init_logging
-
-logger = logging.getLogger('build')
-
-
-class NotoCJKConfig(Config):
-    default = None  # This will be set later in this file.
-
-    def for_font_name(self, name, is_vertical):
-        lang = NotoCJKConfig._lang_from_font_name(name)
-        if lang is None:
-            return None
-        return self.for_language(lang)
-
-    @staticmethod
-    def _lang_from_font_name(name):
-        assert name.startswith('Noto ')
-        if 'Mono' in name:
-            return None
-        if 'JP' in name:
-            return 'JAN'
-        if 'KR' in name:
-            return 'KOR'
-        if 'SC' in name:
-            return 'ZHS'
-        if 'TC' in name:
-            return 'ZHT'
-        if 'HK' in name:
-            return 'ZHH'
-        assert False, name
-
-
-NotoCJKConfig.default = NotoCJKConfig()
-
-
-class NotoCJKBuilder(Builder):
-    def __init__(self, font):
-        super().__init__(font, config=NotoCJKConfig.default)
-
-    @classmethod
-    def expand_dir(cls, path):
-        assert path.is_dir()
-        child_paths = path.rglob('Noto*')
-        child_paths = filter(NotoCJKBuilder.is_font_path, child_paths)
-        return child_paths
-
-    @staticmethod
-    def is_font_path(path):
-        assert path.is_file()
-        if not path.name.startswith('Noto'):
-            return False
-        if 'Mono' in path.name:
-            return False
-        if not Font.is_font_extension(path.suffix):
-            return False
-        return True
-
-    @staticmethod
-    async def main():
-        parser = argparse.ArgumentParser()
-        parser.add_argument("inputs", nargs="+")
-        parser.add_argument("-g",
-                            "--glyph-out",
-                            type=pathlib.Path,
-                            help="output glyph list.")
-        parser.add_argument("-o",
-                            "--output",
-                            default='build',
-                            type=pathlib.Path,
-                            help="output directory.")
-        parser.add_argument("-p",
-                            "--print-path",
-                            action="store_true",
-                            help="print the file paths to stdout.")
-        parser.add_argument("--test",
-                            type=int,
-                            default=1,
-                            help="0=no tests, 1=smoke tests, 2=full tests.")
-        parser.add_argument("-v",
-                            "--verbose",
-                            help="increase output verbosity.",
-                            action="count",
-                            default=0)
-        args = parser.parse_args()
-        init_logging(args.verbose, main=logger)
-        if args.glyph_out:
-            args.glyph_out.mkdir(exist_ok=True, parents=True)
-        if args.output:
-            args.output.mkdir(exist_ok=True, parents=True)
-        for input in NotoCJKBuilder.expand_paths(args.inputs):
-            builder = NotoCJKBuilder(input)
-            await builder.build()
-            builder.save(args.output,
-                         glyph_out=args.glyph_out,
-                         print_path=args.print_path)
-            if args.test:
-                await builder.test(smoke=(args.test == 1))
-
-
-if __name__ == '__main__':
-    start_time = time.time()
-    asyncio.run(NotoCJKBuilder.main())
-    elapsed = time.time() - start_time
-    logger.info(f'Elapsed {elapsed:.2f}s')
diff --git a/east_asian_spacing/shaper.py b/east_asian_spacing/shaper.py
index fb4a300..3fb69ea 100755
--- a/east_asian_spacing/shaper.py
+++ b/east_asian_spacing/shaper.py
@@ -1,6 +1,7 @@
 #!/usr/bin/env python3
 import argparse
 import asyncio
+import enum
 import io
 import json
 import logging
@@ -22,6 +23,46 @@ def show_dump_images():
     ShaperBase._dump_images = True
 
 
+class InkPart(enum.Enum):
+    LEFT = enum.auto()
+    RIGHT = enum.auto()
+    MIDDLE = enum.auto()
+    OTHER = enum.auto()
+
+    def __str__(self):
+        return self.name
+
+
+class InkPartMargin(object):
+    _current = 0
+
+    def __init__(self, margin):
+        self.margin = margin
+
+    def __enter__(self):
+        self.saved_margin = InkPartMargin._current
+        InkPartMargin._current = self.margin
+
+    def __exit__(self, ex_type, ex_value, trace):
+        InkPartMargin._current = self.saved_margin
+
+
+def _compute_ink_part(min, max, left, right):
+    assert min <= max
+    assert left < right
+    margin = InkPartMargin._current
+    middle = (left + right) / 2
+    if max <= middle + margin:
+        return InkPart.LEFT
+    if min >= middle - margin:
+        return InkPart.RIGHT
+    qleft = (left + middle) / 2
+    qright = (right + middle) / 2
+    if min >= qleft - margin and max <= qright + margin:
+        return InkPart.MIDDLE
+    return InkPart.OTHER
+
+
 class GlyphData(object):
     def __init__(self, glyph_id, cluster_index, advance, offset):
         self.glyph_id = glyph_id
@@ -36,13 +77,45 @@ def __eq__(self, other):
                 and self.offset == other.offset)
 
     def __str__(self):
+        values = []
         text = getattr(self, 'text', None)
-        text = f't:"{text}",' if text else ''
-        return (f'{{{text}'
-                f'g:{self.glyph_id},'
-                f'a:{self.advance},'
-                f'o:{self.offset},'
-                f'c:{self.cluster_index}}}')
+        if text:
+            values.append(f't:"{text}"')
+        values.extend((f'g:{self.glyph_id}', f'a:{self.advance}',
+                       f'o:{self.offset}', f'c:{self.cluster_index}'))
+        bounds = getattr(self, 'bounds', None)
+        if bounds:
+            values.append(f'b:{bounds}')
+        ink_part = getattr(self, 'ink_part', None)
+        if ink_part:
+            values.append(f'i:{ink_part}')
+        return f'{{{",".join(values)}}}'
+
+    def compute_ink_part(self, font):
+        self.bounds = bounds = font.glyph_bounds(self.glyph_id)
+        if bounds is None:
+            self.ink_part = InkPart.OTHER
+            return
+        if font.is_vertical:
+            self.ink_part = _compute_ink_part(self.offset - bounds[3],
+                                              self.offset - bounds[1], 0,
+                                              self.advance)
+            return
+        self.ink_part = _compute_ink_part(bounds[0], bounds[2], 0,
+                                          self.advance)
+
+    def get_ink_part(self, font):
+        ink_pos = getattr(self, 'ink_part', None)
+        if ink_pos is not None:
+            return ink_pos
+        self.compute_ink_part(font)
+        return self.ink_part
+
+    @staticmethod
+    def _ink_part_pred(glyph, font, ink_part):
+        if glyph.get_ink_part(font) == ink_part:
+            return True
+        logger.debug('ink_part: not %s %s', ink_part, glyph)
 
 
 class ShapeResult(object):
@@ -64,21 +137,25 @@ def __getitem__(self, item):
     def filter(self, predicate):
         self._glyphs = filter(predicate, self._glyphs)
 
-    def freeze(self):
-        """Freeze the internal generator as a tuple.
-        Once frozen, it can iterate multiple times."""
+    def filter_missing_glyphs(self):
+        # Filter out ".notdef" glyphs. Glyph 0 must be assigned to a .notdef glyph.
+        # https://docs.microsoft.com/en-us/typography/opentype/spec/recom#glyph-0-the-notdef-glyph
+        self.filter(lambda g: g.glyph_id)
+
+    def filter_ink_part(self, font, ink_part):
+        self.filter(lambda g: GlyphData._ink_part_pred(g, font, ink_part))
+
+    def ensure_multi_iterations(self):
+        """Ensure this can iterate multiple times
+        by capturing the internal generator as a tuple."""
         self._glyphs = tuple(self._glyphs)
 
     @property
     def glyph_ids(self):
-        glyph_ids = (g.glyph_id for g in self._glyphs)
-        # Filter out ".notdef" glyphs. Glyph 0 must be assigned to a .notdef glyph.
-        # https://docs.microsoft.com/en-us/typography/opentype/spec/recom#glyph-0-the-notdef-glyph
-        glyph_ids = filter(lambda glyph_id: glyph_id, glyph_ids)
-        return glyph_ids
+        return (g.glyph_id for g in self._glyphs)
 
     def set_text(self, text):
-        self.freeze()
+        self.ensure_multi_iterations()
         if len(self._glyphs) == 0:
             return
         last = self._glyphs[0]
@@ -87,8 +164,13 @@ def set_text(self, text):
             last = glyph
         last.text = text[last.cluster_index:]
 
+    def compute_ink_parts(self, font):
+        self.ensure_multi_iterations()
+        for g in self._glyphs:
+            g.compute_ink_part(font)
+
     def __str__(self):
-        self.freeze()  # Make sure it is still iterable.
+        self.ensure_multi_iterations()  # Make sure it is still iterable.
         return f'[{",".join(str(g) for g in self._glyphs)}]'
 
 
@@ -123,6 +205,7 @@ async def compute_fullwidth_advance(self):
         logger.debug('fullwidth_advance=%s for "%s"', advances, self.font)
         if len(advances) == 1:
             advance = next(iter(advances))
+            self.font.fullwidth_advance = advance
             return advance
         return None
 
@@ -132,9 +215,7 @@ async def ensure_fullwidth_advance(font):
         if font.fullwidth_advance:
             return True
         shaper = Shaper(font, features=['vert'] if font.is_vertical else None)
-        advance = await shaper.compute_fullwidth_advance()
-        if advance:
-            font.fullwidth_advance = advance
+        if await shaper.compute_fullwidth_advance():
             return True
         logger.info('No fullwidth advance for "%s"', font)
         return False
@@ -292,7 +373,6 @@ async def main():
     parser.add_argument("text")
     parser.add_argument("-l", "--language")
     parser.add_argument("-s", "--script")
-    parser.add_argument("--vertical", dest="is_vertical", action="store_true")
     parser.add_argument("-v",
                         "--verbose",
                         help="increase output verbosity",
@@ -305,9 +385,12 @@ async def main():
     font = Font.load(args.font_path)
     if font.is_collection:
         font = font.fonts_in_collection[args.index]
-    if args.is_vertical:
-        font = font.vertical_font
-    features = args.feature.split(',') if args.feature else None
+    if args.feature:
+        features = args.feature.split(',')
+        if 'vert' in features:
+            font = font.vertical_font
+    else:
+        features = None
     shaper = Shaper(font,
                     language=args.language,
                     script=args.script,
@@ -316,7 +399,9 @@ async def main():
           f'upem={font.units_per_em}')
     result = await shaper.shape(args.text)
     result.set_text(args.text)
-    print('glyphs=', '\n        '.join(str(g) for g in result))
+    result.compute_ink_parts(font)
+    for g in result:
+        print(g)
 
 
 if __name__ == '__main__':
diff --git a/east_asian_spacing/spacing.py b/east_asian_spacing/spacing.py
index e6d454d..2e0b04d 100755
--- a/east_asian_spacing/spacing.py
+++ b/east_asian_spacing/spacing.py
@@ -1,6 +1,7 @@
 #!/usr/bin/env python3
 import argparse
 import asyncio
+import itertools
 import logging
 import math
 import sys
@@ -14,7 +15,7 @@
 
 from east_asian_spacing.config import Config
 from east_asian_spacing.font import Font
-from east_asian_spacing.shaper import Shaper
+from east_asian_spacing.shaper import InkPart, Shaper
 from east_asian_spacing.shaper import show_dump_images
 
 logger = logging.getLogger('spacing')
@@ -47,12 +48,20 @@ def assert_glyphs_are_disjoint(self):
         assert self.left.isdisjoint(self.right)
         assert self.middle.isdisjoint(self.right)
 
-    def __str__(self):
+    def _to_str(self, glyph_ids=False):
         name_and_glyphs = self._name_and_glyphs
         name_and_glyphs = filter(lambda name_and_glyph: name_and_glyph[1],
                                  name_and_glyphs)
-        return ', '.join(
-            (f'{name}={glyphs}' for name, glyphs in name_and_glyphs))
+        if glyph_ids:
+            strs = (f'{name}={sorted(glyphs)}'
+                    for name, glyphs in name_and_glyphs)
+        else:
+            strs = (f'{len(glyphs)} {name}'
+                    for name, glyphs in name_and_glyphs)
+        return ', '.join(strs)
+
+    def __str__(self):
+        return self._to_str()
 
     def save_glyphs(self, output, prefix='', separator='\n'):
         for name, glyphs in self._name_and_glyphs:
@@ -68,12 +77,25 @@ def unite(self, other):
         self.middle |= other.middle
         self.right |= other.right
 
+    def add_by_ink_part(self, glyphs, font):
+        for glyph in glyphs:
+            ink_pos = glyph.get_ink_part(font)
+            if ink_pos == InkPart.LEFT:
+                self.left.add(glyph.glyph_id)
+            elif ink_pos == InkPart.MIDDLE:
+                self.middle.add(glyph.glyph_id)
+            else:
+                logger.debug('add_by_ink_part: ignored %s', glyph)
+        self.assert_glyphs_are_disjoint()
+
     async def add_glyphs(self, font, config):
         self.assert_font(font)
         if not await Shaper.ensure_fullwidth_advance(font):
+            logger.info('Skipped because proportional CJK: "%s"', font)
             return
         config = config.for_font(font)
         if not config:
+            logger.info('Skipped by config: "%s"', font)
             return
         results = await asyncio.gather(self.get_opening_closing(font, config),
                                        self.get_period_comma(font, config),
@@ -95,36 +117,48 @@ async def _shape(font, unicodes, language=None):
                         script='hani',
                         features=features)
         result = await shaper.shape(text)
+        result.filter_missing_glyphs()
 
         # East Asian spacing applies only to fullwidth glyphs.
         em = font.fullwidth_advance
         result.filter(lambda g: g.advance == em)
 
         if logger.getEffectiveLevel() <= logging.DEBUG:
-            result.freeze()
+            result.ensure_multi_iterations()
             if len(result):
+                result.compute_ink_parts(font)
                 logger.debug('ShapeResult=%s', result)
+        return result
 
+    @staticmethod
+    async def _glyph_id_set(font, unicodes, language=None):
+        result = await GlyphSetTrio._shape(font, unicodes, language=language)
         return set(result.glyph_ids)
 
     @staticmethod
     async def get_opening_closing(font, config):
         opening = config.cjk_opening | config.quotes_opening
         closing = config.cjk_closing | config.quotes_closing
-        left, right, middle = await asyncio.gather(
+        left, right, middle, space = await asyncio.gather(
             GlyphSetTrio._shape(font, closing),
             GlyphSetTrio._shape(font, opening),
-            GlyphSetTrio._shape(font, config.cjk_middle))
-        result = GlyphSetTrio(left, right, middle)
+            GlyphSetTrio._shape(font, config.cjk_middle),
+            GlyphSetTrio._shape(font, config.fullwidth_space))
+        if config.use_ink_bounds:
+            left.filter_ink_part(font, InkPart.LEFT)
+            right.filter_ink_part(font, InkPart.RIGHT)
+            middle.filter_ink_part(font, InkPart.MIDDLE)
+        trio = GlyphSetTrio(set(left.glyph_ids), set(right.glyph_ids),
+                            set(middle.glyph_ids) | set(space.glyph_ids))
         if font.is_vertical:
             # Left/right in vertical should apply only if they have `vert` glyphs.
             # YuGothic/UDGothic doesn't have 'vert' glyphs for U+2018/201C/301A/301B.
-            horizontal = await GlyphSetTrio._shape(font.horizontal_font,
-                                                   opening | closing)
-            result.left -= horizontal
-            result.right -= horizontal
-        result.assert_glyphs_are_disjoint()
-        return result
+            horizontal = await GlyphSetTrio._glyph_id_set(
+                font.horizontal_font, opening | closing)
+            trio.left -= horizontal
+            trio.right -= horizontal
+        trio.assert_glyphs_are_disjoint()
+        return trio
 
     @staticmethod
     async def get_period_comma(font, config):
@@ -137,79 +171,62 @@ async def get_period_comma(font, config):
         ja, zht = await asyncio.gather(
             GlyphSetTrio._shape(font, text, language="JAN"),
             GlyphSetTrio._shape(font, text, language="ZHT"))
-        if __debug__:
-            zhs, kor = await asyncio.gather(
-                GlyphSetTrio._shape(font, text, language="ZHS"),
-                GlyphSetTrio._shape(font, text, language="KOR"))
-            assert zhs == ja
-            assert kor == ja
-            # Some fonts do not support ZHH, in that case, it may be the same as JAN.
-            # For example, NotoSansCJK supports ZHH but NotoSerifCJK does not.
-            # assert Shaper(font, text, language="ZHH", script="hani").glyph_ids_set() == zht
-        if ja == zht:
+        if config.use_ink_bounds:
+            ja.filter_ink_part(font, InkPart.LEFT)
+            zht.filter_ink_part(font, InkPart.MIDDLE)
+        ja = set(ja.glyph_ids)
+        zht = set(zht.glyph_ids)
+        if not config.use_ink_bounds and ja == zht:
             if not config.language: font.raise_require_language()
             if config.language == "ZHT" or config.language == "ZHH":
                 ja.clear()
             else:
                 zht.clear()
         assert ja.isdisjoint(zht)
-        result = GlyphSetTrio(ja, None, zht)
-        result.assert_glyphs_are_disjoint()
-        return result
+        trio = GlyphSetTrio(ja, None, zht)
+        trio.assert_glyphs_are_disjoint()
+        return trio
 
     @staticmethod
     async def get_colon_semicolon(font, config):
         # Colon/semicolon are at middle for Japanese, left in ZHS.
-        text = config.cjk_column_semicolon
-        is_colon_semicolon_middle = config.is_colon_semicolon_middle
-        result = GlyphSetTrio()
-        if is_colon_semicolon_middle is None:
-            ja, zhs = await asyncio.gather(
-                GlyphSetTrio._shape(font, text, language="JAN"),
-                GlyphSetTrio._shape(font, text, language="ZHS"))
-            if __debug__ and not font.is_vertical:
-                zht, kor = await asyncio.gather(
-                    GlyphSetTrio._shape(font, text, language="ZHT"),
-                    GlyphSetTrio._shape(font, text, language="KOR"))
-                assert zht == ja
-                assert kor == ja
-            ja = result.add_from_cache(font, ja)
-            zhs = result.add_from_cache(font, zhs)
+        text = config.cjk_colon_semicolon
+        trio = GlyphSetTrio()
+        ja, zhs = await asyncio.gather(
+            GlyphSetTrio._shape(font, text, language="JAN"),
+            GlyphSetTrio._shape(font, text, language="ZHS"))
+        if config.use_ink_bounds:
+            trio.add_by_ink_part(itertools.chain(ja, zhs), font)
+        else:
+            ja = set(ja.glyph_ids)
+            zhs = set(zhs.glyph_ids)
+            ja = trio.add_from_cache(font, ja)
+            zhs = trio.add_from_cache(font, zhs)
             if not ja and not zhs:
-                return result
+                return trio
             if ja == zhs:
                 if not config.language: font.raise_require_language()
                 if config.language == "ZHS":
                     ja.clear()
                 else:
                     zhs.clear()
-        else:
-            glyphs = await GlyphSetTrio._shape(font,
-                                               text,
-                                               language=config.language)
-            if is_colon_semicolon_middle:
-                ja = glyphs
-                zhs = set()
-            else:
-                zhs = glyphs
-                ja = set()
-        assert ja.isdisjoint(zhs)
-        if font.is_vertical:
-            # In vertical flow, add colon/semicolon to middle if they have vertical
-            # alternate glyphs. In ZHS, they are upright. In Japanese, they may or
-            # may not be upright. Vertical alternate glyphs indicate they are rotated.
-            # In ZHT, they may be upright even when there are vertical glyphs.
-            if config.language is None or config.language == "JAN":
-                ja_horizontal = await GlyphSetTrio._shape(font.horizontal_font,
-                                                          text,
-                                                          language="JAN")
-                ja -= ja_horizontal
-                result.middle |= ja
-            return result
-        result.middle |= ja
-        result.left |= zhs
-        result.assert_glyphs_are_disjoint()
-        return result
+            assert ja.isdisjoint(zhs)
+            if font.is_vertical:
+                # In vertical flow, add colon/semicolon to middle if they have
+                # vertical alternate glyphs. In ZHS, they are upright. In
+                # Japanese, they may or may not be upright. Vertical alternate
+                # glyphs indicate they are rotated. In ZHT, they may be upright
+                # even when there are vertical glyphs.
+                if config.language is None or config.language == "JAN":
+                    ja_horizontal = await GlyphSetTrio._glyph_id_set(
+                        font.horizontal_font, text, language="JAN")
+                    ja -= ja_horizontal
+                    trio.middle |= ja
+                return trio
+            trio.middle |= ja
+            trio.left |= zhs
+        trio.assert_glyphs_are_disjoint()
+        return trio
 
     @staticmethod
     async def get_exclam_question(font, config):
@@ -220,13 +237,13 @@ async def get_exclam_question(font, config):
         ja, zhs = await asyncio.gather(
             GlyphSetTrio._shape(font, text, language="JAN"),
             GlyphSetTrio._shape(font, text, language="ZHS"))
-        if __debug__:
-            zht, kor = await asyncio.gather(
-                GlyphSetTrio._shape(font, text, language="ZHT"),
-                GlyphSetTrio._shape(font, text, language="KOR"))
-            assert zht == ja
-            assert kor == ja
-        if ja == zhs:
+        if config.use_ink_bounds:
+            ja = set()
+            zhs.filter_ink_part(font, InkPart.LEFT)
+        else:
+            ja = set(ja.glyph_ids)
+        zhs = set(zhs.glyph_ids)
+        if not config.use_ink_bounds and ja == zhs:
             if not config.language: font.raise_require_language()
             if config.language == "ZHS":
                 ja.clear()
@@ -295,6 +312,8 @@ def can_add_to_table(self):
         return self.left and self.right
 
     def add_to_table(self, font, table, feature_tag):
+        logger.debug('add_to_table "%s" %s %s', font, feature_tag,
+                     self._to_str(glyph_ids=True))
         assert self.can_add_to_table, self
         self.assert_font(font)
         self.assert_glyphs_are_disjoint()
@@ -393,6 +412,9 @@ def __init__(self):
         self.horizontal = GlyphSetTrio()
         self.vertical = GlyphSetTrio()
 
+    def __str__(self):
+        return f'{self.horizontal}, vertical={self.vertical}'
+
     def save_glyphs(self, output, separator='\n'):
         self.horizontal.save_glyphs(output, separator=separator)
         if self.vertical:
@@ -422,6 +444,14 @@ def font_has_feature(font):
             return True
         return False
 
+    @staticmethod
+    async def is_monospace_ascii(font):
+        shaper = Shaper(font)
+        result = await shaper.shape('iIMW')
+        advances = set(g.advance for g in result)
+        assert len(advances) > 0
+        return len(advances) == 1
+
     @property
     def can_add_to_font(self):
         return (self.horizontal.can_add_to_table
diff --git a/east_asian_spacing/tester.py b/east_asian_spacing/tester.py
index 1258196..c820857 100755
--- a/east_asian_spacing/tester.py
+++ b/east_asian_spacing/tester.py
@@ -40,10 +40,10 @@ async def shape(self, language):
                         features=self.off_features)
         text = ''.join(chr(c) for c in self.input)
         self.off_glyphs = await shaper.shape(text)
-        self.off_glyphs.freeze()
+        self.off_glyphs.ensure_multi_iterations()
         shaper.features = self.features
         self.glyphs = await shaper.shape(text)
-        self.glyphs.freeze()
+        self.glyphs.ensure_multi_iterations()
 
     def should_apply(self, em=None, glyphs=None):
         # If any glyphs are missing, or their advances are not em,
diff --git a/precommit.sh b/precommit.sh
index 98023e1..1af7dbf 100755
--- a/precommit.sh
+++ b/precommit.sh
@@ -1,6 +1,6 @@
 #!/bin/bash
 set -e
 
-yapf -ir -vv east_asian_spacing tests "$@"
-pytest
+yapf -ir -vv east_asian_spacing tests
+pytest -v
 pytype east_asian_spacing
diff --git a/pyproject.toml b/pyproject.toml
index 4409d57..1451506 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "east_asian_spacing"
-version = "1.1.3"
+version = "1.2.0.dev0"
 description = "East Asian Contextual Spacing Build Tools"
 authors = ["Koji Ishii <kojii@chromium.org>"]
 readme = "README.md"
diff --git a/references/meiryo.ttc-0.G_P_O_S_.ttx.diff b/references/meiryo.ttc-0.G_P_O_S_.ttx.diff
index f3e0114..526fa6f 100644
--- a/references/meiryo.ttc-0.G_P_O_S_.ttx.diff
+++ b/references/meiryo.ttc-0.G_P_O_S_.ttx.diff
@@ -289,7 +289,6 @@
 +        <!-- SubTableCount=1 -->
 +        <PairPos index="0" Format="2">
 +          <Coverage>
-+            <Glyph value="glyph00444"/>
 +            <Glyph value="uniFE11"/>
 +            <Glyph value="uniFE12"/>
 +            <Glyph value="uniFE36"/>
@@ -312,19 +311,18 @@
 +          <ClassDef1>
 +          </ClassDef1>
 +          <ClassDef2>
-+            <ClassDef glyph="glyph00418" class="1"/>
-+            <ClassDef glyph="glyph00444" class="1"/>
 +            <ClassDef glyph="glyph09251" class="1"/>
 +            <ClassDef glyph="glyph09252" class="1"/>
 +            <ClassDef glyph="glyph09304" class="1"/>
 +            <ClassDef glyph="glyph09305" class="1"/>
++            <ClassDef glyph="glyph09616" class="1"/>
++            <ClassDef glyph="glyph09622" class="1"/>
 +            <ClassDef glyph="glyph12997" class="1"/>
 +            <ClassDef glyph="glyph13035" class="1"/>
 +            <ClassDef glyph="glyph13036" class="1"/>
 +            <ClassDef glyph="glyph13037" class="1"/>
 +            <ClassDef glyph="glyph13038" class="1"/>
 +            <ClassDef glyph="glyph13069" class="1"/>
-+            <ClassDef glyph="glyph13070" class="1"/>
 +            <ClassDef glyph="glyph23942" class="1"/>
 +            <ClassDef glyph="glyph23943" class="1"/>
 +            <ClassDef glyph="uni2003" class="1"/>
@@ -368,7 +366,6 @@
 +        <!-- SubTableCount=1 -->
 +        <SinglePos index="0" Format="1">
 +          <Coverage>
-+            <Glyph value="glyph00418"/>
 +            <Glyph value="uniFE35"/>
 +            <Glyph value="uniFE39"/>
 +            <Glyph value="glyph09251"/>
@@ -382,7 +379,6 @@
 +            <Glyph value="glyph13035"/>
 +            <Glyph value="glyph13037"/>
 +            <Glyph value="glyph13069"/>
-+            <Glyph value="glyph13070"/>
 +            <Glyph value="uniFE17"/>
 +            <Glyph value="glyph23942"/>
 +          </Coverage>
@@ -397,7 +393,6 @@
 +        <ChainContextPos index="0" Format="3">
 +          <!-- BacktrackGlyphCount=1 -->
 +          <BacktrackCoverage index="0">
-+            <Glyph value="glyph00418"/>
 +            <Glyph value="uni2003"/>
 +            <Glyph value="uni30FB"/>
 +            <Glyph value="uniFE35"/>
@@ -410,17 +405,17 @@
 +            <Glyph value="uniFE43"/>
 +            <Glyph value="uniFE3B"/>
 +            <Glyph value="glyph09304"/>
++            <Glyph value="glyph09616"/>
++            <Glyph value="glyph09622"/>
 +            <Glyph value="glyph12997"/>
 +            <Glyph value="glyph13035"/>
 +            <Glyph value="glyph13037"/>
 +            <Glyph value="glyph13069"/>
-+            <Glyph value="glyph13070"/>
 +            <Glyph value="uniFE17"/>
 +            <Glyph value="glyph23942"/>
 +          </BacktrackCoverage>
 +          <!-- InputGlyphCount=1 -->
 +          <InputCoverage index="0">
-+            <Glyph value="glyph00418"/>
 +            <Glyph value="uniFE35"/>
 +            <Glyph value="uniFE39"/>
 +            <Glyph value="glyph09251"/>
@@ -434,7 +429,6 @@
 +            <Glyph value="glyph13035"/>
 +            <Glyph value="glyph13037"/>
 +            <Glyph value="glyph13069"/>
-+            <Glyph value="glyph13070"/>
 +            <Glyph value="uniFE17"/>
 +            <Glyph value="glyph23942"/>
 +          </InputCoverage>
diff --git a/references/meiryo.ttc-glyphs b/references/meiryo.ttc-glyphs
index c11e67d..5a26a68 100644
--- a/references/meiryo.ttc-glyphs
+++ b/references/meiryo.ttc-glyphs
@@ -43,7 +43,6 @@
 1567
 1568
 # vertical.left
-444
 9235
 9236
 9248
@@ -61,7 +60,6 @@
 16694
 23943
 # vertical.right
-418
 9247
 9249
 9251
@@ -75,10 +73,11 @@
 13035
 13037
 13069
-13070
 16693
 23942
 # vertical.middle
 1561
 1566
+9616
+9622
 12997
diff --git a/references/meiryo.ttc.tables.diff b/references/meiryo.ttc.tables.diff
index d5d8897..2f05b38 100644
--- a/references/meiryo.ttc.tables.diff
+++ b/references/meiryo.ttc.tables.diff
@@ -3,7 +3,7 @@
  Tag  Size      
  GDEF         54 [0, 1, 2, 3]
 -GPOS     29,870 [0, 1, 2, 3]
-+GPOS     29,662 [0, 1, 2, 3]
++GPOS     29,656 [0, 1, 2, 3]
  GSUB     57,962 [0, 1]
  GSUB     45,274 [2, 3]
  MERG         12 [0, 1, 2, 3]
@@ -14,7 +14,7 @@
 -Total: 9,516,836
 -Data: 9,515,272
 -Gap: 1,564
-+Total: 9,516,616
-+Data: 9,515,064
-+Gap: 1,552
++Total: 9,516,608
++Data: 9,515,058
++Gap: 1,550
  Tables: 41
diff --git a/scripts/build-noto-cjk.sh b/scripts/build-noto-cjk.sh
index af72f75..ec88f6a 100755
--- a/scripts/build-noto-cjk.sh
+++ b/scripts/build-noto-cjk.sh
@@ -1,5 +1,4 @@
 #!/bin/bash
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" &>/dev/null && pwd)"
-export BUILDER_NAME=noto_cjk_builder.py
 export LOG_NAME=${LOG_NAME:-noto-cjk.log}
 "$SCRIPT_DIR/build.sh" $*
diff --git a/scripts/build.sh b/scripts/build.sh
index e535b2c..0ef5350 100755
--- a/scripts/build.sh
+++ b/scripts/build.sh
@@ -2,8 +2,7 @@
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" &>/dev/null && pwd)"
 ROOT_DIR="$(cd "$SCRIPT_DIR/.." &>/dev/null && pwd)"
 PY_DIR="$(cd "$ROOT_DIR/east_asian_spacing" &>/dev/null && pwd)"
-BUILDER_NAME=${BUILDER_NAME:-builder.py}
-BUILDER=${BUILDER:-$PY_DIR/$BUILDER_NAME}
+BUILDER=${BUILDER:-$PY_DIR/builder.py}
 BUILD_DIR=${BUILD_DIR:-build}
 LOG_NAME=${LOG_NAME:-build.log}
 LOG=${LOG:-$BUILD_DIR/log/$LOG_NAME}
diff --git a/tests/config_test.py b/tests/config_test.py
index 64b3838..7ba05b6 100644
--- a/tests/config_test.py
+++ b/tests/config_test.py
@@ -4,7 +4,6 @@
 from east_asian_spacing import CollectionConfig
 from east_asian_spacing import Config
 from east_asian_spacing import EastAsianSpacingTester
-from east_asian_spacing import NotoCJKConfig
 
 
 @pytest.mark.asyncio
@@ -54,24 +53,21 @@ def call(num_fonts, indices, language):
 def test_config_for_font_name():
     config = Config.default
 
-    meiryo = config.for_font_name('Meiryo', False)
-    assert meiryo is not config
-    assert meiryo.language == 'JAN'
-
     # Unknown fonts should use the default config.
     assert config.for_font_name('never exists', False) is config
 
 
-def test_noto_cjk_config_for_font_name():
-    config = NotoCJKConfig.default
-
-    noto_cjk_jp = config.for_font_name('Noto Sans CJK JP', False)
-    assert noto_cjk_jp is not config
-    assert noto_cjk_jp.language == 'JAN'
-
-    # 'Mono' fonts should be not applicable.
-    assert config.for_font_name('Noto Sans Mono CJK JP', False) is None
-
-    # `NotoCJKConfig` is only for Noto fonts.
-    with pytest.raises(AssertionError):
-        config.for_font_name('Meiryo', False)
+def test_config_for_language():
+    config = Config.default
+    assert config.use_ink_bounds
+    assert not config.language
+
+    # `for_language` should clone and set the langauge.
+    jan = config.for_language('JAN')
+    assert jan is not config
+    assert jan.language == 'JAN'
+    assert not jan.use_ink_bounds
+
+    # The original `config` should not be modified.
+    assert config.use_ink_bounds
+    assert not config.language
diff --git a/tests/full_test.py b/tests/full_test.py
index 027f35d..91dd0c4 100644
--- a/tests/full_test.py
+++ b/tests/full_test.py
@@ -1,10 +1,8 @@
 import logging
-import pathlib
 import pytest
-import tempfile
 
 from east_asian_spacing import Dump
-from east_asian_spacing import NotoCJKBuilder
+from east_asian_spacing import Builder
 
 logger = logging.getLogger(__name__)
 
@@ -21,7 +19,7 @@ async def test_build_and_diff(test_font_path, refs_dir, tmp_path):
     ```
     and if there were any differences, update the reference files.
     """
-    builder = NotoCJKBuilder(test_font_path)
+    builder = Builder(test_font_path)
     await builder.build()
     out_path = builder.save(tmp_path)
 
@@ -39,6 +37,6 @@ async def test_build_and_diff(test_font_path, refs_dir, tmp_path):
 
     # Try to build against the `out_path`.
     # This should not add anything because the features already exist.
-    builder2 = NotoCJKBuilder(out_path)
+    builder2 = Builder(out_path)
     await builder2.build()
     assert not builder2.has_spacings
diff --git a/tests/shaper_test.py b/tests/shaper_test.py
index 3dc75d3..0d0199b 100644
--- a/tests/shaper_test.py
+++ b/tests/shaper_test.py
@@ -1,4 +1,10 @@
+from east_asian_spacing.shaper import InkPartMargin
+import pytest
+
+from east_asian_spacing import Font
+from east_asian_spacing import InkPart
 from east_asian_spacing import GlyphData
+from east_asian_spacing import Shaper
 from east_asian_spacing import ShapeResult
 
 
@@ -16,3 +22,41 @@ def test_glyph_data_eq():
     glyph3.advance = 500
     assert glyph1 != glyph3
     assert result1 != result2
+
+
+def test_compute_ink_part():
+    from east_asian_spacing.shaper import _compute_ink_part
+    assert _compute_ink_part(0, 499, 0, 1000) == InkPart.LEFT
+    assert _compute_ink_part(501, 1000, 0, 1000) == InkPart.RIGHT
+    assert _compute_ink_part(251, 749, 0, 1000) == InkPart.MIDDLE
+
+
+def test_compute_ink_part_margin():
+    from east_asian_spacing.shaper import _compute_ink_part
+    # Meiryo vertical U+FF5D
+    assert _compute_ink_part(-1613, -772, -1798, 250) == InkPart.OTHER
+    with InkPartMargin(2):
+        assert _compute_ink_part(-1613, -772, -1798, 250) == InkPart.LEFT
+
+
+@pytest.mark.asyncio
+async def test_ink_part(test_font_path):
+    font = Font.load(test_font_path)
+    shaper = Shaper(font)
+    await shaper.compute_fullwidth_advance()
+    result = await shaper.shape('\uFF08\uFF09\u30FB\u56DB')
+    result.compute_ink_parts(font)
+    assert result[0].ink_part == InkPart.RIGHT
+    assert result[1].ink_part == InkPart.LEFT
+    assert result[2].ink_part == InkPart.MIDDLE
+    assert result[3].ink_part == InkPart.OTHER
+
+    font = font.vertical_font
+    shaper = Shaper(font, features=['vert'])
+    await shaper.compute_fullwidth_advance()
+    result = await shaper.shape('\uFF08\uFF09\u30FB\u56DB')
+    result.compute_ink_parts(font)
+    assert result[0].ink_part == InkPart.RIGHT
+    assert result[1].ink_part == InkPart.LEFT
+    assert result[2].ink_part == InkPart.MIDDLE
+    assert result[3].ink_part == InkPart.OTHER
diff --git a/tox.ini b/tox.ini
index 269df24..15264b8 100644
--- a/tox.ini
+++ b/tox.ini
@@ -12,4 +12,4 @@ deps =
     pytest-asyncio
 # change pytest tempdir and add posargs from command line
 commands =
-    pytest -v --basetemp="{envtmpdir}" {posargs}
+    pytest --basetemp="{envtmpdir}" {posargs}