@mentra/sdk 2.1.28 → 2.1.29-beta.2

package/dist/display-utils.js

@@ -0,0 +1,1197 @@
+import { createRequire } from "node:module";
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/display-utils/profiles/g1.ts
+var G1_GLYPH_WIDTHS = {
+  " ": 2,
+  "!": 1,
+  '"': 2,
+  "#": 6,
+  $: 5,
+  "%": 6,
+  "&": 7,
+  "'": 1,
+  "(": 2,
+  ")": 2,
+  "*": 3,
+  "+": 4,
+  ",": 1,
+  "-": 4,
+  ".": 1,
+  "/": 3,
+  "0": 5,
+  "1": 3,
+  "2": 5,
+  "3": 5,
+  "4": 5,
+  "5": 5,
+  "6": 5,
+  "7": 5,
+  "8": 5,
+  "9": 5,
+  ":": 1,
+  ";": 1,
+  "<": 4,
+  "=": 4,
+  ">": 4,
+  "?": 5,
+  "@": 7,
+  A: 6,
+  B: 5,
+  C: 5,
+  D: 5,
+  E: 4,
+  F: 4,
+  G: 5,
+  H: 5,
+  I: 2,
+  J: 3,
+  K: 5,
+  L: 4,
+  M: 7,
+  N: 5,
+  O: 5,
+  P: 5,
+  Q: 5,
+  R: 5,
+  S: 5,
+  T: 5,
+  U: 5,
+  V: 6,
+  W: 7,
+  X: 6,
+  Y: 6,
+  Z: 5,
+  "[": 2,
+  "\\": 3,
+  "]": 2,
+  "^": 4,
+  _: 3,
+  "`": 2,
+  a: 5,
+  b: 4,
+  c: 4,
+  d: 4,
+  e: 4,
+  f: 4,
+  g: 4,
+  h: 4,
+  i: 1,
+  j: 2,
+  k: 4,
+  l: 1,
+  m: 7,
+  n: 4,
+  o: 4,
+  p: 4,
+  q: 4,
+  r: 3,
+  s: 4,
+  t: 3,
+  u: 5,
+  v: 5,
+  w: 7,
+  x: 5,
+  y: 5,
+  z: 4,
+  "{": 3,
+  "|": 1,
+  "}": 3,
+  "~": 7
+};
+var G1_PROFILE = {
+  id: "even-realities-g1",
+  name: "Even Realities G1",
+  displayWidthPx: 576,
+  maxLines: 5,
+  maxPayloadBytes: 390,
+  bleChunkSize: 176,
+  fontMetrics: {
+    glyphWidths: new Map(Object.entries(G1_GLYPH_WIDTHS)),
+    defaultGlyphWidth: 7,
+    renderFormula: (glyphWidth) => (glyphWidth + 1) * 2,
+    uniformScripts: {
+      cjk: 18,
+      hiragana: 18,
+      katakana: 18,
+      korean: 24,
+      cyrillic: 18
+    },
+    fallback: {
+      latinMaxWidth: 16,
+      unknownBehavior: "useLatinMax"
+    }
+  },
+  constraints: {
+    minCharsBeforeHyphen: 3,
+    noStartChars: [".", ",", "!", "?", ":", ";", ")", "]", "}", "。", "，", "！", "？", "：", "；", "）", "】", "」"],
+    noEndChars: ["(", "[", "{", "（", "【", "「"]
+  }
+};
+var G1_PROFILE_LEGACY = {
+  id: "even-realities-g1-legacy",
+  name: "Even Realities G1 (Legacy Client Compatibility)",
+  displayWidthPx: 420,
+  maxLines: 5,
+  maxPayloadBytes: 390,
+  bleChunkSize: 176,
+  fontMetrics: {
+    glyphWidths: new Map(Object.entries(G1_GLYPH_WIDTHS)),
+    defaultGlyphWidth: 7,
+    renderFormula: (glyphWidth) => (glyphWidth + 1) * 2,
+    uniformScripts: {
+      cjk: 18,
+      hiragana: 18,
+      katakana: 18,
+      korean: 24,
+      cyrillic: 18
+    },
+    fallback: {
+      latinMaxWidth: 16,
+      unknownBehavior: "useLatinMax"
+    }
+  },
+  constraints: {
+    minCharsBeforeHyphen: 3,
+    noStartChars: [".", ",", "!", "?", ":", ";", ")", "]", "}", "。", "，", "！", "？", "：", "；", "）", "】", "」"],
+    noEndChars: ["(", "[", "{", "（", "【", "「"]
+  }
+};
+var G1_HYPHEN_WIDTH_PX = 10;
+var G1_SPACE_WIDTH_PX = 6;
+// src/display-utils/measurer/script-detection.ts
+var SCRIPT_RANGES = {
+  cjk: [
+    [19968, 40959],
+    [13312, 19903],
+    [131072, 173791],
+    [173824, 177983],
+    [177984, 178207],
+    [63744, 64255]
+  ],
+  hiragana: [[12352, 12447]],
+  katakana: [
+    [12448, 12543],
+    [12784, 12799]
+  ],
+  korean: [
+    [44032, 55215],
+    [4352, 4607],
+    [12592, 12687],
+    [43360, 43391],
+    [55216, 55295]
+  ],
+  cyrillic: [
+    [1024, 1279],
+    [1280, 1327]
+  ],
+  numbers: [[48, 57]],
+  punctuation: [
+    [32, 47],
+    [58, 64],
+    [91, 96],
+    [123, 126]
+  ],
+  arabic: [[1536, 1791]],
+  hebrew: [[1424, 1535]],
+  thai: [[3584, 3711]],
+  emoji: [
+    [128512, 128591],
+    [127744, 128511],
+    [128640, 128767],
+    [127456, 127487],
+    [9728, 9983],
+    [9984, 10175],
+    [65024, 65039],
+    [129280, 129535]
+  ]
+};
+function inRanges(codePoint, ranges) {
+  for (const [start, end] of ranges) {
+    if (codePoint >= start && codePoint <= end) {
+      return true;
+    }
+  }
+  return false;
+}
+function detectScript(char) {
+  if (!char || char.length === 0) {
+    return "latin";
+  }
+  const codePoint = char.codePointAt(0);
+  if (codePoint === undefined) {
+    return "latin";
+  }
+  if (inRanges(codePoint, SCRIPT_RANGES.cjk)) {
+    return "cjk";
+  }
+  if (inRanges(codePoint, SCRIPT_RANGES.hiragana)) {
+    return "hiragana";
+  }
+  if (inRanges(codePoint, SCRIPT_RANGES.katakana)) {
+    return "katakana";
+  }
+  if (inRanges(codePoint, SCRIPT_RANGES.korean)) {
+    return "korean";
+  }
+  if (inRanges(codePoint, SCRIPT_RANGES.cyrillic)) {
+    return "cyrillic";
+  }
+  if (inRanges(codePoint, SCRIPT_RANGES.numbers)) {
+    return "numbers";
+  }
+  if (inRanges(codePoint, SCRIPT_RANGES.punctuation)) {
+    return "punctuation";
+  }
+  if (inRanges(codePoint, SCRIPT_RANGES.arabic) || inRanges(codePoint, SCRIPT_RANGES.hebrew) || inRanges(codePoint, SCRIPT_RANGES.thai) || inRanges(codePoint, SCRIPT_RANGES.emoji)) {
+    return "unsupported";
+  }
+  return "latin";
+}
+function isCJKCharacter(char) {
+  const script = detectScript(char);
+  return script === "cjk" || script === "hiragana" || script === "katakana";
+}
+function isKoreanCharacter(char) {
+  return detectScript(char) === "korean";
+}
+function isUniformWidthScript(char) {
+  const script = detectScript(char);
+  return script === "cjk" || script === "hiragana" || script === "katakana" || script === "korean" || script === "cyrillic";
+}
+function isUnsupportedScript(char) {
+  return detectScript(char) === "unsupported";
+}
+function needsHyphenForBreak(charBefore, charAfter) {
+  if (isCJKCharacter(charBefore)) {
+    return false;
+  }
+  if (isCJKCharacter(charAfter)) {
+    return false;
+  }
+  if (charBefore === " " || charBefore === "\t") {
+    return false;
+  }
+  if (charAfter === " " || charAfter === "\t") {
+    return false;
+  }
+  const breakPunctuation = ["-", "–", "—", "/", "\\", "|"];
+  if (breakPunctuation.includes(charBefore)) {
+    return false;
+  }
+  return true;
+}
+
+// src/display-utils/measurer/TextMeasurer.ts
+class TextMeasurer {
+  profile;
+  charCache = new Map;
+  constructor(profile) {
+    this.profile = profile;
+    this.buildCharCache();
+  }
+  buildCharCache() {
+    const { glyphWidths, renderFormula } = this.profile.fontMetrics;
+    for (const [char, glyphWidth] of glyphWidths.entries()) {
+      const renderedWidth = renderFormula(glyphWidth);
+      this.charCache.set(char, renderedWidth);
+    }
+  }
+  measureText(text) {
+    if (!text || text.length === 0) {
+      return 0;
+    }
+    let totalWidth = 0;
+    for (const char of text) {
+      totalWidth += this.measureChar(char);
+    }
+    return totalWidth;
+  }
+  measureTextDetailed(text) {
+    if (!text || text.length === 0) {
+      return {
+        text: "",
+        totalWidthPx: 0,
+        charCount: 0,
+        chars: []
+      };
+    }
+    const chars = [];
+    let totalWidth = 0;
+    for (const char of text) {
+      const script = detectScript(char);
+      const widthPx = this.measureChar(char);
+      const fromGlyphMap = this.profile.fontMetrics.glyphWidths.has(char);
+      chars.push({
+        char,
+        widthPx,
+        script,
+        fromGlyphMap
+      });
+      totalWidth += widthPx;
+    }
+    return {
+      text,
+      totalWidthPx: totalWidth,
+      charCount: chars.length,
+      chars
+    };
+  }
+  measureChar(char) {
+    if (!char || char.length === 0) {
+      return 0;
+    }
+    const cached = this.charCache.get(char);
+    if (cached !== undefined) {
+      return cached;
+    }
+    const width = this.calculateCharWidth(char);
+    this.charCache.set(char, width);
+    return width;
+  }
+  calculateCharWidth(char) {
+    const { fontMetrics } = this.profile;
+    const { uniformScripts, fallback, renderFormula, glyphWidths } = fontMetrics;
+    const glyphWidth = glyphWidths.get(char);
+    if (glyphWidth !== undefined) {
+      return renderFormula(glyphWidth);
+    }
+    const script = detectScript(char);
+    switch (script) {
+      case "cjk":
+        return uniformScripts.cjk;
+      case "hiragana":
+        return uniformScripts.hiragana;
+      case "katakana":
+        return uniformScripts.katakana;
+      case "korean":
+        return uniformScripts.korean;
+      case "cyrillic":
+        return uniformScripts.cyrillic;
+    }
+    return fallback.latinMaxWidth;
+  }
+  getGlyphWidth(char) {
+    return this.profile.fontMetrics.glyphWidths.get(char);
+  }
+  fitsInWidth(text, maxWidthPx) {
+    return this.measureText(text) <= maxWidthPx;
+  }
+  charsThatFit(text, maxWidthPx, startIndex = 0) {
+    if (!text || startIndex >= text.length) {
+      return 0;
+    }
+    let currentWidth = 0;
+    let count = 0;
+    const chars = Array.from(text).slice(startIndex);
+    for (const char of chars) {
+      const charWidth = this.measureChar(char);
+      if (currentWidth + charWidth > maxWidthPx) {
+        break;
+      }
+      currentWidth += charWidth;
+      count++;
+    }
+    return count;
+  }
+  getPixelOffset(text, index) {
+    if (!text || index <= 0) {
+      return 0;
+    }
+    const chars = Array.from(text).slice(0, index);
+    let offset = 0;
+    for (const char of chars) {
+      offset += this.measureChar(char);
+    }
+    return offset;
+  }
+  detectScript(char) {
+    return detectScript(char);
+  }
+  isUniformWidth(char) {
+    return isUniformWidthScript(char);
+  }
+  getProfile() {
+    return this.profile;
+  }
+  getDisplayWidthPx() {
+    return this.profile.displayWidthPx;
+  }
+  getMaxLines() {
+    return this.profile.maxLines;
+  }
+  getMaxPayloadBytes() {
+    return this.profile.maxPayloadBytes;
+  }
+  getByteSize(text) {
+    return new TextEncoder().encode(text).length;
+  }
+  getHyphenWidth() {
+    return this.measureChar("-");
+  }
+  getSpaceWidth() {
+    return this.measureChar(" ");
+  }
+  clearCache() {
+    this.charCache.clear();
+    this.buildCharCache();
+  }
+}
+// src/display-utils/wrapper/types.ts
+var DEFAULT_WRAP_OPTIONS = {
+  breakMode: "character",
+  hyphenChar: "-",
+  minCharsBeforeHyphen: 3,
+  trimLines: true,
+  preserveNewlines: true
+};
+
+// src/display-utils/wrapper/TextWrapper.ts
+class TextWrapper {
+  measurer;
+  defaultOptions;
+  constructor(measurer, defaultOptions) {
+    this.measurer = measurer;
+    const profile = measurer.getProfile();
+    this.defaultOptions = {
+      maxWidthPx: profile.displayWidthPx,
+      maxLines: profile.maxLines,
+      maxBytes: profile.maxPayloadBytes,
+      ...DEFAULT_WRAP_OPTIONS,
+      ...defaultOptions
+    };
+  }
+  wrap(text, options) {
+    const opts = this.mergeOptions(options);
+    const { maxWidthPx, maxLines, maxBytes, breakMode, preserveNewlines } = opts;
+    if (!text || text.length === 0) {
+      return this.createEmptyResult(opts);
+    }
+    const paragraphs = preserveNewlines ? text.split(`
+`) : [text];
+    const allLines = [];
+    const allMetrics = [];
+    let totalBytes = 0;
+    let truncated = false;
+    for (let pIndex = 0;pIndex < paragraphs.length; pIndex++) {
+      const paragraph = paragraphs[pIndex];
+      const isFromNewline = pIndex > 0;
+      const paragraphLines = this.wrapParagraph(paragraph, maxWidthPx, breakMode, opts);
+      for (let lIndex = 0;lIndex < paragraphLines.length; lIndex++) {
+        const line = paragraphLines[lIndex];
+        const lineBytes = this.measurer.getByteSize(line);
+        if (allLines.length >= maxLines) {
+          truncated = true;
+          break;
+        }
+        if (totalBytes + lineBytes > maxBytes) {
+          truncated = true;
+          break;
+        }
+        const widthPx = this.measurer.measureText(line);
+        const metrics = {
+          text: line,
+          widthPx,
+          bytes: lineBytes,
+          utilizationPercent: Math.round(widthPx / maxWidthPx * 100),
+          endsWithHyphen: line.endsWith(opts.hyphenChar) && lIndex < paragraphLines.length - 1,
+          fromExplicitNewline: isFromNewline && lIndex === 0
+        };
+        allLines.push(line);
+        allMetrics.push(metrics);
+        totalBytes += lineBytes;
+        if (allLines.length < maxLines) {
+          totalBytes += 1;
+        }
+      }
+      if (truncated)
+        break;
+    }
+    const maxLineWidthPx = allMetrics.reduce((max, m) => Math.max(max, m.widthPx), 0);
+    return {
+      lines: allLines,
+      truncated,
+      maxLineWidthPx,
+      totalBytes,
+      lineMetrics: allMetrics,
+      originalText: text,
+      breakMode
+    };
+  }
+  wrapToLines(text, options) {
+    return this.wrap(text, options).lines;
+  }
+  needsWrap(text, maxWidthPx) {
+    const width = maxWidthPx ?? this.defaultOptions.maxWidthPx;
+    return this.measurer.measureText(text) > width || text.includes(`
+`);
+  }
+  getOptions() {
+    return { ...this.defaultOptions };
+  }
+  getMeasurer() {
+    return this.measurer;
+  }
+  wrapParagraph(paragraph, maxWidthPx, breakMode, opts) {
+    const trimmed = opts.trimLines ? paragraph.trim() : paragraph;
+    if (!trimmed) {
+      return [""];
+    }
+    if (this.measurer.fitsInWidth(trimmed, maxWidthPx)) {
+      return [trimmed];
+    }
+    switch (breakMode) {
+      case "character":
+        return this.wrapCharacterMode(trimmed, maxWidthPx, opts);
+      case "word":
+        return this.wrapWordMode(trimmed, maxWidthPx, opts);
+      case "strict-word":
+        return this.wrapStrictWordMode(trimmed, maxWidthPx, opts);
+      default:
+        return this.wrapCharacterMode(trimmed, maxWidthPx, opts);
+    }
+  }
+  wrapCharacterMode(text, maxWidthPx, opts) {
+    const lines = [];
+    const hyphenWidth = this.measurer.measureChar(opts.hyphenChar);
+    let currentLine = "";
+    let currentWidth = 0;
+    const chars = Array.from(text);
+    for (let i = 0;i < chars.length; i++) {
+      const char = chars[i];
+      const charWidth = this.measurer.measureChar(char);
+      if (currentWidth + charWidth <= maxWidthPx) {
+        currentLine += char;
+        currentWidth += charWidth;
+      } else {
+        const prevChar = currentLine.length > 0 ? currentLine[currentLine.length - 1] : "";
+        const needsHyphen = currentLine.length >= opts.minCharsBeforeHyphen && needsHyphenForBreak(prevChar, char);
+        if (needsHyphen) {
+          const result = this.backoffForHyphen(currentLine, currentWidth, maxWidthPx, hyphenWidth, opts);
+          if (result.skipHyphen) {
+            lines.push(result.line);
+          } else {
+            lines.push(result.line + opts.hyphenChar);
+          }
+          currentLine = result.remainder + char;
+          currentWidth = this.measurer.measureText(currentLine);
+        } else {
+          const trimmedLine = opts.trimLines ? currentLine.trimEnd() : currentLine;
+          if (trimmedLine) {
+            lines.push(trimmedLine);
+          }
+          currentLine = char === " " ? "" : char;
+          currentWidth = char === " " ? 0 : charWidth;
+        }
+      }
+    }
+    if (currentLine) {
+      const trimmedLine = opts.trimLines ? currentLine.trim() : currentLine;
+      if (trimmedLine) {
+        lines.push(trimmedLine);
+      }
+    }
+    return lines.length > 0 ? lines : [""];
+  }
+  wrapWordMode(text, maxWidthPx, opts) {
+    const lines = [];
+    const words = this.splitIntoWords(text);
+    const spaceWidth = this.measurer.getSpaceWidth();
+    let currentLine = "";
+    let currentWidth = 0;
+    for (const word of words) {
+      const wordWidth = this.measurer.measureText(word);
+      const needsSpace = currentLine.length > 0;
+      const totalWidth = currentWidth + (needsSpace ? spaceWidth : 0) + wordWidth;
+      if (totalWidth <= maxWidthPx) {
+        if (needsSpace) {
+          currentLine += " ";
+          currentWidth += spaceWidth;
+        }
+        currentLine += word;
+        currentWidth += wordWidth;
+      } else {
+        if (currentLine.length > 0) {
+          lines.push(opts.trimLines ? currentLine.trim() : currentLine);
+          currentLine = "";
+          currentWidth = 0;
+        }
+        if (wordWidth > maxWidthPx) {
+          const hyphenatedLines = this.hyphenateLongWord(word, maxWidthPx, opts);
+          for (let i = 0;i < hyphenatedLines.length - 1; i++) {
+            lines.push(hyphenatedLines[i]);
+          }
+          currentLine = hyphenatedLines[hyphenatedLines.length - 1];
+          currentWidth = this.measurer.measureText(currentLine);
+        } else {
+          currentLine = word;
+          currentWidth = wordWidth;
+        }
+      }
+    }
+    if (currentLine) {
+      const trimmedLine = opts.trimLines ? currentLine.trim() : currentLine;
+      if (trimmedLine) {
+        lines.push(trimmedLine);
+      }
+    }
+    return lines.length > 0 ? lines : [""];
+  }
+  wrapStrictWordMode(text, maxWidthPx, opts) {
+    const lines = [];
+    const words = this.splitIntoWords(text);
+    const spaceWidth = this.measurer.getSpaceWidth();
+    let currentLine = "";
+    let currentWidth = 0;
+    for (const word of words) {
+      const wordWidth = this.measurer.measureText(word);
+      const needsSpace = currentLine.length > 0;
+      const totalWidth = currentWidth + (needsSpace ? spaceWidth : 0) + wordWidth;
+      if (totalWidth <= maxWidthPx) {
+        if (needsSpace) {
+          currentLine += " ";
+          currentWidth += spaceWidth;
+        }
+        currentLine += word;
+        currentWidth += wordWidth;
+      } else {
+        if (currentLine.length > 0) {
+          lines.push(opts.trimLines ? currentLine.trim() : currentLine);
+        }
+        currentLine = word;
+        currentWidth = wordWidth;
+      }
+    }
+    if (currentLine) {
+      const trimmedLine = opts.trimLines ? currentLine.trim() : currentLine;
+      if (trimmedLine) {
+        lines.push(trimmedLine);
+      }
+    }
+    return lines.length > 0 ? lines : [""];
+  }
+  splitIntoWords(text) {
+    const words = [];
+    let currentWord = "";
+    for (const char of text) {
+      if (char === " " || char === "\t") {
+        if (currentWord) {
+          words.push(currentWord);
+          currentWord = "";
+        }
+      } else if (isCJKCharacter(char)) {
+        if (currentWord) {
+          words.push(currentWord);
+          currentWord = "";
+        }
+        words.push(char);
+      } else {
+        currentWord += char;
+      }
+    }
+    if (currentWord) {
+      words.push(currentWord);
+    }
+    return words;
+  }
+  hyphenateLongWord(word, maxWidthPx, opts) {
+    const lines = [];
+    const hyphenWidth = this.measurer.measureChar(opts.hyphenChar);
+    const chars = Array.from(word);
+    let currentLine = "";
+    let currentWidth = 0;
+    for (let i = 0;i < chars.length; i++) {
+      const char = chars[i];
+      const charWidth = this.measurer.measureChar(char);
+      const isLastChar = i === chars.length - 1;
+      const widthNeeded = isLastChar ? charWidth : charWidth + hyphenWidth;
+      if (currentWidth + widthNeeded <= maxWidthPx) {
+        currentLine += char;
+        currentWidth += charWidth;
+      } else {
+        if (currentLine.length >= opts.minCharsBeforeHyphen) {
+          const result = this.backoffForHyphen(currentLine, currentWidth, maxWidthPx, hyphenWidth, opts);
+          if (result.skipHyphen) {
+            lines.push(result.line);
+          } else {
+            lines.push(result.line + opts.hyphenChar);
+          }
+          currentLine = result.remainder + char;
+          currentWidth = this.measurer.measureText(currentLine);
+        } else {
+          if (currentLine) {
+            lines.push(currentLine);
+          }
+          currentLine = char;
+          currentWidth = charWidth;
+        }
+      }
+    }
+    if (currentLine) {
+      lines.push(currentLine);
+    }
+    return lines.length > 0 ? lines : [word];
+  }
+  backoffForHyphen(line, lineWidth, maxWidthPx, hyphenWidth, opts) {
+    let adjustedLine = line;
+    let adjustedWidth = lineWidth;
+    let remainder = "";
+    while (adjustedWidth + hyphenWidth > maxWidthPx && adjustedLine.length > opts.minCharsBeforeHyphen) {
+      const lastChar = adjustedLine[adjustedLine.length - 1];
+      const lastCharWidth = this.measurer.measureChar(lastChar);
+      adjustedLine = adjustedLine.slice(0, -1);
+      adjustedWidth -= lastCharWidth;
+      remainder = lastChar + remainder;
+      if (adjustedLine.length > 0 && adjustedLine[adjustedLine.length - 1] === " ") {
+        adjustedLine = adjustedLine.trimEnd();
+        return { line: adjustedLine, remainder, skipHyphen: true };
+      }
+    }
+    return { line: adjustedLine, remainder, skipHyphen: false };
+  }
+  mergeOptions(options) {
+    return {
+      ...this.defaultOptions,
+      ...options
+    };
+  }
+  createEmptyResult(opts) {
+    return {
+      lines: [""],
+      truncated: false,
+      maxLineWidthPx: 0,
+      totalBytes: 0,
+      lineMetrics: [
+        {
+          text: "",
+          widthPx: 0,
+          bytes: 0,
+          utilizationPercent: 0,
+          endsWithHyphen: false,
+          fromExplicitNewline: false
+        }
+      ],
+      originalText: "",
+      breakMode: opts.breakMode
+    };
+  }
+}
+// src/display-utils/helpers/DisplayHelpers.ts
+class DisplayHelpers {
+  measurer;
+  wrapper;
+  profile;
+  constructor(measurer, wrapper) {
+    this.measurer = measurer;
+    this.wrapper = wrapper;
+    this.profile = measurer.getProfile();
+  }
+  truncateToLines(lines, maxLines, fromEnd = false) {
+    if (lines.length <= maxLines) {
+      return lines;
+    }
+    if (fromEnd) {
+      return lines.slice(-maxLines);
+    } else {
+      return lines.slice(0, maxLines);
+    }
+  }
+  truncateWithEllipsis(text, maxWidthPx, ellipsis = "...") {
+    const width = maxWidthPx ?? this.profile.displayWidthPx;
+    const textWidth = this.measurer.measureText(text);
+    if (textWidth <= width) {
+      return {
+        text,
+        wasTruncated: false,
+        widthPx: textWidth,
+        originalLength: text.length,
+        truncatedLength: text.length
+      };
+    }
+    const ellipsisWidth = this.measurer.measureText(ellipsis);
+    const targetWidth = width - ellipsisWidth;
+    let truncated = "";
+    let currentWidth = 0;
+    for (const char of text) {
+      const charWidth = this.measurer.measureChar(char);
+      if (currentWidth + charWidth > targetWidth) {
+        break;
+      }
+      truncated += char;
+      currentWidth += charWidth;
+    }
+    truncated = truncated.trimEnd();
+    const finalText = truncated + ellipsis;
+    return {
+      text: finalText,
+      wasTruncated: true,
+      widthPx: this.measurer.measureText(finalText),
+      originalLength: text.length,
+      truncatedLength: truncated.length
+    };
+  }
+  estimateLineCount(text, maxWidthPx) {
+    if (!text)
+      return 1;
+    const width = maxWidthPx ?? this.profile.displayWidthPx;
+    const textWidth = this.measurer.measureText(text);
+    const newlineCount = (text.match(/\n/g) || []).length;
+    const wrappedLines = Math.ceil(textWidth / width);
+    return wrappedLines + newlineCount;
+  }
+  fitToScreen(text, options) {
+    const result = this.wrapper.wrap(text, options);
+    return result.lines.slice(0, this.profile.maxLines);
+  }
+  paginate(text, options) {
+    const wrapResult = this.wrapper.wrap(text, {
+      ...options,
+      maxLines: Infinity,
+      maxBytes: Infinity
+    });
+    const linesPerPage = options?.maxLines ?? this.profile.maxLines;
+    const allLines = wrapResult.lines;
+    const pages = [];
+    for (let i = 0;i < allLines.length; i += linesPerPage) {
+      const pageLines = allLines.slice(i, i + linesPerPage);
+      const pageNumber = Math.floor(i / linesPerPage) + 1;
+      const totalPages = Math.ceil(allLines.length / linesPerPage);
+      pages.push({
+        lines: pageLines,
+        pageNumber,
+        totalPages,
+        isFirst: pageNumber === 1,
+        isLast: pageNumber === totalPages
+      });
+    }
+    return pages.length > 0 ? pages : [
+      {
+        lines: [""],
+        pageNumber: 1,
+        totalPages: 1,
+        isFirst: true,
+        isLast: true
+      }
+    ];
+  }
+  calculateByteSize(text) {
+    return this.measurer.getByteSize(text);
+  }
+  exceedsByteLimit(text, maxBytes) {
+    const limit = maxBytes ?? this.profile.maxPayloadBytes;
+    return this.calculateByteSize(text) > limit;
+  }
+  splitIntoChunks(text, chunkSize) {
+    const size = chunkSize ?? this.profile.bleChunkSize;
+    const encoder = new TextEncoder;
+    const bytes = encoder.encode(text);
+    if (bytes.length <= size) {
+      return [
+        {
+          text,
+          index: 0,
+          totalChunks: 1,
+          bytes: bytes.length
+        }
+      ];
+    }
+    const chunks = [];
+    let offset = 0;
+    while (offset < bytes.length) {
+      let endOffset = Math.min(offset + size, bytes.length);
+      if (endOffset < bytes.length) {
+        while (endOffset > offset && (bytes[endOffset] & 192) === 128) {
+          endOffset--;
+        }
+        let breakPoint = endOffset;
+        for (let i = endOffset - 1;i > offset + size / 2; i--) {
+          if (bytes[i] === 32 || bytes[i] === 10) {
+            breakPoint = i + 1;
+            break;
+          }
+        }
+        if (breakPoint > offset) {
+          endOffset = breakPoint;
+        }
+      }
+      const chunkBytes = bytes.slice(offset, endOffset);
+      const chunkText = new TextDecoder().decode(chunkBytes);
+      chunks.push({
+        text: chunkText,
+        index: chunks.length,
+        totalChunks: 0,
+        bytes: chunkBytes.length
+      });
+      offset = endOffset;
+    }
+    for (const chunk of chunks) {
+      chunk.totalChunks = chunks.length;
+    }
+    return chunks;
+  }
+  calculateUtilization(result) {
+    if (result.lines.length === 0 || result.lineMetrics.length === 0) {
+      return {
+        averageUtilization: 0,
+        minUtilization: 0,
+        maxUtilization: 0,
+        totalWastedPx: 0
+      };
+    }
+    const maxWidthPx = this.profile.displayWidthPx;
+    let totalUtilization = 0;
+    let minUtilization = 100;
+    let maxUtilization = 0;
+    let totalWastedPx = 0;
+    for (const metric of result.lineMetrics) {
+      totalUtilization += metric.utilizationPercent;
+      minUtilization = Math.min(minUtilization, metric.utilizationPercent);
+      maxUtilization = Math.max(maxUtilization, metric.utilizationPercent);
+      totalWastedPx += maxWidthPx - metric.widthPx;
+    }
+    return {
+      averageUtilization: Math.round(totalUtilization / result.lineMetrics.length),
+      minUtilization,
+      maxUtilization,
+      totalWastedPx
+    };
+  }
+  padToLineCount(lines, targetCount, padAtEnd = true) {
+    if (lines.length >= targetCount) {
+      return lines.slice(0, targetCount);
+    }
+    const padding = Array(targetCount - lines.length).fill("");
+    if (padAtEnd) {
+      return [...lines, ...padding];
+    } else {
+      return [...padding, ...lines];
+    }
+  }
+  joinLines(lines) {
+    return lines.join(`
+`);
+  }
+  getMeasurer() {
+    return this.measurer;
+  }
+  getWrapper() {
+    return this.wrapper;
+  }
+  getProfile() {
+    return this.profile;
+  }
+}
+// src/display-utils/helpers/ScrollView.ts
+class ScrollView {
+  measurer;
+  wrapper;
+  profile;
+  viewportSize;
+  allLines = [];
+  wrapResult = null;
+  scrollOffset = 0;
+  constructor(measurer, wrapper, viewportSize) {
+    this.measurer = measurer;
+    this.wrapper = wrapper;
+    this.profile = measurer.getProfile();
+    this.viewportSize = viewportSize ?? this.profile.maxLines;
+  }
+  setContent(text, options) {
+    this.wrapResult = this.wrapper.wrap(text, {
+      ...options,
+      maxLines: Infinity,
+      maxBytes: Infinity
+    });
+    this.allLines = this.wrapResult.lines;
+    this.scrollOffset = 0;
+  }
+  appendContent(text, options, autoScroll = true) {
+    const wasAtBottom = this.isAtBottom();
+    const newResult = this.wrapper.wrap(text, {
+      ...options,
+      maxLines: Infinity,
+      maxBytes: Infinity
+    });
+    this.allLines = [...this.allLines, ...newResult.lines];
+    if (autoScroll && wasAtBottom) {
+      this.scrollToBottom();
+    }
+  }
+  getViewport() {
+    const visibleLines = this.allLines.slice(this.scrollOffset, this.scrollOffset + this.viewportSize);
+    while (visibleLines.length < this.viewportSize) {
+      visibleLines.push("");
+    }
+    return {
+      lines: visibleLines,
+      position: this.getPosition(),
+      contentTruncated: this.wrapResult?.truncated ?? false
+    };
+  }
+  getPosition() {
+    const totalLines = this.allLines.length;
+    const maxOffset = Math.max(0, totalLines - this.viewportSize);
+    return {
+      offset: this.scrollOffset,
+      totalLines,
+      visibleLines: this.viewportSize,
+      maxOffset,
+      atTop: this.scrollOffset === 0,
+      atBottom: this.scrollOffset >= maxOffset,
+      scrollPercent: maxOffset > 0 ? Math.round(this.scrollOffset / maxOffset * 100) : 100
+    };
+  }
+  scrollTo(offset) {
+    const maxOffset = Math.max(0, this.allLines.length - this.viewportSize);
+    this.scrollOffset = Math.max(0, Math.min(offset, maxOffset));
+  }
+  scrollDown(lines = 1) {
+    this.scrollTo(this.scrollOffset + lines);
+  }
+  scrollUp(lines = 1) {
+    this.scrollTo(this.scrollOffset - lines);
+  }
+  pageDown() {
+    this.scrollDown(this.viewportSize);
+  }
+  pageUp() {
+    this.scrollUp(this.viewportSize);
+  }
+  scrollToTop() {
+    this.scrollOffset = 0;
+  }
+  scrollToBottom() {
+    const maxOffset = Math.max(0, this.allLines.length - this.viewportSize);
+    this.scrollOffset = maxOffset;
+  }
+  scrollToLine(lineIndex, position = "top") {
+    let targetOffset;
+    switch (position) {
+      case "top":
+        targetOffset = lineIndex;
+        break;
+      case "center":
+        targetOffset = lineIndex - Math.floor(this.viewportSize / 2);
+        break;
+      case "bottom":
+        targetOffset = lineIndex - this.viewportSize + 1;
+        break;
+    }
+    this.scrollTo(targetOffset);
+  }
+  scrollToPercent(percent) {
+    const maxOffset = Math.max(0, this.allLines.length - this.viewportSize);
+    const targetOffset = Math.round(percent / 100 * maxOffset);
+    this.scrollTo(targetOffset);
+  }
+  isAtTop() {
+    return this.scrollOffset === 0;
+  }
+  isAtBottom() {
+    const maxOffset = Math.max(0, this.allLines.length - this.viewportSize);
+    return this.scrollOffset >= maxOffset;
+  }
+  isScrollable() {
+    return this.allLines.length > this.viewportSize;
+  }
+  getAllLines() {
+    return [...this.allLines];
+  }
+  getTotalLines() {
+    return this.allLines.length;
+  }
+  getViewportSize() {
+    return this.viewportSize;
+  }
+  clear() {
+    this.allLines = [];
+    this.wrapResult = null;
+    this.scrollOffset = 0;
+  }
+  getMeasurer() {
+    return this.measurer;
+  }
+  getWrapper() {
+    return this.wrapper;
+  }
+  getProfile() {
+    return this.profile;
+  }
+}
+// src/display-utils/index.ts
+function createDisplayToolkit(profile = G1_PROFILE, wrapOptions) {
+  const measurer = new TextMeasurer(profile);
+  const wrapper = new TextWrapper(measurer, wrapOptions);
+  const helpers = new DisplayHelpers(measurer, wrapper);
+  return {
+    measurer,
+    wrapper,
+    helpers,
+    profile
+  };
+}
+function createG1Toolkit() {
+  return createDisplayToolkit(G1_PROFILE, {
+    breakMode: "character",
+    hyphenChar: "-",
+    minCharsBeforeHyphen: 3
+  });
+}
+function createG1LegacyToolkit() {
+  return createDisplayToolkit(G1_PROFILE_LEGACY, {
+    breakMode: "character",
+    hyphenChar: "-",
+    minCharsBeforeHyphen: 3
+  });
+}
+export {
+  needsHyphenForBreak,
+  isUnsupportedScript,
+  isUniformWidthScript,
+  isKoreanCharacter,
+  isCJKCharacter,
+  detectScript,
+  createG1Toolkit,
+  createG1LegacyToolkit,
+  createDisplayToolkit,
+  TextWrapper,
+  TextMeasurer,
+  ScrollView,
+  SCRIPT_RANGES,
+  G1_SPACE_WIDTH_PX,
+  G1_PROFILE_LEGACY,
+  G1_PROFILE,
+  G1_HYPHEN_WIDTH_PX,
+  DisplayHelpers,
+  DEFAULT_WRAP_OPTIONS
+};
+
+//# debugId=7A9C99D0B00FC7CF64756E2164756E21