V1

node_modules/eslint-plugin-standard/LICENSE

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

node_modules/eslint-plugin-standard/README.md

@@ -0,0 +1,39 @@
+# eslint-plugin-standard [![travis][travis-image]][travis-url] [![npm][npm-image]][npm-url] [![downloads][downloads-image]][downloads-url] [![javascript style guide][standard-image]][standard-url]
+
+[travis-image]: https://img.shields.io/travis/standard/eslint-plugin-standard/master.svg
+[travis-url]: https://travis-ci.org/standard/eslint-plugin-standard
+[npm-image]: https://img.shields.io/npm/v/eslint-plugin-standard.svg
+[npm-url]: https://npmjs.org/package/eslint-plugin-standard
+[downloads-image]: https://img.shields.io/npm/dm/eslint-plugin-standard.svg
+[downloads-url]: https://npmjs.org/package/eslint-plugin-standard
+[standard-image]: https://img.shields.io/badge/code_style-standard-brightgreen.svg
+[standard-url]: https://standardjs.com
+
+ESlint Rules for the Standard Linter
+
+### Usage
+
+`npm install --save-dev eslint-plugin-standard`
+
+### Configuration
+
+```js
+{
+  rules: {
+    'standard/object-curly-even-spacing': [2, "either"],
+    'standard/array-bracket-even-spacing': [2, "either"],
+    'standard/computed-property-even-spacing': [2, "even"],
+    'standard/no-callback-literal': [2, ["cb", "callback"]]
+  }
+}
+```
+
+### Rules Explanations
+
+There are several rules that were created specifically for the `standard` linter.
+
+- `object-curly-even-spacing` - Like `object-curly-spacing` from ESLint except it has an `either` option which lets you have 1 or 0 spaces padding.
+- `array-bracket-even-spacing` - Like `array-bracket-even-spacing` from ESLint except it has an `either` option which lets you have 1 or 0 spacing padding.
+- `computed-property-even-spacing` - Like `computed-property-spacing` around ESLint except is has an `even` option which lets you have 1 or 0 spacing padding.
+- `no-callback-literal` - Ensures that we strictly follow the callback pattern with `undefined`, `null` or an error object in the first position of a callback.
+

node_modules/eslint-plugin-standard/index.js

@@ -0,0 +1,16 @@
+'use strict'
+
+module.exports = {
+  rules: {
+    'array-bracket-even-spacing': require('./rules/array-bracket-even-spacing.js'),
+    'computed-property-even-spacing': require('./rules/computed-property-even-spacing.js'),
+    'object-curly-even-spacing': require('./rules/object-curly-even-spacing.js'),
+    'no-callback-literal': require('./rules/no-callback-literal.js')
+  },
+  rulesConfig: {
+    'object-curly-even-spacing': 0,
+    'array-bracket-even-spacing': 0,
+    'computed-property-even-spacing': 0,
+    'no-callback-literal': 0
+  }
+}

node_modules/eslint-plugin-standard/package.json

@@ -0,0 +1,64 @@
+{
+  "_args": [
+    [
+      "eslint-plugin-standard@4.0.1",
+      "/home/node/nuxt"
+    ]
+  ],
+  "_development": true,
+  "_from": "eslint-plugin-standard@4.0.1",
+  "_id": "eslint-plugin-standard@4.0.1",
+  "_inBundle": false,
+  "_integrity": "sha512-v/KBnfyaOMPmZc/dmc6ozOdWqekGp7bBGq4jLAecEfPGmfKiWS4sA8sC0LqiV9w5qmXAtXVn4M3p1jSyhY85SQ==",
+  "_location": "/eslint-plugin-standard",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "eslint-plugin-standard@4.0.1",
+    "name": "eslint-plugin-standard",
+    "escapedName": "eslint-plugin-standard",
+    "rawSpec": "4.0.1",
+    "saveSpec": null,
+    "fetchSpec": "4.0.1"
+  },
+  "_requiredBy": [
+    "/@nuxtjs/eslint-config"
+  ],
+  "_resolved": "https://registry.npmjs.org/eslint-plugin-standard/-/eslint-plugin-standard-4.0.1.tgz",
+  "_spec": "4.0.1",
+  "_where": "/home/node/nuxt",
+  "author": {
+    "name": "Jamund Ferguson",
+    "email": "jamund@gmail.com"
+  },
+  "bugs": {
+    "url": "https://github.com/standard/eslint-plugin-standard/issues"
+  },
+  "dependencies": {},
+  "description": "ESlint Plugin for the Standard Linter",
+  "devDependencies": {
+    "eslint": "^6.1.0",
+    "mocha": "^6.2.0",
+    "standard": "*"
+  },
+  "homepage": "https://github.com/standard/eslint-plugin-standard#readme",
+  "keywords": [
+    "eslint",
+    "eslintplugin"
+  ],
+  "license": "MIT",
+  "main": "index.js",
+  "name": "eslint-plugin-standard",
+  "peerDependencies": {
+    "eslint": ">=5.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/standard/eslint-plugin-standard.git"
+  },
+  "scripts": {
+    "test": "standard && mocha tests/"
+  },
+  "version": "4.0.1"
+}

node_modules/eslint-plugin-standard/rules/array-bracket-even-spacing.js

@@ -0,0 +1,197 @@
+'use strict'
+
+/**
+ * @fileoverview Disallows or enforces spaces inside of array brackets.
+ * @author Jamund Ferguson
+ * @copyright 2015 Jamund Ferguson. All rights reserved.
+ * @copyright 2014 Brandyn Bennett. All rights reserved.
+ * @copyright 2014 Michael Ficarra. No rights reserved.
+ * @copyright 2014 Vignesh Anand. All rights reserved.
+ */
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+module.exports = {
+  meta: {
+    docs: {
+      url: 'https://github.com/standard/eslint-plugin-standard#rules-explanations'
+    }
+  },
+
+  create: function (context) {
+    var spaced = context.options[0] === 'always'
+    var either = context.options[0] === 'either'
+
+    /**
+     * Determines whether an option is set, relative to the spacing option.
+     * If spaced is "always", then check whether option is set to false.
+     * If spaced is "never", then check whether option is set to true.
+     * @param {Object} option - The option to exclude.
+     * @returns {boolean} Whether or not the property is excluded.
+     */
+    function isOptionSet (option) {
+      return context.options[1] != null ? context.options[1][option] === !spaced : false
+    }
+
+    var options = {
+      either: either,
+      spaced: spaced,
+      singleElementException: isOptionSet('singleValue'),
+      objectsInArraysException: isOptionSet('objectsInArrays'),
+      arraysInArraysException: isOptionSet('arraysInArrays')
+    }
+
+    // --------------------------------------------------------------------------
+    // Helpers
+    // --------------------------------------------------------------------------
+
+    /**
+     * Determines whether two adjacent tokens are have whitespace between them.
+     * @param {Object} left - The left token object.
+     * @param {Object} right - The right token object.
+     * @returns {boolean} Whether or not there is space between the tokens.
+     */
+    function isSpaced (left, right) {
+      return left.range[1] < right.range[0]
+    }
+
+    /**
+     * Determines whether two adjacent tokens are on the same line.
+     * @param {Object} left - The left token object.
+     * @param {Object} right - The right token object.
+     * @returns {boolean} Whether or not the tokens are on the same line.
+     */
+    function isSameLine (left, right) {
+      return left.loc.start.line === right.loc.start.line
+    }
+
+    /**
+     * Reports that there shouldn't be a space after the first token
+     * @param {ASTNode} node - The node to report in the event of an error.
+     * @param {Token} token - The token to use for the report.
+     * @returns {void}
+     */
+    function reportNoBeginningSpace (node, token) {
+      context.report(node, token.loc.start,
+        "There should be no space after '" + token.value + "'")
+    }
+
+    /**
+     * Reports that there shouldn't be a space before the last token
+     * @param {ASTNode} node - The node to report in the event of an error.
+     * @param {Token} token - The token to use for the report.
+     * @returns {void}
+     */
+    function reportNoEndingSpace (node, token) {
+      context.report(node, token.loc.start,
+        "There should be no space before '" + token.value + "'")
+    }
+
+    /**
+     * Reports that there should be a space after the first token
+     * @param {ASTNode} node - The node to report in the event of an error.
+     * @param {Token} token - The token to use for the report.
+     * @returns {void}
+     */
+    function reportRequiredBeginningSpace (node, token) {
+      context.report(node, token.loc.start,
+        "A space is required after '" + token.value + "'")
+    }
+
+    /**
+     * Reports that there should be a space before the last token
+     * @param {ASTNode} node - The node to report in the event of an error.
+     * @param {Token} token - The token to use for the report.
+     * @returns {void}
+     */
+    function reportRequiredEndingSpace (node, token) {
+      context.report(node, token.loc.start,
+        "A space is required before '" + token.value + "'")
+    }
+
+    /**
+     * Checks if a start and end brace in a node are spaced evenly
+     * and not too long (>1 space)
+     * @param node
+     * @param start
+     * @param end
+     * @returns {boolean}
+     */
+    function isEvenlySpacedAndNotTooLong (node, start, end) {
+      var expectedSpace = start[1].range[0] - start[0].range[1]
+      var endSpace = end[1].range[0] - end[0].range[1]
+      return endSpace === expectedSpace && endSpace <= 1
+    }
+
+    /**
+     * Validates the spacing around array brackets
+     * @param {ASTNode} node - The node we're checking for spacing
+     * @returns {void}
+     */
+    function validateArraySpacing (node) {
+      if (node.elements.length === 0) {
+        return
+      }
+
+      var first = context.getFirstToken(node)
+      var second = context.getFirstToken(node, 1)
+      var penultimate = context.getLastToken(node, 1)
+      var last = context.getLastToken(node)
+
+      var openingBracketMustBeSpaced =
+      (options.objectsInArraysException && second.value === '{') ||
+      (options.arraysInArraysException && second.value === '[') ||
+      (options.singleElementException && node.elements.length === 1)
+        ? !options.spaced : options.spaced
+
+      var closingBracketMustBeSpaced =
+      (options.objectsInArraysException && penultimate.value === '}') ||
+      (options.arraysInArraysException && penultimate.value === ']') ||
+      (options.singleElementException && node.elements.length === 1)
+        ? !options.spaced : options.spaced
+
+      // we only care about evenly spaced things
+      if (options.either) {
+        // newlines at any point means return
+        if (!isSameLine(first, last)) {
+          return
+        }
+
+        // confirm that the object expression/literal is spaced evenly
+        if (!isEvenlySpacedAndNotTooLong(node, [first, second], [penultimate, last])) {
+          context.report(node, 'Expected consistent spacing')
+        }
+
+        return
+      }
+
+      if (isSameLine(first, second)) {
+        if (openingBracketMustBeSpaced && !isSpaced(first, second)) {
+          reportRequiredBeginningSpace(node, first)
+        }
+        if (!openingBracketMustBeSpaced && isSpaced(first, second)) {
+          reportNoBeginningSpace(node, first)
+        }
+      }
+
+      if (isSameLine(penultimate, last)) {
+        if (closingBracketMustBeSpaced && !isSpaced(penultimate, last)) {
+          reportRequiredEndingSpace(node, last)
+        }
+        if (!closingBracketMustBeSpaced && isSpaced(penultimate, last)) {
+          reportNoEndingSpace(node, last)
+        }
+      }
+    }
+
+    // --------------------------------------------------------------------------
+    // Public
+    // --------------------------------------------------------------------------
+
+    return {
+      ArrayPattern: validateArraySpacing,
+      ArrayExpression: validateArraySpacing
+    }
+  }
+}

node_modules/eslint-plugin-standard/rules/computed-property-even-spacing.js

@@ -0,0 +1,161 @@
+'use strict'
+
+/**
+ * @fileoverview Disallows or enforces spaces inside computed properties.
+ * @author Jamund Ferguson
+ * @copyright 2015 Jamund Ferguson. All rights reserved.
+ */
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+module.exports = {
+  meta: {
+    docs: {
+      url: 'https://github.com/standard/eslint-plugin-standard#rules-explanations'
+    }
+  },
+
+  create: function (context) {
+    var propertyNameMustBeSpaced = context.options[0] === 'always' // default is "never"
+    var propertyNameMustBeEven = context.options[0] === 'even' // default is "never"
+
+    // --------------------------------------------------------------------------
+    // Helpers
+    // --------------------------------------------------------------------------
+
+    /**
+     * Determines whether two adjacent tokens are have whitespace between them.
+     * @param {Object} left - The left token object.
+     * @param {Object} right - The right token object.
+     * @returns {boolean} Whether or not there is space between the tokens.
+     */
+    function isSpaced (left, right) {
+      return left.range[1] < right.range[0]
+    }
+
+    /**
+     * Determines whether two adjacent tokens are on the same line.
+     * @param {Object} left - The left token object.
+     * @param {Object} right - The right token object.
+     * @returns {boolean} Whether or not the tokens are on the same line.
+     */
+    function isSameLine (left, right) {
+      return left.loc.start.line === right.loc.start.line
+    }
+
+    /**
+     * Reports that there shouldn't be a space after the first token
+     * @param {ASTNode} node - The node to report in the event of an error.
+     * @param {Token} token - The token to use for the report.
+     * @returns {void}
+     */
+    function reportNoBeginningSpace (node, token) {
+      context.report(node, token.loc.start,
+        "There should be no space after '" + token.value + "'")
+    }
+
+    /**
+     * Reports that there shouldn't be a space before the last token
+     * @param {ASTNode} node - The node to report in the event of an error.
+     * @param {Token} token - The token to use for the report.
+     * @returns {void}
+     */
+    function reportNoEndingSpace (node, token) {
+      context.report(node, token.loc.start,
+        "There should be no space before '" + token.value + "'")
+    }
+
+    /**
+     * Reports that there should be a space after the first token
+     * @param {ASTNode} node - The node to report in the event of an error.
+     * @param {Token} token - The token to use for the report.
+     * @returns {void}
+     */
+    function reportRequiredBeginningSpace (node, token) {
+      context.report(node, token.loc.start,
+        "A space is required after '" + token.value + "'")
+    }
+
+    /**
+     * Reports that there should be a space before the last token
+     * @param {ASTNode} node - The node to report in the event of an error.
+     * @param {Token} token - The token to use for the report.
+     * @returns {void}
+     */
+    function reportRequiredEndingSpace (node, token) {
+      context.report(node, token.loc.start,
+        "A space is required before '" + token.value + "'")
+    }
+
+    /**
+     * Returns a function that checks the spacing of a node on the property name
+     * that was passed in.
+     * @param {String} propertyName The property on the node to check for spacing
+     * @returns {Function} A function that will check spacing on a node
+     */
+    function checkSpacing (propertyName) {
+      return function (node) {
+        if (!node.computed) {
+          return
+        }
+
+        var property = node[propertyName]
+
+        var before = context.getTokenBefore(property)
+        var first = context.getFirstToken(property)
+        var last = context.getLastToken(property)
+        var after = context.getTokenAfter(property)
+        var startSpace, endSpace
+
+        if (propertyNameMustBeEven) {
+          if (!isSameLine(before, after)) {
+            context.report(node, 'Expected "[" and "]" to be on the same line')
+            return
+          }
+          startSpace = first.loc.start.column - before.loc.end.column
+          endSpace = after.loc.start.column - last.loc.end.column
+
+          if (startSpace !== endSpace || startSpace > 1) {
+            context.report(node, 'Expected 1 or 0 spaces around "[" and "]"')
+          }
+
+          return
+        }
+
+        if (isSameLine(before, first)) {
+          if (propertyNameMustBeSpaced) {
+            if (!isSpaced(before, first) && isSameLine(before, first)) {
+              reportRequiredBeginningSpace(node, before)
+            }
+          } else {
+            if (isSpaced(before, first)) {
+              reportNoBeginningSpace(node, before)
+            }
+          }
+        }
+
+        if (isSameLine(last, after)) {
+          if (propertyNameMustBeSpaced) {
+            if (!isSpaced(last, after) && isSameLine(last, after)) {
+              reportRequiredEndingSpace(node, after)
+            }
+          } else {
+            if (isSpaced(last, after)) {
+              reportNoEndingSpace(node, after)
+            }
+          }
+        }
+      }
+    }
+
+    // --------------------------------------------------------------------------
+    // Public
+    // --------------------------------------------------------------------------
+
+    return {
+      Property: checkSpacing('key'),
+      MemberExpression: checkSpacing('property')
+    }
+  }
+}

node_modules/eslint-plugin-standard/rules/no-callback-literal.js

@@ -0,0 +1,75 @@
+/**
+ * Ensures that the callback pattern is followed properly
+ * with an Error object (or undefined or null) in the first position.
+ */
+
+'use strict'
+
+// ------------------------------------------------------------------------------
+// Helpers
+// ------------------------------------------------------------------------------
+
+/**
+ * Determine if a node has a possiblity to be an Error object
+ * @param  {ASTNode}  node  ASTNode to check
+ * @returns {boolean}       True if there is a chance it contains an Error obj
+ */
+function couldBeError (node) {
+  switch (node.type) {
+    case 'Identifier':
+    case 'CallExpression':
+    case 'NewExpression':
+    case 'MemberExpression':
+    case 'TaggedTemplateExpression':
+    case 'YieldExpression':
+      return true // possibly an error object.
+
+    case 'AssignmentExpression':
+      return couldBeError(node.right)
+
+    case 'SequenceExpression':
+      var exprs = node.expressions
+      return exprs.length !== 0 && couldBeError(exprs[exprs.length - 1])
+
+    case 'LogicalExpression':
+      return couldBeError(node.left) || couldBeError(node.right)
+
+    case 'ConditionalExpression':
+      return couldBeError(node.consequent) || couldBeError(node.alternate)
+
+    default:
+      return node.value === null
+  }
+}
+
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+module.exports = {
+  meta: {
+    docs: {
+      url: 'https://github.com/standard/eslint-plugin-standard#rules-explanations'
+    }
+  },
+
+  create: function (context) {
+    var callbackNames = context.options[0] || ['callback', 'cb']
+
+    function isCallback (name) {
+      return callbackNames.indexOf(name) > -1
+    }
+
+    return {
+
+      CallExpression: function (node) {
+        var errorArg = node.arguments[0]
+        var calleeName = node.callee.name
+
+        if (errorArg && !couldBeError(errorArg) && isCallback(calleeName)) {
+          context.report(node, 'Unexpected literal in error position of callback.')
+        }
+      }
+    }
+  }
+}

node_modules/eslint-plugin-standard/rules/object-curly-even-spacing.js

@@ -0,0 +1,252 @@
+'use strict'
+
+/**
+ * @fileoverview Disallows or enforces spaces inside of object literals.
+ * @author Jamund Ferguson
+ * @copyright 2014 Brandyn Bennett. All rights reserved.
+ * @copyright 2014 Michael Ficarra. No rights reserved.
+ * @copyright 2014 Vignesh Anand. All rights reserved.
+ * @copyright 2015 Jamund Ferguson. All rights reserved.
+ */
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+module.exports = {
+  meta: {
+    docs: {
+      url: 'https://github.com/standard/eslint-plugin-standard#rules-explanations'
+    }
+  },
+
+  create: function (context) {
+    var spaced = context.options[0] === 'always'
+    var either = context.options[0] === 'either'
+
+    /**
+     * Determines whether an option is set, relative to the spacing option.
+     * If spaced is "always", then check whether option is set to false.
+     * If spaced is "never", then check whether option is set to true.
+     * @param {Object} option - The option to exclude.
+     * @returns {boolean} Whether or not the property is excluded.
+     */
+    function isOptionSet (option) {
+      return context.options[1] != null ? context.options[1][option] === !spaced : false
+    }
+
+    var options = {
+      spaced: spaced,
+      either: either,
+      arraysInObjectsException: isOptionSet('arraysInObjects'),
+      objectsInObjectsException: isOptionSet('objectsInObjects')
+    }
+
+    // --------------------------------------------------------------------------
+    // Helpers
+    // --------------------------------------------------------------------------
+
+    /**
+     * Determines whether two adjacent tokens are have whitespace between them.
+     * @param {Object} left - The left token object.
+     * @param {Object} right - The right token object.
+     * @returns {boolean} Whether or not there is space between the tokens.
+     */
+    function isSpaced (left, right) {
+      return left.range[1] < right.range[0]
+    }
+
+    /**
+     * Determines whether two adjacent tokens are on the same line.
+     * @param {Object} left - The left token object.
+     * @param {Object} right - The right token object.
+     * @returns {boolean} Whether or not the tokens are on the same line.
+     */
+    function isSameLine (left, right) {
+      return left.loc.start.line === right.loc.start.line
+    }
+
+    /**
+     * Reports that there shouldn't be a space after the first token
+     * @param {ASTNode} node - The node to report in the event of an error.
+     * @param {Token} token - The token to use for the report.
+     * @returns {void}
+     */
+    function reportNoBeginningSpace (node, token) {
+      context.report(node, token.loc.start,
+        "There should be no space after '" + token.value + "'")
+    }
+
+    /**
+     * Reports that there shouldn't be a space before the last token
+     * @param {ASTNode} node - The node to report in the event of an error.
+     * @param {Token} token - The token to use for the report.
+     * @returns {void}
+     */
+    function reportNoEndingSpace (node, token) {
+      context.report(node, token.loc.start,
+        "There should be no space before '" + token.value + "'")
+    }
+
+    /**
+     * Reports that there should be a space after the first token
+     * @param {ASTNode} node - The node to report in the event of an error.
+     * @param {Token} token - The token to use for the report.
+     * @returns {void}
+     */
+    function reportRequiredBeginningSpace (node, token) {
+      context.report(node, token.loc.start,
+        "A space is required after '" + token.value + "'")
+    }
+
+    /**
+     * Reports that there should be a space before the last token
+     * @param {ASTNode} node - The node to report in the event of an error.
+     * @param {Token} token - The token to use for the report.
+     * @returns {void}
+     */
+    function reportRequiredEndingSpace (node, token) {
+      context.report(node, token.loc.start,
+        "A space is required before '" + token.value + "'")
+    }
+
+    /**
+     * Checks if a start and end brace in a node are spaced evenly
+     * and not too long (>1 space)
+     * @param node
+     * @param start
+     * @param end
+     * @returns {boolean}
+     */
+    function isEvenlySpacedAndNotTooLong (node, start, end) {
+      var expectedSpace = start[1].range[0] - start[0].range[1]
+      var endSpace = end[1].range[0] - end[0].range[1]
+      return endSpace === expectedSpace && endSpace <= 1
+    }
+
+    /**
+     * Determines if spacing in curly braces is valid.
+     * @param {ASTNode} node The AST node to check.
+     * @param {Token} first The first token to check (should be the opening brace)
+     * @param {Token} second The second token to check (should be first after the opening brace)
+     * @param {Token} penultimate The penultimate token to check (should be last before closing brace)
+     * @param {Token} last The last token to check (should be closing brace)
+     * @returns {void}
+     */
+    function validateBraceSpacing (node, first, second, penultimate, last) {
+      var closingCurlyBraceMustBeSpaced =
+      (options.arraysInObjectsException && penultimate.value === ']') ||
+      (options.objectsInObjectsException && penultimate.value === '}')
+        ? !options.spaced : options.spaced
+
+      // we only care about evenly spaced things
+      if (options.either) {
+        // newlines at any point means return
+        if (!isSameLine(first, last)) {
+          return
+        }
+
+        // confirm that the object expression/literal is spaced evenly
+        if (!isEvenlySpacedAndNotTooLong(node, [first, second], [penultimate, last])) {
+          context.report(node, 'Expected consistent spacing')
+        }
+
+        return
+      }
+
+      // { and key are on same line
+      if (isSameLine(first, second)) {
+        if (options.spaced && !isSpaced(first, second)) {
+          reportRequiredBeginningSpace(node, first)
+        }
+        if (!options.spaced && isSpaced(first, second)) {
+          reportNoBeginningSpace(node, first)
+        }
+      }
+
+      // final key and } ore on the same line
+      if (isSameLine(penultimate, last)) {
+        if (closingCurlyBraceMustBeSpaced && !isSpaced(penultimate, last)) {
+          reportRequiredEndingSpace(node, last)
+        }
+        if (!closingCurlyBraceMustBeSpaced && isSpaced(penultimate, last)) {
+          reportNoEndingSpace(node, last)
+        }
+      }
+    }
+
+    // --------------------------------------------------------------------------
+    // Public
+    // --------------------------------------------------------------------------
+
+    return {
+      // var {x} = y
+      ObjectPattern: function (node) {
+        if (node.properties.length === 0) {
+          return
+        }
+
+        var firstSpecifier = node.properties[0]
+        var lastSpecifier = node.properties[node.properties.length - 1]
+
+        var first = context.getTokenBefore(firstSpecifier)
+        var second = context.getFirstToken(firstSpecifier)
+        var penultimate = context.getLastToken(lastSpecifier)
+        var last = context.getTokenAfter(lastSpecifier)
+
+        // support trailing commas
+        if (last.value === ',') {
+          penultimate = last
+          last = context.getTokenAfter(last)
+        }
+
+        validateBraceSpacing(node, first, second, penultimate, last)
+      },
+
+      // import {y} from 'x'
+      ImportDeclaration: function (node) {
+        var firstSpecifier = node.specifiers[0]
+        var lastSpecifier = node.specifiers[node.specifiers.length - 1]
+
+        // don't do anything for namespace or default imports
+        if (firstSpecifier && lastSpecifier && firstSpecifier.type === 'ImportSpecifier' && lastSpecifier.type === 'ImportSpecifier') {
+          var first = context.getTokenBefore(firstSpecifier)
+          var second = context.getFirstToken(firstSpecifier)
+          var penultimate = context.getLastToken(lastSpecifier)
+          var last = context.getTokenAfter(lastSpecifier)
+
+          validateBraceSpacing(node, first, second, penultimate, last)
+        }
+      },
+
+      // export {name} from 'yo'
+      ExportNamedDeclaration: function (node) {
+        if (!node.specifiers.length) {
+          return
+        }
+
+        var firstSpecifier = node.specifiers[0]
+        var lastSpecifier = node.specifiers[node.specifiers.length - 1]
+        var first = context.getTokenBefore(firstSpecifier)
+        var second = context.getFirstToken(firstSpecifier)
+        var penultimate = context.getLastToken(lastSpecifier)
+        var last = context.getTokenAfter(lastSpecifier)
+
+        validateBraceSpacing(node, first, second, penultimate, last)
+      },
+
+      // var y = {x: 'y'}
+      ObjectExpression: function (node) {
+        if (node.properties.length === 0) {
+          return
+        }
+
+        var first = context.getFirstToken(node)
+        var second = context.getFirstToken(node, 1)
+        var penultimate = context.getLastToken(node, 1)
+        var last = context.getLastToken(node)
+
+        validateBraceSpacing(node, first, second, penultimate, last)
+      }
+    }
+  }
+}