cleome 0.3.0__tar.gz

cleome-0.3.0/.agents/docs/css-and-metadata.md

@@ -0,0 +1,16 @@
+# `@font-face` CSS generation, variable axes, and variant bundling
+
+Domain rules for extracting font metadata ([`cleome/metadata.py`](../../src/cleome/metadata.py)), generating `@font-face` stylesheets ([`cleome/css.py`](../../src/cleome/css.py)), and orchestrating cached multi-variant builds ([`cleome/pipeline.py`](../../src/cleome/pipeline.py)) across variable and static fonts.
+
+## Variable and static axis mapping
+
+* `extract_font_face_descriptors` and `extract_font_metadata` (`cleome/metadata.py`) extract `font-weight`, `font-stretch`, and `font-style` descriptors from `fvar` axes (`wght`, `wdth`, `ital`, `slnt`) for variable fonts, and from `OS/2` (`usWeightClass`, `usWidthClass`, `fsSelection`) and `post` (`italicAngle`) tables for static fonts.
+* When a variable font includes `ital`, `slnt`, or both axes, `generate_css` (`cleome/css.py`) emits `@font-face` rules for each supported style (`normal`, `italic`, `oblique ...`) pointing to the same `.woff2` slice files. Emit `font-style: normal` only when the font's axis ranges include an upright form (`ital < 0.5` and `0deg` within `slnt`).
+
+## Multi-font variant bundling and content-hashed filenames
+
+* `validate_and_compute_variant_suffixes` (`cleome/metadata.py`) validates that bundling multiple font files into one stylesheet shares a common `font-family` name (unless overridden) and a unique `(font-weight, font-stretch, font-style)` descriptor tuple for every emitted rule.
+* Raise a `ValueError` on family mismatches or descriptor collisions rather than auto-numbering colliding variants or filenames (`-2`, `-3`).
+* When bundled variants have different `cmap` coverage, `slice_fonts` (`cleome/pipeline.py`) builds and exports each variant's slices from its own mapped codepoints rather than the cross-font union.
+* When `SliceConfig.filename_hash` is `True` (default), `_subset_single_slice_worker` (`cleome/subsetter.py`) appends an 8-character SHA-256 hex digest of the built `.woff2` bytes (`<slug>(-<variant>)-<slice_id>-<hash8>.woff2`), `_export_woff2_slices_batch` prunes superseded hashes for the built stems, and `_try_load_cached_bundle` (`cleome/pipeline.py`) verifies the on-disk filename hash against the `.woff2` content.
+* `slice_font` and `slice_fonts` (`cleome/pipeline.py`, `--css-out` in `cleome/cli.py`) accept an explicit `css_path` file path so consumers can write the `@font-face` stylesheet outside `out_dir` (such as `src/styles/fonts.css` while `out_dir` is `public/fonts`); `css_filename` and `css_path` are mutually exclusive.

cleome-0.3.0/.agents/docs/subsetting-and-shaping.md

@@ -0,0 +1,20 @@
+# WOFF2 subsetting, OpenType shaping, and slicing tiers
+
+Domain rules for `unicode-range` formatting and compaction ([`cleome/urange.py`](../../src/cleome/urange.py)), the 4-tier slicing planner ([`cleome/slicer.py`](../../src/cleome/slicer.py)), and the WOFF2 subsetting pipeline ([`cleome/subsetter.py`](../../src/cleome/subsetter.py)).
+
+## CSS cascade shadowing and range compaction
+
+* Cleome orders `@font-face` declarations from lowest priority (Tier 4 rare ideographs and syllables, using 1-token hex ranges) to highest priority (Tier 1 core phonetic blocks and Latin).
+* When compacting `unicode-range` intervals in an earlier tier with `compact_unicode_range` (`cleome/urange.py`), bridge only across unmapped gaps or codepoints shadowed by a higher-priority tier declared later in the stylesheet.
+* Never bridge `unicode-range` tokens across different Unicode planes (such as Plane 2 SIP and Plane 3 TIP).
+
+## Intra-slice OpenType shaping
+
+* `fontTools.subset` prunes multi-glyph `GSUB` and `GPOS` lookups (`ccmp`, `mark`, `mkmk`, `liga`, `kern`, `chws`, `vchw`, `ljmo`, `vjmo`, `tjmo`) whenever any participating glyph is absent from the slice.
+* Keep base characters and their combining marks or paired brackets in the same tier and slice (Latin combining marks with `latin`, voiced Kana marks with `kana-core`, Conjoining and Compatibility Hangul Jamo with `hangul-core`, and Bopomofo letters plus tone marks `U+02C7`, `U+02C9-02CB`, `U+02D9` with `cjk-core`) so composition and contextual positioning lookups survive subsetting.
+* Verify changes to character partitioning or subsetting options with HarfBuzz (`uharfbuzz`) shaping assertions before and after slicing.
+
+## UVS and IVS (`cmap` Format 14) handling
+
+* Retain `cmap` Format 14 variation selector mappings (both default and non-default UVS and IVS) and their variant glyphs for all base characters included in a slice (`_prepare_uvs_for_slice` in `cleome/subsetter.py`), without leaking standalone variation selector codepoints into the slice's base Format 4 or Format 12 `cmap`.
+* Keep Format 14 sequence retention separate from `patch_uvs_missing_base_cmap` (`cleome/metadata.py`, re-exported by `cleome/subsetter.py`), which recovers characters that upstream fonts mapped in Format 14 but omitted from Format 4 and Format 12.

cleome-0.3.0/.gitignore

@@ -0,0 +1,10 @@
+__pycache__/
+*.py[cod]
+*$py.class
+.venv/
+dist/
+build/
+*.egg-info/
+.pytest_cache/
+.ruff_cache/
+.DS_Store

cleome-0.3.0/AGENTS.md

@@ -0,0 +1,23 @@
+# Cleome
+
+Cleome (`cleome`) is a Python (`>= 3.15`) CLI tool and library that inspects Japanese, Korean, and Chinese (`jp`, `kr`, `sc`, `tc`, `hk`) variable and static fonts (`.ttf` / `.otf`) and generates 4-tier `unicode-range` `.woff2` slices and `@font-face` CSS using CSS cascade shadowing and inverted-pyramid frequency granularity.
+
+## Commands
+
+* Install dependencies (`uharfbuzz`): `uv sync`
+* Run test suite (`unittest` + HarfBuzz shaping verification, fail-fast): `uv run python -m unittest discover -s tests -v -f`
+* Preview a 4-tier slice plan without writing files (read-only): `uv run cleome plan <font.ttf> [--json]`
+* Build `.woff2` slices and `@font-face` CSS: `uv run cleome build <font.ttf> -o dist/ [--css-out <path.css>] [--no-filename-hash] [--dry-run]`
+
+## Architecture and invariants
+
+* **Entrypoint guard (`spawn` / `forkserver`).** Guard runnable scripts and `README.md` or `skills/cleome/SKILL.md` Python examples with `if __name__ == "__main__":`, and pass worker configuration through process pool initializer arguments rather than module globals.
+* **Deterministic, non-destructive font handling.** Open fonts with `recalcTimestamp=False` so repeated builds produce byte-identical `.woff2` files, retain license records (`nameID` `0`, `13`, `14`) in every slice, and never mutate caller-supplied `TTFont` objects in public slicing APIs.
+* **CSS serialization via Stixis.** Delegate `@font-face` AST validation, PEP 750 `Template` (`t"..."`) escaping, and `<urange>` parsing, formatting, and compaction to `stixis` (`SerializationOptions.cleome()`) rather than formatting raw CSS strings by hand.
+* **CLI contract.** `cleome plan` (`src/cleome/cli.py`) is read-only and never creates output directories or imports subsetting workers. Never mix `nargs="*"` or `"+"` optional flags with positional arguments.
+* **Public API sync.** When changing public APIs, CLI flags, or slicing behavior, update [`skills/cleome/SKILL.md`](skills/cleome/SKILL.md), `README.md`, and the relevant guide under `.agents/docs/`.
+
+## Domain guides
+
+* Read [.agents/docs/subsetting-and-shaping.md](.agents/docs/subsetting-and-shaping.md) when modifying `unicode-range` compaction (`src/cleome/urange.py`), the 4-tier slicing planner (`src/cleome/slicer.py`), locale detection (`src/cleome/locale.py`), or `fontTools.subset` and `cmap` Format 14 UVS handling (`src/cleome/subsetter.py`).
+* Read [.agents/docs/css-and-metadata.md](.agents/docs/css-and-metadata.md) when modifying OpenType descriptor extraction (`src/cleome/metadata.py`), `@font-face` stylesheet generation (`src/cleome/css.py`), or cached multi-variant bundling (`src/cleome/pipeline.py`).

cleome-0.3.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 矢倉 眞隆 (Masataka Yakura)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

cleome-0.3.0/PKG-INFO

@@ -0,0 +1,164 @@
+Metadata-Version: 2.5
+Name: cleome
+Version: 0.3.0
+Summary: Dynamic unicode-range WOFF2 slicer and @font-face CSS generator for Japanese, Korean, and Chinese web fonts
+Project-URL: Homepage, https://github.com/myakura/cleome
+Project-URL: Repository, https://github.com/myakura/cleome.git
+Project-URL: Issues, https://github.com/myakura/cleome/issues
+Author-email: Masataka Yakura <masataka.yakura@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: cjk,font-face,opentype,subsetting,unicode-range,variable-fonts,webfont,woff2
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.15
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Multimedia :: Graphics :: Editors :: Vector-Based
+Classifier: Topic :: Text Processing :: Fonts
+Classifier: Typing :: Typed
+Requires-Python: >=3.15
+Requires-Dist: brotli>=1.2.1
+Requires-Dist: fonttools[woff]>=4.67.0
+Requires-Dist: stixis>=0.1.1
+Description-Content-Type: text/markdown
+
+# Cleome
+
+Cleome is a Python CLI tool and library that slices Japanese, Korean, and Chinese (`JP` / `KR` / `SC` / `TC` / `HK`) variable and static fonts (`.ttf` / `.otf`) into `unicode-range` `.woff2` files and `@font-face` CSS.
+
+Cleome inspects a font's `cmap` once and writes deterministic static assets instead of scanning page HTML on every site deploy. You can host the generated `.woff2` chunks and `@font-face` stylesheet directly from Next.js, Astro, Fontsource, or any static CDN. Compared to Google Fonts' static slicing templates, Cleome produces smaller stylesheets and transfers fewer `.woff2` bytes while keeping OpenType layout features, UVS/IVS variation sequences, and variable font axes intact.
+
+---
+
+
+## Installation
+
+Requires Python `>= 3.15` and [`uv`](https://docs.astral.sh/uv/).
+
+```bash
+# Install as a standalone CLI tool from GitHub
+uv tool install git+https://github.com/myakura/cleome
+
+# Or run directly without installing
+uvx --from git+https://github.com/myakura/cleome cleome plan SourceHanSansJP-VF.otf
+
+# Or add to a Python project
+uv add git+https://github.com/myakura/cleome
+```
+
+---
+
+
+## CLI usage
+
+```bash
+# Preview the dynamic 4-tier slice plan without writing files (read-only)
+cleome plan SourceHanSansJP-VF.otf
+cleome plan SourceHanSansJP-VF.otf --json
+
+# Slice a Variable Font (auto-detects CJK profile; outputs <out-dir>/<slug>.css and <out-dir>/slices/<slug>-*-<hash8>.woff2)
+# Subsequent builds with unchanged inputs/config skip WOFF2 subsetting automatically; pass --force to rebuild
+# Pass --dry-run to validate inputs and output paths without creating directories or writing files
+# Pass --css-out to write the stylesheet to src/styles/ while keeping .woff2 slices in public/fonts/
+# Pass --no-filename-hash when placing slices in a bundler-managed directory that adds its own asset hash
+cleome build SourceHanSansJP-VF.otf -o dist/web
+cleome build SourceHanSansJP-VF.otf -o dist/web --dry-run
+cleome build SourceHanSansJP-VF.otf -o dist/web --force
+cleome build SourceHanSansJP-VF.otf -o public/fonts --url-prefix "/fonts/slices" --css-out src/styles/fonts.css
+cleome build SourceHanSansJP-VF.otf -o src/assets/fonts --no-filename-hash
+
+# Explicitly select a CJK slicing profile (auto, jp, kr, sc, tc, hk)
+cleome build SourceHanSansJP-VF.otf --locale jp -o dist/web-jp
+cleome build NotoSansKR-VF.ttf --locale kr -o dist/web-kr
+
+# Slice multiple Static Font weights into a single unified @font-face CSS and slices/ directory
+cleome build MyFontJP-Regular.ttf MyFontJP-Bold.ttf -o dist/web-static
+
+# Customize CSS font-family, URL prefix, chunk sizes, or retained OpenType layout features
+# Note: --layout-features replaces the entire feature list (default is '*' for all features),
+# so include vertical writing (vert,vrt2,vpal,vhal,vkrn) and composition (ccmp,locl) tags if needed.
+cleome build MyFont-VF.otf -o dist/web \
+  --locale jp \
+  --family "My Font JP" \
+  --slug "my-font-jp" \
+  --url-prefix "/assets/fonts/slices" \
+  --rare-chunk-size 250 \
+  --layout-features "ccmp,locl,kern,mark,mkmk,liga,palt,halt,vpal,vhal,vkrn,vert,vrt2,ruby"
+```
+
+---
+
+
+## Python API usage
+
+Call `slice_font` or `slice_fonts` from a build script with either file paths or in-memory `fontTools.ttLib.TTFont` objects. Cleome does not mutate caller-supplied `TTFont` instances.
+
+When `workers > 1` (the default), Cleome runs subsetting in a `ProcessPoolExecutor`. On platforms that use `spawn` or `forkserver` (`macOS`, `Windows`, and `Linux` on Python 3.14+), guard top-level scripts with `if __name__ == "__main__":` or pass `workers=1`.
+
+```python
+from pathlib import Path
+from cleome import SliceConfig, slice_font, slice_fonts
+
+if __name__ == "__main__":
+    # 1. Slice a Variable Font (path or in-memory TTFont; locale="auto" by default)
+    result = slice_font(
+        "SourceHanSansJP-VF.otf",
+        out_dir=Path("dist/web"),
+        config=SliceConfig(
+            locale="auto",  # "auto", "jp", "kr", "sc", "tc", or "hk"
+            slices_subdir="slices",
+            rare_chunk_size=250,
+        ),
+    )
+    print(f"Generated {result.css_path} and {len(result.built_files)} WOFF2 slices")
+
+    # 2. Slice multiple Static Font weights into a unified stylesheet
+    static_result = slice_fonts(
+        [
+            "MyFontJP-Regular.ttf",
+            "MyFontJP-Bold.ttf",
+        ],
+        out_dir=Path("dist/web-static"),
+        family_name="My Font JP",
+    )
+```
+
+---
+
+
+## Development and testing
+
+```bash
+uv sync
+uv run python -m unittest discover -s tests -v -f
+```
+
+---
+
+
+## Documentation
+
+* [Hosting and usage guide](docs/hosting-and-usage.md) explains how to deploy generated `<slug>.css` and `.woff2` slices on static hosts, bundlers, and CDNs, configure `--url-prefix` and `--slices-dir`, and set preload, CORS, and `Cache-Control` headers.
+* [Architecture and rationale](docs/architecture-and-rationale.md) explains the 4-tier cascade shadowing design, inverted-pyramid Kanji granularity simulations, OpenType subsetting details, and the issues found in Google Fonts' Japanese delivery.
+* [Chinese and Korean (`KR` / `SC` / `TC` / `HK`) slicing analysis](docs/cjk-slicing-analysis.md) covers Google Fonts' Korean and Chinese (`SC`, `TC`, `HK`) slice templates, ghost `unicode-range` rules, punctuation, Jamo, and Bopomofo splits, and 4-tier simulation results.
+
+---
+
+
+## Acknowledgments
+
+* [Google Fonts](https://fonts.google.com/) published the production stylesheets, slice definitions (`gfsubsets` / `nam-files`), and corpus frequency data analyzed during this project.
+* [Noto Sans Japanese (`Noto Sans JP`)](https://fonts.google.com/noto/specimen/Noto+Sans+JP) and [Source Han Sans (`源ノ角ゴシック`)](https://github.com/adobe-fonts/source-han-sans) were the primary Japanese typefaces used to test and verify Cleome.
+* [fontTools](https://github.com/fonttools/fonttools) handles OpenType table inspection, `cmap`, `GSUB`, and `GPOS` subsetting (`fontTools.subset`), and WOFF2 packing.
+* [Brotli](https://github.com/google/brotli) compresses and decompresses the WOFF2 streams.
+* [HarfBuzz](https://github.com/harfbuzz/harfbuzz) and [uharfbuzz](https://github.com/harfbuzz/uharfbuzz) verify OpenType glyph shaping, `cmap` Format 14 variation sequences, and combining mark composition (`ccmp`) in the test suite.
+* [Stixis](https://github.com/myakura/stixis) validates and serializes the generated `@font-face` CSS rules and `unicode-range` descriptors.
+
+---
+
+
+## License
+
+[MIT License](LICENSE)

cleome-0.3.0/README.md

@@ -0,0 +1,138 @@
+# Cleome
+
+Cleome is a Python CLI tool and library that slices Japanese, Korean, and Chinese (`JP` / `KR` / `SC` / `TC` / `HK`) variable and static fonts (`.ttf` / `.otf`) into `unicode-range` `.woff2` files and `@font-face` CSS.
+
+Cleome inspects a font's `cmap` once and writes deterministic static assets instead of scanning page HTML on every site deploy. You can host the generated `.woff2` chunks and `@font-face` stylesheet directly from Next.js, Astro, Fontsource, or any static CDN. Compared to Google Fonts' static slicing templates, Cleome produces smaller stylesheets and transfers fewer `.woff2` bytes while keeping OpenType layout features, UVS/IVS variation sequences, and variable font axes intact.
+
+---
+
+
+## Installation
+
+Requires Python `>= 3.15` and [`uv`](https://docs.astral.sh/uv/).
+
+```bash
+# Install as a standalone CLI tool from GitHub
+uv tool install git+https://github.com/myakura/cleome
+
+# Or run directly without installing
+uvx --from git+https://github.com/myakura/cleome cleome plan SourceHanSansJP-VF.otf
+
+# Or add to a Python project
+uv add git+https://github.com/myakura/cleome
+```
+
+---
+
+
+## CLI usage
+
+```bash
+# Preview the dynamic 4-tier slice plan without writing files (read-only)
+cleome plan SourceHanSansJP-VF.otf
+cleome plan SourceHanSansJP-VF.otf --json
+
+# Slice a Variable Font (auto-detects CJK profile; outputs <out-dir>/<slug>.css and <out-dir>/slices/<slug>-*-<hash8>.woff2)
+# Subsequent builds with unchanged inputs/config skip WOFF2 subsetting automatically; pass --force to rebuild
+# Pass --dry-run to validate inputs and output paths without creating directories or writing files
+# Pass --css-out to write the stylesheet to src/styles/ while keeping .woff2 slices in public/fonts/
+# Pass --no-filename-hash when placing slices in a bundler-managed directory that adds its own asset hash
+cleome build SourceHanSansJP-VF.otf -o dist/web
+cleome build SourceHanSansJP-VF.otf -o dist/web --dry-run
+cleome build SourceHanSansJP-VF.otf -o dist/web --force
+cleome build SourceHanSansJP-VF.otf -o public/fonts --url-prefix "/fonts/slices" --css-out src/styles/fonts.css
+cleome build SourceHanSansJP-VF.otf -o src/assets/fonts --no-filename-hash
+
+# Explicitly select a CJK slicing profile (auto, jp, kr, sc, tc, hk)
+cleome build SourceHanSansJP-VF.otf --locale jp -o dist/web-jp
+cleome build NotoSansKR-VF.ttf --locale kr -o dist/web-kr
+
+# Slice multiple Static Font weights into a single unified @font-face CSS and slices/ directory
+cleome build MyFontJP-Regular.ttf MyFontJP-Bold.ttf -o dist/web-static
+
+# Customize CSS font-family, URL prefix, chunk sizes, or retained OpenType layout features
+# Note: --layout-features replaces the entire feature list (default is '*' for all features),
+# so include vertical writing (vert,vrt2,vpal,vhal,vkrn) and composition (ccmp,locl) tags if needed.
+cleome build MyFont-VF.otf -o dist/web \
+  --locale jp \
+  --family "My Font JP" \
+  --slug "my-font-jp" \
+  --url-prefix "/assets/fonts/slices" \
+  --rare-chunk-size 250 \
+  --layout-features "ccmp,locl,kern,mark,mkmk,liga,palt,halt,vpal,vhal,vkrn,vert,vrt2,ruby"
+```
+
+---
+
+
+## Python API usage
+
+Call `slice_font` or `slice_fonts` from a build script with either file paths or in-memory `fontTools.ttLib.TTFont` objects. Cleome does not mutate caller-supplied `TTFont` instances.
+
+When `workers > 1` (the default), Cleome runs subsetting in a `ProcessPoolExecutor`. On platforms that use `spawn` or `forkserver` (`macOS`, `Windows`, and `Linux` on Python 3.14+), guard top-level scripts with `if __name__ == "__main__":` or pass `workers=1`.
+
+```python
+from pathlib import Path
+from cleome import SliceConfig, slice_font, slice_fonts
+
+if __name__ == "__main__":
+    # 1. Slice a Variable Font (path or in-memory TTFont; locale="auto" by default)
+    result = slice_font(
+        "SourceHanSansJP-VF.otf",
+        out_dir=Path("dist/web"),
+        config=SliceConfig(
+            locale="auto",  # "auto", "jp", "kr", "sc", "tc", or "hk"
+            slices_subdir="slices",
+            rare_chunk_size=250,
+        ),
+    )
+    print(f"Generated {result.css_path} and {len(result.built_files)} WOFF2 slices")
+
+    # 2. Slice multiple Static Font weights into a unified stylesheet
+    static_result = slice_fonts(
+        [
+            "MyFontJP-Regular.ttf",
+            "MyFontJP-Bold.ttf",
+        ],
+        out_dir=Path("dist/web-static"),
+        family_name="My Font JP",
+    )
+```
+
+---
+
+
+## Development and testing
+
+```bash
+uv sync
+uv run python -m unittest discover -s tests -v -f
+```
+
+---
+
+
+## Documentation
+
+* [Hosting and usage guide](docs/hosting-and-usage.md) explains how to deploy generated `<slug>.css` and `.woff2` slices on static hosts, bundlers, and CDNs, configure `--url-prefix` and `--slices-dir`, and set preload, CORS, and `Cache-Control` headers.
+* [Architecture and rationale](docs/architecture-and-rationale.md) explains the 4-tier cascade shadowing design, inverted-pyramid Kanji granularity simulations, OpenType subsetting details, and the issues found in Google Fonts' Japanese delivery.
+* [Chinese and Korean (`KR` / `SC` / `TC` / `HK`) slicing analysis](docs/cjk-slicing-analysis.md) covers Google Fonts' Korean and Chinese (`SC`, `TC`, `HK`) slice templates, ghost `unicode-range` rules, punctuation, Jamo, and Bopomofo splits, and 4-tier simulation results.
+
+---
+
+
+## Acknowledgments
+
+* [Google Fonts](https://fonts.google.com/) published the production stylesheets, slice definitions (`gfsubsets` / `nam-files`), and corpus frequency data analyzed during this project.
+* [Noto Sans Japanese (`Noto Sans JP`)](https://fonts.google.com/noto/specimen/Noto+Sans+JP) and [Source Han Sans (`源ノ角ゴシック`)](https://github.com/adobe-fonts/source-han-sans) were the primary Japanese typefaces used to test and verify Cleome.
+* [fontTools](https://github.com/fonttools/fonttools) handles OpenType table inspection, `cmap`, `GSUB`, and `GPOS` subsetting (`fontTools.subset`), and WOFF2 packing.
+* [Brotli](https://github.com/google/brotli) compresses and decompresses the WOFF2 streams.
+* [HarfBuzz](https://github.com/harfbuzz/harfbuzz) and [uharfbuzz](https://github.com/harfbuzz/uharfbuzz) verify OpenType glyph shaping, `cmap` Format 14 variation sequences, and combining mark composition (`ccmp`) in the test suite.
+* [Stixis](https://github.com/myakura/stixis) validates and serializes the generated `@font-face` CSS rules and `unicode-range` descriptors.
+
+---
+
+
+## License
+
+[MIT License](LICENSE)