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 = TList<TCustomOpenTypeCoverageTable>;
    TContextCoverageTables = array[TContextPart] of TCoverageTables;

  private
    FSubFormat: Word;
    function GetLookupTable: TCustomOpenTypeLookupTable;

  protected
    function ApplyLookupRecords(var AGlyphIterator: TPascalTypeGlyphIterator; ANextIndex: integer; const LookupRecords: TSequenceLookupRecords): boolean;

  protected
    function MatchCoverage(var AGlyphIterator: TPascalTypeGlyphIterator; ACoverageTables: TCoverageTables; out ALastMatchedIndex: integer; 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
    TGlyphMapperDelegate = TPascalTypeGlyphString.TGlyphMapperDelegate;
    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.AsAnsiChar), 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; out ALastMatchedIndex: integer; AOptions: TMatchOptions): boolean;
begin
  ALastMatchedIndex := -1;

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

  var Iterator := AGlyphIterator.Clone;

  for var i := 0 to ACoverageTables.Count-1 do
  begin
    if (Iterator.EOF) then
      Exit(False);

    var CoverageIndex := ACoverageTables[i].IndexOfGlyph(Iterator.Glyph.GlyphID);
    if (CoverageIndex = -1) then
      Exit(False);

    ALastMatchedIndex := Iterator.Index;

    if (moBacktrack in AOptions) then
      Iterator.Previous
    else
      Iterator.Next;
  end;

  if (moMoveOnMatch in AOptions) then
    AGlyphIterator.Index := Iterator.Index;

  Result := True;
end;

function TCustomOpenTypeLookupSubTable.MatchCoverage(var AGlyphIterator: TPascalTypeGlyphIterator; ACoverageTables: TCoverageTables; AOptions: TMatchOptions): boolean;
var
  LastMatchedIndex: integer;
begin
  Result := MatchCoverage(AGlyphIterator, ACoverageTables, LastMatchedIndex, 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 LastMatchedIndex: integer := -1;
  if (ACoverageTables[cpInput].Count > 0) then
  begin

    if (not MatchCoverage(Iterator, ACoverageTables[cpInput], LastMatchedIndex, [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, LookaheadIndex, ASequenceRules);
end;

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

  if (AGlyphIterator.Index + ACoverageTables.Count > AGlyphIterator.GlyphString.Count) then
    exit;

  var Iterator := AGlyphIterator.Clone;

  // 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.
  var LastMatchedIndex: integer;
  if (not MatchCoverage(Iterator, ACoverageTables, LastMatchedIndex, [moMoveOnMatch])) then
    exit;

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

function TCustomOpenTypeLookupSubTable.ApplyLookupRecords(var AGlyphIterator: TPascalTypeGlyphIterator; ANextIndex: integer;
  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
    AGlyphIterator.Index := ANextIndex;
    Exit(True);
  end;

  // Note:
  // ANextIndex contains the position the iterator must have after skipping the input
  // sequence, in the current state of the glyph string - before any substitutions has
  // been made. We adjust for glyphs added/deleted at the end when we reposition to
  // ANextIndex.

  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.
  *)
  var StartCount := AGlyphIterator.GlyphString.Count;

  for var i := 0 to High(LookupRecords) do
  begin

    var Iterator := AGlyphIterator.Clone;

    // Adjust delta for glyphs added or deleted (in prior loop iterations);
    // If a preceding lookup record changed the length of the glyph string (e.g. inserted
    // or deleted glyphs), then the SequenceIndex of subsequent records (which is relative
    // to the original sequence) will point to a different physical glyph in the modified
    // buffer if we just apply the same offset to the base index.
    // The spec requires that each record applies to the results of the preceding one,
    // which implies the engine must track these buffer modifications within the sequence.
    (* It turnes out that this isn't necessary at all; The lookups (or rather the value of
    ** SequenceIndex already takes deletions and insertions into account.
    var Delta := Iterator.GlyphString.Count - StartCount;
    *)
    var Delta := 0;

    // Adjust the glyph index
    if (Iterator.Next(LookupRecords[i].SequenceIndex + Delta) = -1) then
      // Sequence starts past end of string so we cannot apply the lookup.
      // This is likely a bug in the font. The more correct thing to do if
      // this occurs would probably be to exit.
      continue;

    // 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);

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

  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.
  *)

  // Reposition past the input sequence, adjusted for deletions/insertions performed
  // by ApplyLookupRecords.
  // TODO : Do we skip the input sequence if no lookups were applied (i.e. Result=False)?
  AGlyphIterator.Index := ANextIndex + (AGlyphIterator.GlyphString.Count - StartCount);

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; out ALastMatchedIndex: integer): boolean;
  begin
    Result := False;
    ALastMatchedIndex := AGlyphIterator.Index;

    (*
      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 (Length(Rule.InputSequence) > 1) then
    begin
      if (not Iterator.GlyphString.Match(Iterator, 1, Rule.InputSequence, ALastMatchedIndex, AClassDefinitions[cpInput].ClassByGlyphID, [moSkipFirst, moMoveOnMatch])) then
        exit;
    end else
      Iterator.Next(1);

    // 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, 0, Rule.BacktrackSequence, AClassDefinitions[cpBacktrack].ClassByGlyphID, [moBackTrack])) 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, 0, Rule.LookaheadSequence, AClassDefinitions[cpLookahead].ClassByGlyphID)) then
        exit;
    end;

    Iterator.Index := LookaheadIndex;
    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];

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

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

    // We have a match; Apply the rules.
    Result := ApplyLookupRecords(AGlyphIterator, Iterator.Index, 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.
  *)

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

    // 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 (Length(SequenceRuleSet[i].InputSequence) > 1) then
    begin
      if (not Iterator.GlyphString.Match(Iterator, 1, SequenceRuleSet[i].InputSequence, LastMatchedIndex, [moSkipFirst, moMoveOnMatch])) then
        continue;
    end else
      Iterator.Next(1);

    // 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, 0, 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, 0, SequenceRuleSet[i].LookaheadSequence)) then
        continue;
    end;


    // We have a match; Apply the rules.
    Result := ApplyLookupRecords(AGlyphIterator, LookaheadIndex, 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];

  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.
    if (Length(SequenceRuleSet[i].InputSequence) > 1) then
    begin
      var LastMatchedIndex := AGlyphIterator.Index;

      if (not Iterator.GlyphString.Match(Iterator, 1, SequenceRuleSet[i].InputSequence, LastMatchedIndex, AClassDefinitions.ClassByGlyphID, [moSkipFirst, moMoveOnMatch])) then
        continue;
    end else
      Iterator.Next(1);

    // We have a match; Apply the rules.
    Result := ApplyLookupRecords(AGlyphIterator, Iterator.Index, 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];

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

    // 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.
    if (not Iterator.GlyphString.Match(Iterator, 1, SequenceRuleSet[i].InputSequence, LastMatchedIndex, [moSkipFirst, moMoveOnMatch])) then
      continue;

    // We have a match; Apply the rules.
    Result := ApplyLookupRecords(AGlyphIterator, Iterator.Index, 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;

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

end.