oasis-editor 0.0.98 → 0.0.100

package/dist/{OasisEditorApp-QVHCHhPa.js → OasisEditorApp-CRjXmvyC.js}

@@ -1,7 +1,7 @@
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-import { v as visitRun, a as assertNever, c as createSignal, b as createEditorStateFromDocument, d as createInitialEditorState, S as STANDARD_FONT_SIZES_PT, f as fontSizePxToPt, p as probeLocalFontFamilies, e as createEditorParagraphFromRuns, i as isInlineObjectRun, g as createEditorStyledRun, h as getParagraphLength, j as getParagraphText, k as getActiveZone, l as getDocumentSections, m as getActiveSectionIndex, n as getParagraphs, o as normalizeSelection, q as positionToParagraphOffset, r as paragraphOffsetToPosition, s as clampPosition, t as findParagraphIndex, u as createCollapsedSelection, w as isSelectionCollapsed, x as parseFontSizePtToPx, y as formatFontSizePt, z as createEditorParagraph, A as getBlockParagraphs, B as findParagraphTableLocation, C as buildTableCellLayout, P as PT_PER_PX, D as createEditorTableCell, E as createEditorTableRow, F as createEditorTable, G as underlineStyleToCssDecorationStyle, H as resolveImageSrc, I as listKindForTag, J as isParagraphTag, K as collectInlineRuns, L as parseParagraphStyle, M as getRunImage, N as InlineShell, O as BalloonShell, Q as DocumentShell, R as createMemo, T as buildCanvasLayoutSnapshot, U as getCaretRectFromSnapshot, V as getParagraphRectFromSnapshot, W as createComponent, X as CaretOverlay, Y as Show, Z as createRenderEffect, _ as style, $ as setAttribute, a0 as setStyleProperty, a1 as memo, a2 as template, a3 as useI18n, a4 as createEffect, a5 as insert, a6 as use, a7 as addEventListener, a8 as Dialog, a9 as delegateEvents, aa as className, ab as For, ac as UNDERLINE_STYLE_OPTIONS, ad as Tabs, ae as onMount, af as onCleanup, ag as PluginUiHost, ah as OasisEditorEditor, ai as OasisBrandMark, aj as setPreciseFontPreference, ak as setWelcomeSeen, al as enablePreciseFontMode, am as TWIPS_PER_POINT, an as PX_PER_INCH, ao as TWIPS_PER_INCH, ap as resolveEffectiveParagraphStyle, aq as resolveEffectiveTextStyleForParagraph, ar as EMU_PER_PX, as as EMU_PER_PT, at as getRunFootnoteReference, au as getRunEndnoteReference, av as iterateFootnoteReferenceRuns, aw as iterateEndnoteReferenceRuns, ax as imageContentTypeDefaults, ay as getRunFieldChar, az as getRunFieldInstruction, aA as createEditorRun, aB as JSZip, aC as imageExtensionFromMime, aD as pxToPt$1, aE as resolveFloatingObjectRect, aF as getTextBoxFloatingGeometry, aG as getPresetPathSegments, aH as projectBlocksLayout, aI as buildListLabels, aJ as getImageFloatingGeometry, aK as textStyleToFontSizePt, aL as PX_PER_POINT, aM as DEFAULT_FONT_SIZE_PX, aN as isDoubleUnderlineStyle, aO as isWavyUnderlineStyle, aP as underlineStyleLineWidthPx, aQ as underlineStyleDashArray, aR as resolveListLabel, aS as getListLabelInset, aT as getAlignedListLabelInset, aU as getParagraphBorderInsets, aV as buildSegmentTable, aW as buildCanvasTableLayout, aX as resolveCanvasTableWidth, aY as resolveFloatingTableRect, aZ as normalizeFamily, a_ as ROBOTO_FONT_FILES, a$ as loadFontAsset, b0 as OFFICE_COMPAT_FONT_FAMILIES, b1 as buildSfnt, b2 as defaultFontDecoderRegistry, b3 as SfntFontProgram, b4 as collectPdfFontFamilies, b5 as projectDocumentLayout, b6 as getPageContentWidth, b7 as getPageHeaderZoneTop, b8 as getPageBodyTop, b9 as getPageColumnRects, ba as findFootnoteReference, bb as FOOTNOTE_MARKER_GUTTER_PX, bc as resolveImporterForFile, bd as getDocumentSectionsCanonical, be as getDocumentParagraphsCanonical, bf as getDocumentParagraphs, bg as getDocumentPageSettings, bh as getTableCellContentWidthForParagraph, bi as on, bj as debounce, bk as unwrap, bl as perfTimer, bm as getRunTextBox, bn as createEditorDocument, bo as resolveResizedDimensions, bp as resolveTextBoxRenderHeight, bq as getToolbarStyleState, br as getCachedCanvasImage, bs as measureParagraphMinContentWidthPx, bt as getEditableBlocksForZone, bu as findParagraphLocation, bv as createSectionBoundaryParagraph, bw as normalizePageSettings, bx as DEFAULT_EDITOR_PAGE_SETTINGS, by as markStart, bz as markEnd, bA as getParagraphEntries, bB as getParagraphById, bC as createEditorFootnote, bD as createFootnoteReferenceRun, bE as renumberFootnotes, bF as getFootnoteDisplayMarker, bG as getHeadingLevel, bH as preciseFontModeVersion, bI as isPreciseFontModeEnabled, bJ as resolveNamedTextStyle, bK as togglePreciseFontMode, bL as nextFontSizePt, bM as previousFontSizePt, bN as fontSizePtToPx, bO as createDefaultToolbarPreset, bP as MenuRegistry, bQ as createToolbarRegistry, bR as Editor, bS as resolveCommandRef, bT as commandRefName, bU as createOasisEditorClient, bV as createEditorZoom, bW as startLongTaskObserver, bX as installGlobalReport, bY as applyStoredPreciseFontPreference, bZ as getWelcomeSeen, b_ as isLocalFontAccessSupported, b$ as EDITOR_SCROLL_PADDING_PX, c0 as Toolbar, c1 as OasisEditorLoading, c2 as I18nProvider, c3 as createTranslator, c4 as createEditorLogger, c5 as registerDomStatsSurface } from "./index-DBzN897A.js";
+import { v as visitRun, a as assertNever, c as createSignal, b as createEditorStateFromDocument, d as createInitialEditorState, S as STANDARD_FONT_SIZES_PT, f as fontSizePxToPt, p as probeLocalFontFamilies, e as createEditorParagraphFromRuns, i as isInlineObjectRun, g as createEditorStyledRun, h as getParagraphLength, j as getParagraphText, k as getActiveZone, l as getDocumentSections, m as getActiveSectionIndex, n as getParagraphs, o as normalizeSelection, q as positionToParagraphOffset, r as paragraphOffsetToPosition, s as clampPosition, t as findParagraphIndex, u as createCollapsedSelection, w as isSelectionCollapsed, x as parseFontSizePtToPx, y as formatFontSizePt, z as createEditorParagraph, A as getBlockParagraphs, B as findParagraphTableLocation, C as buildTableCellLayout, P as PT_PER_PX, D as createEditorTableCell, E as createEditorTableRow, F as createEditorTable, G as underlineStyleToCssDecorationStyle, H as resolveImageSrc, I as listKindForTag, J as isParagraphTag, K as collectInlineRuns, L as parseParagraphStyle, M as getRunImage, N as InlineShell, O as BalloonShell, Q as DocumentShell, R as createMemo, T as buildCanvasLayoutSnapshot, U as getCaretRectFromSnapshot, V as getParagraphRectFromSnapshot, W as createComponent, X as CaretOverlay, Y as Show, Z as createRenderEffect, _ as style, $ as setAttribute, a0 as setStyleProperty, a1 as memo, a2 as template, a3 as useI18n, a4 as createEffect, a5 as insert, a6 as use, a7 as addEventListener, a8 as Dialog, a9 as delegateEvents, aa as className, ab as For, ac as UNDERLINE_STYLE_OPTIONS, ad as Tabs, ae as onMount, af as onCleanup, ag as PluginUiHost, ah as OasisEditorEditor, ai as OasisBrandMark, aj as setPreciseFontPreference, ak as setWelcomeSeen, al as enablePreciseFontMode, am as TWIPS_PER_POINT, an as PX_PER_INCH, ao as TWIPS_PER_INCH, ap as resolveEffectiveParagraphStyle, aq as resolveEffectiveTextStyleForParagraph, ar as EMU_PER_PX, as as EMU_PER_PT, at as getRunFootnoteReference, au as getRunEndnoteReference, av as iterateFootnoteReferenceRuns, aw as iterateEndnoteReferenceRuns, ax as imageContentTypeDefaults, ay as getRunFieldChar, az as getRunFieldInstruction, aA as createEditorRun, aB as JSZip, aC as imageExtensionFromMime, aD as pxToPt$1, aE as resolveFloatingObjectRect, aF as getTextBoxFloatingGeometry, aG as getPresetPathSegments, aH as projectBlocksLayout, aI as buildListLabels, aJ as getImageFloatingGeometry, aK as textStyleToFontSizePt, aL as PX_PER_POINT, aM as resolveOpenTypeFeatureTags, aN as DEFAULT_FONT_SIZE_PX, aO as isDoubleUnderlineStyle, aP as isWavyUnderlineStyle, aQ as underlineStyleLineWidthPx, aR as underlineStyleDashArray, aS as resolveListLabel, aT as getListLabelInset, aU as getAlignedListLabelInset, aV as getParagraphBorderInsets, aW as buildSegmentTable, aX as buildCanvasTableLayout, aY as resolveCanvasTableWidth, aZ as resolveFloatingTableRect, a_ as normalizeFamily, a$ as ROBOTO_FONT_FILES, b0 as loadFontAsset, b1 as OFFICE_COMPAT_FONT_FAMILIES, b2 as BinaryReader, b3 as buildSfnt, b4 as defaultFontDecoderRegistry, b5 as SfntFontProgram, b6 as collectPdfFontFamilies, b7 as projectDocumentLayout, b8 as getPageContentWidth, b9 as getPageHeaderZoneTop, ba as getPageBodyTop, bb as getPageColumnRects, bc as findFootnoteReference, bd as FOOTNOTE_MARKER_GUTTER_PX, be as resolveImporterForFile, bf as getDocumentSectionsCanonical, bg as getDocumentParagraphsCanonical, bh as getDocumentParagraphs, bi as getDocumentPageSettings, bj as getTableCellContentWidthForParagraph, bk as on, bl as debounce, bm as unwrap, bn as perfTimer, bo as getRunTextBox, bp as createEditorDocument, bq as resolveResizedDimensions, br as resolveTextBoxRenderHeight, bs as getToolbarStyleState, bt as getCachedCanvasImage, bu as measureParagraphMinContentWidthPx, bv as getEditableBlocksForZone, bw as findParagraphLocation, bx as createSectionBoundaryParagraph, by as normalizePageSettings, bz as DEFAULT_EDITOR_PAGE_SETTINGS, bA as markStart, bB as markEnd, bC as getParagraphEntries, bD as getParagraphById, bE as createEditorFootnote, bF as createFootnoteReferenceRun, bG as renumberFootnotes, bH as getFootnoteDisplayMarker, bI as getHeadingLevel, bJ as preciseFontModeVersion, bK as isPreciseFontModeEnabled, bL as resolveNamedTextStyle, bM as togglePreciseFontMode, bN as nextFontSizePt, bO as previousFontSizePt, bP as fontSizePtToPx, bQ as createDefaultToolbarPreset, bR as MenuRegistry, bS as createToolbarRegistry, bT as Editor, bU as resolveCommandRef, bV as commandRefName, bW as createOasisEditorClient, bX as createEditorZoom, bY as startLongTaskObserver, bZ as installGlobalReport, b_ as applyStoredPreciseFontPreference, b$ as getWelcomeSeen, c0 as isLocalFontAccessSupported, c1 as EDITOR_SCROLL_PADDING_PX, c2 as Toolbar, c3 as OasisEditorLoading, c4 as I18nProvider, c5 as createTranslator, c6 as createEditorLogger, c7 as registerDomStatsSurface } from "./index-BuxYvaSC.js";
 function cloneStyle(style2) {
   return style2 ? { ...style2 } : void 0;
 }
@@ -36309,6 +36309,13 @@ async function drawFloatingImagesForParagraph(options) {
     }
   }
 }
+function blendColorWithWhite(hex, alpha) {
+  const a = Math.max(0, Math.min(1, alpha));
+  const r = Math.round(255 + (Number.parseInt(hex.slice(1, 3), 16) - 255) * a);
+  const g = Math.round(255 + (Number.parseInt(hex.slice(3, 5), 16) - 255) * a);
+  const b = Math.round(255 + (Number.parseInt(hex.slice(5, 7), 16) - 255) * a);
+  return `#${r.toString(16).padStart(2, "0")}${g.toString(16).padStart(2, "0")}${b.toString(16).padStart(2, "0")}`;
+}
 function drawFragmentHighlight(writer, pageIndex, line, fragment, originX, originY, styles) {
   if (!styles.highlight) {
     return;
@@ -36707,13 +36714,18 @@ async function drawFragmentText(writer, pageIndex, paragraph, line, fragment, do
     styles.color ?? "#000000"
   );
   const paragraphAlign = resolveEffectiveParagraphStyle(paragraph.style, document2.styles).align ?? "left";
+  const fontFeatures = resolveOpenTypeFeatureTags(
+    styles,
+    textStyleToFontSizePt(styles)
+  );
   const baseTextOptions = {
     fontSize: fontSizePt,
     bold: styles.bold,
     italic: styles.italic,
     fontResourceName: fontFace.writerResourceName,
     characterSpacing: styles.characterSpacing ?? 0,
-    horizontalScale: styles.characterScale ?? 100
+    horizontalScale: styles.characterScale ?? 100,
+    fontFeatures
   };
   const mainColor = ((_b = styles.textFill) == null ? void 0 : _b.type) === "solid" ? styles.textFill.color : ((_c = styles.textFill) == null ? void 0 : _c.type) === "gradient" && styles.textFill.stops[0] ? styles.textFill.stops[0].color : styles.color ?? "#000000";
   const offsetPt = pxToPt$1(1);
@@ -36728,6 +36740,30 @@ async function drawFragmentText(writer, pageIndex, paragraph, line, fragment, do
         color: "#BFBFBF"
       });
     }
+    if (styles.glow) {
+      const gl = styles.glow;
+      const r = pxToPt$1(gl.radiusPt * PX_PER_POINT) * 0.5;
+      const glowColor = blendColorWithWhite(gl.color, (gl.alpha ?? 0.5) * 0.4);
+      const dirs = [
+        [r, 0],
+        [-r, 0],
+        [0, r],
+        [0, -r],
+        [r * 0.7, r * 0.7],
+        [-r * 0.7, r * 0.7],
+        [r * 0.7, -r * 0.7],
+        [-r * 0.7, -r * 0.7]
+      ];
+      for (const [dx, dy] of dirs) {
+        writer.drawText(pageIndex, {
+          ...baseTextOptions,
+          x: pxToPt$1(leftPx) + dx,
+          y: pxToPt$1(baselineY) + dy,
+          text: text2,
+          color: glowColor
+        });
+      }
+    }
     if (styles.textShadow) {
       const ts = styles.textShadow;
       const dirRad = ts.dirDeg * Math.PI / 180;
@@ -36748,6 +36784,18 @@ async function drawFragmentText(writer, pageIndex, paragraph, line, fragment, do
         color: "#808080"
       });
     }
+    if (styles.reflection) {
+      const ref = styles.reflection;
+      const avgAlpha = (ref.startAlpha + ref.endAlpha) / 2;
+      const refColor = blendColorWithWhite(mainColor, avgAlpha * 0.6);
+      writer.drawText(pageIndex, {
+        ...baseTextOptions,
+        x: pxToPt$1(leftPx),
+        y: pxToPt$1(baselineY) + pxToPt$1(ref.distPt * PX_PER_POINT) + fontSizePt,
+        text: text2,
+        color: refColor
+      });
+    }
     const textOutline = styles.textOutline;
     writer.drawText(pageIndex, {
       ...baseTextOptions,
@@ -37739,7 +37787,11 @@ class PdfContentStream {
     }
     const fontResourceName = this.fonts.resolveAndMarkFontName(options);
     const unicodeState = this.fonts.getUnicodeState(fontResourceName);
-    const showCommand = unicodeState ? this.fonts.buildUnicodeShowCommand(unicodeState, options.text) : `<${encodePdfHexString(options.text)}> Tj`;
+    const showCommand = unicodeState ? this.fonts.buildUnicodeShowCommand(
+      unicodeState,
+      options.text,
+      options.fontFeatures
+    ) : `<${encodePdfHexString(options.text)}> Tj`;
     if (showCommand === null) {
       return;
     }
@@ -37826,6 +37878,917 @@ class PdfContentStream {
     );
   }
 }
+function parseCoverage(reader, offset) {
+  reader.seek(offset);
+  const format = reader.u16();
+  if (format === 1) {
+    const count = reader.u16();
+    const map = /* @__PURE__ */ new Map();
+    for (let i = 0; i < count; i += 1) {
+      map.set(reader.u16(), i);
+    }
+    return (glyphId) => map.get(glyphId) ?? -1;
+  }
+  if (format === 2) {
+    const rangeCount = reader.u16();
+    const ranges = [];
+    for (let i = 0; i < rangeCount; i += 1) {
+      const start = reader.u16();
+      const end = reader.u16();
+      const startIndex = reader.u16();
+      ranges.push({ start, end, startIndex });
+    }
+    return (glyphId) => {
+      for (const range of ranges) {
+        if (glyphId >= range.start && glyphId <= range.end) {
+          return range.startIndex + (glyphId - range.start);
+        }
+      }
+      return -1;
+    };
+  }
+  return () => -1;
+}
+function parseClassDef(reader, offset) {
+  reader.seek(offset);
+  const format = reader.u16();
+  if (format === 1) {
+    const startGlyph = reader.u16();
+    const glyphCount = reader.u16();
+    const classes = new Array(glyphCount);
+    for (let i = 0; i < glyphCount; i += 1) {
+      classes[i] = reader.u16();
+    }
+    return (glyphId) => {
+      const index = glyphId - startGlyph;
+      return index >= 0 && index < glyphCount ? classes[index] : 0;
+    };
+  }
+  if (format === 2) {
+    const rangeCount = reader.u16();
+    const ranges = [];
+    for (let i = 0; i < rangeCount; i += 1) {
+      const start = reader.u16();
+      const end = reader.u16();
+      const classValue = reader.u16();
+      ranges.push({ start, end, classValue });
+    }
+    return (glyphId) => {
+      for (const range of ranges) {
+        if (glyphId >= range.start && glyphId <= range.end) {
+          return range.classValue;
+        }
+      }
+      return 0;
+    };
+  }
+  return () => 0;
+}
+function parseFeatureList(reader, featureListOffset) {
+  reader.seek(featureListOffset);
+  const featureCount = reader.u16();
+  const records = [];
+  for (let i = 0; i < featureCount; i += 1) {
+    const tag = reader.tag();
+    const offset = featureListOffset + reader.u16();
+    records.push({ tag, offset });
+  }
+  return records.map(({ tag, offset }) => {
+    reader.seek(offset);
+    reader.skip(2);
+    const lookupIndexCount = reader.u16();
+    const lookupIndices = new Array(lookupIndexCount);
+    for (let i = 0; i < lookupIndexCount; i += 1) {
+      lookupIndices[i] = reader.u16();
+    }
+    return { tag, lookupIndices };
+  });
+}
+function parseScriptList(reader, scriptListOffset) {
+  reader.seek(scriptListOffset);
+  const scriptCount = reader.u16();
+  const scripts = [];
+  for (let i = 0; i < scriptCount; i += 1) {
+    const tag = reader.tag();
+    const offset = scriptListOffset + reader.u16();
+    scripts.push({ tag, offset });
+  }
+  if (scripts.length === 0) return [];
+  const chosen = scripts.find((s) => s.tag === "latn") ?? scripts.find((s) => s.tag === "DFLT") ?? scripts[0];
+  reader.seek(chosen.offset);
+  const defaultLangSysOffset = reader.u16();
+  if (defaultLangSysOffset === 0) return [];
+  reader.seek(chosen.offset + defaultLangSysOffset);
+  reader.skip(2);
+  const requiredFeatureIndex = reader.u16();
+  const featureIndexCount = reader.u16();
+  const featureIndices = [];
+  if (requiredFeatureIndex !== 65535) {
+    featureIndices.push(requiredFeatureIndex);
+  }
+  for (let i = 0; i < featureIndexCount; i += 1) {
+    featureIndices.push(reader.u16());
+  }
+  return featureIndices;
+}
+function parseLayoutTableHeader(reader) {
+  reader.seek(0);
+  reader.skip(2);
+  reader.skip(2);
+  const scriptListOffset = reader.u16();
+  const featureListOffset = reader.u16();
+  const lookupListOffset = reader.u16();
+  const featureRecords = parseFeatureList(reader, featureListOffset);
+  const activeFeatureIndices = parseScriptList(reader, scriptListOffset);
+  const featureToLookups = /* @__PURE__ */ new Map();
+  for (const featureIndex of activeFeatureIndices) {
+    const record = featureRecords[featureIndex];
+    if (!record) continue;
+    const existing = featureToLookups.get(record.tag) ?? [];
+    for (const lookupIndex of record.lookupIndices) {
+      if (!existing.includes(lookupIndex)) existing.push(lookupIndex);
+    }
+    featureToLookups.set(record.tag, existing);
+  }
+  return { featureToLookups, lookupListOffset };
+}
+function collectLookupIndices(featureToLookups, tags) {
+  const indices = /* @__PURE__ */ new Set();
+  for (const tag of tags) {
+    for (const lookupIndex of featureToLookups.get(tag) ?? []) {
+      indices.add(lookupIndex);
+    }
+  }
+  return Array.from(indices).sort((a, b) => a - b);
+}
+function parseSingleSubst(reader, offset) {
+  reader.seek(offset);
+  const format = reader.u16();
+  const coverageOffset = offset + reader.u16();
+  if (format === 1) {
+    const delta = reader.i16();
+    const coverage = parseCoverage(reader, coverageOffset);
+    return {
+      apply(glyphs, pos) {
+        const glyph = glyphs[pos];
+        if (!glyph || coverage(glyph.id) < 0) return null;
+        glyph.id = glyph.id + delta & 65535;
+        return 1;
+      }
+    };
+  }
+  if (format === 2) {
+    const glyphCount = reader.u16();
+    const substitutes = new Array(glyphCount);
+    for (let i = 0; i < glyphCount; i += 1) {
+      substitutes[i] = reader.u16();
+    }
+    const coverage = parseCoverage(reader, coverageOffset);
+    return {
+      apply(glyphs, pos) {
+        const glyph = glyphs[pos];
+        if (!glyph) return null;
+        const index = coverage(glyph.id);
+        if (index < 0 || index >= glyphCount) return null;
+        glyph.id = substitutes[index];
+        return 1;
+      }
+    };
+  }
+  return null;
+}
+function parseMultipleSubst(reader, offset) {
+  reader.seek(offset);
+  const format = reader.u16();
+  if (format !== 1) return null;
+  const coverageOffset = offset + reader.u16();
+  const sequenceCount = reader.u16();
+  const sequenceOffsets = new Array(sequenceCount);
+  for (let i = 0; i < sequenceCount; i += 1) {
+    sequenceOffsets[i] = offset + reader.u16();
+  }
+  const sequences = sequenceOffsets.map((seqOffset) => {
+    reader.seek(seqOffset);
+    const glyphCount = reader.u16();
+    const ids = new Array(glyphCount);
+    for (let i = 0; i < glyphCount; i += 1) ids[i] = reader.u16();
+    return ids;
+  });
+  const coverage = parseCoverage(reader, coverageOffset);
+  return {
+    apply(glyphs, pos) {
+      const glyph = glyphs[pos];
+      if (!glyph) return null;
+      const index = coverage(glyph.id);
+      if (index < 0 || index >= sequences.length) return null;
+      const ids = sequences[index];
+      if (ids.length === 0) return null;
+      const codePoints = glyph.codePoints;
+      const replacement = ids.map((id, i) => ({
+        id,
+        codePoints: i === 0 ? codePoints : []
+      }));
+      glyphs.splice(pos, 1, ...replacement);
+      return ids.length;
+    }
+  };
+}
+function parseAlternateSubst(reader, offset) {
+  reader.seek(offset);
+  const format = reader.u16();
+  if (format !== 1) return null;
+  const coverageOffset = offset + reader.u16();
+  const altSetCount = reader.u16();
+  const altSetOffsets = new Array(altSetCount);
+  for (let i = 0; i < altSetCount; i += 1) {
+    altSetOffsets[i] = offset + reader.u16();
+  }
+  const altSets = altSetOffsets.map((setOffset) => {
+    reader.seek(setOffset);
+    const glyphCount = reader.u16();
+    const ids = new Array(glyphCount);
+    for (let i = 0; i < glyphCount; i += 1) ids[i] = reader.u16();
+    return ids;
+  });
+  const coverage = parseCoverage(reader, coverageOffset);
+  return {
+    apply(glyphs, pos) {
+      const glyph = glyphs[pos];
+      if (!glyph) return null;
+      const index = coverage(glyph.id);
+      if (index < 0 || index >= altSets.length) return null;
+      const alts = altSets[index];
+      if (alts.length === 0) return null;
+      glyph.id = alts[0];
+      return 1;
+    }
+  };
+}
+function parseLigatureSubst(reader, offset) {
+  reader.seek(offset);
+  const format = reader.u16();
+  if (format !== 1) return null;
+  const coverageOffset = offset + reader.u16();
+  const ligSetCount = reader.u16();
+  const ligSetOffsets = new Array(ligSetCount);
+  for (let i = 0; i < ligSetCount; i += 1) {
+    ligSetOffsets[i] = offset + reader.u16();
+  }
+  const ligatureSets = ligSetOffsets.map((setOffset) => {
+    reader.seek(setOffset);
+    const ligCount = reader.u16();
+    const ligOffsets = new Array(ligCount);
+    for (let i = 0; i < ligCount; i += 1) {
+      ligOffsets[i] = setOffset + reader.u16();
+    }
+    return ligOffsets.map((ligOffset) => {
+      reader.seek(ligOffset);
+      const ligatureGlyph = reader.u16();
+      const componentCount = reader.u16();
+      const components = new Array(Math.max(0, componentCount - 1));
+      for (let i = 0; i < components.length; i += 1) {
+        components[i] = reader.u16();
+      }
+      return { ligatureGlyph, components };
+    });
+  });
+  const coverage = parseCoverage(reader, coverageOffset);
+  return {
+    apply(glyphs, pos) {
+      const first = glyphs[pos];
+      if (!first) return null;
+      const setIndex = coverage(first.id);
+      if (setIndex < 0 || setIndex >= ligatureSets.length) return null;
+      for (const ligature of ligatureSets[setIndex]) {
+        const { components } = ligature;
+        if (pos + components.length > glyphs.length - 1) continue;
+        let matched = true;
+        for (let i = 0; i < components.length; i += 1) {
+          if (glyphs[pos + 1 + i].id !== components[i]) {
+            matched = false;
+            break;
+          }
+        }
+        if (!matched) continue;
+        const total = components.length + 1;
+        const mergedCodePoints = [];
+        for (let i = 0; i < total; i += 1) {
+          mergedCodePoints.push(...glyphs[pos + i].codePoints);
+        }
+        glyphs.splice(pos, total, {
+          id: ligature.ligatureGlyph,
+          codePoints: mergedCodePoints
+        });
+        return 1;
+      }
+      return null;
+    }
+  };
+}
+function readSubstLookupRecords(reader, count) {
+  const records = new Array(count);
+  for (let i = 0; i < count; i += 1) {
+    const sequenceIndex = reader.u16();
+    const lookupListIndex = reader.u16();
+    records[i] = { sequenceIndex, lookupListIndex };
+  }
+  return records;
+}
+function applySubstRecords(glyphs, pos, records, engine) {
+  for (const record of records) {
+    engine.applyLookupIndexAt(
+      record.lookupListIndex,
+      glyphs,
+      pos + record.sequenceIndex
+    );
+  }
+}
+function parseChainContextSubst(reader, offset) {
+  reader.seek(offset);
+  const format = reader.u16();
+  if (format === 3) {
+    const backtrackCount = reader.u16();
+    const backtrackCoverageOffsets = new Array(backtrackCount);
+    for (let i = 0; i < backtrackCount; i += 1) {
+      backtrackCoverageOffsets[i] = offset + reader.u16();
+    }
+    const inputCount = reader.u16();
+    const inputCoverageOffsets = new Array(inputCount);
+    for (let i = 0; i < inputCount; i += 1) {
+      inputCoverageOffsets[i] = offset + reader.u16();
+    }
+    const lookaheadCount = reader.u16();
+    const lookaheadCoverageOffsets = new Array(lookaheadCount);
+    for (let i = 0; i < lookaheadCount; i += 1) {
+      lookaheadCoverageOffsets[i] = offset + reader.u16();
+    }
+    const substCount = reader.u16();
+    const records = readSubstLookupRecords(reader, substCount);
+    const backtrack = backtrackCoverageOffsets.map(
+      (o) => parseCoverage(reader, o)
+    );
+    const input = inputCoverageOffsets.map((o) => parseCoverage(reader, o));
+    const lookahead = lookaheadCoverageOffsets.map(
+      (o) => parseCoverage(reader, o)
+    );
+    return {
+      apply(glyphs, pos, engine) {
+        if (input.length === 0) return null;
+        if (pos + input.length > glyphs.length) return null;
+        for (let i = 0; i < input.length; i += 1) {
+          if (input[i](glyphs[pos + i].id) < 0) return null;
+        }
+        for (let i = 0; i < backtrack.length; i += 1) {
+          const g = glyphs[pos - 1 - i];
+          if (!g || backtrack[i](g.id) < 0) return null;
+        }
+        for (let i = 0; i < lookahead.length; i += 1) {
+          const g = glyphs[pos + input.length + i];
+          if (!g || lookahead[i](g.id) < 0) return null;
+        }
+        applySubstRecords(glyphs, pos, records, engine);
+        return input.length;
+      }
+    };
+  }
+  if (format === 1) {
+    const coverageOffset = offset + reader.u16();
+    const ruleSetCount = reader.u16();
+    const ruleSetOffsets = new Array(ruleSetCount);
+    for (let i = 0; i < ruleSetCount; i += 1) {
+      ruleSetOffsets[i] = offset + reader.u16();
+    }
+    const coverage = parseCoverage(reader, coverageOffset);
+    const ruleSets = ruleSetOffsets.map(
+      (setOffset) => parseChainRuleSet(reader, setOffset)
+    );
+    return {
+      apply(glyphs, pos, engine) {
+        const glyph = glyphs[pos];
+        if (!glyph) return null;
+        const index = coverage(glyph.id);
+        if (index < 0 || index >= ruleSets.length) return null;
+        return applyChainRules(ruleSets[index], glyphs, pos, engine, null);
+      }
+    };
+  }
+  if (format === 2) {
+    const coverageOffset = offset + reader.u16();
+    const backtrackClassOffset = offset + reader.u16();
+    const inputClassOffset = offset + reader.u16();
+    const lookaheadClassOffset = offset + reader.u16();
+    const classSetCount = reader.u16();
+    const classSetOffsets = new Array(classSetCount);
+    for (let i = 0; i < classSetCount; i += 1) {
+      const raw = reader.u16();
+      classSetOffsets[i] = raw === 0 ? 0 : offset + raw;
+    }
+    const coverage = parseCoverage(reader, coverageOffset);
+    const backtrackClass = parseClassDef(reader, backtrackClassOffset);
+    const inputClass = parseClassDef(reader, inputClassOffset);
+    const lookaheadClass = parseClassDef(reader, lookaheadClassOffset);
+    const classSets = classSetOffsets.map(
+      (setOffset) => setOffset === 0 ? [] : parseChainRuleSet(reader, setOffset)
+    );
+    return {
+      apply(glyphs, pos, engine) {
+        const glyph = glyphs[pos];
+        if (!glyph) return null;
+        if (coverage(glyph.id) < 0) return null;
+        const classIndex = inputClass(glyph.id);
+        const ruleSet = classSets[classIndex];
+        if (!ruleSet) return null;
+        return applyChainRules(ruleSet, glyphs, pos, engine, {
+          backtrack: backtrackClass,
+          input: inputClass,
+          lookahead: lookaheadClass
+        });
+      }
+    };
+  }
+  return null;
+}
+function parseChainRuleSet(reader, setOffset) {
+  reader.seek(setOffset);
+  const ruleCount = reader.u16();
+  const ruleOffsets = new Array(ruleCount);
+  for (let i = 0; i < ruleCount; i += 1) {
+    ruleOffsets[i] = setOffset + reader.u16();
+  }
+  return ruleOffsets.map((ruleOffset) => {
+    reader.seek(ruleOffset);
+    const backtrackCount = reader.u16();
+    const backtrack = new Array(backtrackCount);
+    for (let i = 0; i < backtrackCount; i += 1) backtrack[i] = reader.u16();
+    const inputCount = reader.u16();
+    const input = new Array(Math.max(0, inputCount - 1));
+    for (let i = 0; i < input.length; i += 1) input[i] = reader.u16();
+    const lookaheadCount = reader.u16();
+    const lookahead = new Array(lookaheadCount);
+    for (let i = 0; i < lookaheadCount; i += 1) lookahead[i] = reader.u16();
+    const substCount = reader.u16();
+    const records = readSubstLookupRecords(reader, substCount);
+    return { backtrack, input, lookahead, records };
+  });
+}
+function applyChainRules(rules, glyphs, pos, engine, resolver) {
+  const valueAt = (index, kind) => {
+    const g = glyphs[index];
+    if (!g) return null;
+    if (!resolver) return g.id;
+    if (kind === "b") return resolver.backtrack(g.id);
+    if (kind === "l") return resolver.lookahead(g.id);
+    return resolver.input(g.id);
+  };
+  for (const rule of rules) {
+    const inputLen = rule.input.length + 1;
+    if (pos + inputLen > glyphs.length) continue;
+    let matched = true;
+    for (let i = 0; i < rule.input.length; i += 1) {
+      if (valueAt(pos + 1 + i, "i") !== rule.input[i]) {
+        matched = false;
+        break;
+      }
+    }
+    if (!matched) continue;
+    for (let i = 0; i < rule.backtrack.length; i += 1) {
+      if (valueAt(pos - 1 - i, "b") !== rule.backtrack[i]) {
+        matched = false;
+        break;
+      }
+    }
+    if (!matched) continue;
+    for (let i = 0; i < rule.lookahead.length; i += 1) {
+      if (valueAt(pos + inputLen + i, "l") !== rule.lookahead[i]) {
+        matched = false;
+        break;
+      }
+    }
+    if (!matched) continue;
+    applySubstRecords(glyphs, pos, rule.records, engine);
+    return inputLen;
+  }
+  return null;
+}
+function parseSubtable$1(reader, offset, lookupType) {
+  switch (lookupType) {
+    case 1:
+      return parseSingleSubst(reader, offset);
+    case 2:
+      return parseMultipleSubst(reader, offset);
+    case 3:
+      return parseAlternateSubst(reader, offset);
+    case 4:
+      return parseLigatureSubst(reader, offset);
+    case 6:
+      return parseChainContextSubst(reader, offset);
+    case 7: {
+      reader.seek(offset);
+      const format = reader.u16();
+      if (format !== 1) return null;
+      const extensionType = reader.u16();
+      const extensionOffset = offset + reader.u32();
+      return parseSubtable$1(reader, extensionOffset, extensionType);
+    }
+    default:
+      return null;
+  }
+}
+class GsubTable {
+  constructor(lookups, featureToLookups) {
+    this.lookups = lookups;
+    this.featureToLookups = featureToLookups;
+  }
+  /** Parses GSUB bytes (table-relative). Returns null on any structural failure. */
+  static parse(bytes) {
+    try {
+      const reader = new BinaryReader(bytes);
+      const { featureToLookups, lookupListOffset } = parseLayoutTableHeader(reader);
+      const lookups = parseLookupList$1(reader, lookupListOffset);
+      return new GsubTable(lookups, featureToLookups);
+    } catch {
+      return null;
+    }
+  }
+  /** True when at least one of the requested feature tags exists in this font. */
+  hasAnyFeature(tags) {
+    return tags.some((tag) => this.featureToLookups.has(tag));
+  }
+  /** Ordered (ascending) unique lookup indices referenced by the given tags. */
+  collectLookupIndices(tags) {
+    return collectLookupIndices(this.featureToLookups, tags);
+  }
+  /**
+   * Applies one lookup (by index) at a single position. Tries each subtable in
+   * order; the first that matches wins. Returns the advance (output glyph count)
+   * or null when nothing matched. Used both by the shaping walk and by nested
+   * chaining-contextual substitution records.
+   */
+  applyLookupIndexAt(lookupIndex, glyphs, pos) {
+    const lookup = this.lookups[lookupIndex];
+    if (!lookup || pos < 0 || pos >= glyphs.length) return null;
+    for (const subtable of lookup.subtables) {
+      const advance = subtable.apply(glyphs, pos, this);
+      if (advance !== null) return advance;
+    }
+    return null;
+  }
+  /** Applies the lookups for the given features across the whole buffer. */
+  shape(glyphs, tags) {
+    const lookupIndices = this.collectLookupIndices(tags);
+    for (const lookupIndex of lookupIndices) {
+      let pos = 0;
+      while (pos < glyphs.length) {
+        const advance = this.applyLookupIndexAt(lookupIndex, glyphs, pos);
+        pos += advance && advance > 0 ? advance : 1;
+      }
+    }
+  }
+}
+function parseLookupList$1(reader, lookupListOffset) {
+  reader.seek(lookupListOffset);
+  const lookupCount = reader.u16();
+  const lookupOffsets = new Array(lookupCount);
+  for (let i = 0; i < lookupCount; i += 1) {
+    lookupOffsets[i] = lookupListOffset + reader.u16();
+  }
+  return lookupOffsets.map((lookupOffset) => {
+    reader.seek(lookupOffset);
+    const lookupType = reader.u16();
+    reader.skip(2);
+    const subTableCount = reader.u16();
+    const subtableOffsets = new Array(subTableCount);
+    for (let i = 0; i < subTableCount; i += 1) {
+      subtableOffsets[i] = lookupOffset + reader.u16();
+    }
+    const subtables = [];
+    for (const subtableOffset of subtableOffsets) {
+      try {
+        const subtable = parseSubtable$1(reader, subtableOffset, lookupType);
+        if (subtable) subtables.push(subtable);
+      } catch {
+      }
+    }
+    return { lookupType, subtables };
+  });
+}
+const X_PLACEMENT = 1;
+const Y_PLACEMENT = 2;
+const X_ADVANCE = 4;
+const Y_ADVANCE = 8;
+const X_PLACEMENT_DEVICE = 16;
+const Y_PLACEMENT_DEVICE = 32;
+const X_ADVANCE_DEVICE = 64;
+const Y_ADVANCE_DEVICE = 128;
+function readValueRecordXAdvance(reader, valueFormat) {
+  let xAdvance = 0;
+  if (valueFormat & X_PLACEMENT) reader.i16();
+  if (valueFormat & Y_PLACEMENT) reader.i16();
+  if (valueFormat & X_ADVANCE) xAdvance = reader.i16();
+  if (valueFormat & Y_ADVANCE) reader.i16();
+  if (valueFormat & X_PLACEMENT_DEVICE) reader.u16();
+  if (valueFormat & Y_PLACEMENT_DEVICE) reader.u16();
+  if (valueFormat & X_ADVANCE_DEVICE) reader.u16();
+  if (valueFormat & Y_ADVANCE_DEVICE) reader.u16();
+  return xAdvance;
+}
+function valueRecordSize(valueFormat) {
+  let count = 0;
+  for (let bit = 0; bit < 8; bit += 1) {
+    if (valueFormat & 1 << bit) count += 1;
+  }
+  return count * 2;
+}
+function parseSinglePos(reader, offset) {
+  reader.seek(offset);
+  const format = reader.u16();
+  const coverageOffset = offset + reader.u16();
+  if (format === 1) {
+    const valueFormat = reader.u16();
+    const xAdvance = readValueRecordXAdvance(reader, valueFormat);
+    const coverage = parseCoverage(reader, coverageOffset);
+    if (xAdvance === 0) return null;
+    return {
+      apply(glyphIds, advances, pos) {
+        if (coverage(glyphIds[pos]) < 0) return null;
+        advances[pos] += xAdvance;
+        return 1;
+      }
+    };
+  }
+  if (format === 2) {
+    const valueFormat = reader.u16();
+    const valueCount = reader.u16();
+    const recordSize = valueRecordSize(valueFormat);
+    const recordsStart = reader.tell();
+    const xAdvances = new Array(valueCount);
+    for (let i = 0; i < valueCount; i += 1) {
+      reader.seek(recordsStart + i * recordSize);
+      xAdvances[i] = readValueRecordXAdvance(reader, valueFormat);
+    }
+    const coverage = parseCoverage(reader, coverageOffset);
+    return {
+      apply(glyphIds, advances, pos) {
+        const index = coverage(glyphIds[pos]);
+        if (index < 0 || index >= valueCount) return null;
+        const delta = xAdvances[index];
+        if (delta === 0) return null;
+        advances[pos] += delta;
+        return 1;
+      }
+    };
+  }
+  return null;
+}
+function parsePairPos(reader, offset) {
+  reader.seek(offset);
+  const format = reader.u16();
+  const coverageOffset = offset + reader.u16();
+  const valueFormat1 = reader.u16();
+  const valueFormat2 = reader.u16();
+  const hasSecondAdjustment = (valueFormat2 & X_ADVANCE) !== 0;
+  if (format === 1) {
+    const pairSetCount = reader.u16();
+    const pairSetOffsets = new Array(pairSetCount);
+    for (let i = 0; i < pairSetCount; i += 1) {
+      pairSetOffsets[i] = offset + reader.u16();
+    }
+    const pairSets = pairSetOffsets.map(
+      (setOffset) => {
+        reader.seek(setOffset);
+        const pairValueCount = reader.u16();
+        const pairs = /* @__PURE__ */ new Map();
+        for (let i = 0; i < pairValueCount; i += 1) {
+          const secondGlyph = reader.u16();
+          const value1XAdvance = readValueRecordXAdvance(reader, valueFormat1);
+          const value2XAdvance = readValueRecordXAdvance(reader, valueFormat2);
+          pairs.set(secondGlyph, {
+            secondGlyph,
+            value1XAdvance,
+            value2XAdvance
+          });
+        }
+        return pairs;
+      }
+    );
+    const coverage = parseCoverage(reader, coverageOffset);
+    return {
+      apply(glyphIds, advances, pos) {
+        const second = glyphIds[pos + 1];
+        if (second === void 0) return null;
+        const setIndex = coverage(glyphIds[pos]);
+        if (setIndex < 0 || setIndex >= pairSets.length) return null;
+        const pair = pairSets[setIndex].get(second);
+        if (!pair) return null;
+        advances[pos] += pair.value1XAdvance;
+        advances[pos + 1] += pair.value2XAdvance;
+        return hasSecondAdjustment ? 2 : 1;
+      }
+    };
+  }
+  if (format === 2) {
+    const classDef1Offset = offset + reader.u16();
+    const classDef2Offset = offset + reader.u16();
+    const class1Count = reader.u16();
+    const class2Count = reader.u16();
+    const value1Size = valueRecordSize(valueFormat1);
+    const value2Size = valueRecordSize(valueFormat2);
+    const cellSize = value1Size + value2Size;
+    const matrixStart = reader.tell();
+    const value1 = new Array(class1Count * class2Count);
+    const value2 = new Array(class1Count * class2Count);
+    for (let c1 = 0; c1 < class1Count; c1 += 1) {
+      for (let c2 = 0; c2 < class2Count; c2 += 1) {
+        const cell = (c1 * class2Count + c2) * cellSize;
+        reader.seek(matrixStart + cell);
+        value1[c1 * class2Count + c2] = readValueRecordXAdvance(
+          reader,
+          valueFormat1
+        );
+        reader.seek(matrixStart + cell + value1Size);
+        value2[c1 * class2Count + c2] = readValueRecordXAdvance(
+          reader,
+          valueFormat2
+        );
+      }
+    }
+    const coverage = parseCoverage(reader, coverageOffset);
+    const classDef1 = parseClassDef(reader, classDef1Offset);
+    const classDef2 = parseClassDef(reader, classDef2Offset);
+    return {
+      apply(glyphIds, advances, pos) {
+        const first = glyphIds[pos];
+        const second = glyphIds[pos + 1];
+        if (second === void 0) return null;
+        if (coverage(first) < 0) return null;
+        const c1 = classDef1(first);
+        const c2 = classDef2(second);
+        if (c1 >= class1Count || c2 >= class2Count) return null;
+        const cellIndex = c1 * class2Count + c2;
+        const v1 = value1[cellIndex];
+        const v2 = value2[cellIndex];
+        if (v1 === 0 && v2 === 0) return null;
+        advances[pos] += v1;
+        advances[pos + 1] += v2;
+        return hasSecondAdjustment ? 2 : 1;
+      }
+    };
+  }
+  return null;
+}
+function parseSubtable(reader, offset, lookupType) {
+  switch (lookupType) {
+    case 1:
+      return parseSinglePos(reader, offset);
+    case 2:
+      return parsePairPos(reader, offset);
+    case 9: {
+      reader.seek(offset);
+      const format = reader.u16();
+      if (format !== 1) return null;
+      const extensionType = reader.u16();
+      const extensionOffset = offset + reader.u32();
+      return parseSubtable(reader, extensionOffset, extensionType);
+    }
+    default:
+      return null;
+  }
+}
+function parseLookupList(reader, lookupListOffset) {
+  reader.seek(lookupListOffset);
+  const lookupCount = reader.u16();
+  const lookupOffsets = new Array(lookupCount);
+  for (let i = 0; i < lookupCount; i += 1) {
+    lookupOffsets[i] = lookupListOffset + reader.u16();
+  }
+  return lookupOffsets.map((lookupOffset) => {
+    reader.seek(lookupOffset);
+    const lookupType = reader.u16();
+    reader.skip(2);
+    const subTableCount = reader.u16();
+    const subtableOffsets = new Array(subTableCount);
+    for (let i = 0; i < subTableCount; i += 1) {
+      subtableOffsets[i] = lookupOffset + reader.u16();
+    }
+    const subtables = [];
+    for (const subtableOffset of subtableOffsets) {
+      try {
+        const subtable = parseSubtable(reader, subtableOffset, lookupType);
+        if (subtable) subtables.push(subtable);
+      } catch {
+      }
+    }
+    return { lookupType, subtables };
+  });
+}
+class GposTable {
+  constructor(lookups, featureToLookups) {
+    this.lookups = lookups;
+    this.featureToLookups = featureToLookups;
+  }
+  /** Parses GPOS bytes (table-relative). Returns null on any structural failure. */
+  static parse(bytes) {
+    try {
+      const reader = new BinaryReader(bytes);
+      const { featureToLookups, lookupListOffset } = parseLayoutTableHeader(reader);
+      const lookups = parseLookupList(reader, lookupListOffset);
+      return new GposTable(lookups, featureToLookups);
+    } catch {
+      return null;
+    }
+  }
+  /** True when at least one of the requested feature tags exists in this font. */
+  hasAnyFeature(tags) {
+    return tags.some((tag) => this.featureToLookups.has(tag));
+  }
+  /**
+   * Applies the positioning lookups for the given features across `advances`
+   * (font design units), mutating it in place. `glyphIds[i]` is the glyph at
+   * advance slot `i`; the arrays are parallel and equal length.
+   */
+  position(glyphIds, advances, tags) {
+    const lookupIndices = collectLookupIndices(this.featureToLookups, tags);
+    for (const lookupIndex of lookupIndices) {
+      const lookup = this.lookups[lookupIndex];
+      if (!lookup) continue;
+      let pos = 0;
+      while (pos < glyphIds.length) {
+        let advance = null;
+        for (const subtable of lookup.subtables) {
+          advance = subtable.apply(glyphIds, advances, pos);
+          if (advance !== null) break;
+        }
+        pos += advance && advance > 0 ? advance : 1;
+      }
+    }
+  }
+}
+const GPOS_FEATURE_TAGS = /* @__PURE__ */ new Set(["kern"]);
+class OpenTypeLayouter {
+  constructor(font) {
+    __publicField(this, "gsub");
+    __publicField(this, "gpos");
+    this.font = font;
+    const gsubRaw = font.getRawTableData("GSUB");
+    this.gsub = gsubRaw ? GsubTable.parse(gsubRaw) : null;
+    const gposRaw = font.getRawTableData("GPOS");
+    this.gpos = gposRaw ? GposTable.parse(gposRaw) : null;
+  }
+  /** True when the font exposes a GSUB table the substitution shaper could use. */
+  get hasGsub() {
+    return this.gsub !== null;
+  }
+  /** True when the font exposes a GPOS table the kerning shaper could use. */
+  get hasGpos() {
+    return this.gpos !== null;
+  }
+  /** True when either shaping table is present (so this layouter adds value). */
+  get hasShaping() {
+    return this.gsub !== null || this.gpos !== null;
+  }
+  layout(text, features) {
+    const buffer = [];
+    for (const char of text) {
+      const codePoint = char.codePointAt(0) ?? 65533;
+      const glyphId = this.font.glyphForCodePoint(codePoint);
+      buffer.push({
+        id: glyphId,
+        codePoints: glyphId === 0 ? [65533] : [codePoint]
+      });
+    }
+    const gsubTags = (features == null ? void 0 : features.filter((tag) => !GPOS_FEATURE_TAGS.has(tag))) ?? [];
+    const gposTags = (features == null ? void 0 : features.filter((tag) => GPOS_FEATURE_TAGS.has(tag))) ?? [];
+    if (this.gsub && gsubTags.length > 0) {
+      this.gsub.shape(buffer, gsubTags);
+    }
+    const advances = buffer.map(
+      (glyph) => this.font.advanceWidthForGlyph(glyph.id)
+    );
+    if (this.gpos && gposTags.length > 0) {
+      this.gpos.position(
+        buffer.map((glyph) => glyph.id),
+        advances,
+        gposTags
+      );
+    }
+    const glyphs = [];
+    const positions = [];
+    let advanceWidth = 0;
+    for (let i = 0; i < buffer.length; i += 1) {
+      const glyph = buffer[i];
+      const nominalAdvance = this.font.advanceWidthForGlyph(glyph.id);
+      const positionedAdvance = advances[i];
+      glyphs.push({
+        id: glyph.id,
+        codePoints: glyph.codePoints,
+        advanceWidth: nominalAdvance
+      });
+      positions.push({ xAdvance: positionedAdvance });
+      advanceWidth += positionedAdvance;
+    }
+    return { glyphs, positions, advanceWidth };
+  }
+}
 class SimpleTextLayouter {
   constructor(font) {
     this.font = font;
@@ -38041,9 +39004,11 @@ function parseEmbeddedFontSync(sourceBytes) {
   return SfntFontProgram.parse(sfntBytes);
 }
 function createPdfEmbeddableFont(program) {
+  const shaper = new OpenTypeLayouter(program);
+  const layouter = shaper.hasShaping ? shaper : new SimpleTextLayouter(program);
   return {
     program,
-    layouter: new SimpleTextLayouter(program),
+    layouter,
     subsetter: new TrueTypePdfFontSubsetter()
   };
 }
@@ -38091,8 +39056,8 @@ class PdfFontTable {
    * Unicode run, recording the glyphs used for subsetting. Returns `null` when
    * the run produced no glyphs so the caller can skip emission entirely.
    */
-  buildUnicodeShowCommand(state, text) {
-    const run = this.layoutUnicodeText(state, text);
+  buildUnicodeShowCommand(state, text, features) {
+    const run = this.layoutUnicodeText(state, text, features);
     const encoded = this.encodeUnicodeGlyphRun(state, run);
     if (encoded.length === 0) {
       return null;
@@ -38126,13 +39091,14 @@ class PdfFontTable {
     const resourceXml = fontResourceEntries.map((font, index) => `/${font.resourceName} ${fontObjectIds[index]} 0 R`).join(" ");
     return { resourceXml };
   }
-  layoutUnicodeText(state, text) {
-    const cached = state.layoutCache.get(text);
+  layoutUnicodeText(state, text, features) {
+    const cacheKey = `${(features == null ? void 0 : features.join(",")) ?? ""}\0${text}`;
+    const cached = state.layoutCache.get(cacheKey);
     if (cached) {
       return cached;
     }
-    const run = state.font.layouter.layout(text);
-    state.layoutCache.set(text, run);
+    const run = state.font.layouter.layout(text, features);
+    state.layoutCache.set(cacheKey, run);
     return run;
   }
   encodeUnicodeGlyphRun(state, run) {