Spaces:

docs4you
/

manchester

Running

File size: 12,751 Bytes

635422a

addEventListener('fetch', event => {
  event.respondWith(handleRequest(event.request));
});

async function handleRequest(request) {
  const url = new URL(request.url);
  const pathname = url.pathname;

  // Handle the home page route
  if (pathname === '/' && !url.search) {
    const html = `<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>M3U Playlist Proxy</title>
    <style>
	
body{
	color: #626262;
}
/* General Form Styling */
form {
    max-width: 600px;
    margin: 0 auto;
    padding: 20px;
    background-color: #f7f7f7;
    border: 1px solid #ddd;
    border-radius: 8px;
    box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
}

/* Styling for Input Fields */
input[type="text"] {
    width: calc(50% - 10px);
    padding: 10px;
    font-size: 16px;
    border: 1px solid #ccc;
    border-radius: 4px;
    margin-bottom: 10px;
	color: #626262;
}

input[type="text"]:focus {
    border-color: #007bff;
    outline: none;
    box-shadow: 0 0 5px rgba(0, 123, 255, 0.5);
}

/* Styling for Add More and Submit Buttons */
button {
  padding: 10px 15px;
  font-size: 16px;
  border: none;
  border-radius: 4px;
  cursor: pointer;
  margin-top: 10px;
  width: 45%;
  margin-left: 20px;
  align-content: center;
}

button#add-more {
	background-color: #007bff;
    color: white;
}

button[type="submit"] {
    background-color: #28a745;
    color: white;
}

button:hover {
    opacity: 0.9;
}

button:focus {
    outline: none;
}

/* Styling for Text Area */
textarea {
    width: 100%;
    padding: 10px;
    font-size: 16px;
    border: 1px solid #ccc;
    border-radius: 4px;
    margin-top: 10px;
    resize: none;
	color: #626262;
}

/* Styling for Header Pair Div */
.header-pair {
    display: flex;
    justify-content: space-between;
    margin-bottom: 10px;
}

h3,h4 {
    text-align: center;
    font-size: 24px;
    font-weight: bold;
    margin-bottom: 20px;
    color: #626262;
}
form {
    max-width: 600px;
    margin: 0 auto;
    padding: 20px;
    background-color: #f7f7f7;
    border: 1px solid #ddd;
    border-radius: 8px;
    box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
}

 .container {
    max-width: 600px;
    margin: 0 auto;
}

 .footer {
    max-width: 600px;
    margin: 0 auto;
    padding-top:20px;
    padding-bottom:10px;
    text-align:center;
}


textarea#result {
    width: 100%;
    max-width: 600px;
    display: block;
    margin: 20px auto;
    padding: 10px;
    font-size: 16px;
    border


/* Label Styling */
label {
    font-weight: bold;
    margin-bottom: 5px;
    display: block;
}

/* Basic Responsive Design */
@media (max-width: 600px) {
    input[type="text"] {
        width: 100%;
        margin-bottom: 10px;
    }

    .header-pair {
        flex-direction: column;
    }
}

    </style>
</head>
<body><h3>M3U Playlist Proxy</h3>
     <div class="container"><p>Use the form below to generate a playlist with the necessary headers. For example, if the server requires a "Referer: http://example.com" header to allow streaming, you would enter "Referer" as the Header Name and "http://example.com" as the Header Value.</p></div>

    <form id="headerForm">
        <div>
            <label for="playlistUrl">Playlist URL:</label><br>
            <input type="text" id="playlistUrl" name="playlistUrl" placeholder="Enter playlist URL" style="width: 96%; margin-bottom: 20px;">
        </div>
        
        <div class="header-pair">
            <input type="text" name="headerName" placeholder="Header Name">
            <input type="text" name="headerValue" placeholder="Header Value">
        </div>
        <button type="button" id="add-more">Add More Headers</button>
        <button type="submit">Generate Playlist URL</button>
    </form>

    <h4>Generated Playlist URL:</h4>
    <textarea id="result" rows="4" cols="80" readonly></textarea>
    <div class="container"><p>Once the URL has been generated, you can use a URL shortener like <a href="https://tinyurl.com" target=_blank">TinyURL.com</a> to shorten it. This will make it much easier to add the URL as a M3U playlist within your IPTV application.</p></div>

<div class="footer">Created by  <a href="https://github.com/dtankdempse/m3u-playlist-proxy">Tank Dempse</a></div>
    <script>
    // Function to add more header input fields
    document.getElementById('add-more').addEventListener('click', function () {
        const headerPair = document.createElement('div');
        headerPair.classList.add('header-pair');
        headerPair.innerHTML = 
            "<input type='text' name='headerName' placeholder='Header Name'>" +
            "<input type='text' name='headerValue' placeholder='Header Value'>";
        document.getElementById('headerForm').insertBefore(headerPair, document.getElementById('add-more'));
    });

    // Function to handle form submission and generate the full URL
    document.getElementById('headerForm').addEventListener('submit', function (event) {
        event.preventDefault();

        const playlistUrl = document.getElementById('playlistUrl').value.trim();
        if (!playlistUrl) {
            alert('Please enter a Playlist URL.');
            return;
        }

        let headers = [];
        const headerPairs = document.querySelectorAll('.header-pair');

        headerPairs.forEach(pair => {
            const headerName = pair.querySelector('input[name="headerName"]').value;
            const headerValue = pair.querySelector('input[name="headerValue"]').value;
            if (headerName && headerValue) {
                headers.push(headerName + "=" + headerValue);
            }
        });

        if (headers.length > 0) {
            const headerString = headers.join('|');
            const base64Encoded = btoa(headerString);
            const urlEncodedData = encodeURIComponent(base64Encoded);
            const baseUrl = window.location.origin;
            const fullUrl = baseUrl + "/playlist?url=" + encodeURIComponent(playlistUrl) + "&data=" + urlEncodedData;

            document.getElementById('result').value = fullUrl;
        } else {
            alert('Please add at least one header.');
        }
    });
</script>

</body>
</html>
    `;
    return new Response(html, { headers: { 'Content-Type': 'text/html' } });
  }
  
  // Handle the /playlist route
	if (pathname === '/playlist') {
	  const urlParam = url.searchParams.get('url');
	  const dataParam = url.searchParams.get('data');
	  
	  if (!urlParam) {
		return new Response('URL parameter missing', { status: 400 });
	  }

	  return handlePlaylistRequest(request, urlParam, dataParam);
	}

  // Handle proxied URL requests (same logic as before)
  const params = url.searchParams;
  const requestUrl = params.has('url') ? decodeURIComponent(params.get('url')) : null;
  const secondaryUrl = params.has('url2') ? decodeURIComponent(params.get('url2')) : null;
  const data = params.get('data') ? atob(params.get('data')) : null; // Decode base64

  const isMaster = !params.has('url2'); // Check if it's a master playlist
  const finalRequestUrl = isMaster ? requestUrl : secondaryUrl;

  if (finalRequestUrl) {
    // Handle encryption key requests
    if (params.has('key') && params.get('key') === 'true') {
      return fetchEncryptionKey(finalRequestUrl, data);
    }

    // Set dataType based on whether it's a master playlist (text) or a segment (binary)
    const dataType = isMaster ? 'text' : 'binary';

    // Fetch content from the URL with appropriate headers and dataType
    const result = await fetchContent(finalRequestUrl, data, dataType);

    if (result.status >= 400) {
      return new Response(`Error: ${result.status}`, { status: result.status });
    }

    let content = result.content;

    // If it's a master playlist, rewrite the URLs and treat as text
    if (isMaster) {
      const baseUrl = new URL(result.finalUrl).origin;
      const proxyUrl = `${url.origin}`;
      content = rewriteUrls(content, baseUrl, proxyUrl, params.get('data'));
    }

    // Send the response with content and headers
    return new Response(content, { headers: result.headers, status: result.status });
  }

  return new Response('Bad Request', { status: 400 });
}

// Function to fetch content from a URL using fetch
async function fetchContent(url, data, dataType = 'text') {
  const headers = new Headers();

  if (data) {
    const headersArray = data.split('|');
    headersArray.forEach(header => {
      const [key, value] = header.split('=');
      headers.append(key.trim(), value.trim().replace(/['"]/g, ''));
    });
  }

  const response = await fetch(url, { headers });
  const buffer = await response.arrayBuffer();
  let content;

  if (dataType === 'binary') {
    content = buffer; // Treat as binary
  } else {
    content = new TextDecoder('utf-8').decode(buffer); // Default to text
  }

  return {
    content,
    finalUrl: url,
    status: response.status,
    headers: response.headers,
  };
}

// Function to handle playlist requests
async function handlePlaylistRequest(request, playlistUrl, data) {
  
  const result = await fetchContent(playlistUrl);

  if (result.status !== 200) {
    return new Response('Failed to fetch playlist', { status: 500 });
  }

  let playlistContent = result.content;
  const baseUrl = new URL(request.url).origin;
  playlistContent = rewritePlaylistUrls(playlistContent, baseUrl, data);

  return new Response(playlistContent, { headers: { 'Content-Type': 'text/plain' } });
}

// Function to fetch encryption key
async function fetchEncryptionKey(url, data) {
  const updatedUrl = url.includes('videohls.ru') ? url.replace('videohls.ru', 'onlinehdhls.ru') : url;
  const result = await fetchContent(updatedUrl, data, 'binary'); // Pass 'binary' as the dataType

  if (result.status >= 400) {
    return new Response(`Failed to fetch encryption key: ${result.status}`, { status: 500 });
  }

  return new Response(result.content, { headers: result.headers });
}

// Rewrite URLs in the M3U8 playlist
function rewriteUrls(content, baseUrl, proxyUrl, data) {
  const lines = content.split('\n');
  const rewrittenLines = [];
  let isNextLineUri = false;

  lines.forEach(line => {
    if (line.startsWith('#')) {
      if (line.includes('URI="')) {
        const uriMatch = line.match(/URI="([^"]+)"/i);
        let uri = uriMatch[1];
        
        if (!uri.startsWith('http')) {
          uri = new URL(uri, baseUrl).href;
        }
        
        const rewrittenUri = `${proxyUrl}?url=${encodeURIComponent(uri)}&data=${encodeURIComponent(data)}${line.includes('#EXT-X-KEY') ? '&key=true' : ''}`;
        line = line.replace(uriMatch[1], rewrittenUri);
      }
      
      rewrittenLines.push(line);

      if (line.includes('#EXT-X-STREAM-INF')) {
        isNextLineUri = true;
      }

    } else if (line.startsWith('http') || isNextLineUri) {
      const urlParam = isNextLineUri ? 'url' : 'url2';
      let lineUrl = line;

      if (!lineUrl.startsWith('http')) {
        lineUrl = new URL(lineUrl, baseUrl).href;
      }

      const fullUrl = `${proxyUrl}?${urlParam}=${encodeURIComponent(lineUrl)}&data=${encodeURIComponent(data)}${urlParam === 'url' ? '&type=/index.m3u8' : '&type=/index.ts'}`;
      rewrittenLines.push(fullUrl);

      isNextLineUri = false;
    } else {
      rewrittenLines.push(line);
    }
  });

  return rewrittenLines.join('\n');
}

// Rewrite playlist URLs and encode headers
function rewritePlaylistUrls(content, baseUrl, data) {
  const lines = content.split('\n');
  const rewrittenLines = [];

  lines.forEach(line => {
    if (line.startsWith('#EXTINF')) {
      rewrittenLines.push(line);
    } else if (line.startsWith('http')) {
      const headerSeparatorIndex = line.indexOf('|');
      const streamUrl = headerSeparatorIndex !== -1 ? line.substring(0, headerSeparatorIndex) : line;

      let base64Data = '';

      if (data) {
        base64Data = data; // Use provided data directly if it's passed
      } else if (headerSeparatorIndex !== -1) {
        const headersString = line.substring(headerSeparatorIndex + 1);
        const headers = headersString
          ? headersString.split('|').map(header => {
              const [key, value] = header.split('=');
              const cleanValue = value ? value.replace(/^['"]|['"]$/g, '').trim() : '';
              return `${key.trim()}=${cleanValue}`;
          })
          : [];
        base64Data = headers.length > 0 ? btoa(headers.join('|')) : '';
      }

      const newUrl = `${baseUrl}?url=${encodeURIComponent(streamUrl)}&data=${encodeURIComponent(base64Data)}`;
      rewrittenLines.push(newUrl);
    } else {
      rewrittenLines.push(line);
    }
  });

  return rewrittenLines.join('\n');
}