Add module based architecture

* Build with Webpack * Let Octo.js run in Node
2018-03-19 04:23:05 +01:00 · 2018-03-19 04:23:05 +01:00 · 142576ed49
commit 142576ed49
parent a85e0219ae
42 changed files with 2339 additions and 5412 deletions
--- a/.gitignore
+++ b/.gitignore
@ -1,386 +1,4 @@
-### SublimeText template
+.DS_Store
-
+node_modules
-# cache files for sublime text
+package-lock.json
 *.tmlanguage.cache
 *.tmPreferences.cache
 *.stTheme.cache
 # workspace files are user-specific
 *.sublime-workspace
 # project files should be checked into the repository, unless a significant
 # proportion of contributors will probably not be using SublimeText
 # *.sublime-project
 # sftp configuration file
 sftp-config.json
 # Package control specific files
 Package Control.last-run
 Package Control.ca-list
 Package Control.ca-bundle
 Package Control.system-ca-bundle
 Package Control.cache/
 Package Control.ca-certs/
 Package Control.merged-ca-bundle
 Package Control.user-ca-bundle
 oscrypto-ca-bundle.crt
 bh_unicode_properties.cache
 # Sublime-github package stores a github token in this file
 # https://packagecontrol.io/packages/sublime-github
 GitHub.sublime-settings
 ### macOS template
 *.DS_Store
 .AppleDouble
 .LSOverride
 # Icon must end with two \r
 Icon
 # Thumbnails
 ._*
 # Files that might appear in the root of a volume
 .DocumentRevisions-V100
 .fseventsd
 .Spotlight-V100
 .TemporaryItems
 .Trashes
 .VolumeIcon.icns
 .com.apple.timemachine.donotpresent
 # Directories potentially created on remote AFP share
 .AppleDB
 .AppleDesktop
 Network Trash Folder
 Temporary Items
 .apdisk
 ### Linux template
 *~
 # temporary files which can be created if a process still has a handle open of a deleted file
 .fuse_hidden*
 # KDE directory preferences
 .directory
 # Linux trash folder which might appear on any partition or disk
 .Trash-*
 # .nfs files are created when an open file is removed but is still being accessed
 .nfs*
 ### Windows template
 # Windows thumbnail cache files
 Thumbs.db
 ehthumbs.db
 ehthumbs_vista.db
 # Folder config file
 Desktop.ini
 # Recycle Bin used on file shares
 $RECYCLE.BIN/
 # Windows Installer files
 *.cab
 *.msi
 *.msm
 *.msp
 # Windows shortcuts
 *.lnk
 ### CVS template
 /CVS/*
 **/CVS/*
 .cvsignore
 */.cvsignore
 ### Emacs template
 # -*- mode: gitignore; -*-
 *~
 \#*\#
 /.emacs.desktop
 /.emacs.desktop.lock
 *.elc
 auto-save-list
 tramp
 .\#*
 # Org-mode
 .org-id-locations
 *_archive
 # flymake-mode
 *_flymake.*
 # eshell files
 /eshell/history
 /eshell/lastdir
 # elpa packages
 /elpa/
 # reftex files
 *.rel
 # AUCTeX auto folder
 /auto/
 # cask packages
 .cask/
 dist/
 # Flycheck
 flycheck_*.el
 # server auth directory
 /server/
 # projectiles files
 .projectile
 # directory configuration
 .dir-locals.el
 ### NetBeans template
 nbproject/private/
 build/
 nbbuild/
 dist/
 nbdist/
 .nb-gradle/
 ### Eclipse template
 .metadata
 bin/
 tmp/
 *.tmp
 *.bak
 *.swp
 *~.nib
 local.properties
 .settings/
 .loadpath
 .recommenders
 # Eclipse Core
 .project
 # External tool builders
 .externalToolBuilders/
 # Locally stored "Eclipse launch configurations"
 *.launch
 # PyDev specific (Python IDE for Eclipse)
 *.pydevproject
 # CDT-specific (C/C++ Development Tooling)
 .cproject
 # JDT-specific (Eclipse Java Development Tools)
 .classpath
 # Java annotation processor (APT)
 .factorypath
 # PDT-specific (PHP Development Tools)
 .buildpath
 # sbteclipse plugin
 .target
 # Tern plugin
 .tern-project
 # TeXlipse plugin
 .texlipse
 # STS (Spring Tool Suite)
 .springBeans
 # Code Recommenders
 .recommenders/
 # Scala IDE specific (Scala & Java development for Eclipse)
 .cache-main
 .scala_dependencies
 .worksheet
 ### JetBrains template
 # Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio and Webstorm
 # Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
 # User-specific stuff:
 .idea/**/workspace.xml
 .idea/**/tasks.xml
 .idea/dictionaries
 # Sensitive or high-churn files:
 .idea/**/dataSources/
 .idea/**/dataSources.ids
 .idea/**/dataSources.xml
 .idea/**/dataSources.local.xml
 .idea/**/sqlDataSources.xml
 .idea/**/dynamic.xml
 .idea/**/uiDesigner.xml
 # Gradle:
 .idea/**/gradle.xml
 .idea/**/libraries
 # Mongo Explorer plugin:
 .idea/**/mongoSettings.xml
 ## File-based project format:
 *.iws
 ## Plugin-specific files:
 # IntelliJ
 /out/
 # mpeltonen/sbt-idea plugin
 .idea_modules/
 # JIRA plugin
 atlassian-ide-plugin.xml
 # Crashlytics plugin (for Android Studio and IntelliJ)
 com_crashlytics_export_strings.xml
 crashlytics.properties
 crashlytics-build.properties
 fabric.properties
 ### Xcode template
 # Xcode
 #
 # gitignore contributors: remember to update Global/Xcode.gitignore, Objective-C.gitignore & Swift.gitignore
 ## Build generated
 build/
 DerivedData/
 ## Various settings
 *.pbxuser
 !default.pbxuser
 *.mode1v3
 !default.mode1v3
 *.mode2v3
 !default.mode2v3
 *.perspectivev3
 !default.perspectivev3
 xcuserdata/
 ## Other
 *.moved-aside
 *.xccheckout
 *.xcscmblueprint
 ### Vim template
 # swap
 [._]*.s[a-v][a-z]
 [._]*.sw[a-p]
 [._]s[a-v][a-z]
 [._]sw[a-p]
 # session
 Session.vim
 # temporary
 .netrwhist
 *~
 # auto-generated tag files
 tags
 ### Mercurial template
 .hg/
 .hgignore
 .hgsigs
 .hgsub
 .hgsubstate
 .hgtags
 ### Node template
 # Logs
 logs
 *.log
 npm-debug.log*
 yarn-debug.log*
 yarn-error.log*
 # Runtime data
 pids
 *.pid
 *.seed
 *.pid.lock
 # Directory for instrumented libs generated by jscoverage/JSCover
 lib-cov
 # Coverage directory used by tools like istanbul
 coverage
 tests/coverage
 # nyc test coverage
 .nyc_output
 # Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files)
 .grunt
 # Bower dependency directory (https://bower.io/)
 bower_components
 # node-waf configuration
 .lock-wscript
 # Compiled binary addons (http://nodejs.org/api/addons.html)
 build/Release
 # Dependency directories
 node_modules/
 jspm_packages/
 # Typescript v1 declaration files
 typings/
 # Optional npm cache directory
 .npm
 # Optional eslint cache
 .eslintcache
 # Optional REPL history
 .node_repl_history
 # Output of 'npm pack'
 *.tgz
 # Yarn Integrity file
 .yarn-integrity
 # dotenv environment variables file
 .env
 ### Notepad++ template
 # Notepad++ backups #
 *.bak
 # WebBrains project files
 .idea/
--- a/build.py
+++ b/build.py
@ -1,64 +0,0 @@
 #!/usr/bin/env python
 # coding=utf-8
 from __future__ import print_function
 import argparse
 import os
 # List of files which must be loaded first
 PRELOAD = (
    'random/random.js',
    'random/mersennetwister.js',
    'utils/init.js',
    'utils/platform.js',
    'logging/console.js',
    'make/init.js'
 )
 def argparser():
    parser = argparse.ArgumentParser()
    parser.add_argument('-l', '--libs', required=True,
                        help='Directory containing the octo libraries.')
    parser.add_argument('-d', '--deploy', required=True,
                        help='Directory where the combined octo library will be built.')
    args = parser.parse_args()
    if not os.path.isdir(args.libs):
        parser.error("Lib directory doesn't exist!")
    if not os.path.isdir(args.deploy):
        parser.error("Deploy directory doesn't exist!")
    return args
 def main():
    args = argparser()
    data = []
    loaded = set()
    for filename in PRELOAD:
        path = os.path.join(args.libs, filename)
        if not os.path.isfile(path):
            raise Exception("Unable to find file in preload: {0}".format(path))
        print("Adding path: {0}".format(path))
        with open(path, 'rb') as f:
            data.append(f.read())
            loaded.add(path)
    for root, _, files in os.walk(args.libs):
        for filename in files:
            path = os.path.join(root, filename)
            if path.endswith('.js') and path not in loaded:
                print("Adding path: {0}".format(path))
                with open(path, 'rb') as f:
                    data.append(f.read())
    octo_path = os.path.join(args.deploy, 'octo.js')
    with open(octo_path, 'wb') as f:
        f.write(b'\n\n'.join(data))
 if __name__ == "__main__":
    main()
--- a/deploy/octo.js
+++ b/deploy/octo.js
--- a/lib/index.js
+++ b/lib/index.js
@ -0,0 +1,11 @@
 const logger = require('./logging')
 const make = require('./make')
 const random = require('./random')
 const utils = require('./utils')
 module.exports = {
    logger,
    random,
    make,
    utils
 }
--- a/lib/logging/console.js
+++ b/lib/logging/console.js
@ -2,92 +2,87 @@
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-var websocket = null
+const utils = require('../utils')
 let websocket = null
 var logger = (function () { // eslint-disable-line no-unused-vars
 const sep = '\n/* ### NEXT TESTCASE ############################## */'
 const color = {
  red: '\u{1b}[1;31m',
  green: '\u{1b}[1;32m',
  clear: '\u{1b}[0m'
 }
-  if (utils.platform.isWindows) {
+if (utils.platform.name.isWindows) {
  color.red = ''
  color.green = ''
  color.clear = ''
 }
-  function console (msg) {
+class logger {
  static console (msg) {
    if (websocket) {
      websocket.send(msg)
    }
    if (typeof window === 'undefined') {
      try {
        print(msg)  // eslint-disable-line no-undef
      } catch (e) {
        console.log(msg)
      }
    } else if (window.dump) {
-      window.dump(msg)
+      dump(msg)
    } else if (window.console && window.console.log) {
-      window.console.log(msg)
+      console.log(msg)
    } else {
      throw new Error('Unable to run console logger.')
    }
  }
-  function dump (msg) {
+  static dump (msg) {
-    console(msg)
+    this.console(msg)
  }
-  function dumpln (msg) {
+  static dumpln (msg) {
-    dump(msg + '\n')
+    this.dump(`${msg}\n`)
  }
-  function log (msg) {
+  static log (msg) {
-    dumpln('/*L*/ ' + utils.script.safely(msg))
+    this.dumpln(`/*L*/ ${utils.script.safely(msg)}`)
  }
-  function info (msg) {
+  static info (msg) {
-    dumpln('/*L*/ /* ' + msg + ' */')
+    this.dumpln(`/*L*/ /* ${msg} */`)
  }
-  function error (msg) {
+  static error (msg) {
-    dumpln(color.red + msg + color.clear)
+    this.dumpln(color.red + msg + color.clear)
  }
-  function ok (msg) { // eslint-disable-line no-unused-vars
+  static ok (msg) { // eslint-disable-line no-unused-vars
-    dumpln(color.green + msg + color.green)
+    this.dumpln(color.green + msg + color.green)
  }
-  function JSError (msg) {
+  static JSError (msg) {
-    error('/* ERROR: ' + msg + ' */')
+    this.error(`/* ERROR: ${msg} */`)
  }
-  function comment (msg) {
+  static comment (msg) {
-    dumpln('/*L*/ // ' + msg)
+    this.dumpln(`/*L*/ // ${msg}`)
  }
-  function separator () {
+  static separator () {
-    dumpln(color.green + sep + color.clear)
+    this.dumpln(color.green + sep + color.clear)
  }
-  function traceback () {
+  static traceback () {
-    error('===[ Traceback ]')
+    this.error('===[ Traceback ] ===')
    try {
      throw new Error()
    } catch (e) {
-      dump(e.stack || e.stacktrace || '')
+      this.dump(e.stack || e.stacktrace || '')
    }
  }
    error('================')
 }
-  return {
+module.exports = logger
    console: console,
    dump: dump,
    log: log,
    info: info,
    error: error,
    JSError: JSError,
    dumpln: dumpln,
    comment: comment,
    separator: separator,
    traceback: traceback
  }
 })()
--- a/lib/logging/index.js
+++ b/lib/logging/index.js
@ -0,0 +1,15 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 class logging {
 	constructor () {
 	}
 	static get logger () {
        // Or: const {logger} = require('./logging')
 		return require('./console')
    }
 }
 module.exports = logging
--- a/lib/make/alignment.js
+++ b/lib/make/alignment.js
@ -2,17 +2,21 @@
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-make.alignment = {
+const make = require('../make')
-  horizontal: function () {
+const random = require('../random')
 class alignment extends make {
 	static horizontal () {
 		return random.item(['left', 'right', 'justify', 'center'])
-  },
+	}
-  vertical: function () {
+
 	static vertical () {
 		return random.item(['top', 'bottom', 'middle', 'baseline'])
-  },
+	}
-  any: function () {
+
-    return random.pick([
+	static any () {
-      this.horizontal,
+		return random.pick([this.horizontal, this.vertical])
      this.vertical
    ])
 	}
 }
 module.exports = alignment
--- a/lib/make/arrays.js
+++ b/lib/make/arrays.js
@ -2,8 +2,11 @@
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-make.arrays = {
+const make = require('../make')
-  filledArray: function (fn, limit) {
+const random = require('../random')
 class arrays extends make {
  static filledArray (fn, limit) {
    let array = []
    let size = limit || random.number(make.number.tiny()) + 1
@ -17,3 +20,5 @@ make.arrays = {
    return array
  }
 }
 module.exports = arrays
--- a/lib/make/colors.js
+++ b/lib/make/colors.js
@ -2,16 +2,19 @@
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-make.colors = {
+const make = require('../make')
-  any: function () {
+const random = require('../random')
    return random.pick([
      make.colors.rgb,
      make.colors.hsl,
      make.colors.keyword
    ])
  },
-  rgb: function () {
+class colors extends make {
  static any () {
    return random.pick([
      this.rgb,
      this.hsl,
      this.keyword
    ])
  }
  static rgb () {
    let values
    switch (random.number(4)) {
@ -36,9 +39,9 @@ make.colors = {
        // 8 char hex
        return '#' + random.hex(8)
    }
-  },
+  }
-  hsl: function () {
+  static hsl () {
    let values, opt
    switch (random.number(4)) {
@ -56,9 +59,9 @@ make.colors = {
        values = [random.number(255), '%' + random.number(255), '%' + random.number(255), random.float()]
        return 'hsl(' + values.join(',') + ')'
    }
-  },
+  }
-  keyword: function () {
+  static keyword () {
    return random.pick([
      'lime', 'red', 'blue', 'invert', 'currentColor', 'ActiveBorder', 'ActiveCaption',
      'AppWorkspace', 'Background', 'ButtonFace', 'ButtonHighlight', 'ButtonShadow',
@ -83,3 +86,5 @@ make.colors = {
    ])
  }
 }
 module.exports = colors
--- a/lib/make/command.js
+++ b/lib/make/command.js
@ -2,36 +2,40 @@
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-make.command = {
+const make = require('../make')
-  _data: {
+const random = require('../random')
-    'backcolor': function () { return make.colors.any() },
+
 class command extends make {
  static data () {
    return {
      'backcolor': () => make.colors.any(),
      'bold': null,
-    'contentReadOnly': function () { return random.bool() },
+      'contentReadOnly': () => random.bool(),
      'copy': null,
-    'createlink': function () { return make.uri.any() },
+      'createlink': () => make.uri.any(),
      'cut': null,
      'decreasefontsize': null,
      'delete': null,
-    'enableInlineTableEditing': function () { return random.bool() },
+      'enableInlineTableEditing': () => random.bool(),
-    'enableObjectResizing': function () { return random.bool() },
+      'enableObjectResizing': () => random.bool(),
-    'fontname': function () { return make.font.family() },
+      'fontname': () => make.font.family(),
-    'fontsize': function () { return make.font.relativeSize() },
+      'fontsize': () => make.font.relativeSize(),
      'formatblock': ['p', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'ol', 'ul', 'pre', 'address', 'blockquote', 'dl', 'div'],
      'forwarddelete': null,
-    'forecolor': function () { return make.colors.any() },
+      'forecolor': () => make.colors.any(),
      'gethtml': null,
      'heading': null,
-    'hilitecolor': function () { return make.colors.any() },
+      'hilitecolor': () => make.colors.any(),
      'increasefontsize': null,
      'indent': null,
-    'insertBrOnReturn': function () { return random.bool() },
+      'insertBrOnReturn': () => random.bool(),
      'inserthorizontalrule': null,
      // 'inserthtml': function () { },
      'insertlinebreak': null,
-    'insertimage': function () { return make.uri.any() },
+      'insertimage': () => make.uri.any(),
      'insertorderedlist': null,
      'insertparagraph': null,
-    'inserttext': function () { return make.text.any() },
+      'inserttext': () => make.text.any(),
      'insertunorderedlist': null,
      'italic': null,
      'justifycenter': null,
@ -44,17 +48,22 @@ make.command = {
      'removeformat': null,
      'selectall': null,
      'strikethrough': null,
-    'styleWithCSS': function () { return random.bool() },
+      'styleWithCSS': () => random.bool(),
      'subscript': null,
      'superscript': null,
      'underline': null,
      'undo': null,
      'unlink': null
  },
  name: function () {
    return random.item(Object.keys(this._data))
  },
  value: function (name) {
    return random.pick(this._data[name])
    }
  }
  static name () {
    return random.item(Object.keys(this.data()))
  }
  static value (value) {
    return random.pick(this.data()[name])
  }
 }
 module.exports = command
--- a/lib/make/crypto.js
+++ b/lib/make/crypto.js
@ -2,21 +2,35 @@
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-make.crypto = {
+const make = require('../make')
-  keyFormats: [
+const random = require('../random')
 class crypto extends make {
  static get keyFormats () {
    return [
      'raw',
      'spki',
      'pkcs8',
      'jwk'
-  ],
+    ]
-  randomKeyFormat: () => random.item(make.crypto.keyFormats),
+  }
-  keyTypes: [
+  static randomKeyFormat () {
    return random.item(this.keyFormats)
  }
  static get keyTypes () {
    return [
      'public',
      'private',
      'secret'
-  ],
+    ]
-  randomKeyType: () => random.item(make.crypto.keyTypes),
+  }
-  keyUsages: [
+  static randomKeyType () {
    return random.item(this.keyTypes)
  }
  static get keyUsages () {
    return [
      'encrypt',
      'decrypt',
      'sign',
@ -25,27 +39,51 @@ make.crypto = {
      'deriveBits',
      'wrapKey',
      'unwrapKey'
-  ],
+    ]
-  randomKeyUsage: () => random.subset(make.crypto.keyUsages),
+  }
-  curves: [
+
  static randomKeyUsage () {
    return random.subset(this.keyUsages)
  }
  static get curves () {
    return [
      'P-256',
      'P-384',
      'P-521'
-  ],
+    ]
-  randomCurve: () => random.item(make.crypto.curves),
+  }
-  jwkUsages: [
+
  static randomCurve (){
    return  random.item(this.curves)
  }
  static get jwkUsages () {
    return [
      'enc',
      'sig'
-  ],
+    ]
-  randomJwkUsage: () => random.subset(make.crypto.jwkUsages),
+  }
-  jwkKeyTypes: [
+
  static randomJwkUsage () {
    return random.subset(this.keyUsages)
  }
  static get jwkKeyTypes () {
    return [
      'oct',
      'RSA',
      'EC'
-  ],
+    ]
-  randomJwkKeyType: () => random.subset(make.crypto.jwkKeyTypes),
+  }
-  algorithmNames: {
+
  static randomJwkKeyType () {
    return random.subset(this.jwkKeyTypes)
  }
  static get algorithmNames () {
    // https://www.w3.org/TR/WebCryptoAPI/#algorithm-overview
    return {
      sign: [
        'RSASSA-PKCS1-v1_5',
        'RSA-PSS',
@ -138,10 +176,19 @@ make.crypto = {
        'SHA-384',
        'SHA-512'
      ]
-  },
+    }
-  randomAlgorithmName: (method) => random.item(make.crypto.algorithmNames[method]),
+  }
-  randomDigestName: () => random.item(make.crypto.algorithmNames.digest),
+
-  algorithms: {
+  static randomAlgorithmName (method) {
    return random.item(this.algorithmNames[method])
  }
  static randomDigestName () {
    return random.item(this.algorithmNames.digest)
  }
  static get algorithms () {
    return {
      /* (Unsupported as of 30/01/2017)
      -------------------------------
      |          | Firefox | Chrome |
@ -847,13 +894,21 @@ make.crypto = {
          pkcs8: {}
        }
      }
-  },
+    }
-  supportedAlgorithms: () => Object.keys(make.crypto.algorithms),
+  }
-  randomAlgorithm: () => {
+
  static supportedAlgorithms () {
    Object.keys(make.crypto.algorithms)
  }
  static randomAlgorithm () {
    return make.crypto.algorithms[random.item(Object.keys(make.crypto.algorithms))]
-  },
+  }
-  randomCandidate: (operation) => {
+
  static randomCandidate (operation) {
    // Find and return a random algorithm suitable for a given operation.
    return make.crypto.algorithms[make.crypto.randomAlgorithmName(operation)]
  }
 }
 module.exports = crypto
--- a/lib/make/datetime.js
+++ b/lib/make/datetime.js
@ -2,25 +2,34 @@
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-make.datetime = {
+const make = require('../make')
-  object: function () {
+const random = require('../random')
 class datetime extends make {
  static object () {
    switch (random.number(2)) {
      case 0:
        return new Date(new Date().getTime() + random.number())
      case 1:
        return new Date(new Date().getTime() - random.number())
    }
-  },
+  }
-  date: function () { // eslint-disable-line no-unused-vars
+
  static date () {
    return this.object().toDateString()
-  },
+  }
-  time: function () { // eslint-disable-line no-unused-vars
+
  static time () {
    return this.object().toTimeString()
-  },
+  }
-  iso: function () { // eslint-disable-line no-unused-vars
+
  static iso () {
    return this.object().toISOString()
-  },
+  }
-  epoch: function () { // eslint-disable-line no-unused-vars
+
  static epoch () {
    return Math.floor(this.object() / 1000)
  }
 }
 module.exports = datetime
--- a/lib/make/files.js
+++ b/lib/make/files.js
--- a/lib/make/fonts.js
+++ b/lib/make/fonts.js
@ -2,17 +2,23 @@
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-make.font = {
+const make = require('../make')
-  globalValue: function () {
+const random = require('../random')
 class font extends make {
  static globalValue () {
    return random.pick(['inherit', 'initial', 'unset'])
-  },
+  }
-  style: function () {
+
  static style () {
    return random.pick(['italic', 'normal', 'oblique', 'inherit'])
-  },
+  }
-  variant: function () {
+
  static variant () {
    return random.pick(['normal', 'small-caps', 'inherit'])
-  },
+  }
-  weight: function () {
+
  static weight () {
    return random.pick([
      /* standard */
      ['normal', 'bold'],
@ -21,8 +27,9 @@ make.font = {
      /* numeric values */
      [100, 200, 300, 400, 500, 600, 700, 800, 900]
    ])
-  },
+  }
-  size: function () {
+
  static size () {
    return random.pick([
      /* <absolute-size> values */
      ['xx-small', 'x-small', 'small', 'medium', 'large', 'x-large', 'xx-large'],
@ -33,25 +40,30 @@ make.font = {
      /* <percentage> values */
      make.unit.percent()
    ])
-  },
+  }
-  relativeSize: function () {
+
  static relativeSize () {
    let value = random.number(8)
    return random.item(['', '+', '-']) + value
-  },
+  }
-  genericFamily: function () {
+
  static genericFamily () {
    return random.pick(['serif', 'sans-serif', 'cursive', 'fantasy', 'monospace'])
-  },
+  }
-  familyName: function () {
+
  static familyName () {
    return random.pick(['Times New Roman', 'Arial', 'Courier', 'Helvetica'])
-  },
+  }
-  family: function () {
+
-    let s = random.pick(make.font.familyName)
+  static family () {
    let s = random.pick(this.familyName)
    if (random.chance(8)) {
-      s += ', ' + random.pick(make.font.genericFamily)
+      s += ', ' + random.pick(this.genericFamily)
    }
    return s
-  },
+  }
-  registeredFontFeatures: function () {
+
  static registeredFontFeatures () {
    return random.pick([
      'aalt', 'abvf', 'abvm', 'abvs', 'afrc', 'akhn', 'blwf', 'blwm', 'blws',
      'calt', 'case', 'ccmp', 'cfar', 'cjct', 'clig', 'cpct', 'cpsp', 'cswh',
@ -69,24 +81,27 @@ make.font = {
      'swsh', 'titl', 'tjmo', 'tnam', 'tnum', 'trad', 'twid', 'unic', 'valt',
      'vatu', 'vert', 'vhal', 'vjmo', 'vkna', 'vkrn', 'vpal', 'vrt2', 'zero'
    ])
-  },
+  }
-  font: function () {
+
  static font() {
    let s = ''
    if (random.chance(4)) {
-      s += random.pick(make.font.style) + ' '
+      s += random.pick(this.style) + ' '
    }
    if (random.chance(4)) {
-      s += random.pick(make.font.variant) + ' '
+      s += random.pick(this.variant) + ' '
    }
    if (random.chance(4)) {
-      s += random.pick(make.font.weight) + ' '
+      s += random.pick(this.weight) + ' '
    }
    if (random.chance(4)) {
      s += make.number.any() + '/'
    }
-    s += make.font.size()
+    s += this.size()
    s += ' '
-    s += make.font.family()
+    s += this.family()
    return s
  }
 }
 module.exports = font
--- a/lib/make/html.js
+++ b/lib/make/html.js
@ -1,11 +1,22 @@
-make.html = {
+/* This Source Code Form is subject to the terms of the Mozilla Public
-  tag: function () {
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 const make = require('../make')
 const random = require('../random')
 class html extends make {
  static tag () {
    return random.item(['a', 'abbr', 'acronym', 'address', 'applet', 'area', 'article', 'aside', 'audio', 'b', 'base', 'basefont', 'bdi', 'bdo', 'bgsound', 'big', 'blink', 'blockquote', 'body', 'br', 'button', 'canvas', 'caption', 'center', 'cite', 'code', 'col', 'colgroup', 'command', 'content', 'data', 'datalist', 'dd', 'del', 'details', 'dfn', 'dialog', 'dir', 'div', 'dl', 'dt', 'element', 'em', 'embed', 'fieldset', 'figcaption', 'figure', 'font', 'foo', 'footer', 'form', 'frame', 'frameset', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hgroup', 'hr', 'html', 'i', 'iframe', 'image', 'img', 'input', 'ins', 'isindex', 'kbd', 'keygen', 'label', 'legend', 'li', 'link', 'listing', 'main', 'map', 'mark', 'marquee', 'menu', 'menuitem', 'meta', 'meter', 'multicol', 'nav', 'nobr', 'noembed', 'noframes', 'noscript', 'object', 'ol', 'optgroup', 'option', 'output', 'p', 'param', 'picture', 'plaintext', 'pre', 'progress', 'q', 'rb', 'rp', 'rt', 'rtc', 'ruby', 's', 'samp', 'script', 'section', 'select', 'shadow', 'slot', 'small', 'source', 'spacer', 'span', 'strike', 'strong', 'style', 'sub', 'summary', 'sup', 'table', 'tbody', 'td', 'template', 'textarea', 'tfoot', 'th', 'thead', 'time', 'title', 'tr', 'track', 'tt', 'u', 'ul', 'var', 'video', 'wbr', 'xmp'])
-  },
+  }
-  attribute: function () { // eslint-disable-line no-unused-vars
+
  static attribute () {
    return random.item(['accept', 'accept-charset', 'accesskey', 'action', 'align', 'alt', 'async', 'autocomplete', 'autofocus', 'autoplay', 'autosave', 'bgcolor', 'border', 'buffered', 'challenge', 'charset', 'checked', 'cite', 'class', 'code', 'codebase', 'color', 'cols', 'colspan', 'content', 'contenteditable', 'contextmenu', 'controls', 'coords', 'crossorigin', 'data', 'data-*', 'datetime', 'default', 'defer', 'dir', 'dirname', 'disabled', 'download', 'draggable', 'dropzone', 'enctype', 'for', 'form', 'formaction', 'headers', 'height', 'hidden', 'high', 'href', 'hreflang', 'http-equiv', 'icon', 'id', 'integrity', 'ismap', 'itemprop', 'keytype', 'kind', 'label', 'lang', 'language', 'list', 'loop', 'low', 'manifest', 'max', 'maxlength', 'minlength', 'media', 'method', 'min', 'multiple', 'muted', 'name', 'novalidate', 'open', 'optimum', 'pattern', 'ping', 'placeholder', 'poster', 'preload', 'radiogroup', 'readonly', 'rel', 'required', 'reversed', 'rows', 'rowspan', 'sandbox', 'scope', 'scoped', 'seamless', 'selected', 'shape', 'size', 'sizes', 'slot', 'span', 'spellcheck', 'src', 'srcdoc', 'srclang', 'srcset', 'start', 'step', 'style', 'summary', 'tabindex', 'target', 'title', 'type', 'usemap', 'value', 'width'])
-  },
+  }
-  interfaceName: function () { // eslint-disable-line no-unused-vars
+
  static interfaceName () {
    return random.pick(['HTMLBRElement', 'HTMLTableSectionElement', 'HTMLDataListElement', 'HTMLTableElement', 'HTMLOListElement', 'HTMLFontElement', 'HTMLMapElement', 'HTMLButtonElement', 'HTMLFrameSetElement', 'HTMLDataElement', 'HTMLOptGroupElement', 'HTMLAnchorElement', 'HTMLLinkElement', 'HTMLObjectElement', 'HTMLHeadElement', 'HTMLProgressElement', 'HTMLFrameElement', 'HTMLTimeElement', 'HTMLTableCaptionElement', 'HTMLDivElement', 'HTMLDListElement', 'HTMLBodyElement', 'HTMLImageElement', 'HTMLTableRowElement', 'HTMLScriptElement', 'HTMLInputElement', 'HTMLMeterElement', 'HTMLFieldSetElement', 'HTMLHtmlElement', 'HTMLStyleElement', 'HTMLDetailsElement', 'HTMLTrackElement', 'HTMLBaseElement', 'HTMLTableColElement', 'HTMLSourceElement', 'HTMLPictureElement', 'HTMLSelectElement', 'HTMLLegendElement', 'HTMLHRElement', 'HTMLModElement', 'HTMLTemplateElement', 'HTMLAreaElement', 'HTMLFormElement', 'HTMLEmbedElement', 'HTMLSpanElement', 'HTMLParagraphElement', 'HTMLIFrameElement', 'HTMLTableCellElement', 'HTMLElement', 'HTMLMenuElement', 'HTMLTextAreaElement', 'HTMLHeadingElement', 'HTMLCanvasElement', 'HTMLOutputElement', 'HTMLQuoteElement', 'HTMLOptionElement', 'HTMLLIElement', 'HTMLAudioElement', 'HTMLMenuItemElement', 'HTMLParamElement', 'HTMLUListElement', 'HTMLLabelElement', 'HTMLDirectoryElement', 'HTMLTitleElement', 'HTMLPreElement', 'HTMLMetaElement', 'HTMLVideoElement'])
  }
 }
 module.exports = html
--- a/lib/make/index.js
+++ b/lib/make/index.js
@ -0,0 +1,91 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 class make {
 	static get number () {
 		return require('./numbers')
 	}
 	static get alignment () {
 		return require('./alignment')
 	}
 	static get arrays () {
 		return require('./arrays')
 	}
 	static get colors () {
 		return require('./colors')
 	}
 	static get command () {
 		return require('./command')
 	}
 	static get crypto () {
 		return require('./crypto')
 	}
 	static get datetime () {
 		return require('./datetime')
 	}
 	static get files () {
 		return require('./files')
 	}
 	static get font () {
 		return require('./fonts')
 	}
 	static get html () {
 		return require('./html')
 	}
 	static get mime () {
 		return require('./mime')
 	}
 	static get network () {
 		return require('./network')
 	}
 	static get shaders () {
 		return require('./shaders')
 	}
 	static get style () {
 		return require('./style')
 	}
 	static get text () {
 		return require('./text')
 	}
 	static get time () {
 		return require('./time')
 	}
 	static get typed () {
 		return require('./typed')
 	}
 	static get types () {
 		return require('./types')
 	}
 	static get unit () {
 		return require('./units')
 	}
 	static get uri () {
 		return require('./uri')
 	}
 	static get webgl () {
 		return require('./webgl')
 	}
 }
 module.exports = make
--- a/lib/make/init.js
+++ b/lib/make/init.js
@ -1 +0,0 @@
 var make = {} // eslint-disable-line no-unused-vars
--- a/lib/make/mime.js
+++ b/lib/make/mime.js
@ -2,18 +2,21 @@
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-make.mime = {
+const make = require('../make')
-  any: function () {
+const random = require('../random')
    return random.pick([
      make.mime.standard,
      make.mime.xml,
      make.mime.image,
      make.mime.media,
      make.mime.form
    ])
  },
-  standard: function () {
+class mime extends make {
  static any () {
    return random.pick([
      this.standard,
      this.xml,
      this.image,
      this.media,
      this.form
    ])
  }
  static standard () {
    return random.pick([
      'text/html',
      'text/html; charset=utf-8',
@ -25,9 +28,9 @@ make.mime = {
      'application/x-shockwave-flash',
      'application/x-test'
    ])
-  },
+  }
-  xml: function () {
+  static xml () {
    return random.pick([
      'application/xml',
      'text/xml',
@ -38,9 +41,9 @@ make.mime = {
      'application/rdf+xml',
      'application/xslt+xml'
    ])
-  },
+  }
-  image: function () {
+  static image () {
    return random.pick([
      'image/jpeg',
      'image/gif',
@ -48,9 +51,9 @@ make.mime = {
      'image/mng',
      'image/*'
    ])
-  },
+  }
-  media: function () {
+  static media () {
    return random.pick([
      'audio/mpeg',
      'audio/ogg',
@ -60,9 +63,9 @@ make.mime = {
      'video/mp4',
      'video/mp4; codecs="avc1.42E01E, mp4a.40.2"'
    ])
-  },
+  }
-  form: function () {
+  static form () {
    return random.pick([
      'application/x-www-form-urlencoded',
      'multipart/form-data',
@ -70,3 +73,5 @@ make.mime = {
    ])
  }
 }
 module.exports = mime
--- a/lib/make/network.js
+++ b/lib/make/network.js
@ -2,8 +2,12 @@
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-make.network = {
+const make = require('../make')
-  sdp () {
+const random = require('../random')
 const utils = require('../utils')
 class network extends make {
  static sdp () {
    // session description protocol template
    return [
      'v=0',
@ -37,8 +41,9 @@ make.network = {
      'a=candidate:0 1 UDP 2113601791 192.168.129.33 65080 typ host',
      'a=candidate:0 2 UDP 2113601790 192.168.129.33 62658 typ host'
    ].join('\n')
-  },
+  }
-  IceCandidate () {
+
  static IceCandidate () {
    // https://tools.ietf.org/html/rfc5245#section-15
    // candidate=
    return utils.block.block([
@ -51,7 +56,7 @@ make.network = {
      ' ',
      random.pick([make.number.any]),
      ' ',
-      random.pick([make.network.goodHostnames]),
+      random.pick([this.goodHostnames]),
      ' ',
      random.pick([56187, make.number.any]),
      ' ',
@ -64,15 +69,16 @@ make.network = {
          ' ',
          random.pick(['raddr']),
          ' ',
-          random.pick([make.network.goodHostnames]),
+          random.pick([this.goodHostnames]),
          ' ',
          random.pick(['rport']),
          random.use([utils.block.block([' ', make.number.any])])
        ])
      ])
    ])
-  },
+  }
-  SdpMid () {
+
  static SdpMid () {
    // m=
    return utils.block.block([
      random.pick(['application', 'video', 'audio']),
@ -83,17 +89,18 @@ make.network = {
      ' ',
      make.number.any
    ])
-  },
+  }
-  Turn () {
+
  static Turn () {
    // https://tools.ietf.org/html/rfc7065#section-3.1
    return utils.block.block([
      // scheme
-      random.pick(make.network.PeerConnectionProtocols),
+      random.pick(this.PeerConnectionProtocols),
      ':',
      // turn-host
      random.pick([
-        make.text.any,
+        this.any,
-        make.network.hostname
+        this.hostname
      ]),
      // turn-port
      random.use([utils.block.block([':', make.number.any])]),
@ -103,17 +110,20 @@ make.network = {
      '=',
      random.pick(['udp', 'tcp', make.text.any])
    ])
-  },
+  }
-  PeerConnectionProtocols () {
+
  static PeerConnectionProtocols () {
    return ['turn', 'turns', 'stun', 'stuns']
-  },
+  }
-  randomIPv4 () {
+
  static randomIPv4 () {
    return random.pick([random.number(255), make.number.any]) + '.' +
      random.pick([random.number(255), make.number.any]) + '.' +
      random.pick([random.number(255), make.number.any]) + '.' +
      random.pick([random.number(255), make.number.any])
-  },
+  }
-  randomIPv6 () {
+
  static randomIPv6 () {
    let parts = []
    for (let i = 0; i < 8; i++) {
@ -121,26 +131,30 @@ make.network = {
    }
    return parts.join(':')
-  },
+  }
-  iceServer () {
+
  static iceServer () {
    return random.pick([
      'stun:23.21.150.121'
    ])
-  },
+  }
-  dtmf () {
+
  static dtmf () {
    return random.subset([
      '*', '#',
      'A', 'B', 'C', 'D',
      '0', '1', '2', '3', '4', '5', '6', '7', '8', '9'
    ], make.number.range()).join('')
-  },
+  }
-  goodHostnames () {
+
  static goodHostnames () {
    return [
      '0.0.0.0',
      '127.0.0.1:8080'
    ]
-  },
+  }
-  badHostnames () {
+
  static badHostnames () {
    return [
      'google.org:8080',
      '::1',
@ -154,35 +168,40 @@ make.network = {
      '2001:db8::1:2',
      '2001:db8::1:1:1:1:1'
    ]
-  },
+  }
-  hostname () {
+
  static hostname () {
    return random.pick([
      this.randomIPv4,
      this.randomIPv6,
      this.goodHostnames,
      this.badHostnames
    ])
-  },
+  }
-  port () {
+
  static port () {
    return random.pick([80, 443, 21, 23, 9310])
-  },
+  }
-  hash () {
+
  static hash () {
    return random.pick([
      '',
      '#',
      '#main-content',
      () => '#' + make.text.any()
    ])
-  },
+  }
-  path () {
+
  static path () {
    return random.pick([
      '',
      '/',
      '/index.html',
      () => '/' + make.text.any()
    ])
-  },
+  }
-  protocol () {
+
  static protocol () {
    return random.pick([
      'http',
      'https',
@ -191,16 +210,18 @@ make.network = {
      'chrome',
      'resource'
    ]) + ':'
-  },
+  }
-  search () {
+
  static search () {
    return random.pick([
      '',
      '?',
      '?foo=bar',
      () => '?' + make.text.any()
    ])
-  },
+  }
-  randomBitmask (list) {
+
  static randomBitmask (list) {
    if (list.length <= 1) {
      return list.join('')
    }
@ -212,3 +233,5 @@ make.network = {
    return mask
  }
 }
 module.exports = network
--- a/lib/make/numbers.js
+++ b/lib/make/numbers.js
@ -2,11 +2,15 @@
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-make.number = {
+const make = require('../make')
-  bool: function () {
+const random = require('../random')
 class number extends make {
  static bool () {
    return random.bool()
-  },
+  }
-  float: function () {
+
  static float () {
    let n
    if (random.chance(32)) {
      switch (random.number(4)) {
@ -30,43 +34,52 @@ make.number = {
        n = random.float()
    }
    return n
-  },
+  }
-  range: function () {
+
-    return random.pick([1, 2, 3, 4, 6, 8, 16, 32, 64, make.number.tiny])
+  static range () {
-  },
+    return random.pick([1, 2, 3, 4, 6, 8, 16, 32, 64, number.tiny])
-  frange: function (min, max, precision) {
+  }
  static frange (min, max, precision) {
    let x = Math.random() * (min - max) + max
    if (precision) {
      let power = Math.pow(10, precision || 0)
      x = Math.round(x * power) / power
    }
    return x
-  },
+  }
-  tiny: function () {
+
  static tiny () {
    return Math.pow(2, random.number(12))
-  },
+  }
-  unsigned: function () {
+
  static unsigned () {
    if (random.chance(2)) {
-      return Math.abs(make.number.any())
+      return Math.abs(number.any())
    }
    return Math.pow(2, random.number(random.number(65))) + random.number(3) - 1
-  },
+  }
-  even: function (number) {
+
  static even(number) {
    return number % 2 === 1 ? ++number : number
-  },
+  }
-  interesting: function () {
+
  static interesting () {
    return random.choose([
      [10, [-128, -1, 0, 1, 16, 32, 64, 100, 127]],
      [7, [-32768, -129, 128, 255, 256, 512, 1000, 1024, 4096, 32767]],
      [1, [-2147483648, -100663046, -32769, 32768, 65535, 65536, 100663045, 2147483647]]
    ])
-  },
+  }
-  any: function () {
+
  static any () {
    let value = random.choose([
-      [10, make.number.float],
+      [10, number.float],
-      [10, [make.number.range, make.number.tiny]],
+      [10, [number.range, number.tiny]],
-      [1, make.number.unsigned]
+      [1, number.unsigned]
    ])
    return random.chance(10) ? -value : value
  }
 }
 module.exports = number
--- a/lib/make/shaders.js
+++ b/lib/make/shaders.js
@ -2,8 +2,12 @@
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-make.shaders = {
+const make = require('../make')
-  fragment1: [
+const random = require('../random')
 class shaders extends make {
  static get fragment1 () {
    return [
      [
        '#ifdef GL_ES',
        'precision mediump float;',
@ -22,8 +26,11 @@ make.shaders = {
        'gl_FragColor = vec4(texelColor.rgb * vLighting, texelColor.a);',
        '}'
      ]
-  ],
+    ]
-  vertex1: [
+  }
  static get vertex1() {
    return [
      [
        'attribute vec4 aVertex;',
        'attribute vec4 aColor;',
@ -53,8 +60,11 @@ make.shaders = {
        'vLighting = ambientLight + (directionalLightColor * directional);',
        '}'
      ]
-  ],
+    ]
-  fragment2: [
+  }
  static get fragment2() {
    return [
      [
        'varying highp vec2 vTextureCoord;',
        'varying highp vec3 vLighting;',
@ -83,8 +93,11 @@ make.shaders = {
        'gl_FragData[2]=vec4(specularFactor,specularHardness*0.1,0.0,1.0);',
        '}'
      ]
-  ],
+    ]
-  vertex2: [
+  }
  static get vertex2() {
    return [
      [
        'attribute highp vec3 aVertexNormal;',
        'attribute highp vec3 aVertexPosition;',
@ -127,8 +140,10 @@ make.shaders = {
        'varyingUV = vertexUV;',
        '}'
      ]
-  ],
+    ]
-  shaderPair: function (v, f) {
+  }
  static shaderPair (v, f) {
    let i = random.number(v.length)
    return {
      vertex: utils.common.quote(v[i].join(' ')),
@ -136,3 +151,5 @@ make.shaders = {
    }
  }
 }
 module.exports = shaders
--- a/lib/make/style.js
+++ b/lib/make/style.js
@ -1,5 +1,12 @@
-make.style = {
+/* This Source Code Form is subject to the terms of the Mozilla Public
-  pseudoElement: function () {
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 const make = require('../make')
 const random = require('../random')
 class style extends make {
  static pseudoElement () {
    return random.item([
      '::after',
      '::before',
@ -14,3 +21,5 @@ make.style = {
      '::grammar-error'])
  }
 }
 module.exports = style
--- a/lib/make/text.js
+++ b/lib/make/text.js
@ -2,29 +2,36 @@
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-make.text = {
+const make = require('../make')
-  lineEnd: function () {
+const random = require('../random')
 class text extends make {
  static lineEnd () {
    return random.pick([
      '\n', '\r', '\r\n', '\n\r'
    ])
-  },
+  }
-  controlChar: function () {
+
  static controlChar () {
    return random.pick([
      '\b', '\t', '\n', '\v', '\f', '\r', '\0', '\c', '\a', '\e' // eslint-disable-line no-useless-escape
    ])
-  },
+  }
-  token: function () {
+
  static token () {
    return random.pick([
      '*', '+', '%', '-', '!', '^', ':', '|', '&', '<', '>', '.', '"',
      '#', ' ', ';', ',', '{', '}', '(', ')', '[', ']', '/', '\\', '/*', '*/'
    ])
-  },
+  }
-  charset: function () {
+
  static charset () {
    return random.pick([
      'UTF-8', 'ISO-8859-1'
    ])
-  },
+  }
-  language: function () {
+
  static language () {
    return random.pick([
      // special casing for i, I, dotted/dotless variants
      ['tr', 'az'],
@ -39,8 +46,9 @@ make.text = {
      // Seen in mxr
      ['en-US', 'fr', 'fra', 'de', 'ru', 'en-us', 'is-IS', 'xyzzy']
    ])
-  },
+  }
-  layoutCharCodes: function () {
+
  static layoutCharCodes () {
    return random.pick([
      0,      // null
      160,    // non-breaking space
@ -107,8 +115,9 @@ make.text = {
      0x2064, // mathematical invisible separator
      0x2044  // fraction slash character
    ])
-  },
+  }
-  bidiCharCodes: function () {
+
  static bidiCharCodes () {
    return random.pick([
      0x0660, // START_HINDI_DIGITS
      0x0669, // END_HINDI_DIGITS
@ -119,9 +128,10 @@ make.text = {
      0x06f0, // START_FARSI_DIGITS
      0x06f9 // END_FARSI_DIGITS
    ])
-  },
+  }
  // http://www.unicode.org/Public/6.0.0/ucd/UnicodeData.txt
-  unicodeCombiningCharacters: function () {
+  static unicodeCombiningCharacters () {
    return random.item([
      [0x0300, 0x036F], // Combining Diacritical Marks
      [0x0483, 0x0489],
@ -142,14 +152,16 @@ make.text = {
      [0x1D1AA, 0x1D1AD],
      [0x1D242, 0x1D244]
    ])
-  },
+  }
-  unicodeBMP: function () {
+
  static unicodeBMP () {
    return random.item([
      // BMP = Basic Multilingual Plane
      [0x0000, 0xFFFF]
    ])
-  },
+  }
-  unicodeSMP: function () {
+
  static unicodeSMP () {
    return random.item([
      // SMP = Supplementary Multilingual Plane
      [0x10000, 0x13FFF],
@ -158,38 +170,44 @@ make.text = {
      [0x1D000, 0x1DFFF],
      [0x1F000, 0x1FFFF]
    ])
-  },
+  }
-  unicodeSIP: function () {
+
  static unicodeSIP () {
    return random.item([
      // SIP = Supplementary Ideographic Plane
      [0x20000, 0x2BFFF],
      [0x2F000, 0x2FFFF]
    ])
-  },
+  }
-  unicodeSSP: function () {
+
  static unicodeSSP () {
    return random.item([
      // SSP = Supplementary Special-purpose Plane
      [0xE0000, 0xE0FFF]
    ])
-  },
+  }
-  assignmentOperator: function () {
+
  static assignmentOperator () {
    return random.pick([
      '=', '+=', '-=', '*=', '/=', '%=', '**=', '<<=', '>>=', '>>>=', '&=', '^=', '|='
    ])
-  },
+  }
-  arithmeticOperator: function () {
+
  static arithmeticOperator () {
    return random.pick([
      '%', '-', '+', '*', '/'
    ])
-  },
+  }
-  currency: function () {
+
  static currency () {
    return random.pick([
      // https://en.wikipedia.org/wiki/ISO_4217
      'USD', 'USS', 'USN', 'EUR', 'CHF', 'GBP', 'XAG', 'XBA', 'XBB', 'XBC',
      'XBD', 'XSU', 'XTS', 'XXX'
    ])
-  },
+  }
-  fromBlocks: function (set, maxlen) {
+
  static fromBlocks (set, maxlen) {
    let s = ''
    for (let i = 0; i < random.number(maxlen || 255); i++) {
@ -197,21 +215,24 @@ make.text = {
    }
    return s
-  },
+  }
-  quotedString: function () {
+
-    return utils.common.quote(make.text.any())
+  static quotedString () {
-  },
+    return utils.common.quote(this.any())
-  chars: function () {
+  }
  static chars () {
    return random.pick([
-      make.text.controlChar,
+      this.controlChar,
-      make.text.token,
+      this.token,
-      make.text.assignmentOperator,
+      this.assignmentOperator,
-      make.text.arithmeticOperator,
+      this.arithmeticOperator,
-      String.fromCharCode(make.text.layoutCharCodes()),
+      String.fromCharCode(this.layoutCharCodes()),
-      String.fromCharCode(make.text.bidiCharCodes())
+      String.fromCharCode(this.bidiCharCodes())
    ])
-  },
+  }
-  any: function () {
+
  static any () {
    // Generate a string compromised of random individual characters
    // This might be too slow to used for all 'texts' uses
    let s = ''
@ -223,3 +244,5 @@ make.text = {
    return s
  }
 }
 module.exports = text
--- a/lib/make/time.js
+++ b/lib/make/time.js
@ -2,13 +2,19 @@
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-make.time = {
+const make = require('../make')
-  unit: function () {
+const random = require('../random')
 class time extends make {
  static unit () {
    return random.pick([
      's', 'ms'
    ])
-  },
+  }
-  any: function () {
+
-    return make.number.any() + make.time.unit()
+  static any () {
    return make.number.any() + this.unit()
  }
 }
 module.exports = time
--- a/lib/make/typed.js
+++ b/lib/make/typed.js
@ -2,64 +2,71 @@
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-make.typed = {
+const make = require('../make')
-  byte: function (limit = null) {
+const random = require('../random')
 class typed extends make {
  static byte (limit = null) {
    // [-128, 127]
    let value = (limit !== null) ? random.number(limit) : random.number(129)
    value = random.chance(10) ? -value : value
    return 'new Uint8Array([' + value + '])[0]'
-  },
+  }
-  octet: function (limit = null) {
+
  static octet (limit = null) {
    // [0, 255]
    let value = (limit !== null) ? random.number(limit) : random.number(256)
    return 'new Int8Array([' + value + '])[0]'
-  },
+  }
-  short: function (limit = null) {
+
  static short (limit = null) {
    // [-32768, 32767]
    let value = (limit !== null) ? random.number(limit) : random.number(32769)
    value = random.chance(10) ? -value : value
    return 'new Int16Array([' + value + '])[0]'
-  },
+  }
-  unsignedShort: function (limit = null) {
+
  static unsignedShort (limit = null) {
    // [0, 65535]
    let value = (limit !== null) ? random.number(limit) : random.number(65535)
    return 'new Uint16Array([' + value + '])[0]'
-  },
+  }
-  long: function (limit = null) {
+
  static long (limit = null) {
    // [-2147483648, 2147483647]
    let value = (limit !== null) ? random.number(limit) : random.number(2147483649)
    value = random.chance(10) ? -value : value
    return 'new Int32Array([' + value + '])[0]'
-  },
+  }
-  unsignedLong: function (limit = null) {
+
  static unsignedLong (limit = null) {
    // [0, 4294967295]
    let value = (limit !== null) ? random.number(limit) : random.number(4294967296)
    return 'new Uint32Array([' + value + '])[0]'
-  },
+  }
-  // ToDo: Add support for longlong and ulonglong
+
-  /*
+  static float (limit = null) {
   longLong: function () {},
   unsignedLongLong: function () {},
   */
  float: function (limit = null) {
    let base = (limit !== null) ? random.number(limit) : random.number()
    let value = random.chance(10) ? -(base + random.float()) : (base + random.float())
    return 'new Float32Array([' + value + '])[0]'
-  },
+  }
-  unrestrictedFloat: function (limit = null) {
+
  static unrestrictedFloat (limit = null) {
    if (random.chance(100)) {
      return random.pick([NaN, +Infinity, -Infinity])
    } else {
      let base = (limit !== null) ? random.number(limit) : random.number()
      return 'new Float32Array([' + (base + random.float()) + '])[0]'
    }
-  },
+  }
-  double: function (limit = null) {
+
  static double (limit = null) {
    let base = (limit !== null) ? random.number(limit) : random.number()
    let value = random.chance(10) ? -(base + random.float()) : (base + random.float())
    return 'new Float64Array([' + value + '])[0]'
-  },
+  }
-  unrestrictedDouble: function (limit = null) {
+
  static unrestrictedDouble (limit = null) {
    if (random.chance(100)) {
      return random.pick([NaN, +Infinity, -Infinity])
    } else {
@ -67,8 +74,9 @@ make.typed = {
      let value = random.chance(10) ? -(base + random.float()) : (base + random.float())
      return 'new Float64Array([' + value + '])[0]'
    }
-  },
+  }
-  any: function () {
+
  static any () {
    return random.choose([
      [1, [this.byte, this.octet]],
      [1, [this.short, this.unsignedShort]],
@ -77,16 +85,19 @@ make.typed = {
      [1, [this.double, this.unrestrictedDouble]],
      [1, [make.number.range, make.number.tiny]]
    ])
-  },
+  }
-  arrayBuffer: function (byteLength = null) {
+
  static arrayBuffer (byteLength = null) {
    let length = (byteLength !== null) ? byteLength : this.unsignedShort()
    return 'new ArrayBuffer(' + length + ')'
-  },
+  }
-  dataView: function (byteLength = null) {
+
  static dataView (byteLength = null) {
    let length = (byteLength !== null) ? byteLength : this.unsignedShort()
    return 'new DataView(' + this.arrayBuffer(length) + ')'
-  },
+  }
-  typedArray: function (byteLength = null) {
+
  static typedArray (byteLength = null) {
    let length = (byteLength !== null) ? byteLength : this.unsignedShort()
    let arrType = random.item([
      'Int8', 'Uint8', 'Uint8Clamped',
@ -103,8 +114,9 @@ make.typed = {
      default:
        return method + '(' + length + ')'
    }
-  },
+  }
-  bufferSource: function () {
+
  static bufferSource () {
    switch (random.number(4)) {
      case 0:
        return this.arrayBuffer()
@ -115,3 +127,5 @@ make.typed = {
    }
  }
 }
 module.exports = typed
--- a/lib/make/types.js
+++ b/lib/make/types.js
@ -2,8 +2,11 @@
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-make.types = {
+const make = require('../make')
-  random: function () {
+const random = require('../random')
 class types extends make {
  static random () {
    return random.item([
      'true',
      'null',
@ -16,3 +19,5 @@ make.types = {
    ])
  }
 }
 module.exports = types
--- a/lib/make/units.js
+++ b/lib/make/units.js
@ -2,16 +2,23 @@
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-make.unit = {
+const make = require('../make')
-  unit: function () {
+const random = require('../random')
 class unit extends make {
  static unit () {
    return random.pick([
      'px', 'em', 'ex', 'ch', 'rem', 'mm', 'cm', 'in', 'pt', 'pc', '%'
    ])
-  },
+  }
-  length: function () {
+
  static length () {
    return make.number.any() + make.unit.unit()
-  },
+  }
-  percent: function () {
+
  static percent () {
    return make.number.any() + '%'
  }
 }
 module.exports = unit
--- a/lib/make/uri.js
+++ b/lib/make/uri.js
@ -2,17 +2,20 @@
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-make.uri = {
+const make = require('../make')
-  problematic: function () {
+const random = require('../random')
 class uri extends make {
  static problematic () {
    return random.item([
      'aim:yaz', // Often triggers an 'external protocol request' dialog
      'foop:yaz', // Often triggers an unknown protocol
      'about:memory', // Content is not allowed to link or load
      'ws://localhost/' // WebSocket protocol
    ])
-  },
+  }
-  standard: function () {
+  static standard () {
    return random.item([
      'about:blank',
      'about:srcdoc',
@ -29,17 +32,17 @@ make.uri = {
      'ftp://localhost:6/',
      'http://localhost:25/'
    ])
-  },
+  }
-  namespace: function () {
+  static namespace () {
    return random.item([
      'http://www.w3.org/1999/xhtml',
      'http://www.w3.org/2000/svg',
      'http://www.w3.org/1998/Math/MathML'
    ])
-  },
+  }
-  any: function () {
+  static any () {
    return random.choose([
      [1, this.problematic],
      [10, this.standard],
@ -48,3 +51,5 @@ make.uri = {
    ])
  }
 }
 module.exports = uri
--- a/lib/make/webgl.js
+++ b/lib/make/webgl.js
@ -2,8 +2,12 @@
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-make.webgl = {
+const make = require('../make')
-  internalFormat: {
+const random = require('../random')
 class webgl extends make {
  static get internalFormat () {
    return {
      'RGB': {format: 'RGB', type: ['UNSIGNED_BYTE', 'UNSIGNED_SHORT_5_6_5']},
      'RGBA': {format: 'RGBA', type: ['UNSIGNED_BYTE', 'UNSIGNED_SHORT_4_4_4_4', 'UNSIGNED_SHORT_5_5_5_1']},
      'LUMINANCE_ALPHA': {format: 'LUMINANCE_ALPHA', type: ['UNSIGNED_BYTE']},
@ -33,14 +37,17 @@ make.webgl = {
      'RGBA16F': {format: 'RGBA', type: ['HALF_FLOAT', 'FLOAT']},
      'RGBA32F': {format: 'RGBA', type: ['FLOAT']},
      'RGBA8UI': {format: 'RGBA_INTEGER', type: ['UNSIGNED_BYTE']}
-  },
+    }
-  WebGLFormat: () => {
+  }
-    let internalformat = random.item(Object.keys(make.webgl.internalFormat))
+
-    let format = make.webgl.internalFormat[internalformat].format
+  static WebGLFormat () {
-    let type = random.item(make.webgl.internalFormat[internalformat].type)
+    let internalformat = random.item(Object.keys(this.internalFormat))
    let format = this.internalFormat[internalformat].format
    let type = random.item(this.internalFormat[internalformat].type)
    return [internalformat, format, type]
-  },
+  }
-  textureSources: () => {
+
  static textureSources () {
    let sources = [
      'HTMLCanvasElement',
      'HTMLImageElement',
@ -48,30 +55,35 @@ make.webgl = {
      'ImageData'
    ]
    return random.item(sources)
-  },
+  }
-  parseUniforms: (shader) => {
+
  static parseUniforms (shader) {
    let names = []
    let result = shader.match(/uniform .* (\w+)(?=;)/gm)
    if (result) {
      result.forEach((v) => names.push(v.split(' ').pop()))
    }
    return names
-  },
+  }
-  parseAttributes: (shader) => {
+
  static parseAttributes (shader) {
    let names = []
    let result = shader.match(/attribute .* (\w+)(?=;)/gm)
    if (result) {
      result.forEach((v) => names.push(v.split(' ').pop()))
    }
    return names
-  },
+  }
-  parseFrag: (shader) => {
+
  static parseFrag (shader) {
    return shader.match(/(gl_Frag[^[ =]+)/gm)
-  },
+  }
-  randomBitmask: () => {
+
  static randomBitmask () {
    return parseInt((random.subset([1, 0], 8).join('')))
-  },
+  }
-  randomBufferTarget: (isWebGL2) => {
+
  static randomBufferTarget (isWebGL2) {
    let target = [
      'ARRAY_BUFFER',
      'ELEMENT_ARRAY_BUFFER'
@ -87,8 +99,9 @@ make.webgl = {
      ])
    }
    return random.item(target)
-  },
+  }
-  randomTexParameter: (isWebGL2) => {
+
  static randomTexParameter (isWebGL2) {
    let pname = [
      'TEXTURE_MAG_FILTER',
      'TEXTURE_MIN_FILTER',
@ -107,8 +120,9 @@ make.webgl = {
      ])
    }
    return random.item(pname)
-  },
+  }
-  randomTexParameterValue: (isWebGL2) => {
+
  static randomTexParameterValue (isWebGL2) {
    let pnameparam = {
      'TEXTURE_MAG_FILTER': [
        'LINEAR',
@ -174,8 +188,9 @@ make.webgl = {
    let pname = random.item(Object.keys(pnameparam))
    let param = random.item(pnameparam[pname])
    return [pname, param]
-  },
+  }
-  randomBlendMode: (isWebGL2) => {
+
  static randomBlendMode (isWebGL2) {
    let mode = [
      'FUNC_ADD',
      'FUNC_SUBTRACT',
@ -188,8 +203,9 @@ make.webgl = {
      ])
    }
    return random.item(mode)
-  },
+  }
-  randomBlendFactor: (isWebGL2) => {
+
  static randomBlendFactor (isWebGL2) {
    let factor = [
      'ZERO',
      'ONE',
@ -208,16 +224,18 @@ make.webgl = {
      'SRC_ALPHA_SATURATE'
    ]
    return random.item(factor)
-  },
+  }
-  randomFace: (isWebGL2) => {
+
  static randomFace (isWebGL2) {
    let mode = [
      'FRONT',
      'BACK',
      'FRONT_AND_BACK'
    ]
    return random.item(mode)
-  },
+  }
-  randomTexImage2DTarget: (isWebGL2) => {
+
  static randomTexImage2DTarget (isWebGL2) {
    let target = [
      'TEXTURE_2D',
      'TEXTURE_CUBE_MAP_POSITIVE_X',
@ -228,8 +246,9 @@ make.webgl = {
      'TEXTURE_CUBE_MAP_NEGATIVE_Z'
    ]
    return random.item(target)
-  },
+  }
-  randomTextureTarget: (isWebGL2) => {
+
  static randomTextureTarget (isWebGL2) {
    let target = [
      'TEXTURE_2D',
      'TEXTURE_CUBE_MAP'
@ -241,8 +260,9 @@ make.webgl = {
      ])
    }
    return random.item(target)
-  },
+  }
-  randomFunc: (isWebGL2) => {
+
  static randomFunc (isWebGL2) {
    let func = [
      'NEVER',
      'LESS',
@ -254,8 +274,9 @@ make.webgl = {
      'ALWAYS'
    ]
    return random.item(func)
-  },
+  }
-  randomCap: (isWebGL2) => {
+
  static randomCap (isWebGL2) {
    let cap = [
      'BLEND',
      'CULL_FACE',
@ -273,8 +294,9 @@ make.webgl = {
      ])
    }
    return random.item(cap)
-  },
+  }
-  randomPrimitive: (isWebGL2) => {
+
  static randomPrimitive (isWebGL2) {
    let mode = [
      'POINTS',
      'LINE_STRIP',
@ -285,8 +307,9 @@ make.webgl = {
      'TRIANGLES'
    ]
    return random.item(mode)
-  },
+  }
-  randomTextureAttachment: (isWebGL2) => {
+
  static randomTextureAttachment (isWebGL2) {
    let attachment = [
      'COLOR_ATTACHMENT0',
      'DEPTH_ATTACHMENT',
@ -299,8 +322,9 @@ make.webgl = {
      ])
    }
    return random.item(attachment)
-  },
+  }
-  randomAttachmentQuery: (isWebGL2) => {
+
  static randomAttachmentQuery (isWebGL2) {
    let pname = [
      'FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE',
      'FRAMEBUFFER_ATTACHMENT_OBJECT_NAME',
@ -321,8 +345,9 @@ make.webgl = {
      ])
    }
    return random.item(pname)
-  },
+  }
-  randomShaderPrecision: (isWebGL2) => {
+
  static randomShaderPrecision (isWebGL2) {
    let precisiontype = [
      'LOW_FLOAT',
      'MEDIUM_FLOAT',
@ -332,8 +357,9 @@ make.webgl = {
      'HIGH_INT'
    ]
    return random.item(precisiontype)
-  },
+  }
-  randomStencilRefParameter: (isWebGL2) => {
+
  static randomStencilRefParameter (isWebGL2) {
    let param = [
      'STENCIL_FUNC',
      'STENCIL_VALUE_MASK',
@ -344,16 +370,18 @@ make.webgl = {
      'STENCIL_BITS'
    ]
    return random.item(param)
-  },
+  }
-  randomStencilMaskParameter: (isWebGL2) => {
+
  static randomStencilMaskParameter (isWebGL2) {
    let param = [
      'STENCIL_WRITEMASK',
      'STENCIL_BACK_WRITEMASK',
      'STENCIL_BITS'
    ]
    return random.item(param)
-  },
+  }
-  randomVertexAttribParameter: (isWebGL2) => {
+
  static randomVertexAttribParameter (isWebGL2) {
    let pname = [
      'VERTEX_ATTRIB_ARRAY_BUFFER_BINDING',
      'VERTEX_ATTRIB_ARRAY_ENABLED',
@ -371,8 +399,9 @@ make.webgl = {
      ])
    }
    return random.item(pname)
-  },
+  }
-  randomHint: (isWebGL2) => {
+
  static randomHint (isWebGL2) {
    let target = [
      'GENERATE_MIPMAP_HINT'
    ]
@ -382,16 +411,18 @@ make.webgl = {
      ])
    }
    return random.item(target)
-  },
+  }
-  randomHintMode: (isWebGL2) => {
+
  static randomHintMode (isWebGL2) {
    let mode = [
      'FASTEST',
      'NICEST',
      'DONT_CARE'
    ]
    return random.item(mode)
-  },
+  }
-  randomPixelStorage: (isWebGL2) => {
+
  static randomPixelStorage (isWebGL2) {
    let pname = {
      'PACK_ALIGNMENT': random.item([1, 2, 4, 8]),
      'UNPACK_ALIGNMENT': random.item([1, 2, 4, 8]),
@ -416,8 +447,9 @@ make.webgl = {
    }
    let name = random.item(Object.keys(pname))
    return [name, pname[name]]
-  },
+  }
-  randomStencilAction: (isWebGL2) => {
+
  static randomStencilAction (isWebGL2) {
    let action = [
      'KEEP',
      'ZERO',
@ -429,24 +461,27 @@ make.webgl = {
      'INVERT'
    ]
    return random.item(action)
-  },
+  }
-  randomQueryTarget: (isWebGL2) => {
+
  static randomQueryTarget (isWebGL2) {
    let target = [
      'ANY_SAMPLES_PASSED',
      'ANY_SAMPLES_PASSED_CONSERVATIVE',
      'TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN'
    ]
    return random.item(target)
-  },
+  }
-  randomQueryPname: (isWebGL2) => {
+
  static randomQueryPname (isWebGL2) {
    let pname = [
      'CURRENT_QUERY',
      'QUERY_RESULT',
      'QUERY_RESULT_AVAILABLE'
    ]
    return random.item(pname)
-  },
+  }
-  randomSamplerParameter: (isWebGL2) => {
+
  static randomSamplerParameter (isWebGL2) {
    let pname = [
      'TEXTURE_MAG_FILTER',
      'TEXTURE_MIN_FILTER',
@ -462,8 +497,9 @@ make.webgl = {
      'TEXTURE_MAX_ANISOTROPY_EXT'
    ]
    return random.item(pname)
-  },
+  }
-  randomSyncParameter: (isWebGL2) => {
+
  static randomSyncParameter (isWebGL2) {
    let pname = [
      'OBJECT_TYPE',
      'SYNC_STATUS',
@ -471,8 +507,9 @@ make.webgl = {
      'SYNC_FLAGS'
    ]
    return random.item(pname)
-  },
+  }
-  randomClearBuffer: (isWebGL2) => {
+
  static randomClearBuffer (isWebGL2) {
    let buffer = [
      'COLOR',
      'DEPTH',
@ -480,15 +517,17 @@ make.webgl = {
      'DEPTH_STENCIL'
    ]
    return random.item(buffer)
-  },
+  }
-  randomBindBufferTarget: (isWebGL2) => {
+
  static randomBindBufferTarget (isWebGL2) {
    let target = [
      'TRANSFORM_FEEDBACK_BUFFER',
      'UNIFORM_BUFFER'
    ]
    return random.item(target)
-  },
+  }
-  randomIndexedParameterTarget: (isWebGL2) => {
+
  static randomIndexedParameterTarget (isWebGL2) {
    let target = [
      'TRANSFORM_FEEDBACK_BUFFER_BINDING',
      'TRANSFORM_FEEDBACK_BUFFER_SIZE',
@ -498,8 +537,9 @@ make.webgl = {
      'UNIFORM_BUFFER_START'
    ]
    return random.item(target)
-  },
+  }
-  randomUniformParameter: (isWebGL2) => {
+
  static randomUniformParameter (isWebGL2) {
    let pname = [
      'UNIFORM_TYPE',
      'UNIFORM_SIZE',
@ -510,8 +550,9 @@ make.webgl = {
      'UNIFORM_IS_ROW_MAJOR'
    ]
    return random.item(pname)
-  },
+  }
-  randomUniformBlockParameter: (isWebGL2) => {
+
  static randomUniformBlockParameter (isWebGL2) {
    let pname = [
      'UNIFORM_BLOCK_BINDING',
      'UNIFORM_BLOCK_DATA_SIZE',
@ -521,8 +562,9 @@ make.webgl = {
      'UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER'
    ]
    return random.item(pname)
-  },
+  }
-  randomPixelDatatype: (isWebGL2) => {
+
  static randomPixelDatatype (isWebGL2) {
    let type = [
      'UNSIGNED_BYTE',
      'UNSIGNED_SHORT',
@ -533,8 +575,9 @@ make.webgl = {
      'FLOAT'
    ]
    return random.item(type)
-  },
+  }
-  randomBufferUsage: (isWebGL2) => {
+
  static randomBufferUsage (isWebGL2) {
    let usage = [
      'STATIC_DRAW',
      'DYNAMIC_DRAW',
@ -553,3 +596,5 @@ make.webgl = {
    return random.item(usage)
  }
 }
 module.exports = webgl
--- a/lib/random/index.js
+++ b/lib/random/index.js
@ -0,0 +1,5 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 module.exports = require('./random')
--- a/lib/random/mersennetwister.js
+++ b/lib/random/mersennetwister.js
@ -9,67 +9,68 @@
 *
 */
-function MersenneTwister () { // eslint-disable-line no-unused-vars
+class MersenneTwister {
-  const N = 624
+  constructor () {
-  const M = 397
+    this.N = 624
-  const UPPER_MASK = 0x80000000
+    this.M = 397
-  const LOWER_MASK = 0x7fffffff
+    this.UPPER_MASK = 0x80000000
-  const MAG01 = new Int32Array([0, 0x9908b0df])
+    this.LOWER_MASK = 0x7fffffff
    this.MAG01 = new Int32Array([0, 0x9908b0df])
-  let mt = new Int32Array(N)
+    this.mt = new Int32Array(this.N)
-  /* the array for the state vector */
+    this.mti = 625 // The array for the state vector.
-  let mti = 625
+  }
-  this.seed = function (s) {
+  seed (s) {
-    mt[0] = s | 0
+    this.mt[0] = s | 0
-    for (mti = 1; mti < N; mti++) {
+    for (this.mti = 1; this.mti < this.N; this.mti++) {
-      mt[mti] = Math.imul(1812433253, mt[mti - 1] ^ (mt[mti - 1] >>> 30)) + mti
+      this.mt[this.mti] = Math.imul(1812433253, this.mt[this.mti - 1] ^ (this.mt[this.mti - 1] >>> 30)) + this.mti
    }
  }
-  this.export_state = function () {
+  export_state () {
-    return [mt, mti]
+    return [this.mt, this.mti]
  }
-  this.import_state = function (s) {
+  import_state (s) {
-    mt = s[0]
+    this.mt = s[0]
-    mti = s[1]
+    this.mti = s[1]
  }
-  this.export_mta = function () {
+  export_mta () {
-    return mt
+    return this.mt
  }
-  this.import_mta = function (_mta) {
+  import_mta (_mta) {
-    mt = _mta
+    this.mt = _mta
  }
-  this.export_mti = function () {
+  export_mti () {
-    return mti
+    return this.mti
  }
-  this.import_mti = function (_mti) {
+  import_mti (_mti) {
-    mti = _mti
+    this.mti = _mti
  }
-  this.int32 = function () {
+  int32 () {
    let y, kk
-    if (mti >= N) { /* generate N words at one time */
+    if (this.mti >= this.N) { /* generate N words at one time */
-      for (kk = 0; kk < N - M; kk++) {
+      for (kk = 0; kk < this.N - this.M; kk++) {
-        y = ((mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK))
+      y = ((this.mt[kk] & this.UPPER_MASK) | (this.mt[kk + 1] & this.LOWER_MASK))
-        mt[kk] = (mt[kk + M] ^ (y >>> 1) ^ MAG01[y & 0x1])
+      this.mt[kk] = (this.mt[kk + this.M] ^ (y >>> 1) ^ this.MAG01[y & 0x1])
      }
-      for (; kk < N - 1; kk++) {
+      for (; kk < this.N - 1; kk++) {
-        y = ((mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK))
+        y = ((this.mt[kk] & this.UPPER_MASK) | (this.mt[kk + 1] & this.LOWER_MASK))
-        mt[kk] = (mt[kk + (M - N)] ^ (y >>> 1) ^ MAG01[y & 0x1])
+        this.mt[kk] = (this.mt[kk + (this.M - this.N)] ^ (y >>> 1) ^ this.MAG01[y & 0x1])
      }
-      y = ((mt[N - 1] & UPPER_MASK) | (mt[0] & LOWER_MASK))
+      y = ((this.mt[this.N - 1] & this.UPPER_MASK) | (this.mt[0] & this.LOWER_MASK))
-      mt[N - 1] = (mt[M - 1] ^ (y >>> 1) ^ MAG01[y & 0x1])
+      this.mt[this.N - 1] = (this.mt[this.M - 1] ^ (y >>> 1) ^ this.MAG01[y & 0x1])
-      mti = 0
+      this.mti = 0
    }
-    y = mt[mti++]
+    y = this.mt[this.mti++]
    /* Tempering */
    y = y ^ (y >>> 11)
@ -80,9 +81,9 @@ function MersenneTwister () { // eslint-disable-line no-unused-vars
    return y >>> 0
  }
-  this.real2 = function () {
+  real2 () {
    return ((this.int32() >>> 5) * 67108864.0 + (this.int32() >>> 6)) / 9007199254740992.0
  }
 }
-module.exports = { MersenneTwister }
+module.exports = MersenneTwister
--- a/lib/random/random.js
+++ b/lib/random/random.js
@ -3,27 +3,27 @@
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 const MersenneTwister = require('./mersennetwister')
 const {logger} = require('../logging')
-var random = { // eslint-disable-line no-unused-vars
+class random {
  seed: null,
  twister: null,
  /**
   * Must be called before any other methods can be called to initialize MersenneTwister.
   * @param {number|null|undefined} seed Value to initialize MersenneTwister.
   */
-  init: function (seed) {
+  static init (seed) {
    if (seed === null || seed === undefined) {
      this.seed = new Date().getTime()
    }
-    this.twister = new MersenneTwister.MersenneTwister()
+    this.twister = new MersenneTwister()
    this.twister.seed(this.seed)
  },
  number: function (limit) {
    // Returns an integer in [0, limit). Uniform distribution.
    if (limit === 0) {
      return limit
  }
  /**
   * Returns an integer in [0, limit). Uniform distribution.
   * @param limit
   */
  static number (limit) {
    if (limit === null || limit === undefined) {
      limit = 0xffffffff
    }
@ -34,42 +34,64 @@ var random = { // eslint-disable-line no-unused-vars
      r = this.twister.int32()
    } while (y && r >= y) // eslint-disable-line no-unmodified-loop-condition
    return (r / x) >>> 0
  },
  float: function () {
    // Returns a float in [0, 1). Uniform distribution.
    return this.twister.real2()
  },
  range: function (start, limit) {
    // Returns an integer in [start, limit]. Uniform distribution.
    if (isNaN(start) || isNaN(limit)) {
      logger.traceback()
      throw new TypeError('random.range() received a non number type: \'' + start + '\', \'' + limit + '\')')
    }
    return this.number(limit - start + 1) + start
  },
  ludOneTo: function (limit) {
    // Returns a float in [1, limit]. The logarithm has uniform distribution.
    return Math.exp(this.float() * Math.log(limit))
  },
  item: function (list) {
    if (list === undefined || typeof list === 'string' || list.length === undefined) {
      logger.traceback()
      throw new TypeError('random.item() received an invalid object: \'' + list + '\'')
  }
  /**
   * Returns a float in [0, 1). Uniform distribution.
   */
  static float () {
    return this.twister.real2()
  }
  /**
   * Returns an integer in [start, limit]. Uniform distribution.
   * @param start
   * @param limit
   */
  static range (start, limit) {
    if (isNaN(start) || isNaN(limit)) {
      logger.traceback()
      throw new TypeError(`random.range() received non-number type: (${start}, ${limit})`)
    }
    return this.number(limit - start + 1) + start
  }
  /**
   * Returns a float in [1, limit]. The logarithm has uniform distribution.
   * @param {*} limit
   */
  static ludOneTo (limit) {
    return Math.exp(this.float() * Math.log(limit))
  }
  static item (list) {
    if (list === undefined || typeof list === 'string' || list.length === undefined) {
      logger.traceback()
      throw new TypeError(`random.item() received invalid object: (${list})`)
    }
    return list[this.number(list.length)]
-  },
+  }
-  key: function (obj) {
+
  /**
   * Returns a random key of a provided object.
   * @param {*} obj
   */
  static key (obj) {
    let list = []
    for (let i in obj) {
      list.push(i)
    }
    return this.item(list)
-  },
+  }
-  bool: function () {
+
  /**
   * Return a random Boolean value.
   */
  static bool () {
    return this.item([true, false])
-  },
+  }
-  pick: function (obj) {
+
  static pick (obj) {
    if (typeof obj === 'function') {
      return obj()
    }
@ -77,21 +99,23 @@ var random = { // eslint-disable-line no-unused-vars
      return this.pick(this.item(obj))
    }
    return obj
-  },
+  }
-  chance: function (limit) {
+
  static chance (limit) {
    if (limit === null || limit === undefined) {
      limit = 2
    }
    if (isNaN(limit)) {
      logger.traceback()
-      throw new TypeError('random.chance() received a non number type: \'' + limit + '\'')
+      throw new TypeError(`random.chance() received non-number type: (${limit})`)
    }
    return this.number(limit) === 1
-  },
+  }
-  choose: function (list, flat) {
+
  static choose (list, flat) {
    if (!(Array.isArray(list))) {
      logger.traceback()
-      throw new TypeError('random.choose() received a non-array type: \'' + list + '\'')
+      throw new TypeError(`random.choose() received non-array type: (${list})`)
    }
    let total = 0
    for (let i = 0; i < list.length; i++) {
@ -112,9 +136,13 @@ var random = { // eslint-disable-line no-unused-vars
      return list[0][1]
    }
    return this.pick([list[0][1]])
-  },
+  }
-  weighted: function (wa) {
+
-    // More memory-hungry but hopefully faster than random.choose$flat
+  /**
   * More memory-hungry but hopefully faster than random.choose$flat.
   * @param {*} wa
   */
  static weighted (wa) {
    let a = []
    for (let i = 0; i < wa.length; ++i) {
      for (let j = 0; j < wa[i].w; ++j) {
@ -122,11 +150,13 @@ var random = { // eslint-disable-line no-unused-vars
      }
    }
    return a
-  },
+  }
-  use: function (obj) {
+
  static use (obj) {
    return this.bool() ? obj : ''
-  },
+  }
-  shuffle: function (arr) {
+
  static shuffle (arr) {
    let i = arr.length
    while (i--) {
      let p = this.number(i + 1)
@ -134,16 +164,18 @@ var random = { // eslint-disable-line no-unused-vars
      arr[i] = arr[p]
      arr[p] = t
    }
-  },
+  }
-  shuffled: function (arr) {
+
  static shuffled (arr) {
    let newArray = arr.slice()
    this.shuffle(newArray)
    return newArray
-  },
+  }
-  subset: function (list, limit) {
+
  static subset (list, limit) {
    if (!(Array.isArray(list))) {
      logger.traceback()
-      throw new TypeError('random.subset() received a non-array type: \'' + list + '\'')
+      throw new TypeError(`random.subset() received non-array type: (${list})`)
    }
    if (typeof limit !== 'number') {
      limit = this.number(list.length + 1)
@ -153,9 +185,13 @@ var random = { // eslint-disable-line no-unused-vars
      result.push(this.pick(list))
    }
    return result
-  },
+  }
-  pop: function (arr) {
+
-    // Removes and returns a random item from an array
+  /**
   * Removes and returns a random item from an array.
   * @param {*} arr
   */
  static pop (arr) {
    let i, obj
    i = this.number(arr.length)
@ -163,13 +199,11 @@ var random = { // eslint-disable-line no-unused-vars
    arr.splice(i, 1)
    return obj
-  },
+  }
-  hex: function (len) {
+
  static hex (len) {
    return this.number(Math.pow(2, len * 4)).toString(16)
  }
 }
-module.exports = {
+module.exports = random
  random,
  MersenneTwister
 }
--- a/lib/utils/block.js
+++ b/lib/utils/block.js
@ -2,8 +2,10 @@
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-utils.block = {
+const utils = require('../utils')
-  block: function (list, optional) {
+
 class block extends utils {
  static block (list, optional) {
    if (optional === true) {
      if (random.chance(6)) {
        return ''
@ -38,3 +40,5 @@ utils.block = {
    return asString
  }
 }
 module.exports = block
--- a/lib/utils/common.js
+++ b/lib/utils/common.js
@ -2,30 +2,34 @@
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-utils.common = {
+
-  objToString: function (obj) {
+class common extends utils {
  static objToString (obj) {
    try {
      return '' + obj
    } catch (e) {
      return '[' + e + ']'
    }
-  },
+  }
-  getAllProperties: function (obj) {
+
  static getAllProperties (obj) {
    let list = []
    while (obj) {
      list = list.concat(Object.getOwnPropertyNames(obj))
      obj = Object.getPrototypeOf(obj)
    }
    return list
-  },
+  }
-  getKeysFromHash: function (obj) {
+
  static getKeysFromHash (obj) {
    let list = []
    for (let p in obj) {
      list.push(p)
    }
    return list
-  },
+  }
-  quote: function (s) {
+
  static quote (s) {
    // Taken from DOMfuzz
    function escapeString (s) {
      return ('\"' + // eslint-disable-line no-useless-escape
@ -48,8 +52,9 @@ utils.common = {
      // For other things (such as numbers, |null|, and |undefined|), just coerce to string.
      return JSON.stringify(s)
    }
-  },
+  }
-  b64encode: function (str) {
+
  static b64encode (str) {
    // Unicode safe b64 encoding
    // https://developer.mozilla.org/en-US/docs/Web/API/WindowBase64/Base64_encoding_and_decoding#The_Unicode_Problem
    return btoa(encodeURIComponent(str).replace(/%([0-9A-F]{2})/g,
@ -57,15 +62,17 @@ utils.common = {
        // noinspection JSCheckFunctionSignatures
        return String.fromCharCode('0x' + p1)
      }))
-  },
+  }
-  b64decode: function (str) {
+
  static b64decode (str) {
    // Unicode safe b64 decoding
    // https://developer.mozilla.org/en-US/docs/Web/API/WindowBase64/Base64_encoding_and_decoding#The_Unicode_Problem
    return decodeURIComponent(atob(str).split('').map(function (c) {
      return '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2)
    }).join(''))
-  },
+  }
-  uniqueList: function (list) {
+
  static uniqueList (list) {
    let tmp = {}
    let r = []
    for (let i = 0; i < list.length; i++) {
@ -75,8 +82,9 @@ utils.common = {
      r.push(tmp[i])
    }
    return r
-  },
+  }
-  mergeHash: function (obj1, obj2) {
+
  static mergeHash (obj1, obj2) {
    for (let p in obj2) {
      try {
        if (obj2[p].constructor === Object) {
@ -89,6 +97,11 @@ utils.common = {
      }
    }
    return obj1
  },
  mockup: (obj) => obj.split('\n').map((ln) => ln.trim()).join('')
  }
  static mockup (obj) {
    return obj.split('\n').map((ln) => ln.trim()).join('')
  }
 }
 module.exports = common
--- a/lib/utils/index.js
+++ b/lib/utils/index.js
@ -0,0 +1,27 @@
 class utils {
    static get common () {
        return require('./common')
    }
 	static get block () {
 		return require('./block')
    }
    static get mutate () {
 		return require('./mutate')
    }
    static Objects () {
        return require('./objects')
    }
    static get platform () {
        return require('./platform')
    }
    static get script () {
        return require('./script')
    }
 }
 module.exports = utils
--- a/lib/utils/init.js
+++ b/lib/utils/init.js
@ -1 +0,0 @@
 var utils = {} // eslint-disable-line no-unused-vars
--- a/lib/utils/mutate.js
+++ b/lib/utils/mutate.js
@ -2,22 +2,26 @@
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-utils.mutate = {
+const make = require('../make')
-  text: function (str) {
+const utils = require('../utils')
 const random = require('../random')
 class mutate extends utils {
  static text (str) {
    let mutator = function (m) {
      return random.chance(4) ? m : make.text.any()
    }
    return str.replace(/[a-zA-Z]+?/g, mutator)
-  },
+  }
-  numbers: function (str) {
+  static numbers (str) {
    let mutator = function (m) {
      return random.chance(4) ? m : make.number.any()
    }
    return str.replace(/-?\d+(\.\d+)?/g, mutator)
-  },
+  }
-  units: function (str) {
+  static units (str) {
    let mutator = function (m, p1) {
      if (random.chance(4)) {
        return m
@ -26,9 +30,9 @@ utils.mutate = {
      }
    }
    return str.replace(/(\d+)(px|em|ex|ch|rem|mm|cm|in|pt|pc|%')/g, mutator)
-  },
+  }
-  random: function (str) {
+  static random (str) {
    let mutator = function (m) {
      if (random.chance(20)) {
        if (str.match(/[0-9]/g)) {
@ -41,9 +45,9 @@ utils.mutate = {
      }
    }
    return str.replace(/./g, mutator)
-  },
+  }
-  any: function (str) {
+  static any (str) {
    switch (random.number(4)) {
      case 0:
        return utils.mutate.text(str)
@ -56,3 +60,5 @@ utils.mutate = {
    }
  }
 }
 module.exports = mutate
--- a/lib/utils/objects.js
+++ b/lib/utils/objects.js
@ -2,14 +2,18 @@
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 const utils = require('../utils')
 const {logger} = require('../logging')
 var o = null // eslint-disable-line no-unused-vars
-function Objects () {
+class Objects {
  constructor () {
    this.counter = 0
    this.container = {}
  }
-Objects.prototype.add = function (category, member) {
+  add (category, member) {
    if (!member) {
      member = 'o' + this.counter
    }
@ -21,7 +25,7 @@ Objects.prototype.add = function (category, member) {
    return this.container[category].slice(-1)[0].name
  }
-Objects.prototype.get = function (category, last) {
+  get (category, last) {
    if (!(category in this.container)) {
      // return {type:null, name:null};
      logger.traceback()
@ -33,7 +37,7 @@ Objects.prototype.get = function (category, last) {
    return random.pick(this.container[category])
  }
-Objects.prototype.pick = function (category, last) {
+  pick (category, last) {
    try {
      return this.get(category, last).name
    } catch (e) {
@ -42,7 +46,7 @@ Objects.prototype.pick = function (category, last) {
    }
  }
-Objects.prototype.pop = function (objectName) {
+  pop (objectName) {
    let self = this
    utils.common.getKeysFromHash(this.container).forEach(function (category) {
      self.container[category].forEach(function (obj) {
@ -53,7 +57,7 @@ Objects.prototype.pop = function (objectName) {
    })
  }
-Objects.prototype.contains = function (categoryNames) {
+  contains (categoryNames) {
    let categories = []
    let self = this
    categoryNames.forEach(function (name) {
@ -64,15 +68,15 @@ Objects.prototype.contains = function (categoryNames) {
    return (categories.length === 0) ? null : categories
  }
-Objects.prototype.show = function (category) {
+  show (category) {
    return (category in this.container) ? this.container[category] : this.container
  }
-Objects.prototype.count = function (category) {
+  count (category) {
    return (category in this.container) ? this.container[category].length : 0
  }
-Objects.prototype.has = function (category) {
+  has (category) {
    if (category in this.container) {
      this.check(category)
      return this.container[category].length > 0
@ -80,7 +84,7 @@ Objects.prototype.has = function (category) {
    return false
  }
-Objects.prototype.valid = function () {
+  valid () {
    let items = []
    let self = this
    utils.common.getKeysFromHash(self.container).forEach(function (category) {
@ -94,7 +98,7 @@ Objects.prototype.valid = function () {
    return items
  }
-Objects.prototype.check = function (category) {
+  check (category) {
    let self = this
    self.container[category].forEach(function (object) {
      try {
@ -107,3 +111,6 @@ Objects.prototype.check = function (category) {
      }
    })
  }
 }
 module.exports = Object
--- a/lib/utils/platform.js
+++ b/lib/utils/platform.js
@ -2,9 +2,17 @@
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-utils.platform = (function () {
+const utils = require('../utils')
 class platform extends utils {
  static get name () {
    let platform = {}
    /* In case we are running in Node. */
    if (typeof window === 'undefined') {
      return platform
    }
    const userAgent = (navigator.userAgent).toLowerCase()
    const language = navigator.language || navigator.browserLanguage
@ -99,4 +107,7 @@ utils.platform = (function () {
    }
    return platform
-})()
+  }
 }
 module.exports = platform
--- a/lib/utils/script.js
+++ b/lib/utils/script.js
@ -2,8 +2,11 @@
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-utils.script = {
+const utils = require('../utils')
-  methodHead: function (list, numOptional) {
+const random = require('../random')
 class script extends utils {
  static methodHead (list, numOptional) {
    if (isNaN(numOptional)) {
      numOptional = 0
    }
@ -12,9 +15,10 @@ utils.script = {
    for (let i = 0; i < arity; i++) {
      params.push(random.pick([list[i]]))
    }
-    return '(' + params.join(', ') + ')'
+    return `(${params.join(', ')})`
-  },
+  }
-  methodCall: function (objectName, methodHash) {
+
  static methodCall (objectName, methodHash) {
    if (!utils.common.getKeysFromHash(methodHash).length || !objectName) {
      return ''
    }
@ -23,9 +27,10 @@ utils.script = {
    if (typeof (methodArgs) === 'function') { // Todo: Hmmmm..
      return methodArgs()
    }
-    return objectName + '.' + methodName + utils.script.methodHead(methodArgs)
+    return objectName + '.' + methodName + script.methodHead(methodArgs)
-  },
+  }
-  setAttribute: function (objectName, attributeHash) {
+
  static setAttribute (objectName, attributeHash) {
    if (!utils.common.getKeysFromHash(attributeHash).length || !objectName) {
      return ''
    }
@ -41,65 +46,62 @@ utils.script = {
     }
     */
    return objectName + '.' + attributeName + operator + attributeValue + ';'
-  },
+  }
-  makeConstraint: function (keys, values) {
+
  static makeConstraint (keys, values) {
    let o = {}
    let n = random.range(0, keys.length)
    while (n--) {
      o[random.pick(keys)] = random.pick(values)
    }
    return o
-  },
+  }
-  makeRandomOptions: function (baseObject) {
+
  static makeRandomOptions (baseObject) {
    let o = {}
    let unique = random.subset(Object.keys(baseObject))
    for (let i = 0; i < unique.length; i++) {
      o[unique[i]] = random.pick(baseObject[unique[i]])
    }
    return JSON.stringify(o)
-  },
+  }
-  safely: function (s) {
+
-    return 'try { ' + s + ' } catch(e) { }'
+  static safely (s) {
-  },
+    return `try { ${s} } catch(e) { }`
-  makeLoop: function (s, max) {
+  }
  static makeLoop (s, max) {
    return 'for (let i = 0; i < ' + (max || make.number.range()) + '; i++) {' + s + '}'
-  },
+  }
-  makeArray: function (type, arrayLength, cb) {
+
  static makeArray (type, arrayLength, cb) {
    if (type === null || type === undefined) {
      type = random.item(['Uint8', 'Float32'])
    }
    switch (random.number(8)) {
      case 0:
        let src = 'function() { let buffer = new ' + type + 'Array(' + arrayLength + ');'
-        src += utils.script.makeLoop('buffer[i] = ' + cb() + ';', arrayLength)
+        src += script.makeLoop('buffer[i] = ' + cb() + ';', arrayLength)
        src += 'return buffer;}()'
        return src
      case 1:
-        return 'new ' + type + 'Array([' + make.arrays.filledArray(cb, arrayLength) + '])'
+        return `new ${type}Array([${make.arrays.filledArray(cb, arrayLength)}])`
      default:
-        return 'new ' + type + 'Array(' + arrayLength + ')'
+        return `new ${type}Array(${arrayLength})`
    }
-  },
+  }
-  randListIndex: function (objName) {
+
  static randListIndex (objName) {
    return random.number() + ' % ' + o.pick(objName) + '.length'
  },
  addElementToBody: function (name) {
    return '(document.body || document.documentElement).appendChild' + utils.script.methodHead([name])
  },
  forceGC: function () {
    if (utils.platform.isMozilla) {
  }
-    if (utils.platform.isChrome) {
+
-      if (window.GCController) {
+  static addElementToBody (name) {
-        return GCController.collect() // eslint-disable-line no-undef
+    return `(document.body || document.documentElement).appendChild${script.methodHead([name])}`
-      }
+  }
-    }
+
-    if (utils.platform.isSafari) {
+  static getRandomElement () {
-    }
+    return `document.getElementsByTagName('*')[${random.number(document.getElementsByTagName('*').length)}]`
    if (utils.platform.isIE) {
    }
  },
  getRandomElement: function () {
    return 'document.getElementsByTagName(\'*\')[' + random.number(document.getElementsByTagName('*').length) + ']'
  }
 }
 module.exports = script
--- a/package.json
+++ b/package.json
@ -1,10 +1,13 @@
 {
  "name": "octo",
-  "version": "0.0.3",
+  "version": "1.0.0",
  "description": "",
  "keywords": [
    "fuzzing",
-    "browsers"
+    "browsers",
    "javascript",
    "node",
    "library"
  ],
  "homepage": "https://github.com/mozillasecurity/octo",
  "repository": {
@ -21,7 +24,8 @@
    "test": "grunt test --verbose",
    "test:lint": "cross-env NODE_ENV=test standard --verbose",
    "test:lint:fix": "cross-env NODE_ENV=test standard --fix --verbose",
-    "build": "./build.py -l lib/ -d deploy/",
+    "build": "webpack -p",
    "watch": "webpack --watch",
    "postinstall": "npm run build",
    "precommit": "npm run test:lint"
  },
@ -51,12 +55,16 @@
    "grunt-karma-coveralls": "*",
    "grunt-standard": "*",
    "husky": "^0.14.3",
    "jshint": "^2.9.5",
    "jshint-loader": "^0.8.4",
    "karma": "*",
    "karma-chrome-launcher": "*",
    "karma-coverage": "*",
    "karma-firefox-launcher": "*",
    "karma-qunit": "*",
    "qunitjs": "*",
-    "standard": "*"
+    "standard": "*",
    "webpack": "^4.1.1",
    "webpack-cli": "^2.0.12"
  }
 }
--- a/webpack.config.js
+++ b/webpack.config.js
@ -0,0 +1,14 @@
 const path = require('path')
 const webpack = require("webpack")
 let config = {
    entry: './lib/index.js',
    output: {
        filename: 'octo.js',
        library: 'octo',
        path: path.resolve(__dirname, 'dist'),
        libraryTarget: 'var'
    }
 }
 module.exports = config
		`@ -1 +0,0 @@`
			`var make = {} // eslint-disable-line no-unused-vars`
		`@ -1 +0,0 @@`
			`var utils = {} // eslint-disable-line no-unused-vars`