oasis-editor 0.0.99 → 0.0.100

package/dist/text/fonts/layout/OpenTypeLayouter.d.ts

@@ -1,21 +1,30 @@
 import { GlyphRun, ParsedFontProgram, TextLayouter } from '../core/types.js';
 
 /**
- * A {@link TextLayouter} that applies OpenType GSUB substitution for the editor's
- * Latin font features (ligatures, figure style, stylistic sets, contextual
- * alternates) when the font carries a GSUB table and the caller requests them.
+ * A {@link TextLayouter} that applies OpenType shaping for the editor's Latin font
+ * features when the font carries the relevant tables and the caller requests them:
  *
- * With no requested features — or a font without GSUB — it falls straight back to
- * the same 1:1 codepoint→glyph mapping as `SimpleTextLayouter`, so ordinary text
- * is byte-for-byte unchanged. GSUB only substitutes glyphs; advances come from
- * `hmtx` (GPOS positioning is out of scope), so `positions[].xAdvance` equals each
- * resulting glyph's advance width.
+ * - **GSUB** glyph substitution — ligatures, figure style, stylistic sets, and
+ *   contextual alternates (changes glyph identity and count).
+ * - **GPOS** glyph positioning — pair kerning (`kern`), which adjusts horizontal
+ *   advances only.
+ *
+ * With no requested features — or a font without these tables — it falls straight
+ * back to the same 1:1 codepoint→glyph mapping as `SimpleTextLayouter`, so ordinary
+ * text is byte-for-byte unchanged. Substitution runs first, then kerning adjusts
+ * the resulting glyphs' advances (`positions[].xAdvance`); GPOS placement, vertical
+ * metrics, and mark attachment are out of scope.
  */
 export declare class OpenTypeLayouter implements TextLayouter {
     private readonly font;
     private readonly gsub;
+    private readonly gpos;
     constructor(font: ParsedFontProgram);
-    /** True when the font exposes a GSUB table the shaper could use. */
+    /** True when the font exposes a GSUB table the substitution shaper could use. */
     get hasGsub(): boolean;
+    /** True when the font exposes a GPOS table the kerning shaper could use. */
+    get hasGpos(): boolean;
+    /** True when either shaping table is present (so this layouter adds value). */
+    get hasShaping(): boolean;
     layout(text: string, features?: readonly string[]): GlyphRun;
 }

package/dist/text/fonts/opentype/GposTable.d.ts

@@ -0,0 +1,15 @@
+export declare class GposTable {
+    private readonly lookups;
+    private readonly featureToLookups;
+    private constructor();
+    /** Parses GPOS bytes (table-relative). Returns null on any structural failure. */
+    static parse(bytes: Uint8Array): GposTable | null;
+    /** True when at least one of the requested feature tags exists in this font. */
+    hasAnyFeature(tags: readonly string[]): boolean;
+    /**
+     * Applies the positioning lookups for the given features across `advances`
+     * (font design units), mutating it in place. `glyphIds[i]` is the glyph at
+     * advance slot `i`; the arrays are parallel and equal length.
+     */
+    position(glyphIds: number[], advances: number[], tags: readonly string[]): void;
+}

package/dist/text/fonts/opentype/GsubTable.d.ts

@@ -4,9 +4,10 @@
  * style (lnum/onum/pnum/tnum), stylistic sets (ss01–ss20), and contextual
  * alternates (calt).
  *
- * It parses ScriptList/FeatureList/LookupList and the substitution lookup types
- * those features use — single (1), multiple (2), alternate (3), ligature (4),
- * chaining contextual (6), and extension (7). Positioning (GPOS), complex-script
+ * It parses ScriptList/FeatureList/LookupList (the first two via the shared
+ * {@link otLayoutCommon}) and the substitution lookup types those features use —
+ * single (1), multiple (2), alternate (3), ligature (4), chaining contextual (6),
+ * and extension (7). Positioning (GPOS — see {@link ./GposTable}), complex-script
  * shaping, and lookup-flag glyph skipping are intentionally out of scope.
  *
  * Parsing is defensive: any malformed offset or unsupported construct is skipped

package/dist/text/fonts/opentype/otLayoutCommon.d.ts

@@ -0,0 +1,38 @@
+import { BinaryReader } from '../../truetype/BinaryReader.js';
+
+/**
+ * Shared scaffolding for the OpenType "Layout" tables (GSUB and GPOS). Both share
+ * an identical header (ScriptList / FeatureList / LookupList offsets), the same
+ * Coverage and ClassDef formats, and the same script/feature resolution; only the
+ * lookup subtables differ (substitution vs. positioning). This module owns the
+ * common pieces so {@link ../opentype/GsubTable} and {@link ../opentype/GposTable}
+ * stay a single source of truth for that machinery.
+ *
+ * All offsets are relative to the start of the table bytes passed to the parser.
+ * Parsing is defensive: callers wrap these in try/catch and degrade gracefully, so
+ * a malformed table never breaks export.
+ */
+/** Returns the coverage index of a glyph id, or -1 when not covered. */
+export type Coverage = (glyphId: number) => number;
+/** Returns the class of a glyph id (0 when unlisted). */
+export type ClassLookup = (glyphId: number) => number;
+export declare function parseCoverage(reader: BinaryReader, offset: number): Coverage;
+export declare function parseClassDef(reader: BinaryReader, offset: number): ClassLookup;
+/** The common header of a Layout table: feature→lookup map + lookup-list offset. */
+export interface LayoutTableHeader {
+    /**
+     * Maps each feature tag offered by the resolved Latin/DFLT language system to
+     * its ordered lookup indices.
+     */
+    featureToLookups: Map<string, number[]>;
+    /** Table-relative offset of the LookupList, parsed by the owning table. */
+    lookupListOffset: number;
+}
+/**
+ * Parses the shared GSUB/GPOS header: version, the three list offsets, the
+ * feature list, and the active feature set from the script list. The caller
+ * parses the LookupList itself (its subtables are table-specific).
+ */
+export declare function parseLayoutTableHeader(reader: BinaryReader): LayoutTableHeader;
+/** Ordered (ascending) unique lookup indices referenced by the given tags. */
+export declare function collectLookupIndices(featureToLookups: Map<string, number[]>, tags: readonly string[]): number[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oasis-editor",
-  "version": "0.0.99",
+  "version": "0.0.100",
   "type": "module",
   "repository": {
     "type": "git",