├── .gitignore
├── index.js
├── src
    ├── clean-ast.js
    ├── get-mapping.js
    ├── create-mapping.js
    └── cli.js
├── .travis.yml
├── package.json
├── README.md
└── LICENSE


/.gitignore:
--------------------------------------------------------------------------------
1 | node_modules
2 | 


--------------------------------------------------------------------------------
/index.js:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env node
2 | 
3 | require('./src/cli')
4 | 


--------------------------------------------------------------------------------
/src/clean-ast.js:
--------------------------------------------------------------------------------
1 | const traverse = require('babel-traverse').default
2 | const t = require('babel-types')
3 | const beautifier = require('babel-plugin-transform-beautifier')
4 | 
5 | module.exports = function cleanAst (file) {
6 |   traverse(file, beautifier({ types: t }).visitor)
7 |   return file
8 | }
9 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | language: node_js
 2 | sudo: false
 3 | node_js:
 4 |   - 8
 5 |   - 7
 6 | before_install:
 7 |   - npm install -g npm@latest
 8 |   - npm install -g greenkeeper-lockfile@1
 9 | 
10 | before_script:
11 |   - greenkeeper-lockfile-update
12 | script:
13 |   - node ./index.js --verbose
14 | after_script:
15 |   - greenkeeper-lockfile-upload
16 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "replug",
 3 |   "version": "2.0.2",
 4 |   "license": "MIT",
 5 |   "description": "Auto-reverse engineer Plug.dj javascript",
 6 |   "repository": "extplug/replug",
 7 |   "bin": "./index.js",
 8 |   "engines": {
 9 |     "node": ">= 8.9"
10 |   },
11 |   "dependencies": {
12 |     "babel-plugin-transform-beautifier": "^0.1.0",
13 |     "babel-traverse": "^7.0.0-beta.3",
14 |     "babel-types": "^7.0.0-beta.3",
15 |     "babylon": "^7.0.0-beta.40",
16 |     "bluebird": "^3.5.1",
17 |     "browser-resolve": "^1.11.2",
18 |     "chalk": "^2.3.1",
19 |     "commander": "^2.14.1",
20 |     "got": "^8.1.0",
21 |     "jsdom": "^11.6.2",
22 |     "listr": "^0.13.0",
23 |     "listr-update-renderer": "^0.4.0",
24 |     "listr-verbose-renderer": "^0.4.1",
25 |     "mkdirp-then": "^1.1.0",
26 |     "mz": "^2.7.0",
27 |     "plug-login": "^1.2.0",
28 |     "plug-modules": "^5.2.0",
29 |     "prettier": "^1.10.2"
30 |   },
31 |   "devDependencies": {
32 |     "standard": "^11.0.0"
33 |   },
34 |   "scripts": {
35 |     "test": "standard src/*.js"
36 |   }
37 | }
38 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # non-lethal plug.dj reverse engineering
 2 | 
 3 | A messy script that spews as-readable-as-computerly-possible versions of plug.dj
 4 | modules into a directory.
 5 | 
 6 | ## usage
 7 | 
 8 | The easiest way to use replug is with [npx](https://npmjs.com/package/npx):
 9 | 
10 | 1. `npx replug`
11 | 
12 | Alternatively, install the CLI globally (you'll have to update manually from time to time):
13 | 
14 | 1. `npm install -g replug`
15 | 1. `replug`
16 | 
17 | There are some command-line options:
18 | 
19 |     -h, --help            output usage information
20 |     -V, --version         output the version number
21 |     -m, --mapping [file]  File containing the mapping JSON (optional, it's auto-generated if no file is given)
22 |     -o, --out [dir]       Output directory [out/]
23 |     -v, --verbose         Use verbose output instead of bullet list
24 | 
25 | ### examples
26 | 
27 | Dump output in `out/`:
28 | 
29 | ```
30 | npx replug
31 | ```
32 | 
33 | Output in `output-directory/`:
34 | 
35 | ```
36 | npx replug --out output-directory
37 | ```
38 | 
39 | ## Licence
40 | 
41 | [MIT](./LICENSE)
42 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2015 René Kooi
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in
13 | all copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
21 | THE SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/src/get-mapping.js:
--------------------------------------------------------------------------------
 1 | /* global $ */
 2 | 
 3 | // eslint-disable-next-line no-unused-vars
 4 | function getMapping (plugModules) {
 5 |   plugModules.run()
 6 | 
 7 |   const knownKeys = Object.keys(plugModules._nameMapping)
 8 |   const unknownKeys = plugModules.getUnknownModules()
 9 | 
10 |   const knownModules = knownKeys.map((key) => ({
11 |     isUnknown: false,
12 |     name: key,
13 |     original: plugModules.resolveName(key),
14 |     module: plugModules.require(key)
15 |   }))
16 |   const unknownModules = unknownKeys.map((key) => ({
17 |     isUnknown: true,
18 |     name: '?',
19 |     original: key,
20 |     module: plugModules.require(key)
21 |   }))
22 | 
23 |   // build mappings
24 |   const partsMapping = {}
25 |   knownModules.forEach((mod) => {
26 |     const name = mod.name.split('/')
27 |     const obsc = mod.original.split('/')
28 | 
29 |     obsc.forEach((part, i) => {
30 |       partsMapping[part] = name[i]
31 |     })
32 |   })
33 | 
34 |   // guess module names based on known paths
35 |   unknownModules.forEach((mod) => {
36 |     mod.name = mod.original
37 |       .split('/')
38 |       .map((part) => partsMapping[part] || part)
39 |       .join('/')
40 |   })
41 | 
42 |   // modules that were not remapped by plug-modules, but were partially guessed
43 |   const unknownPlugModules = unknownModules.filter(
44 |     (mod) => mod.name.indexOf('plug/') === 0
45 |   )
46 | 
47 |   void unknownPlugModules // It's not used atm
48 | 
49 |   // build full mapping of original names to (possibly partially guessed) proper names
50 |   const fullMapping = {}
51 |   knownModules.concat(unknownModules).forEach((mod) => {
52 |     fullMapping[mod.original] = mod.name
53 |   })
54 | 
55 |   const scriptSources = $('script[src*="cdn.plug"]').toArray().map((el) => el.src)
56 | 
57 |   // get plug.dj version (it appears in one of the inline <script> tags)
58 |   const js = $('script:not([src])').text()
59 |   const version = /_v="(.*?)"/.exec(js)[1]
60 | 
61 |   const appUrl = scriptSources.find(contains('js/app'))
62 |   const langUrl = scriptSources.find(contains('js/lang/'))
63 |   const avatarsUrl = scriptSources.find(contains('js/avatars'))
64 | 
65 |   return JSON.stringify({
66 |     version: version,
67 |     appUrl: appUrl,
68 |     langUrl: langUrl,
69 |     avatarsUrl: avatarsUrl,
70 |     mapping: fullMapping
71 |   })
72 | 
73 |   function contains (str) {
74 |     return (src) => src.indexOf(str) > 0
75 |   }
76 | }
77 | 


--------------------------------------------------------------------------------
/src/create-mapping.js:
--------------------------------------------------------------------------------
  1 | const Listr = require('listr')
  2 | const got = require('got')
  3 | const { JSDOM } = require('jsdom')
  4 | const bresolve = require('browser-resolve')
  5 | const Promise = require('bluebird')
  6 | const readFile = require('mz/fs').readFile
  7 | 
  8 | const pmPath = bresolve.sync('plug-modules', { filename: __filename })
  9 | 
 10 | // stubs needed by plug.dj's app code at boot time
 11 | const stubs = {
 12 |   localStorage: {
 13 |     getItem () {},
 14 |     setItem () {},
 15 |     clear () {}
 16 |   },
 17 |   gapi: {
 18 |     client: {
 19 |       setApiKey () {},
 20 |       load () {}
 21 |     }
 22 |   },
 23 |   Intercom: {},
 24 |   amplitude: { __VERSION__: true },
 25 |   FB: { init: function () {} }
 26 | }
 27 | 
 28 | function waitForRequireJs (window) {
 29 |   return new Promise((resolve, reject) => {
 30 |     // wait for the app javascript to load, then run plug-modules
 31 |     const intv = setInterval(waitForRequireJs, 20)
 32 |     function waitForRequireJs () {
 33 |       if (window.requirejs) {
 34 |         window.define('facebook', stubs.FB)
 35 |         // intercept plug.dj's booting code
 36 |         // plug.dj uses require([ deps ]) calls in places to actually start the
 37 |         // app. we do want those calls to register the dependencies with require,
 38 |         // but we don't want to start plug.dj because that's expensive and
 39 |         // usually throws an error somewhere. instead we override the callback
 40 |         // with an empty function :D
 41 |         const orig = window.require
 42 |         window.require = Object.assign((arg, ...rest) => {
 43 |           if (Array.isArray(arg) && arg[0].indexOf('http') !== 0) {
 44 |             return orig(arg, () => {
 45 |               /* ... */
 46 |               resolve()
 47 |             })
 48 |           }
 49 |           return orig(arg, ...rest)
 50 |         }, orig)
 51 |         const origDefine = window.define
 52 |         window.define = Object.assign((name, dependencies, ...args) => {
 53 |           if (name === 'async') {
 54 |             return origDefine('async', {
 55 |               load: (name, parent, onload) => onload({})
 56 |             })
 57 |           }
 58 |           if (Array.isArray(dependencies)) {
 59 |             dependencies = dependencies.map((dep) => dep === 'recaptcha' ? 'module' : dep)
 60 |           }
 61 |           return origDefine(name, dependencies, ...args)
 62 |         }, origDefine)
 63 |         clearInterval(intv)
 64 |       }
 65 |     }
 66 |   })
 67 | }
 68 | 
 69 | const PLUG_ROOM_URL = 'https://plug.dj/plug-socket-test'
 70 | 
 71 | // Create a name mapping from plug.dj's obfuscated require.js module names to
 72 | // readable names by running plug-modules in a headless browser-like
 73 | // environment (aka jsdom).
 74 | // You need to be logged in to run plug-modules, so pass in a cookie jar with
 75 | // a valid session cookie.
 76 | module.exports = function createMapping (cookie, ctx) {
 77 |   const reqAsync = (req, id) => new Promise((resolve, reject) => req(id, resolve, reject))
 78 | 
 79 |   return new Listr([
 80 |     {
 81 |       title: 'Loading plug.dj',
 82 |       task: (ctx) =>
 83 |         got(PLUG_ROOM_URL, {
 84 |           headers: { cookie: cookie }
 85 |         }).then((response) => {
 86 |           ctx.source = response.body
 87 |         })
 88 |     },
 89 |     {
 90 |       title: 'Opening plug.dj',
 91 |       task: (ctx) => {
 92 |         ctx.dom = new JSDOM(ctx.source, {
 93 |           url: PLUG_ROOM_URL,
 94 |           runScripts: 'dangerously',
 95 |           resources: 'usable',
 96 |           beforeParse (window) {
 97 |             Object.assign(window, stubs)
 98 |             ctx.window = window
 99 |           }
100 |         })
101 |       }
102 |     },
103 |     {
104 |       title: 'Injecting module mapping helper',
105 |       task: (ctx) =>
106 |         readFile(require.resolve('./get-mapping'), 'utf8').then((source) => {
107 |           ctx.window.eval(source)
108 |         })
109 |     },
110 |     {
111 |       title: 'Waiting for plug.dj to finish loading',
112 |       task: (ctx) => waitForRequireJs(ctx.window)
113 |     },
114 |     {
115 |       title: 'Running plug-modules',
116 |       task: (ctx) => Promise.resolve(readFile(pmPath, 'utf-8'))
117 |         // ensure that plugModules defines itself as "plug-modules"
118 |         .then((plugModules) => plugModules.replace('define([', 'define("plug-modules",['))
119 |         // insert plug-modules
120 |         .then((src) => ctx.window.eval(src))
121 |         .then(() => reqAsync(ctx.window.requirejs, [ 'plug-modules' ]))
122 |         .then((pm) => ctx.window.getMapping(pm))
123 |         .tap(() => ctx.window.close())
124 |         .then(JSON.parse)
125 |         .then((result) => {
126 |           ctx.window = null
127 |           ctx.mapping = result.mapping
128 |           ctx.appUrl = result.appUrl
129 |         })
130 |     }
131 |   ], { context: ctx })
132 | }
133 | 


--------------------------------------------------------------------------------
/src/cli.js:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env node
  2 | 
  3 | const Listr = require('listr')
  4 | const updateRenderer = require('listr-update-renderer')
  5 | const verboseRenderer = require('listr-verbose-renderer')
  6 | const chalk = require('chalk')
  7 | const Promise = require('bluebird')
  8 | const program = require('commander')
  9 | const { parse } = require('babylon')
 10 | const traverse = require('babel-traverse').default
 11 | const generate = require('prettier').__debug.formatAST
 12 | const t = require('babel-types')
 13 | const path = require('path')
 14 | const mkdirp = require('mkdirp-then')
 15 | const fs = require('mz/fs')
 16 | const login = require('plug-login')
 17 | const got = require('got')
 18 | 
 19 | const pkg = require('../package.json')
 20 | const cleanAst = require('./clean-ast')
 21 | const createMappingFile = require('./create-mapping')
 22 | 
 23 | let _v
 24 | 
 25 | program
 26 |   .usage('[options]')
 27 |   .version(pkg.version)
 28 |   .option('-m, --mapping [file]', 'File containing the mapping JSON ' +
 29 |             '(optional, it\'s auto-generated if no file is given)')
 30 |   .option('-o, --out [dir]', 'Output directory [out/]', 'out/')
 31 |   .option('-v, --verbose', 'Use verbose output instead of bullet list', false)
 32 |   .parse(process.argv)
 33 | 
 34 | async function fetchAppFile (url, progress) {
 35 |   const response = got(url)
 36 |   response.on('downloadProgress', ({ transferred, total }) => {
 37 |     progress(transferred, total)
 38 |   })
 39 |   const { body } = await response
 40 |   return body
 41 | }
 42 | 
 43 | function variableNameFor (dep, mapping) {
 44 |   const libraryNames = {
 45 |     jquery: '$',
 46 |     backbone: 'Backbone',
 47 |     handlebars: 'Handlebars',
 48 |     underscore: '_'
 49 |   }
 50 |   return dep in libraryNames
 51 |        ? libraryNames[dep]
 52 |        : dep.indexOf('hbs!templates/') === 0
 53 |        ? 'template' + dep.split('/').pop()
 54 |        : dep in mapping
 55 |        ? mapping[dep].split('/').pop().replace(/-/g, '_')
 56 |        : dep
 57 | }
 58 | 
 59 | function parseModules (str, progress) {
 60 |   const ast = parse(str)
 61 |   const modules = {}
 62 |   traverse(ast, {
 63 |     CallExpression ({ node }) {
 64 |       if (t.isIdentifier(node.callee, { name: 'define' })) {
 65 |         let [ name, deps, factory ] = node.arguments
 66 |         if (t.isArrayExpression(deps)) {
 67 |           deps = deps.elements
 68 |         } else {
 69 |           factory = deps
 70 |           deps = []
 71 |         }
 72 | 
 73 |         const code = str.slice(node.start, node.end)
 74 | 
 75 |         const file = t.file(
 76 |           t.program([ t.expressionStatement(factory) ]),
 77 |           [], [])
 78 | 
 79 |         progress(name.value)
 80 |         modules[name.value] = {
 81 |           deps,
 82 |           code,
 83 |           file,
 84 |           ast: factory
 85 |         }
 86 |       }
 87 |     }
 88 |   })
 89 | 
 90 |   progress(null)
 91 |   return modules
 92 | }
 93 | 
 94 | function findReturnVar (ast) {
 95 |   const lastSt = ast.body[ast.body.length - 1]
 96 |   if (t.isReturnStatement(lastSt)) {
 97 |     const retVal = lastSt.argument
 98 |     return t.isNewExpression(retVal)
 99 |       ? retVal.callee
100 |       : t.isIdentifier(retVal) && retVal.name !== 'undefined'
101 |       ? retVal
102 |       : null
103 |   }
104 | }
105 | 
106 | async function cleanModules (modules, progress) {
107 |   const names = Object.keys(modules)
108 |   for (let i = 0; i < names.length; i += 1) {
109 |     const name = names[i]
110 | 
111 |     cleanAst(modules[name].file)
112 | 
113 |     await progress(i + 1, names.length)
114 |   }
115 | }
116 | 
117 | async function remapModuleNames (modules, mapping, progress) {
118 |   const names = Object.keys(modules)
119 | 
120 |   for (let index = 0; index < names.length; index += 1) {
121 |     const name = names[index]
122 |     const { ast, deps } = modules[name]
123 |     const params = ast.params && ast.params.map((param) => param.name)
124 | 
125 |     if (!params) {
126 |       await progress(index + 1, names.length)
127 |       continue
128 |     }
129 | 
130 |     const renames = []
131 |     // build ast of dependency require()s
132 |     const depsAst = deps.map((dep, i) => {
133 |       if (!params[i]) {
134 |         params[i] = '__' + i
135 |       }
136 | 
137 |       let newName = 'unknown'
138 |       // rename variables according to their module names
139 |       if (mapping[dep.value]) {
140 |         newName = variableNameFor(dep.value, mapping)
141 |         renames.push({ from: params[i], to: newName })
142 |       } else if (/^hbs!templates\//.test(dep.value)) {
143 |         newName = 'template' + dep.value.split('/').pop()
144 |         renames.push({ from: params[i], to: newName })
145 |       }
146 | 
147 |       if (dep.value in mapping) {
148 |         const originalName = dep.value
149 |         dep.value = mapping[originalName]
150 |         dep.extra.raw = JSON.stringify(dep.value)
151 |         dep.comments = [
152 |           { type: 'Block', value: ` was ${originalName}`, trailing: true }
153 |         ]
154 |       } else {
155 |         dep.comments = [
156 |           { type: 'Block', value: ' Unknown module', trailing: true }
157 |         ]
158 |       }
159 | 
160 |       return t.variableDeclaration('var', [
161 |         t.variableDeclarator(
162 |           t.identifier(params[i]),
163 |           t.callExpression(t.identifier('require'), [dep])
164 |         )
165 |       ])
166 |     })
167 | 
168 |     // move dependencies from the define() call
169 |     // to the factory body
170 |     ast.body.body = depsAst.concat(ast.body.body)
171 |     ast.params = [
172 |       t.identifier('require'),
173 |       t.identifier('exports'),
174 |       t.identifier('module')
175 |     ]
176 | 
177 |     const returnVar = findReturnVar(ast.body)
178 |     if (returnVar) {
179 |       renames.push({
180 |         from: returnVar.name,
181 |         to: variableNameFor(name, mapping)
182 |       })
183 |     }
184 | 
185 |     processRenames(modules[name].file, renames)
186 | 
187 |     await progress(index + 1, names.length)
188 |   }
189 | }
190 | 
191 | function getDependents (modules, name) {
192 |   const isDep = (d) => d.value === name
193 | 
194 |   return Object.keys(modules).filter((name) =>
195 |     modules[name].deps.some(isDep)
196 |   )
197 | }
198 | 
199 | function findMemberExpressionName (ast) {
200 |   const body = ast.body
201 |   for (let i = 0, l = body.length; i < l; i++) {
202 |     if (t.isExpressionStatement(body[i]) &&
203 |         t.isAssignmentExpression(body[i].expression) &&
204 |         t.isMemberExpression(body[i].expression.left) &&
205 |         t.isIdentifier(body[i].expression.left.object)) {
206 |       return body[i].expression.left.property
207 |     }
208 |   }
209 | }
210 | 
211 | function addMappingForUnknownModules (modules, mapping) {
212 |   for (const orig in mapping) {
213 |     if (mapping[orig] === 'plug/server/socketReceiver') {
214 |       // websocket event receiver modules don't export anything,
215 |       // so they cannot be identified individually by plug-modules.
216 |       // however, we have accesss to their full source here, so
217 |       // we can extract them anyway!
218 |       // socket event receivers set properties on a shared object,
219 |       // which will actually be require()d by plug.dj source code,
220 |       // and which can also be identified by plug-modules. here, we
221 |       // can find all modules that depend on socketReceiver, and find
222 |       // the relevant assignments.
223 |       getDependents(modules, orig).forEach((name) => {
224 |         const prop = findMemberExpressionName(modules[name].ast.body)
225 |         if (prop) {
226 |           // some of these modules have multiple event receivers, so we
227 |           // rename them to be a bit more clear.
228 |           const niceName = {
229 |             // contains a bunch of booth/wait list moderation events
230 |             modAddDJ: 'plug/server/socket/modBooth',
231 |             // contains subscription, XP, and PP events
232 |             earn: 'plug/server/socket/currency',
233 |             // contains multiple events for updates to the current room
234 |             roomNameUpdate: 'plug/server/socket/roomUpdate',
235 |             // this is actually the websocket manager module,
236 |             // and it sets the window._gws property to undefined.
237 |             // it really is just a false positive but we can abuse
238 |             // it to get the proper module, anyway.
239 |             // TODO detect this in a less stupid way
240 |             _gws: 'plug/server/socket'
241 |           }[prop.name] || 'plug/server/socket/' + prop.name
242 |           mapping[name] = niceName
243 |         }
244 |       })
245 |     } else if (mapping[orig] === 'plug/util/API') {
246 |       getDependents(modules, orig).forEach((name) => {
247 |         const prop = findMemberExpressionName(modules[name].ast.body)
248 |         if (prop) {
249 |           const niceName = {
250 |             getAdmins: 'admins',
251 |             getAmbassadors: 'ambassadors',
252 |             getAudience: 'audience',
253 |             getBannedUsers: 'bannedUsers',
254 |             getDJ: 'dj',
255 |             getHistory: 'history',
256 |             getHost: 'host',
257 |             getMedia: 'media',
258 |             getNextMedia: 'nextMedia',
259 |             getScore: 'score',
260 |             getStaff: 'staff',
261 |             getTimeElapsed: 'playTime',
262 |             getUser: 'users',
263 |             getWaitList: 'waitlist',
264 |             moderateForceSkip: 'moderator',
265 |             sendChat: 'chat',
266 |             setVolume: 'volume'
267 |           }[prop.name] || prop.name
268 |           mapping[name] = 'plug/util/api/' + niceName
269 |         }
270 |       })
271 |     }
272 |   }
273 | }
274 | 
275 | function processRenames (ast, renames) {
276 |   traverse(ast, {
277 |     FunctionExpression (path) {
278 |       renames.forEach(({ from, to }) => {
279 |         if (path.scope.hasBinding(to)) {
280 |           path.scope.rename(to, path.scope.generateUid(to))
281 |         }
282 |         path.scope.rename(from, to)
283 |       })
284 |       path.stop()
285 |     }
286 |   })
287 |   return ast
288 | }
289 | 
290 | function extract (modules, mapping, progress) {
291 |   const moduleNames = Object.keys(modules)
292 |   return Promise.each(moduleNames, (name, i) => {
293 |     const mod = modules[name]
294 | 
295 |     const moduleIdentifier = t.stringLiteral(name)
296 |     if (name in mapping) {
297 |       moduleIdentifier.raw = JSON.stringify(mapping[name])
298 |       moduleIdentifier.value = mapping[name]
299 |       moduleIdentifier.comments = [
300 |         { type: 'Block', value: ` was ${name}`, trailing: true }
301 |       ]
302 |     } else {
303 |       moduleIdentifier.raw = JSON.stringify(name)
304 |       moduleIdentifier.comments = [
305 |         { type: 'Block', value: ' Unknown module', trailing: true }
306 |       ]
307 |     }
308 | 
309 |     const ast = t.program([
310 |       t.expressionStatement(
311 |         t.callExpression(t.identifier('define'), [
312 |           moduleIdentifier,
313 |           mod.ast
314 |         ])
315 |       )
316 |     ])
317 |     const code = generate(ast, { originalText: '', singleQuote: true })
318 |     return outputFile(name, mapping, code.formatted).then(() => {
319 |       progress(i + 1, moduleNames.length)
320 |     })
321 |   })
322 | }
323 | 
324 | function writeFile (name, content) {
325 |   return mkdirp(path.dirname(name))
326 |     .then(() => fs.writeFile(name, content))
327 | }
328 | 
329 | function outputFile (name, mapping, code) {
330 |   const file = path.join(program.out, `${name}.js`)
331 |   return writeFile(file, code).then(() => {
332 |     // set up symlinks from nicer paths
333 |     if (mapping[name] && mapping[name].indexOf('plug/') === 0) {
334 |       const niceFile = path.join(program.out, `${mapping[name]}.js`)
335 |       return writeFile(niceFile, code)
336 |     }
337 |   })
338 | }
339 | 
340 | function progress (task) {
341 |   const title = task.title
342 |   return (current, total) => {
343 |     if (typeof current === 'string') {
344 |       task.title = `${title} ${chalk.gray(current)}`
345 |     } else if (typeof current === 'number' && current < total) {
346 |       const percent = chalk.gray(`${Math.floor((current / total) * 100)}%`)
347 |       task.title = `${title} ${percent}`
348 |     } else {
349 |       task.title = title
350 |     }
351 |   }
352 | }
353 | 
354 | const renderer = program.verbose
355 |   ? verboseRenderer
356 |   : updateRenderer
357 | const main = new Listr([
358 |   {
359 |     title: 'Logging in to plug.dj',
360 |     task: (ctx) =>
361 |       Promise.resolve(login.guest()).tap((result) => {
362 |         ctx.session = result
363 |       })
364 |   },
365 |   {
366 |     title: 'Generating module name mapping',
367 |     task: (ctx) => createMappingFile(ctx.session.cookie, ctx)
368 |   },
369 |   {
370 |     title: 'Downloading application file',
371 |     task: (ctx, task) => fetchAppFile(ctx.appUrl, progress(task)).then((src) => {
372 |       ctx.src = src
373 |     })
374 |   },
375 |   {
376 |     title: 'Parsing modules',
377 |     task: (ctx, task) => Promise.delay(100).then(() => {
378 |       ctx.modules = parseModules(ctx.src, progress(task))
379 |     }).delay(100)
380 |   },
381 |   {
382 |     title: 'Cleaning modules',
383 |     task: (ctx, task) => cleanModules(ctx.modules, progress(task))
384 |   },
385 |   {
386 |     title: 'Finding correct names for special modules',
387 |     task: (ctx) => Promise.delay(100).then(() => {
388 |       addMappingForUnknownModules(ctx.modules, ctx.mapping)
389 |     }).delay(100)
390 |   },
391 |   {
392 |     title: 'Remapping module names',
393 |     task: (ctx, task) => remapModuleNames(ctx.modules, ctx.mapping, progress(task))
394 |   },
395 |   {
396 |     title: 'Extracting files',
397 |     task: (ctx, task) =>
398 |       extract(ctx.modules, ctx.mapping, progress(task))
399 |         .tap(() => fs.writeFile(path.join(program.out, 'source.js'), ctx.src))
400 |         .tap(() => fs.writeFile(path.join(program.out, 'mapping.json'),
401 |           JSON.stringify(ctx.mapping, null, 2)))
402 |         .then(() => outputFile('version', {}, `window._v = '${_v}';`))
403 |         .then(() => console.log(`v${_v} done`))
404 |   }
405 | ], { renderer: renderer })
406 | 
407 | main.run().catch((e) => {
408 |   setImmediate(() => {
409 |     throw e
410 |   })
411 | })
412 | 


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