JSLint, The JavaScript Code Quality and Coverage Tool

August 2, 2026 · View on GitHub

Status

Branch	master (v2026.7.30)	beta (Web Demo)	alpha (Development)
CI
Coverage
Demo
Artifacts

Web Demo

https://www.jslint.com

Web Demo Archived

Quickstart Install
Quickstart JSLint Report
- To create a JSLint report in shell:
- To create a JSLint report in javascript:
Quickstart V8 Coverage Report
- To create V8 coverage report from Node.js / Npm program in shell:
- To create V8 coverage report from Node.js / Npm program in javascript:
Quickstart JSLint in CodeMirror
Quickstart JSLint in Vim
Quickstart JSLint in VSCode
Documentation
Package Listing
Changelog
License
Devops Instruction

Quickstart Install

To install, just download and save https://www.jslint.com/jslint.mjs to file:

#!/bin/sh

curl -L https://www.jslint.com/jslint.mjs > jslint.mjs

shell output

screenshot

To run `jslint.mjs` in shell:

#!/bin/sh

printf "console.log('hello world');\n" > hello.js

node jslint.mjs hello.js

shell output

screenshot

To import `jslint.mjs` in ES Module environment:

#!/bin/sh

node --input-type=module --eval '

/*jslint devel*/

// Import JSLint in ES Module environment.

import jslint from "./jslint.mjs";

let globals = ["caches", "indexedDb"];
let options = {browser: true};
let result;
let source = "console.log(\u0027hello world\u0027);\n";

// JSLint <source> and print <formatted_message>.

result = jslint.jslint(source, options, globals);
result.warnings.forEach(function ({
    formatted_message
}) {
    console.error(formatted_message);
});

'

shell output

screenshot

To import `jslint.mjs` in CommonJS environment:

#!/bin/sh

node --eval '

/*jslint devel*/
(async function () {
    let globals = ["caches", "indexedDb"];
    let jslint;
    let options = {browser: true};
    let result;
    let source = "console.log(\u0027hello world\u0027);\n";

// Import JSLint in CommonJS environment.

    jslint = await import("./jslint.mjs");
    jslint = jslint.default;

// JSLint <source> and print <formatted_message>.

    result = jslint.jslint(source, options, globals);
    result.warnings.forEach(function ({
        formatted_message
    }) {
        console.error(formatted_message);
    });
}());

'

shell output

screenshot

To JSLint entire directory in shell:

#!/bin/sh

# JSLint directory '.'

node jslint.mjs .

shell output

screenshot

Quickstart JSLint Report

To create a JSLint report in shell:

#!/bin/sh

printf "function foo() {console.log('hello world');}\n" > hello.js

# Create JSLint report from file 'hello.js' in shell.

node jslint.mjs \
    jslint_report=.artifact/jslint_report_hello.html \
    hello.js

shell output

screenshot

screenshot file .artifact/jslint_report_hello.html

To create a JSLint report in javascript:

#!/bin/sh

node --input-type=module --eval '

/*jslint devel*/
import jslint from "./jslint.mjs";
import fs from "fs";
(async function () {
    let result;
    let source = "function foo() {console.log(\u0027hello world\u0027);}\n";

// Create JSLint report from <source> in javascript.

    result = jslint.jslint(source);
    result = jslint.jslint_report(result);
    result = `<body class="JSLINT_ JSLINT_REPORT_">\n${result}</body>\n`;

    await fs.promises.mkdir(".artifact/", {recursive: true});
    await fs.promises.writeFile(".artifact/jslint_report_hello.html", result);
    console.error("wrote file .artifact/jslint_report_hello.html");
}());

'

shell output

screenshot

screenshot file .artifact/jslint_report_hello.html

Quickstart V8 Coverage Report

To create V8 coverage report from Node.js / Npm program in shell:

#!/bin/sh

git clone https://github.com/tryghost/node-sqlite3 node-sqlite3-sh \
    --branch=v5.0.11 \
    --depth=1 \
    --single-branch

cd node-sqlite3-sh
npm install

# Create V8 coverage report from program `npm run test` in shell.

node ../jslint.mjs \
    v8_coverage_report=../.artifact/coverage_sqlite3_sh/ \
        --exclude=tes?/ \
        --exclude=tes[!0-9A-Z_a-z-]/ \
        --exclude=tes[0-9A-Z_a-z-]/ \
        --exclude=tes[^0-9A-Z_a-z-]/ \
        --exclude=test/**/*.js \
        --exclude=test/suppor*/*elper.js \
        --exclude=test/suppor?/?elper.js \
        --exclude=test/support/helper.js \
        --include=**/*.cjs \
        --include=**/*.js \
        --include=**/*.mjs \
        --include=li*/*.js \
        --include=li?/*.js \
        --include=lib/ \
        --include=lib/**/*.js \
        --include=lib/*.js \
        --include=lib/sqlite3.js \
    npm run test

shell output

screenshot

screenshot file .artifact/coverage_sqlite3_sh/index.html

screenshot file .artifact/coverage_sqlite3_sh/lib/sqlite3.js.html

To create V8 coverage report from Node.js / Npm program in javascript:

#!/bin/sh

git clone https://github.com/tryghost/node-sqlite3 node-sqlite3-js \
    --branch=v5.0.11 \
    --depth=1 \
    --single-branch

cd node-sqlite3-js
npm install

node --input-type=module --eval '

/*jslint node*/
import jslint from "../jslint.mjs";
(async function () {

// Create V8 coverage report from program `npm run test` in javascript.

    await jslint.v8CoverageReportCreate({
        coverageDir: "../.artifact/coverage_sqlite3_js/",
        processArgv: [
            "--exclude=tes?/",
            "--exclude=tes[!0-9A-Z_a-z-]/",
            "--exclude=tes[0-9A-Z_a-z-]/",
            "--exclude=tes[^0-9A-Z_a-z-]/",
            "--exclude=test/**/*.js",
            "--exclude=test/suppor*/*elper.js",
            "--exclude=test/suppor?/?elper.js",
            "--exclude=test/support/helper.js",
            "--include=**/*.cjs",
            "--include=**/*.js",
            "--include=**/*.mjs",
            "--include=li*/*.js",
            "--include=li?/*.js",
            "--include=lib/",
            "--include=lib/**/*.js",
            "--include=lib/*.js",
            "--include=lib/sqlite3.js",
            "npm", "run", "test"
        ]
    });
}());

'

shell output

screenshot

screenshot file .artifact/coverage_sqlite3_js/index.html

screenshot file .artifact/coverage_sqlite3_js/lib/sqlite3.js.html

Quickstart JSLint in CodeMirror

Download and save jslint.mjs, jslint_wrapper_codemirror.js to file.
Edit, save, and serve example html-file below:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="utf-8">
    <title>CodeMirror: JSLint Demo</title>

<!-- Assets from codemirror. -->

    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/codemirror/5.65.10/codemirror.css">
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/codemirror/5.65.10/addon/lint/lint.css">
    <script defer src="https://cdnjs.cloudflare.com/ajax/libs/codemirror/5.65.10/codemirror.js"></script>
    <script defer src="https://cdnjs.cloudflare.com/ajax/libs/codemirror/5.65.10/mode/javascript/javascript.js"></script>
    <script defer src="https://cdnjs.cloudflare.com/ajax/libs/codemirror/5.65.10/addon/lint/lint.js"></script>

<!-- Assets from jslint. -->

    <script type="module" src="./jslint.mjs?window_jslint=1"></script>
    <script defer src="./jslint_wrapper_codemirror.js"></script>
<style>
body {
    background: #bbb;
    color: #333;
    font-family: sans-serif;
    margin: 20px;
}
.JSLINT_.JSLINT_REPORT_ {
    margin-top: 20px;
}
#editor1 {
    height: 300px;
    width: 100%;
}
</style>
</head>


<body>
    <h1>CodeMirror: JSLint Demo</h1>
    <h3>
This demo will auto-lint the code below, and auto-generate a report as you type.
    </h3>

<!-- Container for codemirror-editor. -->

    <textarea id="editor1">console.log('hello world');</textarea>

<!-- Container for jslint-report. -->

    <div class="JSLINT_ JSLINT_REPORT_"></div>


<script type=module>
window.addEventListener("load", function () {
    let editor = window.CodeMirror.fromTextArea(document.getElementById(
        "editor1"
    ), {
        gutters: [
            "CodeMirror-lint-markers"
        ],
        indentUnit: 4,
        lineNumbers: true,
        lint: {
            lintOnChange: true, // Enable auto-lint.
            options: {
                // browser: true,
                // node: true
                globals: [
                    // "caches",
                    // "indexedDb"
                ]
            }
        },
        mode: "javascript"
    });

// Initialize event-handling before linter is run.

    editor.on("lintJslintBefore", function (/* options */) {
        // options.browser = true;
        // options.node = true;
        // options.globals = [
        //     "caches",
        //     "indexedDb"
        // ];
        return;
    });

// Initialize event-handling after linter is run.

    editor.on("lintJslintAfter", function (options) {

// Generate jslint-report from options.result.

        document.querySelector(
            ".JSLINT_REPORT_"
        ).innerHTML = window.jslint.jslint_report(options.result);
    });

// Manually trigger linter.

    editor.performLint();
});
</script>
</body>
</html>

Live example at https://www.jslint.com/jslint_wrapper_codemirror.html

Quickstart JSLint in Vim

Download and save jslint.mjs, jslint_wrapper_vim.vim to directory ~/.vim/
Add vim-command :source ~/.vim/jslint_wrapper_vim.vim to file ~/.vimrc
- If above files were saved to custom-directory, then use that directory instead, e.g.:
  - save jslint.mjs, jslint_wrapper_vim.vim to directory ~/vimfiles/
  - vim-command :source ~/vimfiles/jslint_wrapper_vim.vim
Vim can now jslint files (via nodejs):
- with vim-command :SaveAndJslint
- with vim-key-combo <Ctrl-S> <Ctrl-J>

screenshot

Quickstart JSLint in VSCode

In VSCode, search and install extension vscode-jslint
In VSCode, while editing a javascript file:
- right-click context-menu and select [JSLint - Lint File]
- or use key-binding [Ctrl + Shift + J], [L]
- or use key-binding [ Cmd + Shift + J], [L] for Mac

screenshot

Documentation

jslint.mjs contains the jslint function. It parses and analyzes a source file, returning an object with information about the file. It can also take an object that sets options.
index.html runs the jslint.mjs function in a web page.

API Doc

https://www.jslint.com/apidoc.html

Directive

`/jslint beta/`

/*jslint beta*/
// Enable experimental warnings.
// Warn if global variables are redefined.
// Warn if const / let statements are not declared at top of function or
//    script, similar to var statements.
// Warn if const / let / var statements are not declared in ascii-order.
// Warn if named-functions are not declared in ascii-order.
// Warn if cases in switch-statements are not in ascii-order.

`/jslint bitwise/`

/*jslint bitwise*/
// Allow bitwise operator.

let foo = 0 | 1;

`/jslint browser/`

/*jslint browser*/
// Assume browser environment.

localStorage.getItem("foo");

`/jslint convert/`

/*jslint convert*/
// Allow conversion operator.

let foo = new Date() + "";
let bar = !!0;

`/jslint couch/`

/*jslint couch*/
// Assume CouchDb environment.

registerType("text-json", "text/json");

`/jslint devel/`

/*jslint devel*/
// Allow console.log() and friends.

console.log("hello");

`/jslint eval/`

/*jslint eval*/
// Allow eval().

eval("1");

`/jslint fart/`

/*jslint fart*/
// Allow complex fat-arrow.

let foo = async ({bar, baz}) => {
    return await bar(baz);
};

`/jslint getset/`

/*jslint getset, this, devel*/
// Allow get() and set().

let foo = {
    bar: 0,
    get getBar() {
        return this.bar;
    },
    set setBar(value) {
        this.bar = value;
    }
};
console.log(foo.getBar); // 0
foo.setBar = 1;
console.log(foo.getBar); // 1

`/jslint indent2/`

/*jslint indent2*/
// Use 2-space indent.

function foo() {
  return;
}

`/jslint long/`

/*jslint long*/
// Allow long lines.

let foo = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";

`/jslint node/`

/*jslint node*/
// Assume Node.js environment.

require("fs");

`/jslint nomen/`

/*jslint nomen*/
// Allow weird property name.

let foo = {};
foo._bar = 1;

`/jslint single/`

/*jslint single*/
// Allow single-quote strings.

let foo = '';

`/jslint subscript/`

/*jslint subscript*/
// Allow identifiers in subscript-notation.

let foo = {};
foo["bar"] = 1;

`/jslint this/`

/*jslint this*/
// Allow 'this'.

function foo() {
    return this;
}

`/jslint trace/`

/*jslint trace*/
// Include jslint stack-trace in warnings.

console.log('hello world');
/*
1. Undeclared 'console'.
console.log('hello world');
Error
    at warn_at (...)
    at warn (...)
    at lookup (...)
    at pre_v (...)
    at jslint.mjs
2. Use double quotes, not single quotes.
console.log(...);
Error
    at warn_at (...)
    at lex_string (...)
    at lex_token (...)
    at jslint_phase2_lex (...)
    at Function.jslint (...)
    at jslint.mjs
*/

`/jslint unordered/`

/*jslint unordered*/
// Allow unordered cases, params, properties, variables, and exports.

let foo = {bb: 1, aa: 0};

function bar({
    bb = 1,
    aa = 0
}) {
    return aa + bb;
}

export {
    foo,
    bar
};

`/jslint white/`

/*jslint white*/
// Allow messy whitespace.

let foo = 1; let bar = 2;

`/global/`

/*global foo, bar*/
// Declare global variables foo, bar.

foo();
bar();

`/property/`

/*property foo, bar*/
// Restrict property-access to only .foo, .bar.

let aa = {bar: 1, foo: 2};

`/jslint-disable/.../jslint-enable/`

/*jslint-disable*/

JSLint will ignore and treat this region as blank-lines.
Syntax error.

/*jslint-enable*/

`//jslint-ignore-line`

// JSLint will ignore non-fatal warnings at given line.

eval("1"); //jslint-ignore-line

`/coverage-disable/.../coverage-enable/`

/*coverage-disable*/

// JSLint will ignore code-coverage in this region.

if (false) {
    console.log("hello world");
}

/*coverage-enable*/

`//coverage-ignore-line`

// JSLint will ignore code-coverage at given line.

if (false) {
    console.log("hello world"); //coverage-ignore-line
}

ECMAScript Feature Support

#.	JSLint Support	ES Version	ES Feature
99.	❌	ES2027	`Explicit Resource Management`
98.	✅	ES2027	`Atomics.pause`
97.	❌	ES2027	`Joint Iteration`
96.	✅	ES2027	`Temporal`
95.	✅	ES2026	`Upsert`
94.	✅	ES2026	`JSON.parse source text access`
93.	❌	ES2026	`Iterator Sequencing`
92.	✅	ES2026	`Uint8Array to/from Base64`
91.	✅	ES2026	`Math.sumPrecise`
90.	✅	ES2026	`Error.isError`
89.	✅	ES2026	`Array.fromAsync`
88.	✅	ES2025	`RegExp.escape`
87.	✅	ES2025	`Redeclarable global eval-introduced vars`
86.	✅	ES2025	`Float16 on TypedArrays, DataView, Math.f16round`
85.	✅	ES2025	`Promise.try`
84.	❌	ES2025	`Sync Iterator helpers`
83.	✅	ES2025	`JSON Modules`
82.	✅	ES2025	`Import Attributes`
81.	✅	ES2025	`RegExp Modifiers`
80.	✅	ES2025	`New Set methods`
79.	✅	ES2025	`Duplicate named capture groups`
78.	✅	ES2024	`ArrayBuffer transfer`
77.	✅	ES2024	`Promise.withResolvers`
76.	✅	ES2024	`Array Grouping`
75.	✅	ES2024	`Resizable and growable ArrayBuffers`
74.	⚠️	ES2024	`RegExp v flag with set notation + properties of strings`
73.	✅	ES2024	`Atomics.waitAsync`
72.	✅	ES2024	`Well-Formed Unicode Strings`
71.	✅	ES2023	`Change Array by Copy`
70.	✅	ES2023	`Symbols as WeakMap keys`
69.	✅	ES2023	`Hashbang Grammar`
68.	✅	ES2023	`Array find from last`
67.	✅	ES2022	`Error Cause`
66.	❌	ES2022	`Class Static Block`
65.	✅	ES2022	`Accessible Object.prototype.hasOwnProperty`
64.	✅	ES2022	`.at()`
63.	❌	ES2022	`Ergonomic brand checks for Private Fields`
62.	✅	ES2022	`Top-level await`
61.	✅	ES2022	`RegExp Match Indices`
60.	❌	ES2022	`Class Public Instance Fields & Private Instance Fields`
59.	✅	ES2021	`Numeric separators`
58.	✅	ES2021	`Logical Assignment Operators`
57.	✅	ES2021	`WeakRefs`
56.	✅	ES2021	`Promise.any`
55.	✅	ES2021	`String.prototype.replaceAll`
54.	✅	ES2020	`import.meta`
53.	✅	ES2020	`Nullish coalescing Operator`
52.	✅	ES2020	`Optional Chaining`
51.	✅	ES2020	`for-in mechanics`
50.	✅	ES2020	`globalThis`
49.	✅	ES2020	`Promise.allSettled`
48.	✅	ES2020	`BigInt`
47.	✅	ES2020	`import()`
46.	✅	ES2020	`String.prototype.matchAll`
45.	✅	ES2019	`Array.prototype.{flat,flatMap}`
44.	✅	ES2019	`String.prototype.{trimStart,trimEnd}`
43.	✅	ES2019	`Well-formed JSON.stringify`
42.	✅	ES2019	`Object.fromEntries`
41.	✅	ES2019	`Function.prototype.toString revision`
40.	✅	ES2019	`Symbol.prototype.description`
39.	✅	ES2019	`JSON superset`
38.	✅	ES2019	`Optional catch binding`
37.	❌	ES2018	`Asynchronous Iteration`
36.	✅	ES2018	`Promise.prototype.finally`
35.	✅	ES2018	`RegExp Unicode Property Escapes`
34.	✅	ES2018	`RegExp Lookbehind Assertions`
33.	✅	ES2018	`Rest/Spread Properties`
32.	✅	ES2018	`RegExp named capture groups`
31.	✅	ES2018	`s (dotAll) flag for regular expressions`
30.	✅	ES2018	`Lifting template literal restriction`
29.	✅	ES2017	`Shared memory and atomics`
28.	✅	ES2017	`Async functions`
27.	⚠️	ES2017	`Trailing commas in function parameter lists and calls`
26.	✅	ES2017	`Object.getOwnPropertyDescriptors`
25.	✅	ES2017	`String padding`
24.	✅	ES2017	`Object.values/Object.entries`
23.	✅	ES2016	`Exponentiation operator`
22.	✅	ES2016	`Array.prototype.includes`
21.	✅	ES2015	`arrows`
20.	❌	ES2015	`classes`
19.	❌	ES2015	`enhanced object literals`
18.	✅	ES2015	`template strings`
17.	✅	ES2015	`destructuring`
16.	✅	ES2015	`default + rest + spread`
15.	✅	ES2015	`let + const`
14.	⚠️	ES2015	`iterators + for..of`
13.	❌	ES2015	`generators`
12.	✅	ES2015	`unicode`
11.	⚠️	ES2015	`modules`
10.	✅	ES2015	`module loaders`
9.	✅	ES2015	`map + set + weakmap + weakset`
8.	✅	ES2015	`proxies`
7.	✅	ES2015	`symbols`
6.	❌	ES2015	`subclassable built-ins`
5.	✅	ES2015	`promises`
4.	✅	ES2015	`math + number + string + array + object APIs`
3.	✅	ES2015	`binary and octal literals`
2.	✅	ES2015	`reflect api`
1.	✅	ES2015	`tail calls`

Package Listing

Changelog

Full CHANGELOG.md

License

JSLint is under Unlicense License.
CodeMirror editor is under MIT License.
Function v8CoverageListMerge is derived from MIT Licensed v8-coverage.

Devops Instruction

pull-request merge

update .github/workflows/ci.yml .github/workflows/publish.yml to:
- latest nodejs-lts version @ https://nodejs.org/en/about/previous-releases

update CHANGELOG.md

verify <CHANGELOG.md entry #1> is most-relevant to pull-request.

run

# re-run until version propagates
npm run test2

# update 'PR-xxx' placeholder
sh jslint_ci.sh shGithubPrUpdatePrxxx

# re-run until version propagates
sh jslint_ci.sh shGithubPrCreate alpha beta # v20yy.mm.dd __pr_beta_pre

git push upstream alpha -f

verify ci-success @ https://github.com/kaizhu256/jslint/actions
verify ci-success @ https://github.com/jslint-org/jslint/actions

goto https://github.com/jslint-org/jslint/compare/beta...kaizhu256:jslint:branch-p2026.7.20
- click Create pull request
- input Add a title * with: <CHANGELOG.md entry #1>
- input Add a description with:
```
Fixes #xxx.

This PR will:
<CHANGELOG.md entry #1>

This PR will additionally:
<CHANGELOG.md entry extra>

<screenshot>
```
- click Preview and review
- verify:
  - base respository: jslint-org/jslint
  - base: beta
- click Create pull request
  - verify ci-success @ https://github.com/jslint-org/jslint/actions/workflows/on_pull_request.yml
wait awhile before continuing ...
- click Squash and merge
  - verify ci-success @ https://github.com/jslint-org/jslint/actions
- run
```
sh jslint_ci.sh shGithubPrCleanup

git push upstream alpha -f
```
  - verify ci-success @ https://github.com/kaizhu256/jslint/actions
  - verify ci-success @ https://github.com/jslint-org/jslint/actions
- click Delete branch

branch-master commit

update .github/workflows/ci.yml .github/workflows/publish.yml to:
- latest nodejs-lts version @ https://nodejs.org/en/about/previous-releases

update CHANGELOG.md

verify <CHANGELOG.md entry #1> is most-relevant to pull-request.

run

# re-run until version propagates
npm run test2

# update 'PR-xxx' placeholder
sh jslint_ci.sh shGithubPrUpdatePrxxx

# re-run until version propagates
sh jslint_ci.sh shGithubPrCreate alpha master # v20yy.mm.dd __pr_master_pre

git push upstream alpha -f

verify ci-success @ https://github.com/kaizhu256/jslint/actions
verify ci-success @ https://github.com/jslint-org/jslint/actions

goto https://github.com/jslint-org/jslint/compare/beta...kaizhu256:jslint:branch-v2026.7.30
- click Create pull request
- input Add a title * with: # v20yy.mm.dd
- input Add a description with:
```
<CHANGELOG.md entry #1>
<CHANGELOG.md entry extra>
```
- click Preview and review
- verify:
  - base respository: jslint-org/jslint
  - base: beta
- click Create pull request
  - verify ci-success @ https://github.com/jslint-org/jslint/actions/workflows/on_pull_request.yml
wait awhile before continuing ...
- click Squash and merge
  - verify ci-success @ https://github.com/jslint-org/jslint/actions
- run
```
sh jslint_ci.sh shGithubPrCleanup

git push upstream alpha -f
```
  - verify ci-success @ https://github.com/kaizhu256/jslint/actions
  - verify ci-success @ https://github.com/jslint-org/jslint/actions
- click Delete branch
- run
```
git push origin beta:master

git push upstream beta:master
```
  - verify ci-success @ https://github.com/kaizhu256/jslint/actions
  - verify ci-success @ https://github.com/jslint-org/jslint/actions

branch-master publish

goto https://www.npmjs.com/package/@jslint-org/jslint/access
- click Github Actions
- input Organization or user* with: jslint-org
- input Repository* with: jslint
- input Workflow filename* with: publish.yml
- click Set up connection or Update Package Settings
- run
```
git push upstream beta:master
```
  - verify ci-success @ https://github.com/jslint-org/jslint/actions
goto https://github.com/jslint-org/jslint/releases/new
- input Tag: Select tag with: v20yy.mm.dd
  - click Create new tag and click Create
  - verify correct-year v20yy.mm.dd
  - select Target: master
- input Release title with: v20yy.mm.dd - <CHANGELOG.md entry #1>
  - select Previous tag: Auto
  - click Generate release notes
- input Write with:
```
<CHANGELOG.md entry #1>
<CHANGELOG.md entry extra>

**Full Changelog**: ...
```
- click Preview and review
- click Latest
- click Publish release
  - verify ci-success @ https://github.com/jslint-org/jslint/actions
  - verify email-notification Successfully published @jslint-org/jslint@20yy.mm.dd

vscode-jslint publish

goto https://github.com/jslint-org/jslint/tree/gh-pages/branch-beta/.artifact/jslint_wrapper_vscode
- click vscode-jslint-20yy.mm.dd.vsix
- click Raw to download
goto https://marketplace.visualstudio.com/manage/publishers/jslint
- move mouse to version-number, right-click, and select Update
- upload downloaded file vscode-jslint-20yy.mm.dd.vsix
- click 'Upload'
  - verify email-notification [Succeeded] Extension publish on Visual Studio Marketplace - vscode-jslint