xiaozhang/zhibo
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

初始化

Browse Source
This commit is contained in:
xiao12feng 2025-12-15 11:21:21 +08:00
commit 696f63d2a1
10620 changed files with 922087 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

353
.kiro/specs/live-streaming-system/design.md Normal file
View File

@ -0,0 +1,353 @@
# Design Document
## Overview
本设计文档描述了基于 SRS 的个人直播系统的技术架构和实现方案。系统采用前后端分离架构，使用 SRS 作为核心流媒体服务器处理视频流的接收和分发，Node.js 后端提供业务 API，React 前端提供用户界面。
### 技术栈选型
| 组件 | 技术选择 | 理由 |
|------|----------|------|
| 流媒体服务器 | SRS 5.0 | 高性能、低延迟、支持多协议、Docker 部署简单 |
| 后端框架 | Node.js + Express | 轻量级、异步处理能力强、生态丰富 |
| 前端框架 | React 18 | 组件化开发、生态成熟、性能优秀 |
| 视频播放器 | flv.js + hls.js | flv.js 支持 HTTP-FLV 低延迟播放，hls.js 提供 HLS 兼容性 |
| 容器化 | Docker + Docker Compose | 简化部署、环境一致性 |
## Architecture
```
┌─────────────────────────────────────────────────────────────────┐
│ 用户层 (Users) │
├─────────────────────────────────────────────────────────────────┤
│ ┌─────────────┐ ┌─────────────────┐ │
│ │ 主播 │ │ 观众 │ │
│ │ (OBS/FFmpeg)│ │ (浏览器) │ │
│ └──────┬──────┘ └────────┬────────┘ │
│ │ RTMP 推流 │ HTTP 请求 │
│ │ rtmp://host:1935/live/{streamKey} │ │
└─────────┼─────────────────────────────────────────┼────────────┘
│ │
┌─────────┼─────────────────────────────────────────┼────────────┐
│ ▼ ▼ │
│ ┌─────────────────┐ ┌─────────────────┐ │
│ │ SRS Server │ │ React Frontend │ │
│ │ (Docker) │ │ (Port 3000) │ │
│ │ │ │ │ │
│ │ RTMP: 1935 │◄───HTTP-FLV/HLS───│ flv.js/hls.js │ │
│ │ HTTP: 8080 │ │ │ │
│ └────────┬────────┘ └────────┬────────┘ │
│ │ │ │
│ │ HTTP Callback │ REST API │
│ │ (on_publish/on_unpublish) │ │
│ ▼ ▼ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ Node.js API Server │ │
│ │ (Port 3001) │ │
│ │ ┌─────────────┐ ┌─────────────┐ ┌─────────────────┐ │ │
│ │ │ Room API │ │ Callback │ │ Room Store │ │ │
│ │ │ Controller │ │ Handler │ │ (In-Memory) │ │ │
│ │ └─────────────┘ └─────────────┘ └─────────────────┘ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ 服务层 (Services) │
└─────────────────────────────────────────────────────────────────┘
```
### 数据流说明
1. **推流流程**: 主播 → RTMP → SRS → HTTP Callback → API Server → 更新房间状态
2. **观看流程**: 观众 → React App → 获取房间信息 → flv.js/hls.js → SRS HTTP-FLV/HLS
3. **管理流程**: 用户 → React App → REST API → API Server → 房间 CRUD
## Components and Interfaces
### 1. SRS 流媒体服务器
**职责**: 接收 RTMP 推流，转换并分发 HTTP-FLV 和 HLS 流
**配置接口**:
```conf
# srs.conf
listen 1935;
max_connections 1000;
daemon off;
srs_log_tank console;
http_server {
enabled on;
listen 8080;
dir ./objs/nginx/html;
}
vhost __defaultVhost__ {
hls {
enabled on;
hls_fragment 2;
hls_window 10;
hls_path ./objs/nginx/html;
hls_m3u8_file [app]/[stream].m3u8;
hls_ts_file [app]/[stream]-[seq].ts;
}
http_remux {
enabled on;
mount [vhost]/[app]/[stream].flv;
}
http_hooks {
enabled on;
on_publish http://api-server:3001/api/srs/on_publish;
on_unpublish http://api-server:3001/api/srs/on_unpublish;
}
}
```
### 2. API Server (Node.js + Express)
**职责**: 提供业务 API，处理 SRS 回调，管理房间数据
#### 2.1 Room API Controller
```typescript
// 接口定义
interface RoomController {
// 获取所有房间
GET /api/rooms -> Room[]
// 创建房间
POST /api/rooms { title: string, streamerName: string } -> Room
// 获取单个房间
GET /api/rooms/:id -> Room
// 删除房间
DELETE /api/rooms/:id -> { success: boolean }
}
```
#### 2.2 SRS Callback Handler
```typescript
// SRS 回调接口
interface SRSCallbackHandler {
// 推流开始回调
POST /api/srs/on_publish {
action: 'on_publish',
app: string, // 应用名，如 'live'
stream: string // 流名称，即 streamKey
} -> { code: 0 }
// 推流结束回调
POST /api/srs/on_unpublish {
action: 'on_unpublish',
app: string,
stream: string
} -> { code: 0 }
}
```
### 3. React Frontend
**职责**: 提供用户界面，包括房间列表、直播播放、房间创建
#### 3.1 组件结构
```
src/
├── components/
│ ├── RoomList.jsx # 房间列表组件
│ ├── RoomCard.jsx # 房间卡片组件
│ ├── LivePlayer.jsx # 直播播放器组件
│ ├── CreateRoom.jsx # 创建房间弹窗
│ └── StreamInfo.jsx # 推流信息展示
├── pages/
│ ├── HomePage.jsx # 首页（房间列表）
│ └── RoomPage.jsx # 房间详情页
├── services/
│ └── api.js # API 调用封装
└── App.jsx # 应用入口
```
#### 3.2 LivePlayer 组件接口
```typescript
interface LivePlayerProps {
room: Room;
preferFlv?: boolean; // 优先使用 FLV（低延迟）
}
// 播放器内部逻辑
// 1. 检测浏览器是否支持 flv.js (需要 MSE 支持)
// 2. 支持则使用 HTTP-FLV，否则降级到 HLS
// 3. 监听播放错误，自动重连
```
## Data Models
### Room 数据模型
```typescript
interface Room {
id: string; // 房间唯一标识 (UUID)
title: string; // 房间标题
streamerName: string; // 主播名称
streamKey: string; // 推流密钥 (与 id 相同)
isLive: boolean; // 是否正在直播
viewerCount: number; // 观看人数
createdAt: string; // 创建时间 (ISO 8601)
startedAt?: string; // 开播时间 (ISO 8601)
}
```
### API 响应格式
```typescript
// 成功响应
interface SuccessResponse<T> {
success: true;
data: T;
}
// 错误响应
interface ErrorResponse {
success: false;
error: {
code: string;
message: string;
};
}
// SRS 回调响应
interface SRSCallbackResponse {
code: number; // 0 表示成功
}
```
### 流地址格式
```typescript
interface StreamUrls {
rtmp: string; // rtmp://host:1935/live/{streamKey}
flv: string; // http://host:8080/live/{streamKey}.flv
hls: string; // http://host:8080/live/{streamKey}.m3u8
}
```
## Correctness Properties
*A property is a characteristic or behavior that should hold true across all valid executions of a system-essentially, a formal statement about what the system should do. Properties serve as the bridge between human-readable specifications and machine-verifiable correctness guarantees.*
### Property 1: Room Creation Round-Trip Consistency
*For any* valid room creation request with non-empty title and streamer name, creating the room and then retrieving it by ID SHALL return a room with matching title, streamer name, a unique stream key, and a valid creation timestamp.
**Validates: Requirements 1.1, 1.4**
### Property 2: New Rooms Start Offline
*For any* newly created room, the initial `isLive` status SHALL be `false`.
**Validates: Requirements 1.2**
### Property 3: Empty Title Rejection
*For any* room creation request where the title is empty or consists only of whitespace characters, the system SHALL reject the request and return a validation error without creating a room.
**Validates: Requirements 1.3**
### Property 4: Publish Callback Status Transition
*For any* room that exists in the system, when a publish callback is received with that room's stream key, the room's `isLive` status SHALL transition to `true`. When an unpublish callback is received, the status SHALL transition to `false`.
**Validates: Requirements 2.3, 2.5**
### Property 5: Stream URLs Contain Required Formats
*For any* room returned by the API, the stream URLs SHALL include both HTTP-FLV (`.flv`) and HLS (`.m3u8`) format URLs containing the room's stream key.
**Validates: Requirements 3.1**
### Property 6: Room List Completeness
*For any* set of created rooms, requesting the room list SHALL return all rooms with their current status, title, and streamer name intact.
**Validates: Requirements 4.1, 4.2**
## Error Handling
### API Error Codes
| 错误码 | 描述 | HTTP 状态码 |
|--------|------|-------------|
| `VALIDATION_ERROR` | 请求参数验证失败 | 400 |
| `ROOM_NOT_FOUND` | 房间不存在 | 404 |
| `STREAM_KEY_INVALID` | 推流密钥无效 | 401 |
| `INTERNAL_ERROR` | 服务器内部错误 | 500 |
### 错误处理策略
1. **API 层**: 统一错误响应格式，包含错误码和消息
2. **SRS 回调**: 返回 `{ code: 0 }` 表示成功，非零表示失败
3. **前端**: 显示友好的错误提示，支持重试操作
4. **播放器**: 自动重连机制，最多重试 3 次
## Testing Strategy
### 单元测试
使用 Jest 进行单元测试，覆盖以下模块：
1. **Room Service**: 房间 CRUD 操作
2. **Validation**: 输入验证逻辑
3. **URL Generator**: 流地址生成
### 属性测试 (Property-Based Testing)
使用 fast-check 库进行属性测试：
1. **Property 1**: 房间创建往返一致性
2. **Property 2**: 新房间初始状态
3. **Property 3**: 空标题拒绝
4. **Property 4**: 回调状态转换
5. **Property 5**: 流地址格式
6. **Property 6**: 房间列表完整性
### 测试配置
```javascript
// jest.config.js
module.exports = {
testEnvironment: 'node',
testMatch: ['**/*.test.js', '**/*.property.test.js'],
collectCoverageFrom: ['server/**/*.js'],
coverageThreshold: {
global: { branches: 80, functions: 80, lines: 80 }
}
};
```
### 属性测试示例
```javascript
// 每个属性测试运行 100 次迭代
// 标注格式: **Feature: live-streaming-system, Property {number}: {property_text}**
import fc from 'fast-check';
// **Feature: live-streaming-system, Property 2: New Rooms Start Offline**
test('newly created rooms should have isLive = false', () => {
fc.assert(
fc.property(
fc.string({ minLength: 1 }), // title
fc.string({ minLength: 1 }), // streamerName
(title, streamerName) => {
const room = createRoom({ title, streamerName });
return room.isLive === false;
}
),
{ numRuns: 100 }
);
});
```

89
.kiro/specs/live-streaming-system/requirements.md Normal file
View File

@ -0,0 +1,89 @@
# Requirements Document
## Introduction
本文档定义了一个基于 SRS（Simple Realtime Server）的个人直播系统的功能需求。该系统允许用户创建直播间、进行实时视频推流、观看直播内容，并提供基本的直播间管理功能。系统采用 SRS 作为核心流媒体服务器，支持 RTMP 推流和 HTTP-FLV/HLS 播放，具有高性能、低延迟的特点。
## Glossary
- **Live Streaming System（直播系统）**: 提供视频直播功能的完整系统，包含前端播放器、后端 API 服务和 SRS 流媒体服务
- **SRS（Simple Realtime Server）**: 开源的高性能流媒体服务器，支持 RTMP、HLS、HTTP-FLV、WebRTC 等协议
- **Streamer（主播）**: 创建直播间并推送视频流的用户
- **Viewer（观众）**: 观看直播内容的用户
- **Live Room（直播间）**: 主播进行直播的虚拟空间，包含标题、主播信息和直播状态
- **Stream Key（推流密钥）**: 用于验证主播身份的唯一标识符
- **RTMP（Real-Time Messaging Protocol）**: 用于主播推流的实时消息传输协议
- **HTTP-FLV**: 基于 HTTP 的 FLV 流协议，延迟低于 HLS，适合实时直播
- **HLS（HTTP Live Streaming）**: 基于 HTTP 的直播流协议，兼容性好但延迟较高
- **SRS Callback**: SRS 的 HTTP 回调机制，用于通知业务服务器推流状态变化
## Requirements
### Requirement 1
**User Story:** As a streamer, I want to create a live room, so that I can start broadcasting my content to viewers.
#### Acceptance Criteria
1. WHEN a streamer submits a room creation request with title and streamer name, THE Live Streaming System SHALL create a new live room and return a unique stream key
2. WHEN a live room is created, THE Live Streaming System SHALL initialize the room status as "offline"
3. WHEN a streamer provides an empty title, THE Live Streaming System SHALL reject the creation request and return a validation error
4. WHEN a live room is created, THE Live Streaming System SHALL store the room information including title, streamer name, stream key, and creation timestamp
### Requirement 2
**User Story:** As a streamer, I want to push my video stream to the server, so that viewers can watch my live content.
#### Acceptance Criteria
1. WHEN a streamer connects to the SRS RTMP endpoint with a valid stream key, THE SRS Server SHALL accept the connection and begin receiving the video stream
2. WHEN SRS receives a publish event, THE SRS Server SHALL trigger an HTTP callback to notify the API service of the stream start
3. WHEN the API service receives a publish callback, THE Live Streaming System SHALL update the corresponding room status to "live"
4. WHEN SRS receives an unpublish event, THE SRS Server SHALL trigger an HTTP callback to notify the API service of the stream end
5. WHEN the API service receives an unpublish callback, THE Live Streaming System SHALL update the room status to "offline"
### Requirement 3
**User Story:** As a viewer, I want to watch live streams, so that I can enjoy the content broadcasted by streamers.
#### Acceptance Criteria
1. WHEN a viewer requests to watch a live room, THE Live Streaming System SHALL provide both HTTP-FLV and HLS stream URLs for playback
2. WHEN a viewer accesses an HTTP-FLV stream URL, THE Live Streaming System SHALL deliver the video with latency under 3 seconds
3. WHEN a viewer accesses an HLS stream URL, THE Live Streaming System SHALL deliver the video with latency under 10 seconds
4. WHEN a viewer attempts to watch an offline room, THE Live Streaming System SHALL display an appropriate offline message
5. WHEN the stream quality changes, THE Live Streaming System SHALL continue playback without interruption
### Requirement 4
**User Story:** As a viewer, I want to browse available live rooms, so that I can discover content to watch.
#### Acceptance Criteria
1. WHEN a viewer requests the room list, THE Live Streaming System SHALL return all available rooms with their current status
2. WHEN displaying the room list, THE Live Streaming System SHALL show room title, streamer name, and live status for each room
3. WHEN a room's live status changes, THE Live Streaming System SHALL reflect the updated status within 5 seconds on subsequent requests
4. WHEN no rooms exist, THE Live Streaming System SHALL return an empty list with appropriate messaging
### Requirement 5
**User Story:** As a system administrator, I want to deploy and configure SRS, so that the streaming service runs reliably.
#### Acceptance Criteria
1. WHEN deploying SRS, THE Live Streaming System SHALL use Docker for containerized deployment
2. WHEN configuring SRS, THE Live Streaming System SHALL enable RTMP input on port 1935
3. WHEN configuring SRS, THE Live Streaming System SHALL enable HTTP-FLV output on port 8080
4. WHEN configuring SRS, THE Live Streaming System SHALL enable HLS output with 2-second segments
5. WHEN configuring SRS, THE Live Streaming System SHALL set up HTTP callbacks for publish and unpublish events
### Requirement 6
**User Story:** As a user, I want a responsive web interface, so that I can access the live streaming platform from any device.
#### Acceptance Criteria
1. WHEN a user accesses the platform, THE Live Streaming System SHALL display a responsive interface that adapts to screen sizes from 320px to 1920px width
2. WHEN a user interacts with the video player, THE Live Streaming System SHALL provide play, pause, and volume controls
3. WHEN a user navigates between pages, THE Live Streaming System SHALL maintain smooth transitions without full page reloads
4. WHEN the interface loads, THE Live Streaming System SHALL display the main content within 3 seconds on a standard broadband connection

66
.kiro/specs/live-streaming-system/tasks.md Normal file
View File

@ -0,0 +1,66 @@
# Implementation Tasks
## Task 1: 项目初始化和 Docker 配置
- [ ] 1.1 创建项目根目录结构 (server/, client/, docker/)
- [ ] 1.2 创建 package.json 配置后端依赖
- [ ] 1.3 创建 SRS 配置文件 (docker/srs/srs.conf)
- [ ] 1.4 创建 docker-compose.yml 配置 SRS 和 API 服务
- [ ] 1.5 创建 .env.example 环境变量模板
## Task 2: 后端 API 服务 - 房间管理
- [ ] 2.1 创建 Express 服务入口 (server/index.js)
- [ ] 2.2 实现房间数据存储模块 (server/store/roomStore.js)
- [ ] 2.3 实现房间 API 路由 (server/routes/rooms.js)
- GET /api/rooms - 获取所有房间
- POST /api/rooms - 创建房间
- GET /api/rooms/:id - 获取单个房间
- DELETE /api/rooms/:id - 删除房间
- [ ] 2.4 实现输入验证中间件 (server/middleware/validate.js)
- [ ] 2.5 实现统一错误处理 (server/middleware/errorHandler.js)
## Task 3: 后端 API 服务 - SRS 回调处理
- [ ] 3.1 实现 SRS 回调路由 (server/routes/srs.js)
- POST /api/srs/on_publish - 推流开始回调
- POST /api/srs/on_unpublish - 推流结束回调
- [ ] 3.2 实现流地址生成工具 (server/utils/streamUrl.js)
- [ ] 3.3 添加回调日志记录
## Task 4: 前端 - 项目搭建和基础组件
- [ ] 4.1 初始化 React 项目 (client/)
- [ ] 4.2 安装依赖 (flv.js, hls.js, axios)
- [ ] 4.3 创建 API 服务封装 (client/src/services/api.js)
- [ ] 4.4 创建全局样式 (client/src/index.css)
- [ ] 4.5 创建 App 入口和路由 (client/src/App.jsx)
## Task 5: 前端 - 房间列表页面
- [ ] 5.1 创建 RoomCard 组件 (client/src/components/RoomCard.jsx)
- [ ] 5.2 创建 RoomList 组件 (client/src/components/RoomList.jsx)
- [ ] 5.3 创建 HomePage 页面 (client/src/pages/HomePage.jsx)
- [ ] 5.4 实现房间列表自动刷新
## Task 6: 前端 - 创建直播间功能
- [ ] 6.1 创建 CreateRoom 弹窗组件 (client/src/components/CreateRoom.jsx)
- [ ] 6.2 创建 StreamInfo 推流信息组件 (client/src/components/StreamInfo.jsx)
- [ ] 6.3 实现复制推流地址功能
## Task 7: 前端 - 直播播放器
- [ ] 7.1 创建 LivePlayer 组件 (client/src/components/LivePlayer.jsx)
- [ ] 7.2 实现 flv.js 播放器集成 (HTTP-FLV 低延迟)
- [ ] 7.3 实现 hls.js 降级播放 (HLS 兼容性)
- [ ] 7.4 实现播放器自动重连机制
- [ ] 7.5 创建 RoomPage 直播间页面 (client/src/pages/RoomPage.jsx)
## Task 8: 集成测试和部署
- [ ] 8.1 编写属性测试 (server/tests/room.property.test.js)
- [ ] 8.2 编写 API 集成测试 (server/tests/api.test.js)
- [ ] 8.3 创建启动脚本 (scripts/start.sh, scripts/start.bat)
- [ ] 8.4 编写 README.md 使用文档
- [ ] 8.5 测试完整推流和观看流程

2
.vscode/settings.json vendored Normal file
View File

@ -0,0 +1,2 @@
{
}

371
Log/1-AI指南.md Normal file
View File

@ -0,0 +1,371 @@
# AI工作指南
## 🚀 快速引用
**使用方法**：在对话中使用编号快速调用对应原则
| 编号 | 原则 | 用法示例 |
|------|------|---------|
| **1** | 主动获取信息 | `1-查询数据库配置` |
| **2** | 确认需求再执行 | `2-修复登录bug` |
| **3** | 简洁文档 | `3-生成部署文档` |
| **4** | 理解功能逻辑 | `4-学习记录功能` |
| **5** | 记录配置信息 | `5-Redis配置` |
**示例**：
- 输入 `1-端口占用` → AI会主动使用命令查询端口，而不是询问你
- 输入 `2-部署到服务器` → AI会先确认服务器地址、环境等信息
- 输入 `4-视频进度功能` → AI会先查找代码、理解逻辑、总结应用场景
- 输入 `5-新增OSS配置` → AI会自动记录到配置清单文件
---
## 工作原则
### 原则1：主动获取信息
**优先使用工具获取信息，减少询问**
✅ **应该做的：**
- 使用`grep_search`查找代码
- 使用`read_file`读取配置文件
- 使用`run_command`检查端口占用、进程状态
- 查询数据库获取数据状态（配置文件中有账号密码）
- 查看日志文件分析问题
❌ **不应该做的：**
- 直接询问"端口是多少"（应该用命令查询）
- 询问"数据库密码是什么"（应该读取配置文件）
- 询问"这个文件在哪里"（应该用find_by_name搜索）
**例外情况：**
- 报错信息（需要用户提供控制台输出）
- 运行结果（需要用户反馈测试结果）
- 业务需求（需要用户明确需求细节）
---
### 原则2：确认需求再执行
**信息不完整时，先确认再行动**
✅ **检查清单：**
- [ ] 用户需求是否明确？有无歧义？
- [ ] 是否需要补充信息才能执行？
- [ ] 能否通过工具自行获取缺失信息？
- [ ] 执行前是否理解了预期结果？
**示例：**
- 用户说"修复这个bug" → 先确认具体是哪个bug，复现步骤是什么
- 用户说"部署到服务器" → 先确认服务器地址、环境、部署方式
- 用户说"优化性能" → 先确认性能瓶颈在哪里，优化目标是什么
---
### 原则3：简洁文档
**只在需要时写文档，内容精简实用**
✅ **文档要求：**
- 用户明确要求时才写文档
- 用户会指定文档路径
- 只写必要内容，不要冗余
- 重点突出，步骤清晰
- 使用Markdown格式
❌ **避免：**
- 自动生成大量README
- 过度详细的注释
- 重复的说明文档
- 长篇大论的总结
**例外情况：**
- SQL脚本（需要记录修改）
- 部署步骤（需要明确指引）
- 配置文件（需要说明参数）
---
### 原则4：理解功能逻辑
**充分理解现有功能后再修改**
✅ **功能理解流程：**
1. 使用`grep_search`和`code_search`查找相关代码
2. 阅读核心逻辑，理解业务流程
3. 用简洁语言总结功能逻辑
4. 提供实际应用场景示例
5. 确认理解正确后再进行修改
**示例：**
- 用户说"优化学习记录功能"
- → 先查找StudyLearningRecord相关代码
- → 理解当前如何记录学习进度
- → 总结：每次上报时更新learning_record和learning_detail
- → 场景：学生观看视频时每10秒上报一次进度
- → 确认理解无误后，再讨论优化方案
---
### 原则5：记录配置信息
**遇到配置信息时，自动记录到配置清单文件**
✅ **需要记录的信息类型：**
- 外部API接口地址和密钥
- 数据库连接信息（地址、端口、账号）
- 本地服务端口和访问地址
- 重要文件路径和位置
- 第三方服务配置
- 环境变量设置
📝 **记录位置：**
- 文件路径：`log/项目配置清单.md`
- 每次遇到新的配置信息时自动追加
- 记录时间和用途说明
**示例：**
- 发现使用了OSS存储 → 记录OSS的endpoint、bucket等信息
- 配置了Redis → 记录Redis的host、port、密码
- 调用百度API → 记录API Key和Secret
- 部署到服务器 → 记录服务器IP、部署路径
---
## 常见操作
### 编译后端
```bash
cd Study-Vue-redis
mvn clean package -DskipTests
```
### 启动后端
```bash
java -jar ry-study-admin/target/ry-study-admin.jar
```
### 查询数据库
```bash
mysql -u root -proot study -e "你的SQL语句"
```
### 查看端口占用
```powershell
netstat -ano | findstr :端口号
```
### 停止Java进程
```powershell
taskkill /F /IM java.exe
```
---
## 工作流程
### 1. 接收需求
- 阅读用户请求
- 识别关键信息
- 判断是否需要补充
### 2. 信息收集
- 优先使用工具获取
- 必要时向用户确认
- 确保信息完整
### 3. 分析问题
- 定位问题根源
- 查看相关代码
- 理解业务逻辑
### 4. 实施修改
- 最小化修改范围
- 保持代码风格一致
- 添加必要注释
### 5. 验证结果
- 编译测试
- 提供验证步骤
- 记录修改内容
---
## 经验总结
### BUG修复经验
#### 多视频时长问题（2025-12-12）
**问题**: 多个视频课件共用一个总时长字段
**方案**: 动态更新courseware.duration，每个课件独立存储
**教训**: 数据设计要考虑一对多关系
#### 防快进检测（2025-12-12）
**问题**: 用户拖动到末尾就能完成
**方案**: 添加累计观看时长检测（>=80%）
**教训**: 前端数据可被篡改，后端必须验证
#### 观看时长共用（2025-12-12）
**问题**: Mapper XML缺少coursewareId过滤
**方案**: 添加WHERE条件
**教训**: SQL查询必须明确过滤条件
#### 异常数据清理（2025-12-12）
**问题**: duration<=0的脏数据影响统计
**方案**: 清理异常数据，代码中过滤
**教训**: 数据验证要在代码和数据库两层进行
---
## 注意事项
1. **修改前先备份** - 重要文件修改前先备份
2. **测试后再部署** - 本地测试通过再部署到服务器
3. **保持代码风格** - 遵循项目现有代码规范
4. **避免过度设计** - 简单问题简单解决
5. **记录关键修改** - 重要修改需要记录在log目录
---
## 遇到问题时
1. 先查看日志文件
2. 使用grep搜索相关代码
3. 查询数据库验证数据
4. 尝试用命令诊断
5. 最后才询问用户
---
## 📞 快速引用详细说明
### 使用格式
```
编号-你的请求内容
```
### 各编号的详细说明
#### **1-主动获取信息**
当你说 `1-xxx` 时，AI会：
- ✅ 优先使用工具自行查找信息
- ✅ 查看配置文件获取参数
- ✅ 执行命令查询状态
- ✅ 搜索代码定位问题
- ❌ 不会直接询问你已有的信息
**适用场景**：
- `1-查看当前运行的端口` → 执行 `netstat -ano` 命令
- `1-数据库连接信息` → 读取 `application-druid.yml`
- `1-查找登录接口` → 使用 `grep_search` 搜索代码
- `1-Redis配置` → 读取 `application.yml` 的Redis部分
---
#### **2-确认需求再执行**
当你说 `2-xxx` 时，AI会：
- ✅ 分析需求是否明确
- ✅ 检查是否有歧义
- ✅ 列出需要补充的信息
- ✅ 确认后再开始执行
**适用场景**：
- `2-修复登录bug` → 会先问：具体是什么bug？复现步骤？报错信息？
- `2-部署到服务器` → 会先问：服务器地址？部署路径？环境信息？
- `2-优化性能` → 会先问：哪里性能差？瓶颈在哪？目标是什么？
- `2-添加新功能` → 会先问：功能的具体需求？业务场景？
---
#### **3-简洁文档**
当你说 `3-xxx` 时，AI会：
- ✅ 只写必要内容
- ✅ 重点突出，步骤清晰
- ✅ 使用Markdown格式
- ❌ 不会写冗余内容
**适用场景**：
- `3-生成部署文档` → 只写部署步骤，不写原理
- `3-API使用说明` → 只写接口参数和返回值
- `3-配置说明` → 只写关键配置项
- `3-修复记录` → 只写问题、方案、结果
**特殊说明**：
- 如果不加 `3-`，默认不会主动生成文档
- 你可以指定文档路径：`3-生成部署文档到log/部署.md`
---
#### **4-理解功能逻辑**
当你说 `4-xxx` 时，AI会：
- ✅ 搜索相关代码
- ✅ 阅读核心逻辑
- ✅ 用简洁语言总结功能
- ✅ 提供实际应用场景
- ✅ 确认理解正确后再修改
**适用场景**：
- `4-学习记录功能` → 会分析代码，总结逻辑，给出应用场景
- `4-视频进度计算` → 会说明如何计算、何时更新、防快进逻辑
- `4-用户认证流程` → 会说明登录、Token、权限验证的完整流程
- `4-文件上传机制` → 会说明上传路径、大小限制、存储方式
**输出格式**：
```
功能逻辑总结：
1. 触发条件：xxx
2. 核心流程：xxx
3. 数据处理：xxx
4. 返回结果：xxx
应用场景示例：
当用户xxx时，系统会xxx
```
---
#### **5-记录配置信息**
当你说 `5-xxx` 时，AI会：
- ✅ 识别配置信息
- ✅ 自动记录到 `log/项目配置清单.md`
- ✅ 添加时间和用途说明
- ✅ 提醒你查看更新
**适用场景**：
- `5-新增OSS配置` → 记录endpoint、bucket、accessKey等
- `5-Redis密码改了` → 更新配置清单中的Redis配置
- `5-添加百度API` → 记录API Key、Secret、接口地址
- `5-服务器部署信息` → 记录服务器IP、路径、账号
**记录位置**：
- 文件：`log/项目配置清单.md`
- 格式：按分类自动追加到对应章节
---
### 组合使用
你可以组合使用多个编号：
**示例1**：`1,4-视频进度功能`
- 先用工具查找代码（原则1）
- 再理解功能逻辑（原则4）
**示例2**：`2,3-部署到生产环境`
- 先确认服务器信息（原则2）
- 再生成简洁的部署文档（原则3）
**示例3**：`1,5-查看Redis配置`
- 先读取配置文件（原则1）
- 再记录到配置清单（原则5）
---
### 快速对照表
| 你想要什么 | 使用编号 | AI会做什么 |
|-----------|---------|-----------|
| 查询信息 | `1-xxx` | 主动用工具查找 |
| 避免误解 | `2-xxx` | 先确认需求 |
| 生成文档 | `3-xxx` | 写简洁文档 |
| 理解代码 | `4-xxx` | 分析逻辑+场景 |
| 记录配置 | `5-xxx` | 自动记录到文件 |
---
*最后更新: 2025-12-12*

0
client/src/components/LivePlayer.js Normal file
View File

6
live-streaming/.env Normal file
View File

@ -0,0 +1,6 @@
NODE_ENV=development
PORT=3001
SRS_HOST=localhost
SRS_RTMP_PORT=1935
SRS_HTTP_PORT=8080
CLIENT_URL=http://localhost:3000

11
live-streaming/.env.example Normal file
View File

@ -0,0 +1,11 @@
# 服务器配置
NODE_ENV=development
PORT=3001
# SRS 配置
SRS_HOST=localhost
SRS_RTMP_PORT=1935
SRS_HTTP_PORT=8080
# 前端地址 (用于 CORS)
CLIENT_URL=http://localhost:3000

12
live-streaming/Dockerfile Normal file
View File

@ -0,0 +1,12 @@
FROM node:18-alpine
WORKDIR /app
COPY package*.json ./
RUN npm install --production
COPY server ./server
EXPOSE 3001
CMD ["node", "server/index.js"]

76
live-streaming/README.md Normal file
View File

@ -0,0 +1,76 @@
# 直播系统
基于 SRS 的个人直播系统，支持 RTMP 推流和 HTTP-FLV/HLS 播放。
## 快速开始
### 1. 安装依赖
```bash
# 后端依赖
npm install
# 前端依赖
cd client && npm install
```
### 2. 启动服务
**方式一：Docker 部署（推荐）**
```bash
docker-compose up -d
```
**方式二：本地开发**
```bash
# 终端1: 启动 SRS (需要先安装 Docker)
docker run -d -p 1935:1935 -p 8080:8080 ossrs/srs:5
# 终端2: 启动 API 服务
npm run dev
# 终端3: 启动前端
cd client && npm start
```
### 3. 访问系统
- 前端界面: http://localhost:3000
- API 服务: http://localhost:3001
## 使用方法
### 主播开播
1. 打开 http://localhost:3000
2. 点击"开始直播"，填写直播间信息
3. 复制推流地址和密钥
4. 打开 OBS，设置 → 推流：
- 服务: 自定义
- 服务器: `rtmp://localhost:1935/live`
- 推流密钥: 复制的密钥
5. 点击"开始推流"
### 观众观看
1. 打开 http://localhost:3000
2. 点击想看的直播间
3. 自动播放（优先使用低延迟的 HTTP-FLV）
## 技术栈
- 流媒体服务器: SRS 5.0
- 后端: Node.js + Express
- 前端: React 18 + flv.js + hls.js
- 容器化: Docker
## 端口说明
| 端口 | 服务 |
|------|------|
| 1935 | RTMP 推流 |
| 8080 | HTTP-FLV/HLS 播放 |
| 3001 | API 服务 |
| 3000 | 前端界面 |

1
live-streaming/client/.gitkeep Normal file
View File

@ -0,0 +1 @@
# Client directory

16
live-streaming/client/node_modules/.bin/acorn generated vendored Normal file
View File

@ -0,0 +1,16 @@
#!/bin/sh
basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
case `uname` in
*CYGWIN*|*MINGW*|*MSYS*)
if command -v cygpath > /dev/null 2>&1; then
basedir=`cygpath -w "$basedir"`
fi
;;
esac
if [ -x "$basedir/node" ]; then
exec "$basedir/node" "$basedir/../acorn/bin/acorn" "$@"
else
exec node "$basedir/../acorn/bin/acorn" "$@"
fi

17
live-streaming/client/node_modules/.bin/acorn.cmd generated vendored Normal file
View File

@ -0,0 +1,17 @@
@ECHO off
GOTO start
:find_dp0
SET dp0=%~dp0
EXIT /b
:start
SETLOCAL
CALL :find_dp0
IF EXIST "%dp0%\node.exe" (
SET "_prog=%dp0%\node.exe"
) ELSE (
SET "_prog=node"
SET PATHEXT=%PATHEXT:;.JS;=;%
)
endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%" "%dp0%\..\acorn\bin\acorn" %*

28
live-streaming/client/node_modules/.bin/acorn.ps1 generated vendored Normal file
View File

@ -0,0 +1,28 @@
#!/usr/bin/env pwsh
$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
$exe=""
if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
# Fix case when both the Windows and Linux builds of Node
# are installed in the same directory
$exe=".exe"
}
$ret=0
if (Test-Path "$basedir/node$exe") {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "$basedir/node$exe" "$basedir/../acorn/bin/acorn" $args
} else {
& "$basedir/node$exe" "$basedir/../acorn/bin/acorn" $args
}
$ret=$LASTEXITCODE
} else {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "node$exe" "$basedir/../acorn/bin/acorn" $args
} else {
& "node$exe" "$basedir/../acorn/bin/acorn" $args
}
$ret=$LASTEXITCODE
}
exit $ret

16
live-streaming/client/node_modules/.bin/ansi-html generated vendored Normal file
View File

@ -0,0 +1,16 @@
#!/bin/sh
basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
case `uname` in
*CYGWIN*|*MINGW*|*MSYS*)
if command -v cygpath > /dev/null 2>&1; then
basedir=`cygpath -w "$basedir"`
fi
;;
esac
if [ -x "$basedir/node" ]; then
exec "$basedir/node" "$basedir/../ansi-html/bin/ansi-html" "$@"
else
exec node "$basedir/../ansi-html/bin/ansi-html" "$@"
fi

17
live-streaming/client/node_modules/.bin/ansi-html.cmd generated vendored Normal file
View File

@ -0,0 +1,17 @@
@ECHO off
GOTO start
:find_dp0
SET dp0=%~dp0
EXIT /b
:start
SETLOCAL
CALL :find_dp0
IF EXIST "%dp0%\node.exe" (
SET "_prog=%dp0%\node.exe"
) ELSE (
SET "_prog=node"
SET PATHEXT=%PATHEXT:;.JS;=;%
)
endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%" "%dp0%\..\ansi-html\bin\ansi-html" %*

28
live-streaming/client/node_modules/.bin/ansi-html.ps1 generated vendored Normal file
View File

@ -0,0 +1,28 @@
#!/usr/bin/env pwsh
$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
$exe=""
if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
# Fix case when both the Windows and Linux builds of Node
# are installed in the same directory
$exe=".exe"
}
$ret=0
if (Test-Path "$basedir/node$exe") {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "$basedir/node$exe" "$basedir/../ansi-html/bin/ansi-html" $args
} else {
& "$basedir/node$exe" "$basedir/../ansi-html/bin/ansi-html" $args
}
$ret=$LASTEXITCODE
} else {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "node$exe" "$basedir/../ansi-html/bin/ansi-html" $args
} else {
& "node$exe" "$basedir/../ansi-html/bin/ansi-html" $args
}
$ret=$LASTEXITCODE
}
exit $ret

16
live-streaming/client/node_modules/.bin/autoprefixer generated vendored Normal file
View File

@ -0,0 +1,16 @@
#!/bin/sh
basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
case `uname` in
*CYGWIN*|*MINGW*|*MSYS*)
if command -v cygpath > /dev/null 2>&1; then
basedir=`cygpath -w "$basedir"`
fi
;;
esac
if [ -x "$basedir/node" ]; then
exec "$basedir/node" "$basedir/../autoprefixer/bin/autoprefixer" "$@"
else
exec node "$basedir/../autoprefixer/bin/autoprefixer" "$@"
fi

17
live-streaming/client/node_modules/.bin/autoprefixer.cmd generated vendored Normal file
View File

@ -0,0 +1,17 @@
@ECHO off
GOTO start
:find_dp0
SET dp0=%~dp0
EXIT /b
:start
SETLOCAL
CALL :find_dp0
IF EXIST "%dp0%\node.exe" (
SET "_prog=%dp0%\node.exe"
) ELSE (
SET "_prog=node"
SET PATHEXT=%PATHEXT:;.JS;=;%
)
endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%" "%dp0%\..\autoprefixer\bin\autoprefixer" %*

28
live-streaming/client/node_modules/.bin/autoprefixer.ps1 generated vendored Normal file
View File

@ -0,0 +1,28 @@
#!/usr/bin/env pwsh
$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
$exe=""
if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
# Fix case when both the Windows and Linux builds of Node
# are installed in the same directory
$exe=".exe"
}
$ret=0
if (Test-Path "$basedir/node$exe") {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "$basedir/node$exe" "$basedir/../autoprefixer/bin/autoprefixer" $args
} else {
& "$basedir/node$exe" "$basedir/../autoprefixer/bin/autoprefixer" $args
}
$ret=$LASTEXITCODE
} else {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "node$exe" "$basedir/../autoprefixer/bin/autoprefixer" $args
} else {
& "node$exe" "$basedir/../autoprefixer/bin/autoprefixer" $args
}
$ret=$LASTEXITCODE
}
exit $ret

16
live-streaming/client/node_modules/.bin/baseline-browser-mapping generated vendored Normal file
View File

@ -0,0 +1,16 @@
#!/bin/sh
basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
case `uname` in
*CYGWIN*|*MINGW*|*MSYS*)
if command -v cygpath > /dev/null 2>&1; then
basedir=`cygpath -w "$basedir"`
fi
;;
esac
if [ -x "$basedir/node" ]; then
exec "$basedir/node" "$basedir/../baseline-browser-mapping/dist/cli.js" "$@"
else
exec node "$basedir/../baseline-browser-mapping/dist/cli.js" "$@"
fi

17
live-streaming/client/node_modules/.bin/baseline-browser-mapping.cmd generated vendored Normal file
View File

@ -0,0 +1,17 @@
@ECHO off
GOTO start
:find_dp0
SET dp0=%~dp0
EXIT /b
:start
SETLOCAL
CALL :find_dp0
IF EXIST "%dp0%\node.exe" (
SET "_prog=%dp0%\node.exe"
) ELSE (
SET "_prog=node"
SET PATHEXT=%PATHEXT:;.JS;=;%
)
endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%" "%dp0%\..\baseline-browser-mapping\dist\cli.js" %*

28
live-streaming/client/node_modules/.bin/baseline-browser-mapping.ps1 generated vendored Normal file
View File

@ -0,0 +1,28 @@
#!/usr/bin/env pwsh
$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
$exe=""
if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
# Fix case when both the Windows and Linux builds of Node
# are installed in the same directory
$exe=".exe"
}
$ret=0
if (Test-Path "$basedir/node$exe") {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "$basedir/node$exe" "$basedir/../baseline-browser-mapping/dist/cli.js" $args
} else {
& "$basedir/node$exe" "$basedir/../baseline-browser-mapping/dist/cli.js" $args
}
$ret=$LASTEXITCODE
} else {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "node$exe" "$basedir/../baseline-browser-mapping/dist/cli.js" $args
} else {
& "node$exe" "$basedir/../baseline-browser-mapping/dist/cli.js" $args
}
$ret=$LASTEXITCODE
}
exit $ret

16
live-streaming/client/node_modules/.bin/browserslist generated vendored Normal file
View File

@ -0,0 +1,16 @@
#!/bin/sh
basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
case `uname` in
*CYGWIN*|*MINGW*|*MSYS*)
if command -v cygpath > /dev/null 2>&1; then
basedir=`cygpath -w "$basedir"`
fi
;;
esac
if [ -x "$basedir/node" ]; then
exec "$basedir/node" "$basedir/../browserslist/cli.js" "$@"
else
exec node "$basedir/../browserslist/cli.js" "$@"
fi

17
live-streaming/client/node_modules/.bin/browserslist.cmd generated vendored Normal file
View File

@ -0,0 +1,17 @@
@ECHO off
GOTO start
:find_dp0
SET dp0=%~dp0
EXIT /b
:start
SETLOCAL
CALL :find_dp0
IF EXIST "%dp0%\node.exe" (
SET "_prog=%dp0%\node.exe"
) ELSE (
SET "_prog=node"
SET PATHEXT=%PATHEXT:;.JS;=;%
)
endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%" "%dp0%\..\browserslist\cli.js" %*

28
live-streaming/client/node_modules/.bin/browserslist.ps1 generated vendored Normal file
View File

@ -0,0 +1,28 @@
#!/usr/bin/env pwsh
$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
$exe=""
if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
# Fix case when both the Windows and Linux builds of Node
# are installed in the same directory
$exe=".exe"
}
$ret=0
if (Test-Path "$basedir/node$exe") {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "$basedir/node$exe" "$basedir/../browserslist/cli.js" $args
} else {
& "$basedir/node$exe" "$basedir/../browserslist/cli.js" $args
}
$ret=$LASTEXITCODE
} else {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "node$exe" "$basedir/../browserslist/cli.js" $args
} else {
& "node$exe" "$basedir/../browserslist/cli.js" $args
}
$ret=$LASTEXITCODE
}
exit $ret

16
live-streaming/client/node_modules/.bin/css-blank-pseudo generated vendored Normal file
View File

@ -0,0 +1,16 @@
#!/bin/sh
basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
case `uname` in
*CYGWIN*|*MINGW*|*MSYS*)
if command -v cygpath > /dev/null 2>&1; then
basedir=`cygpath -w "$basedir"`
fi
;;
esac
if [ -x "$basedir/node" ]; then
exec "$basedir/node" "$basedir/../css-blank-pseudo/dist/cli.cjs" "$@"
else
exec node "$basedir/../css-blank-pseudo/dist/cli.cjs" "$@"
fi

17
live-streaming/client/node_modules/.bin/css-blank-pseudo.cmd generated vendored Normal file
View File

@ -0,0 +1,17 @@
@ECHO off
GOTO start
:find_dp0
SET dp0=%~dp0
EXIT /b
:start
SETLOCAL
CALL :find_dp0
IF EXIST "%dp0%\node.exe" (
SET "_prog=%dp0%\node.exe"
) ELSE (
SET "_prog=node"
SET PATHEXT=%PATHEXT:;.JS;=;%
)
endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%" "%dp0%\..\css-blank-pseudo\dist\cli.cjs" %*

28
live-streaming/client/node_modules/.bin/css-blank-pseudo.ps1 generated vendored Normal file
View File

@ -0,0 +1,28 @@
#!/usr/bin/env pwsh
$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
$exe=""
if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
# Fix case when both the Windows and Linux builds of Node
# are installed in the same directory
$exe=".exe"
}
$ret=0
if (Test-Path "$basedir/node$exe") {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "$basedir/node$exe" "$basedir/../css-blank-pseudo/dist/cli.cjs" $args
} else {
& "$basedir/node$exe" "$basedir/../css-blank-pseudo/dist/cli.cjs" $args
}
$ret=$LASTEXITCODE
} else {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "node$exe" "$basedir/../css-blank-pseudo/dist/cli.cjs" $args
} else {
& "node$exe" "$basedir/../css-blank-pseudo/dist/cli.cjs" $args
}
$ret=$LASTEXITCODE
}
exit $ret

16
live-streaming/client/node_modules/.bin/css-has-pseudo generated vendored Normal file
View File

@ -0,0 +1,16 @@
#!/bin/sh
basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
case `uname` in
*CYGWIN*|*MINGW*|*MSYS*)
if command -v cygpath > /dev/null 2>&1; then
basedir=`cygpath -w "$basedir"`
fi
;;
esac
if [ -x "$basedir/node" ]; then
exec "$basedir/node" "$basedir/../css-has-pseudo/dist/cli.cjs" "$@"
else
exec node "$basedir/../css-has-pseudo/dist/cli.cjs" "$@"
fi

17
live-streaming/client/node_modules/.bin/css-has-pseudo.cmd generated vendored Normal file
View File

@ -0,0 +1,17 @@
@ECHO off
GOTO start
:find_dp0
SET dp0=%~dp0
EXIT /b
:start
SETLOCAL
CALL :find_dp0
IF EXIST "%dp0%\node.exe" (
SET "_prog=%dp0%\node.exe"
) ELSE (
SET "_prog=node"
SET PATHEXT=%PATHEXT:;.JS;=;%
)
endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%" "%dp0%\..\css-has-pseudo\dist\cli.cjs" %*

28
live-streaming/client/node_modules/.bin/css-has-pseudo.ps1 generated vendored Normal file
View File

@ -0,0 +1,28 @@
#!/usr/bin/env pwsh
$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
$exe=""
if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
# Fix case when both the Windows and Linux builds of Node
# are installed in the same directory
$exe=".exe"
}
$ret=0
if (Test-Path "$basedir/node$exe") {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "$basedir/node$exe" "$basedir/../css-has-pseudo/dist/cli.cjs" $args
} else {
& "$basedir/node$exe" "$basedir/../css-has-pseudo/dist/cli.cjs" $args
}
$ret=$LASTEXITCODE
} else {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "node$exe" "$basedir/../css-has-pseudo/dist/cli.cjs" $args
} else {
& "node$exe" "$basedir/../css-has-pseudo/dist/cli.cjs" $args
}
$ret=$LASTEXITCODE
}
exit $ret

16
live-streaming/client/node_modules/.bin/css-prefers-color-scheme generated vendored Normal file
View File

@ -0,0 +1,16 @@
#!/bin/sh
basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
case `uname` in
*CYGWIN*|*MINGW*|*MSYS*)
if command -v cygpath > /dev/null 2>&1; then
basedir=`cygpath -w "$basedir"`
fi
;;
esac
if [ -x "$basedir/node" ]; then
exec "$basedir/node" "$basedir/../css-prefers-color-scheme/dist/cli.cjs" "$@"
else
exec node "$basedir/../css-prefers-color-scheme/dist/cli.cjs" "$@"
fi

17
live-streaming/client/node_modules/.bin/css-prefers-color-scheme.cmd generated vendored Normal file
View File

@ -0,0 +1,17 @@
@ECHO off
GOTO start
:find_dp0
SET dp0=%~dp0
EXIT /b
:start
SETLOCAL
CALL :find_dp0
IF EXIST "%dp0%\node.exe" (
SET "_prog=%dp0%\node.exe"
) ELSE (
SET "_prog=node"
SET PATHEXT=%PATHEXT:;.JS;=;%
)
endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%" "%dp0%\..\css-prefers-color-scheme\dist\cli.cjs" %*

28
live-streaming/client/node_modules/.bin/css-prefers-color-scheme.ps1 generated vendored Normal file
View File

@ -0,0 +1,28 @@
#!/usr/bin/env pwsh
$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
$exe=""
if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
# Fix case when both the Windows and Linux builds of Node
# are installed in the same directory
$exe=".exe"
}
$ret=0
if (Test-Path "$basedir/node$exe") {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "$basedir/node$exe" "$basedir/../css-prefers-color-scheme/dist/cli.cjs" $args
} else {
& "$basedir/node$exe" "$basedir/../css-prefers-color-scheme/dist/cli.cjs" $args
}
$ret=$LASTEXITCODE
} else {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "node$exe" "$basedir/../css-prefers-color-scheme/dist/cli.cjs" $args
} else {
& "node$exe" "$basedir/../css-prefers-color-scheme/dist/cli.cjs" $args
}
$ret=$LASTEXITCODE
}
exit $ret

16
live-streaming/client/node_modules/.bin/cssesc generated vendored Normal file
View File

@ -0,0 +1,16 @@
#!/bin/sh
basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
case `uname` in
*CYGWIN*|*MINGW*|*MSYS*)
if command -v cygpath > /dev/null 2>&1; then
basedir=`cygpath -w "$basedir"`
fi
;;
esac
if [ -x "$basedir/node" ]; then
exec "$basedir/node" "$basedir/../cssesc/bin/cssesc" "$@"
else
exec node "$basedir/../cssesc/bin/cssesc" "$@"
fi

17
live-streaming/client/node_modules/.bin/cssesc.cmd generated vendored Normal file
View File

@ -0,0 +1,17 @@
@ECHO off
GOTO start
:find_dp0
SET dp0=%~dp0
EXIT /b
:start
SETLOCAL
CALL :find_dp0
IF EXIST "%dp0%\node.exe" (
SET "_prog=%dp0%\node.exe"
) ELSE (
SET "_prog=node"
SET PATHEXT=%PATHEXT:;.JS;=;%
)
endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%" "%dp0%\..\cssesc\bin\cssesc" %*

28
live-streaming/client/node_modules/.bin/cssesc.ps1 generated vendored Normal file
View File

@ -0,0 +1,28 @@
#!/usr/bin/env pwsh
$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
$exe=""
if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
# Fix case when both the Windows and Linux builds of Node
# are installed in the same directory
$exe=".exe"
}
$ret=0
if (Test-Path "$basedir/node$exe") {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "$basedir/node$exe" "$basedir/../cssesc/bin/cssesc" $args
} else {
& "$basedir/node$exe" "$basedir/../cssesc/bin/cssesc" $args
}
$ret=$LASTEXITCODE
} else {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "node$exe" "$basedir/../cssesc/bin/cssesc" $args
} else {
& "node$exe" "$basedir/../cssesc/bin/cssesc" $args
}
$ret=$LASTEXITCODE
}
exit $ret

16
live-streaming/client/node_modules/.bin/detect generated vendored Normal file
View File

@ -0,0 +1,16 @@
#!/bin/sh
basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
case `uname` in
*CYGWIN*|*MINGW*|*MSYS*)
if command -v cygpath > /dev/null 2>&1; then
basedir=`cygpath -w "$basedir"`
fi
;;
esac
if [ -x "$basedir/node" ]; then
exec "$basedir/node" "$basedir/../detect-port-alt/bin/detect-port" "$@"
else
exec node "$basedir/../detect-port-alt/bin/detect-port" "$@"
fi

16
live-streaming/client/node_modules/.bin/detect-port generated vendored Normal file
View File

@ -0,0 +1,16 @@
#!/bin/sh
basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
case `uname` in
*CYGWIN*|*MINGW*|*MSYS*)
if command -v cygpath > /dev/null 2>&1; then
basedir=`cygpath -w "$basedir"`
fi
;;
esac
if [ -x "$basedir/node" ]; then
exec "$basedir/node" "$basedir/../detect-port-alt/bin/detect-port" "$@"
else
exec node "$basedir/../detect-port-alt/bin/detect-port" "$@"
fi

17
live-streaming/client/node_modules/.bin/detect-port.cmd generated vendored Normal file
View File

@ -0,0 +1,17 @@
@ECHO off
GOTO start
:find_dp0
SET dp0=%~dp0
EXIT /b
:start
SETLOCAL
CALL :find_dp0
IF EXIST "%dp0%\node.exe" (
SET "_prog=%dp0%\node.exe"
) ELSE (
SET "_prog=node"
SET PATHEXT=%PATHEXT:;.JS;=;%
)
endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%" "%dp0%\..\detect-port-alt\bin\detect-port" %*

28
live-streaming/client/node_modules/.bin/detect-port.ps1 generated vendored Normal file
View File

@ -0,0 +1,28 @@
#!/usr/bin/env pwsh
$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
$exe=""
if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
# Fix case when both the Windows and Linux builds of Node
# are installed in the same directory
$exe=".exe"
}
$ret=0
if (Test-Path "$basedir/node$exe") {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "$basedir/node$exe" "$basedir/../detect-port-alt/bin/detect-port" $args
} else {
& "$basedir/node$exe" "$basedir/../detect-port-alt/bin/detect-port" $args
}
$ret=$LASTEXITCODE
} else {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "node$exe" "$basedir/../detect-port-alt/bin/detect-port" $args
} else {
& "node$exe" "$basedir/../detect-port-alt/bin/detect-port" $args
}
$ret=$LASTEXITCODE
}
exit $ret

17
live-streaming/client/node_modules/.bin/detect.cmd generated vendored Normal file
View File

@ -0,0 +1,17 @@
@ECHO off
GOTO start
:find_dp0
SET dp0=%~dp0
EXIT /b
:start
SETLOCAL
CALL :find_dp0
IF EXIST "%dp0%\node.exe" (
SET "_prog=%dp0%\node.exe"
) ELSE (
SET "_prog=node"
SET PATHEXT=%PATHEXT:;.JS;=;%
)
endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%" "%dp0%\..\detect-port-alt\bin\detect-port" %*

28
live-streaming/client/node_modules/.bin/detect.ps1 generated vendored Normal file
View File

@ -0,0 +1,28 @@
#!/usr/bin/env pwsh
$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
$exe=""
if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
# Fix case when both the Windows and Linux builds of Node
# are installed in the same directory
$exe=".exe"
}
$ret=0
if (Test-Path "$basedir/node$exe") {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "$basedir/node$exe" "$basedir/../detect-port-alt/bin/detect-port" $args
} else {
& "$basedir/node$exe" "$basedir/../detect-port-alt/bin/detect-port" $args
}
$ret=$LASTEXITCODE
} else {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "node$exe" "$basedir/../detect-port-alt/bin/detect-port" $args
} else {
& "node$exe" "$basedir/../detect-port-alt/bin/detect-port" $args
}
$ret=$LASTEXITCODE
}
exit $ret

16
live-streaming/client/node_modules/.bin/ejs generated vendored Normal file
View File

@ -0,0 +1,16 @@
#!/bin/sh
basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
case `uname` in
*CYGWIN*|*MINGW*|*MSYS*)
if command -v cygpath > /dev/null 2>&1; then
basedir=`cygpath -w "$basedir"`
fi
;;
esac
if [ -x "$basedir/node" ]; then
exec "$basedir/node" "$basedir/../ejs/bin/cli.js" "$@"
else
exec node "$basedir/../ejs/bin/cli.js" "$@"
fi

17
live-streaming/client/node_modules/.bin/ejs.cmd generated vendored Normal file
View File

@ -0,0 +1,17 @@
@ECHO off
GOTO start
:find_dp0
SET dp0=%~dp0
EXIT /b
:start
SETLOCAL
CALL :find_dp0
IF EXIST "%dp0%\node.exe" (
SET "_prog=%dp0%\node.exe"
) ELSE (
SET "_prog=node"
SET PATHEXT=%PATHEXT:;.JS;=;%
)
endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%" "%dp0%\..\ejs\bin\cli.js" %*

28
live-streaming/client/node_modules/.bin/ejs.ps1 generated vendored Normal file
View File

@ -0,0 +1,28 @@
#!/usr/bin/env pwsh
$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
$exe=""
if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
# Fix case when both the Windows and Linux builds of Node
# are installed in the same directory
$exe=".exe"
}
$ret=0
if (Test-Path "$basedir/node$exe") {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "$basedir/node$exe" "$basedir/../ejs/bin/cli.js" $args
} else {
& "$basedir/node$exe" "$basedir/../ejs/bin/cli.js" $args
}
$ret=$LASTEXITCODE
} else {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "node$exe" "$basedir/../ejs/bin/cli.js" $args
} else {
& "node$exe" "$basedir/../ejs/bin/cli.js" $args
}
$ret=$LASTEXITCODE
}
exit $ret

16
live-streaming/client/node_modules/.bin/escodegen generated vendored Normal file
View File

@ -0,0 +1,16 @@
#!/bin/sh
basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
case `uname` in
*CYGWIN*|*MINGW*|*MSYS*)
if command -v cygpath > /dev/null 2>&1; then
basedir=`cygpath -w "$basedir"`
fi
;;
esac
if [ -x "$basedir/node" ]; then
exec "$basedir/node" "$basedir/../escodegen/bin/escodegen.js" "$@"
else
exec node "$basedir/../escodegen/bin/escodegen.js" "$@"
fi

17
live-streaming/client/node_modules/.bin/escodegen.cmd generated vendored Normal file
View File

@ -0,0 +1,17 @@
@ECHO off
GOTO start
:find_dp0
SET dp0=%~dp0
EXIT /b
:start
SETLOCAL
CALL :find_dp0
IF EXIST "%dp0%\node.exe" (
SET "_prog=%dp0%\node.exe"
) ELSE (
SET "_prog=node"
SET PATHEXT=%PATHEXT:;.JS;=;%
)
endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%" "%dp0%\..\escodegen\bin\escodegen.js" %*

28
live-streaming/client/node_modules/.bin/escodegen.ps1 generated vendored Normal file
View File

@ -0,0 +1,28 @@
#!/usr/bin/env pwsh
$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
$exe=""
if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
# Fix case when both the Windows and Linux builds of Node
# are installed in the same directory
$exe=".exe"
}
$ret=0
if (Test-Path "$basedir/node$exe") {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "$basedir/node$exe" "$basedir/../escodegen/bin/escodegen.js" $args
} else {
& "$basedir/node$exe" "$basedir/../escodegen/bin/escodegen.js" $args
}
$ret=$LASTEXITCODE
} else {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "node$exe" "$basedir/../escodegen/bin/escodegen.js" $args
} else {
& "node$exe" "$basedir/../escodegen/bin/escodegen.js" $args
}
$ret=$LASTEXITCODE
}
exit $ret

16
live-streaming/client/node_modules/.bin/esgenerate generated vendored Normal file
View File

@ -0,0 +1,16 @@
#!/bin/sh
basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
case `uname` in
*CYGWIN*|*MINGW*|*MSYS*)
if command -v cygpath > /dev/null 2>&1; then
basedir=`cygpath -w "$basedir"`
fi
;;
esac
if [ -x "$basedir/node" ]; then
exec "$basedir/node" "$basedir/../escodegen/bin/esgenerate.js" "$@"
else
exec node "$basedir/../escodegen/bin/esgenerate.js" "$@"
fi

17
live-streaming/client/node_modules/.bin/esgenerate.cmd generated vendored Normal file
View File

@ -0,0 +1,17 @@
@ECHO off
GOTO start
:find_dp0
SET dp0=%~dp0
EXIT /b
:start
SETLOCAL
CALL :find_dp0
IF EXIST "%dp0%\node.exe" (
SET "_prog=%dp0%\node.exe"
) ELSE (
SET "_prog=node"
SET PATHEXT=%PATHEXT:;.JS;=;%
)
endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%" "%dp0%\..\escodegen\bin\esgenerate.js" %*

28
live-streaming/client/node_modules/.bin/esgenerate.ps1 generated vendored Normal file
View File

@ -0,0 +1,28 @@
#!/usr/bin/env pwsh
$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
$exe=""
if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
# Fix case when both the Windows and Linux builds of Node
# are installed in the same directory
$exe=".exe"
}
$ret=0
if (Test-Path "$basedir/node$exe") {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "$basedir/node$exe" "$basedir/../escodegen/bin/esgenerate.js" $args
} else {
& "$basedir/node$exe" "$basedir/../escodegen/bin/esgenerate.js" $args
}
$ret=$LASTEXITCODE
} else {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "node$exe" "$basedir/../escodegen/bin/esgenerate.js" $args
} else {
& "node$exe" "$basedir/../escodegen/bin/esgenerate.js" $args
}
$ret=$LASTEXITCODE
}
exit $ret

16
live-streaming/client/node_modules/.bin/eslint generated vendored Normal file
View File

@ -0,0 +1,16 @@
#!/bin/sh
basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
case `uname` in
*CYGWIN*|*MINGW*|*MSYS*)
if command -v cygpath > /dev/null 2>&1; then
basedir=`cygpath -w "$basedir"`
fi
;;
esac
if [ -x "$basedir/node" ]; then
exec "$basedir/node" "$basedir/../eslint/bin/eslint.js" "$@"
else
exec node "$basedir/../eslint/bin/eslint.js" "$@"
fi

17
live-streaming/client/node_modules/.bin/eslint.cmd generated vendored Normal file
View File

@ -0,0 +1,17 @@
@ECHO off
GOTO start
:find_dp0
SET dp0=%~dp0
EXIT /b
:start
SETLOCAL
CALL :find_dp0
IF EXIST "%dp0%\node.exe" (
SET "_prog=%dp0%\node.exe"
) ELSE (
SET "_prog=node"
SET PATHEXT=%PATHEXT:;.JS;=;%
)
endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%" "%dp0%\..\eslint\bin\eslint.js" %*

28
live-streaming/client/node_modules/.bin/eslint.ps1 generated vendored Normal file
View File

@ -0,0 +1,28 @@
#!/usr/bin/env pwsh
$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
$exe=""
if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
# Fix case when both the Windows and Linux builds of Node
# are installed in the same directory
$exe=".exe"
}
$ret=0
if (Test-Path "$basedir/node$exe") {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "$basedir/node$exe" "$basedir/../eslint/bin/eslint.js" $args
} else {
& "$basedir/node$exe" "$basedir/../eslint/bin/eslint.js" $args
}
$ret=$LASTEXITCODE
} else {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "node$exe" "$basedir/../eslint/bin/eslint.js" $args
} else {
& "node$exe" "$basedir/../eslint/bin/eslint.js" $args
}
$ret=$LASTEXITCODE
}
exit $ret

16
live-streaming/client/node_modules/.bin/esparse generated vendored Normal file
View File

@ -0,0 +1,16 @@
#!/bin/sh
basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
case `uname` in
*CYGWIN*|*MINGW*|*MSYS*)
if command -v cygpath > /dev/null 2>&1; then
basedir=`cygpath -w "$basedir"`
fi
;;
esac
if [ -x "$basedir/node" ]; then
exec "$basedir/node" "$basedir/../esprima/bin/esparse.js" "$@"
else
exec node "$basedir/../esprima/bin/esparse.js" "$@"
fi

17
live-streaming/client/node_modules/.bin/esparse.cmd generated vendored Normal file
View File

@ -0,0 +1,17 @@
@ECHO off
GOTO start
:find_dp0
SET dp0=%~dp0
EXIT /b
:start
SETLOCAL
CALL :find_dp0
IF EXIST "%dp0%\node.exe" (
SET "_prog=%dp0%\node.exe"
) ELSE (
SET "_prog=node"
SET PATHEXT=%PATHEXT:;.JS;=;%
)
endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%" "%dp0%\..\esprima\bin\esparse.js" %*

28
live-streaming/client/node_modules/.bin/esparse.ps1 generated vendored Normal file
View File

@ -0,0 +1,28 @@
#!/usr/bin/env pwsh
$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
$exe=""
if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
# Fix case when both the Windows and Linux builds of Node
# are installed in the same directory
$exe=".exe"
}
$ret=0
if (Test-Path "$basedir/node$exe") {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "$basedir/node$exe" "$basedir/../esprima/bin/esparse.js" $args
} else {
& "$basedir/node$exe" "$basedir/../esprima/bin/esparse.js" $args
}
$ret=$LASTEXITCODE
} else {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "node$exe" "$basedir/../esprima/bin/esparse.js" $args
} else {
& "node$exe" "$basedir/../esprima/bin/esparse.js" $args
}
$ret=$LASTEXITCODE
}
exit $ret

16
live-streaming/client/node_modules/.bin/esvalidate generated vendored Normal file
View File

@ -0,0 +1,16 @@
#!/bin/sh
basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
case `uname` in
*CYGWIN*|*MINGW*|*MSYS*)
if command -v cygpath > /dev/null 2>&1; then
basedir=`cygpath -w "$basedir"`
fi
;;
esac
if [ -x "$basedir/node" ]; then
exec "$basedir/node" "$basedir/../esprima/bin/esvalidate.js" "$@"
else
exec node "$basedir/../esprima/bin/esvalidate.js" "$@"
fi

17
live-streaming/client/node_modules/.bin/esvalidate.cmd generated vendored Normal file
View File

@ -0,0 +1,17 @@
@ECHO off
GOTO start
:find_dp0
SET dp0=%~dp0
EXIT /b
:start
SETLOCAL
CALL :find_dp0
IF EXIST "%dp0%\node.exe" (
SET "_prog=%dp0%\node.exe"
) ELSE (
SET "_prog=node"
SET PATHEXT=%PATHEXT:;.JS;=;%
)
endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%" "%dp0%\..\esprima\bin\esvalidate.js" %*

28
live-streaming/client/node_modules/.bin/esvalidate.ps1 generated vendored Normal file
View File

@ -0,0 +1,28 @@
#!/usr/bin/env pwsh
$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
$exe=""
if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
# Fix case when both the Windows and Linux builds of Node
# are installed in the same directory
$exe=".exe"
}
$ret=0
if (Test-Path "$basedir/node$exe") {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "$basedir/node$exe" "$basedir/../esprima/bin/esvalidate.js" $args
} else {
& "$basedir/node$exe" "$basedir/../esprima/bin/esvalidate.js" $args
}
$ret=$LASTEXITCODE
} else {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "node$exe" "$basedir/../esprima/bin/esvalidate.js" $args
} else {
& "node$exe" "$basedir/../esprima/bin/esvalidate.js" $args
}
$ret=$LASTEXITCODE
}
exit $ret

16
live-streaming/client/node_modules/.bin/he generated vendored Normal file
View File

@ -0,0 +1,16 @@
#!/bin/sh
basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
case `uname` in
*CYGWIN*|*MINGW*|*MSYS*)
if command -v cygpath > /dev/null 2>&1; then
basedir=`cygpath -w "$basedir"`
fi
;;
esac
if [ -x "$basedir/node" ]; then
exec "$basedir/node" "$basedir/../he/bin/he" "$@"
else
exec node "$basedir/../he/bin/he" "$@"
fi

17
live-streaming/client/node_modules/.bin/he.cmd generated vendored Normal file
View File

@ -0,0 +1,17 @@
@ECHO off
GOTO start
:find_dp0
SET dp0=%~dp0
EXIT /b
:start
SETLOCAL
CALL :find_dp0
IF EXIST "%dp0%\node.exe" (
SET "_prog=%dp0%\node.exe"
) ELSE (
SET "_prog=node"
SET PATHEXT=%PATHEXT:;.JS;=;%
)
endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%" "%dp0%\..\he\bin\he" %*

28
live-streaming/client/node_modules/.bin/he.ps1 generated vendored Normal file
View File

@ -0,0 +1,28 @@
#!/usr/bin/env pwsh
$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
$exe=""
if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
# Fix case when both the Windows and Linux builds of Node
# are installed in the same directory
$exe=".exe"
}
$ret=0
if (Test-Path "$basedir/node$exe") {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "$basedir/node$exe" "$basedir/../he/bin/he" $args
} else {
& "$basedir/node$exe" "$basedir/../he/bin/he" $args
}
$ret=$LASTEXITCODE
} else {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "node$exe" "$basedir/../he/bin/he" $args
} else {
& "node$exe" "$basedir/../he/bin/he" $args
}
$ret=$LASTEXITCODE
}
exit $ret

16
live-streaming/client/node_modules/.bin/html-minifier-terser generated vendored Normal file
View File

@ -0,0 +1,16 @@
#!/bin/sh
basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
case `uname` in
*CYGWIN*|*MINGW*|*MSYS*)
if command -v cygpath > /dev/null 2>&1; then
basedir=`cygpath -w "$basedir"`
fi
;;
esac
if [ -x "$basedir/node" ]; then
exec "$basedir/node" "$basedir/../html-minifier-terser/cli.js" "$@"
else
exec node "$basedir/../html-minifier-terser/cli.js" "$@"
fi

17
live-streaming/client/node_modules/.bin/html-minifier-terser.cmd generated vendored Normal file
View File

@ -0,0 +1,17 @@
@ECHO off
GOTO start
:find_dp0
SET dp0=%~dp0
EXIT /b
:start
SETLOCAL
CALL :find_dp0
IF EXIST "%dp0%\node.exe" (
SET "_prog=%dp0%\node.exe"
) ELSE (
SET "_prog=node"
SET PATHEXT=%PATHEXT:;.JS;=;%
)
endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%" "%dp0%\..\html-minifier-terser\cli.js" %*

28
live-streaming/client/node_modules/.bin/html-minifier-terser.ps1 generated vendored Normal file
View File

@ -0,0 +1,28 @@
#!/usr/bin/env pwsh
$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
$exe=""
if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
# Fix case when both the Windows and Linux builds of Node
# are installed in the same directory
$exe=".exe"
}
$ret=0
if (Test-Path "$basedir/node$exe") {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "$basedir/node$exe" "$basedir/../html-minifier-terser/cli.js" $args
} else {
& "$basedir/node$exe" "$basedir/../html-minifier-terser/cli.js" $args
}
$ret=$LASTEXITCODE
} else {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "node$exe" "$basedir/../html-minifier-terser/cli.js" $args
} else {
& "node$exe" "$basedir/../html-minifier-terser/cli.js" $args
}
$ret=$LASTEXITCODE
}
exit $ret

16
live-streaming/client/node_modules/.bin/import-local-fixture generated vendored Normal file
View File

@ -0,0 +1,16 @@
#!/bin/sh
basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
case `uname` in
*CYGWIN*|*MINGW*|*MSYS*)
if command -v cygpath > /dev/null 2>&1; then
basedir=`cygpath -w "$basedir"`
fi
;;
esac
if [ -x "$basedir/node" ]; then
exec "$basedir/node" "$basedir/../import-local/fixtures/cli.js" "$@"
else
exec node "$basedir/../import-local/fixtures/cli.js" "$@"
fi

17
live-streaming/client/node_modules/.bin/import-local-fixture.cmd generated vendored Normal file
View File

@ -0,0 +1,17 @@
@ECHO off
GOTO start
:find_dp0
SET dp0=%~dp0
EXIT /b
:start
SETLOCAL
CALL :find_dp0
IF EXIST "%dp0%\node.exe" (
SET "_prog=%dp0%\node.exe"
) ELSE (
SET "_prog=node"
SET PATHEXT=%PATHEXT:;.JS;=;%
)
endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%" "%dp0%\..\import-local\fixtures\cli.js" %*

28
live-streaming/client/node_modules/.bin/import-local-fixture.ps1 generated vendored Normal file
View File

@ -0,0 +1,28 @@
#!/usr/bin/env pwsh
$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
$exe=""
if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
# Fix case when both the Windows and Linux builds of Node
# are installed in the same directory
$exe=".exe"
}
$ret=0
if (Test-Path "$basedir/node$exe") {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "$basedir/node$exe" "$basedir/../import-local/fixtures/cli.js" $args
} else {
& "$basedir/node$exe" "$basedir/../import-local/fixtures/cli.js" $args
}
$ret=$LASTEXITCODE
} else {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "node$exe" "$basedir/../import-local/fixtures/cli.js" $args
} else {
& "node$exe" "$basedir/../import-local/fixtures/cli.js" $args
}
$ret=$LASTEXITCODE
}
exit $ret

16
live-streaming/client/node_modules/.bin/is-docker generated vendored Normal file
View File

@ -0,0 +1,16 @@
#!/bin/sh
basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
case `uname` in
*CYGWIN*|*MINGW*|*MSYS*)
if command -v cygpath > /dev/null 2>&1; then
basedir=`cygpath -w "$basedir"`
fi
;;
esac
if [ -x "$basedir/node" ]; then
exec "$basedir/node" "$basedir/../is-docker/cli.js" "$@"
else
exec node "$basedir/../is-docker/cli.js" "$@"
fi

17
live-streaming/client/node_modules/.bin/is-docker.cmd generated vendored Normal file
View File

@ -0,0 +1,17 @@
@ECHO off
GOTO start
:find_dp0
SET dp0=%~dp0
EXIT /b
:start
SETLOCAL
CALL :find_dp0
IF EXIST "%dp0%\node.exe" (
SET "_prog=%dp0%\node.exe"
) ELSE (
SET "_prog=node"
SET PATHEXT=%PATHEXT:;.JS;=;%
)
endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%" "%dp0%\..\is-docker\cli.js" %*

28
live-streaming/client/node_modules/.bin/is-docker.ps1 generated vendored Normal file
View File

@ -0,0 +1,28 @@
#!/usr/bin/env pwsh
$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
$exe=""
if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
# Fix case when both the Windows and Linux builds of Node
# are installed in the same directory
$exe=".exe"
}
$ret=0
if (Test-Path "$basedir/node$exe") {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "$basedir/node$exe" "$basedir/../is-docker/cli.js" $args
} else {
& "$basedir/node$exe" "$basedir/../is-docker/cli.js" $args
}
$ret=$LASTEXITCODE
} else {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "node$exe" "$basedir/../is-docker/cli.js" $args
} else {
& "node$exe" "$basedir/../is-docker/cli.js" $args
}
$ret=$LASTEXITCODE
}
exit $ret

16
live-streaming/client/node_modules/.bin/jake generated vendored Normal file
View File

@ -0,0 +1,16 @@
#!/bin/sh
basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
case `uname` in
*CYGWIN*|*MINGW*|*MSYS*)
if command -v cygpath > /dev/null 2>&1; then
basedir=`cygpath -w "$basedir"`
fi
;;
esac
if [ -x "$basedir/node" ]; then
exec "$basedir/node" "$basedir/../jake/bin/cli.js" "$@"
else
exec node "$basedir/../jake/bin/cli.js" "$@"
fi

17
live-streaming/client/node_modules/.bin/jake.cmd generated vendored Normal file
View File

@ -0,0 +1,17 @@
@ECHO off
GOTO start
:find_dp0
SET dp0=%~dp0
EXIT /b
:start
SETLOCAL
CALL :find_dp0
IF EXIST "%dp0%\node.exe" (
SET "_prog=%dp0%\node.exe"
) ELSE (
SET "_prog=node"
SET PATHEXT=%PATHEXT:;.JS;=;%
)
endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%" "%dp0%\..\jake\bin\cli.js" %*

28
live-streaming/client/node_modules/.bin/jake.ps1 generated vendored Normal file
View File

@ -0,0 +1,28 @@
#!/usr/bin/env pwsh
$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
$exe=""
if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
# Fix case when both the Windows and Linux builds of Node
# are installed in the same directory
$exe=".exe"
}
$ret=0
if (Test-Path "$basedir/node$exe") {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "$basedir/node$exe" "$basedir/../jake/bin/cli.js" $args
} else {
& "$basedir/node$exe" "$basedir/../jake/bin/cli.js" $args
}
$ret=$LASTEXITCODE
} else {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "node$exe" "$basedir/../jake/bin/cli.js" $args
} else {
& "node$exe" "$basedir/../jake/bin/cli.js" $args
}
$ret=$LASTEXITCODE
}
exit $ret

16
live-streaming/client/node_modules/.bin/jest generated vendored Normal file
View File

@ -0,0 +1,16 @@
#!/bin/sh
basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
case `uname` in
*CYGWIN*|*MINGW*|*MSYS*)
if command -v cygpath > /dev/null 2>&1; then
basedir=`cygpath -w "$basedir"`
fi
;;
esac
if [ -x "$basedir/node" ]; then
exec "$basedir/node" "$basedir/../jest/bin/jest.js" "$@"
else
exec node "$basedir/../jest/bin/jest.js" "$@"
fi

17
live-streaming/client/node_modules/.bin/jest.cmd generated vendored Normal file
View File

@ -0,0 +1,17 @@
@ECHO off
GOTO start
:find_dp0
SET dp0=%~dp0
EXIT /b
:start
SETLOCAL
CALL :find_dp0
IF EXIST "%dp0%\node.exe" (
SET "_prog=%dp0%\node.exe"
) ELSE (
SET "_prog=node"
SET PATHEXT=%PATHEXT:;.JS;=;%
)
endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%" "%dp0%\..\jest\bin\jest.js" %*

28
live-streaming/client/node_modules/.bin/jest.ps1 generated vendored Normal file
View File

@ -0,0 +1,28 @@
#!/usr/bin/env pwsh
$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
$exe=""
if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
# Fix case when both the Windows and Linux builds of Node
# are installed in the same directory
$exe=".exe"
}
$ret=0
if (Test-Path "$basedir/node$exe") {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "$basedir/node$exe" "$basedir/../jest/bin/jest.js" $args
} else {
& "$basedir/node$exe" "$basedir/../jest/bin/jest.js" $args
}
$ret=$LASTEXITCODE
} else {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "node$exe" "$basedir/../jest/bin/jest.js" $args
} else {
& "node$exe" "$basedir/../jest/bin/jest.js" $args
}
$ret=$LASTEXITCODE
}
exit $ret

16
live-streaming/client/node_modules/.bin/jiti generated vendored Normal file
View File

@ -0,0 +1,16 @@
#!/bin/sh
basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
case `uname` in
*CYGWIN*|*MINGW*|*MSYS*)
if command -v cygpath > /dev/null 2>&1; then
basedir=`cygpath -w "$basedir"`
fi
;;
esac
if [ -x "$basedir/node" ]; then
exec "$basedir/node" "$basedir/../jiti/bin/jiti.js" "$@"
else
exec node "$basedir/../jiti/bin/jiti.js" "$@"
fi

17
live-streaming/client/node_modules/.bin/jiti.cmd generated vendored Normal file
View File

@ -0,0 +1,17 @@
@ECHO off
GOTO start
:find_dp0
SET dp0=%~dp0
EXIT /b
:start
SETLOCAL
CALL :find_dp0
IF EXIST "%dp0%\node.exe" (
SET "_prog=%dp0%\node.exe"
) ELSE (
SET "_prog=node"
SET PATHEXT=%PATHEXT:;.JS;=;%
)
endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%" "%dp0%\..\jiti\bin\jiti.js" %*

28
live-streaming/client/node_modules/.bin/jiti.ps1 generated vendored Normal file
View File

@ -0,0 +1,28 @@
#!/usr/bin/env pwsh
$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
$exe=""
if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
# Fix case when both the Windows and Linux builds of Node
# are installed in the same directory
$exe=".exe"
}
$ret=0
if (Test-Path "$basedir/node$exe") {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "$basedir/node$exe" "$basedir/../jiti/bin/jiti.js" $args
} else {
& "$basedir/node$exe" "$basedir/../jiti/bin/jiti.js" $args
}
$ret=$LASTEXITCODE
} else {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "node$exe" "$basedir/../jiti/bin/jiti.js" $args
} else {
& "node$exe" "$basedir/../jiti/bin/jiti.js" $args
}
$ret=$LASTEXITCODE
}
exit $ret

16
live-streaming/client/node_modules/.bin/js-yaml generated vendored Normal file
View File

@ -0,0 +1,16 @@
#!/bin/sh
basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
case `uname` in
*CYGWIN*|*MINGW*|*MSYS*)
if command -v cygpath > /dev/null 2>&1; then
basedir=`cygpath -w "$basedir"`
fi
;;
esac
if [ -x "$basedir/node" ]; then
exec "$basedir/node" "$basedir/../js-yaml/bin/js-yaml.js" "$@"
else
exec node "$basedir/../js-yaml/bin/js-yaml.js" "$@"
fi

17
live-streaming/client/node_modules/.bin/js-yaml.cmd generated vendored Normal file
View File

@ -0,0 +1,17 @@
@ECHO off
GOTO start
:find_dp0
SET dp0=%~dp0
EXIT /b
:start
SETLOCAL
CALL :find_dp0
IF EXIST "%dp0%\node.exe" (
SET "_prog=%dp0%\node.exe"
) ELSE (
SET "_prog=node"
SET PATHEXT=%PATHEXT:;.JS;=;%
)
endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%" "%dp0%\..\js-yaml\bin\js-yaml.js" %*

28
live-streaming/client/node_modules/.bin/js-yaml.ps1 generated vendored Normal file
View File

@ -0,0 +1,28 @@
#!/usr/bin/env pwsh
$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
$exe=""
if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
# Fix case when both the Windows and Linux builds of Node
# are installed in the same directory
$exe=".exe"
}
$ret=0
if (Test-Path "$basedir/node$exe") {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "$basedir/node$exe" "$basedir/../js-yaml/bin/js-yaml.js" $args
} else {
& "$basedir/node$exe" "$basedir/../js-yaml/bin/js-yaml.js" $args
}
$ret=$LASTEXITCODE
} else {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "node$exe" "$basedir/../js-yaml/bin/js-yaml.js" $args
} else {
& "node$exe" "$basedir/../js-yaml/bin/js-yaml.js" $args
}
$ret=$LASTEXITCODE
}
exit $ret

16
live-streaming/client/node_modules/.bin/jsesc generated vendored Normal file
View File

@ -0,0 +1,16 @@
#!/bin/sh
basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
case `uname` in
*CYGWIN*|*MINGW*|*MSYS*)
if command -v cygpath > /dev/null 2>&1; then
basedir=`cygpath -w "$basedir"`
fi
;;
esac
if [ -x "$basedir/node" ]; then
exec "$basedir/node" "$basedir/../jsesc/bin/jsesc" "$@"
else
exec node "$basedir/../jsesc/bin/jsesc" "$@"
fi

17
live-streaming/client/node_modules/.bin/jsesc.cmd generated vendored Normal file
View File

@ -0,0 +1,17 @@
@ECHO off
GOTO start
:find_dp0
SET dp0=%~dp0
EXIT /b
:start
SETLOCAL
CALL :find_dp0
IF EXIST "%dp0%\node.exe" (
SET "_prog=%dp0%\node.exe"
) ELSE (
SET "_prog=node"
SET PATHEXT=%PATHEXT:;.JS;=;%
)
endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%" "%dp0%\..\jsesc\bin\jsesc" %*

28
live-streaming/client/node_modules/.bin/jsesc.ps1 generated vendored Normal file
View File

@ -0,0 +1,28 @@
#!/usr/bin/env pwsh
$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
$exe=""
if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
# Fix case when both the Windows and Linux builds of Node
# are installed in the same directory
$exe=".exe"
}
$ret=0
if (Test-Path "$basedir/node$exe") {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "$basedir/node$exe" "$basedir/../jsesc/bin/jsesc" $args
} else {
& "$basedir/node$exe" "$basedir/../jsesc/bin/jsesc" $args
}
$ret=$LASTEXITCODE
} else {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "node$exe" "$basedir/../jsesc/bin/jsesc" $args
} else {
& "node$exe" "$basedir/../jsesc/bin/jsesc" $args
}
$ret=$LASTEXITCODE
}
exit $ret

16
live-streaming/client/node_modules/.bin/json5 generated vendored Normal file
View File

@ -0,0 +1,16 @@
#!/bin/sh
basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
case `uname` in
*CYGWIN*|*MINGW*|*MSYS*)
if command -v cygpath > /dev/null 2>&1; then
basedir=`cygpath -w "$basedir"`
fi
;;
esac
if [ -x "$basedir/node" ]; then
exec "$basedir/node" "$basedir/../json5/lib/cli.js" "$@"
else
exec node "$basedir/../json5/lib/cli.js" "$@"
fi

17
live-streaming/client/node_modules/.bin/json5.cmd generated vendored Normal file
View File

@ -0,0 +1,17 @@
@ECHO off
GOTO start
:find_dp0
SET dp0=%~dp0
EXIT /b
:start
SETLOCAL
CALL :find_dp0
IF EXIST "%dp0%\node.exe" (
SET "_prog=%dp0%\node.exe"
) ELSE (
SET "_prog=node"
SET PATHEXT=%PATHEXT:;.JS;=;%
)
endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%" "%dp0%\..\json5\lib\cli.js" %*

28
live-streaming/client/node_modules/.bin/json5.ps1 generated vendored Normal file
View File

@ -0,0 +1,28 @@
#!/usr/bin/env pwsh
$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
$exe=""
if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
# Fix case when both the Windows and Linux builds of Node
# are installed in the same directory
$exe=".exe"
}
$ret=0
if (Test-Path "$basedir/node$exe") {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "$basedir/node$exe" "$basedir/../json5/lib/cli.js" $args
} else {
& "$basedir/node$exe" "$basedir/../json5/lib/cli.js" $args
}
$ret=$LASTEXITCODE
} else {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "node$exe" "$basedir/../json5/lib/cli.js" $args
} else {
& "node$exe" "$basedir/../json5/lib/cli.js" $args
}
$ret=$LASTEXITCODE
}
exit $ret

16
live-streaming/client/node_modules/.bin/loose-envify generated vendored Normal file
View File

@ -0,0 +1,16 @@
#!/bin/sh
basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
case `uname` in
*CYGWIN*|*MINGW*|*MSYS*)
if command -v cygpath > /dev/null 2>&1; then
basedir=`cygpath -w "$basedir"`
fi
;;
esac
if [ -x "$basedir/node" ]; then
exec "$basedir/node" "$basedir/../loose-envify/cli.js" "$@"
else
exec node "$basedir/../loose-envify/cli.js" "$@"
fi

17
live-streaming/client/node_modules/.bin/loose-envify.cmd generated vendored Normal file
View File

@ -0,0 +1,17 @@
@ECHO off
GOTO start
:find_dp0
SET dp0=%~dp0
EXIT /b
:start
SETLOCAL
CALL :find_dp0
IF EXIST "%dp0%\node.exe" (
SET "_prog=%dp0%\node.exe"
) ELSE (
SET "_prog=node"
SET PATHEXT=%PATHEXT:;.JS;=;%
)
endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%" "%dp0%\..\loose-envify\cli.js" %*

28
live-streaming/client/node_modules/.bin/loose-envify.ps1 generated vendored Normal file
View File

@ -0,0 +1,28 @@
#!/usr/bin/env pwsh
$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
$exe=""
if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
# Fix case when both the Windows and Linux builds of Node
# are installed in the same directory
$exe=".exe"
}
$ret=0
if (Test-Path "$basedir/node$exe") {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "$basedir/node$exe" "$basedir/../loose-envify/cli.js" $args
} else {
& "$basedir/node$exe" "$basedir/../loose-envify/cli.js" $args
}
$ret=$LASTEXITCODE
} else {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "node$exe" "$basedir/../loose-envify/cli.js" $args
} else {
& "node$exe" "$basedir/../loose-envify/cli.js" $args
}
$ret=$LASTEXITCODE
}
exit $ret

16
live-streaming/client/node_modules/.bin/mime generated vendored Normal file
View File

@ -0,0 +1,16 @@
#!/bin/sh
basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
case `uname` in
*CYGWIN*|*MINGW*|*MSYS*)
if command -v cygpath > /dev/null 2>&1; then
basedir=`cygpath -w "$basedir"`
fi
;;
esac
if [ -x "$basedir/node" ]; then
exec "$basedir/node" "$basedir/../mime/cli.js" "$@"
else
exec node "$basedir/../mime/cli.js" "$@"
fi

17
live-streaming/client/node_modules/.bin/mime.cmd generated vendored Normal file
View File

@ -0,0 +1,17 @@
@ECHO off
GOTO start
:find_dp0
SET dp0=%~dp0
EXIT /b
:start
SETLOCAL
CALL :find_dp0
IF EXIST "%dp0%\node.exe" (
SET "_prog=%dp0%\node.exe"
) ELSE (
SET "_prog=node"
SET PATHEXT=%PATHEXT:;.JS;=;%
)
endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%" "%dp0%\..\mime\cli.js" %*

28
live-streaming/client/node_modules/.bin/mime.ps1 generated vendored Normal file
View File

@ -0,0 +1,28 @@
#!/usr/bin/env pwsh
$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
$exe=""
if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
# Fix case when both the Windows and Linux builds of Node
# are installed in the same directory
$exe=".exe"
}
$ret=0
if (Test-Path "$basedir/node$exe") {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "$basedir/node$exe" "$basedir/../mime/cli.js" $args
} else {
& "$basedir/node$exe" "$basedir/../mime/cli.js" $args
}
$ret=$LASTEXITCODE
} else {
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
$input | & "node$exe" "$basedir/../mime/cli.js" $args
} else {
& "node$exe" "$basedir/../mime/cli.js" $args
}
$ret=$LASTEXITCODE
}
exit $ret

16
live-streaming/client/node_modules/.bin/mkdirp generated vendored Normal file
View File

@ -0,0 +1,16 @@
#!/bin/sh
basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
case `uname` in
*CYGWIN*|*MINGW*|*MSYS*)
if command -v cygpath > /dev/null 2>&1; then
basedir=`cygpath -w "$basedir"`
fi
;;
esac
if [ -x "$basedir/node" ]; then
exec "$basedir/node" "$basedir/../mkdirp/bin/cmd.js" "$@"
else
exec node "$basedir/../mkdirp/bin/cmd.js" "$@"
fi

17
live-streaming/client/node_modules/.bin/mkdirp.cmd generated vendored Normal file
View File

@ -0,0 +1,17 @@
@ECHO off
GOTO start
:find_dp0
SET dp0=%~dp0
EXIT /b
:start
SETLOCAL
CALL :find_dp0
IF EXIST "%dp0%\node.exe" (
SET "_prog=%dp0%\node.exe"
) ELSE (
SET "_prog=node"
SET PATHEXT=%PATHEXT:;.JS;=;%
)
endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%" "%dp0%\..\mkdirp\bin\cmd.js" %*

Some files were not shown because too many files have changed in this diff Show More