### Mock JSON Rule Example in LightProxy

Source: https://github.com/alibaba/lightproxy/blob/master/docs/docs/doc/getting-started.md

Demonstrates how to create a JSON mock rule in LightProxy. This rule uses an ES6-like multi-line string syntax, an extension of whistle's grammar, allowing for direct multi-line content within the rule definition. This enables quick mocking of interfaces with custom JSON responses and headers.

```whistle
```
// Mock JSON
'https://www.github.com/alibaba/lightproxy' http://127.0.0.1:8888/mock/data.json
```

```
// Mock JSON with custom header
'https://www.github.com/alibaba/lightproxy' http://127.0.0.1:8888/mock/data.json {
  response://header.name my-test-head
}
```
```

--------------------------------

### Install whistle.chii Plugin

Source: https://github.com/alibaba/lightproxy/blob/master/vendor/whistle.chii-internal/README.md

Installs the whistle.chii plugin globally using npm. This command requires Node.js and npm to be installed on your system.

```bash
npm install whistle.chii -g
```

--------------------------------

### Example Curl Request Through LightProxy (Shell)

Source: https://github.com/alibaba/lightproxy/blob/master/docs/docs/doc/cli.md

This example demonstrates how to use `curl` to make a request after setting the proxy environment variables. The output shows the `Proxy-Agent` header indicating that the request went through LightProxy, followed by the actual HTTP response.

```shell
curl https://baidu.com -I
```

--------------------------------

### Umi/Antd Pro Development Integration for HMR and Assets

Source: https://context7.com/alibaba/lightproxy/llms.txt

Configure LightProxy to facilitate local development for Umi or Antd Pro projects. This setup handles Hot Module Replacement (HMR), asynchronous chunks, and CDN resource loading by forwarding requests to the local development server.

```bash
# Forward main JS/CSS files to local dev server
g.alicdn.com/ife/project/umi.css http://127.0.0.1:8000/umi.css
g.alicdn.com/ife/project/umi.js http://127.0.0.1:8000/umi.js

# Forward async chunks and source maps
^www.test.com/***.js http://127.0.0.1:8000/$1.js
^www.test.com/***.map http://127.0.0.1:8000/$1.map
^www.test.com/***.css http://127.0.0.1:8000/$1.css

# Forward HMR websocket connections
^www.test.com/sockjs-node/*** http://127.0.0.1:8000/sockjs-node/$1

# Forward umi-ui requests
www.test.com:3000 http://127.0.0.1:3000/

# Optional: Forward API requests to local backend
^www.test.com/api/*** http://127.0.0.1:8000/api/$1
```

--------------------------------

### Example Usage of BRLOptionParser in Objective-C

Source: https://github.com/alibaba/lightproxy/blob/master/vendor/proxy_conf_helper/BRLOptionParser/README.markdown

This Objective-C code demonstrates how to use BRLOptionParser to parse command-line arguments. It shows how to set a banner, add options with descriptions and arguments, handle errors, and execute custom blocks for options like '--help'.

```objective-c
// main.m
#import <BRLOptionParser/BRLOptionParser.h>

int main(int argc, const char * argv[])
{
    @autoreleasepool {
        NSString *name = @"world";
        BOOL verbose = NO;

        BRLOptionParser *options = [BRLOptionParser new];

        [options setBanner:@"usage: %s [-n <name>] [-vh]", argv[0]];
        [options addOption:"name" flag:'n' description:@"Your name" argument:&name];
        [options addSeparator];
        [options addOption:"verbose" flag:'v' description:nil value:&verbose];
        __weak typeof(options) weakOptions = options;
        [options addOption:"help" flag:'h' description:@"Show this message" block:^{ 
            printf("%s", [[weakOptions description] UTF8String]);
            exit(EXIT_SUCCESS);
        }];

        NSError *error = nil;
        if (![options parseArgc:argc argv:argv error:&error]) {
            const char * message = error.localizedDescription.UTF8String;
            fprintf(stderr, "%s: %s\n", argv[0], message);
            exit(EXIT_FAILURE);
        }

        if (verbose) {
            fprintf(stderr, "(Preparing to say hello...)\n");
        }

        printf("Hello, %s!\n", name.UTF8String);
    }

    return EXIT_SUCCESS;
}
```

--------------------------------

### Wildcard Matching Rules (Lightproxy Syntax)

Source: https://github.com/alibaba/lightproxy/blob/master/docs/docs/rules/match.md

Defines rules for wildcard matching in Lightproxy, using '^' to start, '*' and '***' as wildcards, and '$' for capture groups. '*' matches up to '/', while '***' matches multiple path segments. '$0' represents the entire URL.

```lightproxy
# Wildcard matching must start with ^

# Visit g.alicdn.com/abc/xyz/1.js and it will be mapped to /path/to/xyz/1.js
^ g.alicdn.com / abc / *** / path / to / $ 1

# You can also use $ to limit the end
# Only forward URLs ending in index.js
^ g.alicdn.com / abc / *** index.js $ / path / to / $ 1
```

--------------------------------

### Whistle Rule Syntax: OperatorURI Examples

Source: https://github.com/alibaba/lightproxy/blob/master/vendor/whistle/README.md

Illustrates the operatorURI part of a whistle rule, which specifies the operation to perform on a matched request. It covers `host` for setting the server IP and `file` for replacing requests with local files. Examples show how to specify the opValue for each operation.

```whistle
# host：setting requested server IP
pattern host://opValue

# file：using the local file to replace
pattern file://opValue

# host：setting requested server IP
pattern host://127.0.0.1:6666 # or pattern 127.0.0.1:6666	

# file：using the local file to replace
pattern file:///User/test/dirOrFile # or pattern /User/test/dirOrFile
pattern file://E:\\test\\dirOrFile # or pattern E:\\test\\dirOrFile
```

--------------------------------

### Whistle Rule Syntax: Pattern Matching Examples

Source: https://github.com/alibaba/lightproxy/blob/master/vendor/whistle/README.md

Demonstrates various ways to define patterns for matching target request URLs in whistle. This includes matching domains, domains with ports, protocols, paths, regular expressions, and wildcard characters. These patterns are crucial for configuring whistle's request manipulation rules.

```whistle
# matching domain
www.example.com
# domain with port
www.example.com:6666
# domain with protocol, supporting http, https, ws, wss, tunnel
http://www.example.com

# matching path, supporting protocol, port
www.example.com/test
https:/www.exapmle.com/test
https:/www.exapmle.com:6666/test

# matching regular expression
/^https?://www\.example\.com\/test\/(.*)/ referer://http://www.test.com/$1

# matching wildcard
^www.example.com/test/*** referer://http://www.test.com/$1
```

--------------------------------

### Install BRLOptionParser with CocoaPods

Source: https://github.com/alibaba/lightproxy/blob/master/vendor/proxy_conf_helper/BRLOptionParser/README.markdown

This snippet shows how to add the BRLOptionParser library to your project using CocoaPods. It specifies the dependency in the Podfile.

```ruby
# Podfile
pod 'BRLOptionParser', '~> 0.3.1'
```

--------------------------------

### Node.js Inline Rule Script for LightProxy

Source: https://github.com/alibaba/lightproxy/blob/master/docs/docs/doc/write-rule-in-nodejs.md

An example of an inline Node.js script for LightProxy rules. It demonstrates how to access request details (URL, headers, method, body) and modify the response. The `next()` function is used to forward the request, and the response can be intercepted and modified before being sent back.

```javascript
github.com/alibaba/lightproxy scriptfile://`

exports.handleRequest = async (ctx, next) => {
  // do sth
  // ctx.fullUrl request url
  // ctx.headers request header
  // ctx.options some meta infomation
  // ctx.method request method
  // const reqBody = await ctx.getReqBody(); req body buffer
  // const reqText = await ctx.getReqText();  req body text, or ''
  // const formData = await ctx.getReqForm(); req form data, or {}
  // ctx.req.body = String| Buffer | Stream | null
  // next can use with next({ host, port });
  // use next to send request
  const { statusCode, headers } = await next(); 
  // do sth
  // const resBody = yield ctx.getResBody();
  // const resText = yield ctx.getResText();
  // ctx.status = 404;
  // ctx.set(headers);
  // ctx.set('x-test', 'abc');
  // ctx.body = String| Buffer | Stream | null;
  ctx.body = 'test';
};
`
```

--------------------------------

### Proxy Configuration for Umi/Antd-Pro Static Assets

Source: https://github.com/alibaba/lightproxy/blob/master/docs/docs/doc/use-with-umi-antd-pro.md

This configuration forwards static assets (JS, CSS, map files) from a CDN to a local development server. It also handles proxying for HMR (Hot Module Replacement) and other dynamic features provided by Umi during local development. Adjust domain names and ports as per your project setup.

```nginx
# Proxy two main files, modify according to specific URL
g.alicdn.com/ife/project/umi.css http://127.0.0.1:8000/umi.css
g.alicdn.com/ife/project/umi.js http://127.0.0.1:8000/umi.js

# Locally developed asynchronously loaded async js/css and vendor will be loaded from/, so do the corresponding forwarding
^www.test.com/***. js http://127.0.0.1:8000/$1.js
^www.test.com/***. map http://127.0.0.1:8000/$1.map
^www.test.com/***. css http://127.0.0.1:8000/$1.css

# /socksjs-node/is used by the HMR function, the following ws/xhr should be forwarded
^www.test.com/sockjs-node/*** http://127.0.0.1:8000/sockjs-node/$1

#: 3000/is the interface used by umi-ui, also forwarded in the past
www.test.com:3000 http://127.0.0.1:3000/

# Generally, this is not needed, because the online API is often directly on the online API, but if necessary, you can add
# Forward API to local
# ^www.test.com/api/*** http://127.0.0.1:8000/api/$1
```

--------------------------------

### Configure Chii Rule for Whistle

Source: https://github.com/alibaba/lightproxy/blob/master/vendor/whistle.chii-internal/README.md

Example of how to configure a rule in Whistle to use the chii plugin for a specific domain. This rule directs traffic for 'chii.liriliri.io' to be processed by the 'whistle.chii' plugin, likely for inspection purposes.

```whistle
chii.liriliri.io whistle.chii://title
```

--------------------------------

### Path Matching (Lightproxy Syntax)

Source: https://github.com/alibaba/lightproxy/blob/master/docs/docs/rules/match.md

Demonstrates matching all requests under a specific path in Lightproxy. The rule can also be limited by protocol.

```lightproxy
test.com/test/ (test)

# The agreement can also be limited
http://test.com/test/ (test)
```

--------------------------------

### Domain Wildcard Matching (Lightproxy Syntax)

Source: https://github.com/alibaba/lightproxy/blob/master/docs/docs/rules/match.md

Illustrates domain wildcard matching in Lightproxy. A single '*' matches a subdomain part (e.g., '*.com'), while '***' matches multiple subdomain levels (e.g., '***.com').

```lightproxy
* .com (test)

***. com (test)
```

--------------------------------

### Direct Domain Matching (Lightproxy Syntax)

Source: https://github.com/alibaba/lightproxy/blob/master/docs/docs/rules/match.md

Shows how to directly match specific domain names in Lightproxy. Rules can optionally include the protocol (http/https) and port number.

```lightproxy
test.com (test)

# Can limit the agreement
http://test.com (test)

# Port number can be limited
http://test.com:8000 (test)
```

--------------------------------

### Regular Expression Matching (Lightproxy Syntax)

Source: https://github.com/alibaba/lightproxy/blob/master/docs/docs/rules/match.md

Explains how to use regular expressions for flexible matching in Lightproxy, enclosed in '/'. It supports capture groups '$1' through '$9' and '$0' for the entire URL.

```lightproxy
# Match all requests
/./ (test)

# Match the request that contains a keyword in the url
/ keyword / (test)

# Through regular matching, the same $ 1 ~ $ 9 capture group, $ 0 means the entire URL
/(\d+).html/ (test)
```

--------------------------------

### Node.js External Rule File for LightProxy

Source: https://github.com/alibaba/lightproxy/blob/master/docs/docs/doc/write-rule-in-nodejs.md

This demonstrates how to configure LightProxy to use an external JavaScript file for custom rules. The rule is specified by providing the path to the `.js` file after `scriptfile://` in the configuration.

```javascript
github.com/alibaba/lightproxy scriptfile:/path/to/file.js
```

--------------------------------

### Simulating Network Conditions with Response Delay and Speed Throttling

Source: https://context7.com/alibaba/lightproxy/llms.txt

Simulate slow network conditions by introducing delays to requests or responses, and by limiting bandwidth. This is essential for testing how applications behave under various network constraints, including loading states and timeout handling.

```bash
# Add delay to request (milliseconds)
api.example.com reqDelay://2000

# Add delay to response (milliseconds)
api.example.com resDelay://3000

# Limit request upload speed (KB/s)
api.example.com reqSpeed://50

# Limit response download speed (KB/s)
api.example.com resSpeed://100

# Combine delay and speed limiting
api.example.com resDelay://1000 resSpeed://50
```

--------------------------------

### Set Command Line Proxy Environment Variables (Shell)

Source: https://github.com/alibaba/lightproxy/blob/master/docs/docs/doc/cli.md

This script sets the `https_proxy`, `http_proxy`, and `all_proxy` environment variables to direct traffic through the LightProxy instance. It is intended to be executed in a shell environment. Applications that read these environment variables will then use the specified proxy.

```shell
export https_proxy=http://127.0.0.1:12888 http_proxy=http://127.0.0.1:12888 all_proxy=socks5://127.0.0.1:12889
```

--------------------------------

### Proxy Chaining with SOCKS and HTTP Proxies

Source: https://context7.com/alibaba/lightproxy/llms.txt

Configure LightProxy to forward requests through other proxy servers like SOCKS5 or HTTP. This is useful for scenarios involving VPNs or corporate networks that require traffic to be routed through specific exit points.

```bash
# Forward specific URLs through SOCKS proxy
/internal\.corp\.com/ socks://127.0.0.1:1080

# Forward all traffic through SOCKS proxy
/.*/ socks://127.0.0.1:1080

# Forward through HTTP proxy
/api\.external\.com/ proxy://127.0.0.1:8888

# Forward through HTTPS proxy
/secure\.example\.com/ https-proxy://127.0.0.1:8443
```

--------------------------------

### Custom Window Opening in JavaScript

Source: https://github.com/alibaba/lightproxy/blob/master/vendor/whistle/biz/webui/htdocs/index.html

This JavaScript code intercepts calls to `window.open`. If the URL is 'editor.html' or 'preview.html', it creates a modal-like div to display the content in an iframe. Otherwise, it uses the Electron remote shell to open the URL externally. This allows for in-app previews or editing while maintaining external links.

```javascript
const require = parent && parent.window && parent.window.require;
let lastCleanup;
if (require) {
    const originOpen = window.open;
    window.open = (url) => {
        console.log('url', url);
        if (url === 'editor.html' || url === 'preview.html') {
            if (lastCleanup) {
                lastCleanup();
                lastCleanup = null;
            }
            const floatLayer = document.createElement('div');
            floatLayer.style = ` position: fixed; width: 90%; height: 80%; left: 5%; top: 10%; z-index: 1000; display: flex; flex-direction: column; box-shadow: 0 20px 25px -5px rgba(0, 0, 0, .1), 0 10px 10px -5px rgba(0, 0, 0, .04); border: 1px solid #c0c0c0; border-radius: 6px; overflow: hidden; background-color: #fff; `.replace('\n', '');
            const layerBar = document.createElement('div');
            layerBar.style = ` width: 100%; height: 0; flex: 0 0 28px; background-color: #f5f5f5; display: flex; align-items: center; padding: 0 10px; `.replace('\n', '');
            const container = document.createElement('iframe');
            container.src = url;
            container.style = ` width: 100%; flex: 1; border: 0; `.replace('\n', '');
            floatLayer.appendChild(layerBar);
            floatLayer.appendChild(container);
            document.body.appendChild(floatLayer);
            const closeBtn = document.createElement('div');
            closeBtn.style = ` cursor: pointer; height: 13px; width: 13px; border-radius: 50%; border: 1px solid #e2463f; background-color: #ff5f57 !important; `.replace('\n', '');
            const cleanup = () => {
                closeBtn.remove();
                layerBar.remove();
                container.remove();
                floatLayer.remove();
            };
            closeBtn.onclick = cleanup;
            lastCleanup = cleanup;
            layerBar.appendChild(closeBtn);
            return {
                set setValue(val) { container.contentWindow.setValue = val; },
                set getValue(val) { container.contentWindow.getValue = val; }
            }
        } else {
            require('electron').remote.shell.openExternal(url);
        }
    };
}
```

--------------------------------

### Configure Hosts with IP Addresses

Source: https://github.com/alibaba/lightproxy/blob/master/vendor/whistle/README.md

Configure hostnames to resolve to specific IP addresses or ports. This is useful for local development and testing by directing traffic to local servers or specific network interfaces. Supports both IPv4 and IPv6.

```plaintext
www.ifeng.com 127.0.0.1
# or
127.0.0.1 www.ifeng.com

# www.ifeng.com 127.0.0.1
www.ifeng.com 127.0.0.1:8080
# or
127.0.0.1:8080 www.ifeng.com
```

--------------------------------

### Configure Hosts with Domain Forwarding

Source: https://github.com/alibaba/lightproxy/blob/master/vendor/whistle/README.md

Forward requests from one domain to another, optionally specifying a port. This allows testing how a site behaves when served from a different domain or port, useful for proxying and load balancing configurations.

```plaintext
www.ifeng.com host://www.qq.com:8080
# or
host://www.qq.com:8080 www.ifeng.com
```

--------------------------------

### Initialize Whistle Bridge and Event Listeners (JavaScript)

Source: https://github.com/alibaba/lightproxy/blob/master/vendor/whistle/assets/menu.html

Initializes the `whistleBridge` object, which provides an interface for interacting with the Lightproxy environment. It sets up methods for managing listeners for network, rules, and values, and handles event emission. It also includes a mechanism for delayed initialization and event processing.

```javascript
(function() { var config = window.whistleMenuConfig; var list = []; var networkListeners = []; var rulesListeners = []; var valuesListeners = []; var handleOnLoad = function() { timer = null; list.forEach(emit); list = null; }; var timer = setTimeout(handleOnLoad, 12000); function execListeners(listeners, options) { listeners.forEach(function(fn) { try { fn(options) } catch (e) { console.error(e); } }); } function emit(options) { switch(options.type) { case 'rules': execListeners(rulesListeners, options); break; case 'values': execListeners(valuesListeners, options); break; default: execListeners(networkListeners, options); } } window.onWhistleContextMenuClick = function(options) { if (list) { list.push(options); } else { emit(options); } }; var delayOnLoad = function() { if (timer) { setTimeout(handleOnLoad, 100); clearTimeout(timer); timer = null; } }; window.onload = delayOnLoad; try { window.addEventListener('load', delayOnLoad); } catch (e) {} var toast = {}; var modal = {}; window.whistleBridge = { config: config, modal: modal, toast: toast, addNetworkListener: function(l) { if (typeof l === 'function' && networkListeners.indexOf(l) === -1) { networkListeners.push(l); } }, removeNetworkListener: function(l) { l = networkListeners.indexOf(l); if (l !== -1) { networkListeners.splice(l, 1); } }, removeAllNetworkListeners: function() { networkListeners = []; }, addRulesListener: function(l) { if (typeof l === 'function' && rulesListeners.indexOf(l) === -1) { rulesListeners.push(l); } }, removeRulesListener: function(l) { l = rulesListeners.indexOf(l); if (l !== -1) { rulesListeners.splice(l, 1); } }, removeAllRulesListeners: function() { rulesListeners = []; }, addValuesListener: function(l) { if (typeof l === 'function' && valuesListeners.indexOf(l) === -1) { valuesListeners.push(l); } }, removeValuesListener: function(l) { l = valuesListeners.indexOf(l); if (l !== -1) { valuesListeners.splice(l, 1); } }, removeAllValuesListeners: function() { valuesListeners = []; } }; try { window.initWhistleBridge = function(options) { window.initWhistleBridge = function() {}; Object.keys(options.msgBox).forEach(function(name) { toast[name] = options.msgBox[name]; }); window.whistleBridge.importSessions = options.importSessions; window.whistleBridge.request = options.request; window.whistleBridge.createRequest = options.createRequest; window.whistleBridge.showModal = options.showModal; window.whistleBridge.createModal = options.createModal; window.whistleBridge.importRules = options.importRules; window.whistleBridge.importValues = options.importValues; }; window.parent.onPluginContextMenuReady(window); } catch (e) {} })();
```

--------------------------------

### Configuring Cross-Origin Resource Sharing (CORS)

Source: https://context7.com/alibaba/lightproxy/llms.txt

Enable and configure Cross-Origin Resource Sharing (CORS) headers for API development and testing. This allows web applications from different origins to access resources hosted on your server, essential for modern web development.

```bash
# Enable CORS for requests
api.example.com reqCors://*

# Enable CORS for responses with all origins
api.example.com resCors://*

# Configure specific CORS headers
api.example.com resCors://{cors-config}

# cors-config in Values:
# access-control-allow-origin: https://app.example.com
# access-control-allow-methods: GET, POST, PUT, DELETE
# access-control-allow-headers: Content-Type, Authorization
```

--------------------------------

### Custom Request/Response Handling with Node.js Scripts

Source: https://context7.com/alibaba/lightproxy/llms.txt

Implement custom logic for handling requests and responses using Node.js scripts. These scripts can access and modify request context, headers, body, and programmatically alter responses before they are sent.

```bash
# Inline Node.js script rule
github.com/alibaba/lightproxy scriptfile://`

exports.handleRequest = async (ctx, next) => {
  // Access request properties
  // ctx.fullUrl - full request URL
  // ctx.headers - request headers
  // ctx.method - HTTP method
  // ctx.options - meta information

  // Get request body
  const reqBody = await ctx.getReqBody();   // Buffer
  const reqText = await ctx.getReqText();   // String
  const formData = await ctx.getReqForm();  // Form data object

  // Modify request body before sending
  ctx.req.body = JSON.stringify({ modified: true });

  // Forward request and get response
  const { statusCode, headers } = await next();

  // Get response body
  const resBody = await ctx.getResBody();
  const resText = await ctx.getResText();

  // Modify response
  ctx.status = 200;
  ctx.set('x-custom-header', 'modified');
  ctx.body = JSON.stringify({
    original: JSON.parse(resText),
    timestamp: Date.now()
  });
};
`

# Or reference external script file
api.example.com scriptfile:///Users/dev/scripts/handler.js
```

--------------------------------

### Replace Responses with Local Files

Source: https://github.com/alibaba/lightproxy/blob/master/vendor/whistle/README.md

Replace remote server responses with content from local files. This is highly beneficial for front-end development, allowing developers to work on UI elements and assets locally without redeploying to a server. Supports different path separators for Mac/Linux and Windows.

```plaintext
# Mac or Linux
www.ifeng.com file:///User/username/test
# or www.ifeng.com file:///User/username/test/index.html

# Both '\' and '/' can be used as path separator for Widows
www.ifeng.com file://E:\xx\test
# or www.ifeng.com file://E:\xx\test\index.html
```

--------------------------------

### Inject HTML, JS, and CSS Content

Source: https://github.com/alibaba/lightproxy/blob/master/vendor/whistle/README.md

Inject custom HTML, JavaScript, or CSS into web page responses. Lightproxy intelligently determines how to inject the content based on the response type, wrapping JS in `<script>` and CSS in `<style>` tags for HTML responses.

```plaintext
# Mac、Linux
www.ifeng.com html:///User/xxx/test/test.html
www.ifeng.com js:///User/xxx/test/test.js
www.ifeng.com css:///User/xxx/test/test.css

# Both '\' and '/' can be used as path separator for Widows
www.ifeng.com html://E:\xx\test\test.html
www.ifeng.com js://E:\xx\test\test.js
www.ifeng.com css://E:\xx\test\test.css
```

--------------------------------

### Set Chii Inspection Global Variables (JavaScript)

Source: https://github.com/alibaba/lightproxy/blob/master/vendor/whistle.chii-internal/_rules.txt

This snippet demonstrates setting global JavaScript variables `window.ChiiTitle` and `window.ChiiServerUrl` using the `escapeJs` function and location information. `window.ChiiTitle` is set based on `whistle.chii-internal` or defaults to 'anonymous', while `window.ChiiServerUrl` is constructed from the current host and a specific path. These variables are likely used by the Chii inspection tool to identify and communicate with the target.

```javascript
window.ChiiTitle = escapeJs('${whistle.chii-internal}') || 'anonymous';
window.ChiiServerUrl = location.host + '/...whistle-path.5b6af7b9884e1165...///whistle.chii-internal';

```

--------------------------------

### Base64 Encoding and Decoding in JavaScript

Source: https://github.com/alibaba/lightproxy/blob/master/vendor/whistle/biz/webui/htdocs/preview.html

This snippet demonstrates the core functionality of the Base64 library, including encoding strings to Base64 and decoding Base64 strings back to their original form. It handles character set conversions and provides both standard and URI-safe encoding options.

```javascript
var _Base64 = global.Base64;
var version = "2.4.5";
var buffer;
if (typeof module !== "undefined" && module.exports) {
    try {
        buffer = require("buffer").Buffer;
    } catch (err) {
        // Handle error if buffer is not available
    }
}
var b64chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
var b64tab = function(bin) {
    var t = {};
    for (var i = 0, l = bin.length; i < l; i++) t[bin.charAt(i)] = i;
    return t;
}(b64chars);
var fromCharCode = String.fromCharCode;
var cb_utob = function(c) {
    if (c.length < 2) {
        var cc = c.charCodeAt(0);
        return cc < 128 ? c : cc < 2048 ? fromCharCode(192 | cc >>> 6) + fromCharCode(128 | cc & 63) : fromCharCode(224 | cc >>> 12 & 15) + fromCharCode(128 | cc >>> 6 & 63) + fromCharCode(128 | cc & 63);
    } else {
        var cc = 65536 + (c.charCodeAt(0) - 55296) * 1024 + (c.charCodeAt(1) - 56320);
        return fromCharCode(240 | cc >>> 18 & 7) + fromCharCode(128 | cc >>> 12 & 63) + fromCharCode(128 | cc >>> 6 & 63) + fromCharCode(128 | cc & 63);
    }
};
var re_utob = /[?-?][?-?F] | [^x00-x7F]/g;
var utob = function(u) {
    return u.replace(re_utob, cb_utob);
};
var cb_encode = function(ccc) {
    var padlen = [0, 2, 1][ccc.length % 3],
        ord = ccc.charCodeAt(0) << 16 | (ccc.length > 1 ? ccc.charCodeAt(1) : 0) << 8 | (ccc.length > 2 ? ccc.charCodeAt(2) : 0),
        chars = [b64chars.charAt(ord >>> 18), b64chars.charAt(ord >>> 12 & 63), padlen >= 2 ? "=" : b64chars.charAt(ord >>> 6 & 63), padlen >= 1 ? "=" : b64chars.charAt(ord & 63)];
    return chars.join("");
};
var btoa = global.btoa ? function(b) {
    return global.btoa(b);
} : function(b) {
    return b.replace(/[sS]{1,3}/g, cb_encode);
};
var _encode = buffer ? buffer.from && Uint8Array && buffer.from !== Uint8Array.from ? function(u) {
    return (u.constructor === buffer.constructor ? u : buffer.from(u)).toString("base64");
} : function(u) {
    return (u.constructor === buffer.constructor ? u : new buffer(u)).toString("base64");
} : function(u) {
    return btoa(utob(u));
};
var encode = function(u, urisafe) {
    return !urisafe ? _encode(String(u)) : _encode(String(u)).replace(/[+/]/g, function(m0) {
        return m0 == "+" ? "-" : "_";
    }).replace(/=/g, "");
};
var encodeURI = function(u) {
    return encode(u, true);
};
var re_btou = new RegExp(["[À-ß][€-¿]", "[à-ï][€-¿]{2}", "[ð-÷][€-¿]{3}"].join("|"), "g");
var cb_btou = function(cccc) {
    switch (cccc.length) {
        case 4:
            var cp = (7 & cccc.charCodeAt(0)) << 18 | (63 & cccc.charCodeAt(1)) << 12 | (63 & cccc.charCodeAt(2)) << 6 | 63 & cccc.charCodeAt(3),
                offset = cp - 65536;
            return fromCharCode((offset >>> 10) + 55296) + fromCharCode((offset & 1023) + 56320);
        case 3:
            return fromCharCode((15 & cccc.charCodeAt(0)) << 12 | (63 & cccc.charCodeAt(1)) << 6 | 63 & cccc.charCodeAt(2));
        default:
            return fromCharCode((31 & cccc.charCodeAt(0)) << 6 | 63 & cccc.charCodeAt(1));
    }
};
var btou = function(b) {
    return b.replace(re_btou, cb_btou);
};
var cb_decode = function(cccc) {
    var len = cccc.length,
        padlen = len % 4,
        n = (len > 0 ? b64tab[cccc.charAt(0)] << 18 : 0) | (len > 1 ? b64tab[cccc.charAt(1)] << 12 : 0) | (len > 2 ? b64tab[cccc.charAt(2)] << 6 : 0) | (len > 3 ? b64tab[cccc.charAt(3)] : 0),
        chars = [fromCharCode(n >>> 16), fromCharCode(n >>> 8 & 255), fromCharCode(n & 255)];
    chars.length -= [0, 0, 2, 1][padlen];
    return chars.join("");
};
var atob = global.atob ? function(a) {
    return global.atob(a);
} : function(a) {
    return a.replace(/[sS]{1,4}/g, cb_decode);
};
var _decode = buffer ? buffer.from && Uint8Array && buffer.from !== Uint8Array.from ? function(a) {
    return (a.constructor === buffer.constructor ? a : buffer.from(a, "base64")).toString();
} : function(a) {
    return (a.constructor === buffer.constructor ? a : new buffer(a, "base64")).toString();
} : function(a) {
    return btou(atob(a));
};
var decode = function(a) {
    return _decode(String(a).replace(/[-\_]/g, function(m0) {
        return m0 == "-" ? "+" : "/";
    }).replace(/[^A-Za-z0-9+/]/g, ""));
};
var noConflict = function() {
    var Base64 = global.Base64;
    global.Base64 = _Base64;
    return Base64;
};
global.Base64 = {
    VERSION: version,
    atob: atob,
    btoa: btoa,
    fromBase64: decode,
    toBase64: encode,
    utob: utob,
    encode: encode,
    encodeURI: encodeURI,
    btou: btou,
    decode: decode,
    noConflict: noConflict
};
if (typeof Object.defineProperty === "function") {
    var noEnum = function(v) {
        return { value: v, enumerable: false, writable: true, configurable: true };
    };
    global.Base64.extendString = function() {
        Object.defineProperty(String.prototype, "fromBase64", noEnum(function() {
            return decode(this);
        }));
        Object.defineProperty(String.prototype, "toBase64", noEnum(function(urisafe) {
            return encode(this, urisafe);
        }));
        Object.defineProperty(String.prototype, "toBase64URI", noEnum(function() {
            return encode(this, true);
        }));
    };
}
if (global["Meteor"]) {
    Base64 = global.Base64;
}
if (typeof module !== "undefined" && module.exports) {
    module.exports.Base64 = global.Base64;
} else if (typeof define === "function" && define.amd) {
    define([], function() {
        return global.Base64;
    });
}
return { Base64: global.Base64 });
```

--------------------------------

### Content Preview with Character Set Handling (JavaScript)

Source: https://github.com/alibaba/lightproxy/blob/master/vendor/whistle/biz/webui/htdocs/preview.html

Handles previewing content from the URL's hash, supporting base64 encoded data and specific character sets. It decodes base64 strings using the 'base64js' library and then decodes the resulting bytes into text using 'TextDecoder' based on the provided charset. It also includes logic to handle data URIs for images and temporarily disables browser history manipulation.

```javascript
window.onload = function() { var base64Text = location.hash.substring(1); var charset; if (base64Text && /\?\?\?WHISTLE_PREVIEW_CHARSET=([A-Z\d_-]+)\?\?\?/.test(location.search)) { charset = RegExp.$1; } if (!charset) { return; } if (base64Text.indexOf('data:') === 0) { var style = 'display: -webkit-box; -webkit-box-align: center; -webkit-align-items: center;' + '-webkit-box-pack: center; -webkit-justify-content: center; margin: 0px; background: #0e0e0e;'; document.write('<html><head></head><body style="' + style + '">' + '<img src="' + base64Text + '"></body></html>'); return; } var pushState = history.pushState; var replaceState = history.replaceState; if (typeof pushState === 'function') { try { history.pushState = history.replaceState = function() {}; } catch(e) {} } setTimeout(function() { try { history.pushState = pushState; history.replaceState = replaceState; } catch(e) {} }, 6000); try { if (charset.replace('-', '') === 'UTF8') { document.write(Base64.decode(base64Text)); charset = null; } } catch(e) {} if (charset) { var decoder = new TextDecoder(charset); var bytes = base64js.toByteArray(base64Text); document.write(decoder.decode(new window.Uint8Array(bytes))); } window.Base64 = null; window.base64js = null; };
```

--------------------------------

### Remote Debugging with weinre and Console Logging

Source: https://context7.com/alibaba/lightproxy/llms.txt

Enable remote debugging for web pages on mobile devices using weinre integration. This allows developers to inspect and debug mobile web content from their desktop browsers. Console logging can also be enabled for debugging purposes.

```bash
# Enable weinre debugging for a domain
www.example.com weinre://mobile-debug

# Enable console logging
www.example.com log://{debug-script}

# Visit page with debugging enabled
# Add ?lightproxy=true to URL or configure rule
www.example.com?lightproxy=true

# Debug script example (in Values)
# debug-script content:
console.log('Page loaded:', window.location.href);
console.log('Document ready state:', document.readyState);
```

--------------------------------

### Forward Requests Between Domains

Source: https://github.com/alibaba/lightproxy/blob/master/vendor/whistle/README.md

Forward all requests from a specified source domain to a target domain. This rule is useful for migrating services or testing domain changes without altering client-side configurations.

```plaintext
www.ifeng.com www.aliexpress.com
```

--------------------------------

### Overriding Status Codes and Performing Redirects

Source: https://context7.com/alibaba/lightproxy/llms.txt

Configure LightProxy to override HTTP status codes or redirect requests to different URLs. This allows for simulating server errors, maintenance pages, or managing URL changes gracefully.

```bash
# Return specific status code
api.example.com/maintenance statusCode://503

# Replace status code in response
api.example.com replaceStatus://200

# Redirect to different URL (302)
www.old-domain.com redirect://https://www.new-domain.com

# Permanent redirect (301)
www.old-domain.com location://https://www.new-domain.com

# Set redirect with custom status
www.example.com/old redirect://https://www.example.com/new statusCode://301
```

--------------------------------

### Base64 Encoding and Decoding Utilities (JavaScript)

Source: https://github.com/alibaba/lightproxy/blob/master/vendor/whistle/biz/webui/htdocs/preview.html

Provides functions for converting between binary data and base64 encoded strings. It includes byteLength, toByteArray, and fromByteArray functions. This utility is essential for data transmission and storage where binary data needs to be represented as text.

```javascript
var t=[];var o=[];var a=typeof Uint8Array!=="undefined"?Uint8Array:Array;var f="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/”;for(var i=0,u=f.length;i<u;++i){t[i]=f[i];o[f.charCodeAt(i)]=i}o["-".charCodeAt(0)]=62;o["_".charCodeAt(0)]=63;function v(r){var e=r.length;if(e%4>0){throw new Error("Invalid string. Length must be a multiple of 4")}var n=r.indexOf("=");if(n===-1)n=e;var t=n===e?0:4-n%4;return[n,t]}function d(r){var e=v(r);var n=e[0];var t=e[1];return(n+t)*3/4-t}function c(r,e,n){return(e+n)*3/4-n}function h(r){var e;var n=v(r);var t=n[0];var f=n[1];var i=new a(c(r,t,f));var u=0;var d=f>0?t-4:t;for(var h=0;h<d;h+=4){e=o[r.charCodeAt(h)]<<18|o[r.charCodeAt(h+1)]<<12|o[r.charCodeAt(h+2)]<<6|o[r.charCodeAt(h+3)];i[u++]=e>>16&255;i[u++]=e>>8&255;i[u++]=e&255}if(f===2){e=o[r.charCodeAt(h)]<<2|o[r.charCodeAt(h+1)]>>4;i[u++]=e&255}if(f===1){e=o[r.charCodeAt(h)]<<10|o[r.charCodeAt(h+1)]<<4|o[r.charCodeAt(h+2)]>>2;i[u++]=e>>8&255;i[u++]=e&255}return i}function s(r){return t[r>>18&63]+t[r>>12&63]+t[r>>6&63]+t[r&63]}function l(r,e,n){var t;var o=[];for(var a=e;a<n;a+=3){t=(r[a]<<16&16711680)+(r[a+1]<<8&65280)+(r[a+2]&255);o.push(s(t))}return o.join("")}function p(r){var e;var n=r.length;var o=n%3;var a=[];var f=16383;for(var i=0,u=n-o;i<u;i+=f){a.push(l(r,i,i+f>u?u:i+f))}if(o===1){e=r[n-1];a.push(t[e>>2]+t[e<<4&63]+"==")}else if(o===2){e=(r[n-2]<<8)+r[n-1];a.push(t[e>>10]+t[e>>4&63]+t[e<<2&63]+"=")}return a.join("")}
```

--------------------------------

### Remote Debugging with Log Protocol

Source: https://github.com/alibaba/lightproxy/blob/master/vendor/whistle/README.md

Utilize the log protocol for debugging by capturing console logs and other diagnostic information from remote pages. This feature helps in identifying and resolving JavaScript errors and understanding application behavior in real-time.

```plaintext
www.ifeng.com log://{test.js}
```

--------------------------------

### Remote Debugging with Weinre

Source: https://github.com/alibaba/lightproxy/blob/master/vendor/whistle/README.md

Enable remote debugging for web pages using the Weinre protocol. This allows developers to inspect DOM, debug JavaScript, and monitor network activity in a remote browser session through a dedicated debug page.

```plaintext
www.ifeng.com weinre://test
```

--------------------------------

### Unset Proxy Environment Variables

Source: https://context7.com/alibaba/lightproxy/llms.txt

This command unsets the HTTP, HTTPS, and all proxy environment variables. This is typically used to ensure that subsequent commands or applications do not use proxy settings that were previously configured.

```bash
unset http_proxy https_proxy all_proxy
```

--------------------------------

### Whistle Editor Global and Scrollbar Styling (CSS)

Source: https://github.com/alibaba/lightproxy/blob/master/vendor/whistle/biz/webui/htdocs/editor.html

Applies global styling to html, body, and .main elements for padding, margin, height, and overflow. It also defines custom scrollbar styles for webkit browsers, including width, thumb color, hover effects, and track appearance.

```css
html, body, .main {padding: 0; margin: 0; height: 100%; overflow: hidden;}
::-webkit-scrollbar{ width:10px; height:10px; }
::-webkit-scrollbar-button{ width:10px;height:1px; }
::-webkit-scrollbar-thumb{ background-clip:padding-box; background-color:rgba(0,0,0,.5); border-radius:8px; min-height: 30px;}
::-webkit-scrollbar-thumb:hover{ background-clip:padding-box; background-color:rgba(0,0,0,.7); border-radius:8px;}
::-webkit-scrollbar-track,::-webkit-scrollbar-thumb { border-left:2px solid transparent; border-right:2px solid transparent;}
::-webkit-scrollbar-track:hover{ background-clip:padding-box; background-color:rgba(0,0,0,.15);}
```

--------------------------------

### Escape JavaScript for HTML Attributes (JavaScript)

Source: https://github.com/alibaba/lightproxy/blob/master/vendor/whistle.chii-internal/_rules.txt

The `escapeJs` function takes a string and returns an escaped version suitable for use within HTML attributes or JavaScript strings. It handles common special characters like quotes, backslashes, newlines, and line/paragraph separators. This prevents potential XSS vulnerabilities or syntax errors when embedding dynamic content.

```javascript
function escapeJs(str) {
  if (!str || typeof str !== 'string') {
    return '';
  }
  return str.replace(/["'\\\n\r\u2028\u2029]/g, function(char) {
      switch (char) {
          case '"':
          case "'":
          case '\\':
              return '\\' + char;

          case '\n':
              return '\\n';

          case '\r':
              return '\\r';
          // Line separator

          case '\u2028':
              return '\\u2028';
          // Paragraph separator

          case '\u2029':
              return '\\u2029';
      }
  });
};
```

--------------------------------

### Intercept Link Clicks in JavaScript

Source: https://github.com/alibaba/lightproxy/blob/master/vendor/whistle/biz/webui/htdocs/index.html

This JavaScript code adds a click event listener to the document. When a click occurs, it uses the `findParent` function to check if the clicked element is an anchor tag (`<a>`). If it is, and the link has an `href`, it prevents the default link behavior and opens the URL using the custom `window.open` function defined elsewhere in the script.

```javascript
document.addEventListener('click', (e) => {
    const link = findParent('a', e.target);
    if (link.href) {
        e.preventDefault();
        window.open(link.href);
    }
});
```

--------------------------------

### Find Parent DOM Element in JavaScript

Source: https://github.com/alibaba/lightproxy/blob/master/vendor/whistle/biz/webui/htdocs/index.html

This JavaScript function, `findParent`, traverses up the DOM tree from a given element to find the first ancestor that matches a specified tag name. It's a common utility for event delegation or when direct parent access is not available. The function handles case-insensitive tag name matching.

```javascript
function findParent (tagname, el) {
    while (el){
        if ((el.nodeName || el.tagName).toLowerCase()===tagname.toLowerCase()){
            return el;
        }
        // @ts-ignore
        el = el.parentNode;
    }
    return null;
}
```