├── .gitignore
├── README.md
├── build.rb
├── config.example.yaml
├── config.production.yaml
├── docs
    └── zh-CN
    │   └── how-to-write-a-plan.md
├── lib
    ├── json-object.rb
    ├── mx-plan.rb
    └── mx-plan
    │   ├── action
    │       ├── ch-attr-defines.rb
    │       ├── change-attribute.rb
    │       ├── execute-user-script.rb
    │       ├── formula.rb
    │       └── hide-except.rb
    │   └── mx-action.rb
├── migration.rb
├── migrations
    └── convert_to_actions.rb
├── plans
    ├── channel_default.json
    ├── channel_test.json
    ├── channel_zh.json
    ├── default
    │   ├── arch-wiki.json
    │   ├── github.json
    │   └── wikipedia.json
    ├── test
    │   └── dev-pc.json
    └── zh
    │   ├── 36kr.json
    │   ├── 52pojie.json
    │   ├── bilibili.json
    │   ├── cnblogs.json
    │   ├── coolshell.json
    │   ├── csdn.json
    │   ├── guokr.json
    │   ├── ifeng.json
    │   ├── ipcfun.json
    │   ├── iplaysoft.json
    │   ├── iteye.json
    │   ├── ithome.json
    │   ├── jianshu.json
    │   ├── juejin.json
    │   ├── linux-china.json
    │   ├── ruanyifeng.json
    │   ├── ruby-china.json
    │   ├── segmentfault.json
    │   ├── solidot-cn.json
    │   ├── sspai.json
    │   ├── v2ex.json
    │   ├── wangyi.json
    │   ├── weibo.json
    │   ├── weixin-gh.json
    │   └── zhihu.json
└── tmp
    └── .keep


/.gitignore:
--------------------------------------------------------------------------------
1 | 
2 | config.yaml
3 | public
4 | scripts
5 | tmp
6 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | 
  2 | ## 简介
  3 | 
  4 | 『毛线助手』允许你做如下事情：
  5 | 
  6 | * 在裁剪之前对网页的状态进行一些修改，以实现一个更好的裁剪结果
  7 | * 重写一些配置信息，是一次性配置，即网页级别的配置
  8 | * 预先填写表单，可对某些网页的标题、分类和标签进行预填写
  9 | * 选中某一区域，这样就不需要每次都进行点选
 10 | * 选中某一区域，并进行确认，直接到填写表单那一步
 11 | * 选中某一区域，并立即自动进行裁剪，即当你点击裁剪之后，整个裁剪动作自动开始
 12 | 
 13 | 
 14 | ## 为什么需要修改网页的状态？
 15 | 
 16 | 由于 MaoXian Web Clipper 裁剪网页的时候，裁剪的是当前状态下的网页，并且不会保存任何脚本文件（即 javascript）。 这意味着在一些情况下，我们需要对网页进行一些操作后，才能获得一个较好的裁剪结果。
 17 | 
 18 | 比如：
 19 | 
 20 | * 一篇文章里的图片显示的都是缩略图，而你想保存的是原图
 21 | * 或者是你不想保存选区内的按钮、评论等无关内容
 22 | * 又或者是网页上的某些区域是可折叠的，需要在裁剪前把它们都展开。
 23 | 
 24 | ## 如何利用预填表单？
 25 | 
 26 | * 设置正确的标题，在内容标题和整个网页的标题不一致时使用。
 27 | * 设置分类，比如新闻网页，都预先保存在 `新闻` 分类下。
 28 | * 设置标签，预先为这些网页打上可预知的标签。
 29 | 
 30 | 一旦网页的表单都预先填写了，那么就可利用『选中区域』动作，实现一键裁剪。
 31 | 
 32 | ## 如何利用网页级别的配置？
 33 | 
 34 | 网页级别的配置，一般用于一些例外的情况。如：
 35 | 
 36 | * 你默认的保存格式为 Markdown，但是某些网页更适合保存成 HTML。你就可以利用网页级别配置，把这些网页的存储格式设置成 HTML。
 37 | * 你默认是不保存音频的，而对于一个显示铃声的网页，你想把这些小音频保存下来，你就可以利用网页级别配置完成。
 38 | * 等等。。
 39 | 
 40 | 
 41 | ## 三种不同的 Plan
 42 | 
 43 | **全局 Plan**
 44 | 
 45 | 「全局 Plan」 是由你自己编写的。它会应用到所有的网页上，如果某个操作具备普遍性，则可以加入到「全局 Plan」里。
 46 | 
 47 | **自定义 Plan**
 48 | 
 49 | 「自定义 Plan」也是由你自己编写的，它会应用到某一类网页上。此种为最常见的，一般都会对某个网站的某类网页进行裁剪。比如对某个博客的文章进行裁剪，因为同类网页的结构一般都相同，需要对其的操作也相同，所以可以通过编写此种 Plan 对其进行统一处理。
 50 | 
 51 | **公开的 Plan**
 52 | 
 53 | 为了减少用户重复编写「自定义 Plan」的工作。MaoXian 支持你将自己编写的 「自定义 Plan」分享出来，成为 「公开的 Plan」。这样所有用户都会受益。 此种 Plan，可以通过下方的订阅地址获取到。
 54 | 
 55 | 
 56 | ## 订阅「公开的 Plan」
 57 | 
 58 | 将下方的订阅地址复制到：_MaoXian 扩展 > 设置页面 > 助手_ 页面的订阅框中。
 59 | 
 60 | **订阅地址**
 61 | 
 62 | ```shell
 63 | # 默认网站列表（全球性）
 64 | https://mika-cn.github.io/maoxian-web-clipper/assistant/plans/default/index.json
 65 | 
 66 | # 华人网站列表
 67 | https://mika-cn.github.io/maoxian-web-clipper/assistant/plans/zh/index.json
 68 | ```
 69 | 
 70 | 
 71 | ## 参与进来
 72 | 
 73 | 『毛线助手』的工作方式有点像「广告屏蔽扩展」，需要针对不同的网站，编写不同的 Plan。这也意味着它解决问题的多少，取决于我们适配的网站的多少。这需要的不仅仅是开发者，更是每一个使用者的无私分享精神，于此，我们欢迎各位用户参与进来，只有这般，该助手才能发挥其真正的能力。
 74 | 
 75 | 如果你不会编程，你可以在项目 [issue 页面](https://github.com/mika-cn/maoxian-assistant/issues) 提交适配请求(提供需要适配的网址)，或者回馈某个网站适配不正确的信息，以便其他人进行跟进。
 76 | 
 77 | 如果你会编程（只需要懂一点 CSS，了解 JSON 格式就行），那么恭喜你，你完全有能力编写 Plan，并分享给其他人，具体查看下一节。
 78 | 
 79 | 
 80 | ## 如何编写 Plan
 81 | 
 82 | 请查看[这里](https://mika-cn.github.io/maoxian-web-clipper/assistant/how-to-write-a-plan-zh-CN.html)
 83 | 
 84 | ## 项目地址
 85 | 
 86 | [传送门](https://github.com/mika-cn/maoxian-assistant)
 87 | 
 88 | * 该项目用于收集和分享各个用户编写的 “Plan”。
 89 | * 你也可自部署该项目生成的共有 Plan，来减少外部依赖。
 90 | 
 91 | ## 贡献 Plan
 92 | 
 93 | 所有的 Plan 都存储在 `plans` 的子目录下，不同的子目录代表不同频道，每个频道最终都将生成一个订阅地址。请将你写的 Plan 以数组的形式单独存为一个文件，如： `plans/zh/zhihu.json`。每个网站建一个文件。
 94 | 
 95 | 最终所有的 Plan 会在 `build.rb` 这个脚本的渲染下，变成可订阅的形式。
 96 | 
 97 | 你可以通过下方几种方式把 plan 分享出来：
 98 | 
 99 | * 通过 Github 建 Pull Request 的形式。
100 | * 通过 Github 建 issue。（把 plan 贴上即可）
101 | * 通过发邮件给开发者（i.mika[AT]tutanota.com），直接发送内容或者发送 patch。
102 | 
103 | 
104 | ## 最后
105 | 
106 | 如果你对「毛线助手」有什么看法或建议，请[告诉我们](https://github.com/mika-cn/maoxian-assistant/issues)。
107 | 


--------------------------------------------------------------------------------
/build.rb:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env ruby
  2 | 
  3 | # Usage:
  4 | #  ./build $env
  5 | #
  6 | # env: production, development(default)
  7 | 
  8 | require 'yaml'
  9 | require 'json'
 10 | require 'fileutils'
 11 | require_relative 'lib/mx-plan'
 12 | 
 13 | module Check
 14 | 
 15 |   # validate plan.json, return invalid count
 16 |   def self.perform(filename)
 17 |     count = 0
 18 |     begin
 19 |       json = JSON.parse(File.open(filename, 'r').read);
 20 |       if json.is_a? Array
 21 |         json.each do |it|
 22 |           plan = MxPlan.new(it)
 23 |           unless plan.valid?
 24 |             puts "Invalid plan: "
 25 |             puts JSON.pretty_generate(it)
 26 |             puts "Details: "
 27 |             puts plan.errors
 28 |             count += 1
 29 |           end
 30 |         end
 31 |       else
 32 |         puts "[E] #{filename} is not an array"
 33 |       end
 34 |       return count
 35 |     rescue JSON::ParserError => e
 36 |       throw e
 37 |     end
 38 |   end
 39 | 
 40 | end
 41 | 
 42 | module Build
 43 | 
 44 |   def self.perform(output_dir, deploy_path)
 45 |     channels = [];
 46 |     Dir.glob("plans/channel_*.json") do |filename|
 47 |       channel = JSON.parse(File.open(filename, 'r').read)
 48 |       channels.push channel
 49 |     end
 50 | 
 51 |     channels.each do |channel|
 52 |       invalid_plan_count = 0
 53 |       Dir.glob("plans/#{channel['folder']}/*.json") do |filename|
 54 |         invalid_plan_count += Check.perform(filename)
 55 |       end
 56 | 
 57 |       if invalid_plan_count == 0
 58 |         puts "Channel #{channel['name']} OK"
 59 |         renderIndexAndPlans(output_dir, deploy_path, channel)
 60 |       else
 61 |         puts "Channel #{channel['name']} was not build, there're #{invalid_plan_count} invalid plans"
 62 |       end
 63 |     end
 64 |     puts "\nComplete!\n"
 65 |   end
 66 | 
 67 |   def self.renderIndexAndPlans(output_dir, deploy_path, channel)
 68 |     plans = []
 69 |     version = 0;
 70 |     Dir.glob("plans/#{channel['folder']}/*.json") do |filename|
 71 |       json = JSON.parse(File.open(filename, 'r').read)
 72 |       json.each  do |it|
 73 |         if it['version'] > version
 74 |           version = it['version']
 75 |         end
 76 |         plans << MxPlan.new(it)
 77 |       end
 78 |     end
 79 | 
 80 |     if version == 0
 81 |       puts "Not plan to render"
 82 |     end
 83 | 
 84 |     folder = "plans/#{channel['folder']}"
 85 | 
 86 |     url = File.join(deploy_path, folder, 'index.json')
 87 |     indexFilename = File.join(output_dir, folder, 'index.json')
 88 | 
 89 |     update_url = File.join(deploy_path, folder, "#{version}.json")
 90 |     plansFilename = File.join(output_dir, folder, "#{version}.json")
 91 | 
 92 |     index = {
 93 |       name: channel['name'],
 94 |       description: channel['description'],
 95 |       size: plans.size,
 96 |       latestVersion: version,
 97 |       url: url,
 98 |       updateUrl: update_url
 99 |     }
100 | 
101 |     mkdir(indexFilename)
102 |     File.open(indexFilename, 'w') {|f| f.write JSON.pretty_generate(index)}
103 |     File.open(plansFilename, 'w') {|f| f.write JSON.pretty_generate(plans.map(&:to_hash))}
104 | 
105 |     puts indexFilename
106 |     puts plansFilename
107 |     puts "[Done] channel: #{channel['name']}"
108 |     puts ""
109 |   end
110 | 
111 |   def self.mkdir(filename)
112 |     dir = File.dirname(filename)
113 |     unless File.exist?(dir)
114 |       FileUtils.mkdir_p(dir)
115 |     end
116 |   end
117 | 
118 | 
119 | end
120 | 
121 | script_dir = File.expand_path('..', __FILE__)
122 | if FileUtils.pwd != script_dir
123 |   puts "[Error] Please execute this script in #{script_dir}"
124 |   exit 1
125 | end
126 | 
127 | 
128 | env = (ARGV[0] || 'development')
129 | if env == 'production'
130 |   config = YAML.load(File.open('./config.production.yaml', "r").read)
131 | else
132 |   config = YAML.load(File.open('./config.yaml', "r").read)
133 | end
134 | 
135 | Build.perform(config['output_dir'], config['deploy_path'])
136 | 


--------------------------------------------------------------------------------
/config.example.yaml:
--------------------------------------------------------------------------------
1 | 
2 | output_dir: 'public/dev'
3 | deploy_path: 'http://dev.pc:3000/maoxian-web-clipper/tmp/assistant'
4 | 


--------------------------------------------------------------------------------
/config.production.yaml:
--------------------------------------------------------------------------------
1 | 
2 | output_dir: 'public/dist'
3 | deploy_path: 'https://mika-cn.github.io/maoxian-web-clipper/assistant'
4 | 


--------------------------------------------------------------------------------
/docs/zh-CN/how-to-write-a-plan.md:
--------------------------------------------------------------------------------
  1 | 
  2 | # 如何编写 Plan {#how-to-write-a-plan}
  3 | 
  4 | ## 流程 {#workflow}
  5 | 
  6 | 1. 请到 MaoXian Web Clipper 的设置页面，启用「MaoXian 助手」
  7 | 2. 使用任何编辑器编写 Plan， 再把其复制到 「MaoXian 助手」设置里的**自定义 Plan **里。
  8 | 3. 刷新目标网页，点击「裁剪」验证编写的动作有没有产生预期效果。
  9 | 
 10 | ## Plan 的结构解释 {#plan-structure}
 11 | 
 12 | 
 13 | | 参数名 | 类型 | 是否必填 | 备注 |
 14 | | -------- | -------- | -------- | -------- |
 15 | | name        | 字符串 | 必填 | 起标识作用，可随便填写，一般可以直接填写网站名         |
 16 | | pattern     | 字符串、元组 | 必填 | 匹配的模式，只有网址和模式匹配，该 plan 才会被应用           |
 17 | | excludePattern | 字符串、元组 | 选填 | 用于充当 pattern 的黑名单 |
 18 | | version     | 整型 | 必填 | 用于描述最后更新时间，格式为年月日，如：20190721 |
 19 | | contributors | 元组  | 选填 | 用于描述 plan 的作者和贡献者 |
 20 | | disabled    | 波尔值 | 选填 | 用于表示 plan 的禁用状态 |
 21 | | actions     | 元组   | 必填 | 用于描述要执行的动作 |
 22 | | tags        | 元组   | 选填 | 用于标注网站属性，使这些 plan 更好管理 |
 23 | | comment     | 字符串 | 选填 | 备注 |
 24 | 
 25 | 
 26 | ## pattern 参数的使用 {#arg-pattern}
 27 | 
 28 | pattern 参数描述了该 Plan 会应用到哪一类网址上，如果网站有多个域名且很难用匹配符进行匹配，则可以提供多个 Pattern。
 29 | 
 30 | 例如：
 31 | 
 32 | ```json
 33 | {
 34 |   ...
 35 |   "pattern": [
 36 |     "https://a.com/article/*",
 37 |     "https://abcdefg.onion/article/*"
 38 |   ]
 39 | }
 40 | ```
 41 | 
 42 | 如果 pattern 所匹配的网址中有几个特殊项，则可以用 excludePattern 参数剔除。
 43 | 
 44 | 
 45 | 
 46 | 目前支持的匹配符如下：
 47 | 
 48 | * 数字匹配符：`$d`
 49 | * 单星匹配符：`*`
 50 | * 双星匹配符：`**`
 51 | 
 52 | 
 53 | ----------
 54 | 
 55 | 
 56 | **数字匹配符**
 57 | 
 58 | 专门用于匹配数字，常用于匹配网址路径中的数字部分，只能完整匹配，无法作为前缀或者后缀去使用。
 59 | 
 60 | 用例：
 61 | 
 62 | | 模式 | 网址 | 匹配 | 备注 |
 63 | | -------- | -------- | -------- | -------- |
 64 | | `https://example.org/post/$d/$d/$d/$d` | https://example.org/post/2019/07/21/003 | 能 |其中前三个 `$d` 分别匹配到 年，月，日。最后一个 `$d` 匹配到文章 ID，注意网址中的这四个部分全是数字。|
 65 | | `https://example.org/article-$d` | https://example.org/article-001 | 否 | 无法匹配到 `001` 因为这不是完整匹配 |
 66 | 
 67 | 
 68 | 若要匹配部分，如匹配开头或结尾，则需要使用单星匹配符。
 69 | 
 70 | 
 71 | ----------
 72 | 
 73 | 
 74 | **单星匹配符**
 75 | 
 76 | 常用于匹配开头或结尾，相当于匹配零个或多个字符，也可匹配网址路径中的一个目录，但无法匹配多个目录。
 77 | 
 78 | 用例：
 79 | 
 80 | | 模式 | 网址 | 匹配 | 备注 |
 81 | | -------- | -------- | -------- | -------- |
 82 | | `http*://example.org` | http://example.org | 是 | 匹配到零个字符 |
 83 | | `http*://example.org` | https://example.org | 是 | 匹配到 `s` |
 84 | | `https://*.example.org` | https://www.example.org | 是 | 匹配开头的子域名 `www` |
 85 | | `https://*.example.org` | https://foo.bar.example.org | 是 | 匹配开头的子域名 `foo.bar` |
 86 | | `https://a.org/*/index.html` | https://a.org/blog/index.html | 是 | 匹配到路径中的目录 `blog` |
 87 | | `https://a.org/*/index.html` | https://a.org/blog/jake/index.html | 否 | 无法匹配目录分隔符 `/`，即无法匹配多个目录 |
 88 | 
 89 | 
 90 | ----------
 91 | 
 92 | 
 93 | **双星匹配符**
 94 | 
 95 | 一般使用双星匹配符，来匹配零个或零个以上的目录。
 96 | 
 97 | 用例：
 98 | 
 99 | | 模式 | 网址 | 匹配 | 备注 |
100 | | -------- | -------- | -------- | -------- |
101 | | `https://a.org/blog/**/*/*/*/*/*.html` | https://a.org/blog/javascript/2017/01/05/awesome-article.html | 是 | 中间用了四个 `*` 号来匹配分类和年月日，前面的 `**` 匹配可能存在的子分类 |
102 | | `https://example.org/blog/**/*/$d/$d/$d/*.html` | https://a.org/blog/javascript/2017/01/05/awesome-article.html | 是 | 用了更严格的数字匹配符 |
103 | | `https://example.org/blog/` | https://a.org/blog/javascript/2017/01/05/awesome-article.html | 是 | 注意：最后面的 `/`，匹配以该模式打头的网址，极宽松的模式 |
104 | 
105 | 可以看到，对于同一个网址，可以使用不同的模式去匹配，严格程度不同，根据需求去选择即可。
106 | 
107 | 
108 | ----------
109 | 
110 | 
111 | **匹配网址的查询参数部分（较少使用）**
112 | 
113 | 一般匹配，只是匹配网址的查询参数能满足 Pattern 的参数部分。网址的参数数量可以多，顺序也可以不一致。
114 | 
115 | 用例：
116 | 
117 | | 模式 | 网址 | 匹配 | 备注 |
118 | | -------- | -------- | -------- | -------- |
119 | | `https://a.org/page?id=*` | https://a.org/page?id=123 | 是 | 匹配到参数值 `123` |
120 | | `https://a.org/page?id=*` | https://a.org/page?type=news&id=123 | 是 | 匹配到参数值`123`，即使有多个查询参数 |
121 | | `https://a.org/page?type=news` | https://a.org/page?type=news&id=123 | 是 | 匹配到`type=news`，即使有多个查询参数 |
122 | 
123 | 
124 | 严格匹配， 表示网址的查询参数必须和 Pattern 的参数部分严格一致，数量不能多，不能少，但顺序可以不一致。 严格匹配需要在 Pattern 的参数部分的最前方加上 "!"。
125 | 
126 | 用例：
127 | 
128 | | 模式 | 网址 | 匹配 | 备注 |
129 | | -------- | -------- | -------- | -------- |
130 | | `https://a.org/page?!foo=111&bar=222` | https://a.org/page?foo=111&bar=222 | 是 | 完美匹配 |
131 | | `https://a.org/page?!foo=111&bar=222` | https://a.org/page?bar=222&foo=111 | 是 | 即使顺序不同也匹配 |
132 | | `https://a.org/page?!foo=111&bar=222` | https://a.org/page?foo=111 | 否 | 查询参数的数量少了 `bar`
133 | | `https://a.org/page?!foo=111&bar=222` | https://a.org/page?foo=111&bar=222&baz=333 | 否 | 查询参数的数量多了 `baz` |
134 | 
135 | 
136 | 
137 | ## excludePattern 参数的使用 {#arg-excludePattern}
138 | 
139 | 该参数用于作为 pattern 参数的黑名单，也可提供多个。用法请参考 [pattern 参数](#arg-pattern)
140 | 
141 | ## disabled 参数的使用 {#arg-disabled}
142 | 
143 | disabled 参数用于表明该 plan 是否已禁用了。常用于「全局 plan」，或者是禁用某个「公开 plan」。比如你订阅的公开的 plan 列表里，有一个 plan 你不想使用。则可以把那个 plan 复制进 「自定义 plan」列表里，然后把它设为 `"disabled": true` ，就会把它禁用掉。
144 | 
145 | ## actions 参数的使用 {#arg-actions}
146 | 
147 | actions 参数用于描述要执行的动作，结构如下
148 | 
149 | 
150 | ```json
151 | {
152 |   "name"
153 |   "pattern": "https://example.org/post/*/*.html",
154 |   "actions": [
155 |     {"hide": ".ad"},
156 |     {"hide": ".comment", "tag": "md-only"},
157 |     {"pick": "article"}
158 |   ]
159 | }
160 | ```
161 | 
162 | 上面这个 Plan，定义了三个 action，可以看出 action 的结构为 `{$actionName: $actionValue, [tag]}`。
163 | 
164 | tag 标注了这个 action 的使用条件。目前支持的选项有：
165 | 
166 | | 名字 | 效果 |
167 | | -------- | -------- |
168 | | disabled  | 禁用该 action |
169 | | html-only | 只在存储格式为 html 时，才应用 |
170 | | md-only   | 只在存储格式为 md 时，才应用 |
171 | 
172 | 
173 | 用于修改网页状态的动作如下：
174 | 
175 | | 动作名字 | 类型 | 备注 |
176 | | -------- | -------- | -------- |
177 | | show        | 选择器 | 用于显示隐藏的「块状节点」，可提供多个选择器，详情请看下文   |
178 | | hide        | 选择器 | 用于选择「要剔除的节点」，可提供多个选择器，详情请看下文     |
179 | | hideSibling | 选择器 | 用于选择「要剔除的节点」，可提供多个选择器，详情请看下文     |
180 | | hideExcept  | 元组   | 用于选择「要剔除的节点」，选择方式为反选，详情请看下文       |
181 | | chAttr      | 对象   | 用于修改节点的属性值，提供了多种修改属性的方式，详情请看下文 |
182 | 
183 | 
184 | MaoXian 相关的动作如下：
185 | 
186 | | 参数名 | 类型 | 备注 |
187 | | -------- | -------- | -------- |
188 | | formula | 对象 | 用于标注公式 |
189 | | pick 或 select | 选择器 | 用于选择「要裁剪的节点」，可提供多个选择器，详情请看下文 |
190 | | confirm     | 选择器 | 用于选择「要裁剪的节点」，并确认，可提供多个选择器，详情请看下文 |
191 | | clip        | 选择器 | 用于选择「要裁剪的节点」，并立即开始裁剪，可提供多个选择器，详情请看下文 |
192 | | form        | 对象   | 用于预设置表单的输入值，详情见下文 |
193 | | config      | 对象   | 用于重写某些配置项，详情见下文 |
194 | 
195 | ### 选择器 {#selector}
196 | 
197 | 
198 | **选择器的格式**
199 | 
200 | 选择器有两种：CSS 选择器 和 xPath 选择器。是一个字符串，格式为 `$type||$q` 。
201 | 
202 | | 变量 | 说明 | 值 |
203 | | -------- | -------- | -------- |
204 | | $type | 选择器的类型 | C 代表 CSS, X 代表 xPath |
205 | | $q | 选择器 | CSS 选择器 或 xPath 选择器 |
206 | 
207 | 其中 `$type||` 部分可省略，省略后的部分表示的是 CSS 选择器，大部分情况下我们都会用 CSS 选择器，除非一些很难用 CSS 选择器表示的，才会使用到 xPath 选择器。
208 | 
209 | 
210 | 下面我们来看一个例子（注： 本页面给出的例子都是 JSON 格式）
211 | 
212 | ```json
213 | {
214 |   "name": "example.org",
215 |   "version": 20190831,
216 |   "pattern": "https://www.example.org/article/*",
217 |   "actions": [
218 |     {"hide": [
219 |       "div.status-bar",
220 |       "div.comment",
221 |       "X||//span[text()='更多请关注']"
222 |     ]},
223 |     {"pick": "article"}
224 |   ]
225 | }
226 | ```
227 | 
228 | * hide 填入的是多个选择器，即给出的是一个 选择器的元组（数组）。最后一个选择器是 xPath 选择器，`X||` 部分不能省略。
229 | * pick 填入的是一个选择器，此选择器是 CSS 选择器。其完整形式为 `C||article`，我们给出的是省略了 `C||` 后的部分。
230 | 
231 | ### show 动作的使用 {#action-show}
232 | 
233 | show 动作是用于显示「隐藏的块状节点」的，属性的值也是选择器（可填写多个），show 比较特殊，它**只可用于块状节点（即display 的值为 block）**。它会将节点的 display 样式设置成 block 来让这个节点显示出来. 它相对于后文会提到的 chAttr 动作比较简单，如果要操作的节点都为块状节点，则使用 show 会比较方便，否则，请考虑使用 chAttr 动作（具体查看 chAttr 的例4）
234 | 
235 | ### hide 动作的使用 {#action-hide}
236 | 
237 | hide 动作是用来剔除你不想裁剪的节点的，所有选择器找到的节点都会被隐藏掉（MaoXian 不会裁剪隐藏的节点）。
238 | 
239 | ### hideSibling 动作的使用 {#action-hideSibling}
240 | 
241 | hideSibling 动作是用来剔除你不想裁剪的节点的，它比 hide 动作特殊的地方在于， 所有选择器找到的节点必须具有一个特征：找到的节点在父节点的子节点中有且只有一个。找到的节点的兄弟姊妹节点都会被隐藏掉。 （MaoXian 不会裁剪隐藏的节点）。
242 | 
243 | ### hideExcept 动作的使用 {#action-hideExcept}
244 | 
245 | hideExcept 动作是使用「反选」的方式来选择要剔除的节点。它的值是一个 Object。有两个必须指定的属性：`inside` 和 `except`
246 | 
247 | * inside 属性的类型为选择器，用于指定该动作的作用范围。
248 | * except 属性的类型为选择器，可提供多个选择器，用于指定要保留的节点。
249 | 
250 | 假如有一个网页，它有如下结构：
251 | 
252 | ```html
253 | <div class="post">
254 |   <div class="xxxxx">广告内容</div>
255 |   <div class="post-header"><h1>文章标题</h1></div>
256 |   <div class="post-content">文章内容</div>
257 |   <div class="xxxxx">更多推荐</div>
258 | </div>
259 | ```
260 | 且其中的「广告内容」和「更多推荐」的 class 属性的值是随机生成的，其位置随机出现。这个时候可以通过 hideExcept 参数来反选它们，如：
261 | 
262 | ```json
263 | {
264 |   ...
265 |   "actions": [
266 |     {"hideExcept": {"inside": ".post", "except": [".post-header", ".post-content"]}}
267 |   ]
268 | }
269 | ```
270 | 
271 | 该 Plan 会把 ".post" 选中到的节点内部的子节点进行隐藏，除了 ".post-header" 和 ".post-content" 指定的节点。（MaoXian 不会裁剪隐藏的节点）。
272 | 
273 | 
274 | 
275 | ### chAttr 动作的使用 {#action-chAttr}
276 | 
277 | chAttr 动作可以用来改变元素的属性的值。其值为一个 Object。
278 | 
279 | 其中 pick 参数为必填，用于找到要操作的元素。而修改动作相关的其他参数，则比较特殊，支持两种结构。
280 | 
281 | 
282 | 如下：
283 | 
284 | 当只需要对一个属性做修改，则用下面结构（注：所有参数位于同一级）：
285 | 
286 | ```json
287 | {
288 |   ...
289 |   "actions": [
290 |     {
291 |       "chAttr": {"pick": "_", "attr": "_", "type": "_", ...}
292 |     }
293 |   ]
294 | }
295 | ```
296 | 
297 | 当需要对多个属性做修改，则使用下面结构（注：和修改动作相关的参数，被 action 这个参数包住）：
298 | 
299 | ```json
300 | {
301 |   ...
302 |   "actions": [
303 |     {
304 |       "chAttr": {"pick": "_", "action": [ {"attr": "_", "type": "_", ...} ]}
305 |     }
306 |   ]
307 | }
308 | ```
309 | 
310 | 
311 | 
312 | 下面我们用一些常见的例子来说明 chAttr 的用法。
313 | 
314 | ------------------------------
315 | 
316 | **例1.1**： 假设有一个网页，显示的是低质量的图，这些图的 `src` 属性是一个有规律的地址，比如： https://www.example.org/images/awesome-pic-small.jpg  ，而某些操作后，可能就变为 https://www.example.org/images/awesome-pic-big.jpg 。我们希望裁剪的是后者，而非前者，可以用下面这个 Plan 来实现：
317 | 
318 | ```json
319 | {
320 |   ...
321 |   "actions": [{
322 | 
323 |     "chAttr": {
324 |       "pick": "img",
325 |       "attr": "src",
326 |       "type": "replace.last-match",
327 |       "subStr": "small",
328 |       "newStr": "big"
329 |     }
330 |   }]
331 | }
332 | ```
333 | 
334 | 上面 Plan 中的 chAttr 值的各个参数解读如下：
335 | 
336 | * pick 的类型为选择器，用来选中要操作的节点，我们选中了所有 img 标签。
337 | * attr 的值为要操作的属性名字，此例中，我们选择的是 src 属性。
338 | * type 的值为 **replace.last-match** ，表示要将**找到的节点的属性值的某个部分**，进行替换操作，只会替换最后一个匹配。
339 | * subStr 的值为**要替换掉的那部分**，我们填入的是 small。
340 | * newStr 的值是替换项，也就是说我们用 newStr 的值 big，替换 subStr 的值 small。
341 | 
342 | 
343 | 还有一种和这个类似的修改动作，它的 type 为 **replace.all** ，作用是替换所有找到的匹配，较少使用。 **replace.all** 也支持有多个替换项（即：`subStr` 和 `newStr` 都可以是数组）。替换规则为：如果 `newStr` 有和 `subStr` 对应的项，则使用对应的项，否则使用 `newStr` 的第一项。
344 | 
345 | 
346 | 例如： subStr 为 `["xm", "xxm"]`，newStr 为 `["xl", "xxl"]` 两个值一一对应，则会使用对应项。即 xm 会由 xl 替换， xxm 会由 xxl 替换。
347 | 
348 | 
349 | 例如： subStr 为 `["xm", "xxm"]`，newStr 为 `["xxl"]` ，其中 xxm 没有对应的替换值，则会使用第一项。即 xxm 也会由 xxl 替换。
350 | 
351 | 
352 | **专门用于修改 URL 的修改动作**
353 | 
354 | 比如上方的例1.1，也可以用下方的 Plan 来实现：
355 | 
356 | ```json
357 | {
358 |   ...
359 |   "actions": [{
360 | 
361 |     "chAttr": {
362 |       "pick": "img",
363 |       "attr": "src",
364 |       "type": "url.file.set-name-suffix",
365 |       "sep": "-",
366 |       "suffix": "big",
367 |       "whiteList": ["small", "big"]
368 |     }
369 |   }]
370 | }
371 | ```
372 | 
373 | 这个修改动作，会对 src 属性指定的 url 的文件名部分，设置后缀（在扩展名前面）。其中：
374 | 
375 | * sep 必填，表示分隔符，包含分隔符的文件名，会进行替换，不包含时进行添加。
376 | * suffix 必填，要设置的后缀。
377 | * whiteList 选填（但强烈建议填写），为后缀的可选值，该项表示：当文件名有这些后缀时，替换为 suffix 参数提供的值。若不填，则不判断直接替换。
378 | 
379 | 
380 | 
381 | 如果要移除文件名后缀，则使用下方 Plan ：
382 | 
383 | ```json
384 | {
385 |   ...
386 |   "actions": [{
387 | 
388 |     "chAttr": {
389 |       "type": "url.file.rm-name-suffix",
390 |       "attr": "src",
391 |       "pick": "img",
392 |       "sep": "-",
393 |       "whiteList": ["small", "md"]
394 |     }
395 |   }]
396 | }
397 | ```
398 | 
399 | 参数比前一个 Plan 少了 suffix。其中：
400 | 
401 | * sep 必填，表示分隔符，包含分隔符的文件名，才删除后缀，不包含时，不删除后缀。
402 | * whiteList 选填（但强烈建议填写），为后缀的可选值，该项表示：当文件名有这些后缀时，删除这些后缀。若不填，则不判断直接删除后缀。
403 | 
404 | 
405 | **例1.2**：有些网站会在文件的扩展名后面加上后缀来区分不同的文件质量。如：
406 | 
407 | 
408 | ```html
409 | <img src="assets/name.jpg!sm">
410 | ```
411 | 
412 | 
413 | 则可使用下方 Plan 进行设置：
414 | 
415 | ```json
416 | {
417 |   ...
418 |   "actions": [{
419 | 
420 |     "chAttr": {
421 |       "pick": "img",
422 |       "attr": "src",
423 |       "type": "url.file.set-ext-suffix",
424 |       "sep": "!",
425 |       "suffix": "lg"
426 |     }
427 |   }]
428 | }
429 | ```
430 | 
431 | 若要移除，则使用：
432 | 
433 | ```json
434 | {
435 |   ...
436 |   "actions": [{
437 | 
438 |     "chAttr": {
439 |       "pick": "img",
440 |       "attr": "src",
441 |       "type": "url.file.rm-ext-suffix",
442 |       "sep": "!"
443 |     }
444 |   }]
445 | }
446 | ```
447 | 
448 | 注意： MaoXian 助手对于扩展名后缀的操作很粗暴。须确保 url 文件名中含有的分隔符确实为扩展名和后缀的分隔符，不然会出问题。
449 | 
450 | 
451 | **例1.3**：有些网站还会把版本信息放在 url 的查询参数中，如：
452 | 
453 | ```html
454 | <img src="http://a.org/name.jpg?size=sm&from=google">
455 | ```
456 | 
457 | 遇到这种，可使用下方 Plan：
458 | 
459 | ```json
460 | {
461 |   ...
462 |   "actions": [{
463 | 
464 |     "chAttr": {
465 |       "type": "url.search.edit",
466 |       "pick": "img",
467 |       "attr": "src",
468 |       "change": {"size": "lg"},
469 |       "delete": ["from"]
470 |     }
471 |   }]
472 | }
473 | ```
474 | 
475 | 其中：
476 | 
477 | * change 为要设置的参数。
478 | * delete 为要移除的参数名。
479 | 
480 | 上面这个 plan 应用后， src 属性的值为： "http://a.org/name.jpg?size=lg"
481 | 
482 | ------------------------------
483 | 
484 | 
485 | 
486 | **例2**： 假设有一个网页，显示的是低质量的图，它的高质量图片地址，放在了 img 标签的另一个属性上。图片的 html 如下：
487 | 
488 | ```html
489 | <img src="/image/pic-abc.jpg" hq-src="/image/pic-bdf.jpg" />
490 | ```
491 | 我们要裁剪的是 hq-src 指定的那张图片，使用下面这个 Plan 实现：
492 | 
493 | 
494 | ```json
495 | {
496 |   ...
497 |   "actions": [{
498 | 
499 |     "chAttr": {
500 |       "pick": "img",
501 |       "attr": "src",
502 |       "type": "assign.from.self-attr",
503 |       "tAttr": "hq-src"
504 |     }
505 |   }]
506 | }
507 | ```
508 | * pick 的类型为选择器，用来选中要操作的节点，我们选中了所有 img 标签。
509 | * attr 的值为要操作的属性名字，此例中，我们选择的是 src 属性。
510 | * type 为 **assign.from.self-attr** ，它表明我们要用**找到节点的另一个属性的值**，来重写 attr 指定的属性。
511 | * tAttr 的值为目标属性（target attribute）的名字， 此例中，我们用 hq-src 属性重写 src 属性。
512 | 
513 | 
514 | 
515 | ------------------------------
516 | 
517 | 
518 | **例3.1**： 假设有一个网页，显示的是低质量的图，并且这些图片本身是一个链接，可以通过点击图片查看原图， 图片的 html 如下：
519 | 
520 | ```html
521 | <a href="/image/awesome-pic-bdf.jpg" >
522 |   <img src="/image/pic-abc.jpg" />
523 | </a>
524 | ```
525 | 我们要裁剪的是 a 标签 href 指定的那张图片，使用下面这个 Plan 实现：
526 | 
527 | ```json
528 | {
529 |   ...
530 |   "actions": [{
531 | 
532 |     "chAttr": {
533 |       "pick": "img",
534 |       "attr": "src",
535 |       "type": "assign.from.parent-attr",
536 |       "tAttr": "href"
537 |     }
538 |   }]
539 | }
540 | ```
541 | 
542 | * pick 的类型为选择器，用来选中要操作的节点，我们选中了所有 img 标签。
543 | * attr 的值为要操作的属性名字，此例中，我们选择的是图片的 src 属性。
544 | * type 为 **assign.from.parent-attr** ，它表明我们要用找到节点的 **父节点** 的一个属性的值，来重写 attr 指定的属性。
545 | * tAttr 的值为目标属性（target attribute）的名字， 此例中，我们用父节点的 href 属性重写图片的 src 属性。
546 | 
547 | 
548 | 
549 | 
550 | **例3.2**: 假如和 例3.1 类似，但是原图的链接不在父节点，而是在祖先节点，HTML 如下：
551 | 
552 | ```html
553 | <a href="/image/awesome-pic-bdf.jpg" >
554 |   <div class="wrapper">
555 |     <img src="/image/pic-abc.jpg" />
556 |   <div>
557 | </a>
558 | ```
559 | 
560 | 我们要裁剪的是 a 标签 href 指定的那张图片，使用下面这个 Plan 实现：
561 | 
562 | ```json
563 | {
564 |   ...
565 |   "actions": [{
566 | 
567 |     "chAttr": {
568 |       "pick": "img",
569 |       "attr": "src",
570 |       "type": "assign.from.ancestor-attr",
571 |       "tElem": ["a"],
572 |       "tAttr": "href"
573 |     }
574 |   }]
575 | }
576 | ```
577 | 
578 | * pick 的类型为选择器，用来选中要操作的节点，我们选中了所有 img 标签。
579 | * attr 的值为要操作的属性名字，此例中，我们选择的是图片的 src 属性。
580 | * type 为 **assign.from.ancestor-attr** ，它表明我们要用找到节点的 **祖先节点** 的一个属性的值，来重写 attr 指定的属性。
581 | * tElem 的值为目标元素（target element）的选择器，此例子中，我们选中了 a 标签。
582 | * tAttr 的值为目标属性（target attribute）的名字， 此例中，我们用祖先节点的 href 属性重写图片的 src 属性。
583 | 
584 | 
585 | **注意**  tElem 的值比较特殊，如下：
586 | 
587 | * 必须是一个选择器元祖（数组），而且选择器的个数为 1 ~ 2 个。
588 | * 选择器只能是 CSS 选择器。
589 | * 第一个选择器用于匹配祖先节点
590 | * 第二个选择器用于选择祖先节点的内部节点，只有当第一个选择器无法确定目标节点时，才需要提供。（极少使用到）
591 | 
592 | 
593 | 还有一种 和 **assign.from.ancestor-attr** 相似的类型为： **assign.from.ancestor.child-attr** ， 此种类型也需要提供 tElem ，且需要提供两个选择器。拿到的目标节点为祖先节点的后代节点。
594 | 
595 | 
596 | 
597 | ------------------------------
598 | 
599 | 
600 | **例4**： 除了上面这几种动作, chAttr 还对 class 属性的修改做了支持。请看下方 Plan:
601 | 
602 | ```json
603 | {
604 |   ...
605 |   "actions": [{
606 | 
607 |     "chAttr": {
608 |       "pick": ".section",
609 |       "attr": "class",
610 |       "type": "split2list.remove",
611 |       "value": "folded",
612 |       "sep": " "
613 |     }
614 |   }]
615 | }
616 | ```
617 | 
618 | * pick 的类型为选择器，用来选中要操作的节点，我们选中了所有包含类名为 section 的标签。
619 | * attr 的值为要操作的属性名字，此例中，我们选择的是 class 属性。
620 | * type 为 **split2list.remove** ，它表明我们要用操作的属性具有的值比较特殊，可以通过某个分隔符分成多个部分，该类型表明要移除其中一部分。
621 | * value 为要移除的那部分，可移除多个值（如：`"value": ["a", "b", "c"]`）
622 | * sep 为分隔符
623 | 
624 | 还有一种修改动作, 跟该例子类似，它的类型为 **split2list.add**，该类型表明要往属性里面添加一项。
625 | 
626 | 一般可以使用这两种动作，对网页折叠部分进行控制，使其达到我们想要的状态。这种方式不像上文的 show 参数那样粗暴地对 display 进行操控。
627 | 
628 | 
629 | ------------------------------
630 | 
631 | 
632 | **例5**： 这种可能不常见，即直接修改属性的值
633 | 
634 | 
635 | ```json
636 | {
637 |   ...
638 |   "actions": [{
639 | 
640 |     "chAttr": {
641 |       "pick": ".formula",
642 |       "attr": "type",
643 |       "type": "assign.from.value",
644 |       "value": "image/svg",
645 |     }
646 |   }]
647 | }
648 | ```
649 | 
650 | 上面的例子会把 “type” 属性的值设置为 “image/svg”。
651 | 
652 | ### formula 动作的使用 {#action-formula}
653 | 
654 | 该动作用于创建一个叫做 `<mx-inline-formula>` 或 `<mx-block-formula>` 的标签来标记公式，并把原标签标记为忽略。
655 | 
656 | 例如：
657 | 
658 | 某个网页渲染数学公式的时候，为了兼容所有浏览器，使用了图片的形式，同时又保存其 Latex 公式，如下：
659 | 
660 | ```html
661 | <img src="formula.png" data-formula="x^2+y^2">
662 | ```
663 | 
664 | 我们在裁剪成 Markdown 格式时，完全没有必要保存这个图片，只需要保存这个 `data-formula` 属性的公式即可。
665 | 
666 | 使用下方 Plan：
667 | 
668 | ```json
669 | {
670 |   ...
671 |   "actions": [
672 |     {
673 |       "formula": {"pick": "img", "attr": "data-formula"},
674 |       "tag": "md-only"
675 |     }
676 |   ]
677 | }
678 | ```
679 | 
680 | * pick 的值为选择器，此例选中了所有 `<img>` 元素
681 | * attr 包含数学公式的属性名。
682 | 
683 | 若该 `<img>` 标签是『块状公式』（独占一行）， 应用该 Plan 后的 HTML 如下：
684 | 
685 | ```HTML
686 | <mx-block-formula value="x^2+y^2"></mx-block-formula>
687 | <img src="formula.png" data-formula="x^2+y^2" data-mx-ignore="1">
688 | ```
689 | 
690 | 若该 `<img>` 标签是『行内公式』（和其他文字在同一行）， 应用该 Plan 后的 HTML 如下：
691 | 
692 | ```HTML
693 | <mx-inline-formula value="x^2+y^2"></mx-inline-formula>
694 | <img src="formula.png" data-formula="x^2+y^2" data-mx-ignore="1">
695 | ```
696 | 
697 | 可以看到原来的 `<img>` 标签被标记了 `data-mx-ignore` 属性，标记后 MaoXian 会忽略该标签。
698 | 
699 | 在没有 `block` 参数的时候，formula 动作会自动根据选中元素的样式，决定是『块状公式』还是『行内公式』。
700 | 你也可以通过 `block` 参数直接指定。
701 | 
702 | 比如下方 plan 直接指定了『块状公式』
703 | 
704 | ```json
705 | {
706 |   ...
707 |   "actions": [
708 |     {
709 |       "formula": {"pick": "img", "attr": "data-formula", block: true},
710 |       "tag": "md-only"
711 |     }
712 |   ]
713 | }
714 | ```
715 | 
716 | 
717 | 
718 | ### pick 或 select 动作的使用 {#action-pick}
719 | 
720 | 该动作选中要裁剪的节点。找到第一个匹配的节点就停止查找，如果你填写了多个选择器，则会按照选择器的顺序依次查找，也是找到第一个即停止。
721 | 
722 | **注：该动作在『全局 Plan 』中无效**
723 | 
724 | ### confirm 动作的使用 {#action-confirm}
725 | 
726 | 该动作选中要裁剪的节点，并进行确认，执行完，会到填写表单那一步。找到第一个匹配的节点就停止查找，如果你填写了多个选择器，则会按照选择器的顺序依次查找，也是找到第一个即停止。
727 | 
728 | **注：该动作在『全局 Plan 』中无效**
729 | 
730 | ### clip 动作的使用 {#action-clip}
731 | 
732 | 该动作选中要裁剪的节点，并立即自动进行裁剪。找到第一个匹配的节点就停止查找，如果你填写了多个选择器，则会按照选择器的顺序依次查找，也是找到第一个即停止。
733 | 
734 | **注：该动作在『全局 Plan 』中无效**
735 | 
736 | 
737 | ### form 动作的使用 {#action-form}
738 | 
739 | 用于预设置表单的输入值，MaoXian 会在显示表单的时候，自动帮你输入这些预设的值，都为选填。
740 | 
741 | **注：该动作在『全局 Plan 』中无效**
742 | 
743 | 详情如下：
744 | 
745 | | 名字     | 类型     | 说明     | 默认值   |
746 | | -------- | -------- | -------- | -------- |
747 | | title    | 选择器   | 用于选中包含标题的元素 | 无 |
748 | | category | 字符串   | 对应表单的目录（多级目录用 `/` 隔开） | 取决于你的设置（见扩展设置页面） |
749 | | tagstr   | 字符串   | 对应表单的标签（多个标签用 `,` 或 `空格` 隔开)  | 无  |
750 | 
751 | **主要应用场景：**
752 | 
753 | * 通过设置 title 来解决网页标题和内容标题不一致的问题（MaoXian 默认会使用网页的标题作为表单的标题输入值）。
754 | * 通过设置 category 来为不同的网站的网页设置不同的默认分类。
755 | * 通过设置 tagstr 来为不同的网站的网页，打上不同的默认标签。
756 | 
757 | 例子：
758 | 
759 | 请注意 `title` 的值是一个选择器，此例选中 `main h1` 对应的标题来作为『保存表单』的标题。
760 | 
761 | ```json
762 | {
763 |   ...
764 |   "actions": [{
765 | 
766 |     "form": {
767 |       "title": "main h1",
768 |       "category": "news/read-later",
769 |       "tagstr": "international,freedom-news"
770 |     }
771 |   }]
772 | }
773 | ```
774 | 
775 | ### config 动作的使用 {#action-config}
776 | 
777 | 重写某些配置项，并且重写的这个动作只在这个 Plan 的作用范围内有效。
778 | 
779 | **注：该动作在『全局 Plan 』中无效**
780 | 
781 | 当前允许重写的配置项如下，所有可配置项均为选填。注： 其中的默认值指的是 MaoXian 扩展提供的默认值，该值只作为参考，实际上使用的是你自己配置页面上的值。
782 | 
783 | #### 存储相关 {#config-storage}
784 | 
785 | 可在扩展的 `扩展 > 设置页面 > 存储设置` 一节找到可使用的变量及其说明。
786 | 
787 | 
788 | | 名字               | 说明                     | 类型     | 默认值                     |
789 | | --------           | --------                 | -------- | --------                   |
790 | | clippingHandler    | 处理程序                 | String   | Browser                    |
791 | | saveFormat         | 保存格式                 | String   | html                       |
792 | | rootFolder         | 根目录                   | String   | mx-wc                      |
793 | | defaultCategory    | 默认分类                 | String   | default                    |
794 | | clippingFolderName | 裁剪目录                 | String   | $YYYY-$MM-$DD-$TIME-INTSEC |
795 | | mainFileFolder     | 主文件的存储目录         | String   | $CLIPPING-PATH             |
796 | | mainFileName       | 主文件的文件名           | String   | index.$FORMAT              |
797 | | saveInfoFile       | 是否保存元信息文件       | Boolean  | true                       |
798 | | infoFileFolder     | 元信息文件的存储目录     | String   | $CLIPPING-PATH             |
799 | | infoFileName       | 元信息文件的文件名       | String   | index.json                 |
800 | | saveTitleFile      | 是否保存标题文件         | Boolean  | true                       |
801 | | titleFileFolder    | 标题文件的存储目录       | String   | $CLIPPINT-PATH             |
802 | | titleFileName      | 标题文件的文件名         | String   | a-title_$TITLE             |
803 | | frameFileFolder    | 内嵌的网页文件的存储目录 | String   | $CLIPPING-PATH/frames      |
804 | | frameFileName      | 内嵌的网页文件的文件名   | String   | $TIME-INTSEC-$MD5URL.frame.html |
805 | | assetFolder        | 资源文件的存储目录       | String   | $CLIPPING-PATH/assets      |
806 | | assetFileName      | 资源文件的文件名         | String   | $TIME-INTSEC-$MD5URL$EXT   |
807 | 
808 | 
809 | **备注**：
810 | 
811 | * clippingHandler （处理程序）的可选值为 `Browser`（浏览器下载功能） 和 `NativeApp` （本地程序）
812 | * saveFormat （保存格式）的可选值为 `html` 或 `md`
813 | * saveInfoFile（是否保存元信息文件） 设置为 `false` 后，MaoXian 便不会保存裁剪历史。
814 | 
815 | 
816 | 
817 | #### Markdown 文档相关 {#config-markdown}
818 | 
819 | 请参考 `扩展 > 设置 > Markdown` 的说明文字进行配置。
820 | 
821 | 
822 | | 名字                           | 说明               | 类型     | 默认值            | 可选值                    |
823 | | --------                       | --------           | -------- | --------          | --------                  |
824 | | markdownTemplate               | Markdown 模板      | String   | `\n{{content}}\n` |                           |
825 | | markdownOptionHeadingStyle     | 标题格式           | String   | `atx`             | `setext` 或 `atx`         |
826 | | markdownOptionHr               | 水平分割线         | String   | `* * *`           | `* * *` 或 `- - -` 等等   |
827 | | markdownOptionBulletListMarker | 子弹列表的行头符   | String   | `*`               | `*`，`+` 或 `-`           |
828 | | markdownOptionCodeBlockStyle   | 代码块格式         | String   | `fenced`          | `indented` 或 `fenced`    |
829 | | markdownOptionFence            | 代码块分隔符       | String   | <code>```</code>  | <code>```</code> 或 `~~~` |
830 | | markdownOptionEmDelimiter      | 强调（斜体）分隔符 | String   | `_`               | `_` 或 `*`                |
831 | | markdownOptionStrongDelimiter  | 加重（粗体）分隔符 | String   | `**`              | `**` 或 `__`              |
832 | | markdownOptionLinkStyle        | 链接格式           | String   | `inlined`         | `inlined` 或 `referenced` |
833 | | markdownOptionFormulaBlockWrapper | 块状公式的格式  | String   | `padSameLine`     | `sameLine`, `padSameLIne`, `multipleLine` 或 `mathCodeBlock` |
834 | 
835 | 
836 | **备注**：
837 | 
838 | * markdownOptionHr （水平分割线）可填写的值很灵活，具体查看这里 [Thematic break](https://spec.commonmark.org/0.27/#thematic-breaks)
839 | 
840 | 
841 | 
842 | #### HTML 文档相关 {#config-html}
843 | 
844 | 请参考 `扩展 > 设置 > HTML` 的说明文字进行配置。
845 | 
846 | 
847 | 
848 | | 名字 | 说明 | 类型 | 默认值 | 可选值 |
849 | | -------- | -------- | -------- | -------- | -------- |
850 | | htmlSaveClippingInformation | 追加裁剪信息到内容尾部 | Boolean | `false` | `false`、 `true` |
851 | | htmlCustomBodyBgCssEnabled | 允许自定义 body 标签的 CSS 背景颜色 | Boolean | `false` | `false`、 `true` |
852 | | htmlCustomBodyBgCssValue | body 标签的 CSS 背景颜色 | String | `#000000` | 查看 background-color (CSS) |
853 | | htmlCompressCss | 压缩样式（CSS） |  Boolean | `false` | `false`、`true` |
854 | | htmlCaptureImage | 图片 | String | `saveAll` | `saveAll`、`saveCurrent` |
855 | | htmlCaptureAudio | 声音 | String | `remove` | `saveAll` 、`saveCurrent`、 `remove` |
856 | | htmlCaptureVideo | 影片 | String | `remove` |  `saveAll`、 `saveCurrent`、 `remove` |
857 | | htmlCaptureApplet | Applets | String | `remove` | `saveAll`、 `remove` |
858 | | htmlCaptureEmbed | Embeds | String | `saveImage` | `saveAll`、 `saveImage`、 `remove`、 `filter` |
859 | | htmlCaptureObject | Objects | String | `saveImage` | `saveAll`、 `saveImage`、 `remove`、 `filter` |
860 | | htmlCaptureIcon | 网站图标 | String | `remove` | `saveAll`、 `saveFavicon`、 `remove` |
861 | | htmlCaptureCssRules | 样式规则 | String | `saveUserd` | `saveAll`、 `saveUserd` |
862 | | htmlCaptureWebFont | Web 字体 | String | `remove` | `saveAll`、 `remove`、 `filterList` |
863 | | htmlCaptureCssImage | 样式图片 | String | `remove` | `saveAll`、 `remove` |
864 | | htmlEmbedFilter | Embeds 过滤器 | String | `<images>` | - |
865 | | htmlObjectFilter | Objects 过滤器 | String | `<images>` | - |
866 | | htmlWebFontFilterList | Web 字体过滤器组 | String | `woff2|woff|otf|ttf` | - |
867 | 
868 | 
869 | #### Web 请求相关 {#config-web-request}
870 | 
871 | 请参考 `扩展 > 设置 > 高级设置` 的说明文字进行配置。
872 | 
873 | 
874 | | 名字 | 说明 | 类型 | 默认值 | 可选值 |
875 | | -------- | -------- | -------- | -------- | -------- |
876 | | requestTimeout | 超时（秒） | Integer | 300 | 5 ~ 86400 |
877 | | requestMaxTries | 最大尝试次数 | Integer | 3 | 大于1的整数 |
878 | | requestReferrerPolicy | Referrer 请求头 | String | `originWhenCrossOrigin` | `noReferrer`、 `origin`、 `originWhenCrossOrigin`、 `unsafeUrl` |
879 | 
880 | 
881 | 
882 | ## tags 参数的使用 {#arg-tags}
883 | 
884 | 虽然 Plan 的 tags 属性是非必须的，但还是建议你为 Plan 打上标签，以便后期，我们能更好地管理他们。
885 | 


--------------------------------------------------------------------------------
/lib/json-object.rb:
--------------------------------------------------------------------------------
  1 | module JsonObject
  2 | 
  3 |   def self.included(klass)
  4 |     klass.extend ClassMethods
  5 |     klass.include ConditionFns
  6 |   end
  7 | 
  8 |   module ClassMethods
  9 |     DEFAULT_OPTIONS = {to_hash: true, collection: false}
 10 | 
 11 |     def required_attr(name, options = {})
 12 |       validate_defined_attr(name, options)
 13 |       @attr_defines ||= {}
 14 |       @attr_defines[name.to_s] = DEFAULT_OPTIONS.merge(options).merge({required: true})
 15 |       self.attr_reader name
 16 |     end
 17 | 
 18 |     def optional_attr(name, options = {})
 19 |       validate_defined_attr(name, options)
 20 |       @attr_defines ||= {}
 21 |       @attr_defines[name.to_s] = DEFAULT_OPTIONS.merge(options).merge({required: false})
 22 |       self.attr_reader name
 23 |     end
 24 | 
 25 |     def validate_defined_attr(name, options = {})
 26 |       if options[:collection] && !options.has_key?(:klass)
 27 |         raise "attribute: '#{name}' contains 'collection' option that requires 'klass' option"
 28 |       end
 29 |       if options[:optional_collection] && !options.has_key?(:klass)
 30 |         raise "attribute: '#{name}' contains 'optional_collection' option that requires 'klass' option"
 31 |       end
 32 |     end
 33 |   end
 34 | 
 35 |   module ConditionFns
 36 |     def value_in(name, *values)
 37 |       values.any? { |value| value == self.send(name.to_sym) }
 38 |     end
 39 |   end
 40 | 
 41 | 
 42 |   class Collection
 43 |     include Enumerable
 44 |     attr_reader :klass, :members
 45 | 
 46 |     def initialize(klass, members)
 47 |       @members = (members || []).map {|it| klass.new(it) }
 48 |     end
 49 | 
 50 |     def each(&blk)
 51 |       members.each(&blk)
 52 |     end
 53 | 
 54 |     def valid?
 55 |       @errors = []
 56 |       each do |it|
 57 |         unless it.valid?
 58 |           @errors << it.errors
 59 |         end
 60 |       end
 61 |       @errors.size == 0
 62 |     end
 63 | 
 64 |     def errors
 65 |       @errors
 66 |     end
 67 | 
 68 |     def to_hash
 69 |       members.map(&:to_hash)
 70 |     end
 71 |   end
 72 | 
 73 |   def initialize(params)
 74 |     attr_defines.each_pair do |attr, attr_define|
 75 | 
 76 |       if params.has_key?(attr)
 77 |         value = params[attr]
 78 | 
 79 |         if attr_define[:collection]
 80 |           instance_variable_set vname(attr), Collection.new(attr_define[:klass], value)
 81 |         elsif attr_define[:optional_collection]
 82 |           if value.is_a? Array
 83 |             instance_variable_set vname(attr), Collection.new(attr_define[:klass], value)
 84 |           else
 85 |             instance_variable_set vname(attr), attr_define[:klass].new(value)
 86 |           end
 87 |         elsif attr_define[:klass]
 88 |           instance_variable_set vname(attr), attr_define[:klass].new(value)
 89 |         elsif attr_define[:module]
 90 |           instance_variable_set vname(attr), attr_define[:module].new_instance(value)
 91 |         else
 92 |           instance_variable_set vname(attr), value
 93 |         end
 94 |       elsif attr_define[:default]
 95 |         instance_variable_set vname(attr), attr_define[:default]
 96 |       end
 97 |     end
 98 |     check_missing_defines(params)
 99 |   end
100 | 
101 |   def check_missing_defines(params)
102 |     params.each_pair do |attr, value|
103 |       unless attr_defines.has_key?(attr)
104 |         puts "[WARN] expect #{self.class.name} to define attribute #{attr}"
105 |       end
106 |     end
107 |   end
108 | 
109 |   def valid?
110 |     @errors = []
111 |     attr_defines.each_pair do |attr, attr_define|
112 |       is_valid, error = validate_attr_define(attr, attr_define)
113 |       @errors << error unless is_valid
114 |     end
115 |     return @errors.size == 0
116 |   end
117 | 
118 |   def errors
119 |     @errors
120 |   end
121 | 
122 |   def validate_attr_define(attr, attr_define)
123 |     validate_proc = Proc.new { |attr_define|
124 |       attr_value = instance_variable_get(vname(attr))
125 |       if attr_define[:required] && attr_value.nil?
126 |         return [false, "Required attribute: \"#{attr}\" is not provided"]
127 |       end
128 | 
129 |       if attr_define[:in] && !attr_define[:in].include?(attr_value)
130 |         return [false, "The value of #{attr} must be a member of\n [#{attr_define[:in].map(&:to_s).join(', ')}], \nbut it's value is #{attr_value}"]
131 |       end
132 | 
133 |       if (attr_define[:klass] || attr_define[:module]) && attr_value && !attr_value.valid?
134 |         intent = " " * 4
135 |         error = "#{attr}:\n" + attr_value.errors.map do |it|
136 |           "#{intent}#{it}"
137 |         end.join("\n")
138 |         return [false, error]
139 |       end
140 | 
141 |       return [true]
142 |     }
143 | 
144 |     condition = attr_define[:required_if]
145 |     if condition.is_a?(Proc)
146 |       if self.instance_exec(&condition)
147 |         return validate_proc.call(attr_define.merge({required: true}))
148 |       else
149 |         return [true]
150 |       end
151 |     else
152 |       return validate_proc.call(attr_define)
153 |     end
154 |   end
155 | 
156 |   def to_hash
157 |     hash = {}
158 |     attr_defines.each_pair do |attr, attr_define|
159 |       attr_value = instance_variable_get(vname(attr))
160 |       if attr_define[:to_hash] && attr_value && (attr_define[:default].nil? || attr_define[:default] != attr_value)
161 |         if attr_define[:collection] || attr_define[:klass] || attr_define[:module]
162 |           hash[attr] = attr_value.to_hash
163 |         else
164 |           hash[attr] = attr_value
165 |         end
166 |       end
167 |     end
168 |     hash
169 |   end
170 | 
171 |   def attr_defines
172 |     @_attr_defines ||= self.class.instance_variable_get("@attr_defines")
173 |   end
174 | 
175 |   # get instance variable name
176 |   def vname(k)
177 |     return "@#{k}"
178 |   end
179 | 
180 | end
181 | 


--------------------------------------------------------------------------------
/lib/mx-plan.rb:
--------------------------------------------------------------------------------
 1 | require_relative 'json-object'
 2 | require_relative 'mx-plan/mx-action'
 3 | 
 4 | class MxPlan
 5 |   include JsonObject
 6 | 
 7 |   required_attr :name
 8 |   required_attr :pattern
 9 |   optional_attr :excludePattern
10 |   required_attr :version
11 |   optional_attr :disabled
12 |   optional_attr :actions, collection: true, klass: ::MxAction
13 |   optional_attr :tags
14 |   optional_attr :contributors
15 |   optional_attr :comment, to_hash: false
16 | end
17 | 


--------------------------------------------------------------------------------
/lib/mx-plan/action/ch-attr-defines.rb:
--------------------------------------------------------------------------------
 1 | require_relative '../../json-object'
 2 | 
 3 | module ChAttrActionTypes
 4 |   T01 = "assign.from.value"
 5 |   T02 = "assign.from.self-attr"
 6 | 
 7 |   T11 = "assign.from.parent-attr"
 8 |   T12 = "assign.from.ancestor-attr"
 9 |   T13 = "assign.from.ancestor.child-attr"
10 | 
11 |   T21 = "assign.from.first-child-attr"
12 |   T22 = "assign.from.child-attr"
13 |   T23 = "assign.from.descendent-attr"
14 | 
15 |   T51 = "url.file.set-ext-suffix"
16 |   T52 = "url.file.rm-ext-suffix"
17 |   T53 = "url.file.set-name-suffix"
18 |   T54 = "url.file.rm-name-suffix"
19 |   T55 = "url.search.edit"
20 | 
21 | 
22 |   T71 = "replace.last-match"
23 |   T72 = "replace.all"
24 | 
25 |   T91 = "split2list.add"
26 |   T92 = "split2list.remove"
27 | 
28 | 
29 |   TYPES = [
30 |     T01, T02,
31 |     T11, T12, T13,
32 |     T21, T22, T23,
33 |     T51, T52, T53, T54, T55,
34 | 
35 |     T71, T72,
36 |     T91, T92,
37 |   ];
38 | end
39 | 
40 | 
41 | class OldChAttr
42 |   include JsonObject
43 |   include ChAttrActionTypes
44 | 
45 |   required_attr :type, in: TYPES
46 |   required_attr :pick
47 |   required_attr :attr
48 |   optional_attr :subStr, required_if: -> {value_in(:type, T71, T72)}
49 |   optional_attr :newStr, required_if: -> {value_in(:type, T71, T72)}
50 |   optional_attr :tElem,  required_if: -> {value_in(:type, T12, T13, T22, T23)}
51 |   optional_attr :tAttr,  required_if: -> {value_in(:type, T02, T11, T12, T13, T21, T22, T23)}
52 |   optional_attr :value,  required_if: -> {value_in(:type, T01, T91, T92)}
53 |   optional_attr :sep,    required_if: -> {value_in(:type, T51, T52, T53, T54)}
54 |   optional_attr :suffix, required_if: -> {value_in(:type, T51, T53)}
55 |   optional_attr :whiteList #T52, T54
56 |   optional_attr :change   #T55
57 |   optional_attr :delete   #T55
58 | 
59 | end
60 | 
61 | # without attribute "pick"
62 | class NewChAttrAction
63 |   include JsonObject
64 |   include ChAttrActionTypes
65 | 
66 |   required_attr :type, in: TYPES
67 |   required_attr :attr
68 |   optional_attr :subStr, required_if: -> {value_in(:type, T71, T72)}
69 |   optional_attr :newStr, required_if: -> {value_in(:type, T71, T72)}
70 |   optional_attr :tElem,  required_if: -> {value_in(:type, T12, T13, T22, T23)}
71 |   optional_attr :tAttr,  required_if: -> {value_in(:type, T02, T11, T12, T13, T21, T22, T23)}
72 |   optional_attr :value,  required_if: -> {value_in(:type, T01, T91, T92)}
73 |   optional_attr :sep,    required_if: -> {value_in(:type, T51, T52, T53, T54)}
74 |   optional_attr :suffix, required_if: -> {value_in(:type, T51, T53)}
75 |   optional_attr :whiteList #T52, T54
76 |   optional_attr :change   #T55
77 |   optional_attr :delete   #T55
78 | end
79 | 
80 | class NewChAttr
81 |   include JsonObject
82 |   required_attr :pick
83 |   required_attr :action, optional_collection: true, klass: NewChAttrAction
84 | end
85 | 
86 | 


--------------------------------------------------------------------------------
/lib/mx-plan/action/change-attribute.rb:
--------------------------------------------------------------------------------
 1 | require_relative 'ch-attr-defines'
 2 | 
 3 | module Action
 4 |   module ChangeAttribute
 5 |     def self.new_instance(params)
 6 |       if params.has_key? "action"
 7 |         # new structure
 8 |         NewChAttr.new(params)
 9 |       else
10 |         OldChAttr.new(params)
11 |       end
12 |     end
13 |   end
14 | end
15 | 


--------------------------------------------------------------------------------
/lib/mx-plan/action/execute-user-script.rb:
--------------------------------------------------------------------------------
 1 | require_relative '../../json-object'
 2 | 
 3 | module Action
 4 |   class ExecuteUserScript
 5 |     include JsonObject
 6 | 
 7 |     required_attr :script
 8 |     optional_attr :args
 9 |     optional_attr :when, in: %w[actived selecting idle]
10 |     optional_attr :once, in: [true, false]
11 |   end
12 | end
13 | 


--------------------------------------------------------------------------------
/lib/mx-plan/action/formula.rb:
--------------------------------------------------------------------------------
 1 | require_relative '../../json-object'
 2 | 
 3 | module Action
 4 |   class Formula
 5 |     include JsonObject
 6 |     required_attr :pick
 7 |     required_attr :attr
 8 |     optional_attr :block
 9 |   end
10 | end
11 | 


--------------------------------------------------------------------------------
/lib/mx-plan/action/hide-except.rb:
--------------------------------------------------------------------------------
 1 | require_relative '../../json-object'
 2 | 
 3 | module Action
 4 |   class HideExcept
 5 |     include JsonObject
 6 | 
 7 | =begin
 8 |     Example:
 9 |     {
10 |       ...
11 |       actions: [
12 |         {
13 |           hideExcept: {
14 |             "inside": ".post",
15 |             "except": [".post-title", ".post-content"]
16 |           }
17 |         }
18 |       ]
19 |     }
20 | =end
21 | 
22 |     required_attr :inside
23 |     required_attr :except
24 |   end
25 | end
26 | 


--------------------------------------------------------------------------------
/lib/mx-plan/mx-action.rb:
--------------------------------------------------------------------------------
 1 | require_relative '../json-object'
 2 | require_relative 'action/hide-except'
 3 | require_relative 'action/execute-user-script'
 4 | require_relative 'action/formula'
 5 | require_relative 'action/change-attribute'
 6 | 
 7 | class MxAction
 8 |   include JsonObject
 9 |   optional_attr :hide
10 |   optional_attr :hideSibling
11 |   optional_attr :hideExcept, klass: Action::HideExcept
12 |   optional_attr :show
13 |   optional_attr :chAttr, module: ::Action::ChangeAttribute
14 |   optional_attr :exec,    klass: ::Action::ExecuteUserScript
15 |   optional_attr :formula, klass: ::Action::Formula
16 |   optional_attr :pick
17 |   optional_attr :select
18 |   optional_attr :confirm
19 |   optional_attr :clip
20 |   optional_attr :form
21 |   optional_attr :config
22 |   optional_attr :tag
23 | end
24 | 


--------------------------------------------------------------------------------
/migration.rb:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env ruby
 2 | 
 3 | require 'fileutils'
 4 | require_relative 'migrations/convert_to_actions.rb'
 5 | 
 6 | # convert plan structure to:
 7 | # {actions: [...]}
 8 | 
 9 | def migrate
10 |   Dir.glob('plans/*/*.json') do |file|
11 |     MigrationConvertToActions.migrate(file, file)
12 |   end
13 | end
14 | 
15 | def main
16 |   if !Dir.exist? 'tmp'
17 |     FileUtils.mkdir 'tmp'
18 |   end
19 | 
20 |   if Dir.exist? 'tmp/plans'
21 |     FileUtils.rm_r 'tmp/plans'
22 |   end
23 | 
24 |   FileUtils.cp_r 'plans', 'tmp/'
25 | 
26 |   begin
27 |     migrate
28 |   rescue => e
29 |     puts "Error occured"
30 |     puts "The original plans are backuped inside tmp/plans"
31 |     puts "Restore it from there"
32 |     puts e
33 |     exit 1
34 |   end
35 | 
36 |   puts "All plan converted"
37 |   puts "If anything goes wrong, plase restore from tmp/plans"
38 | end
39 | 
40 | main
41 | 


--------------------------------------------------------------------------------
/migrations/convert_to_actions.rb:
--------------------------------------------------------------------------------
 1 | require 'json'
 2 | 
 3 | module MigrationConvertToActions
 4 |   class << self
 5 | 
 6 |     def migrate(plan_path, output_path)
 7 |       content = File.open(plan_path, 'r').read
 8 |       plans = JSON.parse(content)
 9 |       new_plans = plans.map {|it| migrate_plan(it)}
10 | 
11 |       File.open(output_path, 'w') do |file|
12 |         file.write JSON.pretty_generate(new_plans)
13 |       end
14 |     end
15 | 
16 |     def migrate_plan(plan)
17 |       if plan.has_key? "actions"
18 |         # already the new version
19 |         return plan
20 |       end
21 | 
22 |       new_plan = plan.slice(
23 |         "name",
24 |         "pattern",
25 |         "excludePattern",
26 |         "version",
27 |         "contributors",
28 |         "disabled",
29 |       )
30 | 
31 |       attrs = %W[hide hideSibling hideExcept show chAttr config form pick]
32 | 
33 |       actions = []
34 | 
35 |       attrs.each do |attr|
36 |         next if !plan.has_key?(attr)
37 | 
38 |         value = plan[attr]
39 | 
40 |         case attr
41 |         when 'chAttr'
42 |           value.each do |it|
43 |             action = {"chAttr" => it}
44 |             actions << action
45 |           end
46 |           break
47 |         when 'hideExcept'
48 |           value.each do |it|
49 |             action = {"hideExcept" => it}
50 |             actions << action
51 |           end
52 |           break
53 |         else
54 |           action = [[attr, value]].to_h
55 |           actions << action
56 |         end
57 |       end
58 | 
59 |       new_plan["actions"] = actions
60 |       if plan.has_key? "tags"
61 |         new_plan["tags"] = plan["tags"]
62 |       end
63 |       if plan.has_key? "comment"
64 |         new_plan["comment"] = plan["comment"]
65 |       end
66 |       new_plan["version"] = (Time.now.strftime "%Y%m%d").to_i
67 |       new_plan
68 |     end
69 | 
70 |     def attrbute2action(name, value)
71 |       return [[name, value]].to_h
72 |     end
73 | 
74 |   end
75 | end
76 | 


--------------------------------------------------------------------------------
/plans/channel_default.json:
--------------------------------------------------------------------------------
1 | {
2 |   "name": "default",
3 |   "folder": "default",
4 |   "description": "Default channel hosts plans that relative to international websites"
5 | }
6 | 


--------------------------------------------------------------------------------
/plans/channel_test.json:
--------------------------------------------------------------------------------
1 | {
2 |   "name": "test",
3 |   "folder": "test",
4 |   "description": "this plan list is just for testing only."
5 | }
6 | 


--------------------------------------------------------------------------------
/plans/channel_zh.json:
--------------------------------------------------------------------------------
1 | {
2 |   "name": "Zhong-Hua",
3 |   "folder": "zh",
4 |   "description": "华文网站"
5 | }
6 | 


--------------------------------------------------------------------------------
/plans/default/arch-wiki.json:
--------------------------------------------------------------------------------
 1 | [
 2 |   {
 3 |     "name": "ArchWiki",
 4 |     "pattern": "https://wiki.archlinux.org/title/*",
 5 |     "version": 20240502,
 6 |     "contributors": [
 7 |       "Mika"
 8 |     ],
 9 |     "actions": [
10 |       {
11 |         "pick": "#bodyContent"
12 |       }
13 |     ],
14 |     "tags": [
15 |       "IT",
16 |       "wiki",
17 |       "doc"
18 |     ]
19 |   }
20 | ]


--------------------------------------------------------------------------------
/plans/default/github.json:
--------------------------------------------------------------------------------
 1 | [
 2 |   {
 3 |     "name": "Github",
 4 |     "pattern": "https://github.com/",
 5 |     "version": 20240502,
 6 |     "contributors": [
 7 |       "yzqzss (author)"
 8 |     ],
 9 |     "actions": [
10 |       {
11 |         "hide": [
12 |           ".avatar",
13 |           ".avatar-parent-child",
14 |           ".inline-comment-form-actions",
15 |           ".flex-items-center.d-sm-flex.d-none",
16 |           ".d-inline-block"
17 |         ]
18 |       },
19 |       {
20 |         "pick": [
21 |           ".js-discussion",
22 |           ".markdown-body"
23 |         ]
24 |       }
25 |     ],
26 |     "tags": [
27 |       "IT",
28 |       "geek",
29 |       "git"
30 |     ]
31 |   }
32 | ]


--------------------------------------------------------------------------------
/plans/default/wikipedia.json:
--------------------------------------------------------------------------------
 1 | [
 2 |   {
 3 |     "name": "wikipedia.org",
 4 |     "pattern": "https://*.wikipedia.org/wiki/*",
 5 |     "excludePattern": "https://*.m.wikipedia.org/*/",
 6 |     "version": 20240502,
 7 |     "actions": [
 8 |       {
 9 |         "hide": [
10 |           "div#toc",
11 |           "table.infobox",
12 |           "span.mw-editsection",
13 |           "table.navbox",
14 |           "div.thumb",
15 |           "div.dablink",
16 |           "table.metadata"
17 |         ]
18 |       },
19 |       {
20 |         "pick": "div.mw-parser-output"
21 |       }
22 |     ],
23 |     "tags": [
24 |       "knowledge",
25 |       "wiki"
26 |     ]
27 |   },
28 |   {
29 |     "name": "Wikipedia Mobile View",
30 |     "pattern": "https://*.m.wikipedia.org/*/",
31 |     "version": 20240502,
32 |     "contributors": [
33 |       "Altair Wei (author)"
34 |     ],
35 |     "actions": [
36 |       {
37 |         "hide": [
38 |           ".page-actions-menu",
39 |           "#toc",
40 |           ".mw-editsection",
41 |           "h2 > div.mw-ui-icon",
42 |           "table.box-Unreferenced",
43 |           "table.box-More_citations_needed"
44 |         ]
45 |       },
46 |       {
47 |         "chAttr": {
48 |           "type": "split2list.add",
49 |           "pick": "h2.section-heading",
50 |           "attr": "style",
51 |           "value": "width: 100%",
52 |           "sep": ";"
53 |         }
54 |       }
55 |     ],
56 |     "tags": [
57 |       "knowledge",
58 |       "wiki"
59 |     ]
60 |   }
61 | ]


--------------------------------------------------------------------------------
/plans/test/dev-pc.json:
--------------------------------------------------------------------------------
  1 | [
  2 |   {
  3 |     "name": "mx.pc/hide-except",
  4 |     "pattern": "http://*.pc/maoxian-web-clipper/**/test-hide-except.html",
  5 |     "version": 20240502,
  6 |     "actions": [
  7 |       {
  8 |         "hideExcept": {
  9 |           "inside": "pre",
 10 |           "except": [
 11 |             "code"
 12 |           ]
 13 |         }
 14 |       }
 15 |     ]
 16 |   },
 17 |   {
 18 |     "name": "mx.pc/hg-img",
 19 |     "pattern": "http://*.pc/maoxian-web-clipper/**/test-hq-img.html",
 20 |     "version": 20240502,
 21 |     "actions": [
 22 |       {
 23 |         "chAttr": {
 24 |           "type": "split2list.add",
 25 |           "pick": "div.t0",
 26 |           "attr": "class",
 27 |           "value": "actived"
 28 |         }
 29 |       },
 30 |       {
 31 |         "chAttr": {
 32 |           "type": "assign.from.self-attr",
 33 |           "pick": "div.t1 img",
 34 |           "attr": "src",
 35 |           "tAttr": "hq-src"
 36 |         }
 37 |       },
 38 |       {
 39 |         "chAttr": {
 40 |           "pick": "div.t2 img",
 41 |           "action": {
 42 |             "type": "replace.last-match",
 43 |             "attr": "src",
 44 |             "subStr": "thumb",
 45 |             "newStr": "hq"
 46 |           }
 47 |         }
 48 |       },
 49 |       {
 50 |         "chAttr": {
 51 |           "pick": "div.t3 img",
 52 |           "action": [{
 53 |             "type": "assign.from.parent-attr",
 54 |             "attr": "src",
 55 |             "tAttr": "href"
 56 |           }]
 57 |         }
 58 |       }
 59 |     ]
 60 |   },
 61 |   {
 62 |     "name": "mx.pc/iframe",
 63 |     "pattern": "http://*.pc/maoxian-web-clipper/**/iframe*",
 64 |     "version": 20240502,
 65 |     "actions": [
 66 |       {
 67 |         "chAttr": {
 68 |           "type": "assign.from.self-attr",
 69 |           "pick": "img",
 70 |           "attr": "src",
 71 |           "tAttr": "hq-src"
 72 |         }
 73 |       }
 74 |     ]
 75 |   },
 76 |   {
 77 |     "name": "mx.pc/mx-index",
 78 |     "pattern": "http://*.pc/maoxian-web-clipper/index*.html",
 79 |     "version": 20240502,
 80 |     "actions": [
 81 |       {
 82 |         "hide": "ul"
 83 |       },
 84 |       {
 85 |         "pick": ".main"
 86 |       }
 87 |     ]
 88 |   },
 89 |   {
 90 |     "name": "mx.pc/blog-post",
 91 |     "pattern": "http://*.pc/blog/**/*/*/*/*/*.html",
 92 |     "version": 20240502,
 93 |     "actions": [
 94 |       {
 95 |         "hide": [
 96 |           "header"
 97 |         ]
 98 |       },
 99 |       {
100 |         "pick": [
101 |           ".page-content"
102 |         ]
103 |       }
104 |     ]
105 |   },
106 |   {
107 |     "name": "mx.pc/test-tab",
108 |     "pattern": "http://*.pc/maoxian-web-clipper/**/test-tab.html",
109 |     "version": 20240502,
110 |     "actions": [
111 |       {
112 |         "chAttr": {
113 |           "type": "split2list.add",
114 |           "attr": "class",
115 |           "pick": ".tab-content",
116 |           "value": "actived"
117 |         }
118 |       }
119 |     ]
120 |   }
121 | ]
122 | 


--------------------------------------------------------------------------------
/plans/zh/36kr.json:
--------------------------------------------------------------------------------
 1 | [
 2 |   {
 3 |     "name": "36kr",
 4 |     "pattern": "https://36kr.com/p/$d",
 5 |     "version": 20240502,
 6 |     "contributors": [
 7 |       "Mika"
 8 |     ],
 9 |     "actions": [
10 |       {
11 |         "pick": ".articleDetailContent"
12 |       }
13 |     ],
14 |     "tags": [
15 |       "IT",
16 |       "news",
17 |       "tech"
18 |     ]
19 |   }
20 | ]


--------------------------------------------------------------------------------
/plans/zh/52pojie.json:
--------------------------------------------------------------------------------
 1 | [
 2 |   {
 3 |     "name": "52pojie",
 4 |     "pattern": "https://www.52pojie.cn/thread-*.html",
 5 |     "version": 20240502,
 6 |     "contributors": [
 7 |       "Mika"
 8 |     ],
 9 |     "actions": [
10 |       {
11 |         "hide": [
12 |           "#toptb",
13 |           "#hd",
14 |           "#pt",
15 |           "#pgt",
16 |           "#postlist > table",
17 |           "table.ad",
18 |           ".psth",
19 |           "#fj",
20 |           "img[alt=回帖奖励]",
21 |           "#threadstamp",
22 |           "dl.rate",
23 |           "ul.mbw",
24 |           ".dnch_eo_pb",
25 |           ".dnch_eo_pt",
26 |           ".po.hin",
27 |           ".favatar",
28 |           ".authicn.vm",
29 |           "#p_btn",
30 |           ".pgbtn",
31 |           "#diyfastposttop",
32 |           "#fastpostform",
33 |           ".res-footer-note",
34 |           "#jz52top",
35 |           "#ft",
36 |           "X||//a[text() = '\n推荐\n']",
37 |           "X||//a[text() = '推荐']"
38 |         ]
39 |       },
40 |       {
41 |         "chAttr": {
42 |           "type": "assign.from.value",
43 |           "pick": "#postlist table.plhin",
44 |           "attr": "data-mx-layout-table",
45 |           "value": "1"
46 |         }
47 |       }
48 |     ],
49 |     "tags": [
50 |       "IT",
51 |       "forum"
52 |     ]
53 |   }
54 | ]


--------------------------------------------------------------------------------
/plans/zh/bilibili.json:
--------------------------------------------------------------------------------
 1 | [
 2 |   {
 3 |     "name": "Bilibili 专栏",
 4 |     "pattern": "https://www.bilibili.com/read/*",
 5 |     "version": 20240502,
 6 |     "contributors": [
 7 |       "yzqzss",
 8 |       "Mika"
 9 |     ],
10 |     "actions": [
11 |       {
12 |         "hide": [
13 |           ".img-box .n-img-mask"
14 |         ]
15 |       },
16 |       {
17 |         "chAttr": {
18 |           "type": "assign.from.self-attr",
19 |           "pick": ".img-box img",
20 |           "attr": "src",
21 |           "tAttr": "data-src"
22 |         }
23 |       }
24 |     ]
25 |   }
26 | ]


--------------------------------------------------------------------------------
/plans/zh/cnblogs.json:
--------------------------------------------------------------------------------
 1 | [
 2 |   {
 3 |     "name": "博客园",
 4 |     "pattern": "https://www.cnblogs.com/**/*/*.html",
 5 |     "version": 20240502,
 6 |     "contributors": [
 7 |       "CodingOX"
 8 |     ],
 9 |     "actions": [
10 |       {
11 |         "hide": [
12 |           "div.cnblogs_code_toolbar",
13 |           "div.cnblogs_code_copy"
14 |         ]
15 |       },
16 |       {
17 |         "pick": "div#cnblogs_post_body"
18 |       }
19 |     ],
20 |     "tags": [
21 |       "IT",
22 |       "blog"
23 |     ]
24 |   }
25 | ]


--------------------------------------------------------------------------------
/plans/zh/coolshell.json:
--------------------------------------------------------------------------------
 1 | [
 2 |   {
 3 |     "name": "酷壳",
 4 |     "pattern": "https://coolshell.cn/articles/*",
 5 |     "version": 20240502,
 6 |     "contributors": [
 7 |       "Mika"
 8 |     ],
 9 |     "actions": [
10 |       {
11 |         "pick": ".post-content"
12 |       }
13 |     ],
14 |     "tags": [
15 |       "IT",
16 |       "blog"
17 |     ]
18 |   }
19 | ]


--------------------------------------------------------------------------------
/plans/zh/csdn.json:
--------------------------------------------------------------------------------
 1 | [
 2 |   {
 3 |     "name": "CSDN-博客",
 4 |     "pattern": "https://blog.csdn.net/*/article/details/*",
 5 |     "version": 20240502,
 6 |     "contributors": [
 7 |       "Mika"
 8 |     ],
 9 |     "actions": [
10 |       {
11 |         "hide": [
12 |           "pre > .signin",
13 |           ".hide-article-box",
14 |           "#blogColumnPayAdvert",
15 |           "#toolBarBox",
16 |           "#asidedirectory",
17 |           ".recommend-box",
18 |           ".template-box",
19 |           "#copyright-box"
20 |         ]
21 |       },
22 |       {
23 |         "hideSibling": [
24 |           ".unlogin-comment-model > .unlogin-comment-tit",
25 |           ".main_father",
26 |           "#mainBox > main"
27 |         ]
28 |       },
29 |       {
30 |         "chAttr": {
31 |           "type": "split2list.add",
32 |           "pick": "#article_content",
33 |           "attr": "style",
34 |           "value": "height: auto !important",
35 |           "sep": ";"
36 |         }
37 |       },
38 |       {
39 |         "chAttr": {
40 |           "type": "split2list.add",
41 |           "pick": "#content_views pre code",
42 |           "attr": "style",
43 |           "value": "user-select: text !important",
44 |           "sep": ";"
45 |         }
46 |       }
47 |     ],
48 |     "comment": "Removed code selection, Unfolded article content"
49 |   }
50 | ]


--------------------------------------------------------------------------------
/plans/zh/guokr.json:
--------------------------------------------------------------------------------
 1 | [
 2 |   {
 3 |     "name": "果壳",
 4 |     "pattern": "http*://www.guokr.com/article/",
 5 |     "version": 20240502,
 6 |     "contributors": [
 7 |       "Mika"
 8 |     ],
 9 |     "actions": [
10 |       {
11 |         "pick": "div[class*=ArticleContent]"
12 |       }
13 |     ],
14 |     "tags": [
15 |       "science",
16 |       "nature"
17 |     ]
18 |   }
19 | ]


--------------------------------------------------------------------------------
/plans/zh/ifeng.json:
--------------------------------------------------------------------------------
 1 | [
 2 |   {
 3 |     "name": "凤凰网/资讯",
 4 |     "pattern": "https://news.ifeng.com/c/*",
 5 |     "version": 20240502,
 6 |     "contributors": [
 7 |       "Mika"
 8 |     ],
 9 |     "actions": [
10 |       {
11 |         "hide": [
12 |           "[class|=rightContent]",
13 |           "[class|=infoboxLink] [class|=face]",
14 |           "[class|=infoboxLink] [class|=follow]",
15 |           "[class|=artical] [class|=info] > [class|=share_box]",
16 |           "[class|=article] [class|=info] > [class|=share_box]",
17 |           "[class|=vote_box] [class|=qr_box]",
18 |           "[class|=vote_box] [class|=share_box]",
19 |           "[class|=comment_textarea_head]",
20 |           "[class|=comment_textarea_body]",
21 |           "[class|=comment_textarea_bottom]",
22 |           "[class|=showAllComment]"
23 |         ]
24 |       },
25 |       {
26 |         "hideSibling": [
27 |           "[class|=artical]",
28 |           "[class|=article]"
29 |         ]
30 |       },
31 |       {
32 |         "pick": [
33 |           "[class|=main_content]",
34 |           "[class|=artical]",
35 |           "[class|=article]"
36 |         ]
37 |       }
38 |     ],
39 |     "tags": [
40 |       "news"
41 |     ]
42 |   }
43 | ]


--------------------------------------------------------------------------------
/plans/zh/ipcfun.json:
--------------------------------------------------------------------------------
 1 | [
 2 |   {
 3 |     "name": "iPcfun",
 4 |     "pattern": "https://www.ipcfun.com/*.html",
 5 |     "version": 20240502,
 6 |     "actions": [
 7 |       {
 8 |         "hide": [
 9 |           ".post_detail > .entry-relate-links",
10 |           "#sidebar"
11 |         ]
12 |       },
13 |       {
14 |         "pick": ".post"
15 |       }
16 |     ]
17 |   }
18 | ]


--------------------------------------------------------------------------------
/plans/zh/iplaysoft.json:
--------------------------------------------------------------------------------
 1 | [
 2 |   {
 3 |     "name": "异次元软件世界",
 4 |     "pattern": "https://www.iplaysoft.com/*.html",
 5 |     "version": 20240502,
 6 |     "contributors": [
 7 |       "Mika"
 8 |     ],
 9 |     "actions": [
10 |       {
11 |         "hide": [
12 |           "ul#link1111",
13 |           "#socialshare",
14 |           ".post_wechat_qr",
15 |           ".donate",
16 |           ".entry-recommend-posts",
17 |           ".entry-relate-links",
18 |           ".same-cat-post-head",
19 |           ".same-cat-post",
20 |           "#respond",
21 |           "#sidebar"
22 |         ]
23 |       },
24 |       {
25 |         "chAttr": {
26 |           "type": "assign.from.self-attr",
27 |           "pick": "div.entry-content img.lazyload",
28 |           "attr": "src",
29 |           "tAttr": "data-src"
30 |         }
31 |       }
32 |     ],
33 |     "tags": [
34 |       "IT",
35 |       "software",
36 |       "share"
37 |     ]
38 |   }
39 | ]


--------------------------------------------------------------------------------
/plans/zh/iteye.json:
--------------------------------------------------------------------------------
 1 | [
 2 |   {
 3 |     "name": "iteye",
 4 |     "pattern": "http*://*.iteye.com/blog/*",
 5 |     "version": 20240502,
 6 |     "actions": [
 7 |       {
 8 |         "hide": [
 9 |           "#bottoms",
10 |           ".blog_bottom",
11 |           ".blog_nav",
12 |           ".blog_comment"
13 |         ]
14 |       },
15 |       {
16 |         "pick": "#blog_content"
17 |       }
18 |     ],
19 |     "tags": [
20 |       "IT",
21 |       "blog"
22 |     ]
23 |   }
24 | ]


--------------------------------------------------------------------------------
/plans/zh/ithome.json:
--------------------------------------------------------------------------------
 1 | [
 2 |   {
 3 |     "name": "IT之家",
 4 |     "pattern": "https://www.ithome.com/**/*/*.htm",
 5 |     "version": 20240502,
 6 |     "contributors": [
 7 |       "yzqzss (author)",
 8 |       "Mika"
 9 |     ],
10 |     "actions": [
11 |       {
12 |         "chAttr": {
13 |           "type": "assign.from.self-attr",
14 |           "pick": "img.lazy",
15 |           "attr": "src",
16 |           "tAttr": "data-original"
17 |         }
18 |       }
19 |     ],
20 |     "tags": [
21 |       "IT",
22 |       "news"
23 |     ]
24 |   }
25 | ]


--------------------------------------------------------------------------------
/plans/zh/jianshu.json:
--------------------------------------------------------------------------------
 1 | [
 2 |   {
 3 |     "name": "简书",
 4 |     "pattern": "https://www.jianshu.com/p/*",
 5 |     "version": 20240502,
 6 |     "contributors": [
 7 |       "Mika"
 8 |     ],
 9 |     "actions": [
10 |       {
11 |         "chAttr": {
12 |           "type": "assign.from.self-attr",
13 |           "pick": ".image-view img[data-original-src]",
14 |           "attr": "src",
15 |           "tAttr": "data-original-src"
16 |         }
17 |       }
18 |     ],
19 |     "tags": [
20 |       "writing"
21 |     ]
22 |   }
23 | ]


--------------------------------------------------------------------------------
/plans/zh/juejin.json:
--------------------------------------------------------------------------------
 1 | [
 2 |   {
 3 |     "name": "掘金-文章/资讯",
 4 |     "pattern": [
 5 |       "https://juejin.cn/post/*"
 6 |     ],
 7 |     "version": 20240502,
 8 |     "contributors": [
 9 |       "CodingOX"
10 |     ],
11 |     "actions": [
12 |       {
13 |         "hideSibling": [
14 |           ".article-content pre > code"
15 |         ]
16 |       },
17 |       {
18 |         "pick": ".article-content"
19 |       }
20 |     ],
21 |     "tags": [
22 |       "IT",
23 |       "community",
24 |       "frontend"
25 |     ]
26 |   },
27 |   {
28 |     "name": "掘金-资讯",
29 |     "pattern": [
30 |       "https://juejin.cn/news/*"
31 |     ],
32 |     "version": 20240502,
33 |     "contributors": [
34 |       "Mika"
35 |     ],
36 |     "actions": [
37 |       {
38 |         "hide": [
39 |           ".article #commentListBox",
40 |           ".article .jh-news-detail-action-area > .category",
41 |           ".article .jh-news-detail-action-area > .viewcount"
42 |         ]
43 |       },
44 |       {
45 |         "pick": ".article"
46 |       }
47 |     ],
48 |     "tags": [
49 |       "IT",
50 |       "community",
51 |       "frontend"
52 |     ]
53 |   },
54 |   {
55 |     "name": "掘金-小册",
56 |     "pattern": "https://juejin.cn/book/*/section/*",
57 |     "version": 20240502,
58 |     "contributors": [
59 |       "Sularxx",
60 |       "Mika"
61 |     ],
62 |     "actions": [
63 |       {
64 |         "form": {
65 |           "title": ".article-content > .markdown-body > h1"
66 |         }
67 |       },
68 |       {
69 |         "pick": ".article-content > .markdown-body"
70 |       }
71 |     ],
72 |     "tags": [
73 |       "IT",
74 |       "book"
75 |     ]
76 |   }
77 | ]


--------------------------------------------------------------------------------
/plans/zh/linux-china.json:
--------------------------------------------------------------------------------
 1 | [
 2 |   {
 3 |     "name": "linux.cn",
 4 |     "pattern": "https://linux.cn/article-*.html",
 5 |     "version": 20240502,
 6 |     "contributors": [
 7 |       "Mika"
 8 |     ],
 9 |     "actions": [
10 |       {
11 |         "pick": "div#article_content"
12 |       }
13 |     ],
14 |     "tags": [
15 |       "IT",
16 |       "Linux"
17 |     ]
18 |   }
19 | ]


--------------------------------------------------------------------------------
/plans/zh/ruanyifeng.json:
--------------------------------------------------------------------------------
 1 | [
 2 |   {
 3 |     "name": "阮一峰的博客",
 4 |     "pattern": "http*://www.ruanyifeng.com/blog/**/*/*.html",
 5 |     "version": 20240502,
 6 |     "contributors": [
 7 |       "Mika"
 8 |     ],
 9 |     "actions": [
10 |       {
11 |         "pick": "article"
12 |       }
13 |     ],
14 |     "tags": [
15 |       "IT",
16 |       "blog",
17 |       "frontend"
18 |     ]
19 |   }
20 | ]


--------------------------------------------------------------------------------
/plans/zh/ruby-china.json:
--------------------------------------------------------------------------------
 1 | [
 2 |   {
 3 |     "name": "ruby-china.org",
 4 |     "pattern": "https://ruby-china.org/topics/*",
 5 |     "version": 20240502,
 6 |     "contributors": [
 7 |       "Mika"
 8 |     ],
 9 |     "actions": [
10 |       {
11 |         "pick": ".topic-detail"
12 |       }
13 |     ],
14 |     "tags": [
15 |       "IT",
16 |       "community",
17 |       "ruby"
18 |     ]
19 |   }
20 | ]


--------------------------------------------------------------------------------
/plans/zh/segmentfault.json:
--------------------------------------------------------------------------------
 1 | [
 2 |   {
 3 |     "name": "segmentfault.com",
 4 |     "pattern": "https://segmentfault.com/a/",
 5 |     "version": 20240502,
 6 |     "contributors": [
 7 |       "Mika"
 8 |     ],
 9 |     "actions": [
10 |       {
11 |         "pick": "article.article-content"
12 |       }
13 |     ],
14 |     "tags": [
15 |       "IT",
16 |       "geek"
17 |     ]
18 |   }
19 | ]


--------------------------------------------------------------------------------
/plans/zh/solidot-cn.json:
--------------------------------------------------------------------------------
 1 | [
 2 |   {
 3 |     "name": "Solidot",
 4 |     "pattern": "https://www.solidot.org/story",
 5 |     "version": 20240502,
 6 |     "contributors": [
 7 |       "Mika"
 8 |     ],
 9 |     "actions": [
10 |       {
11 |         "pick": "div.p_mainnew"
12 |       }
13 |     ],
14 |     "tags": [
15 |       "IT",
16 |       "news",
17 |       "geek"
18 |     ]
19 |   }
20 | ]


--------------------------------------------------------------------------------
/plans/zh/sspai.json:
--------------------------------------------------------------------------------
 1 | [
 2 |   {
 3 |     "name": "少数派",
 4 |     "pattern": "https://sspai.com/post/*",
 5 |     "version": 20240502,
 6 |     "contributors": [
 7 |       "Mika"
 8 |     ],
 9 |     "actions": [
10 |       {
11 |         "hide": [
12 |           ".bgGrey",
13 |           ".article-side"
14 |         ]
15 |       },
16 |       {
17 |         "chAttr": {
18 |           "type": "assign.from.self-attr",
19 |           "pick": ".content img",
20 |           "attr": "src",
21 |           "tAttr": "data-original"
22 |         }
23 |       }
24 |     ],
25 |     "tags": [
26 |       "news"
27 |     ]
28 |   }
29 | ]


--------------------------------------------------------------------------------
/plans/zh/v2ex.json:
--------------------------------------------------------------------------------
 1 | [
 2 |   {
 3 |     "name": "v2ex",
 4 |     "pattern": "https://www.v2ex.com/t/",
 5 |     "version": 20240502,
 6 |     "contributors": [
 7 |       "Mika"
 8 |     ],
 9 |     "actions": [
10 |       {
11 |         "pick": "div.topic_content"
12 |       }
13 |     ],
14 |     "tags": [
15 |       "IT",
16 |       "forum",
17 |       "share",
18 |       "creation"
19 |     ]
20 |   }
21 | ]


--------------------------------------------------------------------------------
/plans/zh/wangyi.json:
--------------------------------------------------------------------------------
 1 | [
 2 |   {
 3 |     "name": "wangyi open courses",
 4 |     "pattern": "https://open.163.com/newview/movie/free",
 5 |     "version": 20240502,
 6 |     "actions": [
 7 |       {
 8 |         "hideSibling": [
 9 |           ".video-js > video"
10 |         ]
11 |       },
12 |       {
13 |         "pick": ".video-module"
14 |       }
15 |     ]
16 |   }
17 | ]


--------------------------------------------------------------------------------
/plans/zh/weibo.json:
--------------------------------------------------------------------------------
 1 | [
 2 |   {
 3 |     "name": "新浪微博",
 4 |     "pattern": "https://weibo.com/$d/*",
 5 |     "version": 20240502,
 6 |     "contributors": [
 7 |       "Mika"
 8 |     ],
 9 |     "actions": [
10 |       {
11 |         "hideSibling": [
12 |           "video.wbpv-tech"
13 |         ]
14 |       },
15 |       {
16 |         "chAttr": {
17 |           "type": "assign.from.value",
18 |           "pick": ".vue-recycle-scroller__item-wrapper",
19 |           "attr": "data-mx-sort-by-index",
20 |           "value": "1"
21 |         }
22 |       },
23 |       {
24 |         "chAttr": {
25 |           "type": "assign.from.value",
26 |           "pick": ".vue-recycle-scroller__item-view",
27 |           "attr": "data-mx-locked-style-position",
28 |           "value": "static !important"
29 |         }
30 |       },
31 |       {
32 |         "chAttr": {
33 |           "type": "assign.from.value",
34 |           "pick": ".vue-recycle-scroller__item-view",
35 |           "attr": "data-mx-locked-style-transform",
36 |           "value": "translateY(0px)"
37 |         }
38 |       },
39 |       {
40 |         "chAttr": {
41 |           "type": "assign.from.first-child-attr",
42 |           "pick": ".vue-recycle-scroller__item-view",
43 |           "attr": "data-mx-index",
44 |           "tAttr": "data-index"
45 |         }
46 |       }
47 |     ]
48 |   }
49 | ]


--------------------------------------------------------------------------------
/plans/zh/weixin-gh.json:
--------------------------------------------------------------------------------
 1 | [
 2 |   {
 3 |     "name": "wixin-gh",
 4 |     "pattern": "https://mp.weixin.qq.com/s/*",
 5 |     "version": 20240508,
 6 |     "contributors": [
 7 |       "Mika"
 8 |     ],
 9 |     "actions": [
10 |       {
11 |         "hide": [ ".qr_code_pc" ]
12 |       },
13 |       {
14 |         "chAttr": {
15 |           "type": "assign.from.self-attr",
16 |           "pick": ".wxw-img[data-src], img.img_loading[data-src]",
17 |           "attr": "src",
18 |           "tAttr": "data-src"
19 |         }
20 |       },
21 |       {
22 |         "formula": {
23 |           "pick": "mjx-container",
24 |           "attr": "data-formula"
25 |         },
26 |         "tag": "md-only"
27 |       }
28 |     ]
29 |   }
30 | ]
31 | 


--------------------------------------------------------------------------------
/plans/zh/zhihu.json:
--------------------------------------------------------------------------------
  1 | [
  2 |   {
  3 |     "name": "知乎专栏",
  4 |     "pattern": "https://zhuanlan.zhihu.com/p/**",
  5 |     "version": 20240502,
  6 |     "contributors": [
  7 |       "Mika"
  8 |     ],
  9 |     "actions": [
 10 |       {
 11 |         "hide": [
 12 |           "figure > noscript",
 13 |           ".GifPlayer-icon",
 14 |           ".GifPlayer > .GifPlayer-gif2mp4",
 15 |           ".PostIndex-Contributions",
 16 |           ".Recommendations-Main",
 17 |           ".CommentsV2-footer-wrapper",
 18 |           ".CommentTopbar .Topbar-options",
 19 |           ".ColumnPageHeader-Wrapper"
 20 |         ]
 21 |       },
 22 |       {
 23 |         "chAttr": {
 24 |           "type": "split2list.remove",
 25 |           "pick": ".RichContent-actions",
 26 |           "attr": "class",
 27 |           "value": [
 28 |             "Sticky",
 29 |             "is-fixed",
 30 |             "is-bottom"
 31 |           ]
 32 |         }
 33 |       },
 34 |       {
 35 |         "chAttr": {
 36 |           "type": "assign.from.self-attr",
 37 |           "pick": "figure img",
 38 |           "attr": "src",
 39 |           "tAttr": "data-actualsrc"
 40 |         }
 41 |       },
 42 |       {
 43 |         "chAttr": {
 44 |           "type": "replace.last-match",
 45 |           "pick": ".GifPlayer img",
 46 |           "attr": "src",
 47 |           "subStr": ".jpg",
 48 |           "newStr": ".gif"
 49 |         }
 50 |       }
 51 |     ],
 52 |     "tags": [
 53 |       "knowledge",
 54 |       "share"
 55 |     ]
 56 |   },
 57 |   {
 58 |     "name": "知乎回答",
 59 |     "pattern": "https://www.zhihu.com/question/*/answer/*",
 60 |     "version": 20240502,
 61 |     "contributors": [
 62 |       "Mika"
 63 |     ],
 64 |     "actions": [
 65 |       {
 66 |         "hide": [
 67 |           ".QuestionHeader-footer-main",
 68 |           ".Card.ViewAll",
 69 |           ".Question-mainColumnLogin",
 70 |           ".Topbar-options",
 71 |           ".List-header",
 72 |           ".ContentItem-expandButton",
 73 |           ".ContentItem-action.ContentItem-rightButton",
 74 |           ".GifPlayer-icon",
 75 |           ".GifPlayer > .GifPlayer-gif2mp4",
 76 |           ".CommentsV2-footer-wrapper"
 77 |         ]
 78 |       },
 79 |       {
 80 |         "chAttr": {
 81 |           "type": "split2list.remove",
 82 |           "pick": ".ContentItem .RichContent",
 83 |           "attr": "class",
 84 |           "value": [
 85 |             "is-collapsed"
 86 |           ]
 87 |         }
 88 |       },
 89 |       {
 90 |         "chAttr": {
 91 |           "type": "split2list.remove",
 92 |           "pick": ".ContentItem-actions",
 93 |           "attr": "class",
 94 |           "value": [
 95 |             "Sticky",
 96 |             "is-fixed",
 97 |             "is-bottom"
 98 |           ]
 99 |         }
100 |       },
101 |       {
102 |         "chAttr": {
103 |           "type": "assign.from.self-attr",
104 |           "pick": "figure img",
105 |           "attr": "src",
106 |           "tAttr": "data-actualsrc"
107 |         }
108 |       },
109 |       {
110 |         "chAttr": {
111 |           "type": "replace.last-match",
112 |           "pick": ".GifPlayer img",
113 |           "attr": "src",
114 |           "subStr": ".jpg",
115 |           "newStr": ".gif"
116 |         }
117 |       }
118 |     ],
119 |     "tags": [
120 |       "QA",
121 |       "answer",
122 |       "share",
123 |       "discuss"
124 |     ]
125 |   },
126 |   {
127 |     "name": "知乎问题",
128 |     "pattern": "https://www.zhihu.com/question/*",
129 |     "version": 20240502,
130 |     "contributors": [
131 |       "Mika"
132 |     ],
133 |     "actions": [
134 |       {
135 |         "hide": [
136 |           ".QuestionHeader-footer-main",
137 |           ".AnswersNavWrapper .List-header",
138 |           ".ContentItem-expandButton",
139 |           ".ContentItem-action.ContentItem-rightButton",
140 |           ".GifPlayer-icon",
141 |           ".GifPlayer > .GifPlayer-gif2mp4",
142 |           ".CommentsV2-footer-wrapper",
143 |           ".Question-sideColumn"
144 |         ]
145 |       },
146 |       {
147 |         "chAttr": {
148 |           "type": "split2list.remove",
149 |           "pick": ".ContentItem .RichContent",
150 |           "attr": "class",
151 |           "value": [
152 |             "is-collapsed"
153 |           ]
154 |         }
155 |       },
156 |       {
157 |         "chAttr": {
158 |           "type": "split2list.remove",
159 |           "pick": ".ContentItem-actions",
160 |           "attr": "class",
161 |           "value": [
162 |             "Sticky",
163 |             "is-fixed",
164 |             "is-bottom"
165 |           ],
166 |           "sep": " "
167 |         }
168 |       },
169 |       {
170 |         "chAttr": {
171 |           "type": "assign.from.self-attr",
172 |           "pick": "figure img",
173 |           "attr": "src",
174 |           "tAttr": "data-actualsrc"
175 |         }
176 |       },
177 |       {
178 |         "chAttr": {
179 |           "type": "replace.last-match",
180 |           "pick": ".GifPlayer img",
181 |           "attr": "src",
182 |           "subStr": ".jpg",
183 |           "newStr": ".gif"
184 |         }
185 |       }
186 |     ],
187 |     "tags": [
188 |       "QA",
189 |       "question",
190 |       "share",
191 |       "discuss"
192 |     ]
193 |   },
194 |   {
195 |     "name": "zhihu video",
196 |     "pattern": "https://video.zhihu.com/video/*",
197 |     "version": 20240502,
198 |     "actions": [
199 |       {
200 |         "hideSibling": "X||//video/.."
201 |       }
202 |     ]
203 |   }
204 | ]


--------------------------------------------------------------------------------
/tmp/.keep:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mika-cn/maoxian-assistant/f3acaefc2f0b0dccf955274501be51669453f459/tmp/.keep


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