style: use consistent code example language markers

Author: honzajavorek

sources/academy/glossary/concepts/css_selectors.md

@@ -17,39 +17,39 @@ Some of the most common types of CSS selectors are:
 
 This is used to select elements by their tag name. For example, to select all `<p>` elements, you would use the `p` selector.
 
-```js
+```javascript
 const paragraphs = document.querySelectorAll('p');
 ```
 
 ### Class selector
 
 This is used to select elements by their class attribute. For example, to select all elements with the class of `highlight`, you would use the `.highlight` selector.
 
-```js
+```javascript
 const highlightedElements = document.querySelectorAll('.highlight');
 ```
 
 ### ID selector
 
 This is used to select an element by its `id` attribute. For example, to select an element with the id of `header`, you would use the `#header` selector.
 
-```js
+```javascript
 const header = document.querySelector(`#header`);
 ```
 
 ### Attribute selector
 
 This is used to select elements based on the value of an attribute. For example, to select all elements with the attribute `data-custom` whose value is `yes`, you would use the `[data-custom="yes"]` selector.
 
-```js
+```javascript
 const customElements = document.querySelectorAll('[data-custom="yes"]');
 ```
 
 ### Chaining selectors
 
 You can also chain multiple selectors together to select elements more precisely. For example, to select an element with the class `highlight` that is inside a `<p>` element, you would use the `p.highlight` selector.
 
-```js
+```javascript
 const highlightedParagraph = document.querySelectorAll('p.highlight');
 ```
 

sources/academy/glossary/concepts/html_elements.md

@@ -19,19 +19,19 @@ You can also add **attributes** to an element to provide additional information
 
 In JavaScript, you can use the **DOM** (Document Object Model) to interact with elements on a web page. For example, you can use the [`querySelector()` method](./querying_css_selectors.md) to select an element by its [CSS selector](./css_selectors.md), like this:
 
-```js
+```javascript
 const myElement = document.querySelector('#myId');
 ```
 
 You can also use `getElementById()` method to select an element by its `id`, like this:
 
-```js
+```javascript
 const myElement = document.getElementById('myId');
 ```
 
 You can also use `getElementsByTagName()` method to select all elements of a certain type, like this:
 
-```js
+```javascript
 const myElements = document.getElementsByTagName('p');
 ```
 

sources/academy/glossary/concepts/querying_css_selectors.md

@@ -11,7 +11,7 @@ slug: /concepts/querying-css-selectors
 
 Here's an example of how you can use it:
 
-```js
+```javascript
 const firstButton = document.querySelector('button');
 ```
 
@@ -21,15 +21,15 @@ This will select the first button element on the page and store it in the variab
 
 Here's an example of how you can use it:
 
-```js
+```javascript
 const buttons = document.querySelectorAll('button');
 ```
 
 This will select all button elements on the page and store them in the variable "buttons".
 
 Both functions can be used to access and manipulate the elements in the web page. Here's an example on how you can use it to extract the text of all buttons.
 
-```js
+```javascript
 const buttons = document.querySelectorAll('button');
 const buttonTexts = buttons.forEach((button) => button.textContent);
 ```

sources/academy/platform/deploying_your_code/input_schema.md

@@ -19,7 +19,7 @@ Though writing an [input schema](/platform/actors/development/actor-definition/i
 
 In the root of our project, we'll create a file named **INPUT_SCHEMA.json** and start writing the first part of the schema.
 
-```json
+```javascripton
 {
     "title": "Adding actor input",
     "description": "Add all values in list of numbers with an arbitrary length.",
@@ -34,7 +34,7 @@ The **title** and **description** simply describe what the input schema is for,
 
 In order to define all of the properties our actor is expecting, we must include them within an object with a key of **properties**.
 
-```json
+```javascripton
 {
     "title": "Adding actor input",
     "description": "Add all values in list of numbers with an arbitrary length.",
@@ -55,7 +55,7 @@ Each property's key corresponds to the name we're expecting within our code, whi
 
 Within our new **numbers** property, there are two more fields we must specify. Firstly, we must let the platform know that we're expecting an array of numbers with the **type** field. Then, we should also instruct Apify on which UI component to render for this input property. In our case, we have an array of numbers, which means we should use the **json** editor type that we discovered in the ["array" section](/platform/actors/development/actor-definition/input-schema#array) of the input schema documentation. We could also use **stringList**, but then we'd have to parse out the numbers from the strings.
 
-```json
+```javascripton
 {
     "title": "Adding actor input",
     "description": "Add all values in list of numbers with an arbitrary length.",
@@ -76,7 +76,7 @@ Within our new **numbers** property, there are two more fields we must specify.
 
 The great thing about building an input schema is that it will automatically validate your inputs based on their type, maximum value, minimum value, etc. Sometimes, you want to ensure that the user will always provide input for certain fields, as they are crucial to the actor's run. This can be done by using the **required** field and passing in the names of the fields you'd like to require.
 
-```json
+```javascripton
 {
     "title": "Adding actor input",
     "description": "Add all values in list of numbers with an arbitrary length.",

sources/academy/platform/deploying_your_code/inputs_outputs.md

@@ -39,7 +39,7 @@ npm install apify
 
 Now, let's import `Actor` from `apify` and use the `Actor.getInput()` function to grab our input.
 
-```js
+```javascript
 // index.js
 import { Actor } from 'apify';
 
@@ -59,15 +59,15 @@ If we run this right now, we'll see **null** in our terminal - this is because w
 
 We'll now add an **INPUT.json** file within **storage/key_value_stores/default** to match what we're expecting in our code.
 
-```json
+```javascripton
 {
     "numbers": [5, 5, 5, 5]
 }
 ```
 
 Then we can add our example project code from earlier. It will grab the input and use it to generate a solution which is logged into the console.
 
-```js
+```javascript
 // index.js
 import { Actor } from 'apify';
 
@@ -137,7 +137,7 @@ Similarly to reading input, you can write the actor's output either by using the
 
 In the SDK, we can write to the dataset with the `Actor.pushData()` function. Let's go ahead and write the solution of the `addAllNumbers()` function to the dataset store using this function:
 
-```js
+```javascript
 // index.js
 
 // This is our example project code from earlier.
@@ -213,7 +213,7 @@ Since we've changed our code a lot from the way it originally was by wrapping it
 
 After running our script, there should be a single item in the default dataset that looks like this:
 
-```json
+```javascripton
 {
     "solution": 20
 }

sources/academy/platform/deploying_your_code/output_schema.md

@@ -25,7 +25,7 @@ Firstly, create a `.actor` folder in the root of your actor's source code. Then,
 
 Next, copy-paste the following template code into your `actor.json` file.
 
-```json
+```javascripton
 {
     "actorSpecification": 1,
     "name": "___ENTER_ACTOR_NAME____",
@@ -73,7 +73,7 @@ To configure the output schema, simply replace the fields in the template with t
 
 For reference, you can use the [Zappos Scraper source code](https://github.com/PerVillalva/zappos-scraper-actor/blob/main/.actor/actor.json) as an example of how the final implementation of the output tab should look in a live actor.
 
-```json
+```javascripton
 {
     "actorSpecification": 1,
     "name": "zappos-scraper",
@@ -145,7 +145,7 @@ Also, if your desired label has the same name as the defined object key, then yo
 
 The matching object for the Zappos Scraper shown in the example above will look something like this:
 
-```js
+```javascript
 const results = {
     url: request.loadedUrl,
     imgUrl: $('#stage button[data-media="image"] img[itemprop="image"]').attr('src'),

sources/academy/platform/expert_scraping_with_apify/apify_api_and_client.md

@@ -39,7 +39,7 @@ Though it's a bit unintuitive, this is a perfect activity for learning how to us
 
 The new actor should take the following input values, which be mapped to parameters in the API calls:
 
-```json
+```javascripton
 {
     // How much memory to allocate to the Amazon actor
     // Must be a power of 2

sources/academy/platform/expert_scraping_with_apify/migrations_maintaining_state.md

@@ -35,7 +35,7 @@ Before moving forward, read about actor [events](/sdk/js/docs/upgrading/upgradin
 
 Once again returning to our Amazon **demo-actor**, let's say that we need to store an object in memory (as a variable) containing all of the scraped ASINs as keys and the number of offers scraped from each ASIN as values. The object should follow this format:
 
-```json
+```javascripton
 {
     "B079ZJ1BPR": 3,
     "B07D4R4258": 21

sources/academy/platform/expert_scraping_with_apify/saving_useful_stats.md

@@ -36,7 +36,7 @@ Before moving on, give these valuable resources a quick lookover:
 
 In our Amazon actor, each dataset result must now have the following extra keys:
 
-```json
+```javascripton
 {
     "dateHandled": "date-here", // the date + time at which the request was handled
     "numberOfRetries": 4, // the number of retries of the request before running successfully
@@ -46,7 +46,7 @@ In our Amazon actor, each dataset result must now have the following extra keys:
 
 Also, an object including these values should be persisted during the run in th Key-Value store and logged to the console every 10 seconds:
 
-```json
+```javascripton
 {
     "errors": { // all of the errors for every request path
         "some-site.com/products/123": [

sources/academy/platform/expert_scraping_with_apify/solutions/handling_migrations.md

@@ -15,7 +15,7 @@ Let's first head into our **demo-actor** and create a new file named **asinTrack
 
 Here's the skeleton of our class:
 
-```js
+```javascript
 // asinTracker.js
 class ASINTracker {
     constructor() {
@@ -48,7 +48,7 @@ Multiple techniques exist for storing data in memory; however, this is the most
 
 Here is our updated **routes.js** file which is now utilizing this utility class to track the number of offers for each product ASIN:
 
-```js
+```javascript
 // routes.js
 import { createCheerioRouter } from '@crawlee/cheerio';
 import { BASE_URL, OFFERS_URL, labels } from './constants';
@@ -131,7 +131,7 @@ The **persistState** event is automatically fired (by default) every 60 seconds
 
 In order to persist our ASIN tracker object, let's use the `Actor.on` function to listen for the **persistState** event and store it in the key-value store each time it is emitted.
 
-```js
+```javascript
 // asinTracker.js
 import { Actor } from 'apify';
 // We've updated our constants.js file to include the name
@@ -168,7 +168,7 @@ Great! Now our state will be persisted every 60 seconds in the key-value store.
 
 In order to fix this, let's create a method called `initialize` which will be called at the very beginning of the actor's run, and will check the key-value store for a previous state under the key **ASIN-TRACKER**. If a previous state does live there, then it will update the class' `state` variable with the value read from the key-value store:
 
-```js
+```javascript
 // asinTracker.js
 import { Actor } from 'apify';
 import { ASIN_TRACKER } from './constants';
@@ -209,7 +209,7 @@ module.exports = new ASINTracker();
 
 We'll now call this function at the top level of the **main.js** file to ensure it is the first thing that gets called when the actor starts up:
 
-```js
+```javascript
 // main.js
 
 // ...