nixamp 0.7.21 → 0.7.24

package/dist/protocol.d.ts

@@ -28,6 +28,16 @@ export interface RemoteTrack {
      * a client puts at the top of that block so the two are not one soup.
      */
     group?: string;
+    /**
+     * Which folder it sits in, under whatever it was loaded from.
+     *
+     * Empty for a track at the top. A library is a shelf of albums and seasons,
+     * and five thousand files in one flat list is a list nobody can find
+     * anything in -- so the shape of the folders comes across and a player can
+     * offer them as folders. Relative, always: where the library sits on
+     * somebody's disk is their business.
+     */
+    folder?: string;
 }
 /** Everything a remote needs to draw the player. */
 export interface Snapshot {

package/dist/server.d.ts

@@ -136,6 +136,8 @@ export declare function safeJoin(rootDir: string, urlPath: string): string | nul
  */
 export type Loaded = Track & {
     group?: string;
+    /** The folder it sits in, relative to what it was loaded from. */
+    folder?: string;
     /**
      * Whether this has a picture, when the name could not say.
      *
@@ -205,6 +207,17 @@ export interface Engine {
 }
 export declare function toRemoteTracks(tracks: Loaded[]): RemoteTrack[];
 export declare function hasPicture(path: string): boolean;
+/**
+ * Where a track sits, relative to the thing it was loaded from.
+ *
+ * A library is a shelf of albums and seasons, and a flat list of five thousand
+ * files is one nobody can find anything in. This is what lets a player offer
+ * the folders as folders.
+ *
+ * Relative and never absolute: the shape of somebody's library is what a
+ * listener needs, and where it lives on their disk is not.
+ */
+export declare function folderOf(path: string, from: string): string;
 /**
  * Whether the name of a source tells us anything about what is inside it.
  *
@@ -373,6 +386,18 @@ export interface HandlerOptions {
     };
     /** What this server calls itself, for the list of what is live on it. */
     serverName?: string;
+    /**
+     * The source this server was started on -- its own library.
+     *
+     * Replacing the playlist with a stream leaves no way back to it: the address
+     * is a path on somebody else's machine, and a person looking at a player has
+     * no reason to know it. Reported to an administrator so there can be a
+     * button rather than a thing you have to remember and retype.
+     *
+     * Admin-only, because it is a filesystem path and a viewer has no business
+     * with it.
+     */
+    homeSource?: string;
     /**
      * Going live: whether this server is listed, and how to change that.
      *

package/dist/server.js

@@ -302,6 +302,7 @@ export function toRemoteTracks(tracks) {
         // Only for what was added; the library's own tracks say nothing, which is
         // how a client knows they are the library.
         ...(t.group ? { group: t.group } : {}),
+        ...(t.folder ? { folder: t.folder } : {}),
     }));
 }
 /** Video containers, as opposed to the songs that are most of a library. */
@@ -310,6 +311,34 @@ export function hasPicture(path) {
     const dot = path.lastIndexOf(".");
     return dot > 0 && PICTURE.has(path.slice(dot).toLowerCase());
 }
+/**
+ * Where a track sits, relative to the thing it was loaded from.
+ *
+ * A library is a shelf of albums and seasons, and a flat list of five thousand
+ * files is one nobody can find anything in. This is what lets a player offer
+ * the folders as folders.
+ *
+ * Relative and never absolute: the shape of somebody's library is what a
+ * listener needs, and where it lives on their disk is not.
+ */
+export function folderOf(path, from) {
+    const strip = (value) => value.replace(/\/+$/, "");
+    const base = strip(from);
+    if (base === "" || !path.startsWith(base + "/"))
+        return "";
+    const rest = path.slice(base.length + 1);
+    const at = rest.lastIndexOf("/");
+    if (at === -1)
+        return "";
+    const folder = rest.slice(0, at);
+    // A URL's path is percent-encoded and a person reading a folder name is not.
+    try {
+        return isRemote(path) ? decodeURIComponent(folder) : folder;
+    }
+    catch {
+        return folder;
+    }
+}
 /**
  * Whether the name of a source tells us anything about what is inside it.
  *
@@ -521,7 +550,7 @@ export class PlayerEngine {
     }
     replace(tracks, root) {
         this.stop();
-        this.tracks = tracks;
+        this.tracks = tracks.map((track) => ({ ...track, folder: folderOf(track.path, root) }));
         this.root = root;
         this.state.index = 0;
         this.state.position = 0;
@@ -544,7 +573,9 @@ export class PlayerEngine {
     add(tracks, from) {
         const group = sourceLabel(from);
         const known = new Set(this.tracks.map((track) => track.path));
-        const fresh = tracks.filter((track) => !known.has(track.path)).map((track) => ({ ...track, group }));
+        const fresh = tracks
+            .filter((track) => !known.has(track.path))
+            .map((track) => ({ ...track, group, folder: folderOf(track.path, from) }));
         if (fresh.length === 0)
             return 0;
         this.tracks = [...this.tracks, ...fresh];
@@ -617,7 +648,7 @@ export class PlayerEngine {
         // somebody pointed the server elsewhere. Theirs wins.
         if (this.tracks.length > 0)
             return;
-        this.tracks = tracks;
+        this.tracks = tracks.map((track) => ({ ...track, folder: folderOf(track.path, root) }));
         this.root = root;
         this.state.note = tracks.length === 0 ? `No audio files under ${root}.` : "";
         this.push(true);
@@ -639,7 +670,11 @@ export class PlayerEngine {
             changed = true;
             // The group is ours, not the tagger's: it knows what a track is called,
             // not which pile it is in.
-            return { ...tagged, ...(track.group ? { group: track.group } : {}) };
+            return {
+                ...tagged,
+                ...(track.group ? { group: track.group } : {}),
+                ...(track.folder ? { folder: track.folder } : {}),
+            };
         });
         if (!changed)
             return;
@@ -1598,9 +1633,31 @@ export function createHandler(engine, options) {
                 return;
             }
             if (request.method === "DELETE") {
-                const id = url.searchParams.get("id");
-                if (id)
-                    options.directory.withdraw(id);
+                const id = url.searchParams.get("id") ?? "";
+                const listing = options.directory.list().find((one) => one.id === id);
+                if (!listing) {
+                    // Already gone, or never here. Saying so plainly rather than
+                    // pretending to have done something.
+                    json(response, 404, { error: "no such listing" });
+                    return;
+                }
+                // Taking a stream out of a public directory is the owner's to do.
+                //
+                // This asked nobody anything: a listing id is in every copy of the
+                // list, so anyone who could read the directory could empty it of other
+                // people's streams. The publisher already sends its token; it was
+                // simply never looked at.
+                const who = options.accounts ? await options.accounts.whoIs(tokenFrom(request.headers)) : null;
+                const mine = listing.ownerId !== "" && who !== null && who.id === listing.ownerId;
+                if (!mine) {
+                    json(response, 403, {
+                        error: listing.ownerId === ""
+                            ? "that listing has no owner to prove; it leaves the list when it stops renewing"
+                            : "only the account that published a stream can take it off the list",
+                    });
+                    return;
+                }
+                options.directory.withdraw(id);
                 json(response, 200, { ok: true });
                 return;
             }
@@ -1670,6 +1727,16 @@ export function createHandler(engine, options) {
                     listeners: one.listeners,
                     startedAt: one.startedAt,
                 })),
+                // Anything re-streamed into this server is a live stream too, and was
+                // sitting in the middle of the playlist among the files -- which is
+                // what made moving between a channel and an album so confusing. Named
+                // here with the first track it owns, so it can be played from the list
+                // of what is live rather than hunted for among five thousand files.
+                restreams: engine.groups().map((name) => ({
+                    name,
+                    at: (engine.snapshot().tracks ?? []).findIndex((track) => track.group === name),
+                    tracks: (engine.snapshot().tracks ?? []).filter((track) => track.group === name).length,
+                })),
             });
             return;
         }
@@ -1916,6 +1983,10 @@ export function createHandler(engine, options) {
                 // And which of those slots somebody is already on, because the
                 // question you have in front of three addresses is which one is free.
                 channels: options.channels?.list().map(({ id, name, via }) => ({ id, name, via })) ?? [],
+                // What this server's own library is, and whether it is loaded, so
+                // there can be a way back to it that is not retyping a path.
+                home: options.homeSource ?? "",
+                root: engine.snapshot(false).root,
             });
             return;
         }
@@ -2701,6 +2772,7 @@ export async function serve(argv, version = "0.1.0") {
         channels,
         publishUrls: () => publishUrls,
         serverName: options.name || hostname(),
+        homeSource: root,
         live: {
             status: () => ({
                 live: publisher !== null,

package/dist/share.d.ts

@@ -85,21 +85,28 @@ export declare function reachableAddresses(host: string, port: number, publicUrl
     url: string;
 }[];
 /**
- * The two paths a key can arrive on, and what each one says about itself.
+ * The paths a key can arrive on, and what each one says about itself.
  *
  * `/admin/` administers and `/view/` only views. There used to be a `/s/`
- * that meant
- * neither -- just "here is a key" -- which is why somebody handed one of two
- * identical-looking links had no way to tell which they were holding, and
- * reported the controls as missing when they were never going to be there.
- * A link should say what it is before anybody clicks it.
+ * that meant neither -- just "here is a key" -- which is why somebody handed
+ * one of two identical-looking links had no way to tell which they were
+ * holding, and reported the controls as missing when they were never going to
+ * be there. A link should say what it is before anybody clicks it.
+ *
+ * `/a/` and `/v/` are the same two doors under shorter names they were briefly
+ * given. Both are read, because a link somebody was handed yesterday should
+ * not stop working because the spelling got clearer -- and because a player
+ * and the server it connects to are not upgraded on the same afternoon, which
+ * is exactly how a working server came to report itself as switched off.
+ * Links are written the long way.
  */
-export declare const KEY_PATHS: readonly ["/admin/", "/view/"];
+export declare const KEY_PATHS: readonly ["/admin/", "/view/", "/a/", "/v/"];
 /**
  * The key in a share link, and what the link claimed to be.
  *
- * Both halves, because a label nobody checks is a label that can lie. `/a/`
- * means this administers and `/v/` means this only views; handed the other
+ * Both halves, because a label nobody checks is a label that can lie.
+ * `/admin/` means this administers and `/view/` means this only views; given
+ * the other
  * key, a path would otherwise have said one thing and done the other -- and
  * the dangerous direction is real: a `/view/` link built around the control key
  * reads as view-only to the person you send it to and hands them the controls.

package/dist/share.js

@@ -242,21 +242,28 @@ export function reachableAddresses(host, port, publicUrl = "", scheme = "http")
     ];
 }
 /**
- * The two paths a key can arrive on, and what each one says about itself.
+ * The paths a key can arrive on, and what each one says about itself.
  *
  * `/admin/` administers and `/view/` only views. There used to be a `/s/`
- * that meant
- * neither -- just "here is a key" -- which is why somebody handed one of two
- * identical-looking links had no way to tell which they were holding, and
- * reported the controls as missing when they were never going to be there.
- * A link should say what it is before anybody clicks it.
+ * that meant neither -- just "here is a key" -- which is why somebody handed
+ * one of two identical-looking links had no way to tell which they were
+ * holding, and reported the controls as missing when they were never going to
+ * be there. A link should say what it is before anybody clicks it.
+ *
+ * `/a/` and `/v/` are the same two doors under shorter names they were briefly
+ * given. Both are read, because a link somebody was handed yesterday should
+ * not stop working because the spelling got clearer -- and because a player
+ * and the server it connects to are not upgraded on the same afternoon, which
+ * is exactly how a working server came to report itself as switched off.
+ * Links are written the long way.
  */
-export const KEY_PATHS = ["/admin/", "/view/"];
+export const KEY_PATHS = ["/admin/", "/view/", "/a/", "/v/"];
 /**
  * The key in a share link, and what the link claimed to be.
  *
- * Both halves, because a label nobody checks is a label that can lie. `/a/`
- * means this administers and `/v/` means this only views; handed the other
+ * Both halves, because a label nobody checks is a label that can lie.
+ * `/admin/` means this administers and `/view/` means this only views; given
+ * the other
  * key, a path would otherwise have said one thing and done the other -- and
  * the dangerous direction is real: a `/view/` link built around the control key
  * reads as view-only to the person you send it to and hands them the controls.
@@ -276,7 +283,7 @@ export function keyInPath(path) {
             // A key that is not valid percent-encoding is taken as written; it will
             // fail to match anything, which is the right answer either way.
         }
-        return { key, wants: prefix === "/admin/" ? "control" : "listen" };
+        return { key, wants: prefix === "/admin/" || prefix === "/a/" ? "control" : "listen" };
     }
     return null;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nixamp",
-  "version": "0.7.21",
+  "version": "0.7.24",
   "description": "It really whips the terminal's ass. A Winamp-shaped audio player for your terminal.",
   "license": "MIT",
   "type": "module",

package/src/protocol.ts

@@ -29,6 +29,16 @@ export interface RemoteTrack {
    * a client puts at the top of that block so the two are not one soup.
    */
   group?: string;
+  /**
+   * Which folder it sits in, under whatever it was loaded from.
+   *
+   * Empty for a track at the top. A library is a shelf of albums and seasons,
+   * and five thousand files in one flat list is a list nobody can find
+   * anything in -- so the shape of the folders comes across and a player can
+   * offer them as folders. Relative, always: where the library sits on
+   * somebody's disk is their business.
+   */
+  folder?: string;
 }
 
 /** Everything a remote needs to draw the player. */

package/src/server.ts

@@ -408,6 +408,8 @@ export function safeJoin(rootDir: string, urlPath: string): string | null {
  */
 export type Loaded = Track & {
   group?: string;
+  /** The folder it sits in, relative to what it was loaded from. */
+  folder?: string;
   /**
    * Whether this has a picture, when the name could not say.
    *
@@ -491,6 +493,7 @@ export function toRemoteTracks(tracks: Loaded[]): RemoteTrack[] {
     // Only for what was added; the library's own tracks say nothing, which is
     // how a client knows they are the library.
     ...(t.group ? { group: t.group } : {}),
+    ...(t.folder ? { folder: t.folder } : {}),
   }));
 }
 
@@ -502,6 +505,32 @@ export function hasPicture(path: string): boolean {
   return dot > 0 && PICTURE.has(path.slice(dot).toLowerCase());
 }
 
+/**
+ * Where a track sits, relative to the thing it was loaded from.
+ *
+ * A library is a shelf of albums and seasons, and a flat list of five thousand
+ * files is one nobody can find anything in. This is what lets a player offer
+ * the folders as folders.
+ *
+ * Relative and never absolute: the shape of somebody's library is what a
+ * listener needs, and where it lives on their disk is not.
+ */
+export function folderOf(path: string, from: string): string {
+  const strip = (value: string): string => value.replace(/\/+$/, "");
+  const base = strip(from);
+  if (base === "" || !path.startsWith(base + "/")) return "";
+  const rest = path.slice(base.length + 1);
+  const at = rest.lastIndexOf("/");
+  if (at === -1) return "";
+  const folder = rest.slice(0, at);
+  // A URL's path is percent-encoded and a person reading a folder name is not.
+  try {
+    return isRemote(path) ? decodeURIComponent(folder) : folder;
+  } catch {
+    return folder;
+  }
+}
+
 /**
  * Whether the name of a source tells us anything about what is inside it.
  *
@@ -711,7 +740,7 @@ export class PlayerEngine implements Engine {
 
   replace(tracks: Track[], root: string): void {
     this.stop();
-    this.tracks = tracks;
+    this.tracks = tracks.map((track) => ({ ...track, folder: folderOf(track.path, root) }));
     this.root = root;
     this.state.index = 0;
     this.state.position = 0;
@@ -735,7 +764,9 @@ export class PlayerEngine implements Engine {
   add(tracks: Track[], from: string): number {
     const group = sourceLabel(from);
     const known = new Set(this.tracks.map((track) => track.path));
-    const fresh = tracks.filter((track) => !known.has(track.path)).map((track) => ({ ...track, group }));
+    const fresh = tracks
+      .filter((track) => !known.has(track.path))
+      .map((track) => ({ ...track, group, folder: folderOf(track.path, from) }));
     if (fresh.length === 0) return 0;
     this.tracks = [...this.tracks, ...fresh];
     // The list itself changed, so it has to ride this frame; a count nobody
@@ -805,7 +836,7 @@ export class PlayerEngine implements Engine {
     // Something is already loaded, so this is a scan that finished after
     // somebody pointed the server elsewhere. Theirs wins.
     if (this.tracks.length > 0) return;
-    this.tracks = tracks;
+    this.tracks = tracks.map((track) => ({ ...track, folder: folderOf(track.path, root) }));
     this.root = root;
     this.state.note = tracks.length === 0 ? `No audio files under ${root}.` : "";
     this.push(true);
@@ -827,7 +858,11 @@ export class PlayerEngine implements Engine {
       changed = true;
       // The group is ours, not the tagger's: it knows what a track is called,
       // not which pile it is in.
-      return { ...tagged, ...(track.group ? { group: track.group } : {}) };
+      return {
+        ...tagged,
+        ...(track.group ? { group: track.group } : {}),
+        ...(track.folder ? { folder: track.folder } : {}),
+      };
     });
     if (!changed) return;
     this.tracks = merged;
@@ -988,6 +1023,18 @@ export interface HandlerOptions {
   broadcast?: () => { destinations: Destination[]; settings: EncoderSettings };
   /** What this server calls itself, for the list of what is live on it. */
   serverName?: string;
+  /**
+   * The source this server was started on -- its own library.
+   *
+   * Replacing the playlist with a stream leaves no way back to it: the address
+   * is a path on somebody else's machine, and a person looking at a player has
+   * no reason to know it. Reported to an administrator so there can be a
+   * button rather than a thing you have to remember and retype.
+   *
+   * Admin-only, because it is a filesystem path and a viewer has no business
+   * with it.
+   */
+  homeSource?: string;
   /**
    * Going live: whether this server is listed, and how to change that.
    *
@@ -1968,8 +2015,33 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
         return;
       }
       if (request.method === "DELETE") {
-        const id = url.searchParams.get("id");
-        if (id) options.directory.withdraw(id);
+        const id = url.searchParams.get("id") ?? "";
+        const listing = options.directory.list().find((one) => one.id === id);
+        if (!listing) {
+          // Already gone, or never here. Saying so plainly rather than
+          // pretending to have done something.
+          json(response, 404, { error: "no such listing" });
+          return;
+        }
+
+        // Taking a stream out of a public directory is the owner's to do.
+        //
+        // This asked nobody anything: a listing id is in every copy of the
+        // list, so anyone who could read the directory could empty it of other
+        // people's streams. The publisher already sends its token; it was
+        // simply never looked at.
+        const who = options.accounts ? await options.accounts.whoIs(tokenFrom(request.headers)) : null;
+        const mine = listing.ownerId !== "" && who !== null && who.id === listing.ownerId;
+        if (!mine) {
+          json(response, 403, {
+            error: listing.ownerId === ""
+              ? "that listing has no owner to prove; it leaves the list when it stops renewing"
+              : "only the account that published a stream can take it off the list",
+          });
+          return;
+        }
+
+        options.directory.withdraw(id);
         json(response, 200, { ok: true });
         return;
       }
@@ -2043,6 +2115,16 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
           listeners: one.listeners,
           startedAt: one.startedAt,
         })),
+        // Anything re-streamed into this server is a live stream too, and was
+        // sitting in the middle of the playlist among the files -- which is
+        // what made moving between a channel and an album so confusing. Named
+        // here with the first track it owns, so it can be played from the list
+        // of what is live rather than hunted for among five thousand files.
+        restreams: engine.groups().map((name) => ({
+          name,
+          at: (engine.snapshot().tracks ?? []).findIndex((track) => track.group === name),
+          tracks: (engine.snapshot().tracks ?? []).filter((track) => track.group === name).length,
+        })),
       });
       return;
     }
@@ -2305,6 +2387,10 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
         // And which of those slots somebody is already on, because the
         // question you have in front of three addresses is which one is free.
         channels: options.channels?.list().map(({ id, name, via }) => ({ id, name, via })) ?? [],
+        // What this server's own library is, and whether it is loaded, so
+        // there can be a way back to it that is not retyping a path.
+        home: options.homeSource ?? "",
+        root: engine.snapshot(false).root,
       });
       return;
     }
@@ -3149,6 +3235,7 @@ export async function serve(argv: string[], version = "0.1.0"): Promise<void> {
     channels,
     publishUrls: () => publishUrls,
     serverName: options.name || hostname(),
+    homeSource: root,
     live: {
       status: () => ({
         live: publisher !== null,

package/src/share.ts

@@ -272,22 +272,29 @@ export function reachableAddresses(
 }
 
 /**
- * The two paths a key can arrive on, and what each one says about itself.
+ * The paths a key can arrive on, and what each one says about itself.
  *
  * `/admin/` administers and `/view/` only views. There used to be a `/s/`
- * that meant
- * neither -- just "here is a key" -- which is why somebody handed one of two
- * identical-looking links had no way to tell which they were holding, and
- * reported the controls as missing when they were never going to be there.
- * A link should say what it is before anybody clicks it.
+ * that meant neither -- just "here is a key" -- which is why somebody handed
+ * one of two identical-looking links had no way to tell which they were
+ * holding, and reported the controls as missing when they were never going to
+ * be there. A link should say what it is before anybody clicks it.
+ *
+ * `/a/` and `/v/` are the same two doors under shorter names they were briefly
+ * given. Both are read, because a link somebody was handed yesterday should
+ * not stop working because the spelling got clearer -- and because a player
+ * and the server it connects to are not upgraded on the same afternoon, which
+ * is exactly how a working server came to report itself as switched off.
+ * Links are written the long way.
  */
-export const KEY_PATHS = ["/admin/", "/view/"] as const;
+export const KEY_PATHS = ["/admin/", "/view/", "/a/", "/v/"] as const;
 
 /**
  * The key in a share link, and what the link claimed to be.
  *
- * Both halves, because a label nobody checks is a label that can lie. `/a/`
- * means this administers and `/v/` means this only views; handed the other
+ * Both halves, because a label nobody checks is a label that can lie.
+ * `/admin/` means this administers and `/view/` means this only views; given
+ * the other
  * key, a path would otherwise have said one thing and done the other -- and
  * the dangerous direction is real: a `/view/` link built around the control key
  * reads as view-only to the person you send it to and hands them the controls.
@@ -304,7 +311,7 @@ export function keyInPath(path: string): { key: string; wants: Scope } | null {
       // A key that is not valid percent-encoding is taken as written; it will
       // fail to match anything, which is the right answer either way.
     }
-    return { key, wants: prefix === "/admin/" ? "control" : "listen" };
+    return { key, wants: prefix === "/admin/" || prefix === "/a/" ? "control" : "listen" };
   }
   return null;
 }

package/web/dist/assets/{hls-3VKVEQE3-CvAcQxX0.js → hls-3VKVEQE3-CYp2nKVZ.js}

@@ -1 +1 @@
-import{t as e}from"./index-C_UeOo63.js";var t=3;async function n(n){let{media:r,src:i,isTv:a}=n,{default:o}=await e(async()=>{let{default:e}=await import(`./hls-n74Cnh8A.js`);return{default:e}},[]);if(!o.isSupported())return n.onError(`This browser cannot play HLS streams.`),{destroy:()=>void 0,levels:()=>[]};let s=new o({...a?{maxBufferLength:60,maxMaxBufferLength:120,backBufferLength:30,liveSyncDurationCount:4}:{backBufferLength:90},enableWorker:!0}),c=0,l=!1;s.on(o.Events.ERROR,(e,r)=>{if(!l&&r.fatal){if(c>=t){n.onError(`This stream kept failing and has been stopped.`),s.destroy();return}switch(c+=1,r.type){case o.ErrorTypes.NETWORK_ERROR:n.onNotice(`Reconnecting…`),s.startLoad();break;case o.ErrorTypes.MEDIA_ERROR:n.onNotice(`Recovering…`),s.recoverMediaError();break;default:n.onError(`This stream could not be played.`),s.destroy()}}}),s.on(o.Events.MANIFEST_PARSED,()=>{l||(n.onNotice(null),n.onReady?.({live:s.levels.length>0&&!Number.isFinite(r.duration),levels:u()}))}),s.on(o.Events.LEVEL_LOADED,(e,t)=>{l||n.onReady?.({live:t.details.live,levels:u()})}),s.on(o.Events.FRAG_BUFFERED,()=>{l||n.onNotice(null)});function u(){return s.levels.map((e,t)=>({index:t,height:e.height||null,bitrate:e.bitrate||null,label:e.height?`${String(e.height)}p`:`${String(Math.round((e.bitrate||0)/1e3))}k`}))}return s.loadSource(i),s.attachMedia(r),{destroy(){l=!0,s.destroy()},levels:u,setLevel(e){s.currentLevel=e},currentLevel:()=>s.autoLevelEnabled?-1:s.currentLevel}}export{n as createHlsEngine};
+import{t as e}from"./index-CuPGZuSo.js";var t=3;async function n(n){let{media:r,src:i,isTv:a}=n,{default:o}=await e(async()=>{let{default:e}=await import(`./hls-n74Cnh8A.js`);return{default:e}},[]);if(!o.isSupported())return n.onError(`This browser cannot play HLS streams.`),{destroy:()=>void 0,levels:()=>[]};let s=new o({...a?{maxBufferLength:60,maxMaxBufferLength:120,backBufferLength:30,liveSyncDurationCount:4}:{backBufferLength:90},enableWorker:!0}),c=0,l=!1;s.on(o.Events.ERROR,(e,r)=>{if(!l&&r.fatal){if(c>=t){n.onError(`This stream kept failing and has been stopped.`),s.destroy();return}switch(c+=1,r.type){case o.ErrorTypes.NETWORK_ERROR:n.onNotice(`Reconnecting…`),s.startLoad();break;case o.ErrorTypes.MEDIA_ERROR:n.onNotice(`Recovering…`),s.recoverMediaError();break;default:n.onError(`This stream could not be played.`),s.destroy()}}}),s.on(o.Events.MANIFEST_PARSED,()=>{l||(n.onNotice(null),n.onReady?.({live:s.levels.length>0&&!Number.isFinite(r.duration),levels:u()}))}),s.on(o.Events.LEVEL_LOADED,(e,t)=>{l||n.onReady?.({live:t.details.live,levels:u()})}),s.on(o.Events.FRAG_BUFFERED,()=>{l||n.onNotice(null)});function u(){return s.levels.map((e,t)=>({index:t,height:e.height||null,bitrate:e.bitrate||null,label:e.height?`${String(e.height)}p`:`${String(Math.round((e.bitrate||0)/1e3))}k`}))}return s.loadSource(i),s.attachMedia(r),{destroy(){l=!0,s.destroy()},levels:u,setLevel(e){s.currentLevel=e},currentLevel:()=>s.autoLevelEnabled?-1:s.currentLevel}}export{n as createHlsEngine};