@clockworkdog/cogs-client 3.1.3 → 3.2.0

package/dist/VideoPlayer.d.ts

@@ -0,0 +1,49 @@
+import { MediaObjectFit } from '.';
+import CogsConnection from './CogsConnection';
+import MediaClipStateMessage from './types/MediaClipStateMessage';
+import { VideoState } from './types/VideoState';
+type EventTypes = {
+    state: VideoState;
+    videoClipState: MediaClipStateMessage;
+};
+export default class VideoPlayer {
+    private cogsConnection;
+    private eventTarget;
+    private globalVolume;
+    private videoClipPlayers;
+    private activeClip?;
+    private pendingClip?;
+    private parentElement;
+    private sinkId;
+    constructor(cogsConnection: CogsConnection<any>, parentElement?: HTMLElement);
+    setParentElement(parentElement: HTMLElement): void;
+    resetParentElement(): void;
+    setGlobalVolume(globalVolume: number): void;
+    playVideoClip(path: string, { playId, volume, loop, fit }: {
+        playId: string;
+        volume: number;
+        loop: boolean;
+        fit: MediaObjectFit;
+    }): void;
+    pauseVideoClip(): void;
+    stopVideoClip(): void;
+    setVideoClipVolume({ volume }: {
+        volume: number;
+    }): void;
+    setVideoClipFit({ fit }: {
+        fit: MediaObjectFit;
+    }): void;
+    private handleStoppedClip;
+    private updateVideoClipPlayer;
+    setAudioSink(sinkId: string): void;
+    private updateConfig;
+    private notifyStateListeners;
+    private notifyClipStateListeners;
+    addEventListener<EventName extends keyof EventTypes>(type: EventName, listener: (ev: CustomEvent<EventTypes[EventName]>) => void, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<EventName extends keyof EventTypes>(type: EventName, listener: (ev: CustomEvent<EventTypes[EventName]>) => void, options?: boolean | EventListenerOptions): void;
+    private dispatchEvent;
+    private createVideoElement;
+    private createClipPlayer;
+    private unloadClip;
+}
+export {};

package/dist/VideoPlayer.js

@@ -0,0 +1,394 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const VideoState_1 = require("./types/VideoState");
+const DEFAULT_PARENT_ELEMENT = document.body;
+class VideoPlayer {
+    constructor(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    cogsConnection, parentElement = DEFAULT_PARENT_ELEMENT) {
+        this.cogsConnection = cogsConnection;
+        this.eventTarget = new EventTarget();
+        this.globalVolume = 1;
+        this.videoClipPlayers = {};
+        this.sinkId = '';
+        this.parentElement = parentElement;
+        // Send the current status of each clip to COGS
+        this.addEventListener('videoClipState', ({ detail }) => {
+            cogsConnection.sendMediaClipState(detail);
+        });
+        // Listen for video control messages
+        cogsConnection.addEventListener('message', ({ message }) => {
+            switch (message.type) {
+                case 'media_config_update':
+                    this.setGlobalVolume(message.globalVolume);
+                    if (message.audioOutput !== undefined) {
+                        const sinkId = cogsConnection.getAudioSinkId(message.audioOutput);
+                        this.setAudioSink(sinkId !== null && sinkId !== void 0 ? sinkId : '');
+                    }
+                    this.updateConfig(message.files);
+                    break;
+                case 'video_play':
+                    this.playVideoClip(message.file, {
+                        playId: message.playId,
+                        volume: message.volume,
+                        loop: Boolean(message.loop),
+                        fit: message.fit,
+                    });
+                    break;
+                case 'video_pause':
+                    this.pauseVideoClip();
+                    break;
+                case 'video_stop':
+                    this.stopVideoClip();
+                    break;
+                case 'video_set_volume':
+                    this.setVideoClipVolume({ volume: message.volume });
+                    break;
+                case 'video_set_fit':
+                    this.setVideoClipFit({ fit: message.fit });
+                    break;
+            }
+        });
+        // On connection, send the current playing state of all clips
+        // (Usually empty unless websocket is reconnecting)
+        const sendInitialClipStates = () => {
+            const files = Object.entries(this.videoClipPlayers).map(([file, player]) => {
+                const status = !player.videoElement.paused
+                    ? 'playing'
+                    : player.videoElement.currentTime === 0 || player.videoElement.currentTime === player.videoElement.duration
+                        ? 'paused'
+                        : 'stopped';
+                return [file, status];
+            });
+            cogsConnection.sendInitialMediaClipStates({ mediaType: 'video', files });
+        };
+        cogsConnection.addEventListener('open', sendInitialClipStates);
+        sendInitialClipStates();
+    }
+    setParentElement(parentElement) {
+        this.parentElement = parentElement;
+        Object.values(this.videoClipPlayers).forEach((clipPlayer) => {
+            parentElement.appendChild(clipPlayer.videoElement);
+        });
+    }
+    resetParentElement() {
+        this.setParentElement(DEFAULT_PARENT_ELEMENT);
+    }
+    setGlobalVolume(globalVolume) {
+        Object.values(this.videoClipPlayers).forEach((clipPlayer) => {
+            setVideoElementVolume(clipPlayer.videoElement, clipPlayer.volume * globalVolume);
+        });
+        this.globalVolume = globalVolume;
+        this.notifyStateListeners();
+    }
+    playVideoClip(path, { playId, volume, loop, fit }) {
+        var _a;
+        if (!this.videoClipPlayers[path]) {
+            this.videoClipPlayers[path] = this.createClipPlayer(path, { preload: 'none', ephemeral: true, fit });
+        }
+        // Check if there's already a pending clip, which has now been superseded and abort the play operation
+        if (this.pendingClip) {
+            this.updateVideoClipPlayer(this.pendingClip.path, (clipPlayer) => {
+                clipPlayer.videoElement.load(); // Resets the media element
+                return clipPlayer;
+            });
+        }
+        // New pending clip is video being requested
+        if (((_a = this.activeClip) === null || _a === void 0 ? void 0 : _a.path) !== path) {
+            this.pendingClip = { path, playId, actionOncePlaying: 'play' };
+        }
+        // Setup and play the pending clip's player
+        this.updateVideoClipPlayer(path, (clipPlayer) => {
+            clipPlayer.volume = volume;
+            setVideoElementVolume(clipPlayer.videoElement, volume * this.globalVolume);
+            clipPlayer.videoElement.loop = loop;
+            clipPlayer.videoElement.style.objectFit = fit;
+            if (clipPlayer.videoElement.currentTime === clipPlayer.videoElement.duration) {
+                clipPlayer.videoElement.currentTime = 0;
+            }
+            clipPlayer.videoElement.play();
+            // Display right away if there's currently no active clip
+            if (!this.activeClip) {
+                clipPlayer.videoElement.style.display = 'block';
+            }
+            return clipPlayer;
+        });
+    }
+    pauseVideoClip() {
+        // Pending clip should be paused when it loads and becomes active
+        if (this.pendingClip) {
+            this.pendingClip.actionOncePlaying = 'pause';
+        }
+        // Pause the currently active clip
+        if (this.activeClip) {
+            const { playId, path } = this.activeClip;
+            this.updateVideoClipPlayer(path, (clipPlayer) => {
+                var _a;
+                (_a = clipPlayer.videoElement) === null || _a === void 0 ? void 0 : _a.pause();
+                return clipPlayer;
+            });
+            this.notifyClipStateListeners(playId, path, 'paused');
+        }
+    }
+    stopVideoClip() {
+        // Pending clip should be stopped when it loads and becomes active
+        if (this.pendingClip) {
+            this.pendingClip.actionOncePlaying = 'stop';
+        }
+        // Stop the currently active clip
+        if (this.activeClip) {
+            this.handleStoppedClip(this.activeClip.path);
+        }
+    }
+    setVideoClipVolume({ volume }) {
+        var _a, _b;
+        // If there is a pending clip, this is latest to have been played so update its volume
+        const clipToUpdate = (_b = (_a = this.pendingClip) !== null && _a !== void 0 ? _a : this.activeClip) !== null && _b !== void 0 ? _b : undefined;
+        if (!clipToUpdate) {
+            return;
+        }
+        if (!(volume >= 0 && volume <= 1)) {
+            console.warn('Invalid volume', volume);
+            return;
+        }
+        this.updateVideoClipPlayer(clipToUpdate.path, (clipPlayer) => {
+            if (clipPlayer.videoElement) {
+                clipPlayer.volume = volume;
+                setVideoElementVolume(clipPlayer.videoElement, volume * this.globalVolume);
+            }
+            return clipPlayer;
+        });
+    }
+    setVideoClipFit({ fit }) {
+        var _a, _b;
+        // If there is a pending clip, this is latest to have been played so update its fit
+        const clipToUpdate = (_b = (_a = this.pendingClip) !== null && _a !== void 0 ? _a : this.activeClip) !== null && _b !== void 0 ? _b : undefined;
+        if (!clipToUpdate) {
+            return;
+        }
+        this.updateVideoClipPlayer(clipToUpdate.path, (clipPlayer) => {
+            if (clipPlayer.videoElement) {
+                clipPlayer.videoElement.style.objectFit = fit;
+            }
+            return clipPlayer;
+        });
+    }
+    handleStoppedClip(path) {
+        var _a;
+        if (!this.activeClip || this.activeClip.path !== path) {
+            return;
+        }
+        const playId = this.activeClip.playId;
+        // Once an ephemeral clip stops, cleanup and remove the player
+        if ((_a = this.videoClipPlayers[this.activeClip.path]) === null || _a === void 0 ? void 0 : _a.config.ephemeral) {
+            this.unloadClip(path);
+        }
+        this.activeClip = undefined;
+        this.updateVideoClipPlayer(path, (clipPlayer) => {
+            clipPlayer.videoElement.pause();
+            clipPlayer.videoElement.currentTime = 0;
+            clipPlayer.videoElement.style.display = 'none';
+            return clipPlayer;
+        });
+        this.notifyClipStateListeners(playId, path, 'stopped');
+    }
+    updateVideoClipPlayer(path, update) {
+        if (this.videoClipPlayers[path]) {
+            const newPlayer = update(this.videoClipPlayers[path]);
+            if (newPlayer) {
+                this.videoClipPlayers[path] = newPlayer;
+            }
+            else {
+                delete this.videoClipPlayers[path];
+            }
+            this.notifyStateListeners();
+        }
+    }
+    setAudioSink(sinkId) {
+        for (const clipPlayer of Object.values(this.videoClipPlayers)) {
+            setPlayerSinkId(clipPlayer, sinkId);
+        }
+        this.sinkId = sinkId;
+    }
+    updateConfig(newPaths) {
+        const newVideoPaths = Object.fromEntries(Object.entries(newPaths).filter(([, { type }]) => type === 'video' || !type));
+        const previousClipPlayers = this.videoClipPlayers;
+        this.videoClipPlayers = (() => {
+            const clipPlayers = { ...previousClipPlayers };
+            const removedClips = Object.keys(previousClipPlayers).filter((previousPath) => !(previousPath in newVideoPaths));
+            removedClips.forEach((path) => {
+                var _a, _b;
+                if (((_a = this.activeClip) === null || _a === void 0 ? void 0 : _a.path) === path && ((_b = previousClipPlayers[path]) === null || _b === void 0 ? void 0 : _b.config.ephemeral) === false) {
+                    this.updateVideoClipPlayer(path, (player) => {
+                        player.config = { ...player.config, ephemeral: true };
+                        return player;
+                    });
+                }
+                else {
+                    this.unloadClip(path);
+                    delete clipPlayers[path];
+                }
+            });
+            const addedClips = Object.entries(newVideoPaths).filter(([newFile]) => !previousClipPlayers[newFile]);
+            addedClips.forEach(([path, config]) => {
+                clipPlayers[path] = this.createClipPlayer(path, { ...config, preload: preloadString(config.preload), ephemeral: false, fit: 'contain' });
+            });
+            const updatedClips = Object.entries(previousClipPlayers).filter(([previousPath]) => previousPath in newVideoPaths);
+            updatedClips.forEach(([path, previousClipPlayer]) => {
+                if (previousClipPlayer.config.preload !== newVideoPaths[path].preload) {
+                    this.updateVideoClipPlayer(path, (player) => {
+                        player.config = {
+                            ...player.config,
+                            preload: preloadString(newVideoPaths[path].preload),
+                            ephemeral: false,
+                        };
+                        player.videoElement.preload = player.config.preload;
+                        return player;
+                    });
+                }
+            });
+            return clipPlayers;
+        })();
+        this.notifyStateListeners();
+    }
+    notifyStateListeners() {
+        var _a, _b, _c, _d, _e, _f, _g;
+        const VideoState = {
+            globalVolume: this.globalVolume,
+            isPlaying: this.activeClip ? !((_a = this.videoClipPlayers[this.activeClip.path].videoElement) === null || _a === void 0 ? void 0 : _a.paused) : false,
+            clips: { ...this.videoClipPlayers },
+            activeClip: this.activeClip
+                ? {
+                    path: this.activeClip.path,
+                    state: !((_b = this.videoClipPlayers[this.activeClip.path].videoElement) === null || _b === void 0 ? void 0 : _b.paused) ? VideoState_1.ActiveVideoClipState.Playing : VideoState_1.ActiveVideoClipState.Paused,
+                    loop: (_d = (_c = this.videoClipPlayers[this.activeClip.path].videoElement) === null || _c === void 0 ? void 0 : _c.loop) !== null && _d !== void 0 ? _d : false,
+                    volume: ((_e = this.videoClipPlayers[this.activeClip.path].videoElement) === null || _e === void 0 ? void 0 : _e.muted)
+                        ? 0
+                        : ((_g = (_f = this.videoClipPlayers[this.activeClip.path].videoElement) === null || _f === void 0 ? void 0 : _f.volume) !== null && _g !== void 0 ? _g : 0),
+                }
+                : undefined,
+        };
+        this.dispatchEvent('state', VideoState);
+    }
+    notifyClipStateListeners(playId, file, status) {
+        this.dispatchEvent('videoClipState', { playId, mediaType: 'video', file, status });
+    }
+    // Type-safe wrapper around EventTarget
+    addEventListener(type, listener, options) {
+        this.eventTarget.addEventListener(type, listener, options);
+    }
+    removeEventListener(type, listener, options) {
+        this.eventTarget.removeEventListener(type, listener, options);
+    }
+    dispatchEvent(type, detail) {
+        this.eventTarget.dispatchEvent(new CustomEvent(type, { detail }));
+    }
+    createVideoElement(path, config, { volume }) {
+        const videoElement = document.createElement('video');
+        videoElement.playsInline = true; // Required for iOS
+        videoElement.src = this.cogsConnection.getAssetUrl(path);
+        videoElement.autoplay = false;
+        videoElement.loop = false;
+        setVideoElementVolume(videoElement, volume * this.globalVolume);
+        videoElement.preload = config.preload;
+        videoElement.addEventListener('playing', () => {
+            var _a, _b;
+            // If the clip is still the pending one when it actually start playing, then ensure it is in the correct state
+            if (((_a = this.pendingClip) === null || _a === void 0 ? void 0 : _a.path) === path) {
+                switch (this.pendingClip.actionOncePlaying) {
+                    case 'play': {
+                        // Continue playing, show the video element, and notify listeners
+                        videoElement.style.display = 'block';
+                        this.notifyClipStateListeners(this.pendingClip.playId, path, 'playing');
+                        break;
+                    }
+                    case 'pause': {
+                        // Pause playback, show the video element, and notify listeners
+                        videoElement.style.display = 'block';
+                        videoElement.pause();
+                        this.notifyClipStateListeners(this.pendingClip.playId, path, 'paused');
+                        break;
+                    }
+                    case 'stop': {
+                        // Pause playback, leave the video element hidden, and notify listeners
+                        videoElement.pause();
+                        this.notifyClipStateListeners(this.pendingClip.playId, path, 'stopped');
+                        break;
+                    }
+                }
+                // If there was a previously active clip, then stop it
+                if (this.activeClip) {
+                    this.handleStoppedClip(this.activeClip.path);
+                }
+                this.activeClip = this.pendingClip;
+                this.pendingClip = undefined;
+            }
+            else if (((_b = this.activeClip) === null || _b === void 0 ? void 0 : _b.path) === path) {
+                // If we were the active clip then just notify listeners that we are now playing
+                this.notifyClipStateListeners(this.activeClip.playId, path, 'playing');
+            }
+            else {
+                // Otherwise it shouldn't be playing, like because another clip became pending before we loaded,
+                // so we pause and don't show or notify listeners
+                videoElement.pause();
+            }
+        });
+        videoElement.addEventListener('ended', () => {
+            // Ignore if there's a pending clip, as once that starts playing the active clip will be stopped
+            // Also ignore if the video is set to loop
+            if (!this.pendingClip && !videoElement.loop) {
+                this.handleStoppedClip(path);
+            }
+        });
+        videoElement.style.position = 'absolute';
+        videoElement.style.top = '0';
+        videoElement.style.left = '0';
+        videoElement.style.width = '100%';
+        videoElement.style.height = '100%';
+        videoElement.style.objectFit = config.fit;
+        videoElement.style.display = 'none';
+        this.parentElement.appendChild(videoElement);
+        return videoElement;
+    }
+    createClipPlayer(path, config) {
+        const volume = 1;
+        const player = {
+            config,
+            videoElement: this.createVideoElement(path, config, { volume }),
+            volume,
+        };
+        setPlayerSinkId(player, this.sinkId);
+        return player;
+    }
+    unloadClip(path) {
+        var _a, _b;
+        if (((_a = this.activeClip) === null || _a === void 0 ? void 0 : _a.path) === path) {
+            const playId = this.activeClip.playId;
+            this.activeClip = undefined;
+            this.notifyClipStateListeners(playId, path, 'stopped');
+        }
+        (_b = this.videoClipPlayers[path]) === null || _b === void 0 ? void 0 : _b.videoElement.remove();
+        this.updateVideoClipPlayer(path, () => null);
+    }
+}
+exports.default = VideoPlayer;
+function preloadString(preload) {
+    return typeof preload === 'string' ? preload : preload ? 'auto' : 'none';
+}
+function setPlayerSinkId(player, sinkId) {
+    if (sinkId === undefined) {
+        return;
+    }
+    if (typeof player.videoElement.setSinkId === 'function') {
+        player.videoElement.setSinkId(sinkId);
+    }
+}
+/**
+ * Set video volume
+ *
+ * This doesn't work on iOS (volume is read-only) so at least mute it if the volume is zero
+ */
+function setVideoElementVolume(videoElement, volume) {
+    videoElement.volume = volume;
+    videoElement.muted = volume === 0;
+}

package/dist/browser/index.mjs

@@ -2921,7 +2921,7 @@ const Bu = (e, t) => {
     ...t.checks ?? [],
     ...r.map((n) => typeof n == "function" ? { _zod: { check: n, def: { check: "custom" }, onattach: [] } } : n)
   ]
-})), e.clone = (r, n) => $e(e, r, n), e.brand = () => e, e.register = (r, n) => (r.add(e, n), e), e.parse = (r, n) => Fu(e, r, n, { callee: e.parse }), e.safeParse = (r, n) => Gu(e, r, n), e.parseAsync = async (r, n) => qu(e, r, n, { callee: e.parseAsync }), e.safeParseAsync = async (r, n) => Vu(e, r, n), e.spa = e.safeParseAsync, e.encode = (r, n) => Wu(e, r, n), e.decode = (r, n) => Hu(e, r, n), e.encodeAsync = async (r, n) => Xu(e, r, n), e.decodeAsync = async (r, n) => Ku(e, r, n), e.safeEncode = (r, n) => Yu(e, r, n), e.safeDecode = (r, n) => Ju(e, r, n), e.safeEncodeAsync = async (r, n) => Qu(e, r, n), e.safeDecodeAsync = async (r, n) => ec(e, r, n), e.refine = (r, n) => e.check(Wc(r, n)), e.superRefine = (r) => e.check(Hc(r)), e.overwrite = (r) => e.check(Ze(r)), e.optional = () => Yr(e), e.nullable = () => Jr(e), e.nullish = () => Yr(Jr(e)), e.nonoptional = (r) => jc(e, r), e.array = () => Ee(e), e.or = (r) => de([e, r]), e.and = (r) => Ac(e, r), e.transform = (r) => Qr(e, Cc(r)), e.default = (r) => Zc(e, r), e.prefault = (r) => xc(e, r), e.catch = (r) => Uc(e, r), e.pipe = (r) => Qr(e, r), e.readonly = () => qc(e), e.describe = (r) => {
+})), e.clone = (r, n) => $e(e, r, n), e.brand = () => e, e.register = (r, n) => (r.add(e, n), e), e.parse = (r, n) => Fu(e, r, n, { callee: e.parse }), e.safeParse = (r, n) => Gu(e, r, n), e.parseAsync = async (r, n) => qu(e, r, n, { callee: e.parseAsync }), e.safeParseAsync = async (r, n) => Vu(e, r, n), e.spa = e.safeParseAsync, e.encode = (r, n) => Wu(e, r, n), e.decode = (r, n) => Hu(e, r, n), e.encodeAsync = async (r, n) => Xu(e, r, n), e.decodeAsync = async (r, n) => Ku(e, r, n), e.safeEncode = (r, n) => Yu(e, r, n), e.safeDecode = (r, n) => Ju(e, r, n), e.safeEncodeAsync = async (r, n) => Qu(e, r, n), e.safeDecodeAsync = async (r, n) => ec(e, r, n), e.refine = (r, n) => e.check(Wc(r, n)), e.superRefine = (r) => e.check(Hc(r)), e.overwrite = (r) => e.check(Ze(r)), e.optional = () => Yr(e), e.nullable = () => Jr(e), e.nullish = () => Yr(Jr(e)), e.nonoptional = (r) => jc(e, r), e.array = () => ve(e), e.or = (r) => de([e, r]), e.and = (r) => Ac(e, r), e.transform = (r) => Qr(e, Cc(r)), e.default = (r) => Zc(e, r), e.prefault = (r) => xc(e, r), e.catch = (r) => Uc(e, r), e.pipe = (r) => Qr(e, r), e.readonly = () => qc(e), e.describe = (r) => {
   const n = e.clone();
   return Ve.add(n, { description: r }), n;
 }, Object.defineProperty(e, "description", {
@@ -3028,7 +3028,7 @@ function zs(e) {
 const Ic = /* @__PURE__ */ g("ZodArray", (e, t) => {
   va.init(e, t), H.init(e, t), e.element = t.element, e.min = (r, n) => e.check(Qe(r, n)), e.nonempty = (r) => e.check(Qe(1, r)), e.max = (r, n) => e.check(ks(r, n)), e.length = (r, n) => e.check(Ps(r, n)), e.unwrap = () => e.element;
 });
-function Ee(e, t) {
+function ve(e, t) {
   return ku(Ic, e, t);
 }
 const Zs = /* @__PURE__ */ g("ZodObject", (e, t) => {
@@ -4339,10 +4339,10 @@ function Hs() {
     "64:ff9b:1::/48": "NAT64 (local-use)"
   }, K.RE_BAD_CHARACTERS = /([^0-9a-f:/%])/gi, K.RE_BAD_ADDRESS = /([0-9a-f]{5,}|:{3,}|[^:]:$|^:[^:]|\/$)/gi, K.RE_SUBNET_STRING = /\/\d{1,3}(?=%|$)/, K.RE_ZONE_STRING = /%.*$/, K.RE_URL = /^\[{0,1}([0-9a-f:]+)\]{0,1}/, K.RE_URL_WITH_PORT = /\[([0-9a-f:]+)\]:([0-9]{1,5})/), K;
 }
-var ve = {}, hn;
+var Ee = {}, hn;
 function Xs() {
-  if (hn) return ve;
-  hn = 1, Object.defineProperty(ve, "__esModule", { value: !0 }), ve.escapeHtml = e, ve.spanAllZeroes = t, ve.spanAll = r, ve.spanLeadingZeroes = s, ve.simpleGroup = i;
+  if (hn) return Ee;
+  hn = 1, Object.defineProperty(Ee, "__esModule", { value: !0 }), Ee.escapeHtml = e, Ee.spanAllZeroes = t, Ee.spanAll = r, Ee.spanLeadingZeroes = s, Ee.simpleGroup = i;
   function e(o) {
     return o.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
   }
@@ -4361,7 +4361,7 @@ function Xs() {
   function i(o, c = 0) {
     return o.split(":").map((l, a) => /group-v4/.test(l) ? l : `<span class="hover-group group-${a + c}">${n(l)}</span>`);
   }
-  return ve;
+  return Ee;
 }
 var ne = {}, dn;
 function wl() {
@@ -5326,9 +5326,10 @@ class Il {
   }
   /** Checks whether `host` and `port` are matched by this pattern. */
   validate(t, r) {
-    return this.matchesHost(t) && (this.port === "*" || Number(this.port) === r);
+    return this.validateHostname(t) && (this.port === "*" || Number(this.port) === r);
   }
-  matchesHost(t) {
+  /** Checks whether `host` is matched by the hostname part of this pattern, ignoring the port. */
+  validateHostname(t) {
     const r = this.host.toLowerCase();
     return t = t.toLowerCase(), r === "*" ? !0 : r === "localhost" ? t === "localhost" || Rl(t) : r === "private" ? yl(t) : r.startsWith("*.") ? t.endsWith(r.slice(1)) : r === t;
   }
@@ -6409,7 +6410,7 @@ function Jl() {
   }, sr;
 }
 var Ql = Jl();
-const fr = /* @__PURE__ */ bl(Ql), us = Ee(ee().min(1)).refine((e) => new Set(e).size === e.length, {
+const fr = /* @__PURE__ */ bl(Ql), us = ve(ee().min(1)).refine((e) => new Set(e).size === e.length, {
   message: "Array items must be unique"
 });
 function ei(e) {
@@ -6485,12 +6486,12 @@ function ei(e) {
       height: te().gt(0).int(),
       visible: Pe().optional()
     }).optional(),
-    config: Ee(h).optional(),
+    config: ve(h).optional(),
     events: q({
-      fromCogs: Ee(p).optional(),
-      toCogs: Ee(p).optional()
+      fromCogs: ve(p).optional(),
+      toCogs: ve(p).optional()
     }).optional(),
-    state: Ee(I).optional(),
+    state: ve(I).optional(),
     media: q({
       audio: G(!0).optional(),
       video: G(!0).optional(),
@@ -6506,10 +6507,10 @@ function ei(e) {
     }).optional(),
     permissions: ur({
       network: ur({
-        access: Ee(
+        access: ve(
           e({
-            hosts: Ee(ee().refine(v, { error: "Invalid network host pattern" })).min(1),
-            caCertificate: ee().optional()
+            hosts: ve(ee().refine(v, { error: "Invalid network host pattern" })).min(1),
+            caCertificates: ve(ee().min(1)).optional()
           })
         ).optional()
       }).optional()