Bump packages to fix linter

node_modules/eslint-plugin-escompat/lib/index.js

@@ -0,0 +1,100 @@
+const path = require('path')
+const browserslist = require('browserslist')
+const {findConfig} = require('browserslist/node')
+const {version,homepage} = require('../package.json')
+const createRule = (name, browserstring, description, {ts = null} = {}) => {
+  const rule = require(`./rules/${name}`)
+  module.exports.rules[name] = {
+    meta: Object.assign({
+      type: 'problem',
+      docs: {
+        description,
+        recommended: true,
+        url: `${homepage}/blob/v${version}/docs/${name}.md`
+      },
+      fixable: false,
+      schema: [],
+      deprecated: false,
+      replacedBy: null,
+    }, rule.meta || {}),
+    create(context) {
+      let browsers = browserslist(browserstring)
+      const config = findConfig(path.dirname(context.getFilename())) || { defaults: 'defaults' }
+      const desiredBrowsers = browserslist(config.defaults)
+      const badBrowsers = desiredBrowsers.filter(browser => browsers.indexOf(browser) !== -1).join(', ')
+      if (badBrowsers) {
+        const create = typeof rule === 'function' ? rule : rule.create
+        return create(context, badBrowsers)
+      }
+      return {}
+    }
+  }
+
+  const configName = `typescript-${ts || 'base'}`
+  if (!module.exports.configs[configName]) {
+    let config = {rules: {}}
+    if (ts === 2016) {
+      config.extends = [`plugin:escompat/typescript-base`]
+    } else if (ts) {
+      let previous = ts - 1
+      while (!module.exports.configs[`typescript-${previous}`]) previous -= 1
+      
+      config.extends = [`plugin:escompat/typescript-${previous}`]
+    }
+    module.exports.configs[configName] = config
+  }
+  module.exports.configs[`typescript-base`].rules[`escompat/${name}`] = 'off'
+  module.exports.configs[configName].rules[`escompat/${name}`] = 'error'
+}
+
+module.exports = { rules: {}, configs: {} }
+// ES2015
+createRule('no-edge-destructure-bug', 'edge < 18', 'disallow the use of specific destructuring patterns that cause bugs in old Edge')
+
+// ES2016
+createRule('no-exponentiation-operator', 'chrome < 52, edge < 14, firefox < 52, safari < 10.1', 'disallow use of exponentiation operator (**)', {ts: 2016})
+
+// ES2018
+createRule('no-async-iteration', 'edge < 79, safari < 12, firefox < 57, chrome < 63', 'disallow the use of `for await of` style loops', {ts: 2018})
+createRule('no-async-generator', 'edge < 79, safari < 12, firefox < 57, chrome < 63', 'disallow the use of async generator functions', {ts: 2018})
+createRule('no-object-rest-spread', 'edge < 79, safari < 11.1, firefox < 55, chrome < 60', 'disallow object rest/spread patterns', {ts: 2018})
+createRule('no-regexp-s-flag', 'edge < 79, safari < 11.1, firefox < 78, chrome < 62', 'disallow the use of the RegExp `s` flag')
+createRule('no-regexp-lookbehind', 'edge < 79, safari > 0, firefox < 78, chrome < 62', 'disallow the use of RegExp lookbehinds')
+createRule('no-regexp-named-group', 'edge < 79, safari 11.1, firefox < 78, chrome < 64', 'disallow the use of RegExp named groups')
+
+// ES2019
+createRule('no-optional-catch', 'edge < 79, safari < 11.1, firefox < 58, chrome < 66', 'always require catch() to have an argument', {ts: 2019})
+
+// ES2020
+createRule('no-dynamic-imports', 'edge < 79, safari < 11, firefox < 67, chrome < 63', 'disallow dynamic import statements')
+createRule('no-optional-chaining', 'edge < 80, safari < 13.1, firefox < 72, chrome < 80', 'disallow the .? optional chaning operator', {ts: 2020})
+createRule('no-nullish-coalescing', 'edge < 80, safari < 13.1, firefox < 72, chrome < 80', 'disallow the ?? nullish coalescing operator', {ts: 2020})
+createRule('no-bigint', 'edge < 79, safari < 14, firefox < 68, chrome < 67', 'disallow bigints')
+
+// ES2021
+createRule('no-numeric-separators', 'edge < 79, safari < 13, firefox < 68, chrome < 75', 'disallow use of numeric seperators like 1_000_000', {ts:2021})
+
+// ES2022
+createRule('no-public-static-class-fields', 'edge < 79, safari < 14.5, firefox < 75, chrome < 72', 'disallow public static class fields like foo = 1', {ts: 2022})
+createRule('no-public-instance-class-fields', 'edge < 79, safari < 14.5, firefox < 69, chrome < 72', 'disallow public class fields like foo = 1', {ts: 2022})
+createRule('no-computed-public-class-fields', 'edge < 79, safari < 14.5, firefox < 69, chrome < 74', 'disallow computed public static or instance class fields like [foo] = 1', {ts: 2022})
+createRule('no-private-class-fields', 'edge < 79, safari < 14.5, firefox < 90, chrome < 74', 'disallow private class fields like #foo = 1', {ts: 2022})
+
+// Proposals...
+createRule('no-do-expression', 'edge > 0, safari > 0, firefox > 0, chrome > 0', 'disallow "do" expressions')
+createRule('no-bind-operator', 'edge > 0, safari > 0, firefox > 0, chrome > 0', 'disallow the :: bind operator')
+createRule('no-pipeline-operator', 'edge > 0, safari > 0, firefox > 0, chrome > 0', 'disallow the > pipeline operator')
+
+module.exports.configs.recommended = {
+  plugins: ['escompat'],
+  parserOptions: { ecmaVersion: 2020 },
+  rules: Object.keys(module.exports.rules).reduce((o, r) => (o['escompat/' + r] = ['error'], o), {})
+}
+
+module.exports.configs.typescript = {
+  extends: ['plugin:escompat/typescript-2016']
+}
+
+if (require.main === module) {
+  console.log(require('util').inspect(module.exports, {depth: Infinity}))
+}

node_modules/eslint-plugin-escompat/lib/rules/no-async-generator.js

@@ -0,0 +1,5 @@
+module.exports = (context, badBrowser) => ({
+  ':function[async=true][generator=true]'(node) {
+    context.report(node, `Async Generators are not supported in ${badBrowser}`)
+  }
+})

node_modules/eslint-plugin-escompat/lib/rules/no-async-iteration.js

@@ -0,0 +1,5 @@
+module.exports = (context, badBrowser) => ({
+  'ForOfStatement[await=true]'(node) {
+    context.report(node, `Async Iteration is not supported in ${badBrowser}`)
+  }
+})

node_modules/eslint-plugin-escompat/lib/rules/no-bigint.js

@@ -0,0 +1,5 @@
+module.exports = (context, badBrowser) => ({
+  'Literal[bigint]'(node) {
+    context.report(node, `BigInts are not supported in ${badBrowser}`)
+  }
+})

node_modules/eslint-plugin-escompat/lib/rules/no-bind-operator.js

@@ -0,0 +1,5 @@
+module.exports = (context, badBrowser) => ({
+  BindExpression(node) {
+    context.report(node, `The Bind Operator is not supported in ${badBrowser}`)
+  }
+})

node_modules/eslint-plugin-escompat/lib/rules/no-computed-public-class-fields.js

@@ -0,0 +1,9 @@
+module.exports = (context, badBrowser) => ({
+  // Ignore type annotations that don't assign
+  'ClassProperty[computed=true]:not([typeAnnotation]:not([value]))'(node) {
+    context.report(node, `Computed Class Fields are not supported in ${badBrowser}`)
+  },
+  'PropertyDefinition[computed=true]:not([typeAnnotation]:not([value]))'(node) {
+    context.report(node, `Computed Class Fields are not supported in ${badBrowser}`)
+  }
+})

node_modules/eslint-plugin-escompat/lib/rules/no-do-expression.js

@@ -0,0 +1,5 @@
+module.exports = (context, badBrowser) => ({
+  DoExpression(node) {
+    context.report(node, `Do Expressions are not supported in ${badBrowser}`)
+  }
+})

node_modules/eslint-plugin-escompat/lib/rules/no-dynamic-imports.js

@@ -0,0 +1,5 @@
+module.exports = (context, badBrowser) => ({
+  'ImportExpression, CallExpression[callee.type="Import"]'(node) {
+    context.report(node, `Dynamic import is not supported in ${badBrowser}`)
+  }
+})

node_modules/eslint-plugin-escompat/lib/rules/no-edge-destructure-bug.js

@@ -0,0 +1,29 @@
+const objectPatternHasDefaults = node =>
+  node.type === 'ObjectPattern' && node.properties.some(prop => prop.value.type === 'AssignmentPattern')
+
+module.exports = function(context) {
+  return {
+    ArrowFunctionExpression(node) {
+      // Unary functions don't trip on this bug
+      if (node.params.length < 2) return
+
+      // This bug only occurs when some arguments use Object destructuring
+      if (!node.params.some(param => param.type === 'ObjectPattern')) return
+
+      const objectPatternArgs = node.params.filter(node => node.type === 'ObjectPattern')
+
+      // This bug is only occurs when an argument uses Object Destructuring with Default assignment
+      if (!objectPatternArgs.some(objectPatternHasDefaults)) return
+
+      // This bug gets fixed if the first argument uses Object destructuring with default assignments!
+      if (node.params[0].type === 'ObjectPattern' && objectPatternHasDefaults(node.params[0])) return
+
+      context.report(
+        node,
+        'There is an Edge 15-17 bug which causes second argument destructuring to fail. See https://git.io/fhd7N for more'
+      )
+    }
+  }
+}
+
+module.exports.schema = []

node_modules/eslint-plugin-escompat/lib/rules/no-exponentiation-operator.js

@@ -0,0 +1,5 @@
+module.exports = (context, badBrowser) => ({
+  'AssignmentExpression[operator="**="], BinaryExpression[operator="**"]'(node) {
+    context.report(node, `Exponentiation Operator is not supported in ${badBrowser}`)
+  }
+})

node_modules/eslint-plugin-escompat/lib/rules/no-nullish-coalescing.js

@@ -0,0 +1,5 @@
+module.exports = (context, badBrowser) => ({
+  'LogicalExpression[operator="??"]'(node) {
+    context.report(node, `the Nullish Coalescing Operator is not supported in ${badBrowser}`)
+  }
+})

node_modules/eslint-plugin-escompat/lib/rules/no-numeric-separators.js

@@ -0,0 +1,14 @@
+module.exports = {
+  meta: {
+    fixable: 'code'
+  },
+  create: (context, badBrowser) => ({
+    'Literal[raw=/_/][value>=0], Literal[raw=/_/][value<=0]'(node) {
+      context.report({
+        node,
+        message: `Numeric Separators are not supported in ${badBrowser}`,
+        fix: fixer => fixer.replaceText(node, String(node.value))
+      })
+    }
+  })
+}

node_modules/eslint-plugin-escompat/lib/rules/no-object-rest-spread.js

@@ -0,0 +1,16 @@
+module.exports = (context, badBrowser) => ({
+  'ObjectExpression > SpreadElement'(node) {
+    context.report(node, `Object Rest/Spread is not supported in ${badBrowser}`)
+  },
+  'ObjectPattern > RestElement'(node) {
+    context.report(node, `Object Rest/Spread is not supported in ${badBrowser}`)
+  },
+
+  // Catch older versions of eslint and babel-eslint
+  ExperimentalRestProperty(node) {
+    context.report(node, `Object Rest/Spread is not supported in ${badBrowser}`)
+  },
+  ExperimentalSpreadProperty(node) {
+    context.report(node, `Object Rest/Spread is not supported in ${badBrowser}`)
+  },
+})

node_modules/eslint-plugin-escompat/lib/rules/no-optional-catch.js

@@ -0,0 +1,5 @@
+module.exports = (context, badBrowser) => ({
+  'CatchClause:not([param])'(node) {
+    context.report(node, `Optional Catch Parameters are not supported in ${badBrowser}`)
+  }
+})

node_modules/eslint-plugin-escompat/lib/rules/no-optional-chaining.js

@@ -0,0 +1,8 @@
+module.exports = (context, badBrowser) => ({
+  OptionalMemberExpression(node) {
+    context.report(node, `Optional Chaining is not supported in ${badBrowser}`)
+  },
+  ChainExpression(node) {
+    context.report(node, `Optional Chaining is not supported in ${badBrowser}`)
+  }
+})

node_modules/eslint-plugin-escompat/lib/rules/no-pipeline-operator.js

@@ -0,0 +1,5 @@
+module.exports = (context, badBrowser) => ({
+  'BinaryExpression[operator="|>"]'(node) {
+    context.report(node, `The Pipeline Operator is not supported in ${badBrowser}`)
+  }
+})

node_modules/eslint-plugin-escompat/lib/rules/no-private-class-fields.js

@@ -0,0 +1,8 @@
+module.exports = (context, badBrowser) => ({
+  ClassPrivateProperty(node) {
+    context.report(node, `Private Class Fields are not supported in ${badBrowser}`)
+  },
+  PrivateIdentifier(node) {
+    context.report(node, `Private Class Fields are not supported in ${badBrowser}`)
+  }
+})

node_modules/eslint-plugin-escompat/lib/rules/no-public-instance-class-fields.js

@@ -0,0 +1,11 @@
+module.exports = (context, badBrowser) => ({
+  // Ignore type annotations that don't assign
+  'ClassProperty[static=false]:not([typeAnnotation]:not([value]))'(node) {
+    if (node.value === null) return
+    context.report(node, `Instance Class Fields are not supported in ${badBrowser}`)
+  },
+  'PropertyDefinition[static=false]:not([typeAnnotation]:not([value]))'(node) {
+    if (node.value === null) return
+    context.report(node, `Instance Class Fields are not supported in ${badBrowser}`)
+  }
+})

node_modules/eslint-plugin-escompat/lib/rules/no-public-static-class-fields.js

@@ -0,0 +1,9 @@
+module.exports = (context, badBrowser) => ({
+  // Ignore type annotations that don't assign
+  'ClassProperty[static=true]:not([typeAnnotation]:not([value]))'(node) {
+    context.report(node, `Static Class Fields are not supported in ${badBrowser}`)
+  },
+  'PropertyDefinition[static=true]:not([typeAnnotation]:not([value]))'(node) {
+    context.report(node, `Static Class Fields are not supported in ${badBrowser}`)
+  }
+})

node_modules/eslint-plugin-escompat/lib/rules/no-regexp-lookbehind.js

@@ -0,0 +1,28 @@
+const hasLookbehind = s => s.includes('(?<=') || s.includes('(?<!)')
+
+module.exports = (context, badBrowser) => ({
+  'Literal[regex]'(node) {
+    if (hasLookbehind(node.regex.pattern)) {
+      context.report(node, `RegExp lookbehinds are not supported in ${badBrowser}`)
+    }
+  },
+  'CallExpression[callee.name="RegExp"], NewExpression[callee.name="RegExp"]'(node) {
+    const [source] = node.arguments;
+    if (
+      source &&
+      (
+        (
+          source.type === 'Literal' &&
+          typeof source.value === 'string' &&
+          hasLookbehind(source.value)
+        ) ||
+        (
+          source.type === 'TemplateLiteral' &&
+          source.quasis.some(({value: {raw}}) => hasLookbehind(raw))
+        )
+      )
+    ) {
+      context.report(node, `RegExp lookbehinds are not supported in ${badBrowser}`)
+    }
+  }
+})

node_modules/eslint-plugin-escompat/lib/rules/no-regexp-named-group.js

@@ -0,0 +1,28 @@
+const hasNamedGroup = s => /\(\?<[_$\w]/.test(s)
+
+module.exports = (context, badBrowser) => ({
+  'Literal[regex]'(node) {
+    if (hasNamedGroup(node.regex.pattern)) {
+      context.report(node, `RegExp named groups are not supported in ${badBrowser}`)
+    }
+  },
+  'CallExpression[callee.name="RegExp"], NewExpression[callee.name="RegExp"]'(node) {
+    const [source] = node.arguments;
+    if (
+      source &&
+      (
+        (
+          source.type === 'Literal' &&
+          typeof source.value === 'string' &&
+          hasNamedGroup(source.value)
+        ) ||
+        (
+          source.type === 'TemplateLiteral' &&
+          source.quasis.some(({value: {raw}}) => hasNamedGroup(raw))
+        )
+      )
+    ) {
+      context.report(node, `RegExp named groups are not supported in ${badBrowser}`)
+    }
+  }
+})

node_modules/eslint-plugin-escompat/lib/rules/no-regexp-s-flag.js

@@ -0,0 +1,26 @@
+module.exports = (context, badBrowser) => ({
+  'Literal[regex]'(node) {
+    if (node.regex.flags.includes('s')) {
+      context.report(node, `RegExp "s" flag is not supported in ${badBrowser}`)
+    }
+  },
+  'CallExpression[callee.name="RegExp"], NewExpression[callee.name="RegExp"]'(node) {
+    const [, flags] = node.arguments;
+    if (
+      flags && 
+      (
+        (
+          flags.type === 'Literal' &&
+          typeof flags.value === 'string' &&
+          flags.value.includes('s')
+        ) || 
+        (
+          flags.type === 'TemplateLiteral' &&
+          flags.quasis.some(({value: {raw}}) => raw.includes('s'))
+        )
+      )
+    ) {
+      context.report(node, `RegExp "s" flag is not supported in ${badBrowser}`)
+    }
+  }
+})