@mevdragon/vidfarm-devcli 0.2.13 → 0.3.0

package/dist/src/composition-runtime.js

@@ -1,581 +0,0 @@
-// Runtime script injected into composition iframes so the studio editor can
-// see a `__player` adapter and drive playback. The script lives in src/ so the
-// API lambda can inject it into both draft and fork composition HTML before
-// serving it to the editor iframe.
-//
-// IMPORTANT: this body is executed inside the iframe, NOT in the Node API
-// runtime. Keep it browser-only (no node imports, no top-level await).
-export const COMPOSITION_RUNTIME_SCRIPT_BODY = `
-(() => {
-  const root = document.querySelector("[data-composition-id]");
-  const duration = Number(root?.getAttribute("data-duration") || 0);
-  let time = 0;
-  let playing = false;
-  let playbackRate = 1;
-  let previewMuted = false;
-  let raf = 0;
-  let last = 0;
-  const backingVideo = document.querySelector("[data-vf-playback-source]");
-  const initialMuted = new WeakMap();
-  if (backingVideo instanceof HTMLMediaElement) {
-    initialMuted.set(backingVideo, backingVideo.muted || backingVideo.hasAttribute("muted"));
-  }
-  let clips = [];
-  let activeVideoProxyKey = null;
-  let activeVideoProxyNode = null;
-  let hasVideoProxies = false;
-  const activeMedia = new WeakSet();
-  const mediaStateKeys = new WeakMap();
-  const visibilityStates = new WeakMap();
-
-  function clampTime(nextTime) {
-    const safe = Number(nextTime);
-    if (!Number.isFinite(safe)) return 0;
-    return Math.max(0, Math.min(duration, safe));
-  }
-
-  function readNumberAttr(node, names, fallback = 0) {
-    for (const name of names) {
-      const raw = node.getAttribute(name);
-      if (raw !== null) {
-        const value = Number(raw);
-        return Number.isFinite(value) ? value : fallback;
-      }
-    }
-    return fallback;
-  }
-
-  function readTiming(clip) {
-    const start = readNumberAttr(clip, ["data-start"], 0);
-    const clipDuration = readNumberAttr(clip, ["data-duration"], 0);
-    const mediaStart = readNumberAttr(clip, ["data-playback-start", "data-media-start"], 0);
-    return { start, duration: clipDuration, end: start + clipDuration, mediaStart };
-  }
-
-  function refreshClips() {
-    clips = Array.from(document.querySelectorAll("[data-start]")).filter((node) => node !== root);
-    for (const clip of clips) {
-      if (clip instanceof HTMLMediaElement && !initialMuted.has(clip)) {
-        initialMuted.set(clip, clip.muted || clip.hasAttribute("muted"));
-      }
-      if (clip instanceof HTMLMediaElement) {
-        clip.preload = "auto";
-        if (clip.readyState === 0) {
-          try { clip.load(); } catch {}
-        }
-      }
-    }
-    if (backingVideo instanceof HTMLMediaElement) {
-      backingVideo.preload = "auto";
-      if (backingVideo.readyState === 0) {
-        try { backingVideo.load(); } catch {}
-      }
-    }
-    activeVideoProxyKey = null;
-    activeVideoProxyNode = null;
-    hasVideoProxies = clips.some((clip) => clip instanceof Element && clip.getAttribute("data-vf-timeline-proxy") === "video");
-    apply(time, { forceSeek: true });
-  }
-
-  function applyMediaState(clip) {
-    const volume = Number(clip.getAttribute("data-volume") || 1);
-    const nextMuted = previewMuted || initialMuted.get(clip) === true;
-    const stateKey = playbackRate + "|" + volume + "|" + nextMuted;
-    if (mediaStateKeys.get(clip) === stateKey) return;
-    mediaStateKeys.set(clip, stateKey);
-    if (Number.isFinite(volume)) clip.volume = Math.max(0, Math.min(1, volume));
-    clip.muted = nextMuted;
-    try { clip.playbackRate = playbackRate; } catch {}
-    try { clip.defaultPlaybackRate = playbackRate; } catch {}
-    try {
-      if ("preservesPitch" in clip) clip.preservesPitch = true;
-      if ("mozPreservesPitch" in clip) clip.mozPreservesPitch = true;
-      if ("webkitPreservesPitch" in clip) clip.webkitPreservesPitch = true;
-    } catch {}
-  }
-
-  function setVisibility(node, active) {
-    const next = active ? "visible" : "hidden";
-    if (visibilityStates.get(node) === next) return;
-    visibilityStates.set(node, next);
-    node.style.visibility = next;
-  }
-
-  function setPlaybackRate(nextRate) {
-    const next = Number(nextRate);
-    playbackRate = Number.isFinite(next) && next > 0 ? Math.max(0.05, Math.min(8, next)) : 1;
-    for (const clip of clips) {
-      if (clip instanceof HTMLMediaElement) applyMediaState(clip);
-    }
-    if (backingVideo instanceof HTMLMediaElement) applyMediaState(backingVideo);
-  }
-
-  function setMuted(nextMuted) {
-    previewMuted = Boolean(nextMuted);
-    for (const clip of clips) {
-      if (clip instanceof HTMLMediaElement) applyMediaState(clip);
-    }
-    if (backingVideo instanceof HTMLMediaElement) applyMediaState(backingVideo);
-  }
-
-  function clipKey(clip) {
-    return clip.getAttribute("data-hf-id") || clip.id || clip.getAttribute("data-label") || "";
-  }
-
-  function ensurePlaying(media) {
-    if (!playing) {
-      if (!media.paused) media.pause();
-      activeMedia.delete(media);
-      return;
-    }
-    if (!activeMedia.has(media) || media.paused) {
-      activeMedia.add(media);
-      void media.play().catch(() => {});
-    }
-  }
-
-  function pauseInactiveMedia(media) {
-    activeMedia.delete(media);
-    if (!media.paused) media.pause();
-  }
-
-  function seekMedia(media, target, forceSeek, driftLimit) {
-    if (!Number.isFinite(target)) return;
-    if (forceSeek || Math.abs(media.currentTime - target) > driftLimit) {
-      try { media.currentTime = Math.max(0, target); } catch {}
-    }
-  }
-
-  function apply(nextTime, options = {}) {
-    const forceSeek = Boolean(options.forceSeek);
-    const fromClock = Boolean(options.fromClock);
-    time = clampTime(nextTime);
-    let activeVideoProxy = null;
-    for (const clip of clips) {
-      const timing = readTiming(clip);
-      const active = time >= timing.start && time < timing.end;
-      if (clip instanceof HTMLElement && !(clip instanceof HTMLAudioElement)) {
-        if (clip.getAttribute("data-vf-timeline-proxy") === "video") {
-          if (active) activeVideoProxy = clip;
-        } else {
-          setVisibility(clip, active);
-        }
-      }
-      if (clip instanceof HTMLMediaElement) {
-        applyMediaState(clip);
-        if (active) {
-          const target = Math.max(0, timing.mediaStart + time - timing.start);
-          const enteringClip = !activeMedia.has(clip);
-          seekMedia(clip, target, forceSeek || enteringClip, playing ? 0.75 : 0.08);
-          if (playing) {
-            ensurePlaying(clip);
-          } else {
-            pauseInactiveMedia(clip);
-          }
-        } else {
-          pauseInactiveMedia(clip);
-        }
-      }
-    }
-    if (backingVideo instanceof HTMLVideoElement) {
-      applyMediaState(backingVideo);
-      const shouldShowBackingVideo = !hasVideoProxies || Boolean(activeVideoProxy);
-      backingVideo.style.visibility = shouldShowBackingVideo ? "visible" : "hidden";
-      if (activeVideoProxy) {
-        const nextProxyKey = clipKey(activeVideoProxy);
-        const proxyChanged = nextProxyKey !== activeVideoProxyKey;
-        activeVideoProxyKey = nextProxyKey;
-        activeVideoProxyNode = activeVideoProxy;
-        const timing = readTiming(activeVideoProxy);
-        const target = Math.max(0, timing.mediaStart + time - timing.start);
-        const driftLimit = playing ? (fromClock ? 0.75 : 2.0) : 0.08;
-        const drifting = !backingVideo.seeking && Math.abs(backingVideo.currentTime - target) > driftLimit;
-        if (forceSeek || proxyChanged || !playing || drifting) {
-          seekMedia(backingVideo, target, true, 0.08);
-        }
-      } else {
-        activeVideoProxyKey = null;
-        activeVideoProxyNode = null;
-        if (!hasVideoProxies && !fromClock) seekMedia(backingVideo, time, forceSeek, playing ? 1.25 : 0.08);
-      }
-      if (playing && shouldShowBackingVideo) {
-        ensurePlaying(backingVideo);
-      } else {
-        pauseInactiveMedia(backingVideo);
-      }
-    }
-  }
-
-  function tick(now) {
-    if (!playing) return;
-    if (!last) last = now;
-    const delta = ((now - last) / 1000) * playbackRate;
-    const next = time + delta;
-    last = now;
-    apply(next >= duration ? duration : next, { fromClock: true });
-    if (time >= duration) {
-      playing = false;
-      for (const clip of clips) {
-        if (clip instanceof HTMLMediaElement) pauseInactiveMedia(clip);
-      }
-      if (backingVideo instanceof HTMLMediaElement) pauseInactiveMedia(backingVideo);
-      return;
-    }
-    raf = requestAnimationFrame(tick);
-  }
-
-  window.__player = {
-    play() {
-      if (playing) return;
-      if (time >= duration) time = 0;
-      playing = true;
-      last = 0;
-      apply(time, { forceSeek: true });
-      cancelAnimationFrame(raf);
-      raf = requestAnimationFrame(tick);
-    },
-    pause() {
-      playing = false;
-      cancelAnimationFrame(raf);
-      for (const clip of clips) {
-        if (clip instanceof HTMLMediaElement) pauseInactiveMedia(clip);
-      }
-      if (backingVideo instanceof HTMLMediaElement) pauseInactiveMedia(backingVideo);
-    },
-    seek(nextTime, options = {}) {
-      const shouldKeepPlaying = playing || options.keepPlaying === true;
-      playing = shouldKeepPlaying;
-      if (!shouldKeepPlaying) cancelAnimationFrame(raf);
-      apply(nextTime, { forceSeek: true });
-      if (shouldKeepPlaying) {
-        last = 0;
-        cancelAnimationFrame(raf);
-        raf = requestAnimationFrame(tick);
-      }
-    },
-    getTime() {
-      return time;
-    },
-    getDuration() {
-      return duration;
-    },
-    isPlaying() {
-      return playing;
-    },
-    setPlaybackRate,
-    getPlaybackRate() {
-      return playbackRate;
-    },
-    setMuted,
-    refreshClips
-  };
-
-  refreshClips();
-  if (backingVideo instanceof HTMLMediaElement) {
-    backingVideo.addEventListener("loadedmetadata", () => {
-      if (!playing) apply(time, { forceSeek: true });
-    });
-  }
-
-  window.addEventListener("message", (event) => {
-    const data = event.data || {};
-    if (data.type !== "control" && data.source !== "hf-parent") return;
-    if (data.action === "play") {
-      window.__player.play();
-    }
-    if (data.action === "pause" || data.action === "stop-media") {
-      window.__player.pause();
-    }
-    if (data.action === "seek") {
-      const nextTime = Number.isFinite(Number(data.time))
-        ? Number(data.time)
-        : Number.isFinite(Number(data.frame))
-          ? Number(data.frame) / 30
-          : Number.isFinite(Number(data.payload?.time))
-            ? Number(data.payload.time)
-            : time;
-      window.__player.seek(nextTime);
-    }
-    if (data.action === "set-playback-rate") {
-      setPlaybackRate(data.playbackRate ?? data.payload?.playbackRate);
-    }
-    if (data.action === "set-muted") {
-      setMuted(data.muted ?? data.payload?.muted);
-    }
-  });
-
-  function selectTargetFromEvent(event) {
-    const handle = event.target instanceof Element
-      ? event.target.closest("[data-vf-frame-handle]")
-      : null;
-    const handleTargetId = handle?.getAttribute("data-vf-target-id") || null;
-    if (handleTargetId) {
-      return document.querySelector("[data-hf-id='" + CSS.escape(handleTargetId) + "'], #" + CSS.escape(handleTargetId));
-    }
-    return event.target instanceof Element
-      ? event.target.closest("[data-start]")
-      : null;
-  }
-
-  function postSelectedLayer(event) {
-    const target = selectTargetFromEvent(event);
-    const rawId = target?.getAttribute("data-hf-id") || target?.id || null;
-    const id = rawId === "source-video" ? null : rawId;
-    window.parent?.postMessage({
-      source: "vidfarm-composition",
-      action: "select-layer",
-      id
-    }, "*");
-  }
-
-  function postPreviewContextMenu(event) {
-    event.preventDefault();
-    const root = document.querySelector("[data-composition-id]");
-    const rect = root instanceof HTMLElement ? root.getBoundingClientRect() : null;
-    const target = selectTargetFromEvent(event);
-    const rawId = target?.getAttribute("data-hf-id") || target?.id || null;
-    const id = rawId === "source-video" ? null : rawId;
-    const x = rect ? ((event.clientX - rect.left) / Math.max(1, rect.width)) * 100 : 12;
-    const y = rect ? ((event.clientY - rect.top) / Math.max(1, rect.height)) * 100 : 70;
-    window.parent?.postMessage({
-      source: "vidfarm-composition",
-      action: "preview-context-menu",
-      id,
-      clientX: event.clientX,
-      clientY: event.clientY,
-      time,
-      frame: {
-        x: Math.max(0, Math.min(95, x)),
-        y: Math.max(0, Math.min(95, y)),
-        width: 42,
-        height: 12
-      }
-    }, "*");
-  }
-
-  function frameFromNode(node) {
-    return {
-      x: Number.parseFloat(node.style.left || "0") || 0,
-      y: Number.parseFloat(node.style.top || "0") || 0,
-      width: Number.parseFloat(node.style.width || "100") || 100,
-      height: Number.parseFloat(node.style.height || "100") || 100,
-      fontSize: Number.parseFloat(node.style.fontSize || "18") || 18
-    };
-  }
-
-  function isVisualFrameTarget(node) {
-    if (!(node instanceof HTMLElement) || node instanceof HTMLAudioElement) return false;
-    const id = node.getAttribute("data-hf-id") || node.id || "";
-    return id !== "source-video";
-  }
-
-  function isTextFrameTarget(node) {
-    return node instanceof HTMLElement &&
-      !(node instanceof HTMLAudioElement) &&
-      !(node instanceof HTMLVideoElement) &&
-      !(node instanceof HTMLImageElement);
-  }
-
-  function syncRuntimeFrameControls(node) {
-    if (!isVisualFrameTarget(node)) return;
-    const root = document.querySelector("[data-composition-id]");
-    if (!(root instanceof HTMLElement)) return;
-    const targetId = node.getAttribute("data-hf-id") || node.id || "";
-    if (!targetId) return;
-    let ring = document.querySelector("[data-vf-selection-ring='true']");
-    if (!(ring instanceof HTMLElement)) {
-      ring = document.createElement("div");
-      ring.setAttribute("data-vf-selection-ring", "true");
-      root.append(ring);
-    }
-    ring.style.display = "block";
-    ring.style.position = "absolute";
-    ring.style.left = node.style.left || "0%";
-    ring.style.top = node.style.top || "0%";
-    ring.style.width = node.style.width || "100%";
-    ring.style.height = node.style.height || "100%";
-    ring.style.borderRadius = node.style.borderRadius || "0";
-    ring.style.zIndex = "9999";
-    ring.style.pointerEvents = "auto";
-    ring.style.cursor = "grab";
-    ring.style.border = "1px dashed #F2CD46";
-    ring.style.boxShadow = "0 0 0 2px #118df2";
-    ring.setAttribute("data-vf-frame-handle", "move");
-    ring.setAttribute("data-vf-target-id", targetId);
-    for (const handle of Array.from(ring.querySelectorAll("[data-vf-frame-handle]"))) {
-      if (handle !== ring) handle.remove();
-    }
-    for (const [mode, cssText] of [
-      ["top-left", "left:-7px;top:-7px;cursor:nwse-resize;"],
-      ["top", "top:-7px;left:50%;transform:translateX(-50%);cursor:ns-resize;"],
-      ["top-right", "right:-7px;top:-7px;cursor:nesw-resize;"],
-      ["right", "right:-7px;top:50%;transform:translateY(-50%);cursor:ew-resize;"],
-      ["bottom-right", "right:-7px;bottom:-7px;cursor:nwse-resize;"],
-      ["bottom", "bottom:-7px;left:50%;transform:translateX(-50%);cursor:ns-resize;"],
-      ["bottom-left", "left:-7px;bottom:-7px;cursor:nesw-resize;"],
-      ["left", "left:-7px;top:50%;transform:translateY(-50%);cursor:ew-resize;"]
-    ]) {
-      const handle = document.createElement("span");
-      handle.setAttribute("data-vf-frame-handle", mode);
-      handle.setAttribute("data-vf-target-id", targetId);
-      handle.style.cssText = [
-        "position:absolute",
-        "display:block",
-        "width:14px",
-        "height:14px",
-        "box-sizing:border-box",
-        "border-radius:999px",
-        "border:2px solid #0b0d0a",
-        "background:#F2CD46",
-        "box-shadow:0 0 0 2px rgba(242,205,70,0.32),0 1px 4px rgba(0,0,0,0.38)",
-        "pointer-events:auto",
-        "touch-action:none",
-        cssText
-      ].join(";");
-      ring.append(handle);
-    }
-  }
-
-  function applyFrameToNode(node, frame) {
-    node.style.left = frame.x + "%";
-    node.style.top = frame.y + "%";
-    node.style.width = frame.width + "%";
-    node.style.height = frame.height + "%";
-    if (Number.isFinite(frame.fontSize)) {
-      node.style.fontSize = frame.fontSize + "px";
-    }
-    syncRuntimeFrameControls(node);
-  }
-
-  function postFrameDraft(node, phase) {
-    const id = node.getAttribute("data-hf-id") || node.id || null;
-    if (!id) return;
-    window.parent?.postMessage({
-      source: "vidfarm-composition",
-      action: "visual-frame-draft",
-      phase,
-      id,
-      frame: frameFromNode(node)
-    }, "*");
-  }
-
-  let visualFrameDrag = null;
-
-  function beginVisualFrameDrag(event) {
-    if (event.button !== 0) return;
-    const handle = event.target instanceof Element
-      ? event.target.closest("[data-vf-frame-handle]")
-      : null;
-    const handleTargetId = handle?.getAttribute("data-vf-target-id") || null;
-    const target = handleTargetId
-      ? document.querySelector("[data-hf-id='" + CSS.escape(handleTargetId) + "'], #" + CSS.escape(handleTargetId))
-      : event.target instanceof Element
-        ? event.target.closest("[data-start]")
-        : null;
-    if (!isVisualFrameTarget(target)) return;
-    const root = document.querySelector("[data-composition-id]");
-    if (!(root instanceof HTMLElement)) return;
-    const rootRect = root.getBoundingClientRect();
-    event.preventDefault();
-    event.stopPropagation();
-    postSelectedLayer(event);
-    visualFrameDrag = {
-      node: target,
-      mode: handle?.getAttribute("data-vf-frame-handle") || "move",
-      startX: event.clientX,
-      startY: event.clientY,
-      rootWidth: Math.max(1, rootRect.width),
-      rootHeight: Math.max(1, rootRect.height),
-      frame: frameFromNode(target),
-      moved: false
-    };
-    syncRuntimeFrameControls(target);
-    target.style.cursor = "grabbing";
-    postFrameDraft(target, "start");
-  }
-
-  function updateVisualFrameDrag(event) {
-    if (!visualFrameDrag) return;
-    const drag = visualFrameDrag;
-    const dx = ((event.clientX - drag.startX) / drag.rootWidth) * 100;
-    const dy = ((event.clientY - drag.startY) / drag.rootHeight) * 100;
-    if (!drag.moved && Math.hypot(event.clientX - drag.startX, event.clientY - drag.startY) < 2) return;
-    drag.moved = true;
-    event.preventDefault();
-    const next = { ...drag.frame };
-    if (drag.mode === "move") {
-      next.x = Math.max(0, Math.min(100 - drag.frame.width, drag.frame.x + dx));
-      next.y = Math.max(0, Math.min(100 - drag.frame.height, drag.frame.y + dy));
-    }
-    if (drag.mode === "left" || drag.mode === "top-left" || drag.mode === "bottom-left") {
-      const nextX = Math.max(0, Math.min(drag.frame.x + drag.frame.width - 1, drag.frame.x + dx));
-      next.x = nextX;
-      next.width = Math.max(1, Math.min(100 - nextX, drag.frame.width + (drag.frame.x - nextX)));
-    }
-    if (drag.mode === "right" || drag.mode === "top-right" || drag.mode === "bottom-right") {
-      next.width = Math.max(1, Math.min(100 - drag.frame.x, drag.frame.width + dx));
-    }
-    if (drag.mode === "top" || drag.mode === "top-left" || drag.mode === "top-right") {
-      const nextY = Math.max(0, Math.min(drag.frame.y + drag.frame.height - 1, drag.frame.y + dy));
-      next.y = nextY;
-      next.height = Math.max(1, Math.min(100 - nextY, drag.frame.height + (drag.frame.y - nextY)));
-    }
-    if (drag.mode === "bottom" || drag.mode === "bottom-left" || drag.mode === "bottom-right") {
-      next.height = Math.max(1, Math.min(100 - drag.frame.y, drag.frame.height + dy));
-    }
-    if (
-      isTextFrameTarget(drag.node) &&
-      ["top-left", "top-right", "bottom-left", "bottom-right"].includes(drag.mode)
-    ) {
-      const widthScale = next.width / Math.max(1, drag.frame.width);
-      const heightScale = next.height / Math.max(1, drag.frame.height);
-      const scale = Math.sqrt(Math.max(0.05, widthScale * heightScale));
-      next.fontSize = Math.max(8, Math.min(180, (drag.frame.fontSize || 18) * scale));
-    }
-    applyFrameToNode(drag.node, next);
-    postFrameDraft(drag.node, "move");
-  }
-
-  function endVisualFrameDrag() {
-    if (!visualFrameDrag) return;
-    visualFrameDrag.node.style.cursor = "";
-    postFrameDraft(visualFrameDrag.node, visualFrameDrag.moved ? "end" : "tap");
-    visualFrameDrag = null;
-  }
-
-  function hoverVisualFrameTarget(event) {
-    const handle = event.target instanceof Element
-      ? event.target.closest("[data-vf-frame-handle]")
-      : null;
-    const handleTargetId = handle?.getAttribute("data-vf-target-id") || null;
-    const target = handleTargetId
-      ? document.querySelector("[data-hf-id='" + CSS.escape(handleTargetId) + "'], #" + CSS.escape(handleTargetId))
-      : event.target instanceof Element
-        ? event.target.closest("[data-start]")
-        : null;
-    if (!isVisualFrameTarget(target)) return;
-    target.style.cursor = "grab";
-    syncRuntimeFrameControls(target);
-  }
-
-  document.addEventListener("pointerover", hoverVisualFrameTarget, true);
-  document.addEventListener("pointerdown", beginVisualFrameDrag, true);
-  document.addEventListener("pointermove", updateVisualFrameDrag, { passive: false });
-  document.addEventListener("pointerup", endVisualFrameDrag);
-  document.addEventListener("pointercancel", endVisualFrameDrag);
-  document.addEventListener("pointerdown", postSelectedLayer);
-  document.addEventListener("click", postSelectedLayer);
-  document.addEventListener("contextmenu", postPreviewContextMenu, true);
-
-  try {
-    console.info("[hf-runtime] ready", {
-      compositionId: root?.getAttribute("data-composition-id"),
-      duration,
-      clipCount: document.querySelectorAll("[data-start]").length
-    });
-  } catch {}
-
-  apply(0);
-})();
-`;
-//# sourceMappingURL=composition-runtime.js.map

package/dist/src/composition-runtime.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"composition-runtime.js","sourceRoot":"","sources":["../../src/composition-runtime.ts"],"names":[],"mappings":"AAAA,4EAA4E;AAC5E,+EAA+E;AAC/E,4EAA4E;AAC5E,mCAAmC;AACnC,EAAE;AACF,0EAA0E;AAC1E,uEAAuE;AACvE,MAAM,CAAC,MAAM,+BAA+B,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4jB9C,CAAC"}