@thomas.f/prnext 0.1.19-alpha → 0.1.21-alpha

package/vendor/fontkit/licenses/@swc__helpers/LICENSE

@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright 2024 SWC contributors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/vendor/fontkit/licenses/base64-js/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Jameson Little
+
+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.

package/vendor/fontkit/licenses/brotli/readme.md

@@ -0,0 +1,61 @@
+# Brotli.js
+
+Brotli.js is port of the [Brotli](http://tools.ietf.org/html/draft-alakuijala-brotli-01) compression algorithm (as used in the [WOFF2](http://www.w3.org/TR/WOFF2/) font format) to JavaScript. The decompressor is hand ported, and the compressor is ported
+with Emscripten.  The original C++ source code can be found [here](http://github.com/google/brotli).
+
+## Installation and usage
+
+Install using npm.
+
+    npm install brotli
+
+If you want to use brotli in the browser, you should use [Browserify](http://browserify.org/) to build it.
+
+In node, or in browserify, you can load brotli in the standard way:
+
+```javascript
+var brotli = require('brotli');
+```
+
+You can also require just the `decompress` function or just the `compress` function, which is useful for browserify builds.
+For example, here's how you'd require just the `decompress` function.
+
+```javascript
+var decompress = require('brotli/decompress');
+```
+
+## API
+
+### brotli.decompress(buffer, [outSize])
+
+Decompresses the given buffer to produce the original input to the compressor.
+The `outSize` parameter is optional, and will be computed by the decompressor
+if not provided. Inside a WOFF2 file, this can be computed from the WOFF2 directory.
+
+```javascript
+// decode a buffer where the output size is known
+brotli.decompress(compressedData, uncompressedLength);
+
+// decode a buffer where the output size is not known
+brotli.decompress(fs.readFileSync('compressed.bin'));
+```
+
+### brotli.compress(buffer, isText = false)
+
+Compresses the given buffer. Pass optional parameters as the second argument.
+
+```javascript
+// encode a buffer of binary data
+brotli.compress(fs.readFileSync('myfile.bin'));
+
+// encode some data with options (default options shown)
+brotli.compress(fs.readFileSync('myfile.bin'), {
+  mode: 0, // 0 = generic, 1 = text, 2 = font (WOFF2)
+  quality: 11, // 0 - 11
+  lgwin: 22 // window size
+});
+```
+
+## License
+
+MIT

package/vendor/fontkit/licenses/clone/LICENSE

@@ -0,0 +1,18 @@
+Copyright © 2011-2015 Paul Vorbach <paul@vorba.ch>
+
+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, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/vendor/fontkit/licenses/dfa/README.md

@@ -0,0 +1,83 @@
+# dfa
+
+Compiles a regular expression like syntax to fast deterministic finite automata.
+Useful for pattern matching against non-string sequences.
+
+## Example
+
+This example matches [Hangul](https://en.wikipedia.org/wiki/Hangul) syllables. The symbols defined in the machine are Unicode character categories which could be mapped from code points.
+
+Machine definition:
+
+```coffeescript
+# define symbols
+X   = 0; # Other character
+L   = 1; # Leading consonant
+V   = 2; # Medial vowel
+T   = 3; # Trailing consonant
+LV  = 4; # Composed <LV> syllable
+LVT = 5; # Composed <LVT> syllable
+M   = 6; # Tone mark
+
+# define variables
+decomposed = L V T?;
+partial = LV T?;
+composed = LVT;
+
+# define main state machine pattern
+main = (decomposed | partial | composed) M?;
+```
+
+Visualized, the machine looks like this (double circles are accepting states):
+
+![dfa](https://cloud.githubusercontent.com/assets/19409/19143719/8fbc6a12-8b5a-11e6-868d-99621644d094.png)
+
+Compiling and using the machine:
+
+```javascript
+import compile from 'dfa/compile';
+import fs from 'fs';
+
+let stateMachine = compile(fs.readFileSync('hangul.machine', 'utf8'));
+
+// find matches
+for (let [startIndex, endIndex] of stateMachine.match([0, 1, 2, 3, 0, 4, 6]) {
+  console.log('match:', startIndex, endIndex);
+}
+```
+
+Output:
+```
+match: 1 3
+match: 5 6
+```
+
+## Syntax
+
+A state machine file contains a list of assignment statements. Comments are also allowed
+and are started with the `#` character. Each statement is an assignment of a variable name
+to a value or expression. Assigning a variable to a number produces a symbol, which is
+added to the state machine's alphabet. Assigning a variable to an expression allows
+for substitutions into later expressions. The special `main` variable should always be
+assigned to at the end of the file, and is the final expression that will be compiled.
+
+A subset of common regular expression syntax is supported. A list of operators and their
+precedence is below. Operators with the same precedence are evaluated left to right.
+
+| Precedence | Syntax     | Type          | Meaning                                    |
+| ---------- | ---------- | --------------| ------------------------------------------ |
+| 1          | `a \| b`   | Alternation   | Matches either `a` or `b`                  |
+| 2          | `a b`      | Concatenation | Matches `a` followed by `b`                |
+| 3          | `a*`       | Repetition    | Matches zero or more occurrences of `a`    |
+| 3          | `a+`       | Repetition    | Matches one ore more occurrences of `a`    |
+| 3          | `a?`       | Optional      | Matches zero or one occurrence of `a`      |
+| 3          | `a{n}`     | Repetition    | Matches exactly n occurrences of `a`       |
+| 3          | `a{n,}`    | Repetition    | Matches n or more occurrences of `a`       |
+| 3          | `a{,n}`    | Repetition    | Matches up to n occurrences of `a`         |
+| 3          | `a{n,m}`   | Repetition    | Matches n to m occurrences of `a`          |
+| 4          | `t:<expr>` | Tag           | Tags the following expression with tag `t` |
+| 5          | `(<expr>)` | Grouping      | Groups an expression                       |
+
+## License
+
+MIT

package/vendor/fontkit/licenses/fast-deep-equal/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Evgeny Poberezkin
+
+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.

package/vendor/fontkit/licenses/fontkit/README.md

@@ -0,0 +1,266 @@
+# fontkit
+
+Fontkit is an advanced font engine for Node and the browser, used by [PDFKit](https://github.com/devongovett/pdfkit). It supports many font formats, advanced glyph substitution and layout features, glyph path extraction, color emoji glyphs, font subsetting, and more.
+
+## Features
+
+* Supports TrueType (.ttf), OpenType (.otf), WOFF, WOFF2, TrueType Collection (.ttc), and Datafork TrueType (.dfont) font files
+* Supports mapping characters to glyphs, including support for ligatures and other advanced substitutions (see below)
+* Supports reading glyph metrics and laying out glyphs, including support for kerning and other advanced layout features (see below)
+* Advanced OpenType features including glyph substitution (GSUB) and positioning (GPOS)
+* Apple Advanced Typography (AAT) glyph substitution features (morx table)
+* Support for getting glyph vector paths and converting them to SVG paths, or rendering them to a graphics context
+* Supports TrueType (glyf) and PostScript (CFF) outlines
+* Support for color glyphs (e.g. emoji), including Apple’s SBIX table, and Microsoft’s COLR table
+* Support for AAT variation glyphs, allowing for nearly infinite design control over weight, width, and other axes.
+* Font subsetting support - create a new font including only the specified glyphs
+
+## Installation
+
+    npm install fontkit
+
+## Example
+
+```javascript
+var fontkit = require('fontkit');
+
+// open a font synchronously
+var font = fontkit.openSync('font.ttf');
+
+// layout a string, using default shaping features.
+// returns a GlyphRun, describing glyphs and positions.
+var run = font.layout('hello world!');
+
+// get an SVG path for a glyph
+var svg = run.glyphs[0].path.toSVG();
+
+// create a font subset
+var subset = font.createSubset();
+run.glyphs.forEach(function(glyph) {
+  subset.includeGlyph(glyph);
+});
+
+let buffer = subset.encode();
+```
+
+## API
+
+### `fontkit.open(filename, postscriptName = null)`
+
+Opens a font file asynchronously, and returns a `Promise` with a font object. For collection fonts (such as TrueType collection files), you can pass a `postscriptName` to get that font out of the collection instead of a collection object.
+
+### `fontkit.openSync(filename, postscriptName = null)`
+
+Opens a font file synchronously, and returns a font object. For collection fonts (such as TrueType collection files), you can pass a `postscriptName` to get that font out of the collection instead of a collection object.
+
+### `fontkit.create(buffer, postscriptName = null)`
+
+Returns a font object for the given buffer. For collection fonts (such as TrueType collection files), you can pass a `postscriptName` to get that font out of the collection instead of a collection object.
+
+## Font objects
+
+There are several different types of font objects that are returned by fontkit depending on the font format. They all inherit from the `TTFFont` class and have the same public API, described below.
+
+### Metadata properties
+
+The following properties are strings (or null if the font does not contain strings for them) describing the font, as specified by the font creator.
+
+* `postscriptName`
+* `fullName`
+* `familyName`
+* `subfamilyName`
+* `copyright`
+* `version`
+
+### Metrics
+
+The following properties describe the general metrics of the font. See [here](http://www.freetype.org/freetype2/docs/glyphs/glyphs-3.html) for a good overview of how all of these properties relate to one another.
+
+* `unitsPerEm` - the size of the font’s internal coordinate grid
+* `ascent` - the font’s [ascender](http://en.wikipedia.org/wiki/Ascender_(typography))
+* `descent` - the font’s [descender](http://en.wikipedia.org/wiki/Descender)
+* `lineGap` - the amount of space that should be included between lines
+* `underlinePosition` - the offset from the normal underline position that should be used
+* `underlineThickness` - the weight of the underline that should be used
+* `italicAngle` - if this is an italic font, the angle the cursor should be drawn at to match the font design
+* `capHeight` - the height of capital letters above the baseline. See [here](http://en.wikipedia.org/wiki/Cap_height) for more details.
+* `xHeight`- the height of lower case letters. See [here](http://en.wikipedia.org/wiki/X-height) for more details.
+* `bbox` - the font’s bounding box, i.e. the box that encloses all glyphs in the font
+
+### Other properties
+
+* `numGlyphs` - the number of glyphs in the font
+* `characterSet` - an array of all of the unicode code points supported by the font
+* `availableFeatures` - an array of all [OpenType feature tags](https://www.microsoft.com/typography/otspec/featuretags.htm) (or mapped AAT tags) supported by the font (see below for a description of this)
+
+### Character to glyph mapping
+
+Fontkit includes several methods for character to glyph mapping, including support for advanced OpenType and AAT substitutions.
+
+#### `font.glyphForCodePoint(codePoint)`
+
+Maps a single unicode code point (number) to a Glyph object. Does not perform any advanced substitutions (there is no context to do so).
+
+#### `font.hasGlyphForCodePoint(codePoint)`
+
+Returns whether there is glyph in the font for the given unicode code point.
+
+#### `font.glyphsForString(string)`
+
+This method returns an array of Glyph objects for the given string. This is only a one-to-one mapping from characters
+to glyphs. For most uses, you should use `font.layout` (described below), which provides a much more advanced mapping
+supporting AAT and OpenType shaping.
+
+### Glyph metrics and layout
+
+Fontkit includes several methods for accessing glyph metrics and performing layout, including support for kerning and other advanced OpenType positioning adjustments.
+
+#### `font.widthOfGlyph(glyph_id)`
+
+Returns the advance width (described above) for a single glyph id.
+
+#### `font.layout(string, features = [] | {})`
+
+This method returns a `GlyphRun` object, which includes an array of `Glyph`s and `GlyphPosition`s for the given string.
+`Glyph` objects are described below. `GlyphPosition` objects include 4 properties: `xAdvance`, `yAdvance`, `xOffset`,
+and `yOffset`.
+
+The `features` parameter is either an array of [OpenType feature tags](https://www.microsoft.com/typography/otspec/featuretags.htm) to be applied
+in addition to the default set, or an object mapping OpenType features to a boolean enabling or disabling each. If this is an AAT font, the OpenType feature tags are mapped to AAT features.
+
+### Variation fonts
+
+Fontkit has support for AAT variation fonts, where glyphs can adjust their shape according to user defined settings along
+various axes including weight, width, and slant. Font designers specify the minimum, default, and maximum values for each
+axis they support, and allow the user fine grained control over the rendered text.
+
+#### `font.variationAxes`
+
+Returns an object describing the available variation axes. Keys are 4 letter axis tags, and values include `name`,
+`min`, `default`, and `max` properties for the axis.
+
+#### `font.namedVariations`
+
+The font designer may have picked out some variations that they think look particularly good, for example a light, regular,
+and bold weight which would traditionally be separate fonts. This property returns an object describing these named variation
+instances that the designer has specified. Keys are variation names, and values are objects with axis settings.
+
+#### `font.getVariation(variation)`
+
+Returns a new font object representing this variation, from which you can get glyphs and perform layout as normal.
+The `variation` parameter can either be a variation settings object or a string variation name. Variation settings objects
+have axis names as keys, and numbers as values (should be in the range specified by `font.variationAxes`).
+
+### Other methods
+
+#### `font.getGlyph(glyph_id, codePoints = [])`
+
+Returns a glyph object for the given glyph id. You can pass the array of code points this glyph represents for your use later, and it will be stored in the glyph object.
+
+#### `font.createSubset()`
+
+Returns a Subset object for this font, described below.
+
+## Font Collection objects
+
+For font collection files that contain multiple fonts in a single file, such as TrueType Collection (.ttc) and Datafork TrueType (.dfont) files, a font collection object can be returned by Fontkit.
+
+### `collection.getFont(postscriptName)`
+
+Gets a font from the collection by its postscript name. Returns a Font object, described above.
+
+### `collection.fonts`
+
+This property is a lazily-loaded array of all of the fonts in the collection.
+
+## Glyph objects
+
+Glyph objects represent a glyph in the font. They have various properties for accessing metrics and the actual vector path the glyph represents, and methods for rendering the glyph to a graphics context.
+
+You do not create glyph objects directly. They are created by various methods on the font object, described above. There are several subclasses of the base `Glyph` class internally that may be returned depending on the font format, but they all include the following API.
+
+### Properties
+
+* `id` - the glyph id in the font
+* `name` - the glyph name in the font
+* `codePoints` - an array of unicode code points that are represented by this glyph. There can be multiple code points in the case of ligatures and other glyphs that represent multiple visual characters.
+* `path` - a vector Path object representing the glyph
+* `bbox` - the glyph’s bounding box, i.e. the rectangle that encloses the glyph outline as tightly as possible.
+* `cbox` - the glyph’s control box. This is often the same as the bounding box, but is faster to compute. Because of the way bezier curves are defined, some of the control points can be outside of the bounding box. Where `bbox` takes this into account, `cbox` does not. Thus, `cbox` is less accurate, but faster to compute. See [here](http://www.freetype.org/freetype2/docs/glyphs/glyphs-6.html#section-2) for a more detailed description.
+* `advanceWidth` - the glyph’s advance width.
+
+### `glyph.render(ctx, size)`
+
+Renders the glyph to the given graphics context, at the specified font size.
+
+### Color glyphs (e.g. emoji)
+
+Fontkit has support for several different color emoji font formats. Currently, these include Apple’s SBIX table (as used by the “Apple Color Emoji” font), and Microsoft’s COLR table (supported by Windows 8.1). [Here](http://blog.symbolset.com/multicolor-fonts) is an overview of the various color font formats out there.
+
+#### `glyph.getImageForSize(size)`
+
+For SBIX glyphs, which are bitmap based, this returns an object containing some properties about the image, along with the image data itself (usually PNG).
+
+#### `glyph.layers`
+
+For COLR glyphs, which are vector based, this returns an array of objects representing the glyphs and colors for each layer in render order.
+
+## Path objects
+
+Path objects are returned by glyphs and represent the actual vector outlines for each glyph in the font. Paths can be converted to SVG path data strings, or to functions that can be applied to render the path to a graphics context.
+
+### `path.moveTo(x, y)`
+
+Moves the virtual pen to the given x, y coordinates.
+
+### `path.lineTo(x, y)`
+
+Adds a line to the path from the current point to the given x, y coordinates.
+
+### `path.quadraticCurveTo(cpx, cpy, x, y)`
+
+Adds a quadratic curve to the path from the current point to the given x, y coordinates using cpx, cpy as a control point.
+
+### `path.bezierCurveTo(cp1x, cp1y, cp2x, cp2y, x, y)`
+
+Adds a bezier curve to the path from the current point to the given x, y coordinates using cp1x, cp1y and cp2x, cp2y as control points.
+
+### `path.closePath()`
+
+Closes the current sub-path by drawing a straight line back to the starting point.
+
+### `path.toFunction()`
+
+Compiles the path to a JavaScript function that can be applied with a graphics context in order to render the path.
+
+### `path.toSVG()`
+
+Converts the path to an SVG path data string.
+
+### `path.bbox`
+
+This property represents the path’s bounding box, i.e. the smallest rectangle that contains the entire path shape. This is the exact bounding box, taking into account control points that may be outside the visible shape.
+
+### `path.cbox`
+
+This property represents the path’s control box. It is like the bounding box, but it includes all points of the path, including control points of bezier segments. It is much faster to compute than the real bounding box, but less accurate if there are control points outside of the visible shape.
+
+## Subsets
+
+Fontkit can perform font subsetting, i.e. the process of creating a new font from an existing font where only the specified glyphs are included. This is useful to reduce the size of large fonts, such as in PDF generation or for web use.
+
+Currently, subsets produce minimal fonts designed for PDF embedding that may not work as standalone files. They have no cmap tables and other essential tables for standalone use. This limitation will be removed in the future.
+
+You create a Subset object by calling `font.createSubset()`, described above. The API on Subset objects is as follows.
+
+### `subset.includeGlyph(glyph)`
+
+Includes the given glyph object or glyph ID in the subset.
+
+### `subset.encode()`
+
+Returns a `Uint8Array` containing the encoded font file.
+
+## License
+
+MIT