PascalType.Tables.TrueType.CharacterMaps.pas

unit PascalType.Tables.TrueType.CharacterMaps;

////////////////////////////////////////////////////////////////////////////////
//                                                                            //
//  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}

uses
  Classes,
  SysUtils,
  Generics.Defaults,
  PascalType.Types,
  PascalType.Classes,
  PascalType.Tables,
  PascalType.Unicode,
  PascalType.Tables.TrueType.cmap;


//------------------------------------------------------------------------------
//
//              TPascalTypeFormat0CharacterMap
//
//------------------------------------------------------------------------------
// Format 0: Byte encoding table
//------------------------------------------------------------------------------
// https://learn.microsoft.com/en-us/typography/opentype/spec/cmap#format-0-byte-encoding-table
//------------------------------------------------------------------------------
type
  TPascalTypeFormat0CharacterMap = class(TCustomPascalTypeCharacterMap)
  private
    FLength: Word; // This is the length in bytes of the subtable.
    FLanguage: Word; // Please see "Note on the language field in 'cmap' subtables" in the cmap spec.
    FGlyphIdArray: array[Byte] of Byte; // An array that maps character codes to glyph index values.
  protected
    class function GetFormat: Word; override;
  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 CharacterToGlyph(ACodePoint: TPascalTypeCodePoint): Integer; override;
  end;


//------------------------------------------------------------------------------
//
//              TPascalTypeFormat2CharacterMap
//
//------------------------------------------------------------------------------
// Format 2: High-byte mapping through table
//------------------------------------------------------------------------------
// https://learn.microsoft.com/en-us/typography/opentype/spec/cmap#format-2-high-byte-mapping-through-table
//------------------------------------------------------------------------------
type
  TPascalTypeFormat2CharacterMap = class(TCustomPascalTypeCharacterMap)
  private
    FLength: Word; // This is the length in bytes of the subtable.
    FLanguage: Word; // Please see "Note on the language field in 'cmap' subtables" in the cmap spec.
  protected
    class function GetFormat: Word; override;
  public
    procedure Assign(Source: TPersistent); override;

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

    function CharacterToGlyph(ACodePoint: TPascalTypeCodePoint): Integer; override;
  end;


//------------------------------------------------------------------------------
//
//              TPascalTypeFormat4CharacterMap
//
//------------------------------------------------------------------------------
// Format 4: Segment mapping to delta values
//------------------------------------------------------------------------------
// https://learn.microsoft.com/en-us/typography/opentype/spec/cmap#format-4-segment-mapping-to-delta-values
//------------------------------------------------------------------------------
type
  TPascalTypeFormat4CharacterMap = class(TCustomPascalTypeCharacterMap)
  private type
    TSegment = record
      StartCode: Word;
      EndCode: Word;
    end;
  private
    FLength: Word;                    // This is the length in bytes of the subtable.
    FLanguage: Word;                  // Please see "Note on the language field in 'cmap' subtables" in the cmap spec.
    FSegments: TArray<TSegment>;      // Start and End characterCode for each segment, last=0xFFFF.
    FIdDelta: array of SmallInt;      // Delta for all character codes in segment.
    FIdRangeOffset: array of Word;    // Offsets into glyphIdArray or 0
    FGlyphIdArray: TGlyphString;     // Glyph index array (arbitrary length)
  protected
    class function GetFormat: Word; override;
  public
    procedure Assign(Source: TPersistent); override;

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

    function CharacterToGlyph(ACodePoint: TPascalTypeCodePoint): Integer; override;
  end;


//------------------------------------------------------------------------------
//
//              TPascalTypeFormat6CharacterMap
//
//------------------------------------------------------------------------------
// Format 6: Trimmed table mapping
//------------------------------------------------------------------------------
// https://learn.microsoft.com/en-us/typography/opentype/spec/cmap#format-6-trimmed-table-mapping
//------------------------------------------------------------------------------
type
  TPascalTypeFormat6CharacterMap = class(TCustomPascalTypeCharacterMap)
  private
    FLanguage: Word;              // Please see "Note on the language field in 'cmap' subtables" in the cmap spec.
    FFirstCode: Word;             // First character code of subrange.
    FGlyphIdArray: TGlyphString;  // Array of glyph index values for character codes in the range.
    function GetEntryCount: Word;
  protected
    class function GetFormat: Word; override;
  public
    procedure Assign(Source: TPersistent); override;

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

    function CharacterToGlyph(ACodePoint: TPascalTypeCodePoint): Integer; override;

    property EntryCount: Word read GetEntryCount;
  end;


//------------------------------------------------------------------------------
//
//              TPascalTypeFormat10CharacterMap
//
//------------------------------------------------------------------------------
// Format 10: Trimmed array
//------------------------------------------------------------------------------
// https://learn.microsoft.com/en-us/typography/opentype/spec/cmap#format-10-trimmed-array
//------------------------------------------------------------------------------
type
  TPascalTypeFormat10CharacterMap = class(TCustomPascalTypeCharacterMap)
  private
    FLanguage: Cardinal;
    FStartCharCode: Cardinal;
    FGlyphIdArray: TGlyphString;
    function GetEntryCount: Cardinal;
  protected
    class function GetFormat: Word; override;
  public
    procedure Assign(Source: TPersistent); override;

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

    function CharacterToGlyph(ACodePoint: TPascalTypeCodePoint): Integer; override;

    property EntryCount: Cardinal read GetEntryCount;
  end;


//------------------------------------------------------------------------------
//
//              TPascalTypeFormat12CharacterMap
//
//------------------------------------------------------------------------------
// Format 12: Segmented coverage
//------------------------------------------------------------------------------
// https://learn.microsoft.com/en-us/typography/opentype/spec/cmap#format-12-segmented-coverage
//------------------------------------------------------------------------------
type
  TCharMapSegmentedCoverageRecord = packed record
    StartCharCode: TPascalTypeCodePoint; // First character code in this group
    EndCharCode: TPascalTypeCodePoint;   // Last character code in this group
    StartGlyphID: Cardinal;  // Glyph index corresponding to the starting character code
  end;

  TPascalTypeFormat12CharacterMap = class(TCustomPascalTypeCharacterMap)
  private class var
    FComparer: IComparer<TCharMapSegmentedCoverageRecord>;

  private
    class destructor Destroy;

  private
    FLanguage: Cardinal; // Please see "Note on the language field in 'cmap' subtables" in this document.
    FCoverageArray: TArray<TCharMapSegmentedCoverageRecord>;

  protected
    class function GetFormat: Word; override;
    function MapCodePoint(ACodePoint: TPascalTypeCodePoint; const ACoverageRecord: TCharMapSegmentedCoverageRecord): Integer; virtual;

  public
    procedure Assign(Source: TPersistent); override;

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

    function CharacterToGlyph(ACodePoint: TPascalTypeCodePoint): Integer; override;
  end;


//------------------------------------------------------------------------------
//
//              TPascalTypeFormat13CharacterMap
//
//------------------------------------------------------------------------------
// Format 13: Many-to-one range mappings
//------------------------------------------------------------------------------
// https://learn.microsoft.com/en-us/typography/opentype/spec/cmap#format-13-many-to-one-range-mappings
//------------------------------------------------------------------------------
type
  TPascalTypeFormat13CharacterMap = class(TPascalTypeFormat12CharacterMap)
  protected
    class function GetFormat: Word; override;
    function MapCodePoint(ACodePoint: TPascalTypeCodePoint; const ACoverageRecord: TCharMapSegmentedCoverageRecord): Integer; override;
  public
  end;


//------------------------------------------------------------------------------
//
//              TPascalTypeFormat14CharacterMap
//
//------------------------------------------------------------------------------
// Format 14: Unicode Variation Sequences
//------------------------------------------------------------------------------
// https://learn.microsoft.com/en-us/typography/opentype/spec/cmap#format-14-unicode-variation-sequences
//------------------------------------------------------------------------------
type
  TPascalTypeFormat14CharacterMap = class(TCustomPascalTypeCharacterMap)
  private type
    TUnicodeRange = record
      StartUnicodeValue: TPascalTypeCodePoint;  // First value in this range, 24-bit
      AdditionalCount: Byte;                    // Number of additional values in this range
    end;

    TUVSMapping = record
      UnicodeValue: TPascalTypeCodePoint;       // Base Unicode value of the UVS, 24-bit
      GlyphID: Word;                            // Glyph ID of the UVS
    end;

    TDefaultUVS = TArray<TUnicodeRange>;
    TNonDefaultUVS = TArray<TUVSMapping>;

    TVariationSelector = record
      VariationSelector: Cardinal;
      DefaultUVS: TDefaultUVS;
      NonDefaultUVS: TNonDefaultUVS;
    end;

    TVariationSelectors = TArray<TVariationSelector>;
  private
    FVariationSelectors: TVariationSelectors;
  protected
    class function GetFormat: Word; override;
  public
    procedure Assign(Source: TPersistent); override;

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

    function CharacterToGlyph(ACodePoint: TPascalTypeCodePoint): Integer; override;
    function TryGetGlyphID(ACodePoint, ANextCodePoint: TPascalTypeCodePoint; DefaultGlyphID: Word; var Index: integer; out GlyphID: Word): boolean;
  end;

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

implementation

uses
  Math,
  Generics.Collections,
  PascalType.Math,
  PascalType.ResourceStrings;


//------------------------------------------------------------------------------
//
//              TPascalTypeFormat0CharacterMap
//
//------------------------------------------------------------------------------
constructor TPascalTypeFormat0CharacterMap.Create(AParent: TCustomPascalTypeTable);
var
  GlyphIdIndex: Byte;
begin
  inherited;

  for GlyphIdIndex := Low(Byte) to High(Byte) do
    FGlyphIdArray[GlyphIdIndex] := GlyphIdIndex;
end;

class function TPascalTypeFormat0CharacterMap.GetFormat: Word;
begin
  Result := 0;
end;

procedure TPascalTypeFormat0CharacterMap.LoadFromStream(Stream: TStream; Size: Cardinal);
begin
  inherited;

  // check (minimum) table size
  if Stream.Position + 2*SizeOf(Word) + SizeOf(FGlyphIdArray) > Stream.Size then
    raise EPascalTypeTableIncomplete.Create(RCStrTableIncomplete);

  // read length
  FLength := BigEndianValue.ReadWord(Stream);

  // read language
  FLanguage := BigEndianValue.ReadWord(Stream);

  Stream.Read(FGlyphIdArray, SizeOf(FGlyphIdArray));
end;

procedure TPascalTypeFormat0CharacterMap.SaveToStream(Stream: TStream);
begin
  inherited;

  // write length
  BigEndianValue.WriteWord(Stream, FLength);

  // write language
  BigEndianValue.WriteWord(Stream, FLanguage);

  Stream.Write(FGlyphIdArray, SizeOf(FGlyphIdArray));
end;

procedure TPascalTypeFormat0CharacterMap.Assign(Source: TPersistent);
begin
  inherited;
  if Source is TPascalTypeFormat0CharacterMap then
  begin
    FLength := TPascalTypeFormat0CharacterMap(Source).FLength;
    FLanguage := TPascalTypeFormat0CharacterMap(Source).FLanguage;
    FGlyphIdArray := TPascalTypeFormat0CharacterMap(Source).FGlyphIdArray;
  end;
end;

function TPascalTypeFormat0CharacterMap.CharacterToGlyph(ACodePoint: TPascalTypeCodePoint): Integer;
begin
  if (ACodePoint <= High(FGlyphIdArray)) then
    Result := FGlyphIdArray[ACodePoint]
  else
    // raise EPascalTypeError.CreateFmt(RCStrIndexOutOfBounds, [ACodePoint]);
    Result := GlyphNotDef; // Not defined
end;


//------------------------------------------------------------------------------
//
//              TPascalTypeFormat2CharacterMap
//
//------------------------------------------------------------------------------
class function TPascalTypeFormat2CharacterMap.GetFormat: Word;
begin
  Result := 2;
end;

procedure TPascalTypeFormat2CharacterMap.Assign(Source: TPersistent);
begin
  inherited;
  if Source is TPascalTypeFormat2CharacterMap then
  begin
    FLength := TPascalTypeFormat2CharacterMap(Source).FLength;
    FLanguage := TPascalTypeFormat2CharacterMap(Source).FLanguage;
  end;
end;

function TPascalTypeFormat2CharacterMap.CharacterToGlyph(ACodePoint: TPascalTypeCodePoint): Integer;
begin
  Result := ACodePoint;
end;

procedure TPascalTypeFormat2CharacterMap.LoadFromStream(Stream: TStream; Size: Cardinal);
begin
  inherited;

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

  // read length
  FLength := BigEndianValue.ReadWord(Stream);

  // read language
  FLanguage := BigEndianValue.ReadWord(Stream);
end;

procedure TPascalTypeFormat2CharacterMap.SaveToStream(Stream: TStream);
begin
  inherited;

  // write length
  BigEndianValue.WriteWord(Stream, FLength);

  // write language
  BigEndianValue.WriteWord(Stream, FLanguage);
end;


//------------------------------------------------------------------------------
//
//              TPascalTypeFormat4CharacterMap
//
//------------------------------------------------------------------------------
class function TPascalTypeFormat4CharacterMap.GetFormat: Word;
begin
  Result := 4;
end;

procedure TPascalTypeFormat4CharacterMap.Assign(Source: TPersistent);
begin
  inherited;
  if Source is TPascalTypeFormat4CharacterMap then
  begin
    FLength := TPascalTypeFormat4CharacterMap(Source).FLength;
    FLanguage := TPascalTypeFormat4CharacterMap(Source).FLanguage;
    FSegments := Copy(TPascalTypeFormat4CharacterMap(Source).FSegments);
    FIdDelta := Copy(TPascalTypeFormat4CharacterMap(Source).FIdDelta);
    FIdRangeOffset := Copy(TPascalTypeFormat4CharacterMap(Source).FIdRangeOffset);
    FGlyphIdArray := Copy(TPascalTypeFormat4CharacterMap(Source).FGlyphIdArray);
  end;
end;

function TPascalTypeFormat4CharacterMap.CharacterToGlyph(ACodePoint: TPascalTypeCodePoint): Integer;
var
  SegmentIndex: Word;
  GlyphIndex: integer;
  Lo, Hi: Integer;
begin
  if (ACodePoint > High(Word)) then
    Exit(GlyphNotDef);

  // Binary search
  Lo := Low(FSegments);
  Hi := High(FSegments);
  SegmentIndex := 0;
  while (Lo <= Hi) do
  begin
    SegmentIndex := (Lo + Hi) div 2;
    if (ACodePoint > FSegments[SegmentIndex].EndCode) then
      Lo := Succ(SegmentIndex)
    else
    if (ACodePoint < FSegments[SegmentIndex].StartCode) then
      Hi := Pred(SegmentIndex)
    else
      break;
  end;

  if (Lo > Hi) then
    // Missing glyph
    Exit(GlyphNotDef);

  var RangeOffset := FIdRangeOffset[SegmentIndex];
  if RangeOffset <> 0 then
  begin
    // Thank you Apple and Microsoft for the completely bonkers definition
    // of this value.
    GlyphIndex := (
        (RangeOffset div 2 - Length(FIdRangeOffset)) +
        integer(SegmentIndex + ACodePoint - FSegments[SegmentIndex].StartCode)
      ) and $0000FFFF;

    Result := FGlyphIdArray[GlyphIndex];

    // Check for missing character and add offset
    if (Result <> 0) then
      Result := (Result + FIdDelta[SegmentIndex]) and $0000FFFF;
  end else
    Result := (integer(ACodePoint) + FIdDelta[SegmentIndex]) and $0000FFFF;
end;

procedure TPascalTypeFormat4CharacterMap.LoadFromStream(Stream: TStream; Size: Cardinal);
var
  StartPos: Int64;
  SegIndex: Integer;
{$IFDEF StrictExceptions}
  Value16: Word;
{$ENDIF}
  Count: integer;
begin
  StartPos := Stream.Position;

  inherited;

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

  // read length
  FLength := BigEndianValue.ReadWord(Stream);

  // check (minimum) table size
  if StartPos + FLength > Stream.Size then
    raise EPascalTypeTableIncomplete.Create(RCStrTableIncomplete);

  // read language
  FLanguage := BigEndianValue.ReadWord(Stream);

  Count := BigEndianValue.ReadWord(Stream) div 2;
  Stream.Seek(3*SizeOf(Word), soFromCurrent);

  SetLength(FSegments, Count);
  SetLength(FIdDelta, Count);
  SetLength(FIdRangeOffset, Count);

  // read end count
  for SegIndex := 0 to High(FSegments) do
    FSegments[SegIndex].EndCode := BigEndianValue.ReadWord(Stream);

{$IFDEF StrictExceptions}
  // Confirm end code is valid (required for binary search)
  // The specs state that the last entry MUST be $FFFF but we don't need it
  // and it causes some Harfbuzz unit tests to fail. Naturally this is a
  // problem wit the fonts but since we can survive it we might as well
  // ignore the problem.
  if FSegments[High(FSegments)].EndCode <> $FFFF then
    raise EPascalTypeError.CreateFmt(RCStrCharMapErrorEndCount, [FSegments[High(FSegments)].EndCode]);
{$ENDIF}

{$IFDEF StrictExceptions}
  // read reserved
  Value16 := BigEndianValue.ReadWord(Stream);

  // confirm reserved value is valid
  if Value16 <> 0 then
    raise EPascalTypeError.CreateFmt(RCStrCharMapErrorReserved, [Value16]);
{$ELSE}
  // skip reserved
  Stream.Seek(2, soFromCurrent);
{$ENDIF}

  // read start count
  for SegIndex := 0 to High(FSegments) do
  begin
    FSegments[SegIndex].StartCode := BigEndianValue.ReadWord(Stream);

{$IFDEF StrictExceptions}
    // confirm start count is valid
    if FSegments[SegIndex].StartCode > FSegments[SegIndex].EndCode then
      raise EPascalTypeError.CreateFmt(RCStrCharMapErrorStartCount, [FSegments[SegIndex].StartCode]);
{$ENDIF}
  end;

  // read ID delta
  for SegIndex := 0 to High(FIdDelta) do
    Word(FIdDelta[SegIndex]) := BigEndianValue.ReadWord(Stream);

{$IFDEF StrictExceptions}
(*
Disabled: I see no reason why the last entry must be 1. It isn't documented either.
A value of 0 has been observed in the Architecture font. Actually the whole FIdDelta table is zero.
  // confirm ID delta is valid
  if FIdDelta[High(FIdDelta)] <> 1 then
    raise EPascalTypeError.CreateFmt(RCStrCharMapErrorIdDelta, [FIdDelta[High(FIdDelta)]]);
*)
{$ENDIF}

  // read ID range offset
  for SegIndex := 0 to High(FIdRangeOffset) do
    FIdRangeOffset[SegIndex] := BigEndianValue.ReadWord(Stream);

  SetLength(FGlyphIdArray, (FLength - (Stream.Position - StartPos)) div SizeOf(Word));

  // read glyph ID array
  for SegIndex := 0 to High(FGlyphIdArray) do
    FGlyphIdArray[SegIndex] := BigEndianValue.ReadWord(Stream);
end;

procedure TPascalTypeFormat4CharacterMap.SaveToStream(Stream: TStream);
begin
  var StartPos := Stream.Position;

  inherited;

  var SegCount := Length(FSegments);
  var SearchRange: Word;
  var EntrySelector: Word;
  if (SegCount > 0) then
  begin
    SearchRange := (1 shl FloorLog2(SegCount)) * 2;
    EntrySelector := FloorLog2(SegCount);
  end else
  begin
    SearchRange := 0;
    EntrySelector := 0;
  end;

  // write length (to be updated later)
  var LengthPos := Stream.Position;
  BigEndianValue.WriteWord(Stream, 0);

  // write language
  BigEndianValue.WriteWord(Stream, FLanguage);

  // write segCountX2
  BigEndianValue.WriteWord(Stream, SegCount * 2);

  // write searchRange
  BigEndianValue.WriteWord(Stream, SearchRange);

  // write entrySelector
  BigEndianValue.WriteWord(Stream, EntrySelector);

  // write rangeShift
  BigEndianValue.WriteWord(Stream, (SegCount * 2) - SearchRange);

  // write endCode
  for var SegIndex := 0 to SegCount - 1 do
    BigEndianValue.WriteWord(Stream, FSegments[SegIndex].EndCode);

  // write reservedPad
  BigEndianValue.WriteWord(Stream, 0);

  // write startCode
  for var SegIndex := 0 to SegCount - 1 do
    BigEndianValue.WriteWord(Stream, FSegments[SegIndex].StartCode);

  // write idDelta
  for var SegIndex := 0 to SegCount - 1 do
    BigEndianValue.WriteWord(Stream, Word(FIdDelta[SegIndex]));

  // write idRangeOffset
  for var SegIndex := 0 to SegCount - 1 do
    BigEndianValue.WriteWord(Stream, FIdRangeOffset[SegIndex]);

  // write glyph ID array
  for var SegIndex := 0 to High(FGlyphIdArray) do
    BigEndianValue.WriteWord(Stream, FGlyphIdArray[SegIndex]);

  // update length
  var CurrentPos := Stream.Position;
  Stream.Position := LengthPos;
  BigEndianValue.WriteWord(Stream, Word(CurrentPos - StartPos));
  Stream.Position := CurrentPos;
end;


//------------------------------------------------------------------------------
//
//              TPascalTypeFormat6CharacterMap
//
//------------------------------------------------------------------------------
procedure TPascalTypeFormat6CharacterMap.Assign(Source: TPersistent);
begin
  inherited;
  if Source is TPascalTypeFormat6CharacterMap then
  begin
    FLanguage := TPascalTypeFormat6CharacterMap(Source).FLanguage;
    FFirstCode := TPascalTypeFormat6CharacterMap(Source).FFirstCode;
    FGlyphIdArray := Copy(TPascalTypeFormat6CharacterMap(Source).FGlyphIdArray);
  end;
end;

function TPascalTypeFormat6CharacterMap.CharacterToGlyph(ACodePoint: TPascalTypeCodePoint): Integer;
begin
  if (ACodePoint >= FFirstCode) and (integer(ACodePoint - FFirstCode) <= High(FGlyphIdArray)) then
    Result := FGlyphIdArray[ACodePoint - FFirstCode]
  else
    Result := GlyphNotDef;
end;

function TPascalTypeFormat6CharacterMap.GetEntryCount: Word;
begin
  Result := Length(FGlyphIdArray);
end;

class function TPascalTypeFormat6CharacterMap.GetFormat: Word;
begin
  Result := 6
end;

procedure TPascalTypeFormat6CharacterMap.LoadFromStream(Stream: TStream; Size: Cardinal);
var
  EntryIndex: Integer;
begin
  inherited;

  // read table size
  // TableLength := BigEndianValue.ReadWord(Stream);
  Stream.Seek(SizeOf(Word), soFromCurrent);

  // read language
  FLanguage := BigEndianValue.ReadWord(Stream);

  // read first code
  FFirstCode := BigEndianValue.ReadWord(Stream);

  // read number of character codes in subrange
  SetLength(FGlyphIdArray, BigEndianValue.ReadWord(Stream));

  for EntryIndex := 0 to High(FGlyphIdArray) do
    FGlyphIdArray[EntryIndex] := BigEndianValue.ReadWord(Stream);
end;

procedure TPascalTypeFormat6CharacterMap.SaveToStream(Stream: TStream);
var
  EntryIndex: Integer;
begin
  inherited;

  // write table size
  BigEndianValue.WriteWord(Stream, 8 + 2 * Length(FGlyphIdArray));

  // write language
  BigEndianValue.WriteWord(Stream, FLanguage);

  // write first code
  BigEndianValue.WriteWord(Stream, FFirstCode);

  // write number of character codes in subrange
  BigEndianValue.WriteWord(Stream, Length(FGlyphIdArray));

  // write glyph indices
  for EntryIndex := 0 to High(FGlyphIdArray) do
    BigEndianValue.WriteWord(Stream, FGlyphIdArray[EntryIndex]);
end;


//------------------------------------------------------------------------------
//
//              TPascalTypeFormat10CharacterMap
//
//------------------------------------------------------------------------------
procedure TPascalTypeFormat10CharacterMap.Assign(Source: TPersistent);
begin
  inherited;
  if Source is TPascalTypeFormat10CharacterMap then
  begin
    FLanguage := TPascalTypeFormat10CharacterMap(Source).FLanguage;
    FStartCharCode := TPascalTypeFormat10CharacterMap(Source).FStartCharCode;
    FGlyphIdArray := Copy(TPascalTypeFormat10CharacterMap(Source).FGlyphIdArray);
  end;
end;

function TPascalTypeFormat10CharacterMap.CharacterToGlyph(ACodePoint: TPascalTypeCodePoint): Integer;
begin
  if (ACodePoint >= FStartCharCode) and (ACodePoint < FStartCharCode + EntryCount) then
    Result := FGlyphIdArray[ACodePoint - FStartCharCode]
  else
    Result := GlyphNotDef;
end;

function TPascalTypeFormat10CharacterMap.GetEntryCount: Cardinal;
begin
  Result := Length(FGlyphIdArray);
end;

class function TPascalTypeFormat10CharacterMap.GetFormat: Word;
begin
  Result := 10;
end;

procedure TPascalTypeFormat10CharacterMap.LoadFromStream(Stream: TStream; Size: Cardinal);
var
  StartPos: Int64;
  TableLength: Cardinal;
  EntryIndex: Integer;
begin
  StartPos := Stream.Position;

  inherited;

  // reserved
  Stream.Seek(2, soFromCurrent);

  // read table length
  TableLength := BigEndianValue.ReadCardinal(Stream);

  // read language
  FLanguage := BigEndianValue.ReadCardinal(Stream);

  // read start char code
  FStartCharCode := BigEndianValue.ReadCardinal(Stream);

  // read number of character codes in subrange
  var EntryCount := BigEndianValue.ReadCardinal(Stream);
  if EntryCount > 65535 then
    raise EPascalTypeError.CreateFmt(RCStrValueOutOfBounds, [EntryCount]);

  if (StartPos + TableLength > Stream.Size) or
     (Stream.Position + (EntryCount * SizeOf(Word)) > StartPos + TableLength) then
    raise EPascalTypeTableIncomplete.Create(RCStrTableIncomplete);

  SetLength(FGlyphIdArray, EntryCount);

  for EntryIndex := 0 to High(FGlyphIdArray) do
    FGlyphIdArray[EntryIndex] := BigEndianValue.ReadWord(Stream);

  // seek end of this table
  Stream.Position := StartPos + TableLength;
end;

procedure TPascalTypeFormat10CharacterMap.SaveToStream(Stream: TStream);
var
  StartPos: Int64;
  CurrentPos: Int64;
  EntryIndex: Integer;
begin
  StartPos := Stream.Position;

  inherited;

  // reserved
  BigEndianValue.WriteWord(Stream, 0);

  // write table length (to be updated later)
  BigEndianValue.WriteCardinal(Stream, 0);

  // write language
  BigEndianValue.WriteCardinal(Stream, FLanguage);

  // write start char code
  BigEndianValue.WriteCardinal(Stream, FStartCharCode);

  // write number of character codes in subrange
  BigEndianValue.WriteCardinal(Stream, EntryCount);

  for EntryIndex := 0 to High(FGlyphIdArray) do
    BigEndianValue.WriteWord(Stream, FGlyphIdArray[EntryIndex]);

  // update table length
  CurrentPos := Stream.Position;
  Stream.Position := StartPos + 4;
  BigEndianValue.WriteCardinal(Stream, Cardinal(CurrentPos - StartPos));
  Stream.Position := CurrentPos;
end;


//------------------------------------------------------------------------------
//
//              TPascalTypeFormat12CharacterMap
//
//------------------------------------------------------------------------------
class destructor TPascalTypeFormat12CharacterMap.Destroy;
begin
  FComparer := nil;
end;

class function TPascalTypeFormat12CharacterMap.GetFormat: Word;
begin
  Result := 12;
end;

procedure TPascalTypeFormat12CharacterMap.Assign(Source: TPersistent);
begin
  inherited;
  if Source is TPascalTypeFormat12CharacterMap then
  begin
    FLanguage := TPascalTypeFormat12CharacterMap(Source).FLanguage;
    FCoverageArray := Copy(TPascalTypeFormat12CharacterMap(Source).FCoverageArray);
  end;
end;

function TPascalTypeFormat12CharacterMap.CharacterToGlyph(ACodePoint: TPascalTypeCodePoint): Integer;
begin
  if (FComparer = nil) then
    FComparer := TComparer<TCharMapSegmentedCoverageRecord>.Construct(
      function(const ATableItem, ASearchItem: TCharMapSegmentedCoverageRecord): integer
      begin
        Result := integer(ATableItem.EndCharCode) - integer(ASearchItem.EndCharCode);
        if (Result > 0) then
        begin
          Result := integer(ATableItem.StartCharCode) - integer(ASearchItem.StartCharCode);
          if (Result < 0) then
            Result := 0;
        end;
      end);

  var SearchItem: TCharMapSegmentedCoverageRecord;
  SearchItem.StartCharCode := ACodePoint;
  SearchItem.EndCharCode := ACodePoint;
  var Index: integer;

  if (TArray.BinarySearch<TCharMapSegmentedCoverageRecord>(FCoverageArray, SearchItem, Index, FComparer)) then
    Result := MapCodePoint(ACodePoint, FCoverageArray[Index])
  else
    Result := GlyphNotDef;
end;

function TPascalTypeFormat12CharacterMap.MapCodePoint(ACodePoint: TPascalTypeCodePoint;
  const ACoverageRecord: TCharMapSegmentedCoverageRecord): Integer;
begin
  Result := Integer(ACoverageRecord.StartGlyphID) + (Integer(ACodePoint) - Integer(ACoverageRecord.StartCharCode))
end;

procedure TPascalTypeFormat12CharacterMap.LoadFromStream(Stream: TStream; Size: Cardinal);
var
  StartPos: Int64;
  TableLength: Cardinal;
  GroupIndex: Integer;
begin
  StartPos := Stream.Position;

  inherited;

{$IFDEF StrictExceptions}
  if BigEndianValue.ReadWord(Stream) <> 0 then
    raise EPascalTypeError.Create(RCStrReservedValueError);
{$ELSE}
  Stream.Seek(2, soFromCurrent);
{$ENDIF}
  // read table length
  TableLength := BigEndianValue.ReadCardinal(Stream);

  // read language
  FLanguage := BigEndianValue.ReadCardinal(Stream);

  // read group count
  var GroupCount := BigEndianValue.ReadCardinal(Stream);
  if GroupCount > 65535 then
    raise EPascalTypeError.CreateFmt(RCStrValueOutOfBounds, [GroupCount]);

  if (StartPos + TableLength > Stream.Size) or
     (Stream.Position + (GroupCount * 12) > StartPos + TableLength) then
    raise EPascalTypeTableIncomplete.Create(RCStrTableIncomplete);

  SetLength(FCoverageArray, GroupCount);

  for GroupIndex := 0 to High(FCoverageArray) do
  begin
    FCoverageArray[GroupIndex].StartCharCode := BigEndianValue.ReadCardinal(Stream);
    FCoverageArray[GroupIndex].EndCharCode := BigEndianValue.ReadCardinal(Stream);
    FCoverageArray[GroupIndex].StartGlyphID := BigEndianValue.ReadCardinal(Stream);
  end;

  // seek end of this table
  // TODO : Why?
  Stream.Position := StartPos + TableLength;
end;

procedure TPascalTypeFormat12CharacterMap.SaveToStream(Stream: TStream);
var
  StartPos: Int64;
  GroupIndex: Integer;
  CurrentPos: Int64;
begin
  StartPos := Stream.Position;

  inherited;

  // reserved
  BigEndianValue.WriteWord(Stream, 0);

  // write table length (to be updated later)
  BigEndianValue.WriteCardinal(Stream, 0);

  // write language
  BigEndianValue.WriteCardinal(Stream, FLanguage);

  // write group count
  BigEndianValue.WriteCardinal(Stream, Length(FCoverageArray));

  for GroupIndex := 0 to High(FCoverageArray) do
  begin
    BigEndianValue.WriteCardinal(Stream, FCoverageArray[GroupIndex].StartCharCode);
    BigEndianValue.WriteCardinal(Stream, FCoverageArray[GroupIndex].EndCharCode);
    BigEndianValue.WriteCardinal(Stream, FCoverageArray[GroupIndex].StartGlyphID);
  end;

  // update table length
  CurrentPos := Stream.Position;
  Stream.Position := StartPos + 4;
  BigEndianValue.WriteCardinal(Stream, Cardinal(CurrentPos - StartPos));
  Stream.Position := CurrentPos;
end;


//------------------------------------------------------------------------------
//
//              TPascalTypeFormat13CharacterMap
//
//------------------------------------------------------------------------------
class function TPascalTypeFormat13CharacterMap.GetFormat: Word;
begin
  Result := 13;
end;

function TPascalTypeFormat13CharacterMap.MapCodePoint(ACodePoint: TPascalTypeCodePoint;
  const ACoverageRecord: TCharMapSegmentedCoverageRecord): Integer;
begin
  Result := integer(ACoverageRecord.StartGlyphID);
end;


//------------------------------------------------------------------------------
//
//              TPascalTypeFormat14CharacterMap
//
//------------------------------------------------------------------------------
procedure TPascalTypeFormat14CharacterMap.Assign(Source: TPersistent);
var
  i: Integer;
begin
  inherited;
  if Source is TPascalTypeFormat14CharacterMap then
  begin
    SetLength(FVariationSelectors, Length(TPascalTypeFormat14CharacterMap(Source).FVariationSelectors));
    for i := 0 to High(FVariationSelectors) do
    begin
      FVariationSelectors[i].VariationSelector := TPascalTypeFormat14CharacterMap(Source).FVariationSelectors[i].VariationSelector;
      FVariationSelectors[i].DefaultUVS := Copy(TPascalTypeFormat14CharacterMap(Source).FVariationSelectors[i].DefaultUVS);
      FVariationSelectors[i].NonDefaultUVS := Copy(TPascalTypeFormat14CharacterMap(Source).FVariationSelectors[i].NonDefaultUVS);
    end;
  end;
end;

function TPascalTypeFormat14CharacterMap.CharacterToGlyph(ACodePoint: TPascalTypeCodePoint): Integer;
begin
  Result := GlyphNotDef; // Not yet supported
end;

function TPascalTypeFormat14CharacterMap.TryGetGlyphID(ACodePoint, ANextCodePoint: TPascalTypeCodePoint; DefaultGlyphID: Word;
  var Index: integer; out GlyphID: Word): boolean;
var
  Lo, Hi, Mid: Integer;
  NonDefaultUVS: TNonDefaultUVS;
  DefaultUVS: TDefaultUVS;
begin
  Result := False;

  if (ANextCodePoint = 0) or (not PascalTypeUnicode.IsVariationSelector(ANextCodePoint)) then
    exit;

  // Binary search for VariationSelector
  Mid := 0;
  Lo := Low(FVariationSelectors);
  Hi := High(FVariationSelectors);
  while (Lo <= Hi) do
  begin
    Mid := (Lo + Hi) div 2;
    if (ANextCodePoint > FVariationSelectors[Mid].VariationSelector) then
      Lo := Succ(Mid)
    else
    if (ANextCodePoint < FVariationSelectors[Mid].VariationSelector) then
      Hi := Pred(Mid)
    else
      break;
  end;
  if (Lo > Hi) then
    exit;

  NonDefaultUVS := FVariationSelectors[Mid].NonDefaultUVS;
  DefaultUVS := FVariationSelectors[Mid].DefaultUVS;

  // If the sequence is a non-default UVS, return the mapped glyph
  // Binary search for VariationSelector
  Lo := Low(NonDefaultUVS);
  Hi := High(NonDefaultUVS);
  while (Lo <= Hi) do
  begin
    Mid := (Lo + Hi) div 2;
    if (ACodePoint > NonDefaultUVS[Mid].UnicodeValue) then
      Lo := Succ(Mid)
    else
    if (ACodePoint < NonDefaultUVS[Mid].UnicodeValue) then
      Hi := Pred(Mid)
    else
    begin
      GlyphID := NonDefaultUVS[Mid].GlyphID;
      Inc(Index, 2);
      Exit(True);
    end;
  end;

  // If the sequence is a default UVS, return the default glyph
  Lo := Low(DefaultUVS);
  Hi := High(DefaultUVS);
  while (Lo <= Hi) do
  begin
    Mid := (Lo + Hi) div 2;
    if (ACodePoint < DefaultUVS[Mid].StartUnicodeValue) then
      Hi := Pred(Mid)
    else
    if (ACodePoint > DefaultUVS[Mid].StartUnicodeValue + DefaultUVS[Mid].AdditionalCount) then
      Lo := Succ(Mid)
    else
    begin
      GlyphID := DefaultGlyphID;
      Inc(Index, 2);
      Exit(True);
    end;
  end;

  // At this point we are neither a non-default UVS nor a default UVS,
  // but we know the next codepoint is a variation selector.
  //
  //   http://unicode.org/faq/unsup_char.html#4
  //
  //   Q: What is the intended display for variation selector sequences (including unsupported ones)?
  //
  //   A: The expected rendering behavior for the sequence of character plus a variation selector (C+VS)
  //      is specified as follows:
  //
  //      - If C + VS is listed in StandardizedVariants.txt or in the Ideographic Variation Database
  //        and is supported by the rendering system, then display with the specified glyph.
  //
  //      - If C + FE0F is listed in emoji-variant-sequences.txt, display C as emoji, if supported.
  //
  //      - If C + FE0E is listed in emoji-variant-sequences.txt, display C with a regular, non-emoji
  //        glyph, if supported.
  //
  //      - Otherwise, display with the normal glyph for C (with no visible rendering for the VS).
  //
  //   If C is unsupported see Q: "How should characters be displayed if the rendering system doesn't
  //   fully support them?"
  //
  //   A VS sequence may also be part of a grapheme cluster, such as an emoji sequence. See UTS #51
  //   Unicode Emoji for more details about emoji display.
  GlyphID := DefaultGlyphID;
  Inc(Index, 2);
  Result := True;
end;

class function TPascalTypeFormat14CharacterMap.GetFormat: Word;
begin
  Result := 14;
end;

procedure TPascalTypeFormat14CharacterMap.LoadFromStream(Stream: TStream; Size: Cardinal);
var
  StartPos: Int64;
//  TableLength: Cardinal;
  i, j: integer;
  Offsets: array of record
    DefaultUVSOffset: Cardinal;
    NonDefaultUVSOffset: Cardinal;
  end;
begin
  // +-------------------+------------------------------------+------------------------------------------------------+
  // | Type              | Name                               | Description                                          |
  // +===================+====================================+======================================================+
  // | uint16            | format                             | Subtable format. Set to 14.                          |
  // +-------------------+------------------------------------+------------------------------------------------------+
  // | uint32            | length                             | Byte length of this subtable (including this header) |
  // +-------------------+------------------------------------+------------------------------------------------------+
  // | uint32            | numVarSelectorRecords              | Number of variation Selector Records                 |
  // +-------------------+------------------------------------+------------------------------------------------------+
  // | VariationSelector | varSelector[numVarSelectorRecords] | Array of VariationSelector records.                  |
  // +-------------------+------------------------------------+------------------------------------------------------+

  StartPos := Stream.Position;

  inherited;

  var TableLength := BigEndianValue.ReadCardinal(Stream);
  if StartPos + TableLength > Stream.Size then
    raise EPascalTypeTableIncomplete.Create(RCStrTableIncomplete);

  var VarSelectorCount := BigEndianValue.ReadCardinal(Stream);
  if VarSelectorCount > 65535 then
    raise EPascalTypeError.CreateFmt(RCStrValueOutOfBounds, [VarSelectorCount]);

  SetLength(FVariationSelectors, VarSelectorCount);
  SetLength(Offsets, Length(FVariationSelectors));

  for i := 0 to High(FVariationSelectors) do
  begin
    // +----------+---------------------+----------------------------------------------------+
    // | Type     | Name                | Description                                        |
    // +==========+=====================+====================================================+
    // | uint24   | varSelector         | Variation selector                                 |
    // +----------+---------------------+----------------------------------------------------+
    // | Offset32 | defaultUVSOffset    | Offset from the start of the format 14 subtable to |
    // |          |                     | Default UVS Table. May be 0.                       |
    // +----------+---------------------+----------------------------------------------------+
    // | Offset32 | nonDefaultUVSOffset | Offset from the start of the format 14 subtable to |
    // |          |                     | Non-Default UVS Table. May be 0.                   |
    // +----------+---------------------+----------------------------------------------------+
    FVariationSelectors[i].VariationSelector := BigEndianValue.ReadUInt24(Stream);

    Offsets[i].DefaultUVSOffset := BigEndianValue.ReadCardinal(Stream);
    Offsets[i].NonDefaultUVSOffset := BigEndianValue.ReadCardinal(Stream);
  end;

  for i := 0 to High(FVariationSelectors) do
  begin
    if (Offsets[i].DefaultUVSOffset <> 0) then
    begin
      Stream.Position := StartPos + Offsets[i].DefaultUVSOffset;

      // Default UVS table
      // +--------------+-------------------------------+-------------------------------------+
      // | Type         | Name                          | Description                         |
      // +==============+===============================+=====================================+
      // | uint32       | numUnicodeValueRanges         | Number of Unicode character ranges. |
      // +--------------+-------------------------------+-------------------------------------+
      // | UnicodeRange | ranges[numUnicodeValueRanges] | Array of UnicodeRange records.      |
      // +--------------+-------------------------------+-------------------------------------+
      var RangeCount := BigEndianValue.ReadCardinal(Stream);
      if RangeCount > 65535 then
        raise EPascalTypeError.CreateFmt(RCStrValueOutOfBounds, [RangeCount]);
      SetLength(FVariationSelectors[i].DefaultUVS, RangeCount);

      for j := 0 to High(FVariationSelectors[i].DefaultUVS) do
      begin
        // UnicodeRange Record
        // +--------+-------------------+-------------------------------------------+
        // | Type   | Name              | Description                               |
        // +========+===================+===========================================+
        // | uint24 | startUnicodeValue | First value in this range                 |
        // +--------+-------------------+-------------------------------------------+
        // | uint8  | additionalCount   | Number of additional values in this range |
        // +--------+-------------------+-------------------------------------------+
        FVariationSelectors[i].DefaultUVS[j].StartUnicodeValue := BigEndianValue.ReadUInt24(Stream);
        FVariationSelectors[i].DefaultUVS[j].AdditionalCount := BigEndianValue.ReadByte(Stream);
      end;
    end;

    if (Offsets[i].NonDefaultUVSOffset <> 0) then
    begin
      Stream.Position := StartPos + Offsets[i].NonDefaultUVSOffset;

      // Non-Default UVS table
      // +------------+-----------------------------+------------------------------------+
      // | Type       | Name                        | Description                        |
      // +============+=============================+====================================+
      // | uint32     | numUVSMappings              | Number of UVS Mappings that follow |
      // +------------+-----------------------------+------------------------------------+
      // | UVSMapping | uvsMappings[numUVSMappings] | Array of UVSMapping records.       |
      // +------------+-----------------------------+------------------------------------+
      var MappingCount := BigEndianValue.ReadCardinal(Stream);
      if MappingCount > 65535 then
        raise EPascalTypeError.CreateFmt(RCStrValueOutOfBounds, [MappingCount]);
      SetLength(FVariationSelectors[i].NonDefaultUVS, MappingCount);

      for j := 0 to High(FVariationSelectors[i].NonDefaultUVS) do
      begin
        // UVSMapping Record
        // +--------+--------------+-------------------------------+
        // | Type   | Name         | Description                   |
        // +========+==============+===============================+
        // | uint24 | unicodeValue | Base Unicode value of the UVS |
        // +--------+--------------+-------------------------------+
        // | uint16 | glyphID      | Glyph ID of the UVS           |
        // +--------+--------------+-------------------------------+
        FVariationSelectors[i].NonDefaultUVS[j].UnicodeValue := BigEndianValue.ReadUInt24(Stream);
        FVariationSelectors[i].NonDefaultUVS[j].GlyphID := BigEndianValue.ReadWord(Stream);
      end;
    end;
  end;
end;

procedure TPascalTypeFormat14CharacterMap.SaveToStream(Stream: TStream);
var
  Offsets: array of record
    DefaultUVSOffset: Cardinal;
    NonDefaultUVSOffset: Cardinal;
  end;
begin
  var StartPos := Stream.Position;

  inherited;

  // length (updated later)
  var LengthPos := Stream.Position;
  Stream.Seek(SizeOf(Cardinal), soFromCurrent);

  // numVarSelectorRecords
  BigEndianValue.WriteCardinal(Stream, Length(FVariationSelectors));

  SetLength(Offsets, Length(FVariationSelectors));

  // variation records (written later)
  var LengthVarRecsPos := Stream.Position;
  Stream.Seek(Length(FVariationSelectors) * (3 + SizeOf(Cardinal) + SizeOf(Cardinal)), soFromCurrent);

  // Write Default UVS tables
  for var i := 0 to High(FVariationSelectors) do
  begin
    if Length(FVariationSelectors[i].DefaultUVS) > 0 then
    begin
      Offsets[i].DefaultUVSOffset := Cardinal(Stream.Position - StartPos);
      BigEndianValue.WriteCardinal(Stream, Length(FVariationSelectors[i].DefaultUVS));
      for var j := 0 to High(FVariationSelectors[i].DefaultUVS) do
      begin
        BigEndianValue.WriteUInt24(Stream, FVariationSelectors[i].DefaultUVS[j].StartUnicodeValue);
        BigEndianValue.WriteByte(Stream, FVariationSelectors[i].DefaultUVS[j].AdditionalCount);
      end;
    end else
      Offsets[i].DefaultUVSOffset := 0;
  end;

  // Write Non-Default UVS tables
  for var i := 0 to High(FVariationSelectors) do
  begin
    if Length(FVariationSelectors[i].NonDefaultUVS) > 0 then
    begin
      Offsets[i].NonDefaultUVSOffset := Cardinal(Stream.Position - StartPos);
      BigEndianValue.WriteCardinal(Stream, Length(FVariationSelectors[i].NonDefaultUVS));
      for var j := 0 to High(FVariationSelectors[i].NonDefaultUVS) do
      begin
        BigEndianValue.WriteUInt24(Stream, FVariationSelectors[i].NonDefaultUVS[j].UnicodeValue);
        BigEndianValue.WriteWord(Stream, FVariationSelectors[i].NonDefaultUVS[j].GlyphID);
      end;
    end else
      Offsets[i].NonDefaultUVSOffset := 0;
  end;

  var CurrentPos := Stream.Position;

  // Update length
  Stream.Position := LengthPos;
  BigEndianValue.WriteCardinal(Stream, Cardinal(CurrentPos - StartPos));

  // Update offsets in VariationSelector records
  Stream.Position := LengthVarRecsPos;
  for var i := 0 to High(FVariationSelectors) do
  begin
    Stream.Seek(3, soFromCurrent); // skip varSelector
    BigEndianValue.WriteCardinal(Stream, Offsets[i].DefaultUVSOffset);
    BigEndianValue.WriteCardinal(Stream, Offsets[i].NonDefaultUVSOffset);
  end;

  Stream.Position := CurrentPos;
end;

initialization

  PascalTypeCharacterMaps.RegisterCharacterMaps([
    TPascalTypeFormat0CharacterMap, TPascalTypeFormat2CharacterMap, TPascalTypeFormat4CharacterMap,
    TPascalTypeFormat6CharacterMap, TPascalTypeFormat10CharacterMap, TPascalTypeFormat12CharacterMap,
    TPascalTypeFormat13CharacterMap, TPascalTypeFormat14CharacterMap]);

end.