text-shaper 0.1.2 → 0.1.4

package/dist/fluent/types.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Shared types for the fluent API
+ */
+import type { FillRule, PixelMode } from "../raster/types.ts";
+import type { Matrix2D, Matrix3x3 } from "../render/outline-transform.ts";
+/**
+ * Accumulated transform state for lazy evaluation
+ */
+export interface TransformState {
+    /** 2D affine transform matrix */
+    matrix2D: Matrix2D;
+    /** 3D perspective matrix (takes precedence over matrix2D if set) */
+    matrix3D: Matrix3x3 | null;
+}
+/**
+ * Options for rasterization
+ */
+export interface RasterOptions {
+    /** Bitmap width in pixels */
+    width?: number;
+    /** Bitmap height in pixels */
+    height?: number;
+    /** Scale factor applied during rasterization */
+    scale?: number;
+    /** X offset for rasterization */
+    offsetX?: number;
+    /** Y offset for rasterization */
+    offsetY?: number;
+    /** Padding around the glyph */
+    padding?: number;
+    /** Pixel mode (Gray, Mono, LCD, etc.) */
+    pixelMode?: PixelMode;
+    /** Fill rule for path filling */
+    fillRule?: FillRule;
+    /** Flip Y axis (default true for screen coordinates) */
+    flipY?: boolean;
+}
+/**
+ * Options for auto-sized rasterization
+ */
+export interface AutoRasterOptions {
+    /** Padding around the glyph (default: 1) */
+    padding?: number;
+    /** Scale factor (default: 1) */
+    scale?: number;
+    /** Pixel mode (default: Gray) */
+    pixelMode?: PixelMode;
+    /** Fill rule (default: NonZero) */
+    fillRule?: FillRule;
+    /** Flip Y axis (default: true) */
+    flipY?: boolean;
+}
+/**
+ * Options for SVG output
+ */
+export interface SVGOptions {
+    /** Flip Y axis (default: true) */
+    flipY?: boolean;
+    /** Scale factor */
+    scale?: number;
+}
+/**
+ * Options for SVG element output
+ */
+export interface SVGElementOptions {
+    /** Font size for scaling */
+    fontSize?: number;
+    /** Fill color */
+    fill?: string;
+    /** Stroke color */
+    stroke?: string;
+    /** Stroke width */
+    strokeWidth?: number;
+}
+/**
+ * Options for canvas rendering
+ */
+export interface CanvasOptions {
+    /** Flip Y axis (default: true) */
+    flipY?: boolean;
+    /** Scale factor */
+    scale?: number;
+    /** X offset */
+    offsetX?: number;
+    /** Y offset */
+    offsetY?: number;
+    /** Fill color (set to "none" to skip fill) */
+    fill?: string;
+    /** Stroke color */
+    stroke?: string;
+    /** Stroke width */
+    strokeWidth?: number;
+}

package/dist/font/brotli/decode.d.ts

@@ -3,7 +3,49 @@
  * Based on the brotli.js reference implementation (MIT License)
  * https://github.com/devongovett/brotli.js
  */
+interface HuffmanCode {
+    bits: number;
+    value: number;
+}
+declare class BitReader {
+    private data;
+    private buf;
+    private pos;
+    private val;
+    private bitPos;
+    private bitEndPos;
+    private eos;
+    constructor(data: Uint8Array);
+    private fillBuffer;
+    readMoreInput(): void;
+    fillBitWindow(): void;
+    readBits(n: number): number;
+    get currentBitPos(): number;
+    set currentBitPos(v: number);
+    get currentVal(): number;
+}
+declare function buildHuffmanTable(rootTable: HuffmanCode[], tableOffset: number, rootBits: number, codeLengths: Uint8Array, codeLengthsSize: number): number;
+declare function getNextKey(key: number, len: number): number;
+declare function replicateValue(table: HuffmanCode[], offset: number, step: number, end: number, code: HuffmanCode): void;
+declare function nextTableBitSize(count: Int32Array, len: number, rootBits: number): number;
+declare function readHuffmanCodeLengths(codeLengthCodeLengths: Uint8Array, numSymbols: number, codeLengths: Uint8Array, br: BitReader): void;
+declare function readBlockLength(table: HuffmanCode[], tableOffset: number, br: BitReader): number;
 /**
  * Decompress Brotli-compressed data
  */
 export declare function decompress(data: Uint8Array): Uint8Array;
+export declare const __testing: {
+    getNextKey: typeof getNextKey;
+    replicateValue: typeof replicateValue;
+    nextTableBitSize: typeof nextTableBitSize;
+    buildHuffmanTable: typeof buildHuffmanTable;
+    readBlockLength: typeof readBlockLength;
+    readHuffmanCodeLengths: typeof readHuffmanCodeLengths;
+    BitReader: typeof BitReader;
+    HuffmanCode: {
+        bits: number;
+        value: number;
+    };
+    CODE_LENGTH_CODES: number;
+};
+export {};

package/dist/font/face.d.ts

@@ -11,6 +11,8 @@ export declare class Face {
     private _coords;
     /** User-space axis values */
     private _variations;
+    /** Cached advance width deltas for variable fonts (glyphId -> delta) */
+    private _advanceDeltas;
     constructor(font: Font, variations?: Record<string, number> | Variation[]);
     /**
      * Set variation axis values

package/dist/font/font.d.ts

@@ -198,6 +198,20 @@ export declare class Font {
         xMax: number;
         yMax: number;
     } | null;
+    /**
+     * Get contours and bounds for a glyph in a single operation.
+     * More efficient than calling getGlyphContours + getGlyphBounds separately
+     * as it only parses the glyph once.
+     */
+    getGlyphContoursAndBounds(glyphId: GlyphId): {
+        contours: Contour[];
+        bounds: {
+            xMin: number;
+            yMin: number;
+            xMax: number;
+            yMax: number;
+        } | null;
+    } | null;
     /** Get contours for a glyph with variation applied */
     getGlyphContoursWithVariation(glyphId: GlyphId, axisCoords: number[]): Contour[] | null;
 }

package/dist/font/tables/cff.d.ts

@@ -88,7 +88,9 @@ export interface FDSelect {
     select: (glyphId: number) => number;
 }
 /**
- * Parse CFF table
+ * Parse CFF table - Compact Font Format for PostScript outlines
+ * @param reader - Reader positioned at start of CFF table
+ * @returns Parsed CFF table with CharStrings, DICTs, and subroutines
  */
 export declare function parseCff(reader: Reader): CffTable;
 /**

package/dist/font/tables/cff2.d.ts

@@ -79,7 +79,70 @@ export interface ItemVariationData {
  * Parse CFF2 table
  */
 export declare function parseCff2(reader: Reader): Cff2Table;
+/**
+ * Parse CFF2 INDEX structure (uses 32-bit count)
+ */
+declare function parseIndex(reader: Reader): Uint8Array[];
+/**
+ * Read offset of given size
+ */
+declare function readOffset(reader: Reader, offSize: number): number;
+/**
+ * Parse a CFF2 DICT structure
+ */
+declare function parseDict(reader: Reader): Map<number, number[]>;
+/**
+ * Parse real number
+ */
+declare function parseReal(reader: Reader): number;
+/**
+ * Parse CFF2 Top DICT
+ */
+declare function parseCff2TopDict(reader: Reader): Cff2TopDict;
+/**
+ * Parse CFF2 FD DICT
+ */
+declare function parseCff2FDDict(reader: Reader): Cff2FDDict;
+/**
+ * Parse CFF2 Private DICT
+ */
+declare function parseCff2PrivateDict(reader: Reader): Cff2PrivateDict;
+/**
+ * Convert delta-encoded values to absolute
+ */
+declare function deltaToAbsolute(deltas: number[]): number[];
+/**
+ * Parse FDSelect structure
+ */
+declare function parseFDSelect(reader: Reader, numGlyphs: number): Cff2FDSelect;
+/**
+ * Parse ItemVariationStore
+ */
+declare function parseItemVariationStore(reader: Reader): ItemVariationStore;
+/**
+ * Parse VariationRegionList
+ */
+declare function parseVariationRegionList(reader: Reader): VariationRegionList;
+/**
+ * Parse ItemVariationData
+ */
+declare function parseItemVariationData(reader: Reader): ItemVariationData;
 /**
  * Calculate variation delta for given coordinates
  */
 export declare function calculateVariationDelta(vstore: ItemVariationStore, outerIndex: number, innerIndex: number, normalizedCoords: number[]): number;
+export declare const __testing: {
+    parseIndex: typeof parseIndex;
+    readOffset: typeof readOffset;
+    parseDict: typeof parseDict;
+    parseReal: typeof parseReal;
+    parseCff2TopDict: typeof parseCff2TopDict;
+    parseCff2FDDict: typeof parseCff2FDDict;
+    parseCff2PrivateDict: typeof parseCff2PrivateDict;
+    deltaToAbsolute: typeof deltaToAbsolute;
+    parseFDSelect: typeof parseFDSelect;
+    parseItemVariationStore: typeof parseItemVariationStore;
+    parseVariationRegionList: typeof parseVariationRegionList;
+    parseItemVariationData: typeof parseItemVariationData;
+};
+export {};

package/dist/font/tables/colr.d.ts

@@ -245,7 +245,10 @@ export interface VarColorStop extends ColorStop {
     varIndexBase?: number;
 }
 /**
- * Parse COLR table
+ * Parse COLR table - color glyph definitions with layered or gradient fills
+ * Supports both v0 (simple layers) and v1 (advanced paint operations)
+ * @param reader - Reader positioned at start of COLR table
+ * @returns Parsed COLR table with color layer and paint definitions
  */
 export declare function parseColr(reader: Reader): ColrTable;
 /**

package/dist/font/tables/fvar.d.ts

@@ -56,7 +56,9 @@ export declare const AxisTags: {
     readonly opsz: 1869640570;
 };
 /**
- * Parse fvar table
+ * Parse fvar table - font variations defining axes and named instances
+ * @param reader - Reader positioned at start of fvar table
+ * @returns Parsed fvar table with variation axes and instances
  */
 export declare function parseFvar(reader: Reader): FvarTable;
 /**

package/dist/font/tables/glyf.d.ts

@@ -97,6 +97,19 @@ export declare function flattenCompositeGlyph(glyf: GlyfTable, loca: LocaTable,
  * Get all contours for a glyph, flattening composites
  */
 export declare function getGlyphContours(glyf: GlyfTable, loca: LocaTable, glyphId: GlyphId): Contour[];
+/**
+ * Get contours and bounds for a glyph in one parse operation.
+ * More efficient than calling getGlyphContours + getGlyphBounds separately.
+ */
+export declare function getGlyphContoursAndBounds(glyf: GlyfTable, loca: LocaTable, glyphId: GlyphId): {
+    contours: Contour[];
+    bounds: {
+        xMin: number;
+        yMin: number;
+        xMax: number;
+        yMax: number;
+    } | null;
+};
 /**
  * Get bounding box for a glyph
  */

package/dist/font/tables/gpos.d.ts

@@ -2,7 +2,8 @@ import { type ClassDef } from "../../layout/structures/class-def.ts";
 import { type Coverage } from "../../layout/structures/coverage.ts";
 import { type DeviceOrVariationIndex } from "../../layout/structures/device.ts";
 import { type FeatureList, type ScriptList } from "../../layout/structures/layout-common.ts";
-import type { GlyphId, int16, uint16 } from "../../types.ts";
+import { SetDigest } from "../../layout/structures/set-digest.ts";
+import type { GlyphId, GlyphPosition, int16, uint16 } from "../../types.ts";
 import type { Reader } from "../binary/reader.ts";
 import { type ChainingContextPosLookup, type ContextPosLookup } from "./gpos-contextual.ts";
 import { type CursivePosSubtable, type MarkBasePosSubtable, type MarkLigaturePosSubtable, type MarkMarkPosSubtable } from "./gpos-mark.ts";
@@ -45,6 +46,8 @@ export interface GposLookup {
     type: GposLookupType;
     flag: uint16;
     markFilteringSet?: uint16;
+    /** Bloom filter for fast O(1) glyph rejection */
+    digest: SetDigest;
 }
 /** Single adjustment lookup (Type 1) */
 export interface SinglePosLookup extends GposLookup {
@@ -131,7 +134,27 @@ export interface GposTable {
 }
 export type { Anchor, MarkArray } from "./gpos-mark.ts";
 export declare function parseGpos(reader: Reader): GposTable;
+declare function parseGposLookup(reader: Reader): AnyGposLookup | null;
+declare function parseValueRecord(reader: Reader, valueFormat: uint16, subtableReader?: Reader): ValueRecord;
+declare function parseSinglePos(reader: Reader, subtableOffsets: number[]): SinglePosSubtable[];
+declare function parsePairPos(reader: Reader, subtableOffsets: number[]): PairPosSubtable[];
+declare function parseExtensionLookup(reader: Reader, subtableOffsets: number[], baseProps: {
+    flag: uint16;
+    markFilteringSet?: uint16;
+}): AnyGposLookup | null;
 export declare function getKerning(lookup: PairPosLookup, firstGlyph: GlyphId, secondGlyph: GlyphId): {
     xAdvance1: number;
     xAdvance2: number;
 } | null;
+/**
+ * Apply kerning directly to positions, avoiding object allocation.
+ * Returns true if kerning was applied, false otherwise.
+ */
+export declare function applyKerningDirect(lookup: PairPosLookup, firstGlyph: GlyphId, secondGlyph: GlyphId, pos1: GlyphPosition, pos2: GlyphPosition): boolean;
+export declare const __testing: {
+    parseGposLookup: typeof parseGposLookup;
+    parseExtensionLookup: typeof parseExtensionLookup;
+    parseSinglePos: typeof parseSinglePos;
+    parsePairPos: typeof parsePairPos;
+    parseValueRecord: typeof parseValueRecord;
+};

package/dist/font/tables/gsub.d.ts

@@ -1,5 +1,6 @@
 import { type Coverage } from "../../layout/structures/coverage.ts";
 import { type FeatureList, type ScriptList } from "../../layout/structures/layout-common.ts";
+import { SetDigest } from "../../layout/structures/set-digest.ts";
 import type { GlyphId, uint16 } from "../../types.ts";
 import type { Reader } from "../binary/reader.ts";
 import { type ChainingContextSubstSubtable, type ContextSubstSubtable } from "./gsub-contextual.ts";
@@ -19,6 +20,8 @@ export interface GsubLookup {
     type: GsubLookupType;
     flag: uint16;
     markFilteringSet?: uint16;
+    /** Bloom filter for fast O(1) glyph rejection */
+    digest: SetDigest;
 }
 /** Single substitution lookup (Type 1) */
 export interface SingleSubstLookup extends GsubLookup {
@@ -100,8 +103,25 @@ export interface GsubTable {
 }
 export type { SequenceLookupRecord } from "./gsub-contextual.ts";
 export declare function parseGsub(reader: Reader): GsubTable;
+declare function parseGsubLookup(reader: Reader, _lookupListReader: Reader, _lookupOffset: number): AnyGsubLookup | null;
+declare function parseExtensionLookup(reader: Reader, subtableOffsets: number[], baseProps: {
+    flag: uint16;
+    markFilteringSet?: uint16;
+}): AnyGsubLookup | null;
 export declare function applySingleSubst(lookup: SingleSubstLookup, glyphId: GlyphId): GlyphId | null;
 export declare function applyLigatureSubst(lookup: LigatureSubstLookup, glyphIds: GlyphId[], startIndex: number): {
     ligatureGlyph: GlyphId;
     consumed: number;
 } | null;
+/**
+ * Apply ligature substitution using a Uint16Array directly (avoids Array.from allocation).
+ * glyphIds is a pre-allocated typed array, matchLen is the valid length to consider.
+ */
+export declare function applyLigatureSubstDirect(lookup: LigatureSubstLookup, glyphIds: Uint16Array, matchLen: number, startIndex: number): {
+    ligatureGlyph: GlyphId;
+    consumed: number;
+} | null;
+export declare const __testing: {
+    parseGsubLookup: typeof parseGsubLookup;
+    parseExtensionLookup: typeof parseExtensionLookup;
+};

package/dist/font/tables/gvar.d.ts

@@ -39,7 +39,10 @@ export interface PointDelta {
     y: int16;
 }
 /**
- * Parse gvar table
+ * Parse gvar table - glyph variations for TrueType outlines in variable fonts
+ * @param reader - Reader positioned at start of gvar table
+ * @param _numGlyphs - Number of glyphs (currently unused)
+ * @returns Parsed gvar table with per-glyph variation data
  */
 export declare function parseGvar(reader: Reader, _numGlyphs: number): GvarTable;
 /**
@@ -48,6 +51,12 @@ export declare function parseGvar(reader: Reader, _numGlyphs: number): GvarTable
 export declare function parsePackedDeltas(reader: Reader, count: number): number[];
 /**
  * Calculate the scalar for a tuple given axis coordinates
+ * Determines how much a variation tuple contributes based on current axis values
+ * @param peakTuple - Peak coordinates for each axis where variation is at maximum
+ * @param axisCoords - Current normalized axis coordinates
+ * @param intermediateStart - Start of intermediate region (null if not used)
+ * @param intermediateEnd - End of intermediate region (null if not used)
+ * @returns Scalar value between 0 and 1 indicating variation contribution
  */
 export declare function calculateTupleScalar(peakTuple: number[], axisCoords: number[], intermediateStart: number[] | null, intermediateEnd: number[] | null): number;
 /**

package/dist/font/tables/head.d.ts

@@ -44,4 +44,9 @@ export declare const MacStyle: {
     readonly Condensed: 32;
     readonly Extended: 64;
 };
+/**
+ * Parse head table - font header with global metrics
+ * @param reader - Reader positioned at start of head table
+ * @returns Parsed head table
+ */
 export declare function parseHead(reader: Reader): HeadTable;

package/dist/font/tables/hhea.d.ts

@@ -21,4 +21,9 @@ export interface HheaTable {
     metricDataFormat: int16;
     numberOfHMetrics: uint16;
 }
+/**
+ * Parse hhea table - horizontal header with metrics for horizontal layout
+ * @param reader - Reader positioned at start of hhea table
+ * @returns Parsed hhea table
+ */
 export declare function parseHhea(reader: Reader): HheaTable;

package/dist/font/tables/loca.d.ts

@@ -20,6 +20,9 @@ export declare function parseLoca(reader: Reader, numGlyphs: number, indexToLocF
 /**
  * Get byte offset and length for a glyph in the glyf table
  * Returns null if glyph has no outline (empty glyph)
+ * @param loca - Parsed loca table
+ * @param glyphId - Glyph ID to look up
+ * @returns Object with offset and length, or null if glyph has no outline
  */
 export declare function getGlyphLocation(loca: LocaTable, glyphId: GlyphId): {
     offset: uint32;

package/dist/font/tables/maxp.d.ts

@@ -24,4 +24,9 @@ export interface MaxpTable10 {
     maxComponentDepth: uint16;
 }
 export type MaxpTable = MaxpTable05 | MaxpTable10;
+/**
+ * Parse maxp table - maximum profile with glyph count and limits
+ * @param reader - Reader positioned at start of maxp table
+ * @returns Parsed maxp table (version 0.5 for CFF or 1.0 for TrueType)
+ */
 export declare function parseMaxp(reader: Reader): MaxpTable;

package/dist/font/tables/name.d.ts

@@ -60,6 +60,11 @@ export interface NameTable {
     format: uint16;
     records: NameRecord[];
 }
+/**
+ * Parse name table - font naming information in multiple languages
+ * @param reader - Reader positioned at start of name table
+ * @returns Parsed name table with decoded name records
+ */
 export declare function parseName(reader: Reader): NameTable;
 /** Get a specific name by ID, preferring Windows Unicode */
 export declare function getNameById(table: NameTable, nameId: number, languageId?: number): string | null;

package/dist/font/tables/os2.d.ts

@@ -91,6 +91,11 @@ export declare const FsType: {
     readonly NoSubsetting: 256;
     readonly BitmapOnly: 512;
 };
+/**
+ * Parse OS/2 table - Windows-specific metrics, weight, width, and classification
+ * @param reader - Reader positioned at start of OS/2 table
+ * @returns Parsed OS/2 table
+ */
 export declare function parseOs2(reader: Reader): Os2Table;
 /** Check if font is italic */
 export declare function isItalic(os2: Os2Table): boolean;

package/dist/font/tables/post.d.ts

@@ -18,6 +18,11 @@ export interface PostTable {
     glyphNameIndex?: uint16[];
     names?: string[];
 }
+/**
+ * Parse post table - PostScript information including glyph names
+ * @param reader - Reader positioned at start of post table
+ * @returns Parsed post table
+ */
 export declare function parsePost(reader: Reader): PostTable;
 /** Get glyph name by glyph ID */
 export declare function getGlyphName(post: PostTable, glyphId: number): string | null;

package/dist/index.d.ts

@@ -1,6 +1,8 @@
 export { processContextual, processInsertion, processLigature, processRearrangement, } from "./aat/state-machine.ts";
 export { GlyphBuffer } from "./buffer/glyph-buffer.ts";
 export { UnicodeBuffer } from "./buffer/unicode-buffer.ts";
+export { adaptiveBlur as $adaptiveBlur, BitmapBuilder, bitmap, blur as $blur, boxBlur as $boxBlur, cascadeBlur as $cascadeBlur, char, clone as $clone, combine, combinePaths as $combinePaths, condensePath as $condensePath, convert as $convert, copy as $copy, embolden as $embolden, emboldenPath as $emboldenPath, fastBlur as $fastBlur, fromGlyph as $fromGlyph, glyph, glyphVar, italic as $italic, matrix as $matrix, obliquePath as $obliquePath, PathBuilder, pad as $pad, path, perspective as $perspective, pipe, rasterize as $rasterize, rasterizeAuto as $rasterizeAuto, rasterizeWithGradient as $rasterizeWithGradient, renderMsdf as $renderMsdf, renderSdf as $renderSdf, resize as $resize, resizeBilinear as $resizeBilinear, rotate as $rotate, rotateDeg as $rotateDeg, scale as $scale, shear as $shear, shift as $shift, strokeAsymmetric as $strokeAsymmetric, strokeAsymmetricCombined as $strokeAsymmetricCombined, strokePath as $strokePath, toGray as $toGray, toRGBA as $toRGBA, toSVG as $toSVG, translate as $translate, } from "./fluent/index.ts";
+export type { AutoRasterOptions, CanvasOptions, RasterOptions, SVGElementOptions, SVGOptions, TransformState, } from "./fluent/types.ts";
 export { Reader } from "./font/binary/reader.ts";
 export { createFace, Face } from "./font/face.ts";
 export { Font, type FontLoadOptions } from "./font/font.ts";
@@ -66,7 +68,7 @@ export { applyFeatureVariations, evaluateConditionSet, findMatchingFeatureVariat
 export { type AsymmetricStrokeOptions, strokeAsymmetric, strokeAsymmetricCombined, strokeUniform, } from "./raster/asymmetric-stroke.ts";
 export { atlasToAlpha, atlasToRGBA, buildAsciiAtlas, buildAtlas, buildStringAtlas, getGlyphUV, } from "./raster/atlas.ts";
 export { getExactBounds } from "./raster/bbox.ts";
-export { addBitmaps, blendBitmap, compositeBitmaps, convertBitmap, copyBitmap, emboldenBitmap, expandToFit, fixOutline, maxBitmaps, mulBitmaps, padBitmap, resizeBitmap, shiftBitmap, subBitmaps, } from "./raster/bitmap-utils.ts";
+export { addBitmaps, blendBitmap, compositeBitmaps, convertBitmap, copyBitmap, emboldenBitmap, expandToFit, fixOutline, maxBitmaps, mulBitmaps, padBitmap, resizeBitmap, resizeBitmapBilinear, shiftBitmap, subBitmaps, } from "./raster/bitmap-utils.ts";
 export { blurBitmap, boxBlur, createGaussianKernel, gaussianBlur, } from "./raster/blur.ts";
 export { adaptiveBlur, cascadeBlur, fastGaussianBlur, } from "./raster/cascade-blur.ts";
 export { type ColorStop as GradientColorStop, createGradientBitmap, type Gradient, interpolateGradient, type LinearGradient, type RadialGradient, rasterizePathWithGradient, } from "./raster/gradient.ts";
@@ -79,11 +81,11 @@ export type { Bitmap, GlyphAtlas, GlyphMetrics, MsdfAtlasOptions, RasterizedGlyp
 export { clearBitmap, createBitmap, FillRule, PixelMode, } from "./raster/types.ts";
 export { type BoundingBox, type ControlBox, clonePath, combinePaths, computeControlBox, computeTightBounds, identity2D, identity3x3, italicizeOutline, type Matrix2D, type Matrix3x3, multiply2D, multiply3x3, perspectiveMatrix, rotate2D, rotateOutline, rotateOutline90, scale2D, scaleOutline, scaleOutlinePow2, shear2D, transformOutline2D, transformOutline3D, transformPoint2D, transformPoint3x3, translate2D, translateOutline, updateMinTransformedX, } from "./render/outline-transform.ts";
 export type { GlyphPath, PathCommand, ShapedGlyph } from "./render/path.ts";
-export { contourToPath, createPath2D, getGlyphPath, getGlyphPathWithVariation, getTextWidth, glyphBufferToShapedGlyphs, glyphToSVG, pathToCanvas, pathToSVG, renderShapedText, renderShapedTextWithVariation, shapedTextToSVG, shapedTextToSVGWithVariation, } from "./render/path.ts";
+export { applyMatrixToContext, contourToPath, createPath2D, getGlyphPath, getGlyphPathWithVariation, getTextWidth, glyphBufferToShapedGlyphs, glyphToSVG, matrixToSVGTransform, pathToCanvas, pathToCanvasWithMatrix, pathToCanvasWithMatrix3D, pathToSVG, pathToSVGWithMatrix, pathToSVGWithMatrix3D, renderShapedText, renderShapedTextWithVariation, shapedTextToSVG, shapedTextToSVGWithVariation, } from "./render/path.ts";
 export { applyFallbackKerning, applyFallbackMarkPositioning, } from "./shaper/fallback.ts";
 export { allSmallCaps, capitalSpacing, capsToSmallCaps, caseSensitiveForms, characterVariant, characterVariants, combineFeatures, contextualAlternates, discretionaryLigatures, feature, features, fractions, fullWidthForms, halfWidthForms, historicalLigatures, jis78Forms, jis83Forms, jis90Forms, jis2004Forms, kerning, liningFigures, oldstyleFigures, ordinals, petiteCaps, proportionalFigures, proportionalWidthForms, quarterWidthForms, ruby, scientificInferiors, simplifiedForms, slashedZero, smallCaps, standardLigatures, stylisticAlternates, stylisticSet, stylisticSets, subscript, superscript, swash, tabularFigures, thirdWidthForms, traditionalForms, verticalAlternatesRotation, verticalForms, verticalKanaAlternates, verticalLayoutFeatures, } from "./shaper/features.ts";
 export { createShapePlan, getOrCreateShapePlan, type ShapeFeature, type ShapePlan, } from "./shaper/shape-plan.ts";
-export { type FontLike, type ShapeOptions, shape } from "./shaper/shaper.ts";
+export { type FontLike, type ShapeOptions, shape, shapeInto, } from "./shaper/shaper.ts";
 export * from "./types.ts";
 export { applyMirroring, type BidiParagraph, type BidiResult, BidiType, detectDirection, getCharType, getEmbeddings, getMirror, getVisualOrder, isLTR, isRTL, processBidi, reorderGlyphs, } from "./unicode/bidi.ts";
 export type { LineBreakAnalysis } from "./unicode/line-break.ts";