Fix typos (#11805)

Author: szepeviktor

integrations/execute.js

@@ -5,10 +5,10 @@ let resolveToolRoot = require('./resolve-tool-root')
 
 let SHOW_OUTPUT = false
 
-let runningProcessess = []
+let runningProcesses = []
 
 afterEach(() => {
-  runningProcessess.splice(0).forEach((runningProcess) => runningProcess.stop())
+  runningProcesses.splice(0).forEach((runningProcess) => runningProcess.stop())
 })
 
 function debounce(fn, ms) {
@@ -129,7 +129,7 @@ module.exports = function $(command, options = {}) {
     })
   })
 
-  runningProcessess.push(runningProcess)
+  runningProcesses.push(runningProcess)
 
   return Object.assign(runningProcess, {
     stop() {

oxide/crates/core/src/parser.rs

@@ -417,7 +417,7 @@ impl<'a> Extractor<'a> {
                 // a flag. E.g.: '<sm'
                 // | '$' | '^' | '_'
 
-                // When the new candidate is preceeded by a `:`, then we want to keep parsing, but
+                // When the new candidate is preceded by a `:`, then we want to keep parsing, but
                 // throw away the full candidate because it can not be a valid candidate at the end
                 // of the day.
                 if self.cursor.prev == b':' {
@@ -704,11 +704,11 @@ impl<'a> Extractor<'a> {
     fn generate_slices(&mut self, candidate: &'a [u8]) -> ParseAction<'a> {
         match self.without_surrounding() {
             Bracketing::None => ParseAction::SingleCandidate(candidate),
-            Bracketing::Included(slicable) if slicable == candidate => {
+            Bracketing::Included(sliceable) if sliceable == candidate => {
                 ParseAction::SingleCandidate(candidate)
             }
-            Bracketing::Included(slicable) | Bracketing::Wrapped(slicable) => {
-                let parts = vec![candidate, slicable];
+            Bracketing::Included(sliceable) | Bracketing::Wrapped(sliceable) => {
+                let parts = vec![candidate, sliceable];
                 let parts = parts
                     .into_iter()
                     .filter(|v| !v.is_empty())
@@ -947,7 +947,7 @@ mod test {
                 "available",
                 "See",
                 // "what", // what is dropped because it is followed by the fancy: ’
-                // "s",    // s is dropped because it is preceeded by the fancy: ’
+                // "s",    // s is dropped because it is preceded by the fancy: ’
                 // "new", // Already seen
                 "in",
                 "version",

scripts/release-notes.js

@@ -1,5 +1,5 @@
 // Given a version, figure out what the release notes are so that we can use this to pre-fill the
-// relase notes on a GitHub release for the current version.
+// release notes on a GitHub release for the current version.
 
 let path = require('path')
 let fs = require('fs')

src/corePlugins.js

@@ -369,7 +369,7 @@ export let variantPlugins = {
         let check = normalize(value)
         let isRaw = /^\w*\s*\(/.test(check)
 
-        // Chrome has a bug where `(condtion1)or(condition2)` is not valid
+        // Chrome has a bug where `(condition1)or(condition2)` is not valid
         // But `(condition1) or (condition2)` is supported.
         check = isRaw ? check.replace(/\b(and|or|not)\b/g, ' $1 ') : check
 

tests/apply-important-selector.test.js

@@ -16,10 +16,10 @@ it.each`
   ${':is(.foo) :is(.bar)'}                      | ${'#app :is(:is(.foo) :is(.bar))'}
   ${':is(.foo)::before'}                        | ${'#app :is(.foo)::before'}
   ${'.foo:before'}                              | ${'#app :is(.foo):before'}
-  ${'.foo::some-uknown-pseudo'}                 | ${'#app :is(.foo)::some-uknown-pseudo'}
-  ${'.foo::some-uknown-pseudo:hover'}           | ${'#app :is(.foo)::some-uknown-pseudo:hover'}
-  ${'.foo:focus::some-uknown-pseudo:hover'}     | ${'#app :is(.foo:focus)::some-uknown-pseudo:hover'}
-  ${'.foo:hover::some-uknown-pseudo:focus'}     | ${'#app :is(.foo:hover)::some-uknown-pseudo:focus'}
+  ${'.foo::some-unknown-pseudo'}                | ${'#app :is(.foo)::some-unknown-pseudo'}
+  ${'.foo::some-unknown-pseudo:hover'}          | ${'#app :is(.foo)::some-unknown-pseudo:hover'}
+  ${'.foo:focus::some-unknown-pseudo:hover'}    | ${'#app :is(.foo:focus)::some-unknown-pseudo:hover'}
+  ${'.foo:hover::some-unknown-pseudo:focus'}    | ${'#app :is(.foo:hover)::some-unknown-pseudo:focus'}
 `('should generate "$after" from "$before"', ({ before, after }) => {
   expect(applyImportantSelector(before, '#app')).toEqual(after)
 })

tests/color.test.js

@@ -73,7 +73,7 @@ describe('parseColor', () => {
     ${'initial'}
     ${'revert'}
     ${'unset'}
-  `('should return `null` for unparseable color "$color"', ({ color }) => {
+  `('should return `null` for unparsable color "$color"', ({ color }) => {
     expect(parseColor(color)).toBe(null)
   })
 })

tests/getSortOrder.test.js

@@ -141,7 +141,7 @@ it('sorts classes deterministically across multiple class lists', () => {
   }
 })
 
-it('sorts based on first occurence of a candidate / rule', () => {
+it('sorts based on first occurrence of a candidate / rule', () => {
   let classes = [
     ['foo-1 foo', 'foo foo-1'],
     ['bar', 'bar'],

tests/parseAnimationValue.test.js

@@ -134,7 +134,7 @@ describe('iteration count', () => {
     ['spin 200s 100s infinite linear', 'infinite'],
     ['spin 200s 100s linear infinite', 'infinite'],
   ])(
-    'should be possible to parse "%s" with an iteraction count of "%s"',
+    'should be possible to parse "%s" with an iteration count of "%s"',
     (input, iterationCount) => {
       const parsed = parseAnimationValue(input)
       expect(parsed).toHaveLength(1)