Merge pull request #5 from NitroRCr/alpha

v0.11
NitroRCr · Jun 8, 2020 · 0bfe55c · 0bfe55c
2 parents 7f7734f + f9bf5e1
commit 0bfe55c
Showing 9 changed files with 203 additions and 241 deletions.
diff --git a/README.md b/README.md
@@ -5,14 +5,17 @@
 设计目标为酷安，理论上所有完整支持Unicode的社区等 都能够使用，但效果不确定。实测对[网易易盾](https://dun.163.com/product/text-detection)的文本检测API有一定效果。
 
 ## 原理：
+以下是不同选项的原理
+
 + 普通模式：在相隔的两个字符之间插入Unicode零宽间隔符（[U+200B](https://unicode.org/cldr/utility/character.jsp?a=200B)）以规避检测。
-+ （可选）增强的每行双重反转模式：将一行内所有文字顺序反转（物理）再加入Unicode反转控制符([U+202E](https://unicode.org/cldr/utility/character.jsp?a=202E))从而实现增强的规避检测。
-+ （可选）每两字反转模式：另一种增强模式，这里不作过多解释~~（其实是懒）~~
-+ （可选）转为竖向排列：纯“物理”的处理方法，不使用`Unicode`控制符，仅把文本转为竖向排列。
-+ （可选）（默认选中）规避中括号和链接：遇到中括号和链接时不进行处理，以兼容表情符号和链接。
-+ （可选）同形字母替换：将部分普通拉丁文字母替换为其他语言中外形相同的字母
++ 每行双重反转模式：将一行内所有文字顺序反转（物理）再加入Unicode反转控制符([U+202E](https://unicode.org/cldr/utility/character.jsp?a=202E))从而实现增强的规避检测。
++ 每两字反转模式：另一种增强模式，这里不作过多解释~~（其实是懒）~~
++ 转为竖向排列：纯“物理”的处理方法，不使用`Unicode`控制符，仅把文本转为竖向排列。
++ 规避中括号和链接：遇到中括号和链接时不进行处理，以兼容表情符号和链接。
++ 同形字母替换：将部分普通拉丁文字母替换为其他语言中外形相同的字母
++ 链接转短链接：使用[is.gd](https://is.gd)的`API`，将文本中的`http/https`链接替换短连接，以避开对链接的域名检测
+
 
-关于原理的详细说明，可以参考[这篇文章](https://blog.texice.xyz/2020/Anti-Text-Detect/)。
 
 ### Example
 
@@ -36,8 +39,10 @@
 "ABCD" => "\u200eA\u202eCB\u202c\u200eD"
 ```
 
+看详细原理的话，翻源码吧（没写注释别打我）
 
 ## 隐私：
+
 基于JavaScript的网页实现，仅运行在浏览器端，不会将数据传到服务器~可以放心使用
 ## 已实现/将实现的功能：
 + [x] 增强模式
@@ -53,10 +58,9 @@
 + 可以在[Release页面](https://github.com/NitroRCr/Words-away/releases)下载最新的离线版本
 >1. 打开网页  
 >2. 输入或粘贴需要处理的文本  
->3. 根据需要选中相应的功能。  
+>3. 根据需要选中相应的选项。  
 >4. 处理，复制  
->5. 粘贴到酷安，能够正常发出（大多数情况）  
->>另有一个[被历史抛弃的旧版](https://blog.texice.xyz/demo/textmix)，已停止维护，随时移除。
+>5. 粘贴到酷安，能够正常发布（大多数情况）  
 ## 免责声明：
 **过于敏感的词语即使反转也会被检测到**，因此这个工具并不是万能的  
 另外虽然Unicode控制符不会被机器检测，**但是酷安小编本人说过用Unicode控制符发送严重违规消息直接永封不解。**  

diff --git a/_redirects b/_redirects
diff --git a/css/simple.css b/css/simple.css
@@ -15,6 +15,11 @@ h3 {
     font-weight: bold;
 }
 
+h2 {
+    font-size: 1.6em;
+    font-weight: bold;
+}
+
 .container {
     width: 90%;
     margin: auto;

diff --git a/index.html b/index.html
@@ -81,11 +81,11 @@ <h3>多种处理方式</h3>
                             <p>可根据需要选用不同的处理方式</p>
                         </div>
                         <div class="col s12 m6">
-                           <h3>Change Log v0.10.2</h3>
+                           <h3>Change Log v0.11</h3>
                            <p>
-                           优化细节，修复bug <br>
-                           <span style="font-weight: bold;">v0.10.1</span><br>
-                              兼容 emoji 等 代理对字符
+                           新增 链接转短链接 选项<br>
+                           改进 同形字母替换 选项
+                           优化 代码逻辑
                             </p>
                         </div>
                     </div>
@@ -129,7 +129,7 @@ <h2>Start</h2>
                             <div class="switch">
                                 <label>
                                     <input type="checkbox" class="filled-in" checked="checked" id="miss-brackets" />
-                                    <span>避开链接和中括号</span>
+                                    <span>兼容链接和酷安表情</span>
                                 </label><br>
                                 <label>
                                     <input type="checkbox" class="filled-in" id="zero-width-space" checked="checked" />
@@ -143,13 +143,17 @@ <h2>Start</h2>
                                     <input type="checkbox" class="filled-in" id="words-reverse" />
                                     <span>每两字双重反转（增强）</span>
                                 </label><br>
+                                <label>
+                                    <input type="checkbox" class="filled-in" id="shorten-url" />
+                                    <span>链接转短链接（API）</span>
+                                </label><br>
                                 <label>
                                     <input type="checkbox" class="filled-in" id="vertical-text" />
                                     <span>转为竖向排列（物理）</span>
                                 </label><br>
                                 <label>
                                     <input type="checkbox" class="filled-in" id="fake-normal" />
-                                    <span>同形字母替换（不兼容链接）</span>
+                                    <span>同形字母替换（附加）</span>
                                 </label><br>
                             </div>
                             <a class="waves-effect waves-light btn-small start-mixin" onclick="return false;" style="float: right">处理</a>
@@ -184,6 +188,8 @@ <h3>每两字双重反转</h3>
                     <p>
                         另一种增强模式，缺陷是当一行文本以多行的形式显示时，有三分之一的概率 上一行的最后一字与下一行的第一个字位置交换，这里不作过多解释。
                     </p>
+                    <h3>链接转短链接</h3>
+                    <p>使用<a href="https://is.gd">is.gd</a>的API，将文本中的http/https链接替换短连接，以避开对链接的域名检测</p>
                     <h3>转为竖向排列</h3>
                     <p>
                         纯“物理”的处理方法，不使用Unicode控制符，仅把文本转为竖向排列。<br>
@@ -203,10 +209,11 @@ <h3>使用须知 &amp; 免责声明</h3>
                         <li>- 禁止用于传播不良信息。使用不当造成不良后果概不负责。</li>
                         <li>- 无法避开所有的关键词检测</li>
                         <li>- 只能避开机器检测</li>
+                        <li>- 请低调使用</li>
                         <li>- nhml警告<i class="c-shounuehuaji"></i></li>
                         (酷安小编本人说过用Unicode控制符发送严重违规消息直接永封不解。)
                         <li>- 某些模式不能共存</li>
-                        <li>- 一段文本不可多次处理，处理后的文本暂无法直接还原。</li>
+                        <li>- 处理后的文本暂无法直接还原。</li>
                     </ul>
                     <div style="height: 50px;"></div>
                 </div>
@@ -232,6 +239,7 @@ <h3>使用须知 &amp; 免责声明</h3>
     <script src="js/clipboard.min.js"></script>
     <script src="js/Words-away.js"></script>
     <script src="js/OneText.js"></script>
+    <script src="js/simple.js"></script>
     <script src="js/index.js"></script>
     <script src="js/materialize.min.js"></script>
     <script async src="//busuanzi.ibruce.info/busuanzi/2.3/busuanzi.pure.mini.js">

diff --git a/js/Words-away.js b/js/Words-away.js
@@ -1,101 +1,44 @@
 function WordsAway() {}
 WordsAway.prototype.mixin = function (text, mixin = '\u200b', missBrackets = true) {
-    text = Array.from(text);
-    var result = '';
-    var inBrackets = false;
-    if (missBrackets) {
-        for (let i of text) {
-            if (inBrackets) {
-                result += i;
-            } else {
-                result += (mixin + i);
-            }
-            if (i == '[') {
-                inBrackets = true;
-            } else if (i == ']') {
-                inBrackets = false;
-            }
-        }
-    } else {
-        for (let i of text) {
-            result += (mixin + i);
-        }
-    }
-    return result;
+    return this.stringListed(text, missBrackets).join(mixin);
 }
-WordsAway.prototype.turnOver = function (text, missBrackets = true) {
+WordsAway.prototype.rowsReverse = function (text, missBrackets = true) {
     var rows = text.split('\n');
     var result = '';
-    for (let i in rows) {
-        let x = Array.from(rows[i]);
-        let inBrackets = false;
-        let before;
-        let newRow = '';
-        for (let j in x) {
-            let y = x[j];
-            if (y == '[' && missBrackets) {
-                before = j;
-                inBrackets = true;
-            } else if (y == ']' && missBrackets && inBrackets) {
-                inBrackets = false;
-                newRow = x.slice(before, parseInt(j) + 1).join('') + newRow;
-            } else if (!inBrackets) {
-                newRow = y + newRow;
-            }
-        }
-        if (inBrackets && missBrackets) {
-            inBrackets = false;
-            newRow = x.slice(before, x.length + 1).reverse().join('') + newRow;
-        }
+    for (let i = 0; i < rows.length; i++) {
+        result += '\u202e' + this.stringListed(rows[i], missBrackets).reverse().join('');
         if (i < rows.length - 1) {
-            newRow = '\u202e' + newRow + '\n';
-        } else {
-            newRow = '\u202e' + newRow;
+            result += '\n';
         }
-        result += newRow;
     }
-    return this.toggleBrackets(result);
+    return this.toggleBrackets(result, missBrackets);
 }
 WordsAway.prototype.wordsReverse = function (text, missBrackets = true) {
     var rows = text.split('\n');
     var result = '';
-    for (let i in rows) {
-        let inBrackets = false;
-        let x = Array.from(rows[i]);
-        let before;
-        let newRow = '';
-        for (let j = 0; j < x.length; j += 3) {
-            let y = x.slice(j, j + 3);
-            let hasBrackets = false;
-            if (y.indexOf('[') != -1 && missBrackets) {
-                inBrackets = true;
-                hasBrackets = true;
-            }
-            if (y.indexOf(']') != -1 && missBrackets) {
-                inBrackets = false;
-                hasBrackets = true;
-            }
-            if (inBrackets | hasBrackets) {
-                newRow += y.join('');
-            } else {
-                newRow += '\u200e' + x[j] + '\u202e' +
-                    ((x[j + 2] !== undefined) ? this.toggleBracketsChar(x[j + 2]) : '') +
-                    ((x[j + 1] !== undefined) ? this.toggleBracketsChar(x[j + 1]) : '') +
-                    '\u202c';
-            }
+    for (let i = 0; i < rows.length; i++) {
+        let list = this.stringListed(rows[i]);
+        for (let j = 0; j < list.length; j += 3) {
+            let first = list[j];
+            let second = (list[j + 1] !== undefined) ?
+                this.toggleBracketsChar(list[j + 1]) :
+                '';
+            let third = (list[j + 2] !== undefined) ?
+                this.toggleBracketsChar(list[j + 2]) :
+                '';
+            result += ('\u200e' + first + '\u202e' + third + second + '\u202c');
         }
         if (i < rows.length - 1) {
-            result += newRow + '\n';
-        } else {
-            result += newRow;
+            result += '\n';
         }
     }
     return result;
 }
-WordsAway.prototype.toggleBrackets = function (text) {
+WordsAway.prototype.toggleBrackets = function (text, brackets) {
+    var list = this.stringListed(text, brackets);
     result = '';
-    for (let i in text) {
-        result += this.toggleBracketsChar(text[i]);
+    for (let i in list) {
+        result += this.toggleBracketsChar(list[i]);
     }
     return result;
 }
@@ -131,21 +74,61 @@ WordsAway.prototype.verticalText = function (text, maxCol = 12, minHeight = 10)
     }
     return result;
 }
-WordsAway.prototype.sameShape = function(text) {
+WordsAway.prototype.sameShape = function (text, brackets) {
     var styles = {
         'normal': 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ',
         //实际有效：асԁеցһіјӏոорԛѕսԝхуАВСЕНІЈКМОРԚЅΤՍԜХΥΖ
         'fake-normal': 'аbсԁеfցһіјkӏmոорԛrѕtսvԝхуzАВСDЕFGНІЈКLМNОРԚRЅΤՍVԜХΥΖ',
     }
-    return this.replaceAll(text, styles['normal'], styles['fake-normal']);
+    return this.replaceAll(text, styles['normal'], styles['fake-normal'], brackets);
+}
+WordsAway.prototype.replaceAll = function (text, from, to, brackets) {
+    if (from.length != to.length) {
+        console.log('`from` and `to`, length are not the same!');
+    }
+    var result = '';
+    var list = this.stringListed(text, brackets);
+    for (let i of list) {
+        let found = false;
+        for (let j in from) {
+            if (i == from[j]) {
+                result += to[j];
+                found = true;
+            }
+        }
+        if (!found) {
+            result += i;
+        }
+    }
+    return result;
 }
-WordsAway.prototype.replaceAll = function (text, from, to) {
-    for (let i = 0; i < from.length; i++) {
-        if (to[i] === undefined) {
-            continue;
+WordsAway.prototype.stringListed = function (text, brackets = true) {
+    var list = Array.from(text);
+    var result = [];
+    if (brackets) {
+        var inBrackets = false;
+        var before = 0;
+        for (let i = 0; i < list.length; i++) {
+            let x = list[i];
+            if (x == '[') {
+                if (inBrackets) {
+                    result.concat(list.slice(before, i));
+                } else {
+                    inBrackets = true;
+                    before = i;
+                }
+            } else if (x == ']' && inBrackets) {
+                inBrackets = false;
+                result.push(list.slice(before, i + 1).join(''));
+            } else if (!inBrackets) {
+                result.push(x);
+            }
+        }
+        if (inBrackets) {
+            result.concat(list.slice(before, list.length));
         }
-        let step = (to.codePointAt(0) > 65536) ? 2 : 1;
-        text = text.replace(new RegExp(from[i], 'g'), to.slice(step * i, step * i + step));
+    } else {
+        result = list;
     }
-    return text;
-}
+    return result
+}
diff --git a/js/common.js b/js/common.js
diff --git a/js/index.js b/js/index.js
@@ -1,81 +1,3 @@
-var wordsAway = new WordsAway();
-
-$('.start-mixin').click(function () {
-    var text = $('#textin').val();
-    var mixin = '\u200b';
-    var missBrackets = $('#miss-brackets')[0].checked;
-    text = (missBrackets) ?
-        text.replace(/(http(s)?:\/\/([\w-]+\.)+[\w-]+(\/[\w- .\/?%&=]*)?)/g, '[$1]') :
-        text;
-    text = ($('#rows-reverse')[0].checked) ?
-        wordsAway.turnOver(text, missBrackets) :
-        text;
-    text = ($('#words-reverse')[0].checked) ?
-        wordsAway.wordsReverse(text, missBrackets) :
-        text;
-    text = ($('#zero-width-space')[0].checked) ?
-        wordsAway.mixin(text, mixin, missBrackets) :
-        text;
-    text = ($('#vertical-text')[0].checked) ?
-        wordsAway.verticalText(text, parseInt($('#max-col').val()), parseInt($('#min-row').val())) :
-        text;
-    text = (missBrackets) ?
-        text.replace(/\[(http(s)?:\/\/([\w-]+\.)+[\w-]+(\/[\w- .\/?%&=]*)?)\]/g, '$1') :
-        text;
-    text = ($('#fake-normal')[0].checked) ?
-        wordsAway.sameShape(text) :
-        text;
-    $('pre.result').text(text);
-    $('.to-copy').attr('data-clipboard-text', text);
-})
-
-$('#miss-brackets').click(function () {
-    if ($(this)[0].checked) {
-        $('#vertical-text')[0].checked = false;
-    }
-})
-$('#rows-reverse').click(function () {
-    if ($(this)[0].checked) {
-        $('#words-reverse')[0].checked = false;
-        $('#vertical-text')[0].checked = false;
-    }
-})
-$('#words-reverse').click(function () {
-    if ($(this)[0].checked) {
-        $('#rows-reverse')[0].checked = false;
-        $('#zero-width-space')[0].checked = false;
-        $('#vertical-text')[0].checked = false;
-    }
-})
-$('#zero-width-space').click(function () {
-    if ($(this)[0].checked) {
-        $('#words-reverse')[0].checked = false;
-        $('#vertical-text')[0].checked = false;
-    }
-})
-$('#vertical-text').click(function () {
-    if ($(this)[0].checked) {
-        $('#rows-reverse').attr('disabled', 'disabled')[0].checked = false;
-        $('#zero-width-space').attr('disabled', 'disabled')[0].checked = false;
-        $('#words-reverse').attr('disabled', 'disabled')[0].checked = false;
-        $('#miss-brackets').attr('disabled', 'disabled')[0].checked = false;
-        $('.input-field.hidden').css('display', 'inline-block');
-    } else {
-        $('#rows-reverse').removeAttr('disabled');
-        $('#zero-width-space').removeAttr('disabled')[0].checked = true;
-        $('#words-reverse').removeAttr('disabled');
-        $('#miss-brackets').removeAttr('disabled')[0].checked = true;
-        $('.input-field.hidden').css('display', 'none');
-    }
-})
-
-new ClipboardJS('.to-copy');
-$('.to-copy').click(function () {
-    M.toast({
-        html: '已复制'
-    });
-})
-
 function Index() {
     this.landBgs = [
         'img/dark-PC-compressed/1.jpg',

diff --git a/js/simple.js b/js/simple.js
@@ -8,7 +8,7 @@ $('.start-mixin').click(function () {
         text.replace(/(http(s)?:\/\/([\w-]+\.)+[\w-]+(\/[\w- .\/?%&=]*)?)/g, '[$1]') :
         text;
     text = ($('#rows-reverse')[0].checked) ?
-        wordsAway.turnOver(text, missBrackets) :
+        wordsAway.rowsReverse(text, missBrackets) :
         text;
     text = ($('#words-reverse')[0].checked) ?
         wordsAway.wordsReverse(text, missBrackets) :
@@ -19,59 +19,89 @@ $('.start-mixin').click(function () {
     text = ($('#vertical-text')[0].checked) ?
         wordsAway.verticalText(text, parseInt($('#max-col').val()), parseInt($('#min-row').val())) :
         text;
+    text = ($('#fake-normal')[0].checked) ?
+        wordsAway.sameShape(text, missBrackets) :
+        text;
     text = (missBrackets) ?
         text.replace(/\[(http(s)?:\/\/([\w-]+\.)+[\w-]+(\/[\w- .\/?%&=]*)?)\]/g, '$1') :
         text;
-    text = ($('#fake-normal')[0].checked) ?
-        wordsAway.sameShape(text) :
-        text;
-    $('pre.result').text(text);
-    $('.to-copy').attr('data-clipboard-text', text);
-})
+
+    var setText = () => {
+        $('pre.result').text(text);
+        $('.to-copy').attr('data-clipboard-text', text);
+    }
+
+    if ($('#shorten-url')[0].checked) {
+        var urls = text.match(/(http(s)?:\/\/([\w-]+\.)+[\w-]+(\/[\w- .\/?%&=]*)?)/g);
+        $('pre.result').text('短链接请求中...');
+        urls || setText();
+        for (let i in urls) {
+            $.get('https://is.gd/create.php', {
+                'url': urls[i],
+                'format': 'json'
+            }, (data) => {
+                text = text.replace(urls[i], data['shorturl']);
+                if (i == urls.length - 1) {
+                    setText();
+                }
+            }, 'jsonp').fail(() => {
+                M.toast('短链接请求失败');
+                setText();
+            });
+        }
+    } else {
+        setText();
+    }
+});
 
 $('#miss-brackets').click(function () {
     if ($(this)[0].checked) {
         $('#vertical-text')[0].checked = false;
+        $('#shorten-url').removeAttr('disabled');
+    } else {
+        $('#shorten-url').attr('disabled', 'disabled')[0].checked = false;
     }
-})
+});
 $('#rows-reverse').click(function () {
     if ($(this)[0].checked) {
         $('#words-reverse')[0].checked = false;
         $('#vertical-text')[0].checked = false;
     }
-})
+});
 $('#words-reverse').click(function () {
     if ($(this)[0].checked) {
         $('#rows-reverse')[0].checked = false;
         $('#zero-width-space')[0].checked = false;
         $('#vertical-text')[0].checked = false;
     }
-})
+});
 $('#zero-width-space').click(function () {
     if ($(this)[0].checked) {
         $('#words-reverse')[0].checked = false;
         $('#vertical-text')[0].checked = false;
     }
-})
+});
 $('#vertical-text').click(function () {
     if ($(this)[0].checked) {
         $('#rows-reverse').attr('disabled', 'disabled')[0].checked = false;
         $('#zero-width-space').attr('disabled', 'disabled')[0].checked = false;
         $('#words-reverse').attr('disabled', 'disabled')[0].checked = false;
         $('#miss-brackets').attr('disabled', 'disabled')[0].checked = false;
+        $('#shorten-url').attr('disabled', 'disabled')[0].checked = false;
         $('.input-field.hidden').css('display', 'inline-block');
     } else {
         $('#rows-reverse').removeAttr('disabled');
         $('#zero-width-space').removeAttr('disabled')[0].checked = true;
         $('#words-reverse').removeAttr('disabled');
         $('#miss-brackets').removeAttr('disabled')[0].checked = true;
+        $('#shorten-url').removeAttr('disabled');
         $('.input-field.hidden').css('display', 'none');
     }
-})
+});
 
 new ClipboardJS('.to-copy');
 $('.to-copy').click(function () {
     M.toast({
-        html: '已复制<i class="c-huaji no-transform"></i>'
+        html: '已复制'
     });
-})
+});
diff --git a/simple.html b/simple.html
@@ -14,47 +14,9 @@
     <div class="container">
         <h1 style="font-weight: bold; font-size: 2em">文本防检测 | Words-away</h1>
         <p style="line-height: 2;">
-            一个文本处理工具，可用于避免酷安的关键词误屏蔽<i class="c-shounuehuaji"></i><br>
-            以下是说明：
+            一个文本处理工具，可用于避免酷安的关键词误屏蔽<br>
         </p>
-        <h3>零宽间隔模式</h3>
-        <p>
-            可视为普通模式，会在每两个字符之间插♂入一个 零宽间隔符 (<a href="https://unicode-table.com/cn/200B/">U+200B</a>)。<br>
-            处理之后文本看上去没有变化，实际上每个字都被间隔开了，可以避开一般的关键词检测。<br>
-        </p>
-        <h3>每行双重反转</h3>
-        <p>
-            可视为一种增强模式，会将每行文字反转，然后在每行开头加上一个 强制从右至左符 (<a href="https://unicode-table.com/cn/202E/">U+202E</a>可以避开更多的关键词检测<i class="c-coshuaji"></i><br>
-            但这个模式的缺陷是当一行文本（即不含换行符）以多行形式显示时，这几行的显示顺序会混乱。<br>
-        </p>
-        <h3>每两字双重反转</h3>
-        <p>
-            另一种增强模式，缺陷是当一行文本以多行的形式显示时，有三分之一的概率 上一行的最后一字与下一行的第一个字位置交换，这里不作过多解释。
-        </p>
-        <h3>转为竖向排列</h3>
-        <p>
-            纯“物理”的处理方法，不使用Unicode控制符，仅把文本转为竖向排列。<br>
-            当处理后的文本超过一列时，这个方法的防检测效果最好（相较于以上几种方法）<br>
-            这个方法仅兼容中文或其他等宽字符，否则会错位。<br>
-            会自动去掉空格和换行符。
-        </p>
-        <h3>同形字母替换</h3>
-        <p>
-            将部分普通拉丁文字母替换为其他语言中外形相同的字母
-        </p>
-        <h3>避开中括号和链接</h3>
-        <p>不对中括号里的内容和http链接进行处理。以兼容酷安表情和防止处理之后链接打不开</p>
-        <h3>使用须知 &amp; 免责声明</h3>
-        <ul style="list-style-type: disc;">
-            <li>- 用途：防止误屏蔽 / 防爬虫 / 防复制 / 防机器检测</li>
-            <li>- 禁止用于传播不良信息。使用不当造成不良后果概不负责。</li>
-            <li>- 无法避开所有的关键词检测</li>
-            <li>- 只能避免机器检测</li>
-            <li>- nhml警告<i class="c-shounuehuaji"></i></li>
-            (酷安小编本人说过用Unicode控制符发送严重违规消息直接永封不解。)
-            <li>- 某些模式不能共存</li>
-            <li>- 一段文本不可多次处理，处理后的文本暂无法直接还原。</li>
-        </ul>
+
         <div class="row">
             <form class="col s12">
                 <div class="row">
@@ -74,7 +36,7 @@ <h3>使用须知 &amp; 免责声明</h3>
                         <div class="switch">
                             <label>
                                 <input type="checkbox" class="filled-in" checked="checked" id="miss-brackets" />
-                                <span>避开链接和中括号</span>
+                                <span>兼容链接和酷安表情</span>
                             </label><br>
                             <label>
                                 <input type="checkbox" class="filled-in" id="zero-width-space" checked="checked" />
@@ -88,26 +50,72 @@ <h3>使用须知 &amp; 免责声明</h3>
                                 <input type="checkbox" class="filled-in" id="words-reverse" />
                                 <span>每两字双重反转（增强）</span>
                             </label><br>
+                            <label>
+                                <input type="checkbox" class="filled-in" id="shorten-url" />
+                                <span>链接转短链接（API）</span>
+                            </label><br>
                             <label>
                                 <input type="checkbox" class="filled-in" id="vertical-text" />
                                 <span>转为竖向排列（物理）</span>
                             </label><br>
                             <label>
                                 <input type="checkbox" class="filled-in" id="fake-normal" />
-                                <span>同形字母替换（不兼容链接）</span>
+                                <span>同形字母替换（附加）</span>
                             </label><br>
                         </div>
                         <a class="waves-effect waves-light btn-small start-mixin" onclick="return false;" style="float: right">处理</a>
                     </div>
                 </div>
             </form>
         </div>
-        <div style="height: 100px"></div>
+        <div style="height: 50px"></div>
         <p style="font-weight: bold">处理结果：</p>
         <pre class="result">请先处理<i class="c-shounuehuaji"></i>
 </pre>
         <button data-clipboard-text="请先处理" class="waves-effect waves-light btn-small to-copy">复制</button>
-        <div style="height: 100px"></div>
+        <div style="height: 50px"></div>
+        <h2>使用说明</h2>
+        <h3>零宽间隔模式</h3>
+        <p>
+            可视为普通模式，会在每两个字符之间插♂入一个 零宽间隔符 (<a href="https://unicode-table.com/cn/200B/">U+200B</a>)。<br>
+            处理之后文本看上去没有变化，实际上每个字都被间隔开了，可以避开一般的关键词检测。<br>
+        </p>
+        <h3>每行双重反转</h3>
+        <p>
+            可视为一种增强模式，会将每行文字反转，然后在每行开头加上一个 强制从右至左符 (<a href="https://unicode-table.com/cn/202E/">U+202E</a>可以避开更多的关键词检测<i class="c-coshuaji"></i><br>
+            但这个模式的缺陷是当一行文本（即不含换行符）以多行形式显示时，这几行的显示顺序会混乱。<br>
+        </p>
+        <h3>每两字双重反转</h3>
+        <p>
+            另一种增强模式，缺陷是当一行文本以多行的形式显示时，有三分之一的概率 上一行的最后一字与下一行的第一个字位置交换，这里不作过多解释。
+        </p>
+        <h3>链接转短链接</h3>
+        <p>使用<a href="https://is.gd">is.gd</a>的API，将文本中的http/https链接替换短连接，以避开对链接的域名检测</p>
+        <h3>转为竖向排列</h3>
+        <p>
+            纯“物理”的处理方法，不使用Unicode控制符，仅把文本转为竖向排列。<br>
+            当处理后的文本超过一列时，这个方法的防检测效果最好（相较于以上几种方法）<br>
+            这个方法仅兼容中文或其他等宽字符，否则会错位。<br>
+            会自动去掉空格和换行符。
+        </p>
+        <h3>同形字母替换</h3>
+        <p>
+            将部分普通拉丁文字母替换为其他语言中外形相同的字母
+        </p>
+        <h3>避开中括号和链接</h3>
+        <p>不对中括号里的内容和http链接进行处理。以兼容酷安表情和防止处理之后链接打不开</p>
+        <h3>使用须知 &amp; 免责声明</h3>
+        <ul style="list-style-type: disc;">
+            <li>- 用途：防止误屏蔽 / 防爬虫 / 防复制 / 防机器检测</li>
+            <li>- 禁止用于传播不良信息。使用不当造成不良后果概不负责。</li>
+            <li>- 无法避开所有的关键词检测</li>
+            <li>- 只能避免机器检测</li>
+            <li>- nhml警告<i class="c-shounuehuaji"></i></li>
+            (酷安小编本人说过用Unicode控制符发送严重违规消息直接永封不解。)
+            <li>- 某些模式不能共存</li>
+            <li>- 一段文本不可多次处理，处理后的文本暂无法直接还原。</li>
+        </ul>
+        <div style="height: 50px;"></div>
         <p>
             <a href="https://github.com/NitroRCr/Words-away">Github 项目地址</a><br>
             <a href="index.html">花里胡哨的版本</a>
@@ -126,6 +134,8 @@ <h3>使用须知 &amp; 免责声明</h3>
     <script src="js/simple.js"></script>
     <script src="js/materialize.min.js"></script>
     <script src="https://coolemotion.netlify.com/png-edition/coolapk-emotion-png.min.js"></script>
+    <!--
     <script async src="//busuanzi.ibruce.info/busuanzi/2.3/busuanzi.pure.mini.js">
     </script>
+-->
 </body>