@zync/zync-screnplay-player 0.1.245 → 0.1.247

package/dist/screenplay/RemotionRenderer/fontRegistry.js

@@ -0,0 +1,422 @@
+function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { getInfo as getCherryBombOneInfo, loadFont as loadCherryBombOneFont } from "@remotion/google-fonts/CherryBombOne";
+import { getInfo as getKanitInfo, loadFont as loadKanitFont } from "@remotion/google-fonts/Kanit";
+import { getInfo as getMontserratInfo, loadFont as loadMontserratFont } from "@remotion/google-fonts/Montserrat";
+import { getInfo as getOswaldInfo, loadFont as loadOswaldFont } from "@remotion/google-fonts/Oswald";
+import { getInfo as getPoppinsInfo, loadFont as loadPoppinsFont } from "@remotion/google-fonts/Poppins";
+import { getInfo as getRobotoInfo, loadFont as loadRobotoFont } from "@remotion/google-fonts/Roboto";
+import { getInfo as getRochesterInfo, loadFont as loadRochesterFont } from "@remotion/google-fonts/Rochester";
+import { getInfo as getTitanOneInfo, loadFont as loadTitanOneFont } from "@remotion/google-fonts/TitanOne";
+var LATIN_SUBSETS = ["latin", "latin-ext"];
+var LATIN_ONLY_SUBSETS = ["latin"];
+var GENERIC_SUBSETS = new Set(["math", "symbols"]);
+export var FONT_FAMILIES = Object.freeze({
+  CHERRY_BOMB_ONE: "Cherry Bomb One",
+  KANIT: "Kanit",
+  MONTSERRAT: "Montserrat",
+  OSWALD: "Oswald",
+  POPPINS: "Poppins",
+  ROBOTO: "Roboto",
+  ROCHESTER: "Rochester",
+  TITAN_ONE: "Titan One"
+});
+var FONT_METADATA = Object.freeze(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty({}, FONT_FAMILIES.CHERRY_BOMB_ONE, getCherryBombOneInfo()), FONT_FAMILIES.KANIT, getKanitInfo()), FONT_FAMILIES.MONTSERRAT, getMontserratInfo()), FONT_FAMILIES.OSWALD, getOswaldInfo()), FONT_FAMILIES.POPPINS, getPoppinsInfo()), FONT_FAMILIES.ROBOTO, getRobotoInfo()), FONT_FAMILIES.ROCHESTER, getRochesterInfo()), FONT_FAMILIES.TITAN_ONE, getTitanOneInfo()));
+var createProfile = function createProfile(style, weights) {
+  var subsets = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : LATIN_SUBSETS;
+  return Object.freeze({
+    style: style,
+    weights: Object.freeze(weights),
+    subsets: Object.freeze(subsets)
+  });
+};
+export var FONT_PROFILES = Object.freeze(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty({}, FONT_FAMILIES.POPPINS, Object.freeze([createProfile("normal", ["300", "400", "500", "600", "700", "800", "900"]), createProfile("italic", ["800"])])), FONT_FAMILIES.KANIT, Object.freeze([createProfile("normal", ["400", "500", "600", "700", "800", "900"]), createProfile("italic", ["600", "800", "900"])])), FONT_FAMILIES.MONTSERRAT, Object.freeze([createProfile("normal", ["400", "500", "600", "700", "800", "900"])])), FONT_FAMILIES.ROBOTO, Object.freeze([createProfile("normal", ["300", "400", "700", "900"])])), FONT_FAMILIES.OSWALD, Object.freeze([createProfile("normal", ["400", "500", "600", "700"])])), FONT_FAMILIES.ROCHESTER, Object.freeze([createProfile("normal", ["400"], LATIN_ONLY_SUBSETS)])), FONT_FAMILIES.TITAN_ONE, Object.freeze([createProfile("normal", ["400"])])), FONT_FAMILIES.CHERRY_BOMB_ONE, Object.freeze([createProfile("normal", ["400"])])));
+var FONT_LOADERS = Object.freeze(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty({}, FONT_FAMILIES.CHERRY_BOMB_ONE, loadCherryBombOneFont), FONT_FAMILIES.KANIT, loadKanitFont), FONT_FAMILIES.MONTSERRAT, loadMontserratFont), FONT_FAMILIES.OSWALD, loadOswaldFont), FONT_FAMILIES.POPPINS, loadPoppinsFont), FONT_FAMILIES.ROBOTO, loadRobotoFont), FONT_FAMILIES.ROCHESTER, loadRochesterFont), FONT_FAMILIES.TITAN_ONE, loadTitanOneFont));
+var DEFAULT_COMPONENT_DEPENDENCIES = Object.freeze({
+  Caption: [FONT_FAMILIES.POPPINS],
+  CaptionSimple: [FONT_FAMILIES.POPPINS],
+  HandoffNametag: [FONT_FAMILIES.ROBOTO],
+  Nametag: [FONT_FAMILIES.POPPINS],
+  Sentence: [FONT_FAMILIES.KANIT],
+  Title: [FONT_FAMILIES.POPPINS]
+});
+var THEME_COMPONENT_DEPENDENCIES = Object.freeze({
+  "default": DEFAULT_COMPONENT_DEPENDENCIES,
+  glitch: _objectSpread(_objectSpread({}, DEFAULT_COMPONENT_DEPENDENCIES), {}, {
+    Nametag: [FONT_FAMILIES.KANIT],
+    Sentence: [FONT_FAMILIES.KANIT],
+    Title: [FONT_FAMILIES.KANIT]
+  }),
+  glassmorphism: _objectSpread(_objectSpread({}, DEFAULT_COMPONENT_DEPENDENCIES), {}, {
+    Nametag: [FONT_FAMILIES.POPPINS],
+    Sentence: [FONT_FAMILIES.POPPINS],
+    Title: [FONT_FAMILIES.POPPINS]
+  }),
+  sports: _objectSpread(_objectSpread({}, DEFAULT_COMPONENT_DEPENDENCIES), {}, {
+    Nametag: [FONT_FAMILIES.KANIT],
+    Sentence: [FONT_FAMILIES.KANIT],
+    Title: [FONT_FAMILIES.KANIT]
+  }),
+  sportsbounce: _objectSpread(_objectSpread({}, DEFAULT_COMPONENT_DEPENDENCIES), {}, {
+    Nametag: [FONT_FAMILIES.MONTSERRAT],
+    Sentence: [FONT_FAMILIES.MONTSERRAT],
+    Title: [FONT_FAMILIES.KANIT]
+  }),
+  bigbold: _objectSpread(_objectSpread({}, DEFAULT_COMPONENT_DEPENDENCIES), {}, {
+    Nametag: [FONT_FAMILIES.MONTSERRAT],
+    Sentence: [FONT_FAMILIES.MONTSERRAT],
+    Title: [FONT_FAMILIES.MONTSERRAT]
+  }),
+  pushpull: _objectSpread(_objectSpread({}, DEFAULT_COMPONENT_DEPENDENCIES), {}, {
+    Nametag: [FONT_FAMILIES.KANIT],
+    Sentence: [FONT_FAMILIES.KANIT],
+    Title: [FONT_FAMILIES.KANIT]
+  }),
+  none: _objectSpread(_objectSpread({}, DEFAULT_COMPONENT_DEPENDENCIES), {}, {
+    Nametag: [],
+    Title: []
+  }),
+  collabintro: _objectSpread(_objectSpread({}, DEFAULT_COMPONENT_DEPENDENCIES), {}, {
+    Nametag: [FONT_FAMILIES.OSWALD, FONT_FAMILIES.POPPINS],
+    Title: [FONT_FAMILIES.OSWALD, FONT_FAMILIES.POPPINS]
+  }),
+  centerline: _objectSpread(_objectSpread({}, DEFAULT_COMPONENT_DEPENDENCIES), {}, {
+    Nametag: [FONT_FAMILIES.KANIT]
+  }),
+  boxwipe: _objectSpread(_objectSpread({}, DEFAULT_COMPONENT_DEPENDENCIES), {}, {
+    Nametag: [FONT_FAMILIES.KANIT]
+  }),
+  stackfill: _objectSpread(_objectSpread({}, DEFAULT_COMPONENT_DEPENDENCIES), {}, {
+    Nametag: [FONT_FAMILIES.KANIT]
+  }),
+  rightslide: _objectSpread(_objectSpread({}, DEFAULT_COMPONENT_DEPENDENCIES), {}, {
+    Nametag: [FONT_FAMILIES.KANIT]
+  }),
+  depth: _objectSpread(_objectSpread({}, DEFAULT_COMPONENT_DEPENDENCIES), {}, {
+    Sentence: [FONT_FAMILIES.POPPINS]
+  }),
+  fullcover: _objectSpread(_objectSpread({}, DEFAULT_COMPONENT_DEPENDENCIES), {}, {
+    Sentence: [FONT_FAMILIES.POPPINS]
+  })
+});
+var DIRECT_COMPONENT_DEPENDENCIES = Object.freeze({
+  CaptionColor: [FONT_FAMILIES.POPPINS],
+  CaptionColorInverse: [FONT_FAMILIES.POPPINS],
+  CaptionColorShadow: [FONT_FAMILIES.MONTSERRAT],
+  CaptionElegant: [FONT_FAMILIES.MONTSERRAT, FONT_FAMILIES.ROCHESTER],
+  CaptionEmphasis: [FONT_FAMILIES.MONTSERRAT],
+  CaptionPunctuated: [FONT_FAMILIES.POPPINS],
+  CaptionWordBoom: [FONT_FAMILIES.TITAN_ONE],
+  CaptionWordBubble: [FONT_FAMILIES.MONTSERRAT],
+  CaptionWordPopup: [FONT_FAMILIES.MONTSERRAT, FONT_FAMILIES.CHERRY_BOMB_ONE],
+  DefaultCaption: [FONT_FAMILIES.POPPINS],
+  GlitchNametag: [FONT_FAMILIES.KANIT],
+  GlitchSentence: [FONT_FAMILIES.KANIT],
+  GlitchTitle: [FONT_FAMILIES.KANIT],
+  PhraseRainbowEffect: [FONT_FAMILIES.ROBOTO],
+  SportsCaption: [FONT_FAMILIES.KANIT]
+});
+var COMPONENT_ALIASES = Object.freeze({
+  CaptionSimple: "Caption",
+  NametagFold: "Nametag",
+  SentenceSimple: "Sentence",
+  SimpleFrameSentence: "Sentence"
+});
+var LAYOUT_COMPONENT_DEPENDENCIES = Object.freeze({
+  CreatorCollabColdOpen: [FONT_FAMILIES.OSWALD, FONT_FAMILIES.POPPINS],
+  CreatorCollabConversationSpine: [FONT_FAMILIES.OSWALD, FONT_FAMILIES.POPPINS],
+  CreatorCollabDocumentaryInset: [FONT_FAMILIES.OSWALD, FONT_FAMILIES.POPPINS],
+  CreatorCollabRackFocus: [FONT_FAMILIES.OSWALD, FONT_FAMILIES.POPPINS],
+  CreatorCollabSplit: [FONT_FAMILIES.POPPINS],
+  CreatorCollabStudioSet: [FONT_FAMILIES.OSWALD, FONT_FAMILIES.POPPINS],
+  DynamicTriangle: [FONT_FAMILIES.KANIT],
+  HookVideo: [FONT_FAMILIES.OSWALD],
+  IntroVideo: [FONT_FAMILIES.OSWALD],
+  KeyPointOverlayDepth: [FONT_FAMILIES.POPPINS],
+  Keyword: [FONT_FAMILIES.POPPINS],
+  KeywordStudioBackdrop: [FONT_FAMILIES.POPPINS],
+  MotionStill: [FONT_FAMILIES.POPPINS],
+  TextWithVideo: [FONT_FAMILIES.POPPINS],
+  TextFullCover: [FONT_FAMILIES.POPPINS]
+});
+var getComponentDependencies = function getComponentDependencies(component, theme) {
+  if (!component) {
+    return [];
+  }
+  var normalizedComponent = COMPONENT_ALIASES[component] || component;
+  if (DIRECT_COMPONENT_DEPENDENCIES[normalizedComponent]) {
+    return DIRECT_COMPONENT_DEPENDENCIES[normalizedComponent];
+  }
+  if (LAYOUT_COMPONENT_DEPENDENCIES[normalizedComponent]) {
+    return LAYOUT_COMPONENT_DEPENDENCIES[normalizedComponent];
+  }
+  var themeDependencies = THEME_COMPONENT_DEPENDENCIES[theme] || THEME_COMPONENT_DEPENDENCIES["default"];
+  return themeDependencies[normalizedComponent] || DEFAULT_COMPONENT_DEPENDENCIES[normalizedComponent] || [];
+};
+var addEntryDependencies = function addEntryDependencies(families, entry, theme) {
+  if (!entry) {
+    return;
+  }
+  var entryTheme = entry.theme || theme;
+  var _iterator = _createForOfIteratorHelper(getComponentDependencies(entry.component, entryTheme)),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var family = _step.value;
+      families.add(family);
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+};
+var parseUnicodeRange = function parseUnicodeRange(unicodeRange) {
+  return unicodeRange.split(",").map(function (range) {
+    var _range$trim$replace$s = range.trim().replace(/^U\+/i, "").split("-"),
+      _range$trim$replace$s2 = _slicedToArray(_range$trim$replace$s, 2),
+      start = _range$trim$replace$s2[0],
+      end = _range$trim$replace$s2[1];
+    return [Number.parseInt(start, 16), Number.parseInt(end || start, 16)];
+  });
+};
+var getTimelineText = function getTimelineText(timeline) {
+  var text = [];
+  var visited = new WeakSet();
+  var _visit = function visit(value) {
+    if (typeof value === "string") {
+      text.push(value);
+      return;
+    }
+    if (!value || _typeof(value) !== "object" || visited.has(value)) {
+      return;
+    }
+    visited.add(value);
+    for (var _i = 0, _Object$values = Object.values(value); _i < _Object$values.length; _i++) {
+      var child = _Object$values[_i];
+      _visit(child);
+    }
+  };
+  _visit(timeline);
+  return text.join("\n");
+};
+var getSubsetsForProfile = function getSubsetsForProfile(family, profile, timelineText) {
+  var metadata = FONT_METADATA[family];
+  var subsets = _toConsumableArray(profile.subsets);
+  var codePoints = _toConsumableArray(timelineText).map(function (character) {
+    return character.codePointAt(0);
+  });
+  var subsetRanges = new Map();
+  var metadataSubsets = new Set([].concat(_toConsumableArray(metadata.subsets || []), _toConsumableArray(Object.keys(metadata.unicodeRanges || {}))));
+  var _iterator2 = _createForOfIteratorHelper(metadataSubsets),
+    _step2;
+  try {
+    var _loop = function _loop() {
+        var _metadata$unicodeRang;
+        var subset = _step2.value;
+        if (!profile.weights.every(function (weight) {
+          var _metadata$fonts, _metadata$fonts$profi, _metadata$fonts$profi2;
+          return (_metadata$fonts = metadata.fonts) === null || _metadata$fonts === void 0 ? void 0 : (_metadata$fonts$profi = _metadata$fonts[profile.style]) === null || _metadata$fonts$profi === void 0 ? void 0 : (_metadata$fonts$profi2 = _metadata$fonts$profi[weight]) === null || _metadata$fonts$profi2 === void 0 ? void 0 : _metadata$fonts$profi2[subset];
+        })) {
+          return 0; // continue
+        }
+        var unicodeRange = (_metadata$unicodeRang = metadata.unicodeRanges) === null || _metadata$unicodeRang === void 0 ? void 0 : _metadata$unicodeRang[subset];
+        if (!unicodeRange) {
+          return 0; // continue
+        }
+        subsetRanges.set(subset, parseUnicodeRange(unicodeRange));
+      },
+      _ret;
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      _ret = _loop();
+      if (_ret === 0) continue;
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+  var matchesSubset = function matchesSubset(subset, codePoint) {
+    var _subsetRanges$get;
+    return (_subsetRanges$get = subsetRanges.get(subset)) === null || _subsetRanges$get === void 0 ? void 0 : _subsetRanges$get.some(function (_ref) {
+      var _ref2 = _slicedToArray(_ref, 2),
+        start = _ref2[0],
+        end = _ref2[1];
+      return codePoint >= start && codePoint <= end;
+    });
+  };
+  var specificSubsets = _toConsumableArray(subsetRanges.keys()).filter(function (subset) {
+    return !GENERIC_SUBSETS.has(subset);
+  });
+  var _iterator3 = _createForOfIteratorHelper(specificSubsets),
+    _step3;
+  try {
+    var _loop2 = function _loop2() {
+      var subset = _step3.value;
+      if (!subsets.includes(subset) && codePoints.some(function (codePoint) {
+        return matchesSubset(subset, codePoint);
+      })) {
+        subsets.push(subset);
+      }
+    };
+    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+      _loop2();
+    }
+  } catch (err) {
+    _iterator3.e(err);
+  } finally {
+    _iterator3.f();
+  }
+  var _iterator4 = _createForOfIteratorHelper(GENERIC_SUBSETS),
+    _step4;
+  try {
+    var _loop3 = function _loop3() {
+      var subset = _step4.value;
+      var isUsedByUnmatchedCodePoint = codePoints.some(function (codePoint) {
+        return matchesSubset(subset, codePoint) && !specificSubsets.some(function (specificSubset) {
+          return matchesSubset(specificSubset, codePoint);
+        });
+      });
+      if (isUsedByUnmatchedCodePoint && !subsets.includes(subset)) {
+        subsets.push(subset);
+      }
+    };
+    for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+      _loop3();
+    }
+  } catch (err) {
+    _iterator4.e(err);
+  } finally {
+    _iterator4.f();
+  }
+  return subsets;
+};
+export var getFontRequestsForTimeline = function getFontRequestsForTimeline() {
+  var _timeline$output;
+  var timeline = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var families = new Set();
+  var theme = ((_timeline$output = timeline.output) === null || _timeline$output === void 0 ? void 0 : _timeline$output.theme) || "default";
+  var timelineText = getTimelineText(timeline);
+  var visitTrackEntry = function visitTrackEntry(entry) {
+    addEntryDependencies(families, entry === null || entry === void 0 ? void 0 : entry.layout, theme);
+    var _iterator5 = _createForOfIteratorHelper((entry === null || entry === void 0 ? void 0 : entry.effects) || []),
+      _step5;
+    try {
+      for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+        var effect = _step5.value;
+        addEntryDependencies(families, effect, effect.theme || theme);
+      }
+    } catch (err) {
+      _iterator5.e(err);
+    } finally {
+      _iterator5.f();
+    }
+    addEntryDependencies(families, entry, theme);
+  };
+  visitTrackEntry(timeline.mainVideoTrack);
+  var _iterator6 = _createForOfIteratorHelper(timeline.layoutVideoTrack || []),
+    _step6;
+  try {
+    for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+      var entry = _step6.value;
+      visitTrackEntry(entry);
+    }
+  } catch (err) {
+    _iterator6.e(err);
+  } finally {
+    _iterator6.f();
+  }
+  var _iterator7 = _createForOfIteratorHelper(timeline.effectsVideoTrack || []),
+    _step7;
+  try {
+    for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+      var _entry = _step7.value;
+      addEntryDependencies(families, _entry, _entry.theme || theme);
+    }
+  } catch (err) {
+    _iterator7.e(err);
+  } finally {
+    _iterator7.f();
+  }
+  var _iterator8 = _createForOfIteratorHelper(timeline.captionsVideoTrack || []),
+    _step8;
+  try {
+    for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
+      var _entry2 = _step8.value;
+      addEntryDependencies(families, _entry2, _entry2.theme || theme);
+    }
+  } catch (err) {
+    _iterator8.e(err);
+  } finally {
+    _iterator8.f();
+  }
+  return _toConsumableArray(families).sort().map(function (family) {
+    return {
+      family: family,
+      profiles: FONT_PROFILES[family].map(function (profile) {
+        return createProfile(profile.style, profile.weights, getSubsetsForProfile(family, profile, timelineText));
+      })
+    };
+  });
+};
+var loadedProfilesByDocument = new WeakMap();
+export var loadFontsForTimeline = function loadFontsForTimeline() {
+  var timeline = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  if (typeof document === "undefined" || typeof FontFace === "undefined") {
+    return;
+  }
+  var loadedProfiles = loadedProfilesByDocument.get(document);
+  if (!loadedProfiles) {
+    loadedProfiles = new Set();
+    loadedProfilesByDocument.set(document, loadedProfiles);
+  }
+  var _iterator9 = _createForOfIteratorHelper(getFontRequestsForTimeline(timeline)),
+    _step9;
+  try {
+    for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
+      var _step9$value = _step9.value,
+        family = _step9$value.family,
+        profiles = _step9$value.profiles;
+      var loadFont = FONT_LOADERS[family];
+      var _iterator10 = _createForOfIteratorHelper(profiles),
+        _step10;
+      try {
+        for (_iterator10.s(); !(_step10 = _iterator10.n()).done;) {
+          var profile = _step10.value;
+          var key = [family, profile.style, profile.weights.join(","), profile.subsets.join(",")].join(":");
+          if (loadedProfiles.has(key)) {
+            continue;
+          }
+          loadFont(profile.style, {
+            weights: profile.weights,
+            subsets: profile.subsets
+          });
+          loadedProfiles.add(key);
+        }
+      } catch (err) {
+        _iterator10.e(err);
+      } finally {
+        _iterator10.f();
+      }
+    }
+  } catch (err) {
+    _iterator9.e(err);
+  } finally {
+    _iterator9.f();
+  }
+};

package/dist/screenplay/RemotionRenderer/helpers/convertToSeconds.js

@@ -1,11 +1,11 @@
-/**
- * Converts seconds and a portion of frames to a numeric value of seconds.
- *
- * @param {number} seconds - The number of full seconds.
- * @param {number} nthFrame - The current frame within the second.
- * @param {number} delayInSeconds - Optional delay that adds up to the calculation
- * @param {number} frameRate - The frame rate (frames per second).
- * @return {number} The total time in seconds (with decimals for frames).
+/**
+ * Converts seconds and a portion of frames to a numeric value of seconds.
+ *
+ * @param {number} seconds - The number of full seconds.
+ * @param {number} nthFrame - The current frame within the second.
+ * @param {number} delayInSeconds - Optional delay that adds up to the calculation
+ * @param {number} frameRate - The frame rate (frames per second).
+ * @return {number} The total time in seconds (with decimals for frames).
  */
 export var convertToSeconds = function convertToSeconds(seconds, nthFrame) {
   var delayInSeconds = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;

package/dist/screenplay/RemotionRenderer/helpers/faceBasedVideoStyles.js

@@ -4,10 +4,10 @@ function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r)
 function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
 function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
 function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
-/**
- * Calculate video styles based on face detection metadata
- * This helper adjusts video positioning and transform origin to center faces in the viewport
- * when zooming, accounting for objectFit: "cover" behavior
+/**
+ * Calculate video styles based on face detection metadata
+ * This helper adjusts video positioning and transform origin to center faces in the viewport
+ * when zooming, accounting for objectFit: "cover" behavior
  */
 export var getFaceBasedVideoStyles = function getFaceBasedVideoStyles(_ref) {
   var faceMetadata = _ref.faceMetadata,

package/dist/screenplay/RemotionRenderer/helpers/faceCenteredVideoTransforms.js

@@ -4,33 +4,33 @@ function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t =
 function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
 function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
 function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
-/**
- * Face-Centered Video Transform Calculator
- *
- * This helper calculates transform origin and positioning to ensure a video is ALWAYS
- * centered on a person's face, regardless of aspect ratio (landscape, square, portrait).
- *
- * Key features:
- * - Converts absolute face coordinates to relative values
- * - Handles different target aspect ratios (1920x1080, 1080x1080, 1080x1920)
- * - Provides smooth interpolation between frames
- * - Calculates optimal scale and positioning for face centering
+/**
+ * Face-Centered Video Transform Calculator
+ *
+ * This helper calculates transform origin and positioning to ensure a video is ALWAYS
+ * centered on a person's face, regardless of aspect ratio (landscape, square, portrait).
+ *
+ * Key features:
+ * - Converts absolute face coordinates to relative values
+ * - Handles different target aspect ratios (1920x1080, 1080x1080, 1080x1920)
+ * - Provides smooth interpolation between frames
+ * - Calculates optimal scale and positioning for face centering
  */
 
 import { useCurrentFrame } from "remotion";
 
-/**
- * Calculate face-centered video transforms
- * @param {Object} params - Configuration object
- * @param {Object} params.faceMetadata - Face detection metadata
- * @param {number} params.targetWidth - Target video width (1920 for landscape, 1080 for square/portrait)
- * @param {number} params.targetHeight - Target video height (1080 for landscape/square, 1920 for portrait)
- * @param {number} params.currentFrame - Current frame number (optional, will use useCurrentFrame if not provided)
- * @param {boolean} params.enableInterpolation - Whether to interpolate between frames
- * @param {number} params.faceScale - Scale factor for face area (1.0 = face fills frame, 0.5 = face takes half frame)
- * @param {boolean} params.useAveragePosition - Whether to use average face position for entire video duration
- * @param {boolean} params.centerHorizontally - Whether to only center horizontally (X axis), not vertically (Y axis)
- * @returns {Object} Transform styles and debug info
+/**
+ * Calculate face-centered video transforms
+ * @param {Object} params - Configuration object
+ * @param {Object} params.faceMetadata - Face detection metadata
+ * @param {number} params.targetWidth - Target video width (1920 for landscape, 1080 for square/portrait)
+ * @param {number} params.targetHeight - Target video height (1080 for landscape/square, 1920 for portrait)
+ * @param {number} params.currentFrame - Current frame number (optional, will use useCurrentFrame if not provided)
+ * @param {boolean} params.enableInterpolation - Whether to interpolate between frames
+ * @param {number} params.faceScale - Scale factor for face area (1.0 = face fills frame, 0.5 = face takes half frame)
+ * @param {boolean} params.useAveragePosition - Whether to use average face position for entire video duration
+ * @param {boolean} params.centerHorizontally - Whether to only center horizontally (X axis), not vertically (Y axis)
+ * @returns {Object} Transform styles and debug info
  */
 export var calculateFaceCenteredTransforms = function calculateFaceCenteredTransforms(_ref) {
   var _faceMetadata$metadat, _faceMetadata$metadat2;
@@ -173,10 +173,10 @@ export var calculateFaceCenteredTransforms = function calculateFaceCenteredTrans
   };
 };
 
-/**
- * Calculate average face position from all frames with face data
- * @param {Array} frames - Array of frame data
- * @returns {Object|null} Average face data or null if no face data available
+/**
+ * Calculate average face position from all frames with face data
+ * @param {Array} frames - Array of frame data
+ * @returns {Object|null} Average face data or null if no face data available
  */
 function getAverageFaceData(frames) {
   if (!frames || frames.length === 0) return null;
@@ -225,8 +225,8 @@ function getAverageFaceData(frames) {
   return averageFaceData;
 }
 
-/**
- * Get face data for a specific frame with optional interpolation
+/**
+ * Get face data for a specific frame with optional interpolation
  */
 function getFaceDataForFrame(frames, targetFrame, enableInterpolation) {
   if (!frames || frames.length === 0) return null;
@@ -285,8 +285,8 @@ function getFaceDataForFrame(frames, targetFrame, enableInterpolation) {
   };
 }
 
-/**
- * Preset configurations for common aspect ratios
+/**
+ * Preset configurations for common aspect ratios
  */
 export var ASPECT_RATIO_PRESETS = {
   LANDSCAPE: {
@@ -303,17 +303,17 @@ export var ASPECT_RATIO_PRESETS = {
   }
 };
 
-/**
- * Calculate face-centered object-position values
- * @param {Object} params - Configuration object
- * @param {Object} params.faceMetadata - Face detection metadata
- * @param {number} params.targetWidth - Target video width (1920 for landscape, 1080 for square/portrait)
- * @param {number} params.targetHeight - Target video height (1080 for landscape/square, 1920 for portrait)
- * @param {number} params.currentFrame - Current frame number (optional, will use useCurrentFrame if not provided)
- * @param {boolean} params.enableInterpolation - Whether to interpolate between frames
- * @param {boolean} params.useAveragePosition - Whether to use average face position for entire video duration
- * @param {boolean} params.centerHorizontally - Whether to only center horizontally (X axis), not vertically (Y axis)
- * @returns {Object} Object-position styles and debug info
+/**
+ * Calculate face-centered object-position values
+ * @param {Object} params - Configuration object
+ * @param {Object} params.faceMetadata - Face detection metadata
+ * @param {number} params.targetWidth - Target video width (1920 for landscape, 1080 for square/portrait)
+ * @param {number} params.targetHeight - Target video height (1080 for landscape/square, 1920 for portrait)
+ * @param {number} params.currentFrame - Current frame number (optional, will use useCurrentFrame if not provided)
+ * @param {boolean} params.enableInterpolation - Whether to interpolate between frames
+ * @param {boolean} params.useAveragePosition - Whether to use average face position for entire video duration
+ * @param {boolean} params.centerHorizontally - Whether to only center horizontally (X axis), not vertically (Y axis)
+ * @returns {Object} Object-position styles and debug info
  */
 export var calculateFaceCenteredObjectPosition = function calculateFaceCenteredObjectPosition(_ref2) {
   var _faceMetadata$metadat4, _faceMetadata$metadat5;
@@ -435,8 +435,8 @@ export var calculateFaceCenteredObjectPosition = function calculateFaceCenteredO
   };
 };
 
-/**
- * Helper function to get transforms for specific aspect ratios
+/**
+ * Helper function to get transforms for specific aspect ratios
  */
 export var getFaceCenteredTransformsForAspectRatio = function getFaceCenteredTransformsForAspectRatio(aspectRatio, faceMetadata) {
   var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
@@ -451,8 +451,8 @@ export var getFaceCenteredTransformsForAspectRatio = function getFaceCenteredTra
   }, options));
 };
 
-/**
- * Helper function to get object-position for specific aspect ratios
+/**
+ * Helper function to get object-position for specific aspect ratios
  */
 export var getFaceCenteredObjectPositionForAspectRatio = function getFaceCenteredObjectPositionForAspectRatio(aspectRatio, faceMetadata) {
   var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};