PascalType.Shaper.Script.Indic2.pas

unit PascalType.Shaper.Script.Indic2;

////////////////////////////////////////////////////////////////////////////////
//                                                                            //
//      Shaper for Indic scripts.                                             //
//                                                                            //
//      Supports Devanagari, Bengali, Gurmukhi, Gujarati, Oriya, Tamil,       //
//      Telugu, Kannada, and Malayalam.                                       //
//                                                                            //
//      Follows the "New" OpenType Indic spec (v2) and implements a generic   //
//      syllabic model based on the Universal Shaping Engine.                 //
//                                                                            //
////////////////////////////////////////////////////////////////////////////////
//                                                                            //
//  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 Anders Melander                     //
//                                                                            //
//  Portions created by Anders Melander are Copyright (C) 2025-2026           //
//  by Anders Melander. All Rights Reserved.                                  //
//                                                                            //
////////////////////////////////////////////////////////////////////////////////

interface

{$I PT_Compiler.inc}

uses
  System.Generics.Collections,
  PascalType.Types,
  PascalType.Unicode,
  PascalType.GlyphString,
  PascalType.Shaper,
  PascalType.Shaper.Script.Default,
  PascalType.Shaper.Plan,
  PascalType.Shaper.Layout;

type
  TTagMap = record
    Indic1: TPascalTypeTag;
    Indic2: TPascalTypeTag;
  end;

  TIndicScript = (
    isDevanagari,
    isBengali,
    isGurmukhi,
    isGujarati,
    isOriya,
    isTamil,
    isTelugu,
    isKannada,
    isMalayalam,
    isSinhala
  );

  TBasePos = (bpLast, bpLastSinhala, bpFirst);

  TRephMode = (rmExplicit, rmImplicit, rmLogicalRepha, rmVisualRepha);

  TBlwfMode = (bmPostOnly, bmPreAndPost);

  TIndicSortPosition = (
    ispRaToBecomeReph,
    ispPrebaseMatra,
    ispPrefForm,
    ispPrebaseConsonant,
    ispSyllableBase,
    ispAfterMain,
    ispMalayalamDotReph,
    ispAbovebaseConsonant,
    ispBeforeSubjoined,
    ispBelowbaseConsonant,
    ispAfterSubjoined,
    ispBeforePost,
    ispPostbaseConsonant,
    ispAfterPost,
    ispFinalConsonant,
    ispSMVD
  );

  TIndicScriptProperties = record
    Script: TIndicScript;
    BasePos: TBasePos;
    RephMode: TRephMode;
    RephPos: TIndicSortPosition;
    BlwfMode: TBlwfMode;
    AbovebaseMatraPos: TIndicSortPosition;
    BelowbaseMatraPos: TIndicSortPosition;
    RightsideMatraPos: TIndicSortPosition;
  end;

type
  TPascalTypeIndicShaper = class(TCustomPascalTypeShaper)
  private type
    TIndicClass = (icC, icV, icN, icH, icDV, icM, icR, icS, icJ, icX);
    TIndicSyllable = record
      Start, Stop: integer;
      Base: integer;
      Repha: integer;
      SyllableType: TSyllableType;
    end;

  private
    FScriptID: TIndicScript;
    FScriptProperties: TIndicScriptProperties;
    procedure UpdateScriptProperties;
    procedure ApplyVowelConstraints(var AGlyphs: TPascalTypeGlyphString);
    procedure DecomposeMatras(var AGlyphs: TPascalTypeGlyphString);
    procedure ApplyLegacyCompatibility(var AGlyphs: TPascalTypeGlyphString);
    procedure TagSyllableGlyphs(var AGlyphs: TPascalTypeGlyphString; const ASyllable: TIndicSyllable);
    function GetMatraSortPosition(ACodePoint: TPascalTypeCodePoint; APositionalCategory: TIndicPositionalCategory): TIndicSortPosition;

    function MatchREPH(const AGlyphs: TPascalTypeGlyphString; Index: integer): integer;
    function MatchCN(const AGlyphs: TPascalTypeGlyphString; Index: integer): integer;
    function MatchForcedRakar(const AGlyphs: TPascalTypeGlyphString; Index: integer): integer;
    function MatchMatraGroup(const AGlyphs: TPascalTypeGlyphString; Index: integer): integer;
    function MatchSyllableTail(const AGlyphs: TPascalTypeGlyphString; Index: integer): integer;
    function MatchHalantGroup(const AGlyphs: TPascalTypeGlyphString; Index: integer): integer;
    function MatchMedialGroup(const AGlyphs: TPascalTypeGlyphString; Index: integer): integer;
    function MatchHalantOrMatraGroup(const AGlyphs: TPascalTypeGlyphString; Index: integer): integer;

    function MatchConsonantSyllable(const AGlyphs: TPascalTypeGlyphString; Index: integer; out ABase, ARepha: integer): integer;
    function MatchVowelSyllable(const AGlyphs: TPascalTypeGlyphString; Index: integer; out ABase, ARepha: integer): integer;
    function MatchStandaloneSyllable(const AGlyphs: TPascalTypeGlyphString; Index: integer; out ABase, ARepha: integer): integer;
    function MatchSymbolSyllable(const AGlyphs: TPascalTypeGlyphString; Index: integer; out ABase, ARepha: integer): integer;
    function MatchBrokenSyllable(const AGlyphs: TPascalTypeGlyphString; Index: integer; out ABase, ARepha: integer): integer;

    class function GetIndicClass(ACategory: TIndicSyllabicCategory): TIndicClass; static;
    function IsRA(ACodePoint: TPascalTypeCodePoint): boolean;
    function IsPlaceholder(Index: integer; const AGlyphs: TPascalTypeGlyphString): boolean;
    procedure SegmentSyllables(var AGlyphs: TPascalTypeGlyphString; ASyllables: TList<TIndicSyllable>);
    procedure SortSyllable(var AGlyphs: TPascalTypeGlyphString; const ASyllable: TIndicSyllable);
    function ReorderInitialDelegate(AProcessor: TObject; var AGlyphs: TPascalTypeGlyphString): TTableNames;
    function ReorderPreBaseDelegate(AProcessor: TObject; var AGlyphs: TPascalTypeGlyphString): TTableNames;
    function ReorderFinalDelegate(AProcessor: TObject; var AGlyphs: TPascalTypeGlyphString): TTableNames;
    function FindSyllableBase(const AGlyphs: TPascalTypeGlyphString; Start, Stop: integer): integer;

  protected
    procedure SetScript(const Value: TPascalTypeTag); override;
    procedure PlanFeatures(AStage: TPascalTypeShapingPlanStage); override;
    procedure AssignLocalFeatures(const AFeatures: TPascalTypeFeatures; var AGlyphs: TPascalTypeGlyphString); override;

  public
    property IndicScript: TIndicScript read FScriptID;
    property ScriptProperties: TIndicScriptProperties read FScriptProperties;
  end;

implementation

uses
  System.Math,
  System.SysUtils;

const
  // Supported Indic v1 scripts and their corresponding Indic v2 scripts
  // Note that the list is ordered by TTagMap.Indic1.AsCardinal so we can do a binary search on it.
  TagMap: array[0..8] of TTagMap = (
    (Indic1: (AsTableName: 'knda'); Indic2: (AsTableName: 'knd2')),
    (Indic1: (AsTableName: 'deva'); Indic2: (AsTableName: 'dev2')),
    (Indic1: (AsTableName: 'orya'); Indic2: (AsTableName: 'ory2')),
    (Indic1: (AsTableName: 'beng'); Indic2: (AsTableName: 'bng2')),
    (Indic1: (AsTableName: 'taml'); Indic2: (AsTableName: 'tml2')),
    (Indic1: (AsTableName: 'mlym'); Indic2: (AsTableName: 'mlm2')),
    (Indic1: (AsTableName: 'gujr'); Indic2: (AsTableName: 'gjr2')),
    (Indic1: (AsTableName: 'telu'); Indic2: (AsTableName: 'tel2')),
    (Indic1: (AsTableName: 'guru'); Indic2: (AsTableName: 'gur2'))
  );

  // Basic Indic features to be applied in Stage 3.
  // Reference: https://github.com/n8willis/opentype-shaping-documents/blob/master/opentype-shaping-indic-general.md#stage-3-applying-the-basic-substitution-features-from-gsub
  IndicBasicFeatures: TTableNames = [
    'nukt', // Nukta forms
    'akhn', // Akhand forms
    'rphf', // Reph form
    'rkrf', // Rakar form
    'pref', // Pre-base forms
    'blwf', // Below-base forms
    'abvf', // Above-base forms
    'half', // Half forms
    'pstf', // Post-base forms
    'vatu', // Vattu variants
    'cjct', // Conjunct forms
    'cfar'  // Conjunct Form After Ro
  ];

  // Presentation features to be applied in Stage 6.
  // Reference: https://github.com/n8willis/opentype-shaping-documents/blob/master/opentype-shaping-indic-general.md#stage-5-applying-all-remaining-substitution-features-from-gsub
  IndicPresentationFeatures: TTableNames = [
    'ss01', 'ss02', 'ss03', 'ss04', 'ss05', 'ss06', 'ss07', 'ss08', 'ss09', 'ss10',
    'ss11', 'ss12', 'ss13', 'ss14', 'ss15', 'ss16', 'ss17', 'ss18', 'ss19', 'ss20',
    'pres', // Pre-base substitutions
    'abvs', // Above-base substitutions
    'blws', // Below-base substitutions
    'psts', // Post-base substitutions
    'haln', // Halant forms
    'calt', // Contextual alternates
    'clig', // Contextual ligatures
    'liga', // Standard ligatures
    'mset'  // Mark positioning via substitution
  ];

  // Positioning features to be applied in Stage 7.
  // Reference: https://github.com/n8willis/opentype-shaping-documents/blob/master/opentype-shaping-indic-general.md#stage-6-applying-remaining-positioning-features-from-gpos
  IndicPositioningFeatures: TTableNames = [
    'dist', // Distance adjustments
    'abvp', // Above-base positioning
    'abvm', // Above-base mark positioning
    'blwp', // Below-base positioning
    'blwm', // Below-base mark positioning
    'kern'  // Kerning
  ];

const
  IndicScriptProperties: array[TIndicScript] of TIndicScriptProperties = (
    ( // isDevanagari
      Script: isDevanagari;
      BasePos: bpLast;
      RephMode: rmImplicit;
      RephPos: ispBeforePost;
      BlwfMode: bmPreAndPost;
      AbovebaseMatraPos: ispAfterSubjoined;
      BelowbaseMatraPos: ispAfterSubjoined;
      RightsideMatraPos: ispAfterSubjoined
    ),
    ( // isBengali
      Script: isBengali;
      BasePos: bpLast;
      RephMode: rmImplicit;
      RephPos: ispAfterSubjoined;
      BlwfMode: bmPreAndPost;
      AbovebaseMatraPos: ispSMVD; // None
      BelowbaseMatraPos: ispAfterSubjoined;
      RightsideMatraPos: ispAfterPost
    ),
    ( // isGurmukhi
      Script: isGurmukhi;
      BasePos: bpLast;
      RephMode: rmImplicit;
      RephPos: ispBeforeSubjoined;
      BlwfMode: bmPreAndPost;
      AbovebaseMatraPos: ispAfterPost;
      BelowbaseMatraPos: ispAfterPost;
      RightsideMatraPos: ispAfterPost
    ),
    ( // isGujarati
      Script: isGujarati;
      BasePos: bpLast;
      RephMode: rmImplicit;
      RephPos: ispBeforePost;
      BlwfMode: bmPreAndPost;
      AbovebaseMatraPos: ispAfterSubjoined;
      BelowbaseMatraPos: ispAfterPost;
      RightsideMatraPos: ispAfterPost
    ),
    ( // isOriya
      Script: isOriya;
      BasePos: bpLast;
      RephMode: rmImplicit;
      RephPos: ispAfterMain;
      BlwfMode: bmPreAndPost;
      AbovebaseMatraPos: ispAfterMain;
      BelowbaseMatraPos: ispAfterSubjoined;
      RightsideMatraPos: ispAfterPost
    ),
    ( // isTamil
      Script: isTamil;
      BasePos: bpLast;
      RephMode: rmImplicit;
      RephPos: ispAfterPost;
      BlwfMode: bmPreAndPost;
      AbovebaseMatraPos: ispAfterSubjoined;
      BelowbaseMatraPos: ispAfterPost;
      RightsideMatraPos: ispAfterPost
    ),
    ( // isTelugu
      Script: isTelugu;
      BasePos: bpLast;
      RephMode: rmExplicit;
      RephPos: ispAfterPost;
      BlwfMode: bmPostOnly;
      AbovebaseMatraPos: ispBeforeSubjoined;
      BelowbaseMatraPos: ispBeforeSubjoined;
      RightsideMatraPos: ispSMVD // Varies, handled in GetMatraSortPosition
    ),
    ( // isKannada
      Script: isKannada;
      BasePos: bpLast;
      RephMode: rmImplicit;
      RephPos: ispAfterPost;
      BlwfMode: bmPostOnly;
      AbovebaseMatraPos: ispBeforeSubjoined;
      BelowbaseMatraPos: ispBeforeSubjoined;
      RightsideMatraPos: ispSMVD // Varies, handled in GetMatraSortPosition
    ),
    ( // isMalayalam
      Script: isMalayalam;
      BasePos: bpLast;
      RephMode: rmLogicalRepha;
      RephPos: ispMalayalamDotReph;
      BlwfMode: bmPreAndPost;
      AbovebaseMatraPos: ispSMVD; // None
      BelowbaseMatraPos: ispAfterPost;
      RightsideMatraPos: ispAfterPost
    ),
    ( // isSinhala
      Script: isSinhala;
      BasePos: bpLastSinhala;
      RephMode: rmExplicit;
      RephPos: ispAfterMain;
      BlwfMode: bmPreAndPost;
      AbovebaseMatraPos: ispAfterSubjoined;
      BelowbaseMatraPos: ispAfterSubjoined;
      RightsideMatraPos: ispAfterSubjoined
    )
  );

{ TPascalTypeIndicShaper }

procedure TPascalTypeIndicShaper.SetScript(const Value: TPascalTypeTag);
begin
{$ifdef DEBUG}
  // Verify that TagMap has the correct order
  for var i := Low(TagMap) to High(TagMap)-1 do
    Assert(TagMap[i].Indic1.AsCardinal < TagMap[i+1].Indic1.AsCardinal);
{$endif}

  var Tag := Value;

  if (SubstitutionTable <> nil) then
  begin
    // Binary search for v1 tag in TagMap
    var L: integer := 0;
    var R: integer := High(TagMap);

    while L <= R do
    begin
      var M: integer := (L + R) div 2;

      if (TagMap[M].Indic1.AsCardinal = Value.AsCardinal) then
      begin
        // Found v1 tag, check if font supports v2 tag
        if (SubstitutionTable.ScriptListTable.FindScript(TagMap[M].Indic2) <> nil) then
          Tag := TagMap[M].Indic2;

        break;
      end;

      if (TagMap[M].Indic1.AsCardinal < Value.AsCardinal) then
        L := M + 1
      else
        R := M - 1;
    end;
  end;

  inherited SetScript(Tag);

  UpdateScriptProperties;
end;

procedure TPascalTypeIndicShaper.ApplyLegacyCompatibility(var AGlyphs: TPascalTypeGlyphString);
begin
  // 1. Bengali: Recompose "Ya" + "Nukta" to "Yya"
  // HarfBuzz does this to match Uniscribe behavior.
  // See: https://github.com/n8willis/opentype-shaping-documents/issues/74
  if (FScriptID = isBengali) then
  begin
    var i := 0;
    while (i < AGlyphs.Count - 1) do
    begin
      if (AGlyphs[i].CodePoint = $09AF) and (AGlyphs[i+1].CodePoint = $09BC) then
      begin
        AGlyphs[i].CodePoints := [$09DF];
        AGlyphs[i].GlyphID := Font.GetGlyphByCodePoint($09DF);
        AGlyphs.Delete(i+1);
      end else
        Inc(i);
    end;
  end;

  // 2. Kannada: Reorder "Ra" + "Halant" + "ZWJ" to "Ra" + "ZWJ" + "Halant"
  // For compatibility with legacy sequences, "Ra, Halant, ZWJ" must behave like
  // "Ra, ZWJ, Halant" such that if a consonant follows the "ZWJ"
  // (i.e. "Ra, Halant, ZWJ, Consonant"), it should take on a subjoined form.
  // See: https://github.com/n8willis/opentype-shaping-documents/issues/61
  // See: https://github.com/harfbuzz/harfbuzz/issues/435
  if (FScriptID = isKannada) then
  begin
    var i := 0;
    while (i < AGlyphs.Count - 2) do
    begin
      if IsRA(AGlyphs[i].CodePoint) and
         (PascalTypeUnicode.GetIndicSyllabicCategory(AGlyphs[i+1].CodePoint) = iscVirama) and
         (AGlyphs[i+2].CodePoint = PascalTypeUnicode.cpZWJ) then
      begin
        AGlyphs.Move(i+2, i+1);
        Inc(i, 3);
      end else
        Inc(i);
    end;
  end;
end;

procedure TPascalTypeIndicShaper.DecomposeMatras(var AGlyphs: TPascalTypeGlyphString);

  function Decompose(var Index: integer; const cp1, cp2: TPascalTypeCodePoint): TPascalTypeGlyph; overload;
  begin
    Result := AGlyphs[Index];
    Result.CodePoints := [cp1];
    Result.GlyphID := Font.GetGlyphByCodePoint(cp1);
    Inc(Index);

    var Glyph := AGlyphs.Insert(Index);
    Glyph.CodePoints := [cp2];
    Glyph.GlyphID := Font.GetGlyphByCodePoint(cp2);
    Glyph.Cluster := Result.Cluster;
    Inc(Index);
  end;

  function Decompose(var Index: integer; const cp1, cp2, cp3: TPascalTypeCodePoint): TPascalTypeGlyph; overload;
  begin
    Result := Decompose(Index, cp1, cp2);

    var Glyph := AGlyphs.Insert(Index);
    Glyph.CodePoints := [cp3];
    Glyph.GlyphID := Font.GetGlyphByCodePoint(cp3);
    Glyph.Cluster := Result.Cluster;
    Inc(Index);
  end;

begin
  var i := 0;
  while (i < AGlyphs.Count) do
  begin
    var cp := AGlyphs[i].CodePoint;

    case cp of
      // Bengali
      $09CB: Decompose(i, $09C7, $09BE);
      $09CC: Decompose(i, $09C7, $09D7);

      // Oriya
      $0B48: Decompose(i, $0B47, $0B56);
      $0B4B: Decompose(i, $0B47, $0B3E);
      $0B4C: Decompose(i, $0B47, $0B57);

      // Tamil
      $0BCA: Decompose(i, $0BC6, $0BBE);
      $0BCB: Decompose(i, $0BC7, $0BBE);
      $0BCC: Decompose(i, $0BC6, $0BD7);

      // Telugu
      $0C48: Decompose(i, $0C46, $0C56);

      // Kannada
      $0CC0: Decompose(i, $0CBF, $0CD5);
      $0CC7: Decompose(i, $0CC6, $0CD5);
      $0CC8: Decompose(i, $0CC6, $0CD6);
      $0CCA: Decompose(i, $0CC6, $0CC2);
      $0CCB: Decompose(i, $0CC6, $0CC2, $0CD5);

      // Malayalam
      $0D4A: Decompose(i, $0D46, $0D3E);
      $0D4B: Decompose(i, $0D47, $0D3E);
      $0D4C: Decompose(i, $0D46, $0D57);

      // Sinhala
      $0DDA: Decompose(i, $0DD9, $0DCA);
      $0DDC: Decompose(i, $0DD9, $0DCF);
      $0DDD: Decompose(i, $0DD9, $0DCF, $0DCA);
      $0DDE: Decompose(i, $0DD9, $0DDF);
    else
      Inc(i);
    end;
  end;
end;

procedure TPascalTypeIndicShaper.ApplyVowelConstraints(var AGlyphs: TPascalTypeGlyphString);

  procedure InsertDottedCircle(Index: integer);
  begin
    var Glyph := AGlyphs.Insert(Index);
    Glyph.CodePoints := [PascalTypeUnicode.cpDottedCircle];
    Glyph.GlyphID := Font.GetGlyphByCodePoint(PascalTypeUnicode.cpDottedCircle);

    // Inherit cluster from following glyph (the one that triggered the constraint)
    if (Index + 1 < AGlyphs.Count) then
      Glyph.Cluster := AGlyphs[Index + 1].Cluster;
  end;

begin
  var i := 0;
  while (i < AGlyphs.Count - 1) do
  begin
    var cp1 := AGlyphs[i].CodePoint;
    var cp2 := AGlyphs[i + 1].CodePoint;
    var Match := False;

    case FScriptID of
      isDevanagari:
        begin
          if (cp1 = $0930) and (cp2 = $094D) and (i + 2 < AGlyphs.Count) and (AGlyphs[i + 2].CodePoint = $0907) then
          begin
            InsertDottedCircle(i + 2);
            Inc(i, 3);
            continue;
          end;

          case cp1 of
            $0905: Match := (cp2 >= $093A) and (cp2 <= $0957) and (Byte(cp2 - $093A) in [$0946-$093A, $093E-$093A, $0949-$093A, $094A-$093A, $094B-$093A, $094C-$093A, $0945-$093A, $093A-$093A, $093B-$093A, $094F-$093A, $0956-$093A, $0957-$093A]);
            $0906: Match := (cp2 >= $093A) and (cp2 <= $0948) and (Byte(cp2 - $093A) in [$0945-$093A, $0946-$093A, $0947-$093A, $0948-$093A, $093A-$093A]);
            $0909: Match := (cp2 = $0941);
            $090F: Match := (cp2 >= $0945) and (cp2 <= $0947) and (Byte(cp2 - $0945) in [$0945-$0945, $0946-$0945, $0947-$0945]);
          end;
        end;

      isBengali:
        case cp1 of
          $0985: Match := (cp2 = $09BE);
          $098B: Match := (cp2 = $09C3);
          $098C: Match := (cp2 = $09E2);
        end;

      isTamil:
        if (cp1 = $0B85) and (cp2 = $0BC2) then
          Match := True;

      isGurmukhi:
        case cp1 of
          $0A05: Match := (cp2 >= $0A3E) and (cp2 <= $0A4C) and (Byte(cp2 - $0A3E) in [$0A3E-$0A3E, $0A48-$0A3E, $0A4C-$0A3E]);
          $0A72: Match := (cp2 >= $0A3F) and (cp2 <= $0A47) and (Byte(cp2 - $0A3F) in [$0A3F-$0A3F, $0A40-$0A3F, $0A47-$0A3F]);
          $0A73: Match := (cp2 >= $0A41) and (cp2 <= $0A4B) and (Byte(cp2 - $0A41) in [$0A41-$0A41, $0A42-$0A41, $0A4B-$0A41]);
        end;

      isGujarati:
        case cp1 of
          $0A85: Match := (cp2 >= $0ABE) and (cp2 <= $0ACC) and (Byte(cp2 - $0ABE) in [$0ABE-$0ABE, $0AC5-$0ABE, $0AC7-$0ABE, $0AC8-$0ABE, $0AC9-$0ABE, $0ACB-$0ABE, $0ACC-$0ABE]);
          $0AC5: Match := (cp2 = $0ABE);
        end;

      isOriya:
        case cp1 of
          $0B05: Match := (cp2 = $0B3E);
          $0B0F, $0B13: Match := (cp2 = $0B57);
        end;

      isTelugu:
        case cp1 of
          $0C12: Match := (cp2 >= $0C4C) and (cp2 <= $0C55) and (Byte(cp2 - $0C4C) in [$0C55-$0C4C, $0C4C-$0C4C]);
          $0C3F, $0C46, $0C4A: Match := (cp2 = $0C55);
        end;

      isKannada:
        case cp1 of
          $0C89, $0C8B: Match := (cp2 = $0CBE);
          $0C92: Match := (cp2 = $0CCC);
        end;

      isMalayalam:
        case cp1 of
          $0D07, $0D09: Match := (cp2 = $0D57);
          $0D0E: Match := (cp2 = $0D46);
          $0D12: Match := (cp2 >= $0D3E) and (cp2 <= $0D57) and (Byte(cp2 - $0D3E) in [$0D3E-$0D3E, $0D57-$0D3E]);
        end;

      isSinhala:
        case cp1 of
          $0D85: Match := (cp2 >= $0DCF) and (cp2 <= $0DD1) and (Byte(cp2 - $0DCF) in [$0DCF-$0DCF, $0DD0-$0DCF, $0DD1-$0DCF]);
          $0D8B, $0D8F, $0D94: Match := (cp2 = $0DDF);
          $0D8D: Match := (cp2 = $0DD8);
          $0D91: Match := (cp2 >= $0DCA) and (cp2 <= $0DDE) and (Byte(cp2 - $0DCA) in [$0DCA-$0DCA, $0DD9-$0DCA, $0DDA-$0DCA, $0DDC-$0DCA, $0DDD-$0DCA, $0DDE-$0DCA]);
        end;
    end;

    if Match then
    begin
      InsertDottedCircle(i + 1);
      Inc(i, 2);
    end else
      Inc(i);
  end;
end;

procedure TPascalTypeIndicShaper.UpdateScriptProperties;
begin
  case Script.AsCardinal of
    $32766564, $61766564: FScriptID := isDevanagari; // dev2, deva
    $32676E62, $676E6562: FScriptID := isBengali;    // bng2, beng
    $32727567, $75727567: FScriptID := isGurmukhi;   // gur2, guru
    $32726A67, $726A7567: FScriptID := isGujarati;   // gjr2, gujr
    $3279726F, $6179726F: FScriptID := isOriya;      // ory2, orya
    $326C6D74, $6C6D6174: FScriptID := isTamil;      // tml2, taml
    $326C6574, $756C6574: FScriptID := isTelugu;     // tel2, telu
    $32646E6B, $61646E6B: FScriptID := isKannada;    // knd2, knda
    $326D6C6D, $6D796C6D: FScriptID := isMalayalam;  // mlm2, mlym
    $686E6973:            FScriptID := isSinhala;    // sinh
  else
    FScriptID := isDevanagari; // Default
  end;
  FScriptProperties := IndicScriptProperties[FScriptID];
end;

function TPascalTypeIndicShaper.MatchREPH(const AGlyphs: TPascalTypeGlyphString; Index: integer): integer;
begin
  // REPH = (_ra_ _halant_) | _repha_
  // See OpenType Shaping Documents - Indic General, Stage 1:
  // https://github.com/n8willis/opentype-shaping-documents/blob/master/opentype-shaping-indic-general.md#stage-1-identifying-syllables-and-other-sequences
  Result := Index;
  if (Result >= AGlyphs.Count) then
    exit;

  // Malayalam Dot Repha (U+0D4E)
  if (FScriptID = isMalayalam) and (AGlyphs[Result].CodePoint = $0D4E) then
    Exit(Result + 1);

  // Sinhala multi-glyph Repha: RA + H + ZWJ
  if (FScriptID = isSinhala) and (Result + 2 < AGlyphs.Count) and
     IsRA(AGlyphs[Result].CodePoint) and
     (PascalTypeUnicode.GetIndicSyllabicCategory(AGlyphs[Result + 1].CodePoint) = iscVirama) and
     (AGlyphs[Result + 2].CodePoint = PascalTypeUnicode.cpZWJ) then
    Exit(Result + 3);

  // Standard Repha category (iscConsonant_Preceding_Repha)
  if (GetIndicClass(AGlyphs[Result].SyllabicCategory) = icR) then
    Exit(Result + 1);

  // Standard Ra + Halant
  if (Result + 1 < AGlyphs.Count) and IsRA(AGlyphs[Result].CodePoint) and (GetIndicClass(AGlyphs[Result + 1].SyllabicCategory) = icH) then
  begin
    Inc(Result, 2);
    // Optional ZWJ for Telugu/Kannada explicit Repha
    if (Result < AGlyphs.Count) and (AGlyphs[Result].CodePoint = PascalTypeUnicode.cpZWJ) and (FScriptID in [isTelugu, isKannada]) then
      Inc(Result);
    Exit(Result);
  end;
end;

function TPascalTypeIndicShaper.MatchCN(const AGlyphs: TPascalTypeGlyphString; Index: integer): integer;
begin
  // CN = C zwj? nukta?
  // See OpenType Shaping Documents - Indic General, Stage 1:
  // https://github.com/n8willis/opentype-shaping-documents/blob/master/opentype-shaping-indic-general.md#stage-1-identifying-syllables-and-other-sequences
  Result := Index;
  if (Result < AGlyphs.Count) and (GetIndicClass(AGlyphs[Result].SyllabicCategory) in [icC, icR]) then
  begin
    Inc(Result);
    // Optional ZWJ
    if (Result < AGlyphs.Count) and (AGlyphs[Result].CodePoint = PascalTypeUnicode.cpZWJ) then
      Inc(Result);
    // Optional Nukta
    if (Result < AGlyphs.Count) and (GetIndicClass(AGlyphs[Result].SyllabicCategory) = icN) then
      Inc(Result);
  end;
end;

function TPascalTypeIndicShaper.MatchForcedRakar(const AGlyphs: TPascalTypeGlyphString; Index: integer): integer;
begin
  Result := Index;
  if (Result + 2 < AGlyphs.Count) and (GetIndicClass(AGlyphs[Result].SyllabicCategory) = icH) and
     (AGlyphs[Result + 1].CodePoint = PascalTypeUnicode.cpZWJ) and
     IsRA(AGlyphs[Result + 2].CodePoint) then
    Exit(Result + 3);
end;

function TPascalTypeIndicShaper.MatchMatraGroup(const AGlyphs: TPascalTypeGlyphString; Index: integer): integer;
begin
  Result := Index;
  while (Result < AGlyphs.Count) and (GetIndicClass(AGlyphs[Result].SyllabicCategory) = icDV) do
    Inc(Result);
end;

function TPascalTypeIndicShaper.MatchSyllableTail(const AGlyphs: TPascalTypeGlyphString; Index: integer): integer;
begin
  // SYLLABLE_TAIL = (N | M | J | DV | H | medial)*
  Result := Index;
  while (Result < AGlyphs.Count) do
  begin
    var ClassID := GetIndicClass(AGlyphs[Result].SyllabicCategory);
    if (ClassID in [icN, icM, icJ, icDV, icH]) or (AGlyphs[Result].SyllabicCategory = iscConsonant_Medial) then
      Inc(Result)
    else
      break;
  end;
end;

function TPascalTypeIndicShaper.MatchHalantGroup(const AGlyphs: TPascalTypeGlyphString; Index: integer): integer;
begin
  // HALANT_GROUP = [ZWJ] _halant_ [ZWJ [N]]
  // See OpenType Shaping Documents - Indic General, Stage 1:
  // https://github.com/n8willis/opentype-shaping-documents/blob/master/opentype-shaping-indic-general.md#stage-1-identifying-syllables-and-other-sequences
  Result := Index;

  // Optional Joiner before Halant
  if (Result < AGlyphs.Count) and (GetIndicClass(AGlyphs[Result].SyllabicCategory) = icJ) then
    Inc(Result);

  // Mandatory Halant
  if (Result < AGlyphs.Count) and (GetIndicClass(AGlyphs[Result].SyllabicCategory) = icH) then
  begin
    Inc(Result);

    // Optional Joiner after Halant
    if (Result < AGlyphs.Count) and (GetIndicClass(AGlyphs[Result].SyllabicCategory) = icJ) then
    begin
      Inc(Result);
      // Optional Nukta after Joiner
      if (Result < AGlyphs.Count) and (GetIndicClass(AGlyphs[Result].SyllabicCategory) = icN) then
        Inc(Result);
    end;
  end else
    Result := Index; // Fail if no Halant found
end;

function TPascalTypeIndicShaper.MatchMedialGroup(const AGlyphs: TPascalTypeGlyphString; Index: integer): integer;
begin
  Result := Index;
  while (Result < AGlyphs.Count) and (AGlyphs[Result].SyllabicCategory = iscConsonant_Medial) do
    Inc(Result);
end;

function TPascalTypeIndicShaper.MatchHalantOrMatraGroup(const AGlyphs: TPascalTypeGlyphString; Index: integer): integer;
begin
  Result := MatchHalantGroup(AGlyphs, Index);
  if (Result = Index) then
    Result := MatchMatraGroup(AGlyphs, Index);
end;

function TPascalTypeIndicShaper.MatchConsonantSyllable(const AGlyphs: TPascalTypeGlyphString; Index: integer; out ABase, ARepha: integer): integer;
begin
  // Consonant Syllable = (_repha_|_consonantwithstacker_)? (CN HALANT_GROUP)* CN MEDIAL_GROUP HALANT_OR_MATRA_GROUP SYLLABLE_TAIL
  // See OpenType Shaping Documents - Indic General, Stage 1:
  // https://github.com/n8willis/opentype-shaping-documents/blob/master/opentype-shaping-indic-general.md#stage-1-identifying-syllables-and-other-sequences
  ABase := -1;
  ARepha := -1;
  Result := Index;

  // Optional prefix: (_repha_|_consonantwithstacker_)?
  var RephaPos := -1;
  if (Result < AGlyphs.Count) then
  begin

    // Consume REPH?
    if (AGlyphs[Result].SyllabicCategory = iscConsonant_Preceding_Repha) then
    begin
      RephaPos := Result;
      Inc(Result);
    end;

    // Consume STACKER?
    if (Result < AGlyphs.Count) and (AGlyphs[Result].SyllabicCategory = iscConsonant_With_Stacker) then
      Inc(Result);

  end;

  // (CN HALANT_GROUP)*
  var Next := MatchCN(AGlyphs, Result);
  if (Next = Result) then
  begin

    // If prefix was consumed but no core followed, check if the core starts at Index.
    // This handles cases where a consonant with an inherent stacker (e.g. U+0CF1)
    // is being matched as the syllable core.
    if (Result > Index) then
    begin
      Result := Index;
      Next := MatchCN(AGlyphs, Result);
    end;

    if (Next = Result) then
      Exit(Index); // No consonant found

  end;

  ARepha := RephaPos;
  ABase := Result; // Assume first CN is base initially
  Result := Next;

  // (H + CN)*
  while True do
  begin
    Next := MatchHalantGroup(AGlyphs, Result);

    if (Next > Result) then
    begin
      var NextCN := MatchCN(AGlyphs, Next);

      if (NextCN > Next) then
      begin
        if (FScriptProperties.BasePos = bpLast) then
        begin

          // In Malayalam, a VIRAMA + RA sequence forms a 'pref' form and cannot be the base.
          var IsPrefRA := (FScriptID = isMalayalam) and IsRA(AGlyphs[Next].CodePoint);
          if not IsPrefRA then
            ABase := Next; // Base moves to the last consonant

        end else
        if (FScriptProperties.BasePos = bpLastSinhala) then
        begin

          // In Sinhala, the base is the last consonant, but we stop if we see a ZWJ.
          // Search for a ZWJ within the Halant group that was just matched.
          var iH := -1;
          for var k := Result to Next - 1 do
            if (GetIndicClass(AGlyphs[k].SyllabicCategory) = icH) then
            begin
              iH := k;
              break;
            end;

          var FoundStop := False;
          if (iH <> -1) then
            for var k := iH + 1 to Next - 1 do
              if (AGlyphs[k].CodePoint = PascalTypeUnicode.cpZWJ) then
              begin
                FoundStop := True;
                break;
              end;

          if (not FoundStop) then
            ABase := Next;

        end;
        Result := NextCN;
        continue;
      end;
    end;

    break;
  end;

  // Medials
  Result := MatchMedialGroup(AGlyphs, Result);

  // Final part: H | Forced_Rakar | (H? + V* + VM* + D*)
  Next := MatchForcedRakar(AGlyphs, Result);
  if (Next > Result) then
    Result := Next
  else
  begin

    // Optional Halant before matras
    Next := MatchHalantGroup(AGlyphs, Result);
    if (Next > Result) then
      Result := Next;

    Result := MatchMatraGroup(AGlyphs, Result);
    Result := MatchSyllableTail(AGlyphs, Result);

    // Optional digits at the end. Must belong to the same script as the syllable base.
    var BaseScript := PascalTypeUnicode.GetScript(AGlyphs[ABase].CodePoint);
    while (Result < AGlyphs.Count) and (GetIndicClass(AGlyphs[Result].SyllabicCategory) = icC) and
          PascalTypeUnicode.IsDigit(AGlyphs[Result].CodePoint) and
          (PascalTypeUnicode.GetScript(AGlyphs[Result].CodePoint) = BaseScript) do
      Inc(Result);

  end;
end;

function TPascalTypeIndicShaper.MatchVowelSyllable(const AGlyphs: TPascalTypeGlyphString; Index: integer; out ABase, ARepha: integer): integer;
begin
  // Vowel Syllable = REPH? _vowel_ SYLLABLE_TAIL
  // See HarfBuzz match_vowel: REPH? V [SYLLABLE_TAIL]
  ABase := -1;
  ARepha := -1;
  Result := Index;

  // REPH?
  var Next := MatchREPH(AGlyphs, Result);
  if (Next > Result) then
  begin
    ARepha := Result;
    Result := Next;
  end;

  // _vowel_
  if (Result < AGlyphs.Count) and (GetIndicClass(AGlyphs[Result].SyllabicCategory) = icV) then
  begin
    ABase := Result;
    Inc(Result);
  end else
  begin
    ABase := -1;
    ARepha := -1;
    Exit(Index);
  end;

  Result := MatchSyllableTail(AGlyphs, Result);
end;

function TPascalTypeIndicShaper.MatchStandaloneSyllable(const AGlyphs: TPascalTypeGlyphString; Index: integer; out ABase, ARepha: integer): integer;
begin
  // Standalone Syllable = REPH? (placeholder | dottedcircle) SYLLABLE_TAIL
  // See HarfBuzz match_standalone: REPH? [DOTTED_CIRCLE | PLACEHOLDER] [SYLLABLE_TAIL]
  ABase := -1;
  ARepha := -1;
  Result := Index;

  // REPH?
  var Next := MatchREPH(AGlyphs, Result);
  var RephaPos := -1;
  if (Next > Result) then
  begin
    RephaPos := Result;
    Result := Next;
  end;

  if (Result < AGlyphs.Count) and
     ((AGlyphs[Result].CodePoint = PascalTypeUnicode.cpDottedCircle) or IsPlaceholder(Result, AGlyphs)) then
  begin
    ABase := Result;
    ARepha := RephaPos;
    Inc(Result);
    Result := MatchSyllableTail(AGlyphs, Result);
  end else
    Exit(Index);
end;

function TPascalTypeIndicShaper.MatchSymbolSyllable(const AGlyphs: TPascalTypeGlyphString; Index: integer; out ABase, ARepha: integer): integer;
begin
  ABase := -1;
  ARepha := -1;
  Result := Index;
  if (Result < AGlyphs.Count) and (not PascalTypeUnicode.IsMark(AGlyphs[Result].CodePoint)) then
  begin
    if GetIndicClass(AGlyphs[Result].SyllabicCategory) = icX then
      Inc(Result);
  end;
end;

function TPascalTypeIndicShaper.MatchBrokenSyllable(const AGlyphs: TPascalTypeGlyphString; Index: integer; out ABase, ARepha: integer): integer;
begin
  // Broken Syllable = [REPH] SYLLABLE_TAIL
  ABase := -1;
  ARepha := -1;
  Result := Index;

  // Optional leading joiner (allows ZWNJ to be part of a broken syllable)
  if (Result < AGlyphs.Count) and (GetIndicClass(AGlyphs[Result].SyllabicCategory) = icJ) then
    Inc(Result);

  // REPH?
  var Next := MatchREPH(AGlyphs, Result);
  if (Next > Result) then
  begin
    ARepha := Result;
    Result := Next;
  end;

  Result := MatchSyllableTail(AGlyphs, Result);

  // Ensure we at least consume one character if we're not empty, to avoid infinite loops.
  if (Result = Index) and (Result < AGlyphs.Count) then
    Inc(Result);
end;

procedure TPascalTypeIndicShaper.TagSyllableGlyphs(var AGlyphs: TPascalTypeGlyphString; const ASyllable: TIndicSyllable);
begin
  var i := ASyllable.Start;

  // 1. Tag Repha
  if (i = ASyllable.Repha) then
  begin
    var RephaEnd := MatchREPH(AGlyphs, i);

    while (i < RephaEnd) do
    begin
      AGlyphs[i].SyllabicPosition := spRepha;
      // Repha is initially at the start (pos 0) but will be moved by dynamic reordering.
      // We set a script-specific target sort position.
      AGlyphs[i].SortPosition := Ord(FScriptProperties.RephPos);
      Inc(i);
    end;
  end;

  // 2. Tag rest of syllable
  while (i <= ASyllable.Stop) do
  begin
    var Glyph := AGlyphs[i];
    var IndicClass := GetIndicClass(Glyph.SyllabicCategory);

    if (i = ASyllable.Base) then
    begin
      Glyph.SortPosition := Ord(ispSyllableBase);
      Glyph.SyllabicPosition := spBase;
    end else
    if (i = ASyllable.Repha) then
    begin
      // Repha identified during segmentation (e.g. for rmExplicit or rmLogicalRepha)
      Glyph.SortPosition := Ord(FScriptProperties.RephPos);
      Glyph.SyllabicPosition := spRepha;
    end else
    if (IndicClass = icR) and (FScriptID = isMalayalam) and (Glyph.CodePoint = $0D4E) then
    begin
      Glyph.SortPosition := Ord(ispMalayalamDotReph);
      Glyph.SyllabicPosition := spAbove_Base;
    end else
    if (Glyph.SyllabicCategory = iscConsonant_Medial) then
    begin
      Glyph.SortPosition := Ord(ispBelowbaseConsonant);
      Glyph.SyllabicPosition := spBelow_Base;
    end else
    if (IndicClass = icJ) or (IndicClass = icH) then
    begin
      Glyph.SortPosition := Ord(ispSyllableBase);
      Glyph.SyllabicPosition := spNone;
    end else
    if (IndicClass = icDV) then
    begin
      var Pos := GetMatraSortPosition(Glyph.CodePoint, Glyph.PositionalCategory);
      Glyph.SortPosition := Ord(Pos);

      if (Pos = ispPrebaseMatra) then
        Glyph.SyllabicPosition := spPre_Base
      else
      if (Pos = FScriptProperties.AbovebaseMatraPos) then
        Glyph.SyllabicPosition := spAbove_Base
      else
      if (Pos = FScriptProperties.BelowbaseMatraPos) then
        Glyph.SyllabicPosition := spBelow_Base
      else
      if (Pos = ispMalayalamDotReph) then
        Glyph.SyllabicPosition := spAbove_Base // Dot Repha is positioned above
      else
        Glyph.SyllabicPosition := spPost_Base;
    end else
    if (IndicClass = icM) then
    begin
      Glyph.SortPosition := Ord(ispSMVD);
      Glyph.SyllabicPosition := spNone;
    end else
    if (IndicClass = icC) or (IndicClass = icR) then
    begin
      // Consonants (other than base/repha)
      if (i < ASyllable.Base) then
      begin
        Glyph.SortPosition := Ord(ispPrebaseConsonant);
        Glyph.SyllabicPosition := spPre_Base;
      end else
      begin
        Glyph.SortPosition := Ord(ispPostbaseConsonant);
        Glyph.SyllabicPosition := spPost_Base;
      end;
    end else
    begin
      Glyph.SortPosition := Ord(ispSyllableBase);
      Glyph.SyllabicPosition := spNone;
    end;

    Inc(i);
  end;
end;

function TPascalTypeIndicShaper.GetMatraSortPosition(ACodePoint: TPascalTypeCodePoint; APositionalCategory: TIndicPositionalCategory): TIndicSortPosition;
begin
  // Malayalam Dot Repha (U+0D4E) placement
  if (FScriptID = isMalayalam) and (ACodePoint = $0D4E) then
    Exit(ispMalayalamDotReph);

  // Script-specific overrides for matra reordering.
  // Reference: https://github.com/n8willis/opentype-shaping-documents/blob/master/opentype-shaping-indic-general.md#script-shaping-characteristics

  // Special handling for Telugu and Kannada matras
  if (FScriptID = isTelugu) then
  begin
    case ACodePoint of
      $0C41, $0C42: Exit(ispBeforeSubjoined); // Telugu Sign U, Uu (RIGHT)
      $0C43, $0C44: Exit(ispAfterSubjoined);  // Telugu Sign Vocalic R, Rr (RIGHT)
      $0C3F, $0C40, $0C46, $0C47, $0C48, $0C4A, $0C4B: Exit(ispBeforeSubjoined); // TOP matras
    end;
  end else
  if (FScriptID = isKannada) then
  begin
    case ACodePoint of
      $0CBE, $0CC0, $0CC1, $0CC2: Exit(ispBeforeSubjoined); // Kannada Sign Aa, Ii, U, Uu (RIGHT)
      $0CC3, $0CC4, $0CD5, $0CD6: Exit(ispAfterSubjoined);  // Kannada Sign Vocalic R, Rr, Length Mark, Ai Length Mark (RIGHT)
      $0CBF, $0CC6, $0CC7, $0CC8, $0CCA, $0CCB: Exit(ispBeforeSubjoined); // TOP matras
    end;
  end;

  case APositionalCategory of

    ipcLeft:
      Result := ispPrebaseMatra;

    ipcTop, ipcTop_And_Bottom, ipcTop_And_Right, ipcTop_And_Left, ipcTop_And_Left_And_Right, ipcTop_And_Bottom_And_Left, ipcTop_And_Bottom_And_Right:
      Result := FScriptProperties.AbovebaseMatraPos;

    ipcBottom, ipcBottom_And_Right, ipcBottom_And_Left:
      Result := FScriptProperties.BelowbaseMatraPos;

    ipcRight, ipcLeft_And_Right:
      Result := FScriptProperties.RightsideMatraPos;

  else
    Result := ispSMVD;
  end;
end;

procedure TPascalTypeIndicShaper.PlanFeatures(AStage: TPascalTypeShapingPlanStage);
begin
  // Stage 1: Mandatory Preprocessing (ccmp, locl) - already handled by base class

  // Stage 2: Basic Indic features (nukt, akhn, rphf, rkrf, pref, blwf, abvf, half, pstf, vatu, cjct, cfar)
  var Stage := AStage.Plan.Stages.Add;
  Stage.Add(IndicBasicFeatures, False);

  // Stage 3: Initial Reordering (Repha)
  Stage := AStage.Plan.Stages.Add;
  Stage.Delegate := ReorderInitialDelegate;

  // Stage 4: Reorder pre-base substitutions (pref)
  Stage := AStage.Plan.Stages.Add;
  Stage.Delegate := ReorderPreBaseDelegate;

  // Stage 5: Final Reordering (Pre-base vowels)
  Stage := AStage.Plan.Stages.Add;
  Stage.Delegate := ReorderFinalDelegate;

  // Stage 6: Presentation forms
  Stage := AStage.Plan.Stages.Add;
  Stage.Add('init', False);
  Stage.Add(IndicPresentationFeatures);

  // Stage 7: Positioning forms
  Stage := AStage.Plan.Stages.Add;
  Stage.Add(IndicPositioningFeatures);
end;

procedure TPascalTypeIndicShaper.AssignLocalFeatures(const AFeatures: TPascalTypeFeatures; var AGlyphs: TPascalTypeGlyphString);
begin
  if (AGlyphs.Count = 0) then
    exit;

  inherited AssignLocalFeatures(AFeatures, AGlyphs);

  // Apply vowel constraints before segmentation
  ApplyVowelConstraints(AGlyphs);

  // Explicitly decompose multi-part matras
  DecomposeMatras(AGlyphs);

  // Apply legacy compatibility recompositions and reorderings
  ApplyLegacyCompatibility(AGlyphs);

  // 1. Categorize glyphs
  for var i := 0 to AGlyphs.Count - 1 do
  begin
    var Glyph := AGlyphs[i];

    if Length(Glyph.CodePoints) > 0 then
    begin
      Glyph.SyllabicCategory := PascalTypeUnicode.GetIndicSyllabicCategory(Glyph.CodePoint);
      Glyph.PositionalCategory := PascalTypeUnicode.GetIndicPositionalCategory(Glyph.CodePoint);
    end else
    begin
      Glyph.SyllabicCategory := iscOther;
      Glyph.PositionalCategory := ipcNull;
    end;

    Glyph.SyllableIndex := -1;
    Glyph.SyllableType := stOther;
    Glyph.SyllabicPosition := spNone;
  end;

  // 2. Segment syllables
  var Syllables := TList<TIndicSyllable>.Create;
  try
    SegmentSyllables(AGlyphs, Syllables);

    // 3. Assign features and reorder each syllable
    // Process from back to front to maintain index stability
    for var i := Syllables.Count - 1 downto 0 do
    begin
      var Syllable := Syllables[i];

      if (Syllable.SyllableType = stBroken_Cluster) then
      begin
        var Glyph := AGlyphs.Insert(Syllable.Start);
        Glyph.CodePoints := [PascalTypeUnicode.cpDottedCircle];
        Glyph.GlyphID := Font.GetGlyphByCodePoint(PascalTypeUnicode.cpDottedCircle);
        Glyph.Cluster := AGlyphs[Syllable.Start + 1].Cluster;
        Glyph.SyllableIndex := i;
        Glyph.SyllableType := stBroken_Cluster;
        Glyph.SyllabicCategory := PascalTypeUnicode.GetIndicSyllabicCategory(PascalTypeUnicode.cpDottedCircle);
        Glyph.PositionalCategory := PascalTypeUnicode.GetIndicPositionalCategory(PascalTypeUnicode.cpDottedCircle);
        Inc(Syllable.Stop);
      end;

      // Cluster IDs
      if (AGlyphs.ClusterLevel <= clLevel1) then
      begin
        // For Level 0 and 1, we merge clusters for broken clusters and standalone clusters.
        // This ensures that dotted circles and placeholders have the same cluster ID
        // as the rest of the syllable.
        // Consonant and vowel syllables are not merged here; they are merged
        // by the reordering logic and by substitutions.
        if (Syllable.SyllableType in [stBroken_Cluster, stStandalone_Cluster]) then
          AGlyphs.MergeClusters(Syllable.Start, Syllable.Stop);
      end;

      // Basic features (nukt, akhn, rkrf, vatu, cjct) apply to everything
      for var j := Syllable.Start to Syllable.Stop do
      begin
        AGlyphs[j].PlanFeatures.Add('nukt');
        AGlyphs[j].PlanFeatures.Add('akhn');
        AGlyphs[j].PlanFeatures.Add('rkrf');
        AGlyphs[j].PlanFeatures.Add('vatu');
        AGlyphs[j].PlanFeatures.Add('cjct');

        // Add optional/requested features
        AGlyphs[j].PlanFeatures.Add(AFeatures);
      end;

      // 3.1 Tag glyphs for reordering
      TagSyllableGlyphs(AGlyphs, Syllable);

      // init feature - apply to the glyph that will end up at the start of the word.
      // Reference: https://github.com/n8willis/opentype-shaping-documents/blob/master/opentype-shaping-indic-general.md#stage-4-step-5-flagging-initial-matras
      var IsWordStart := (Syllable.Start = 0) or (GetIndicClass(AGlyphs[Syllable.Start - 1].SyllabicCategory) = icX);
      if (IsWordStart) and (Syllable.SyllableType <> stNon_Indic_Cluster) then
      begin
        var InitGlyphIndex := Syllable.Start;
        var MinSortPos := AGlyphs[Syllable.Start].SortPosition;
        for var j := Syllable.Start + 1 to Syllable.Stop do
        begin
          if (AGlyphs[j].SortPosition < MinSortPos) then
          begin
            MinSortPos := AGlyphs[j].SortPosition;
            InitGlyphIndex := j;
          end;
        end;

        // Stage 4, Step 5: Flagging initial matras.
        // Apply 'init' to the glyph that will end up at the start of the word.
        // We only apply this to pre-base matras as per the specification's Stage 4, Step 5.
        // If no pre-base matra reordered to the front, then 'init' isn't flagged here.
        if (AGlyphs[InitGlyphIndex].SortPosition = Ord(ispPrebaseMatra)) and
           (GetIndicClass(AGlyphs[InitGlyphIndex].SyllabicCategory) = icDV) then
        begin
          AGlyphs[InitGlyphIndex].PlanFeatures.Add('init');
        end;
      end;

      // Repha
      if Syllable.Repha <> -1 then
      begin
        // Tag all glyphs that belong to the Repha sequence
        var RephaEnd := MatchREPH(AGlyphs, Syllable.Repha);
        for var j := Syllable.Repha to RephaEnd - 1 do
        begin
          AGlyphs[j].PlanFeatures.Add('rphf');
          AGlyphs[j].SyllabicPosition := spRepha;
          AGlyphs[j].SortPosition := Ord(FScriptProperties.RephPos);
        end;
      end;

      // pref, blwf, pstf
      var j := Syllable.Start;
      while (j < Syllable.Stop) do
      begin
        if (GetIndicClass(AGlyphs[j].SyllabicCategory) = icH) then // VIRAMA
        begin
           var k := j + 1;
           // Skip joiners
           while (k <= Syllable.Stop) and ((AGlyphs[k].CodePoint = PascalTypeUnicode.cpZWJ) or (AGlyphs[k].CodePoint = PascalTypeUnicode.cpZWNJ)) do
             Inc(k);

           if (k <= Syllable.Stop) and (GetIndicClass(AGlyphs[k].SyllabicCategory) = icC) then
           begin
              // It's a subjoined consonant!
              AGlyphs[j].PlanFeatures.Add('pref');
              AGlyphs[k].PlanFeatures.Add('pref');
              AGlyphs[j].PlanFeatures.Add('blwf');
              AGlyphs[k].PlanFeatures.Add('blwf');
              AGlyphs[j].PlanFeatures.Add('abvf');
              AGlyphs[k].PlanFeatures.Add('abvf');
              AGlyphs[j].PlanFeatures.Add('pstf');
              AGlyphs[k].PlanFeatures.Add('pstf');

              // In v2, many post-base consonants that reorder use 'pref'.
              // In our supported scripts, this is only RA in Malayalam.
              if (FScriptID = isMalayalam) and IsRA(AGlyphs[k].CodePoint) then
              begin
                AGlyphs[j].SyllabicPosition := spPre_Base;
                AGlyphs[j].SortPosition := Ord(ispPrefForm);
                AGlyphs[k].SyllabicPosition := spPre_Base;
                AGlyphs[k].SortPosition := Ord(ispPrefForm);
              end;

              j := k;
           end;
        end else
        if (Syllable.Base <> -1) and (j < Syllable.Base) and (GetIndicClass(AGlyphs[j].SyllabicCategory) = icC) and (j + 1 <= Syllable.Stop) and (GetIndicClass(AGlyphs[j+1].SyllabicCategory) = icH) then
        begin
           // Consonants before base get 'half' if virama follows.
           // Only for scripts that use half-forms in v2.
           if (FScriptID in [isDevanagari, isBengali, isGurmukhi, isGujarati, isOriya, isTelugu, isKannada]) then
           begin
             AGlyphs[j].PlanFeatures.Add('half');
             AGlyphs[j+1].PlanFeatures.Add('half');
           end;
        end;
        Inc(j);
      end;

      // Reordering is now handled by delegates in the shaping plan
    end;
  finally
    Syllables.Free;
  end;
end;

class function TPascalTypeIndicShaper.GetIndicClass(ACategory: TIndicSyllabicCategory): TIndicClass;
begin
  case ACategory of
    iscConsonant,
    iscConsonant_Dead,
    iscConsonant_With_Stacker,
    iscConsonant_Prefixed,
    iscConsonant_Initial_Postfixed,
    iscConsonant_Succeeding_Repha,
    iscConsonant_Subjoined,
    iscConsonant_Medial,
    iscConsonant_Final,
    iscConsonant_Head_Letter,
    iscConsonant_Killer,
    iscConsonant_Placeholder:
      Result := icC;

    iscVowel_Independent:
      Result := icV;

    iscNukta:
      Result := icN;

    iscVirama,
    iscInvisible_Stacker:
      Result := icH;

    iscVowel_Dependent,
    iscVowel:
      Result := icDV;

    iscBindu,
    iscVisarga,
    iscAvagraha,
    iscSyllable_Modifier,
    iscGemination_Mark,
    iscCantillation_Mark,
    iscRegister_Shifter,
    iscTone_Mark,
    iscTone_Letter,
    iscModifying_Letter:
      Result := icM;

    iscConsonant_Preceding_Repha:
      Result := icR;

    iscNumber,
    iscBrahmi_Joining_Number:
      Result := icC;

    iscJoiner,
    iscNon_Joiner:
      Result := icJ;

    else
      Result := icX;
  end;
end;

function TPascalTypeIndicShaper.IsPlaceholder(Index: integer; const AGlyphs: TPascalTypeGlyphString): boolean;
begin
  // _placeholder_ = PLACEHOLDER | CONSONANT_PLACEHOLDER | NUMBER
  // Note: NUMBER also includes icC if it's a digit.
  // See OpenType Shaping Documents - Indic General, Stage 1:
  // https://github.com/n8willis/opentype-shaping-documents/blob/master/opentype-shaping-indic-general.md#stage-1-identifying-syllables-and-other-sequences
  var Glyph := AGlyphs[Index];
  case Glyph.SyllabicCategory of
    iscConsonant_Placeholder,
    iscNumber:
      Exit(True);
  end;

  // Manual identification of digits and NBSP if they didn't get classified by UCD.
  if PascalTypeUnicode.IsDigit(Glyph.CodePoint) then
    Exit(True);

  if (Glyph.CodePoint = $00A0) then // NO-BREAK SPACE
    Exit(True);

  Result := False;
end;

function TPascalTypeIndicShaper.IsRA(ACodePoint: TPascalTypeCodePoint): boolean;
begin
  // Standard Indic RA at block offset $30 for Devanagari through Malayalam.
  // See OpenType Shaping Documents - Indic General, Stage 1:
  // https://github.com/n8willis/opentype-shaping-documents/blob/master/opentype-shaping-indic-general.md#stage-1-identifying-syllables-and-other-sequences
  if (ACodePoint and $7F = $30) and (ACodePoint >= $0900) and (ACodePoint <= $0D7F) then
    Exit(True);

  // Script-specific RA overrides.
  case ACodePoint of
    $0DBB: // SINHALA LETTER RAYANNA (Ra)
           // See OpenType Shaping Documents - Sinhala, Stage 1:
           // https://github.com/n8willis/opentype-shaping-documents/blob/master/opentype-shaping-sinhala.md#stage-1-identifying-syllables-and-other-sequences
      Result := True;
  else
    Result := False;
  end;
end;

procedure TPascalTypeIndicShaper.SegmentSyllables(var AGlyphs: TPascalTypeGlyphString; ASyllables: TList<TIndicSyllable>);
begin
  var i := 0;
  while (i < AGlyphs.Count) do
  begin
    // To prevent incorrect splitting (and mis-categorisation) of a syllable,
    // the greediest syllable match wins.
    // In the event of a tie, precedence is:
    // consonant > vowel > standalone > symbol > broken
    // See HarfBuzz - match_syllable in hb-ot-shape-complex-indic.cc

    var Syllable: TIndicSyllable;
    Syllable.Start := i;
    Syllable.Base := -1;
    Syllable.Repha := -1;

    var C_Next := MatchConsonantSyllable(AGlyphs, i, Syllable.Base, Syllable.Repha);
    var V_Base, V_Repha: integer;
    var V_Next := MatchVowelSyllable(AGlyphs, i, V_Base, V_Repha);
    var S_Base, S_Repha: integer;
    var S_Next := MatchStandaloneSyllable(AGlyphs, i, S_Base, S_Repha);
    var Y_Base, Y_Repha: integer;
    var Y_Next := MatchSymbolSyllable(AGlyphs, i, Y_Base, Y_Repha);
    var B_Base, B_Repha: integer;
    var B_Next := MatchBrokenSyllable(AGlyphs, i, B_Base, B_Repha);

    var Next := Max(C_Next, Max(V_Next, Max(S_Next, Max(Y_Next, B_Next))));

    if (Next = C_Next) and (C_Next > i) then
    begin
      Syllable.SyllableType := stConsonant_Syllable;
      // Already has base/repha from MatchConsonantSyllable
    end else
    if (Next = V_Next) and (V_Next > i) then
    begin
      Syllable.SyllableType := stVowel_Syllable;
      Syllable.Base := V_Base;
      Syllable.Repha := V_Repha;
    end else
    if (Next = S_Next) and (S_Next > i) then
    begin
      Syllable.SyllableType := stStandalone_Cluster;
      Syllable.Base := S_Base;
      Syllable.Repha := S_Repha;
    end else
    if (Next = Y_Next) and (Y_Next > i) then
    begin
      Syllable.SyllableType := stNon_Indic_Cluster;
      Syllable.Base := Y_Base;
      Syllable.Repha := Y_Repha;
    end else
    begin
      Syllable.SyllableType := stBroken_Cluster;
      Syllable.Base := B_Base;
      Syllable.Repha := B_Repha;
      Next := B_Next;
    end;

    Syllable.Stop := Next - 1;
    for var j := Syllable.Start to Syllable.Stop do
    begin
      AGlyphs[j].SyllableIndex := ASyllables.Count;
      AGlyphs[j].SyllableType := Syllable.SyllableType;
    end;
    ASyllables.Add(Syllable);
    i := Next;
  end;
end;

procedure TPascalTypeIndicShaper.SortSyllable(var AGlyphs: TPascalTypeGlyphString; const ASyllable: TIndicSyllable);
begin
  var Reordered := False;
  // Stable bubble sort on SortPosition
  for var i := ASyllable.Start to ASyllable.Stop - 1 do
  begin
    for var j := ASyllable.Start to ASyllable.Stop - 1 - (i - ASyllable.Start) do
    begin
      if (AGlyphs[j].SortPosition > AGlyphs[j + 1].SortPosition) then
      begin
        AGlyphs.Move(j, j + 1);
        Reordered := True;
      end;
    end;
  end;

  if Reordered then
    AGlyphs.MergeClusters(ASyllable.Start, ASyllable.Stop);
end;

function TPascalTypeIndicShaper.FindSyllableBase(const AGlyphs: TPascalTypeGlyphString; Start, Stop: integer): integer;
begin
  // Re-implement Stage 4, Step 1: Base consonant search.
  // Note: This logic must match what was used in SegmentSyllables but
  // account for the fact that substitutions might have occurred.
  // See: https://github.com/n8willis/opentype-shaping-documents/blob/master/opentype-shaping-indic-general.md#stage-4-step-1-base-consonant

  Result := -1;
  if (Start > Stop) then
    exit;

  // Standalone sequences and independent vowel bases are always the base.
  if (GetIndicClass(AGlyphs[Start].SyllabicCategory) in [icV, icX]) or
     (AGlyphs[Start].CodePoint = PascalTypeUnicode.cpDottedCircle) or
     IsPlaceholder(Start, AGlyphs) then
  begin
    Exit(Start);
  end;

  // Consonant syllable base search.
  // Skip initial repha/stacker if present.
  var i := Start;
  if (AGlyphs[i].SyllabicCategory in [iscConsonant_Preceding_Repha, iscConsonant_With_Stacker]) then
    Inc(i);

  if (FScriptProperties.BasePos = bpLastSinhala) then
  begin
    // Sinhala algorithm: Starting from the end, move backwards until a consonant is found.
    // Stop if preceded by ZWJ.
    var j := Stop;
    while (j >= i) do
    begin
      if (GetIndicClass(AGlyphs[j].SyllabicCategory) = icC) then
      begin
        if (j > i) and (AGlyphs[j-1].CodePoint = PascalTypeUnicode.cpZWJ) then
        begin
          Dec(j, 2); // Skip ZWJ and keep looking
          continue;
        end;
        Exit(j);
      end;
      Dec(j);
    end;
    Exit(i); // Fallback to first
  end else
  begin
    // Standard BASE_POS_LAST algorithm.
    // The base consonant is the last consonant in the syllable, excluding all consonants
    // that take on special post-base or below-base forms.
    // In our implementation, we track this via the 'Base' index identified during segmentation,
    // but since glyphs might have been merged or substituted, we look for the last glyph
    // that WAS marked as spBase.
    for var j := Stop downto Start do
      if (AGlyphs[j].SyllabicPosition = spBase) then
        Exit(j);

    // Fallback if no spBase tag found (shouldn't happen for valid syllables)
    for var j := Start to Stop do
      if (GetIndicClass(AGlyphs[j].SyllabicCategory) = icC) and (AGlyphs[j].SortPosition <> Ord(ispPrefForm)) then
        Exit(j);
  end;
  Result := Start;
end;

function TPascalTypeIndicShaper.ReorderInitialDelegate(AProcessor: TObject; var AGlyphs: TPascalTypeGlyphString): TTableNames;
begin
  // Stage 4, Step 3: Repha positioning.
  // Re-implements the 7-step Repha positioning algorithm.
  // Reference: https://github.com/n8willis/opentype-shaping-documents/blob/master/opentype-shaping-indic-general.md#stage-4-step-3-reph

  if (FScriptProperties.RephMode = rmExplicit) then
    Exit(nil);

  var i := 0;
  while (i < AGlyphs.Count) do
  begin
    if (AGlyphs[i].SyllabicPosition = spRepha) then
    begin
      var SyllableIndex := AGlyphs[i].SyllableIndex;
      var Start := i;
      while (Start > 0) and (AGlyphs[Start - 1].SyllableIndex = SyllableIndex) do
        Dec(Start);
      var Stop := i;
      while (Stop < AGlyphs.Count - 1) and (AGlyphs[Stop + 1].SyllableIndex = SyllableIndex) do
        Inc(Stop);

      var RephaStart := i;
      var RephaEnd := i;
      while (RephaEnd <= Stop) and (AGlyphs[RephaEnd].SyllabicPosition = spRepha) do
        Inc(RephaEnd);
      var RephaLen := RephaEnd - RephaStart;

      var Base := FindSyllableBase(AGlyphs, Start, Stop);

      // (a) If rule is REPH_POS_AFTER_POST, jump to (e).
      var TargetPos := -1;
      if (FScriptProperties.RephPos <> ispAfterPost) then
      begin
        // (b) Find first explicit Halant between base and first post-Repha consonant.
        for var j := Base + 1 to Stop do
        begin
          if (GetIndicClass(AGlyphs[j].SyllabicCategory) = icH) then
          begin
            TargetPos := j + 1;
            // If ZWJ/ZWNJ follows, move after it.
            if (TargetPos <= Stop) and (GetIndicClass(AGlyphs[TargetPos].SyllabicCategory) = icJ) then
              Inc(TargetPos);
            break;
          end;
        end;

        if (TargetPos = -1) then
        begin
          // (c) REPH_POS_AFTER_MAIN
          if (FScriptProperties.RephPos = ispAfterMain) then
          begin
             for var j := Base + 1 to Stop do
             begin
               if (GetIndicClass(AGlyphs[j].SyllabicCategory) = icC) and (AGlyphs[j].SyllabicPosition <> spPre_Base) then
               begin
                 TargetPos := j + 1;
                 break;
               end;
             end;
          end;
        end;

        if (TargetPos = -1) then
        begin
          // (d) REPH_POS_BEFORE_POST
          if (FScriptProperties.RephPos = ispBeforePost) then
          begin
             for var j := Base + 1 to Stop do
             begin
               if (AGlyphs[j].SyllabicPosition = spPost_Base) and (GetIndicClass(AGlyphs[j].SyllabicCategory) = icC) then
               begin
                 TargetPos := j;
                 break;
               end;
             end;
          end;
        end;
      end;

      if (TargetPos = -1) then
      begin
        // (e) Move before first post-base matra/modifier with sort position > RephPos
        for var j := Base + 1 to Stop do
        begin
          if (AGlyphs[j].SortPosition > Ord(FScriptProperties.RephPos)) then
          begin
            TargetPos := j;
            break;
          end;
        end;
      end;

      if (TargetPos = -1) then
        // (f) Move to end of syllable.
        TargetPos := Stop + 1;

      // (mH) If after a "matra, Halant" sequence, move before Halant.
      if (TargetPos > Start + 1) and (TargetPos <= Stop + 1) then
      begin
         if (GetIndicClass(AGlyphs[TargetPos - 1].SyllabicCategory) = icH) and
            (TargetPos > Start + 1) and (GetIndicClass(AGlyphs[TargetPos - 2].SyllabicCategory) = icDV) then
           Dec(TargetPos);
      end;

      // Perform the move.
      if (TargetPos <> RephaStart) and (TargetPos <> RephaEnd) then
      begin
        if (TargetPos > RephaEnd) then
        begin
          for var k := 0 to RephaLen - 1 do
            AGlyphs.Move(RephaStart, TargetPos - 1);
        end else
        if (TargetPos < RephaStart) then
        begin
          for var k := 0 to RephaLen - 1 do
            AGlyphs.Move(RephaStart + k, TargetPos + k);
        end;

        // Ensure Level 0/1 cluster mapping is updated on reordering
        AGlyphs.MergeClusters(Start, Stop);
      end;

      i := Stop + 1;
      continue;
    end;
    Inc(i);
  end;
  Result := nil;
end;

function TPascalTypeIndicShaper.ReorderPreBaseDelegate(AProcessor: TObject; var AGlyphs: TPascalTypeGlyphString): TTableNames;
begin
  var i := 0;
  while (i < AGlyphs.Count) do
  begin
    var Glyph := AGlyphs[i];

    if (Glyph.SyllabicPosition = spPre_Base) then
    begin
      var SyllableIndex := Glyph.SyllableIndex;

      // Find syllable boundaries
      var Start := i;
      while (Start > 0) and (AGlyphs[Start - 1].SyllableIndex = SyllableIndex) do
        Dec(Start);

      var Stop := i;
      while (Stop < AGlyphs.Count - 1) and (AGlyphs[Stop + 1].SyllableIndex = SyllableIndex) do
        Inc(Stop);

      var Syllable: TIndicSyllable;
      Syllable.Start := Start;
      Syllable.Stop := Stop;
      SortSyllable(AGlyphs, Syllable);

      i := Stop + 1;
      continue;
    end;

    Inc(i);
  end;
  Result := nil;
end;

function TPascalTypeIndicShaper.ReorderFinalDelegate(AProcessor: TObject; var AGlyphs: TPascalTypeGlyphString): TTableNames;
begin
  // Stage 4, Step 2: Pre-base matra positioning.
  // Reference: https://github.com/n8willis/opentype-shaping-documents/blob/master/opentype-shaping-indic-general.md#stage-4-step-2-pre-base-matras

  var i := 0;
  while (i < AGlyphs.Count) do
  begin
    // Identify pre-base matra.
    if (GetIndicClass(AGlyphs[i].SyllabicCategory) = icDV) and (AGlyphs[i].SyllabicPosition = spPre_Base) then
    begin
      var SyllableIndex := AGlyphs[i].SyllableIndex;
      var Start := i;
      while (Start > 0) and (AGlyphs[Start - 1].SyllableIndex = SyllableIndex) do
        Dec(Start);
      var Stop := i;
      while (Stop < AGlyphs.Count - 1) and (AGlyphs[Stop + 1].SyllableIndex = SyllableIndex) do
        Inc(Stop);

      var MatraPos := i;
      var Base := FindSyllableBase(AGlyphs, Start, Stop);

      // The position is defined as:
      // - after the last standalone "Halant" glyph that comes after the matra's
      //   starting position and also comes before the main consonant.
      // - If a ZWJ follows this last standalone "Halant", the final matra
      //   position is moved to after the joiner.
      var TargetPos := Start;
      for var j := MatraPos + 1 to Base - 1 do
      begin
        if (GetIndicClass(AGlyphs[j].SyllabicCategory) = icH) then
        begin
          TargetPos := j + 1;
          // Check for optional ZWJ (Uniscribe/HarfBuzz compatibility note in spec)
          if (TargetPos < Base) and (AGlyphs[TargetPos].CodePoint = PascalTypeUnicode.cpZWJ) then
            Inc(TargetPos);
        end;
      end;

      if (TargetPos <> MatraPos) then
      begin
        if (TargetPos > MatraPos) then
          AGlyphs.Move(MatraPos, TargetPos - 1)
        else
          AGlyphs.Move(MatraPos, TargetPos);

        // Ensure Level 0/1 cluster mapping is updated on reordering
        AGlyphs.MergeClusters(Start, Stop);
      end;

      // Note: We don't advance i past the syllable because there might be multiple
      // pre-base matras (rare but possible in some scripts/Vedic).
      Inc(i);
      continue;
    end;
    Inc(i);
  end;
  Result := nil;
end;

initialization
  TPascalTypeShaper.RegisterShaperForScript('dev2', TPascalTypeIndicShaper);
  TPascalTypeShaper.RegisterShaperForScript('bng2', TPascalTypeIndicShaper);
  TPascalTypeShaper.RegisterShaperForScript('gur2', TPascalTypeIndicShaper);
  TPascalTypeShaper.RegisterShaperForScript('gjr2', TPascalTypeIndicShaper);
  TPascalTypeShaper.RegisterShaperForScript('ory2', TPascalTypeIndicShaper);
  TPascalTypeShaper.RegisterShaperForScript('tml2', TPascalTypeIndicShaper);
  TPascalTypeShaper.RegisterShaperForScript('tel2', TPascalTypeIndicShaper);
  TPascalTypeShaper.RegisterShaperForScript('knd2', TPascalTypeIndicShaper);
  TPascalTypeShaper.RegisterShaperForScript('mlm2', TPascalTypeIndicShaper);
  TPascalTypeShaper.RegisterShaperForScript('sinh', TPascalTypeIndicShaper);

  TPascalTypeShaper.RegisterShaperForScript('deva', TPascalTypeIndicShaper);
  TPascalTypeShaper.RegisterShaperForScript('beng', TPascalTypeIndicShaper);
  TPascalTypeShaper.RegisterShaperForScript('guru', TPascalTypeIndicShaper);
  TPascalTypeShaper.RegisterShaperForScript('gujr', TPascalTypeIndicShaper);
  TPascalTypeShaper.RegisterShaperForScript('orya', TPascalTypeIndicShaper);
  TPascalTypeShaper.RegisterShaperForScript('taml', TPascalTypeIndicShaper);
  TPascalTypeShaper.RegisterShaperForScript('telu', TPascalTypeIndicShaper);
  TPascalTypeShaper.RegisterShaperForScript('knda', TPascalTypeIndicShaper);
  TPascalTypeShaper.RegisterShaperForScript('mlym', TPascalTypeIndicShaper);
end.