PascalType.Tables.OpenType.Lookup.pas

unit PascalType.Tables.OpenType.Lookup;

////////////////////////////////////////////////////////////////////////////////
//                                                                            //
//  Version: MPL 1.1 or LGPL 2.1 with linking exception                       //
//                                                                            //
//  The contents of this file are subject to the Mozilla Public License       //
//  Version 1.1 (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.mozilla.org/MPL/                                               //
//                                                                            //
//  Software distributed under the License is distributed on an "AS IS"       //
//  basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the   //
//  License for the specific language governing rights and limitations under  //
//  the License.                                                              //
//                                                                            //
//  Alternatively, the contents of this file may be used under the terms of   //
//  the Free Pascal modified version of the GNU Lesser General Public         //
//  License Version 2.1 (the "FPC modified LGPL License"), in which case the  //
//  provisions of this license are applicable instead of those above.         //
//  Please see the file LICENSE.txt for additional information concerning     //
//  this license.                                                             //
//                                                                            //
//  The code is part of the PascalType Project                                //
//                                                                            //
//  The initial developer of this code is Christian-W. Budde                  //
//                                                                            //
//  Portions created by Christian-W. Budde are Copyright (C) 2010-2017        //
//  by Christian-W. Budde. All Rights Reserved.                               //
//                                                                            //
////////////////////////////////////////////////////////////////////////////////

interface

{$I PT_Compiler.inc}

{-$define VerboseDebug}

uses
  Generics.Collections,
  Generics.Defaults,
  System.Classes,
  PascalType.Types,
  PascalType.Classes,
  PascalType.Tables,
  PascalType.GlyphString,
  PascalType.Tables.OpenType.Coverage,
  PascalType.Tables.OpenType.ClassDefinition;

type
  TContextPart = (cpBacktrack, cpInput, cpLookahead);

type
  TCustomOpenTypeLookupTable = class;
  TOpenTypeLookupListTable = class;

//------------------------------------------------------------------------------
//
//              TCustomOpenTypeLookupSubTable
//
//------------------------------------------------------------------------------
// Base class for lookup table sub-formats
//------------------------------------------------------------------------------
  TCustomOpenTypeLookupSubTable = class abstract(TCustomPascalTypeTable)
  private type
    TMatchOptions = TPascalTypeGlyphString.TMatchOptions;

  protected type
    TSequenceLookupRecord = record
      SequenceIndex: Word;
      LookupListIndex: Word;
    end;
    TSequenceLookupRecords = TArray<TSequenceLookupRecord>;

  protected type
    TCoverageTables = class(TObjectList<TCustomOpenTypeCoverageTable>)
    protected
      function MatchCoverage(AIndex: integer; AItem, GlyphID: TGlyphID): boolean;
    end;

    TContextCoverageTables = array[TContextPart] of TCoverageTables;

  private
    FSubFormat: Word;
    function GetLookupTable: TCustomOpenTypeLookupTable;

  protected
    function ApplyLookupRecords(var AGlyphIterator: TPascalTypeGlyphIterator; const AMatchedIndices: TMatchedIndices; const LookupRecords: TSequenceLookupRecords): boolean;

  protected
    function MatchCoverage(var AGlyphIterator: TPascalTypeGlyphIterator; ACoverageTables: TCoverageTables; var AMatchedIndices: TMatchedIndices; AOptions: TMatchOptions = []): boolean; overload;
    function MatchCoverage(var AGlyphIterator: TPascalTypeGlyphIterator; ACoverageTables: TCoverageTables; AOptions: TMatchOptions = []): boolean; overload;


    // Common handler for:
    // - TOpenTypePositioningSubTableChainedContextCoverage.Apply
    // - TOpenTypeSubstitutionSubTableChainedContextCoverage.Apply
    function ApplyChainedContextCoverage(const ACoverageTables: TContextCoverageTables; const ASequenceRules: TSequenceLookupRecords; var AGlyphIterator: TPascalTypeGlyphIterator): boolean;

    // Common handler for:
    // - TOpenTypePositioningSubTableContextCoverage.Apply
    // - TOpenTypeSubstitutionSubTableContextCoverage.Apply
    function ApplyContextCoverage(const ACoverageTables: TCoverageTables; const ASequenceRules: TSequenceLookupRecords; var AGlyphIterator: TPascalTypeGlyphIterator): boolean;

  public
    constructor Create(AParent: TCustomPascalTypeTable); override;

    procedure Assign(Source: TPersistent); override;

    procedure LoadFromStream(Stream: TStream; Size: Cardinal = 0); override;
    procedure SaveToStream(Stream: TStream); override;

    function Apply(var AGlyphIterator: TPascalTypeGlyphIterator): boolean; virtual; abstract;

    property SubFormat: Word read FSubFormat;
    property LookupTable: TCustomOpenTypeLookupTable read GetLookupTable;
  end;

  TOpenTypeLookupSubTableClass = class of TCustomOpenTypeLookupSubTable;

//------------------------------------------------------------------------------
//
//              TCustomOpenTypeLookupTable
//
//------------------------------------------------------------------------------
// Common base class for GSUB/GPOS lookup tables
//------------------------------------------------------------------------------
// https://learn.microsoft.com/en-us/typography/opentype/spec/chapter2#lookup-table
//------------------------------------------------------------------------------
  TCustomOpenTypeLookupTable = class abstract(TCustomPascalTypeTable)
  public const
    RIGHT_TO_LEFT               = $0001;
    IGNORE_BASE_GLYPHS          = $0002;
    IGNORE_LIGATURES            = $0004;
    IGNORE_MARKS                = $0008;
    USE_MARK_FILTERING_SET      = $0010;
    MASK_RESERVED               = $00E0;
    MARK_ATTACHMENT_TYPE_MASK   = $FF00;
    MARK_ATTACHMENT_CLASS_FILTER = MARK_ATTACHMENT_TYPE_MASK; // The official name

  private
    FLookupType       : Word; // Different enumerations for GSUB and GPOS
    FLookupFlags      : Word; // Lookup qualifiers
    FMarkFilteringSet : Word; // Index (base 0) into GDEF mark glyph sets structure. This field is only present if bit UseMarkFilteringSet of lookup flags is set.
    FSubTableList: TPascalTypeTableInterfaceList<TCustomOpenTypeLookupSubTable>;

  protected
    procedure SetLookupFlags(const Value: Word);
    procedure SetMarkFilteringSet(const Value: Word);
    function GetSubTable(Index: Integer): TCustomOpenTypeLookupSubTable;
    function GetSubTableCount: Integer;
    function GetLookupList: TOpenTypeLookupListTable;
    procedure LookupFlagsChanged; virtual;
    procedure MarkFilteringSetChanged; virtual;
    function GetSubTableClass(ASubFormat: Word): TOpenTypeLookupSubTableClass; virtual; abstract;
    function GetUseReverseDirection: boolean; virtual;

  public
    constructor Create(AParent: TCustomPascalTypeTable); override;
    destructor Destroy; override;

    procedure Assign(Source: TPersistent); override;

    procedure LoadFromStream(Stream: TStream; Size: Cardinal = 0); override;
    procedure SaveToStream(Stream: TStream); override;

    function GetEnumerator: TEnumerator<TCustomOpenTypeLookupSubTable>;

    function Apply(var AGlyphIterator: TPascalTypeGlyphIterator): boolean; virtual;

    // The meaning of LookupType depends on the parent type (GSUB/GPOS)
    property LookupType: Word read FLookupType;
    property LookupFlags: Word read FLookupFlags write SetLookupFlags;
    property MarkFilteringSet: Word read FMarkFilteringSet write SetMarkFilteringSet;
    // See: TCustomPascalTypeOpenTypeProcessor.ApplyLookups
    property UseReverseDirection: boolean read GetUseReverseDirection;

    property SubTableCount: Integer read GetSubTableCount;
    property SubTables[Index: Integer]: TCustomOpenTypeLookupSubTable read GetSubTable; default;

    property LookupList: TOpenTypeLookupListTable read GetLookupList;
  end;

  TOpenTypeLookupTableClass = class of TCustomOpenTypeLookupTable;


//------------------------------------------------------------------------------
//
//              TCustomOpenTypeLookupSubTableWithCoverage
//
//------------------------------------------------------------------------------
// Base class for lookup table sub-formats with a coverage table (all except the
// Extension lookup type sub-table)
//------------------------------------------------------------------------------
  TCustomOpenTypeLookupSubTableWithCoverage = class abstract(TCustomOpenTypeLookupSubTable)
  protected type
    TChainedSequenceRule = record
      BacktrackSequence: TGlyphString;
      InputSequence: TGlyphString;
      LookaheadSequence: TGlyphString;
      SequenceLookupRecords: TSequenceLookupRecords;
    end;
    TChainedSequenceRuleSet = TArray<TChainedSequenceRule>;
    TChainedSequenceRuleSets = TArray<TChainedSequenceRuleSet>;

  protected type
    TSequenceRule = record
      InputSequence: TGlyphString;
      SequenceLookupRecords: TSequenceLookupRecords;
    end;
    TSequenceRuleSet = TArray<TSequenceRule>;
    TSequenceRuleSets = TArray<TSequenceRuleSet>;

  protected type
    TClassDefinitions = array[TContextPart] of TCustomOpenTypeClassDefinitionTable;

  private type
    TMatchOptions = TPascalTypeGlyphString.TMatchOptions;

  private
    FCoverageTable: TCustomOpenTypeCoverageTable;

  protected
    procedure DoSaveToStream(Stream: TStream); virtual; abstract;

  protected
    // Common handler for:
    // - TOpenTypePositioningSubTableChainedContextSimple.Apply
    // - TOpenTypeSubstitutionSubTableChainedContextSimple.Apply
    function ApplyChainedContextSimple(const ASequenceRules: TChainedSequenceRuleSets; var AGlyphIterator: TPascalTypeGlyphIterator): boolean;

    // Common handler for:
    // - TOpenTypePositioningSubTableChainedContextClass.Apply
    // - TOpenTypeSubstitutionSubTableChainedContextClass.Apply
    function ApplyChainedContextClass(const ASequenceRules: TChainedSequenceRuleSets; const AClassDefinitions: TClassDefinitions; var AGlyphIterator: TPascalTypeGlyphIterator): boolean;

    // Common handler for:
    // - TOpenTypePositioningSubTableContextSimple.Apply
    // - TOpenTypeSubstitutionSubTableContextSimple.Apply
    function ApplyContextSimple(const ASequenceRules: TSequenceRuleSets; var AGlyphIterator: TPascalTypeGlyphIterator): boolean;

    // Common handler for:
    // - TOpenTypePositioningSubTableContextClass.Apply
    // - TOpenTypeSubstitutionSubTableContextClass.Apply
    function ApplyContextClass(const ASequenceRules: TSequenceRuleSets; AClassDefinitions: TCustomOpenTypeClassDefinitionTable; var AGlyphIterator: TPascalTypeGlyphIterator): boolean;
  public
    destructor Destroy; override;

    procedure Assign(Source: TPersistent); override;

    procedure LoadFromStream(Stream: TStream; Size: Cardinal = 0); override;
    procedure SaveToStream(Stream: TStream); reintroduce; override; // Prevent derived from overriding; They must go through DoSaveToStream

    property CoverageTable: TCustomOpenTypeCoverageTable read FCoverageTable;
  end;


//------------------------------------------------------------------------------
//
//              TOpenTypeLookupListTable
//
//------------------------------------------------------------------------------
// Lookup list table
//------------------------------------------------------------------------------
// https://learn.microsoft.com/en-us/typography/opentype/spec/chapter2#lookup-list-table
//------------------------------------------------------------------------------
  TOpenTypeLookupListTable = class(TCustomPascalTypeTable)
  private
    FLookupList: TPascalTypeTableInterfaceList<TCustomOpenTypeLookupTable>;
    function GetLookupTableCount: Integer;
    function GetLookupTable(Index: Integer): TCustomOpenTypeLookupTable;
  public
    constructor Create(AParent: TCustomPascalTypeTable); override;
    destructor Destroy; override;

    procedure Assign(Source: TPersistent); override;

    procedure LoadFromStream(Stream: TStream; Size: Cardinal = 0); override;
    procedure SaveToStream(Stream: TStream); override;

    property LookupTableCount: Integer read GetLookupTableCount;
    property LookupTables[Index: Integer]: TCustomOpenTypeLookupTable read GetLookupTable; default;
  end;


//------------------------------------------------------------------------------
//
//              TOpenTypeLookupTableGeneric
//
//------------------------------------------------------------------------------
// Generic placeholder for those lookup types that have no concrete implementation.
//------------------------------------------------------------------------------
type
  TOpenTypeLookupTableGeneric = class(TCustomOpenTypeLookupTable)
  private type
    TOpenTypeLookupSubTableGeneric = class(TCustomOpenTypeLookupSubTable)
    public
      function Apply(var AGlyphIterator: TPascalTypeGlyphIterator): boolean; override;
    end;
  protected
    function GetSubTableClass(ASubFormat: Word): TOpenTypeLookupSubTableClass; override;
  end;


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

implementation

uses
  System.SysUtils,
  System.Math,
{$ifdef DEBUG}
  WinApi.Windows,
{$endif DEBUG}
  PascalType.ResourceStrings,
  PascalType.Tables.OpenType.Common;

//------------------------------------------------------------------------------
//
//              TCustomOpenTypeLookupTable
//
//------------------------------------------------------------------------------
constructor TCustomOpenTypeLookupTable.Create(AParent: TCustomPascalTypeTable);
begin
  inherited Create(AParent); // Type check the parent
  FSubTableList := TPascalTypeTableInterfaceList<TCustomOpenTypeLookupSubTable>.Create(Self);
end;

destructor TCustomOpenTypeLookupTable.Destroy;
begin
  FreeAndNil(FSubTableList);
  inherited;
end;

procedure TCustomOpenTypeLookupTable.Assign(Source: TPersistent);
begin
  inherited;
  if Source is TCustomOpenTypeLookupTable then
  begin
    Assert(FLookupType = TCustomOpenTypeLookupTable(Source).FLookupType);
    FLookupFlags := TCustomOpenTypeLookupTable(Source).FLookupFlags;
    FMarkFilteringSet := TCustomOpenTypeLookupTable(Source).FMarkFilteringSet;
    FSubTableList.Assign(TCustomOpenTypeLookupTable(Source).FSubTableList);
  end;
end;

procedure TCustomOpenTypeLookupTable.LoadFromStream(Stream: TStream; Size: Cardinal);
var
  StartPos: Int64;
  LookupPos: Int64;
  IsExtension: boolean;
  PosFormat: Word;
  Offset: Cardinal;
  i: integer;
  SubTableType: Word;
  SubTableOffsets: array of Word;
  SubTable: TCustomOpenTypeLookupSubTable;
  SubTableClass: TOpenTypeLookupSubTableClass;
begin

  // +----------+-----------------------+--------------------------------------------+
  // | Type     | Name                  | Description                                |
  // +==========+=======================+============================================+
  // | uint16   | lookupType            | Different enumerations for GSUB and GPOS.  |
  // +----------+-----------------------+--------------------------------------------+
  // | uint16   | lookupFlag            | Lookup qualifiers.                         |
  // +----------+-----------------------+--------------------------------------------+
  // | uint16   | subTableCount         | Number of SubTable offsets.                |
  // +----------+-----------------------+--------------------------------------------+
  // | Offset16 | subTableOffsets[count]| Array of offsets to SubTables.             |
  // +----------+-----------------------+--------------------------------------------+
  // | uint16   | markFilteringSet      | Index (for GDEF mark filtering sets).      |
  // +----------+-----------------------+--------------------------------------------+
  StartPos := Stream.Position;

  FLookupType := BigEndianValue.ReadWord(Stream);
  IsExtension := TCustomOpenTypeCommonTable(Parent.Parent).IsExtensionLookupType(FLookupType);

  FLookupFlags := BigEndianValue.ReadWord(Stream);

  // Read subtable count
  SetLength(SubTableOffsets, BigEndianValue.ReadWord(Stream));

  // Read lookup list index offsets
  for i := 0 to High(SubTableOffsets) do
    SubTableOffsets[i] := BigEndianValue.ReadWord(Stream);

  if (FLookupFlags and USE_MARK_FILTERING_SET <> 0) then
    FMarkFilteringSet := BigEndianValue.ReadWord(Stream);

  for i := 0 to High(SubTableOffsets) do
  begin
    LookupPos := StartPos + SubTableOffsets[i];
    Stream.Position := LookupPos;

    // Lookup is a an extension.
    // Get the actual lookuptype from the sub-table and the offset to the sub-table.
    if (IsExtension) then
    begin
      PosFormat := BigEndianValue.ReadWord(Stream);
      if (PosFormat <> 1) then
        raise EPascalTypeError.CreateFmt(RCStrUnknownVersion, [PosFormat]);

      FLookupType := BigEndianValue.ReadWord(Stream);
      if (TCustomOpenTypeCommonTable(Parent.Parent).IsExtensionLookupType(FLookupType)) then
        raise EPascalTypeError.CreateFmt(RCStrInvalidLookupType, [FLookupType]);

      Offset := BigEndianValue.ReadCardinal(Stream);

      Stream.Position := LookupPos + Offset;
    end;

    // Read lookup type
    SubTableType := BigEndianValue.ReadWord(Stream);
    SubTableClass := GetSubTableClass(SubTableType);

    if (SubTableClass = nil) then
      continue;

    // Add to subtable list
    SubTable := FSubTableList.Add(SubTableClass);

    // Load subtable
    Stream.Seek(-SizeOf(Word), soFromCurrent);
    SubTable.LoadFromStream(Stream);
  end;
end;

procedure TCustomOpenTypeLookupTable.SaveToStream(Stream: TStream);
var
  StartPos: Int64;
  SubTableOffsets: array of Word;
  i: integer;
  OffsetTablePos: Int64;
begin
  StartPos := Stream.Position;

  inherited;

  BigEndianValue.WriteWord(Stream, FLookupType);
  BigEndianValue.WriteWord(Stream, FLookupFlags);

  BigEndianValue.WriteWord(Stream, FSubTableList.Count);
  OffsetTablePos := Stream.Position;
  // Reserve space for offset list
  Stream.Seek(FSubTableList.Count * SizeOf(Word), soCurrent);

  SetLength(SubTableOffsets, FSubTableList.Count);
  for i := 0 to FSubTableList.Count-1 do
  begin
    SubTableOffsets[i] := Stream.Position - StartPos;
    FSubTableList[i].SaveToStream(Stream);
  end;

  StartPos := Stream.Position;

  Stream.Position := OffsetTablePos;
  for i := 0 to FSubTableList.Count-1 do
    BigEndianValue.WriteWord(Stream, SubTableOffsets[i]);

  Stream.Position := StartPos;
end;

function TCustomOpenTypeLookupTable.GetEnumerator: TEnumerator<TCustomOpenTypeLookupSubTable>;
begin
  Result := FSubTableList.GetEnumerator;
end;

function TCustomOpenTypeLookupTable.GetLookupList: TOpenTypeLookupListTable;
begin
  // Not so nice, but I'd rather not go through the FontFace to get at the list :-(
  Result := Parent as TOpenTypeLookupListTable;
end;

function TCustomOpenTypeLookupTable.Apply(var AGlyphIterator: TPascalTypeGlyphIterator): boolean;
var
  SubTable: TCustomOpenTypeLookupSubTable;
begin
  for SubTable in FSubTableList do
    if (SubTable.Apply(AGlyphIterator)) then
{$if (not Defined(DEBUG)) or (not Defined(VerboseDebug))}
      Exit(True);
{$else}
    begin
      OutputDebugString(PChar(Format('Applied lookup %s: %s', [ClassName, SubTable.ClassName])));
      Exit(True);
    end else
      ;//OutputDebugString(PChar(Format('Did not match lookup %s: %s', [ClassName, SubTable.ClassName])));
{$ifend}
  Result := False;
end;

function TCustomOpenTypeLookupTable.GetSubTable(Index: Integer): TCustomOpenTypeLookupSubTable;
begin
  if (Index < 0) or (Index >= FSubTableList.Count) then
    raise EPascalTypeError.CreateFmt(RCStrIndexOutOfBounds, [Index]);
  Result := TCustomOpenTypeLookupSubTable(FSubTableList[Index]);
end;

function TCustomOpenTypeLookupTable.GetSubTableCount: Integer;
begin
  Result := FSubTableList.Count;
end;

function TCustomOpenTypeLookupTable.GetUseReverseDirection: boolean;
begin
  Result := False;
end;

procedure TCustomOpenTypeLookupTable.SetLookupFlags(const Value: Word);
begin
  if FLookupFlags <> Value then
  begin
    FLookupFlags := Value;
    LookupFlagsChanged;
  end;
end;

procedure TCustomOpenTypeLookupTable.SetMarkFilteringSet(const Value: Word);
begin
  if FMarkFilteringSet <> Value then
  begin
    FMarkFilteringSet := Value;
    MarkFilteringSetChanged;
  end;
end;

procedure TCustomOpenTypeLookupTable.LookupFlagsChanged;
begin
  Changed;
end;

procedure TCustomOpenTypeLookupTable.MarkFilteringSetChanged;
begin
  Changed;
end;


//------------------------------------------------------------------------------
//
//              TOpenTypeLookupTableGeneric
//
//------------------------------------------------------------------------------
function TOpenTypeLookupTableGeneric.GetSubTableClass(ASubFormat: Word): TOpenTypeLookupSubTableClass;
begin
  Result := TOpenTypeLookupSubTableGeneric;
end;

function TOpenTypeLookupTableGeneric.TOpenTypeLookupSubTableGeneric.Apply(var AGlyphIterator: TPascalTypeGlyphIterator): boolean;
begin
{$ifdef DEBUG}
  OutputDebugString(PChar(Format('%s lookup not implemented. Lookup type: %d, sub-format: %d', [string(TCustomPascalTypeNamedTable(TOpenTypeLookupTableGeneric(Parent).LookupList.Parent).TableType.AsTableName), TOpenTypeLookupTableGeneric(Parent).LookupType, SubFormat])));
{$endif DEBUG}

  Result := False;
end;


//------------------------------------------------------------------------------
//
//              TOpenTypeLookupListTable
//
//------------------------------------------------------------------------------
constructor TOpenTypeLookupListTable.Create(AParent: TCustomPascalTypeTable);
begin
  inherited Create(AParent as TCustomOpenTypeCommonTable); // Type check the parent
  FLookupList := TPascalTypeTableInterfaceList<TCustomOpenTypeLookupTable>.Create(Self);
end;

destructor TOpenTypeLookupListTable.Destroy;
begin
  FreeAndNil(FLookupList);
  inherited;
end;

procedure TOpenTypeLookupListTable.Assign(Source: TPersistent);
begin
  inherited;
  if Source is TOpenTypeLookupListTable then
    FLookupList.Assign(TOpenTypeLookupListTable(Source).FLookupList);
end;

function TOpenTypeLookupListTable.GetLookupTable(Index: Integer): TCustomOpenTypeLookupTable;
begin
  if (Index < 0) or (Index >= FLookupList.Count) then
    raise EPascalTypeError.CreateFmt(RCStrIndexOutOfBounds, [Index]);
  Result := FLookupList[Index];
end;

function TOpenTypeLookupListTable.GetLookupTableCount: Integer;
begin
  Result := FLookupList.Count;
end;

procedure TOpenTypeLookupListTable.LoadFromStream(Stream: TStream; Size: Cardinal);

  function GetLookupTypeFromExtension: Word;
  var
    StartPos: Int64;
    LookupFlags: Word;
    Count: Word;
    SubOffset: Word;
    PosFormat: Word;
  begin
    StartPos := Stream.Position;

    Result := 0;

    // Skip LookupType and LookupFlags
    Stream.Position := Stream.Position + SizeOf(Word);

    // Read LookupFlags
    LookupFlags := BigEndianValue.ReadWord(Stream);

    // Read subtable count
    Count := BigEndianValue.ReadWord(Stream);

    // Read first lookup list index offset
    if (Count = 0) then
      Exit; // Invalid
    SubOffset := BigEndianValue.ReadWord(Stream);
    Stream.Position := Stream.Position + (Count-1)*SizeOf(Word);

    // Skip MarkFilteringSet
    if (LookupFlags and TCustomOpenTypeLookupTable.USE_MARK_FILTERING_SET <> 0) then
      Stream.Position := Stream.Position + SizeOf(Word);

    // Seek to sub-table
    Stream.Position := StartPos + SubOffset;

    // Read Extension Positioning Subtable Format 1
    // - posFormat (we just verify that it has the correct value)
    PosFormat := BigEndianValue.ReadWord(Stream);
    if (PosFormat <> 1) then
      Exit;

    // - extensionLookupType
    Result := BigEndianValue.ReadWord(Stream);

    // Skip extensionOffset. We don't need it here.
  end;

var
  StartPos: Int64;
  SavePos: Int64;
  i: Integer;
  LookupTableOffsets: array of Word;
  LookupTable: TCustomOpenTypeLookupTable;
  LookupType: Word;
  LookupTableClass: TOpenTypeLookupTableClass;
begin
  StartPos := Stream.Position;

  inherited;

  // check (minimum) table size
  if Stream.Position + 2 > Stream.Size then
    raise EPascalTypeError.Create(RCStrTableIncomplete);

  // read lookup list count
  SetLength(LookupTableOffsets, BigEndianValue.ReadWord(Stream));

  // read offsets
  for i := 0 to High(LookupTableOffsets) do
    LookupTableOffsets[i] := BigEndianValue.ReadWord(Stream);

  FLookupList.Clear;

  for i := 0 to High(LookupTableOffsets) do
  begin
    // set position to start of lookup table
    Stream.Position := StartPos + LookupTableOffsets[i];

    // We peek ahead into the stream to determine the lookup table class in order to
    // support extension lookups. For extension lookup types the actual lookup type
    // is stored in the lookup sub-tables.
    LookupType := BigEndianValue.ReadWord(Stream);
    Stream.Seek(-SizeOf(Word), soFromCurrent);

    if (TCustomOpenTypeCommonTable(Parent).IsExtensionLookupType(LookupType)) then
    begin
      SavePos := Stream.Position;
      // Peek ahead into lookup table to get actual lookup type
      LookupType := GetLookupTypeFromExtension;

      // Make sure that the extension lookup didn't specify the lookup type as an extension lookup
      if (TCustomOpenTypeCommonTable(Parent).IsExtensionLookupType(LookupType)) then
        raise EPascalTypeError.CreateFmt(RCStrInvalidLookupType, [LookupType]);

      Stream.Position := SavePos;
    end;

    // Get the lookup table class from the parent.
    // The mapping from LookupType to lookup table class differs between GSUB and GPOS.
    LookupTableClass := TCustomOpenTypeCommonTable(Parent).GetLookupTableClass(LookupType);

    if (LookupTableClass = nil) then
      // We *must* load the table even if we have no implementation for it.
      // Otherwise the index numbers in the feature lookup list (see
      // TCustomOpenTypeFeatureTable) will not match.
      LookupTableClass := TOpenTypeLookupTableGeneric;

    LookupTable := FLookupList.Add(LookupTableClass);

    // Load lookup table
    LookupTable.LoadFromStream(Stream);
  end;
end;

procedure TOpenTypeLookupListTable.SaveToStream(Stream: TStream);
begin
  inherited;
  raise EPascalTypeNotImplemented.Create(RCStrNotImplemented);
end;


//------------------------------------------------------------------------------
//
//              TCustomOpenTypeLookupSubTable
//
//------------------------------------------------------------------------------
constructor TCustomOpenTypeLookupSubTable.Create(AParent: TCustomPascalTypeTable);
begin
  inherited Create(AParent as TCustomOpenTypeLookupTable);
  FSubFormat := $FFFF;
end;

//------------------------------------------------------------------------------

function TCustomOpenTypeLookupSubTable.GetLookupTable: TCustomOpenTypeLookupTable;
begin
  Result := TCustomOpenTypeLookupTable(Parent);
end;

//------------------------------------------------------------------------------

procedure TCustomOpenTypeLookupSubTable.LoadFromStream(Stream: TStream; Size: Cardinal);
begin
  inherited;
  FSubFormat := BigEndianValue.ReadWord(Stream);
end;

procedure TCustomOpenTypeLookupSubTable.SaveToStream(Stream: TStream);
begin
  inherited;
  BigEndianValue.WriteWord(Stream, FSubFormat);
end;

//------------------------------------------------------------------------------

function TCustomOpenTypeLookupSubTable.MatchCoverage(var AGlyphIterator: TPascalTypeGlyphIterator; ACoverageTables: TCoverageTables;
  var AMatchedIndices: TMatchedIndices; AOptions: TMatchOptions): boolean;
begin
  AMatchedIndices := nil;

  if (ACoverageTables.Count = 0) then
    Exit(True);

  // Dummy sequence. Required but not used by our matcher delegate.
  var Sequence: TGlyphString;
  SetLength(Sequence, ACoverageTables.Count);

  Result := AGlyphIterator.GlyphString.Match(AGlyphIterator, Sequence, AMatchedIndices, AOptions, ACoverageTables.MatchCoverage);
end;

function TCustomOpenTypeLookupSubTable.MatchCoverage(var AGlyphIterator: TPascalTypeGlyphIterator; ACoverageTables: TCoverageTables; AOptions: TMatchOptions): boolean;
var
  MatchedIndices: TArray<integer>;
begin
  Result := MatchCoverage(AGlyphIterator, ACoverageTables, MatchedIndices, AOptions);
end;

//------------------------------------------------------------------------------

function TCustomOpenTypeLookupSubTable.ApplyChainedContextCoverage(const ACoverageTables: TContextCoverageTables;
  const ASequenceRules: TSequenceLookupRecords;
  var AGlyphIterator: TPascalTypeGlyphIterator): boolean;
begin
  Result := False;

  if (AGlyphIterator.EOF) then
    exit;

  // Quick short-circuit exit.
  // We can get away with not taking the iterator filters into account here
  // because the filters would only ever reduce the effective length of the
  // glyph string, so if the sequences are larger than the raw glyph string,
  // then they will also be larger than the filtered glyph string.
  //
  // 1) There needs to be enough glyphs to matching input+lookahead, starting
  //    at the current glyph.
  if (AGlyphIterator.Index + ACoverageTables[cpInput].Count + ACoverageTables[cpLookahead].Count > AGlyphIterator.GlyphString.Count) then
    exit;
  // 2) There needs to be enough glyphs to match backtrack, before the
  //    current glyph.
  if (AGlyphIterator.Index < ACoverageTables[cpBacktrack].Count) then
    exit;

  var Iterator := AGlyphIterator.Clone;

  // The strings are matched, character by character, against the coverage tables.
  // The coverage index itself isn't used. We just need to determine if we should proceed.

  // Input
  var MatchedIndices: TMatchedIndices;
  if (ACoverageTables[cpInput].Count > 0) then
  begin

    if (not MatchCoverage(Iterator, ACoverageTables[cpInput], MatchedIndices, [moMoveOnMatch])) then
      exit;

  end;

  // Save position, just after Input sequence, so we can resume the match for Lookahead there
  var LookaheadIndex := Iterator.Index;

  // Backtrack
  if (ACoverageTables[cpBacktrack].Count > 0) then
  begin

    // Backtrack starts just before the initial start position
    Iterator.Index := AGlyphIterator.Peek(-1);

    // Note: We match backwards in the glyph string
    if (not MatchCoverage(Iterator, ACoverageTables[cpBacktrack], [moBackTrack])) then
      exit;

  end;

  // Lookahead
  if (ACoverageTables[cpLookahead].Count > 0) then
  begin

    // Lookahead starts just after the Input sequence
    Iterator.Index := LookaheadIndex;

    if (not MatchCoverage(Iterator, ACoverageTables[cpLookahead])) then
      exit;

  end;

  // We have a match. Apply the rules.
  Result := ApplyLookupRecords(AGlyphIterator, MatchedIndices, ASequenceRules);
end;

function TCustomOpenTypeLookupSubTable.ApplyContextCoverage(const ACoverageTables: TCoverageTables;
  const ASequenceRules: TSequenceLookupRecords; var AGlyphIterator: TPascalTypeGlyphIterator): boolean;
begin
  Result := False;

  // Short-circuit
  if (AGlyphIterator.Index + ACoverageTables.Count > AGlyphIterator.GlyphString.Count) then
    exit;

  var Iterator := AGlyphIterator.Clone;

  var MatchedIndices: TArray<integer>;

  // The string is matched, character by character, against the coverage table.
  // The coverage index itself isn't used. We just need to determine if we should proceed.
  // TODO : Why do we use moMoveOnMatch here? We are not using the iterator position after the call.
  if (not MatchCoverage(Iterator, ACoverageTables, MatchedIndices, [moMoveOnMatch])) then
    exit;

  // We have a match. Apply the rules.
  Result := ApplyLookupRecords(AGlyphIterator, MatchedIndices, ASequenceRules);
end;

function TCustomOpenTypeLookupSubTable.ApplyLookupRecords(var AGlyphIterator: TPascalTypeGlyphIterator;
  const AMatchedIndices: TMatchedIndices; const LookupRecords: TSequenceLookupRecords): boolean;
begin
  // Lookup can be empty in which case we consider it a match. See issue #49
  if (Length(LookupRecords) = 0) then
  begin
    if (AMatchedIndices <> nil) then
      AGlyphIterator.Index := AMatchedIndices[High(AMatchedIndices)] + 1
    else
      AGlyphIterator.Step;
    Exit(True);
  end;

  Result := False;

  var LookupList := LookupTable.LookupList;

  (*
    Sequence context format 1: simple glyph contexts
    https://learn.microsoft.com/en-us/typography/opentype/spec/chapter2#sequence-context-format-1-simple-glyph-contexts

    The seqLookupRecords array lists the sequence lookup records that specify actions
    to be taken on glyphs at various positions within the input sequence. These do not
    have to be ordered in sequence position order; they are ordered according to the
    desired result. All of the sequence lookup records are processed in order, and
    each applies to the results of the actions indicated by the preceding record.

    Note: The above text is present in the description of all the sequence context
    formats. Not just format 1.
  *)

  // We need to keep track of the physical positions of the matched components
  // because nested lookups might change the buffer length (ligatures/multiple).
  var CurrentMatchedIndices := Copy(AMatchedIndices); // TODO : We can probably just work directly on AMatchedIndices since the caller doesn't use it for anything

  // Save the index of the last match; We need it later.
  var MatchEnd := -1;
  if (Length(CurrentMatchedIndices) > 0) then
    MatchEnd := CurrentMatchedIndices[High(CurrentMatchedIndices)];

  for var i := 0 to High(LookupRecords) do
  begin
    var SequenceIndex := LookupRecords[i].SequenceIndex;

    // Safety check
    if (SequenceIndex > High(CurrentMatchedIndices)) then
      continue;

    var PhysicalIndex := CurrentMatchedIndices[SequenceIndex];
    if (PhysicalIndex = -1) then
      continue;

    var Iterator := AGlyphIterator.Clone;
    Iterator.Index := PhysicalIndex;

    // Get the referenced lookup
    var Lookup := LookupList[LookupRecords[i].LookupListIndex];

    if (Lookup.LookupFlags and TCustomOpenTypeLookupTable.USE_MARK_FILTERING_SET <> 0) then
      Iterator.ResetFlags(Lookup.LookupFlags, Lookup.MarkFilteringSet)
    else
      Iterator.ResetFlags(Lookup.LookupFlags);

    var NestedStartCount := AGlyphIterator.GlyphString.Count;

    // *Recursively* apply
    if (Lookup.Apply(Iterator)) then
    begin
      Result := True;

      // Adjust remaining matched indices for insertions/deletions;
      // When a nested lookup results in a change in glyph count (Delta), the
      // CurrentMatchedIndices array must be appropriately resized and its
      // elements shifted. For multiple substitutions, new physical indices
      // must be populated. This ensures that subsequent lookup records,
      // within the same contextual rule, target the intended glyphs in the
      // updated sequence.

      var Delta := AGlyphIterator.GlyphString.Count - NestedStartCount;

      if (Delta <> 0) then
      begin

        // Adjust physical index values for ALL elements.
        // Glyphs following the substitution have shifted in the physical buffer.
        for var j := 0 to High(CurrentMatchedIndices) do
          if (CurrentMatchedIndices[j] > PhysicalIndex) then
            Inc(CurrentMatchedIndices[j], Delta);

        // Also adjust the tracking of the end of the input sequence
        if (MatchEnd > PhysicalIndex) then
          Inc(MatchEnd, Delta);

        if (Delta < 0) then
        begin

          (*
          ** Ligature/Deletion: logical glyphs were consumed.
          **
          ** Update the logical-to-physical index mapping when a substitution
          ** (like a ligature) removes glyphs from the buffer.
          **
          ** In a chaining contextual substitution, the font defines a rule that
          ** matches a sequence of glyphs (e.g., [A, B, C, D]). The MatchedIndices
          ** array keeps track of where each of those logical positions (0, 1, 2, 3)
          ** currently resides in the physical glyph buffer.
          ** When a nested lookup is applied (say, a ligature at logical position 1
          ** that consumes two glyphs: B and C), the sequence effectively shrinks.
          ** Logical positions that used to exist are now gone, and we must remove
          ** them from our tracking array so that subsequent lookups in the same
          ** rule don't try to target "ghost" glyphs.
          *)

          if (SequenceIndex < High(CurrentMatchedIndices)) then
          begin
            // Index of the glyph immediately following the substituted glyph
            var StartIdx := SequenceIndex + 1;

            // How many glyphs were consumed by the substitution
            var CountToRemove := -Delta;

            // Remove the logical entries for the consumed glyphs.
            Delete(CurrentMatchedIndices, StartIdx, CountToRemove);
          end;

        end else
        begin

          (*
          ** Multiple substitution/Insertion: logical glyphs were added.
          **
          ** he Multiple Substitution/Insertion section handles the opposite case
          ** of a ligature: when a single glyph is expanded into multiple glyphs
          ** (e.g., f becomes [f, i]), increasing the length of the buffer.
          ** When this happens, the logical sequence mapping must also expand to
          ** accommodate the new "sub-positions" created by the expansion. If
          ** our rule originally matched [A, B, C] and A expands into [A1, A2],
          ** subsequent lookup records in the same rule might need to target A2
          ** or the shifted B.
          *)
          var CountToAdd := Delta;
          var StartIdx := SequenceIndex + 1;
          var OldLen := Length(CurrentMatchedIndices);

          if (CountToAdd > 1) then
          begin
            // Make room for new:
            // [0, 1, 2] -> [0, 1, 2, ?]
            SetLength(CurrentMatchedIndices, OldLen + CountToAdd);

            var Remaining := OldLen - StartIdx;

            if (Remaining > 0) then
              // Shift existing entries to the right to make a gap
              // [0, 1, 2, ?] -> [0, ?, 1, 2]
              System.Move(CurrentMatchedIndices[StartIdx], CurrentMatchedIndices[StartIdx + CountToAdd], Remaining * SizeOf(integer));

            // Adjust physical index values (done above)
            // [0, ?, 1, 2] -> [0, ?, 2, 3]

            // Fill in the new physical indices
            //                 [A1, A2, B, C]
            // [0, ?, 2, 3] -> [0,  1,  2, 3]
            for var k := 0 to Delta - 1 do
              CurrentMatchedIndices[SequenceIndex + 1 + k] := PhysicalIndex + 1 + k;
          end else
            // Insert single element
            Insert(PhysicalIndex+1, CurrentMatchedIndices, StartIdx);
        end;
      end;
    end;
  end;

  (*
  ** OpenType Layout Common Table Formats, Lookup table
  **
  ** https://learn.microsoft.com/en-us/typography/opentype/spec/chapter2
  **
  ** "To move to the 'next' glyph, the client skips all the glyphs that participated in
  **  the lookup operation: glyphs that were substituted as well as any other glyphs
  **  that formed a context for the operation."
  **
  ** While "context" could be interpreted to include lookahead, standard practice (e.g.
  ** HarfBuzz) is to advance past the entire *input sequence* but NOT the lookahead
  ** sequence, as lookahead glyphs may need to be the start of a subsequent match.
  **
  ** For example, let's say we have a sequence of glyphs [A, B, C, D] and a contextual
  ** rule matches the 3-glyph sequence [A, B, C] but `ApplyLookupRecords` only applies
  ** a lookup to the 1st glyph (A), the shaper must advance past the whole input
  ** sequence and continue at D; Not just advance past A to continue at B.
  **
  ** Note that there is an exception to the above rule:
  **
  ** "However, an exception to this rule is made in the case of pair positioning
  **  operations (for example, kerning): the "next" glyph in a sequence may be the
  **  second glyph of the input sequence pair, rather than skipping over the entire
  **  input sequence."
  **
  ** Another place the specs qualify the above rule:
  **
  ** "There is just one exception: the "next" glyph in a sequence may be one of those
  **  that formed a context for the operation just performed. Specifically, in the
  **  case of pair positioning operations (i.e., kerning), if the ValueRecord for the
  **  second glyph is null, that glyph is treated as the "next" glyph in the sequence."
  **
  ** The above is implemented in TOpenTypePositioningSubTablePairSingle.Apply and
  ** TOpenTypePositioningSubTablePairClass.Apply.
  *)

  // HarfBuzz preserving logic:
  // Intermediate glyphs that were skipped during matching (Default Ignorables)
  // should be moved to follow the matched input sequence.
  // We move from the last gap to the first, and from the end of each gap,
  // to preserve relative order of skipped glyphs.

  for var k := High(CurrentMatchedIndices) - 1 downto 0 do
  begin
    // Example: [abCdeFgh]
    // In the string [abCdeFgh] we matched "C" and "F"; The gap goes from "d" to "e"
    var GapStart := CurrentMatchedIndices[k] + 1;
    var GapEnd := CurrentMatchedIndices[k+1] - 1;

    for var m := GapEnd downto GapStart do
    begin
      // Only move Default Ignorables (GSUB skippables).
      // We must NOT move other skipped glyphs like marks, as that would break their base attachment.
      if not AGlyphIterator.GlyphString[m].IsGSUBSkippable then
        continue;

      // Example: [abCdeFgh]
      // 1. Move "e": [abCdFegh]
      // 2. Move "d": [abCFdegh]
      var Target := MatchEnd;
      AGlyphIterator.GlyphString.Move(m, Target);

      // Since we moved a glyph from index m to Target (where m < Target),
      // all indices in the range ]m, Target] shift down by 1.
      for var n := 0 to High(CurrentMatchedIndices) do
        if (CurrentMatchedIndices[n] > m) and (CurrentMatchedIndices[n] <= Target) then
          Dec(CurrentMatchedIndices[n]);

      if (MatchEnd > m) and (MatchEnd <= Target) then
        Dec(MatchEnd);
    end;
  end;

  // Reposition past the input sequence
  if (MatchEnd <> -1) then
    AGlyphIterator.Index := MatchEnd + 1
  else
    AGlyphIterator.Step;
end;

procedure TCustomOpenTypeLookupSubTable.Assign(Source: TPersistent);
begin
  inherited;
  if (Source is TCustomOpenTypeLookupSubTable) then
    FSubFormat := TCustomOpenTypeLookupSubTable(Source).SubFormat;
end;


//------------------------------------------------------------------------------
//
//              TCustomOpenTypeLookupSubTableWithCoverage
//
//------------------------------------------------------------------------------
destructor TCustomOpenTypeLookupSubTableWithCoverage.Destroy;
begin
  FreeAndNil(FCoverageTable);
  inherited;
end;

//------------------------------------------------------------------------------

function TCustomOpenTypeLookupSubTableWithCoverage.ApplyChainedContextClass(const ASequenceRules: TChainedSequenceRuleSets;
  const AClassDefinitions: TClassDefinitions;
  var AGlyphIterator: TPascalTypeGlyphIterator): boolean;

  function Match(var Iterator: TPascalTypeGlyphIterator; const Rule: TChainedSequenceRule; var AMatchedIndices: TMatchedIndices): boolean;
  begin
    Result := False;

    (*
      Chained sequence context format 2: class-based glyph contexts
      https://learn.microsoft.com/en-us/typography/opentype/spec/chapter2#chained-sequence-context-format-2-class-based-glyph-contexts

      Matching of the sequence rules with the current glyph sequence requires matching of input, backtrack and
      lookahead sequences. Note that Lookup flags affect matching in backtrack and lookahead sequences as well
      as the input sequence. Backtrack sequence patterns are specified in reverse logical order. Specification
      of backtrack, input and lookahead sequences is the same as described above for Chained sequence context
      format 1, except that sequences are specified using class values rather than glyph IDs.
    *)

    // Input
    // Note: We have already implicitly matched the first character via the
    // coverage table, so we skip that here.
    // [moSkipFirst] because first entry in InputSequence isn't used.
    if (not Iterator.GlyphString.Match(Iterator, Rule.InputSequence, AMatchedIndices, [moSkipFirst, moMoveOnMatch], AClassDefinitions[cpInput].MatchClassByGlyphID)) then
      exit;

    // Save position, just after Input sequence, so we can resume the match for Lookahead there
    var LookaheadIndex := Iterator.Index;

    // Backtrack
    if (Length(Rule.BacktrackSequence) > 0) then
    begin
      // Backtrack starts just before the initial start position
      Iterator.Index := AGlyphIterator.Peek(-1);

      if (not Iterator.GlyphString.Match(Iterator, Rule.BacktrackSequence, [moBackTrack], AClassDefinitions[cpBacktrack].MatchClassByGlyphID)) then
        exit;
    end;

    // Lookahead
    if (Length(Rule.LookaheadSequence) > 0) then
    begin
      // Lookahead starts just after the Input sequence
      Iterator.Index := LookaheadIndex;

      if (not Iterator.GlyphString.Match(Iterator, Rule.LookaheadSequence, [], AClassDefinitions[cpLookahead].MatchClassByGlyphID)) then
        exit;
    end;

    Result := True;
  end;

var
  SequenceRuleSetIndex: integer;
  SequenceRuleSet: TChainedSequenceRuleSet;
  i: integer;
begin
  Result := False;

  // The coverage table contains the index of the first character of the sequence.
  // The index itself isn't used. We just need to determine if we should proceed.
  SequenceRuleSetIndex := CoverageTable.IndexOfGlyph(AGlyphIterator.Glyph.GlyphID);

  if (SequenceRuleSetIndex = -1) then
    Exit;

  // Get the class ID of the first character and use that as an index into the
  // rule set table.
  SequenceRuleSetIndex := AClassDefinitions[cpInput].ClassByGlyphID(AGlyphIterator.Glyph.GlyphID);

  if (SequenceRuleSetIndex < 0) or (SequenceRuleSetIndex > High(ASequenceRules)) then
    Exit;

  SequenceRuleSet := ASequenceRules[SequenceRuleSetIndex];

  var MatchedIndices: TMatchedIndices;

  for i := 0 to High(SequenceRuleSet) do
  begin
    var Iterator := AGlyphIterator.Clone;

    // Compare each character class in the sequence strings to the source string
    if (not Match(Iterator, SequenceRuleSet[i], MatchedIndices)) then
      continue;

    // We have a match; Apply the rules.
    Result := ApplyLookupRecords(AGlyphIterator, MatchedIndices, SequenceRuleSet[i].SequenceLookupRecords);
    break;
  end;
end;

//------------------------------------------------------------------------------

function TCustomOpenTypeLookupSubTableWithCoverage.ApplyChainedContextSimple(const ASequenceRules: TChainedSequenceRuleSets;
  var AGlyphIterator: TPascalTypeGlyphIterator): boolean;
begin
  Result := False;

  // The coverage table contains the index of the first character of the sequence.
  var SequenceRuleSetIndex := CoverageTable.IndexOfGlyph(AGlyphIterator.Glyph.GlyphID);

  if (SequenceRuleSetIndex = -1) then
    Exit;

  // Sequences are grouped by starting character so all members of a group
  // has the same start character.
  var SequenceRuleSet := ASequenceRules[SequenceRuleSetIndex];

  (*
    Chained sequence context format 1: simple glyph contexts"
    https://learn.microsoft.com/en-us/typography/opentype/spec/chapter2#chseqctxt1

    Matching of the sequence rules with the current glyph sequence requires matching of
    input, backtrack and lookahead sequences. Lookup flags affect matching in backtrack and
    lookahead sequences as well as the input sequence.

    Note that the backtrack sequence is given in reverse logical order: if the current glyph
    is at position i in the text glyph buffer, the backtrack sequence begins at i-1 and
    decrements offset values moving away from i. The lookahead sequence begins after the
    input sequence and increases in logical order.
  *)

  var MatchedIndices: TMatchedIndices;

  for var i := 0 to High(SequenceRuleSet) do
  begin
    var Iterator := AGlyphIterator.Clone;

    // Input
    // Compare each character in the sequence string to the source string
    // Note: We have already implicitly matched the first character via the
    // coverage table, so we skip that here.
    // [moSkipFirst] because first entry in InputSequence isn't used.
    if (not Iterator.GlyphString.Match(Iterator, SequenceRuleSet[i].InputSequence, MatchedIndices, [moSkipFirst, moMoveOnMatch])) then
      continue;

    // Save position, just after Input sequence, so we can resume the match for Lookahead there
    var LookaheadIndex := Iterator.Index;

    // Backtrack
    if (Length(SequenceRuleSet[i].BacktrackSequence) > 0) then
    begin
      // Backtrack starts just before the initial start position
      Iterator.Index := AGlyphIterator.Peek(-1);

      if (not Iterator.GlyphString.Match(Iterator, SequenceRuleSet[i].BacktrackSequence, [moBackTrack])) then
        continue;
    end;

    // Lookahead
    if (Length(SequenceRuleSet[i].LookaheadSequence) > 0) then
    begin
      // Lookahead starts just after the Input sequence
      Iterator.Index := LookaheadIndex;

      if (not Iterator.GlyphString.Match(Iterator, SequenceRuleSet[i].LookaheadSequence)) then
        continue;
    end;

    // We have a match; Apply the rules.
    Result := ApplyLookupRecords(AGlyphIterator, MatchedIndices, SequenceRuleSet[i].SequenceLookupRecords);

    break;
  end;
end;

//------------------------------------------------------------------------------

function TCustomOpenTypeLookupSubTableWithCoverage.ApplyContextClass(const ASequenceRules: TSequenceRuleSets;
  AClassDefinitions: TCustomOpenTypeClassDefinitionTable; var AGlyphIterator: TPascalTypeGlyphIterator): boolean;
var
  SequenceRuleSetIndex: integer;
  SequenceRuleSet: TSequenceRuleSet;
  i: integer;
begin
  Result := False;

  // The coverage table contains the index of the first character of the sequence.
  // The index itself isn't used. We just need to determine if we should proceed.
  SequenceRuleSetIndex := CoverageTable.IndexOfGlyph(AGlyphIterator.Glyph.GlyphID);

  if (SequenceRuleSetIndex = -1) then
    Exit;

  // Get the class ID of the first character and use that as an index into the
  // rule set table.
  SequenceRuleSetIndex := AClassDefinitions.ClassByGlyphID(AGlyphIterator.Glyph.GlyphID);

  if (SequenceRuleSetIndex < 0) or (SequenceRuleSetIndex > High(ASequenceRules)) then
    Exit;

  SequenceRuleSet := ASequenceRules[SequenceRuleSetIndex];

  var MatchedIndices: TMatchedIndices;

  for i := 0 to High(SequenceRuleSet) do
  begin
    var Iterator := AGlyphIterator.Clone;

    // Compare each character in the sequence string to the source string.
    // Note: We have already implicitly matched the first character via the
    // coverage table, so we skip that here. Additionally, the first sequence
    // entry (which is always zero) is also skipped.
    // TODO : Why do we use moMoveOnMatch here? We are not using the iterator position after the call.
    if (not Iterator.GlyphString.Match(Iterator, SequenceRuleSet[i].InputSequence, MatchedIndices, [moSkipFirst, moMoveOnMatch], AClassDefinitions.MatchClassByGlyphID)) then
      continue;

    // We have a match; Apply the rules.
    Result := ApplyLookupRecords(AGlyphIterator, MatchedIndices, SequenceRuleSet[i].SequenceLookupRecords);

    break;
  end;
end;

//------------------------------------------------------------------------------

function TCustomOpenTypeLookupSubTableWithCoverage.ApplyContextSimple(const ASequenceRules: TSequenceRuleSets; var AGlyphIterator: TPascalTypeGlyphIterator): boolean;
var
  SequenceRuleSetIndex: integer;
  SequenceRuleSet: TSequenceRuleSet;
  i: integer;
begin
  Result := False;

  // The coverage table contains the index of the first character of the sequence.
  SequenceRuleSetIndex := CoverageTable.IndexOfGlyph(AGlyphIterator.Glyph.GlyphID);

  if (SequenceRuleSetIndex = -1) then
    Exit;

  // Sequences are grouped by starting character so all members of a group
  // has the same start character.
  SequenceRuleSet := ASequenceRules[SequenceRuleSetIndex];

  var MatchedIndices: TMatchedIndices;

  for i := 0 to High(SequenceRuleSet) do
  begin
    var Iterator := AGlyphIterator.Clone;

    // Compare each character in the sequence string to the source string
    // Note: We have already implicitly matched the first character via the
    // coverage table, so we skip that here. Additionally, the first sequence
    // entry (which is always zero) is also skipped.
    // TODO : Why do we use moMoveOnMatch here? We are not using the iterator position after the call.
    if (not Iterator.GlyphString.Match(Iterator, SequenceRuleSet[i].InputSequence, MatchedIndices, [moSkipFirst, moMoveOnMatch])) then
      continue;

    // We have a match; Apply the rules.
    Result := ApplyLookupRecords(AGlyphIterator, MatchedIndices, SequenceRuleSet[i].SequenceLookupRecords);

    break;
  end;
end;

//------------------------------------------------------------------------------

procedure TCustomOpenTypeLookupSubTableWithCoverage.Assign(Source: TPersistent);
begin
  inherited;
  if (Source is TCustomOpenTypeLookupSubTableWithCoverage) then
  begin
    FreeAndNil(FCoverageTable);
    if (TCustomOpenTypeLookupSubTableWithCoverage(Source).CoverageTable <> nil) then
      FCoverageTable := TCustomOpenTypeLookupSubTableWithCoverage(Source).CoverageTable.Clone(Self);
  end;
end;

//------------------------------------------------------------------------------

procedure TCustomOpenTypeLookupSubTableWithCoverage.LoadFromStream(Stream: TStream; Size: Cardinal);
var
  StartPos: Int64;
  CoverageOfs: Word;
  SavePos: Int64;
begin
  FreeAndNil(FCoverageTable);

  StartPos := Stream.Position;

  inherited;

  // Offset from start of sub-table to coverage table
  CoverageOfs := BigEndianValue.ReadWord(Stream);
  SavePos := Stream.Position;

  Stream.Position := StartPos + CoverageOfs;
  FCoverageTable := TCustomOpenTypeCoverageTable.CreateFromStream(Stream, Self);

  // Sub table header continues after Coverage offset
  Stream.Position := SavePos;
end;

//------------------------------------------------------------------------------

procedure TCustomOpenTypeLookupSubTableWithCoverage.SaveToStream(Stream: TStream);
begin
  Assert(FCoverageTable <> nil);

  var StartPos := Stream.Position;

  inherited;

  // Save position coverage table offset
  var CoverageOffsetPos := Stream.Position;
  Stream.Seek(SizeOf(Word), soFromCurrent); // Skip coverage offset

  // Save lookup table
  DoSaveToStream(Stream);

  // Save position of coverage table
  var CoveragePos := Stream.Position;

  // Save coverage table
  FCoverageTable.SaveToStream(Stream);

  var SavePos := Stream.Position;

  // Fix up Coverage Offset and save it
  var CoverageOffset: Word := CoveragePos - StartPos;
  Stream.Position := CoverageOffsetPos;
  BigEndianValue.WriteWord(Stream, CoverageOffset);

  Stream.Position := SavePos;
end;

//------------------------------------------------------------------------------

{ TCustomOpenTypeLookupSubTable.TCoverageTables }

function TCustomOpenTypeLookupSubTable.TCoverageTables.MatchCoverage(AIndex: integer; AItem, GlyphID: TGlyphID): boolean;
begin
  // AIndex is the index into ACoverageTables.
  // AItem is unused.
  Result := (Items[AIndex].IndexOfGlyph(GlyphID) <> -1);
end;

//------------------------------------------------------------------------------

end.