repo_id
stringlengths 22
103
| file_path
stringlengths 41
147
| content
stringlengths 181
193k
| __index_level_0__
int64 0
0
|
|---|---|---|---|
data/mdn-content/files/en-us/web/progressive_web_apps/tutorials/js13kgames | data/mdn-content/files/en-us/web/progressive_web_apps/tutorials/js13kgames/app_structure/index.md | ---
title: Progressive web app structure
slug: Web/Progressive_web_apps/Tutorials/js13kGames/App_structure
page-type: guide
---
{{PreviousMenuNext("Web/Progressive_web_apps/Tutorials/js13kGames", "Web/Progressive_web_apps/Tutorials/js13kGames/Offline_Service_workers", "Web/Progressive_web_apps/Tutorials/js13kGames")}}
{{PWASidebar}}
In this article, we will analyze the [js13kPWA](https://mdn.github.io/pwa-examples/js13kpwa/) application, why it is built that way, and what benefits it brings.
The [js13kPWA](https://mdn.github.io/pwa-examples/js13kpwa/) website structure is quite simple: it consists of a single HTML file ([index.html](https://github.com/mdn/pwa-examples/blob/main/js13kpwa/index.html)) with basic CSS styling ([style.css](https://github.com/mdn/pwa-examples/blob/main/js13kpwa/style.css)), and a few images, scripts, and fonts. The folder structure looks like this:
### The HTML
From the HTML point of view, the app shell is everything outside the content section:
```html
<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8" />
<title>js13kGames A-Frame entries</title>
<meta
name="description"
content="A list of A-Frame entries submitted to the js13kGames 2017 competition, used as an example for the MDN articles about Progressive Web Apps." />
<meta name="author" content="end3r" />
<meta name="theme-color" content="#B12A34" />
<meta name="viewport" content="width=device-width, initial-scale=1" />
<meta
property="og:image"
content="https://js13kgames.com/img/js13kgames-banner.png" />
<link rel="icon" href="favicon.ico" />
<link rel="stylesheet" href="style.css" />
<link rel="manifest" href="js13kpwa.webmanifest" />
<script src="data/games.js" defer></script>
<script src="app.js" defer></script>
</head>
<body>
<header>
<p>
<a class="logo" href="https://js13kgames.com">
<img src="img/js13kgames.png" alt="js13kGames" />
</a>
</p>
</header>
<main>
<h1>js13kGames A-Frame entries</h1>
<p class="description">
List of games submitted to the
<a href="https://js13kgames.com/aframe">A-Frame category</a> in the
<a href="https://2017.js13kgames.com">js13kGames 2017</a> competition.
You can
<a href="https://github.com/mdn/pwa-examples/blob/main/js13kpwa"
>fork js13kPWA on GitHub</a
>
to check its source code.
</p>
<button id="notifications">Request dummy notifications</button>
<section id="content">// Content inserted in here</section>
</main>
<footer>
<p>
© js13kGames 2012-2018, created and maintained by
<a href="https://end3r.com">Andrzej Mazur</a> from
<a href="https://enclavegames.com">Enclave Games</a>.
</p>
</footer>
</body>
</html>
```
The {{htmlelement("head")}} section contains some basic info like title, description and links to CSS, web manifest, games content JS file, and app.js — that's where our JavaScript application is initialized. The {{htmlelement("body")}} is split into the {{htmlelement("header")}} (containing linked image), {{htmlelement("main")}} page (with title, description and place for a content), and {{htmlelement("footer")}} (copy and links).
The app's only job is to list all the A-Frame entries from the js13kGames 2017 competition. As you can see it is a very ordinary, one page website — the point is to have something simple so we can focus on the implementation of the actual PWA features.
### The CSS
The CSS is also as plain as possible: it uses {{cssxref("@font-face")}} to load and use a custom font, and it applies some simple styling of the HTML elements. The overall approach is to have the design look good on both mobile (with a responsive web design approach) and desktop devices.
### The main app JavaScript
The app.js file does a few things we will look into closely in the next articles. First of all it generates the content based on this template:
```js
const template = `<article>
<img src='data/img/placeholder.png' data-src='data/img/SLUG.jpg' alt='NAME'>
<h3>#POS. NAME</h3>
<ul>
<li><span>Author:</span> <strong>AUTHOR</strong></li>
<li><span>Website:</span> <a href='http://WEBSITE/'>WEBSITE</a></li>
<li><span>GitHub:</span> <a href='https://GITHUB'>GITHUB</a></li>
<li><span>More:</span> <a href='http://js13kgames.com/entries/SLUG'>js13kgames.com/entries/SLUG</a></li>
</ul>
</article>`;
let content = "";
for (let i = 0; i < games.length; i++) {
let entry = template
.replace(/POS/g, i + 1)
.replace(/SLUG/g, games[i].slug)
.replace(/NAME/g, games[i].name)
.replace(/AUTHOR/g, games[i].author)
.replace(/WEBSITE/g, games[i].website)
.replace(/GITHUB/g, games[i].github);
entry = entry.replace("<a href='http:///'></a>", "-");
content += entry;
}
document.getElementById("content").innerHTML = content;
```
Next, it registers a service worker:
```js
if ("serviceWorker" in navigator) {
navigator.serviceWorker.register("/pwa-examples/js13kpwa/sw.js");
}
```
The next code block requests permission for notifications when a button is clicked:
```js
const button = document.getElementById("notifications");
button.addEventListener("click", () => {
Notification.requestPermission().then((result) => {
if (result === "granted") {
randomNotification();
}
});
});
```
The last block creates notifications that display a randomly-selected item from the games list:
```js
function randomNotification() {
const randomItem = Math.floor(Math.random() * games.length);
const notifTitle = games[randomItem].name;
const notifBody = `Created by ${games[randomItem].author}.`;
const notifImg = `data/img/${games[randomItem].slug}.jpg`;
const options = {
body: notifBody,
icon: notifImg,
};
new Notification(notifTitle, options);
setTimeout(randomNotification, 30000);
}
```
### The service worker
The last file we will quickly look at is the service worker: sw\.js — it first imports data from the games.js file:
```js
self.importScripts("data/games.js");
```
Next, it creates a list of all the files to be cached, both from the app shell and the content:
```js
const cacheName = "js13kPWA-v1";
const appShellFiles = [
"/pwa-examples/js13kpwa/",
"/pwa-examples/js13kpwa/index.html",
"/pwa-examples/js13kpwa/app.js",
"/pwa-examples/js13kpwa/style.css",
"/pwa-examples/js13kpwa/fonts/graduate.eot",
"/pwa-examples/js13kpwa/fonts/graduate.ttf",
"/pwa-examples/js13kpwa/fonts/graduate.woff",
"/pwa-examples/js13kpwa/favicon.ico",
"/pwa-examples/js13kpwa/img/js13kgames.png",
"/pwa-examples/js13kpwa/img/bg.png",
"/pwa-examples/js13kpwa/icons/icon-32.png",
"/pwa-examples/js13kpwa/icons/icon-64.png",
"/pwa-examples/js13kpwa/icons/icon-96.png",
"/pwa-examples/js13kpwa/icons/icon-128.png",
"/pwa-examples/js13kpwa/icons/icon-168.png",
"/pwa-examples/js13kpwa/icons/icon-192.png",
"/pwa-examples/js13kpwa/icons/icon-256.png",
"/pwa-examples/js13kpwa/icons/icon-512.png",
];
const gamesImages = [];
for (let i = 0; i < games.length; i++) {
gamesImages.push(`data/img/${games[i].slug}.jpg`);
}
const contentToCache = appShellFiles.concat(gamesImages);
```
The next block installs the service worker, which then actually caches all the files contained in the above list:
```js
self.addEventListener("install", (e) => {
console.log("[Service Worker] Install");
e.waitUntil(
(async () => {
const cache = await caches.open(cacheName);
console.log("[Service Worker] Caching all: app shell and content");
await cache.addAll(contentToCache);
})(),
);
});
```
Last of all, the service worker fetches content from the cache if it is available there, providing offline functionality:
```js
self.addEventListener("fetch", (e) => {
e.respondWith(
(async () => {
const r = await caches.match(e.request);
console.log(`[Service Worker] Fetching resource: ${e.request.url}`);
if (r) {
return r;
}
const response = await fetch(e.request);
const cache = await caches.open(cacheName);
console.log(`[Service Worker] Caching new resource: ${e.request.url}`);
cache.put(e.request, response.clone());
return response;
})(),
);
});
```
### The JavaScript data
The games data is present in the data folder in a form of a JavaScript object ([games.js](https://github.com/mdn/pwa-examples/blob/main/js13kpwa/data/games.js)):
```js
const games = [
{
slug: "lost-in-cyberspace",
name: "Lost in Cyberspace",
author: "Zosia and Bartek",
website: "",
github: "github.com/bartaz/lost-in-cyberspace",
},
{
slug: "vernissage",
name: "Vernissage",
author: "Platane",
website: "github.com/Platane",
github: "github.com/Platane/js13k-2017",
},
// ...
{
slug: "emma-3d",
name: "Emma-3D",
author: "Prateek Roushan",
website: "",
github: "github.com/coderprateek/Emma-3D",
},
];
```
Every entry has its own image in the data/img folder. This is our content, loaded into the content section with JavaScript.
## Next up
In the next article we will look in more detail at how the app shell and the content are cached for offline use with the help from the service worker.
{{PreviousMenuNext("Web/Progressive_web_apps/Tutorials/js13kGames", "Web/Progressive_web_apps/Tutorials/js13kGames/Offline_Service_workers", "Web/Progressive_web_apps/Tutorials/js13kGames")}}
| 0 |
data/mdn-content/files/en-us/web/progressive_web_apps/tutorials/js13kgames | data/mdn-content/files/en-us/web/progressive_web_apps/tutorials/js13kgames/loading/index.md | ---
title: Progressive loading
slug: Web/Progressive_web_apps/Tutorials/js13kGames/Loading
page-type: guide
---
{{PreviousMenu("Web/Progressive_web_apps/Tutorials/js13kGames/Re-engageable_Notifications_Push", "Web/Progressive_web_apps/Tutorials/js13kGames")}}
{{PWASidebar}}
In previous steps of this tutorial we covered APIs that help us make our [js13kPWA](https://mdn.github.io/pwa-examples/js13kpwa/) example a Progressive Web App: [Service Workers](/en-US/docs/Web/Progressive_web_apps/Tutorials/js13kGames/Offline_Service_workers), [Web Manifests](/en-US/docs/Web/Progressive_web_apps/Tutorials/js13kGames/Installable_PWAs), [Notifications and Push](/en-US/docs/Web/Progressive_web_apps/Tutorials/js13kGames/Re-engageable_Notifications_Push). In this article we will go further and improve the performance of the app by progressively loading its resources.
## First meaningful paint
It's important to deliver something meaningful to the user as soon as possible — the longer they wait for the page to load, the bigger the chance they will leave before waiting for everything to finish. We should be able to show them at least the basic view of the page they want to see, with placeholders in the places more content will eventually be loaded.
This could be achieved by progressive loading — also known as [Lazy loading](https://en.wikipedia.org/wiki/Lazy_loading). This is all about deferring loading of as many resources as possible (HTML, CSS, JavaScript), and only loading those immediately that are really needed for the very first experience.
## Bundling versus splitting
Many visitors won't go through every single page of a website, yet the usual approach is to bundle every feature we have into one big file. A `bundle.js` file can be many megabytes, and a single `style.css` bundle can contain everything from basic CSS structure definitions to all the possible styles of every version of the site: mobile, tablet, desktop, print only, etc.
It is faster to load all that information as one file rather than many small ones, but if the user doesn't need everything at the very beginning, we could load only what's crucial and then manage other resources when needed.
## Render-blocking resources
Bundling is a problem, because the browser has to load the HTML, CSS, and JavaScript before it can paint their rendered results onto the screen. During the few seconds between initial website access and completion of loading, the user sees a blank page, which is a bad experience.
To fix that we can, for example, add `defer` to JavaScript files:
```html
<script src="app.js" defer></script>
```
They will be downloaded and executed _after_ the document itself has been parsed, so it won't block rendering the HTML structure.
Another technique is to load JavaScript modules using [dynamic import](/en-US/docs/Web/JavaScript/Reference/Operators/import) only when needed.
For example, if a website has a search button, we can load the JavaScript for the search function after the user clicks on the search button:
```js
document.getElementById("open-search").addEventListener("click", async () => {
const searchModule = await import("/modules/search.js");
searchModule.loadAutoComplete();
});
```
Once the user clicks on the button, the async click handler is called. The function waits till the module is loaded, then calls the `loadAutoComplete()` function exported from that module. The `search.js` module is therefore only downloaded, parsed, and executed when the interaction happens.
We can also split CSS files and add media types to them:
```html
<link rel="stylesheet" href="style.css" />
<link rel="stylesheet" href="print.css" media="print" />
```
This will tell the browser to load them only when the condition is met.
In our js13kPWA demo app, the CSS is simple enough to leave it all in a single file with no specific rules as to how to load them. We could go even further and move everything from `style.css` to the `<style>` tag in the `<head>` of `index.html` — this would improve performance even more, but for the readability of the example we will skip that approach too.
## Images
Besides JavaScript and CSS, websites will likely contain a number of images. When you include {{htmlelement("img")}} elements in your HTML, then every referenced image will be fetched and downloaded during initial website access. It's not unusual to have megabytes of image data to download before announcing the site is ready, but this again creates a bad perception of performance. We don't need all of the images in the best possible quality at the very beginning of viewing the site.
This can be optimized. First of all, you should use tools or services similar to [TinyPNG](https://tinypng.com/), which will reduce the file size of your images without altering the quality too much. If you're past that point, then you can start thinking about optimizing the image loading using JavaScript. We'll explain this below.
### Placeholder image
Instead of having all the screenshots of games referenced in `<img>` element `src` attributes, which will force the browser to download them automatically, we can do it selectively via JavaScript. The js13kPWA app uses a placeholder image instead, which is small and lightweight, while the final paths to target images are stored in `data-src` attributes:
```html
<img src="data/img/placeholder.png" data-src="data/img/SLUG.jpg" alt="NAME" />
```
Those images will be loaded via JavaScript _after_ the site finishes building the HTML structure. The placeholder image is scaled the same way the original images are, so it will take up the same space and not cause the layout to repaint as the images load.
### Loading via JavaScript
The `app.js` file processes the `data-src` attributes like so:
```js
let imagesToLoad = document.querySelectorAll("img[data-src]");
const loadImages = (image) => {
image.setAttribute("src", image.getAttribute("data-src"));
image.onload = () => {
image.removeAttribute("data-src");
};
};
```
The `imagesToLoad` variable contains references to all the images, while the `loadImages` function moves the path from `data-src` to `src`. When each image is actually loaded, we remove its `data-src` attribute as it's not needed anymore. Then we loop through each image and load it:
```js
imagesToLoad.forEach((img) => {
loadImages(img);
});
```
### Blur in CSS
To make the whole process more visually appealing, the placeholder is blurred in CSS.
We render the images with a blur at the beginning, so a transition to the sharp one can be achieved:
```css
article img[data-src] {
filter: blur(0.2em);
}
article img {
filter: blur(0em);
transition: filter 0.5s;
}
```
This will remove the blur effect within half a second, which looks good enough for the "loading" effect.
## Loading on demand
The image loading mechanism discussed in the above section works OK — it loads the images after rendering the HTML structure, and applies a nice transition effect in the process. The problem is that it still loads _all_ the images at once, even though the user will only see the first two or three upon page load.
This problem can be solved by loading the images only when needed: this is called _lazy loading_. [Lazy loading](/en-US/docs/Web/Performance/Lazy_loading) is a technique to load images only when they appear in the viewport. There are several ways to tell the browser to lazy load images.
### The loading attribute on \<img>
The easiest way to tell the browser to load lazily doesn't involve JavaScript. You add the [`loading`](/en-US/docs/Web/HTML/Element/img#loading) attribute to an {{HTMLElement("img")}} element with the value `lazy`, and the browser will know to load this image only when needed.
```html
<img
src="data/img/placeholder.png"
data-src="data/img/SLUG.jpg"
alt="NAME"
loading="lazy" />
```
### Intersection Observer
This is a progressive enhancement to the previously working example — [Intersection Observer](/en-US/docs/Web/API/Intersection_Observer_API) will load target images only when the user scrolls down, causing them to display in the viewport.
Here's what the relevant code looks like:
```js
if ("IntersectionObserver" in window) {
const observer = new IntersectionObserver((items, observer) => {
items.forEach((item) => {
if (item.isIntersecting) {
loadImages(item.target);
observer.unobserve(item.target);
}
});
});
imagesToLoad.forEach((img) => {
observer.observe(img);
});
} else {
imagesToLoad.forEach((img) => {
loadImages(img);
});
}
```
If the {{domxref("IntersectionObserver")}} object is supported, the app creates a new instance of it. The function passed as a parameter is handling the case when one or more items are intersecting with the observer (i.e. is appearing inside the viewport). We can iterate over each case and react accordingly — when an image is visible, we load the correct image and stop observing it as we no longer need to observe it.
Let's reiterate our earlier mention of progressive enhancement — the code is written so that the app will work whether Intersection Observer is supported or not. If it's not, we just load the images using the more basic approach covered earlier.
## Improvements
Remember that there are many ways to optimize loading times, and this example is exploring only one of the approaches. You could try to make your apps more bulletproof by making them work without JavaScript — either using {{htmlelement("noscript")}} to show the image with final `src` already assigned, or by wrapping `<img>` tags with {{htmlelement("a")}} elements pointing at the target images, so the user can click and access them when desired.
We won't do that because the app itself is dependent on JavaScript — without it, the list of games wouldn't even be loaded, and the Service Worker code wouldn't be executed.
We could rewrite the loading process to load not only the images, but the complete items consisting of full descriptions and links. It would work like an infinite scroll — loading the items on the list only when the user scrolls the page down. That way the initial HTML structure would be minimal, loading time even smaller, and we would have even greater performance benefits.
## Conclusion
Fewer files to load initially, smaller files split into modules, use of placeholders, and loading more content on demand — this will help achieve faster initial load times, which brings benefits to the app creator and offers a smoother experience to the user.
Remember about the progressive enhancement approach — offer a usable product no matter the device or platform, but be sure to enrich the experience to those using modern browsers.
## Final thoughts
That's all for this tutorial series — we went through the [source code of the js13kPWA example app](https://github.com/mdn/pwa-examples/tree/main/js13kpwa) and learned about the [PWA structure](/en-US/docs/Web/Progressive_web_apps/Tutorials/js13kGames/App_structure), [offline availability with Service Workers](/en-US/docs/Web/Progressive_web_apps/Tutorials/js13kGames/Offline_Service_workers), [installable PWAs](/en-US/docs/Web/Progressive_web_apps/Tutorials/js13kGames/Installable_PWAs), and finally [notifications](/en-US/docs/Web/Progressive_web_apps/Tutorials/js13kGames/Re-engageable_Notifications_Push).
And in this article, we've looked into the concept of progressive loading, including an interesting example that makes use of the [Intersection Observer API](/en-US/docs/Web/API/Intersection_Observer_API).
Feel free to experiment with the code, enhance your existing app with PWA features, or build something entirely new on your own. PWAs give a huge advantage over regular web apps.
{{PreviousMenu("Web/Progressive_web_apps/Tutorials/js13kGames/Re-engageable_Notifications_Push", "Web/Progressive_web_apps/Tutorials/js13kGames")}}
| 0 |
data/mdn-content/files/en-us/web/progressive_web_apps/tutorials/js13kgames | data/mdn-content/files/en-us/web/progressive_web_apps/tutorials/js13kgames/offline_service_workers/index.md | ---
title: Making PWAs work offline with Service workers
slug: Web/Progressive_web_apps/Tutorials/js13kGames/Offline_Service_workers
page-type: guide
---
{{PreviousMenuNext("Web/Progressive_web_apps/Tutorials/js13kGames/App_structure", "Web/Progressive_web_apps/Tutorials/js13kGames/Installable_PWAs", "Web/Progressive_web_apps/Tutorials/js13kGames")}}
{{PWASidebar}}
Now that we've seen what the structure of js13kPWA looks like and have seen the basic shell up and running, let's look at how the offline capabilities using Service Worker are implemented. In this article, we look at how it is used in our [js13kPWA example](https://mdn.github.io/pwa-examples/js13kpwa/) ([see the source code also](https://github.com/mdn/pwa-examples/tree/main/js13kpwa)). We examine how to add offline functionality.
## Service workers explained
Service Workers are a virtual proxy between the browser and the network. They make it possible to properly cache the assets of a website and make them available when the user's device is offline.
They run on a separate thread from the main JavaScript code of our page, and don't have any access to the DOM structure. This introduces a different approach from traditional web programming — the API is non-blocking, and can send and receive communication between different contexts. You are able to give a Service Worker something to work on, and receive the result whenever it is ready using a [Promise](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise)-based approach.
Service workers can do more than offering offline capabilities, including handling notifications or performing heavy calculations. Service workers are quite powerful as they can take control over network requests, modify them, serve custom responses retrieved from the cache, or synthesize responses completely.
To learn more about service workers, see [Offline and background operation](/en-US/docs/Web/Progressive_web_apps/Guides/Offline_and_background_operation).
## Service workers in the js13kPWA app
Let's see how the js13kPWA app uses Service Workers to provide offline capabilities.
### Registering the Service Worker
We'll start by looking at the code that registers a new Service Worker, in the app.js file:
```js
if ("serviceWorker" in navigator) {
navigator.serviceWorker.register("./pwa-examples/js13kpwa/sw.js");
}
```
If the service worker API is supported in the browser, it is registered against the site using the {{domxref("ServiceWorkerContainer.register()")}} method. Its contents reside in the sw\.js file, and can be executed after the registration is successful. It's the only piece of Service Worker code that sits inside the app.js file; everything else that is Service Worker-specific is written in the sw\.js file itself.
### Lifecycle of a Service Worker
When registration is complete, the sw\.js file is automatically downloaded, then installed, and finally activated.
#### Installation
The API allows us to add event listeners for key events we are interested in — the first one is the `install` event:
```js
self.addEventListener("install", (e) => {
console.log("[Service Worker] Install");
});
```
In the `install` listener, we can initialize the cache and add files to it for offline use. Our js13kPWA app does exactly that.
First, a variable for storing the cache name is created, and the app shell files are listed in one array.
```js
const cacheName = "js13kPWA-v1";
const appShellFiles = [
"/pwa-examples/js13kpwa/",
"/pwa-examples/js13kpwa/index.html",
"/pwa-examples/js13kpwa/app.js",
"/pwa-examples/js13kpwa/style.css",
"/pwa-examples/js13kpwa/fonts/graduate.eot",
"/pwa-examples/js13kpwa/fonts/graduate.ttf",
"/pwa-examples/js13kpwa/fonts/graduate.woff",
"/pwa-examples/js13kpwa/favicon.ico",
"/pwa-examples/js13kpwa/img/js13kgames.png",
"/pwa-examples/js13kpwa/img/bg.png",
"/pwa-examples/js13kpwa/icons/icon-32.png",
"/pwa-examples/js13kpwa/icons/icon-64.png",
"/pwa-examples/js13kpwa/icons/icon-96.png",
"/pwa-examples/js13kpwa/icons/icon-128.png",
"/pwa-examples/js13kpwa/icons/icon-168.png",
"/pwa-examples/js13kpwa/icons/icon-192.png",
"/pwa-examples/js13kpwa/icons/icon-256.png",
"/pwa-examples/js13kpwa/icons/icon-512.png",
];
```
Next, the links to images to be loaded along with the content from the data/games.js file are generated in the second array. After that, both arrays are merged using the {{jsxref("Array.prototype.concat()")}} function.
```js
const gamesImages = [];
for (let i = 0; i < games.length; i++) {
gamesImages.push(`data/img/${games[i].slug}.jpg`);
}
const contentToCache = appShellFiles.concat(gamesImages);
```
Then we can manage the `install` event itself:
```js
self.addEventListener("install", (e) => {
console.log("[Service Worker] Install");
e.waitUntil(
(async () => {
const cache = await caches.open(cacheName);
console.log("[Service Worker] Caching all: app shell and content");
await cache.addAll(contentToCache);
})(),
);
});
```
There are two things that need an explanation here: what {{domxref("ExtendableEvent.waitUntil")}} does, and what the {{domxref("Cache","caches")}} object is.
The service worker does not install until the code inside `waitUntil` is executed. It returns a promise — this approach is needed because installing may take some time, so we have to wait for it to finish.
`caches` is a special {{domxref("CacheStorage")}} object available in the scope of the given Service Worker to enable saving data — saving to [web storage](/en-US/docs/Web/API/Web_Storage_API) won't work, because web storage is synchronous. With Service Workers, we use the Cache API instead.
Here, we open a cache with a given name, then add all the files our app uses to the cache, so they are available next time it loads. Resources are identified by their request URL, which is relative to the worker's {{domxref("WorkerGlobalScope.location", "location", "", 1)}}.
You may notice we haven't cached `game.js`. This is the file that contains the data we use when displaying our games. In reality this data would most likely come from an API endpoint or database and caching the data would mean updating it periodically when there was network connectivity. We won't go into that here, but the {{domxref('Web Periodic Background Synchronization API','Periodic Background Sync API')}} is good further reading on this topic.
#### Activation
There is also an `activate` event, which is used in the same way as `install`. This event is usually used to delete any files that are no longer necessary and clean up after the app in general. We don't need to do that in our app, so we'll skip it.
### Responding to fetches
We also have a `fetch` event at our disposal, which fires every time an HTTP request is fired off from our app. This is very useful, as it allows us to intercept requests and respond to them with custom responses. Here is a simple usage example:
```js
self.addEventListener("fetch", (e) => {
console.log(`[Service Worker] Fetched resource ${e.request.url}`);
});
```
The response can be anything we want: the requested file, its cached copy, or a piece of JavaScript code that will do something specific — the possibilities are endless.
In our example app, we serve content from the cache instead of the network as long as the resource is actually in the cache. We do this whether the app is online or offline. If the file is not in the cache, the app adds it there first before then serving it:
```js
self.addEventListener("fetch", (e) => {
e.respondWith(
(async () => {
const r = await caches.match(e.request);
console.log(`[Service Worker] Fetching resource: ${e.request.url}`);
if (r) {
return r;
}
const response = await fetch(e.request);
const cache = await caches.open(cacheName);
console.log(`[Service Worker] Caching new resource: ${e.request.url}`);
cache.put(e.request, response.clone());
return response;
})(),
);
});
```
Here, we respond to the fetch event with a function that tries to find the resource in the cache and return the response if it's there. If not, we use another fetch request to fetch it from the network, then store the response in the cache so it will be available there next time it is requested.
The {{domxref("FetchEvent.respondWith")}} method takes over control — this is the part that functions as a proxy server between the app and the network. This allows us to respond to every single request with any response we want: prepared by the Service Worker, taken from cache, modified if needed.
That's it! Our app is caching its resources on install and serving them with fetch from the cache, so it works even if the user is offline. It also caches new content whenever it is added.
## Updates
There is still one point to cover: how do you upgrade a Service Worker when a new version of the app containing new assets is available? The version number in the cache name is key to this:
```js
const cacheName = "js13kPWA-v1";
```
When this updates to v2, we can then add all of our files (including our new files) to a new cache:
```js
contentToCache.push("/pwa-examples/js13kpwa/icons/icon-32.png");
// ...
self.addEventListener("install", (e) => {
e.waitUntil(
(async () => {
const cache = await caches.open(cacheName);
await cache.addAll(contentToCache);
})(),
);
});
```
A new service worker is installed in the background, and the previous one (v1) works correctly up until there are no pages using it — the new Service Worker is then activated and takes over management of the page from the old one.
## Clearing the cache
Remember the `activate` event we skipped? It can be used to clear out the old cache we don't need anymore:
```js
self.addEventListener("activate", (e) => {
e.waitUntil(
caches.keys().then((keyList) => {
return Promise.all(
keyList.map((key) => {
if (key === cacheName) {
return;
}
return caches.delete(key);
}),
);
}),
);
});
```
This ensures we have only the files we need in the cache, so we don't leave any garbage behind; the [available cache space in the browser is limited](/en-US/docs/Web/API/Storage_API/Storage_quotas_and_eviction_criteria), so it is a good idea to clean up after ourselves.
## Other use cases
Serving files from cache is not the only feature Service Worker offers. If you have heavy calculations to do, you can offload them from the main thread and do them in the worker, and receive results as soon as they are available. Performance-wise, you can prefetch resources that are not needed right now, but might be in the near future, so the app will be faster when you actually need those resources.
## Summary
In this article we took a simple look at how you can make your PWA work offline with service workers. Be sure to check out our further documentation if you want to learn more about the concepts behind the [Service Worker API](/en-US/docs/Web/API/Service_Worker_API) and how to use it in more detail.
Service Workers are also used when dealing with [push notifications](/en-US/docs/Web/API/Push_API) — this will be explained in a subsequent article.
{{PreviousMenuNext("Web/Progressive_web_apps/Tutorials/js13kGames/App_structure", "Web/Progressive_web_apps/Tutorials/js13kGames/Installable_PWAs", "Web/Progressive_web_apps/Tutorials/js13kGames")}}
| 0 |
data/mdn-content/files/en-us/web/progressive_web_apps/tutorials | data/mdn-content/files/en-us/web/progressive_web_apps/tutorials/cycletracker/index.md | ---
title: CycleTracker
slug: Web/Progressive_web_apps/Tutorials/CycleTracker
page-type: tutorial
---
{{NextMenu("Web/Progressive_web_apps/Tutorials/CycleTracker/HTML_and_CSS")}}
{{PWASidebar}}
This intro-level tutorial walks through all the steps of building a basic progressive web app, or PWA. We will be using web technologies — HTML, CSS, and JavaScript — to build a period tracking web app called "CycleTracker". Like all web apps, CycleTracker is designed to work in all browsers on all devices.
We will walk through the steps of building a fully functional web app, then progressively enhance CycleTracker to make it installable and to work even when the user is offline.
By default, PWAs are regular websites, built with the same technologies. Just like a regular websites, PWAs are linkable, discoverable via search engines, and visible in a browser. By including a manifest file and service worker, and serving the website over TLS, any website can become a PWA.
## PWA benefits
Using the languages of the web, we will create a fully functioning application that works both online and offline, both in the browsers and on the user's operating systems (OS). Like any regular website, CycleTracker is hosted on and downloadable from a web server. All we need is a text editor: CycleTracker, like all PWAs, doesn't require any additional programming language knowledge, packaging, or proprietary SDK. CycleTracker, like any PWA, can be seamlessly installed on any operating system without the need of app stores (nor app store approval and fees).
- Use standard and open web technologies
- : Historically, for an application to be installable on an OS, such as Windows, iOS, MacOS, Linux, and Android, the applications are developed in OS-supported programming languages, like C#, .Net, Objective C, Swift, Kotlin, Java, or Python. PWAs are based on a different model: they use a single code base, written using standard open web technologies (HTML, CSS, and JavaScript) that work across OSes.
- No compiling required
- : With most programming languages—like Java, C/C++, and Kotlin, which are commonly used for building Android apps, and Objective-C and Swift, for iOS—the code needs to be compiled and packaged into an installable format, like .exe, .dmg, .elf, and .apk, or another installable file type, depending on the operating system. Depending on the language, compiling and packaging may require the OS's {{glossary("SDK")}}. PWAs use web technologies supported by every operating system that doesn't need to be packaged or compiled. Yes, developer teams can have complex build systems, but, as we will demonstrate as we build CycleTracker, PWAs can be built out of just HTML and JavaScript (and CSS, though styling is not necessarily required for a PWA).
- Available anywhere and everywhere
- : Single-OS-only applications are distributed to users through downloads, often in proprietary app stores. They are available through a vendor like the Apple App Store, [Google Play](https://play.google.com/store/apps), [Microsoft Store](https://apps.microsoft.com/store/apps), or similar. PWAs don't have these requirements. If you want to distribute your CycleTracker app, you won't require an intermediary. A user can access your app by visiting its online version. But if you want, it is possible to distribute your PWA on the Play Store and App Store, undifferentiated from other iOS or Android apps.
- Easy for the user to install
- : Historically, downloaded single-OS-only applications have to be intentionally installed by the user. Depending on the OS, install format, and download origin, this can be a multi-step installation process. PWAs are streamlined. PWAs are available to anyone with a supporting browser, and are [installable](/en-US/docs/Web/Progressive_web_apps/Guides/Installing) with a couple of clicks.
### Compared to OS-installed software applications
Once installed, PWAs can be made to appear and act similarly to other applications installed on the user's device:
- Application window
- : With a [manifest](/en-US/docs/Web/Progressive_web_apps/Tutorials/CycleTracker/Manifest_file#app_presentation) setting, we'll make CycleTracker open in its own application window, meaning installed PWAs are similar to other installed applications.
- Application icon
- : PWAs display an application icon in the same location as other installed applications installed on the users' operating system. This can be an icon on the homescreen, in the toolbar, in the application's folder, or wherever the device displays application icons. We'll learn how to [declare icons](/en-US/docs/Web/Progressive_web_apps/Tutorials/CycleTracker/Manifest_file#app_iconography) for CycleTracker, so, once installed, our PWA can appear like any other installed application on the user's device.
- Works offline
- : Internet access is initially required to download the application and is also required when syncing data with the server or other users. This is required of all applications, not just PWAs. We'll add a [service worker](/en-US/docs/Web/Progressive_web_apps/Tutorials/CycleTracker/Service_workers) to create an offline experience, meaning CycleTracker will work even when the user loses internet access. We will only touch on the power of PWA offline support. Service workers can be used to make PWAs work offline just like any other installed application. If a user makes changes while offline, service workers enable PWAs to sync data once connectivity is restored. With service workers, the user doesn't need to be actively engaging with the PWA, in fact, the PWA doesn't even need to be open, for it to send and retrieve server data.
## CycleTracker PWA lessons
The base web application for this PWA tutorial is a period tracker, in which the user can track the beginning and end of each menstrual cycle. We'll create a static website shell and style it, then learn how to create a secure connection to view our progress. We'll add JavaScript functionality converting the HTML and CSS shell into a fully functioning application storing data in localStorage. Using this fully functional web application you built, we will progressively enhance this web app into an offline capable PWA by adding a manifest file, including iconography, and a service worker.
The steps include:
- [App HTML and CSS](/en-US/docs/Web/Progressive_web_apps/Tutorials/CycleTracker/HTML_and_CSS)
- : Line by line explanation of HTML for the static content of the website, the CycleTracker static content, along with the CSS to style that content.
- [Local development environment or secure connection](/en-US/docs/Web/Progressive_web_apps/Tutorials/CycleTracker/Secure_connection)
- : While all websites should be served over https, with PWAs, https is a requirement. Service workers, and therefore PWAs, are restricted to secure contexts including TLS contexts served with the `https://` protocol and locally-delivered resources, including `127.0.0.1` and `localhost` URLs served with the `http://` protocol. We will look at the page in the current state with the `file://` protocol, then cover options for creating a secure localhost connection to test your code as we progress through the tutorial steps. We also look at serving your PWA with GitHub pages.
- [JavaScript and LocalStorage](/en-US/docs/Web/Progressive_web_apps/Tutorials/CycleTracker/JavaScript_functionality)
- : Full explanation of the JavaScript functionality to make a client-side period tracker web application so we have a functioning application that can be progressively enhanced into a PWA, using [`localStorage`](/en-US/docs/Web/API/Window/localStorage) to store period information.
- [Manifest: identity, appearance, and iconography](/en-US/docs/Web/Progressive_web_apps/Tutorials/CycleTracker/Manifest_file)
- : A PWA requires a manifest, which is a JSON file that describes the name, icon, description, and other definitions of how the application works within the operating system on which the PWA is installed. We will create a manifest file that defines the appearance of the application when installed, including which icons should be used depending on the user's device, and parameters for the application viewport. We also look at debugging the manifest file with browser developer tools.
- [Service workers](/en-US/docs/Web/Progressive_web_apps/Tutorials/CycleTracker/Service_workers)
- : The service worker enables the application to work offline. With the secure connection in the previous step, the initial visit to a page provides its baseline functionality while the service worker downloads. After a service worker is installed and activated, it controls the page to offer improved reliability and speed.
<!--
- [Offline experience](/en-US/docs/Web/Progressive_web_apps/Tutorials/CycleTracker/offline)
- : With JavaScript, we will determine whether the user is online or offline. When offline, they will be shown an offline experience that informs the user they are offline. When online, the experience will be similar to the website, but the installation button will not be visible.
- [Session storage](/en-US/docs/Web/Progressive_web_apps/Tutorials/CycleTracker/Storage)
- : Will take a look at service workers and session storage, using JavaScript to enhance the PWA.
-->
To complete this tutorial, it is helpful to have a basic level of understanding of HTML, CSS, and JavaScript. The tutorial provides instructions on creating the manifest file and initiating the service worker, as well as setting up a local development environment so you can view your progress. <!--The tutorial will cover checking for internet access, defining both an online and offline experience.-->
While a secure connection is a requirement, there are no software requirements for creating a PWA other than any text editor to code the PWA and a browser to view it.
You can try the [live period tracker](https://mdn.github.io/pwa-examples/cycletracker/) and view the [period tracker source code](https://github.com/mdn/pwa-examples/tree/main/cycletracker) on GitHub.
{{NextMenu("Web/Progressive_web_apps/Tutorials/CycleTracker/HTML_and_CSS")}}
| 0 |
data/mdn-content/files/en-us/web/progressive_web_apps/tutorials/cycletracker | data/mdn-content/files/en-us/web/progressive_web_apps/tutorials/cycletracker/javascript_functionality/index.md | ---
title: "CycleTracker: JavaScript functionality"
short-title: JavaScript functionality
slug: Web/Progressive_web_apps/Tutorials/CycleTracker/JavaScript_functionality
page-type: tutorial-chapter
---
{{PWASidebar}}
{{PreviousMenuNext("Web/Progressive_web_apps/Tutorials/CycleTracker/Secure_connection", "Web/Progressive_web_apps/Tutorials/CycleTracker", "Web/Progressive_web_apps/Tutorials/CycleTracker")}}
In the previous section, we wrote the HTML and CSS for CycleTracker, creating a static version of our web app. In this section, we will write the JavaScript required to convert static HTML into a fully functional web application.
If you haven't already done so, copy the [HTML](https://github.com/mdn/pwa-examples/tree/main/cycletracker/javascript_functionality/index.html) and [CSS](https://github.com/mdn/pwa-examples/tree/main/cycletracker/javascript_functionality/style.css) and save them to files called `index.html` and `style.css`.
The last line in the HTML file calls the `app.js` JavaScript file. This is the script we are creating in this section. In this lesson, we will be writing client-side JavaScript code to capture form submissions, locally store submitted data, and populate the past-periods section.
At the end of this lesson, you will have a fully functional app. In future lessons, we will progressively enhance the app to create a fully installable PWA that works even when the user is offline.
## JavaScript task
When a user visits the page, we check if they have existing data stored in local storage. The first time a user visits the page, there won't be any data. When a new user selects two dates and submits the form, we need to:
1. Create a "`<h2>Past periods</h2>`" header
2. Create an {{HTMLelement("ul")}}
3. Populate the `<ul>` with a single {{HTMLelement("li")}} containing information about that cycle
4. Save the data to local storage
For each subsequent form submission, we need to:
1. Add the new menstrual cycle to the current list
2. Sort the list in date order
3. Repopulate the `<ul>` with the new list, one `<li>` per cycle
4. Append the data to our saved local storage
Existing users will have existing data in local storage. When a user comes back to our webpage with the same browser on the same device, we need to:
1. Retrieve the data from local storage
2. Create a "`<h2>Past periods</h2>`" header
3. Create an {{HTMLelement("ul")}}
4. Populate the `<ul>` with an {{HTMLelement("li")}} for every menstrual cycle saved in local storage.
This is a beginner-level demonstration application. The goal is to teach the basics of converting a web application to a PWA. This application does not contain necessary features like form validation, error checking, edit or delete functionality, etc. You are welcome to expand on the features that are covered and tailor the lesson and applications to your learning goals and application needs.
## Form submission
The page contains a {{HTMLelement("form")}} with date pickers for selecting the start and end dates of each menstrual cycle. The date pickers are {{HTMLElement("input")}} of type {{HTMLElement("input/date", "date")}} with the [`id`](/en-US/docs/Web/HTML/Global_attributes/id) of `start-date` and `end-date` respectively.
The form has no method or action. Instead, we add an event listener with [`addEventListener()`](/en-US/docs/Web/API/EventTarget/addEventListener) to the form. When the user tries to submit the form, we prevent the form from submitting, store the new menstrual cycle, render this period along with previous ones, and then reset the form.
```js
// create constants for the form and the form controls
const newPeriodFormEl = document.getElementsByTagName("form")[0];
const startDateInputEl = document.getElementById("start-date");
const endDateInputEl = document.getElementById("end-date");
// Listen to form submissions.
newPeriodFormEl.addEventListener("submit", (event) => {
// Prevent the form from submitting to the server
// since everything is client-side.
event.preventDefault();
// Get the start and end dates from the form.
const startDate = startDateInputEl.value;
const endDate = endDateInputEl.value;
// Check if the dates are invalid
if (checkDatesInvalid(startDate, endDate)) {
// If the dates are invalid, exit.
return;
}
// Store the new period in our client-side storage.
storeNewPeriod(startDate, endDate);
// Refresh the UI.
renderPastPeriods();
// Reset the form.
newPeriodFormEl.reset();
});
```
After preventing the form submission with [`preventDefault()`](/en-US/docs/Web/API/Event/preventDefault), we:
1. [Validate user input](#validate_user_input); exiting if invalid,
2. store the new period by [retrieving, parsing, appending, sorting, stringifying, and re-storing](#retrieve_append_sort_and_re-store_data) data in localStorage,
3. [render the form data](#render_data_to_screen) along with the data of past menstrual cycles and a section header, and
4. reset the form using the HTMLFormElement [`reset()`](/en-US/docs/Web/API/HTMLFormElement/reset) method
### Validate user input
We check if the dates are invalid. We do minimal error checking. We make sure neither date is null, which the `required` attribute should prevent from happening. We also check that the start date is not greater than the end date. If there is an error, we clear the form.
```js
function checkDatesInvalid(startDate, endDate) {
// Check that end date is after start date and neither is null.
if (!startDate || !endDate || startDate > endDate) {
// To make the validation robust we could:
// 1. add error messaging based on error type
// 2. Alert assistive technology users about the error
// 3. move focus to the error location
// instead, for now, we clear the dates if either
// or both are invalid
newPeriodFormEl.reset();
// as dates are invalid, we return true
return true;
}
// else
return false;
}
```
In a more robust version of this app, we would, at minimum, include error messaging informing the user there is an error. A good application would inform the user what the error is, put focus on the offending form control, and use [ARIA live regions](/en-US/docs/Web/Accessibility/ARIA/ARIA_Live_Regions) to alert assistive technology users to the error.
## Local storage
We are using the [Web Storage API](/en-US/docs/Web/API/Web_Storage_API), specifically [window.localStorage](/en-US/docs/Web/API/Window/localStorage), to store start and end date pairs in a stringified JSON object.
[LocalStorage](/en-US/docs/Learn/JavaScript/Client-side_web_APIs/Client-side_storage#storing_simple_data_—_web_storage) has several limitations, but suffices for our apps needs. We're using localStorage to make this simple and client-side only. This means the data will only be stored on one browser on a single device. Clearing the browser data will also lose all locally stored periods. What may seem like a limitation for many applications may be an asset in the case of this application, as menstrual cycle data is personal, and the user of such an app may very rightly be concerned about privacy.
For a more robust application, other [client side storage](/en-US/docs/Learn/JavaScript/Client-side_web_APIs/Client-side_storage) options like [IndexedDB](/en-US/docs/Web/API/IndexedDB_API/Using_IndexedDB) (IDB) and, discussed later, service workers, have better performance.
Limitations of `localStorage` include:
- Limited data storage: `localStorage` is limited to 5MB of data per origin. Our storage needs are much less than that.
- Stores strings only: `localStorage` stores data as string key and string value pairs. Our start and end dates will be stored as a JSON object parsed as a string. For more complex data, a more robust storage mechanism like IDB would be required.
- Can cause poor performance: Getting and setting from and to local storage is done synchronously on the main thread. When the main thread is occupied, apps are not responsive and appear frozen. With the limited nature of this app, this blip of bad user experience is negligible.
- Only available to the main thread: In addition to the performance issues of occupying the main thread, service workers do not have access to the main thread, meaning the service worker can't directly set or get the local storage data.
### Retrieve, append, sort, and re-store data
Because we're using localStorage, which comprises of a single string, we retrieve the JSON string of data from local storage, parse the JSON data (if any), push the new pair of dates to the existing array, sort the dates, parse the JSON object back into a string, and save that string back to `localStorage`.
This process requires the creation of a few functions:
```js
// Add the storage key as an app-wide constant
const STORAGE_KEY = "period-tracker";
function storeNewPeriod(startDate, endDate) {
// Get data from storage.
const periods = getAllStoredPeriods();
// Add the new period objet to the end of the array of period objects.
periods.push({ startDate, endDate });
// Sort the array so that periods are ordered by start date, from newest
// to oldest.
periods.sort((a, b) => {
return new Date(b.startDate) - new Date(a.startDate);
});
// Store the updated array back in the storage.
window.localStorage.setItem(STORAGE_KEY, JSON.stringify(periods));
}
function getAllStoredPeriods() {
// Get the string of period data from localStorage
const data = window.localStorage.getItem(STORAGE_KEY);
// If no periods were stored, default to an empty array
// otherwise, return the stored data as parsed JSON
const periods = data ? JSON.parse(data) : [];
return periods;
}
```
## Render data to screen
The last step of our application is to render the list of past periods to the screen along with a heading.
In our HTML, we added a `<section id="past-periods">` placeholder to contain the heading and list of past periods.
Add the container element to the list of contents at the top of your script.
```js
const pastPeriodContainer = document.getElementById("past-periods");
```
We retrieve the parsed string of past periods, or an empty array. If empty, we exit. If past periods exist, we clear the current contents from the past period container. We create a header and an unordered list. We loop through the past periods, adding list items containing formatted from and to dates.
```js
function renderPastPeriods() {
// get the parsed string of periods, or an empty array.
const periods = getAllStoredPeriods();
// exit if there are no periods
if (periods.length === 0) {
return;
}
// Clear the list of past periods, since we're going to re-render it.
pastPeriodContainer.innerHTML = "";
const pastPeriodHeader = document.createElement("h2");
pastPeriodHeader.textContent = "Past periods";
const pastPeriodList = document.createElement("ul");
// Loop over all periods and render them.
periods.forEach((period) => {
const periodEl = document.createElement("li");
periodEl.textContent = `From ${formatDate(
period.startDate,
)} to ${formatDate(period.endDate)}`;
pastPeriodList.appendChild(periodEl);
});
pastPeriodContainer.appendChild(pastPeriodHeader);
pastPeriodContainer.appendChild(pastPeriodList);
}
function formatDate(dateString) {
// Convert the date string to a Date object.
const date = new Date(dateString);
// Format the date into a locale-specific string.
// include your locale for better user experience
return date.toLocaleDateString("en-US", { timeZone: "UTC" });
}
```
### Render past periods on load
When the deferred JavaScript runs on page load, we render past periods, if any.
```js
// Start the app by rendering the past periods.
renderPastPeriods();
```
## Complete JavaScript
Your `app.js` file should look similar to this JavaScript:
```js
const newPeriodFormEl = document.getElementsByTagName("form")[0];
const startDateInputEl = document.getElementById("start-date");
const endDateInputEl = document.getElementById("end-date");
const pastPeriodContainer = document.getElementById("past-periods");
// Add the storage key as an app-wide constant
const STORAGE_KEY = "period-tracker";
// Listen to form submissions.
newPeriodFormEl.addEventListener("submit", (event) => {
event.preventDefault();
const startDate = startDateInputEl.value;
const endDate = endDateInputEl.value;
if (checkDatesInvalid(startDate, endDate)) {
return;
}
storeNewPeriod(startDate, endDate);
renderPastPeriods();
newPeriodFormEl.reset();
});
function checkDatesInvalid(startDate, endDate) {
if (!startDate || !endDate || startDate > endDate) {
newPeriodFormEl.reset();
return true;
}
return false;
}
function storeNewPeriod(startDate, endDate) {
const periods = getAllStoredPeriods();
periods.push({ startDate, endDate });
periods.sort((a, b) => {
return new Date(b.startDate) - new Date(a.startDate);
});
window.localStorage.setItem(STORAGE_KEY, JSON.stringify(periods));
}
function getAllStoredPeriods() {
const data = window.localStorage.getItem(STORAGE_KEY);
const periods = data ? JSON.parse(data) : [];
console.dir(periods);
console.log(periods);
return periods;
}
function renderPastPeriods() {
const pastPeriodHeader = document.createElement("h2");
const pastPeriodList = document.createElement("ul");
const periods = getAllStoredPeriods();
if (periods.length === 0) {
return;
}
pastPeriodContainer.innerHTML = "";
pastPeriodHeader.textContent = "Past periods";
periods.forEach((period) => {
const periodEl = document.createElement("li");
periodEl.textContent = `From ${formatDate(
period.startDate,
)} to ${formatDate(period.endDate)}`;
pastPeriodList.appendChild(periodEl);
});
pastPeriodContainer.appendChild(pastPeriodHeader);
pastPeriodContainer.appendChild(pastPeriodList);
}
function formatDate(dateString) {
const date = new Date(dateString);
return date.toLocaleDateString("en-US", { timeZone: "UTC" });
}
renderPastPeriods();
```
You can try the fully functioning [CycleTracker period tracking web app](https://mdn.github.io/pwa-examples/cycletracker/javascript_functionality) and view the [web app source code](https://github.com/mdn/pwa-examples/tree/main/cycletracker/javascript_functionality) on GitHub. Yes, it works, but it's not a yet PWA.
## Up next
At its core, a PWA is a web application that can be installed is progressively enhanced to work offline. Now that we have a fully functional web application, we add the features required to convert it to a PWA, including the [manifest file](/en-US/docs/Web/Progressive_web_apps/Tutorials/CycleTracker/Manifest_file), [secure connection](/en-US/docs/Web/Progressive_web_apps/Tutorials/CycleTracker/Secure_connection), and [service worker](/en-US/docs/Web/Progressive_web_apps/Tutorials/CycleTracker/Service_workers).
Up first, we create the [CycleTracker's manifest file](/en-US/docs/Web/Progressive_web_apps/Tutorials/CycleTracker/Manifest_file), including the identity, appearance, and iconography for our CycleTracker PWA.
{{PreviousMenuNext("Web/Progressive_web_apps/Tutorials/CycleTracker/HTML_and_CSS", "Web/Progressive_web_apps/Tutorials/CycleTracker/Manifest_file", "Web/Progressive_web_apps/Tutorials/CycleTracker")}}
| 0 |
data/mdn-content/files/en-us/web/progressive_web_apps/tutorials/cycletracker | data/mdn-content/files/en-us/web/progressive_web_apps/tutorials/cycletracker/manifest_file/tire.svg | <svg xmlns="http://www.w3.org/2000/svg" width="600" height="600" xml:space="preserve" style="background:#363"><circle style="stroke:#cfc;stroke-width:45;stroke-dasharray:none;stroke-linecap:butt;stroke-dashoffset:0;stroke-linejoin:miter;stroke-miterlimit:4;fill:none" cx="300" cy="300" r="225"/><path style="stroke:#cfc;stroke-width:50" d="M300 70v455M70 300h455M130 130l340 340m-340 0 340-340"/></svg> | 0 |
data/mdn-content/files/en-us/web/progressive_web_apps/tutorials/cycletracker | data/mdn-content/files/en-us/web/progressive_web_apps/tutorials/cycletracker/manifest_file/index.md | ---
title: "CycleTracker: Manifest and iconography"
short-title: Manifest and iconography
slug: Web/Progressive_web_apps/Tutorials/CycleTracker/Manifest_file
page-type: tutorial-chapter
---
{{PreviousMenuNext("Web/Progressive_web_apps/Tutorials/CycleTracker/JavaScript_functionality", "Web/Progressive_web_apps/Tutorials/CycleTracker/Service_workers", "Web/Progressive_web_apps/Tutorials/CycleTracker")}}
{{PWASidebar}}
A PWA manifest file is a JSON file that provides information about the features of that app to make it look and behave like a native app when installed on the user's device. The manifest contains metadata for your app, including its name, icons, and presentational directives.
While according to the spec, all of the manifest keys, or members, are optional, some browsers, operating systems, and app distributors have [require specific members](/en-US/docs/Web/Progressive_web_apps/Guides/Making_PWAs_installable#required_manifest_members) for a web app to be a PWA. By including a name or short name, the start URL, an icon meeting some minimum requirements, and the type of application viewport in which the PWA should be viewed, your app will meet the manifest requirements of a PWA.
A minimalist manifest file for our menstrual cycle tracking app could look like this:
```js
{
"short_name": "CT",
"start_url" : "/",
"icons": [
{
"src": "icon-512.png",
"sizes": "512x512"
}
],
"display": "standalone"
}
```
Before saving the manifest file and linking to it from our HTML file, we can develop a still brief but more informative JSON object to define the identity, presentation, and iconography of the PWA. Yes, the above would work, but let's discuss the members in this example and a few other members that enable manifest files to better define the appearance of our CycleTracker PWA.
## App identity
To identify your PWA, the JSON must include a `name` or `short_name` member, or both, to define the PWA name. It can also include a `description`.
- [`name`](/en-US/docs/Web/Manifest/name)
- : The name of the PWA. This is the name used when the operating system lists applications, as the label next to the application icon, etc.
- [`short_name`](/en-US/docs/Web/Manifest/short_name)
- : The name of the PWA displayed to the user if there isn't enough space to display the `name`. It is used as the label for icons on phone screens, including in the "Add to Home Screen" dialog on iOS.
When both the `name` and `short_name` are present, the `name` is used in most instances, with the `short_name` used when there is a limited space to display the application name.
- [`description`](/en-US/docs/Web/Manifest/description)
- : Explanation of what the application does. It provides an {{glossary("accessible description")}} of the application's purpose and function.
### Task
Write the first few lines of your manifest file. You can use the text below, or more discreet or descriptive values, and a description of your choosing.
### Example solution
```js
{
"name": "CycleTracker: Period Tracking app",
"short_name": "CT",
"description": "Securely and confidentially track your menstrual cycle. Enter the start and end dates of your periods, saving your private data to your browser on your device, without sharing it with the rest of the world."
}
```
## App presentation
The appearance, or presentation, of a PWA's installed and offline experiences are defined in the manifest. Presentation manifest members include `start_url` and `display`, and members which can be used to [customize your app colors](/en-US/docs/Web/Progressive_web_apps/How_to/Customize_your_app_colors), including `theme_color` and `background_color`.
- [`start_url`](/en-US/docs/Web/Manifest/start_url)
- : The start page when a user launches the PWA.
- [`display`](/en-US/docs/Web/Manifest/display)
- : Controls the app's display mode including `fullscreen`, `standalone`, which displays the [PWA as a standalone application](/en-US/docs/Web/Progressive_web_apps/How_to/Create_a_standalone_app), `minimal-ui`, which is similar to a standalone view but with UI elements for controlling navigation, and `browser`, which opens the app in a regular browser view.
There is also an [`orientation`](/en-US/docs/Web/Manifest/orientation) member that defines the PWA's default orientation as `portrait` or `landscape`. As our app works well in both orientations, we'll omit this member.
### Colors
- [`theme_color`](/en-US/docs/Web/Manifest/theme_color)
- : The default [color of operating system and browser UI elements](/en-US/docs/Web/Progressive_web_apps/How_to/Customize_your_app_colors#define_a_theme_color) such as the status bar on some mobile experiences and the application title bar on desktop operating systems.
- [`background_color`](/en-US/docs/Web/Manifest/background_color)
- : A placeholder color to be displayed as the [background of the app](/en-US/docs/Web/Progressive_web_apps/How_to/Customize_your_app_colors#customize_the_app_window_background_color) until the CSS is loaded. To create a smooth transition between app launch and load, it is recommended to use the [`<color>`](/en-US/docs/Web/CSS/color_value) declared as the app's [`background-color`](/en-US/docs/Web/CSS/background-color) color.
### Task
Add presentation definitions to the manifest file you began creating in the previous task.
### Example solution
As the example application is a single page, we can use `"/"` as the `start_url`, or omit the member altogether. For that same reason, we can display the app without the browser UI by setting the `display` to `standalone`.
In [our CSS](/en-US/docs/Web/Progressive_web_apps/Tutorials/CycleTracker/HTML_and_CSS#css_file), the `background-color: #efe;` is set on the `body` element selector. We use `#eeffee` to ensure a smooth transition from placeholder appearance to app load.
```js
{
"name": "...",
"short_name": "...",
"description": "...",
"start_url": "/",
"theme_color": "#eeffee",
"background_color": "#eeffee",
"display": "standalone"
}
```
## App iconography
PWA icons help users identify your app, make it more visually appealing, and improve discoverability. The PWA app icon appears on home screens, app launchers, or app store search results. The size of the rendered icon and the file requirements varies depending on where it is displayed and by whom. The manifest is where you define your images.
Within the manifest JSON object, the `icons` member specifies an array of one or more icon objects for use in different contexts, each with a `src` and `sizes` member, and optional `type` and `purpose` members. Each icon object's `src` list the source of a single image file. The `sizes` member provides a list of space-separated sizes for which that particular image should be used or the keyword `any`; the value is the same as the {{HTMLElement("link")}} element's [`sizes`](/en-US/docs/Web/HTML/Element/link#sizes) attribute. The `type` member lists the image's MIME type.
```js
{
"name": "MyApp",
"icons": [
{
"src": "icons/tiny.webp",
"sizes": "48x48"
},
{
"src": "icons/small.png",
"sizes": "72x72 96x96 128x128 256x256",
"purpose": "maskable"
},
{
"src": "icons/large.png",
"sizes": "512x512"
},
{
"src": "icons/scalable.svg",
"sizes": "any"
}
]
}
```
All icons should have the same look and feel to ensure users recognize your PWA, but the larger the icon, the greater the detail it can contain. While all icon files are squares, some operating systems render different shapes, cutting sections off, or "masking" the icon, to meet the UI, or shrinking and centering the icon with a background if the icon is not maskable. The [safe zone](/en-US/docs/Web/Progressive_web_apps/How_to/Define_app_icons#support_masking), the area that will render okay if the icon is masked as a circle, is the inner 80% of the image file. Icons are labeled as safe to be masked by the `purpose` member which, when set to `maskable`, defines the [icon as adaptive](https://web.dev/articles/maskable-icon).
In Safari, and therefor for iOS and iPadOS, if you include the [non-standard `apple-touch-icon`](/en-US/docs/Learn/HTML/Introduction_to_HTML/The_head_metadata_in_HTML#adding_custom_icons_to_your_site) in the {{HTMLElement("head")}} of the HTML document via {{HTMLElement("link")}}, they will take precedence over manifest-declared icons.
### Task
Add the icons to the manifest file you have been constructing.
Playing with the words "cycle" and "period" of CycleTracker and the green theme color we've chosen, our icon images could all be light green squares with a green circle. Our smallest size `circle.ico`, and icon file that is just a circle representing the period punctuation mark and app theme color, with our in-between images, `circle.svg`, `tire.svg`, and `wheel.svg`, adding more detail moving from a plain circle to a tire as it gets larger, with our largest icons being a detailed wheel with spokes and shadows. That said, designing icons is beyond the scope of this tutorial.
```html hidden
<div>
<img alt="a green circle" src="circle.svg" role="img" />
<img alt="a simple wheel" src="tire.svg" role="img" />
<img alt="a detailed wheel" src="wheel.svg" role="img" />
</div>
```
```css hidden
div {
display: flex;
gap: 5px;
}
img {
width: 33%;
}
```
{{EmbedLiveSample("PWA iconography", 600, 250)}}
### Example solution
```js
{
"name": "...",
"short_name": "...",
"description": "...",
"start_url": "...",
"theme_color": "...",
"background_color": "...",
"display": "...",
"icons": [
{
"src": "circle.ico",
"sizes": "48x48"
},
{
"src": "icons/circle.svg",
"sizes": "72x72 96x96",
"purpose": "maskable"
},
{
"src": "icons/tire.svg",
"sizes": "128x128 256x256"
},
{
"src": "icons/wheel.svg",
"sizes": "512x512"
}
]
}
```
## Adding the manifest to the app
You now have a fully usable manifest file. Time to save it and link to it from our HTML file.
The manifest file extension can be the specification suggestion `.webappmanifest`. However, being a JSON file, it is most commonly saved with the browser-supported `.json` extension.
PWAs require a manifest file to be linked from the app's HTML document. We have a fully functional app, but it's not yet a PWA because it doesn't link to our external manifest JSON file yet. To include the external JSON resource, we use the `<link>` element, with the `rel="manifest"` attribute, and set the `href` attribute to the location of the resource.
```html
<link rel="manifest" href="cycletracker.json" />
```
The `<link>` element is most commonly used to link to stylesheets and, with PWAs, the required manifest file, but is also used to [establish site icons](/en-US/docs/Web/HTML/Attributes/rel#icon) (both "favicon" style icons and icons for the home screen and apps on mobile devices) among other things.
```html
<link rel="icon" href="icons/circle.svg" />
```
When using the `.webmanifest` extension, set `type="application/manifest+json"` if your server doesn't support that MIME type.
### Task
Save the manifest file that you have created in the steps above, then link to it from the `index.html` file.
Optionally, link to a shortcut icon from your HTML as well.
### Example solution
The {{HTMLelement("head")}} of `index.html` may now look similar to:
```html
<head>
<meta charset="utf-8" />
<meta name="viewport" content="width=device-width" />
<title>Cycle Tracker</title>
<link rel="stylesheet" href="style.css" />
<link rel="manifest" href="cycletracker.json" />
<link rel="icon" href="icons/circle.svg" />
</head>
```
View the [`cycletracker.json` file](https://mdn.github.io/pwa-examples/cycletracker/manifest_file/cycletracker.json) and view the [project source code](https://github.com/mdn/pwa-examples/blob/main/cycletracker/manifest_file/) on GitHub.
With a manifest file, Safari will recognize your site as a web app. For the web app to be a full PWA, we will still need to add a service worker.
## Debugging manifest files
Some browser developer tools provide insight into the app manifest. In Edge, Firefox, and Chrome developer tools, the manifest members and their values are visible under the "Application" panel.
The Manifest App pane provides the name of the manifest file as a link, and identity, presentation, and icons sections.
Supported manifest members are displayed, along with all included values. In this screenshot, while we did not include the `orientation` or `id` members, they are listed. The App panel can be used to see the manifest members and even learn: in this example, we learn that to specify an App Id that matches the current identity, set the `id` field to "/".
Chrome and Edge also provide errors and warnings, protocol handlers, and information to improve the manifest and icons.
Our web app doesn't have any protocol handlers; a topic not covered in this tutorial. Had we included some, they would be found under "Protocol Handlers". As that section is empty, the developer tools link to more information on the topic.
The manifest panel also includes insight into the safe area for maskable icons and a link to a [PWA image generator](https://www.pwabuilder.com/imageGenerator). This tool creates over 100 square PNG images for Android, Apple OSs, and Windows, as well as a JSON object listing all the images and their sizes. The images produced may not serve your needs, but the list of image sizes produced for each OS demonstrates the diversity of where and how PWAs can be served.
The developer tools are useful in identifying which manifest members are supported. Note the Firefox developer tools have entries for `dir`, `lang`, `orientation`, `scope`, and `id`, even though our manifest file did not include these members. Firefox also includes the value of the `purpose` member for each icon, displaying `any` if no the purpose is not explicitly set.
## Up next
To get the PWA benefits from other browsers and all operating systems that support PWAs, we need to [add a service worker](/en-US/docs/Web/Progressive_web_apps/Tutorials/CycleTracker/Service_workers), which we'll do without using a framework.
{{PreviousMenuNext("Web/Progressive_web_apps/Tutorials/CycleTracker/JavaScript_functionality", "Web/Progressive_web_apps/Tutorials/CycleTracker/Service_workers", "Web/Progressive_web_apps/Tutorials/CycleTracker")}}
| 0 |
data/mdn-content/files/en-us/web/progressive_web_apps/tutorials/cycletracker | data/mdn-content/files/en-us/web/progressive_web_apps/tutorials/cycletracker/manifest_file/wheel.svg | <svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" version="1.1" width="600" height="600" viewBox="0 0 600 600" xml:space="preserve" style="background: #363">
<style>
line {
stroke: #cfc;
stroke-width: 20;
transform-origin: center;
}
circle {
stroke-miterlimit: 4;
fill: none;
}
</style>
<line x1="300" y1="70" x2="300" y2="525" />
<line style="rotate: 22.5deg;" x1="300" y1="70" x2="300" y2="525" />
<line style="rotate: 45deg;" x1="300" y1="70" x2="300" y2="525" />
<line style="rotate: 67.5deg;" x1="300" y1="70" x2="300" y2="525" />
<line style="rotate: 90deg;" x1="300" y1="70" x2="300" y2="525" />
<line style="rotate: 112.5deg;" x1="300" y1="70" x2="300" y2="525" />
<line style="rotate: 135deg;" x1="300" y1="70" x2="300" y2="525" />
<line style="rotate: 157.5deg;" x1="300" y1="70" x2="300" y2="525" />
<circle style="stroke: #fff; stroke-width: 35;" cx="300" cy="300" r="223" />
<circle style="stroke: #cfc; stroke-width: 35;" cx="300" cy="300" r="225" />
<circle style="stroke: #bfb; stroke-width: 25;" cx="300" cy="300" r="229" />
<circle style="stroke: #afa; stroke-width: 15;" cx="300" cy="300" r="233" />
<circle style="stroke: #9f9; stroke-width: 5;" cx="300" cy="300" r="237" />
<circle style="stroke: #484; stroke-width: 1;" cx="300" cy="300" r="240" />
<circle style="stroke: #393; stroke-width: 1;" cx="300" cy="300" r="233" />
<circle style="stroke: #2a2; stroke-width: 1;" cx="300" cy="300" r="226" />
<circle style="stroke: #1b1; stroke-width: 1;" cx="300" cy="300" r="219" />
<circle style="stroke: #aca; stroke-width: 1;" cx="300" cy="300" r="212" />
<circle style="stroke: #363; stroke-width: 4;" cx="300" cy="300" r="204" />
<circle style="stroke: #fff; stroke-width: 29;" cx="300" cy="300" r="55" />
<circle style="stroke: #cfc; stroke-width: 28;" cx="300" cy="300" r="55" />
<circle style="stroke: #bfb; stroke-width: 22;" cx="300" cy="300" r="45" />
<circle style="stroke: #afa; stroke-width: 18;" cx="300" cy="300" r="45" />
<circle style="stroke: #9f9; stroke-width: 12;" cx="300" cy="300" r="25" />
<circle style="stroke: #363; stroke-width: 3;" cx="300" cy="300" r="69" />
<circle style="stroke: #363; stroke-width: 3;" cx="300" cy="300" r="55" />
<circle style="stroke: #2a2; stroke-width: 1;" cx="300" cy="300" r="50" />
<circle style="stroke: #1b1; stroke-width: 1;" cx="300" cy="300" r="45" />
<circle style="stroke: #aca; stroke-width: 1;" cx="300" cy="300" r="40" />
<circle style="stroke: #bdb; stroke-width: 1;" cx="300" cy="300" r="35" />
<circle style="fill: #363; stroke-width: 0;" cx="300" cy="300" r="28" />
</svg> | 0 |
data/mdn-content/files/en-us/web/progressive_web_apps/tutorials/cycletracker | data/mdn-content/files/en-us/web/progressive_web_apps/tutorials/cycletracker/manifest_file/circle.svg | <svg xmlns="http://www.w3.org/2000/svg" width="600" height="600" xml:space="preserve" style="background:#363"><circle style="stroke:none;fill:#cfc" cx="300" cy="300" r="255"/></svg> | 0 |
data/mdn-content/files/en-us/web/progressive_web_apps/tutorials/cycletracker | data/mdn-content/files/en-us/web/progressive_web_apps/tutorials/cycletracker/html_and_css/index.md | ---
title: "CycleTracker: Base HTML and CSS"
short-title: Base HTML and CSS
slug: Web/Progressive_web_apps/Tutorials/CycleTracker/HTML_and_CSS
page-type: tutorial-chapter
---
{{PreviousMenuNext("Web/Progressive_web_apps/Tutorials/CycleTracker", "Web/Progressive_web_apps/Tutorials/CycleTracker/Secure_connection", "Web/Progressive_web_apps/Tutorials/CycleTracker")}}
{{PWASidebar}}
To build a PWA, a progressive web application, we need to create a fully-functioning web application. In this section, we will markup the HTML for a static web page and enhance the appearance with CSS.
Our project is to create CycleTracker, a menstrual cycle tracker.
The first step in this introductory [PWA tutorial](/en-US/docs/Web/Progressive_web_apps/Tutorials) is to write the HTML and CSS. The top section of the page is a form for the user to enter the start and end dates of each period. The bottom is a list of previous menstrual cycles.
We create an HTML file, with meta data in the head and a static web page containing a form and a placeholder to display user inputted data. We'll then add an external CSS stylesheet to improve the site's appearance.
To complete this tutorial, it is helpful to have a basic level of understanding of [HTML](/en-US/docs/Learn/Getting_started_with_the_web/HTML_basics), [CSS](/en-US/docs/Learn/Getting_started_with_the_web/CSS_basics), and [JavaScript](/en-US/docs/Learn/Getting_started_with_the_web/JavaScript_basics). If you're not familiar with these, MDN is the home of [Getting Started](/en-US/docs/Learn/Getting_started_with_the_web), an introduction to web development series.
In the next sections, we'll set up a [local development environment](/en-US/docs/Web/Progressive_web_apps/Tutorials/CycleTracker/Secure_connection) and take a look at our progress before adding [JavaScript functionality](/en-US/docs/Web/Progressive_web_apps/Tutorials/CycleTracker/JavaScript_functionality) to convert the static content created in this section into a functional web application. Once we have a functioning app we will have something that we can progressively enhance into a PWA that is installable and works offline.
## Static web content
Our static site HTML, with placeholder {{HTMLElement("link")}} and {{HTMLElement("script")}} elements for yet-to-be-created external CSS and JavaScript files, is:
```html
<!doctype html>
<html lang="en-US">
<head>
<meta charset="utf-8" />
<meta name="viewport" content="width=device-width" />
<title>Cycle Tracker</title>
<link rel="stylesheet" href="style.css" />
</head>
<body>
<h1>Period tracker</h1>
<form>
<fieldset>
<legend>Enter your period start and end date</legend>
<p>
<label for="start-date">Start date</label>
<input type="date" id="start-date" required />
</p>
<p>
<label for="end-date">End date</label>
<input type="date" id="end-date" required />
</p>
</fieldset>
<p>
<button type="submit">Add Period</button>
</p>
</form>
<section id="past-periods"></section>
<script src="app.js" defer></script>
</body>
</html>
```
Copy this HTML and save it in a file called `index.html`.
## HTML content
Even if the HTML in `index.html` is familiar to you, we recommend reading through this section before adding some [temporary hard-coded data](#temporary-hard-coded-results-text), adding CSS to a [`style.css`](#css_content) external stylesheet, and creating `app.js`, the [application's JavaScript](/en-US/docs/Web/Progressive_web_apps/Tutorials/CycleTracker/JavaScript_functionality) that makes this web page function.
The HTML's first line is a {{glossary("doctype")}} preamble, which ensures the content behaves correctly.
```html
<!doctype html>
```
The root {{HTMLelement("html")}} tags wrap all the content with the [`lang`](/en-US/docs/Web/HTML/Global_attributes/lang) attribute defining the primary language of the page.
```html
<!doctype html>
<html lang="en-US">
<!-- the <head> and <body> will go here -->
</html>
```
### Document head
The {{HTMLelement("head")}} contains machine-readable information about the web application that's not visible to readers except for the `<title>`, which is displayed as the heading of the browser tab.
The `<head>` includes all the [meta data](/en-US/docs/Learn/HTML/Introduction_to_HTML/The_head_metadata_in_HTML). The first two bits of information in your `<head>` should always be the character set definition, which defines the [character encoding](/en-US/docs/Glossary/Character_encoding), and the [viewport](/en-US/docs/Web/HTML/Viewport_meta_tag) {{HTMLelement("meta")}} tag, which ensures the page renders at the width of the viewport and isn't shrunken down when loaded on very small screens.
```html
<head>
<meta charset="utf-8" />
<meta name="viewport" content="width=device-width" />
</head>
```
We set the title of the page to "Cycle Tracker" with the {{HTMLelement("title")}} element. While the contents of the `<head>` are not displayed within the page, the contents of the `<title>` are seen! The `<title>` element's inner text appears in the browser tab when the page is loaded, in search engine results, and is the default title used when a user bookmarks a web page. The title also provides an accessible name for screen reader users who depend on it to know which tab they're currently on.
While the title could be "Menstrual cycle tracking application", we opted for a shortened name that is more discreet.
```html
<title>Cycle Tracker</title>
```
While officially optional, for better user experience, these two `<meta>` tags and the `<title>` are the three components of the `<head>` that should be considered required components of any HTML document.
For right now, the last component we include in the `<head>` is a {{HTMLelement("link")}} element linking `style.css`, our yet-to-be-written stylesheet, to our HTML.
```html
<link rel="stylesheet" href="style.css" />
```
The HTML `<link>` element is used to specify a relationship between the current document and an external resource. There are more than 25 defined values for the [`rel`](/en-US/docs/Web/HTML/Attributes/rel) attribute—and many more values that are not in any specification. The most common value, `rel="stylesheet"`, imports an external resource as a stylesheet.
We will revisit the `<link>` element and its `rel` attribute in a future section when we include the [link to the manifest](/en-US/docs/Web/Progressive_web_apps/Tutorials/CycleTracker/Manifest_file#adding_the_manifest_to_the_app) file.
### Document body
The {{HTMLelement("body")}} element contains all the content we want displayed when users visit the site on the Internet.
Within the `<body>`, we include the name of the app as a level-1 heading using an [`<h1>`](/en-US/docs/Web/HTML/Element/Heading_Elements) and a {{HTMLelement("form")}}.
```html
<body>
<h1>Period tracker</h1>
<form></form>
</body>
```
The form will contain instructions, form controls, a label for each form control, and a submit button. In terms of form controls, we need the user to enter both a start date and an end date for each menstrual cycle submitted.
Within the `<form>`, we include a {{HTMLelement("fieldset")}} with a {{HTMLelement("legend")}} labeling the purpose of that set of form fields.
```html
<form>
<fieldset>
<legend>Enter your period start and end date</legend>
</fieldset>
</form>
```
The date pickers are {{HTMLElement("input")}} elements of type {{HTMLElement("input/date", "date")}}. We include the [`required`](/en-US/docs/Web/HTML/Attributes/required) attribute to reduce user errors by preventing the user from accidentally submitting an incomplete form.
To associate a `<label>` with a form control, each `<input>` has an [`id`](/en-US/docs/Web/HTML/Global_attributes/id) attribute matching the [`for`](/en-US/docs/Web/HTML/Attributes/for) attribute of the associated {{HTMLelement("label")}}. The associated label provides each `<input>` with an {{glossary("accessible name")}}.
```html
<label for="start-date">Start date</label>
<input type="date" id="start-date" required />
```
Putting it altogether, within the `<fieldset>`, we include two paragraphs ({{HTMLelement("p")}} elements), each with a date picker for the start and end dates of the menstrual cycle currently being entered, along with the date pickers' associated {{HTMLelement("label")}}s. We also include a {{HTMLelement("button")}} element which submits the form; we label it "Add period" by including that text between the opening and closing tags. The `type="submit"` is optional, as `submit` is the default type for `<button>`.
```html
<form>
<fieldset>
<legend>Enter your period start and end date</legend>
<p>
<label for="start-date">Start date</label>
<input type="date" id="start-date" required />
</p>
<p>
<label for="end-date">End date</label>
<input type="date" id="end-date" required />
</p>
</fieldset>
<p>
<button type="submit">Add Period</button>
</p>
</form>
```
We encourage you to [learn more about making accessible web forms](/en-US/docs/Learn/Forms).
### Temporary hard-coded results text
We then include an empty {{HTMLElement("section")}}. This container will be populated using JavaScript.
```html
<section id="past-periods"></section>
```
When the user submits the form, we will use JavaScript to capture the data and present a list of past periods along with a header for the section.
For the time being, we temporarily hardcode some content within this `<section>`, including an `<h2>` header and a few past periods, to have something to style as we write the page's CSS.
```html
<section id="past-periods">
<h2>Past periods</h2>
<ul>
<li>From 01/01/2024 to 01/06/2024</li>
<li>From 01/29/2024 to 02/04/2024</li>
</ul>
</section>
```
This content, other than the container `<section id="past-periods"></section>`, is temporary. We will remove or comment-out this temporary data once we [complete the CSS](#css_content) and are satisfied with the app's appearance.
### JavaScript link
Before closing the `</body>`, we include a link to the yet-to-be-written `app.js` JavaScript file. We include the [`defer`](/en-US/docs/Learn/JavaScript/First_steps/What_is_JavaScript#async_and_defer) attribute to defer the loading of this script and ensure the JavaScript is executed after the document's HTML has been parsed.
```html
<script src="app.js" defer></script>
```
The `app.js` file will include all the workings of our application, including the event handlers for the `<button>`, saving the data submitted to local storage, and displaying cycles within the content of the body.
The [HTML file for this step](https://github.com/mdn/pwa-examples/tree/main/cycletracker/html_and_css/index.html) is now complete! You can open the file in your browser at this point, but you'll notice that it's quite plain. We'll fix that in the next section.
## CSS content
We can now style the static HTML using CSS. Our final CSS is:
```css
body {
margin: 1vh 1vw;
background-color: #efe;
}
ul,
fieldset,
legend {
border: 1px solid;
background-color: #fff;
}
ul {
padding: 0;
font-family: monospace;
}
li,
legend {
list-style-type: none;
padding: 0.2em 0.5em;
background-color: #cfc;
}
li:nth-of-type(even) {
background-color: inherit;
}
```
If every line is familiar to you, you can copy the above CSS, or write your own CSS, and save the file as [`style.css`](https://github.com/mdn/pwa-examples/tree/main/cycletracker/html_and_css/style.css), then [finish up the static HTML and CSS](#finishing_the_static_html_and_css_for_our_pwa). If anything in the above CSS is new to you, keep reading for an explanation.
### CSS explained
We use the {{CSSXref("background-color")}} property to set a light green (`#efe`) background color on the `body`. Then on the unordered list, fieldset, and legend, we use a white (`#fff`) background color, along with a thin solid border added with the {{CSSXref("border")}} property. We override the `background-color` for the legend, making the legend and the list items a darker green (`#cfc`).
We use the [`:nth-of-type(even)`](/en-US/docs/Web/CSS/:nth-of-type) pseudo-class [selector](/en-US/docs/Web/CSS/CSS_selectors) to set every even-numbered list item to {{CSSXref("inherit")}} the background color from its parent; in this case, inheriting the `#fff` background color from the unordered list.
```css
body {
background-color: #efe;
}
ul,
fieldset,
legend {
border: 1px solid;
background-color: #fff;
}
li,
legend {
background-color: #cfc;
}
li:nth-of-type(even) {
background-color: inherit;
}
```
To make the unordered list and list items not look like a list, we remove the padding by setting {{CSSXref("padding", "padding: 0")}} on the `ul` and remove the list markers by setting {{CSSXref("list-style-type", "list-style-type: none")}} on the list items themselves.
```css
ul {
padding: 0;
}
li {
list-style-type: none;
}
```
We add a little white space by setting the `body`'s {{CSSXref("margin")}} using the `vw` and `vh` [viewport units](/en-US/docs/Web/CSS/length#relative_length_units_based_on_viewport), making white space on the outside of our app be proportional to the viewport's size. We also add a little padding to the `li` and `legend`. Finally, to improve, but not fix, the alignment of the past-periods data, we set the {{CSSXref("font-family")}} of the `ul` results section to be `monospace`, making each glyph have the same fixed width.
```css
body {
margin: 1vh 1vw;
}
ul {
font-family: monospace;
}
li,
legend {
padding: 0.2em 0.5em;
}
```
We can combine the above, putting multiple properties in each selector declaration block. We can even put the styles for the `li` and `legend` together; irrelevant styles, like the `list-style-type` declaration on `legend`, are ignored.
```css
body {
margin: 1vh 1vw;
background-color: #efe;
}
ul,
fieldset,
legend {
border: 1px solid;
background-color: #fff;
}
ul {
padding: 0;
font-family: monospace;
}
li,
legend {
list-style-type: none;
padding: 0.2em 0.5em;
background-color: #cfc;
}
li:nth-of-type(even) {
background-color: inherit;
}
```
If any of the above CSS still looks unfamiliar to you, you can look up the [CSS properties](/en-US/docs/Glossary/Property/CSS) and [selectors](/en-US/docs/Web/CSS/CSS_selectors), or work through the [getting started with CSS](/en-US/docs/Learn/CSS/First_steps/Getting_started) learning path.
Whether you use the above CSS verbatim, edit the above styles to your preference, or write your own CSS from scratch, include all the CSS in a new file and save it as [`style.css`](https://github.com/mdn/pwa-examples/tree/main/cycletracker/html_and_css/style.css) in the same directory as your `index.html` file.
### Finishing the static HTML and CSS for our PWA
Before moving on, [comment](/en-US/docs/Learn/HTML/Introduction_to_HTML/Getting_started#html_comments) out or delete the fake past period data and header:
```html
<section id="past-periods">
<!--
<h2>Past periods</h2>
<ul>
<li>From 01/01/2024 to 01/06/2024</li>
<li>From 01/29/2024 to 02/04/2024</li>
</ul>
-->
</section>
```
## Up next
Before adding the [JavaScript functionality](/en-US/docs/Web/Progressive_web_apps/Tutorials/CycleTracker/JavaScript_functionality) to convert this static content into a web app and then enhancing it into a progressive web app with a [manifest file](/en-US/docs/Web/Progressive_web_apps/Tutorials/CycleTracker/Manifest_file) and [service worker](/en-US/docs/Web/Progressive_web_apps/Tutorials/CycleTracker/Service_workers), we'll [create a local development environment](/en-US/docs/Web/Progressive_web_apps/Tutorials/CycleTracker/Secure_connection) to view our progress.
Until then, you can view the [static CycleTracker shell](https://mdn.github.io/pwa-examples/cycletracker/html_and_css) and download the [CycleTracker HTML and CSS source code](https://github.com/mdn/pwa-examples/tree/main/cycletracker/html_and_css) from GitHub.
{{PreviousMenuNext("Web/Progressive_web_apps/Tutorials/CycleTracker/", "Web/Progressive_web_apps/Tutorials/CycleTracker/Secure_connection", "Web/Progressive_web_apps/Tutorials/CycleTracker")}}
| 0 |
data/mdn-content/files/en-us/web/progressive_web_apps/tutorials/cycletracker | data/mdn-content/files/en-us/web/progressive_web_apps/tutorials/cycletracker/service_workers/index.md | ---
title: "CycleTracker: Service workers"
short-title: Service workers
slug: Web/Progressive_web_apps/Tutorials/CycleTracker/Service_workers
page-type: tutorial-chapter
---
{{PWASidebar}}
{{PreviousMenu("Web/Progressive_web_apps/Tutorials/CycleTracker/Manifest_file", "Web/Progressive_web_apps/Tutorials/CycleTracker")}}
Thus far, we've written the HTML, CSS, and JavaScript for CycleTracker. We added a manifest file defining colors, icons, URL, and other app features. We have a working web app! But it isn't yet a PWA. In this section, we will write the JavaScript required to convert our fully functional web application into a PWA that can be distributed as a standalone app and works seamlessly offline.
If you haven't already done so, copy the [HTML](https://github.com/mdn/pwa-examples/tree/main/cycletracker/manifest_file/index.html), [CSS](https://github.com/mdn/pwa-examples/tree/main/cycletracker/manifest_file/style.css), [JavaScript](https://github.com/mdn/pwa-examples/tree/main/cycletracker/manifest_file/app.js), and [manifest](https://github.com/mdn/pwa-examples/tree/main/cycletracker/manifest_file/cycletracker.json) JSON file. Save them to files called `index.html`, `style.css`, `app.js`, and `cycletracker.json`, respectively.
In this section, we are creating `sw.js`, the service worker script, that will convert our Web App into a PWA. We already have one JavaScript file; the last line in the HTML file calls the `app.js`. This JavaScript provides all the functionality for the standard web application features. Instead of calling the `sw.js` file like we did the `app.js` file with the `src` attribute of {{HTMLElement("script")}}, we will create a relationship between the web app and its service worker by registering the service worker.
At the end of this lesson, you will have a fully functional PWA; a progressively enhanced web application that is fully installable that works even when the user is offline.
## Service worker responsibilities
The service worker is what makes the application work offline while making sure the application is always up to date. To do this well, the service worker should include the following:
- Version number (or other identifier).
- List of resources to cache.
- Cache version name.
The service worker is also responsible for:
- Installing the cache when the app is installed.
- Updating itself and the other application file as needed.
- Removing cached files that are no longer used.
We achieve these tasks by reacting to three service worker events, including the
- [`fetch`](/en-US/docs/Web/API/ServiceWorkerGlobalScope/fetch_event),
- [`install`](/en-US/docs/Web/API/ServiceWorkerGlobalScope/install_event), and
- [`activate`](/en-US/docs/Web/API/ServiceWorkerGlobalScope/activate_event) events.
### Version number
Once the PWA is installed on the user's machine, the only way to inform the browser that there are updated files to be retrieved is for there to be a change in the service worker. If a change is made to any other PWA resource — if the HTML is updated, a bug is fixed in the CSS, a function is added to `app.js`, an image is compressed to reduce the file save, etc. — the service worker of your installed PWA will not know it needs to download updated resources. Only when the service worker is altered in any way, will the PWA know it may be time to update the cache; which is the service worker's task to initiate.
While changing any character may technically suffice, a PWA best practice is to create a version number constant that gets updated sequentially to indicate an update to the file. Updating a version number (or date), provides an official edit to the service worker even if nothing else is changed in the service worker itself and provides developers with a way of identifying app versions.
#### Task
Start a JavaScript file by including a version number:
```js
const VERSION = "v1";
```
Save the file as `sw.js`
### Offline resource list
For a good offline experience, the list of cached files should include all the resources used within the PWA's offline experience. While the manifest file may have a multitude of icons listed in various sizes, the application cache only needs to include the assets used by the app in offline mode.
```js
const APP_STATIC_RESOURCES = [
"/",
"/index.html",
"/style.css",
"/app.js",
"/icon-512x512.png",
];
```
You don't need to include the various icons that are used by all the different operating systems and devices in the list. But do include any images that are used within the app, including assets to used within any splash pages that may be visible if the app is slow as the app loads or used in any "you need to connect to the internet for the full experience" type pages.
Do not include the service worker file in the list of resources to be cached.
#### Task
Add the list of resources to be cached for the CycleTracker PWA to `sw.js`.
#### Example solution
We include the static resources created in other sections of this tutorial that CycleTracker needs to function when offline. Our current `sw.js` file is:
```js
const VERSION = "v1";
const APP_STATIC_RESOURCES = [
"/",
"/index.html",
"/style.css",
"/app.js",
"/cycletrack.json",
"/icons/wheel.svg",
];
```
We included the `wheel.svg` icon, even though our current application doesn't use it, in case you are enhancing the PWA UI, such as displaying the logo when there is no period data.
### Application cache name
We have a version number and we have the files that need to be cached. Before caching the files, we need to create a name of the cache that will be used to store the app's static resources. This cache name should be versioned to ensure that when the app is updated, a new cache will be created and the old one will be deleted.
#### Task
Use the `VERSION` number to create a versioned `CACHE_NAME`, adding it as a constant to `sw.js`.
#### Example solution
We name our cache `period-tracker-` with the current `VERSION` appended. As the constant declaration is on a single line, we put it before the array of resources constant for better legibility.
```js
const VERSION = "v1";
const CACHE_NAME = `period-tracker-${VERSION}`;
const APP_STATIC_RESOURCES = [ ... ];
```
We have successfully declared our constants; a unique identifier, the list of offline resources as an array, and the application's cache name that changes every time the identifier is updated. Now let's focus on installing, updating, and deleting unused cached resources.
### Saving the cache on PWA installation
When a user installs a PWA or simply visits a website with a service worker, an `install` event is fired in the service worker scope. We want to listen for this event, filling the cache with the PWA's static resources upon installation. Every time the service worker version is updated, the browser installs the new service worker and the install event occurs.
The `install` event happens when the app is used for the first time, or when a new version of the service worker is detected by the browser. When an older service worker is being replaced by a new one, the old service worker is used as the PWA's service worker until the new service work is activated.
Only available in secure contexts, the [`caches`](/en-US/docs/Web/API/caches) global property returns a {{domxref("CacheStorage")}} object associated with the current context. The {{domxref("CacheStorage.open()")}} method returns a {{jsxref("Promise")}} that resolves to the {{domxref("Cache")}} object matching name of the cache, passed as a parameter.
The {{domxref("Cache.addAll()")}} method takes an array of URLs as a parameter, retrieves them, then adds the responses to the given cache. The [`waitUntil()`](/en-US/docs/Web/API/ExtendableEvent/waitUntil) method tells the browser that work is ongoing until the promise settles, and it shouldn't terminate the service worker if it wants that work to complete. While browsers are responsible for executing and terminating service workers when necessary, the `waitUntil` method is a request to the browser to not terminate the service worker while a task is being executed.
```js
self.addEventListener("install", (e) => {
e.waitUntil((async () => {
const cache = await caches.open("cacheName_identifier");
cache.addAll([
"/",
"/index.html"
"/style.css"
"/app.js"
]);
})()
);
});
```
#### Task
Add an install event listener that retrieves and stores the files listed in `APP_STATIC_RESOURCES` into the cache named `CACHE_NAME`.
#### Example solution
```js
self.addEventListener("install", (event) => {
event.waitUntil(
(async () => {
const cache = await caches.open(CACHE_NAME);
cache.addAll(APP_STATIC_RESOURCES);
})(),
);
});
```
### Updating the PWA and deleting old caches
As mentioned, when an existing service worker is being replaced by a new one, the existing service worker is used as the PWA's service worker until the new service worker is activated. We use the `activate` event to delete old caches to avoid running out of space. We iterate over named {{domxref("Cache")}} objects, deleting all but the current one, and then set the service worker as the [`controller`](/en-US/docs/Web/API/ServiceWorkerContainer/controller) for the PWA.
We listen for the current service worker's global scope [`activate`](/en-US/docs/Web/API/ServiceWorkerGlobalScope/activate_event) event.
We get the names of the existing named caches. We use the {{domxref("CacheStorage.keys()")}} method (again accessing `CacheStorage` through the global {{domxref("caches")}} property) which returns a {{jsxref("Promise")}} that resolves with an array containing strings corresponding to all of the named {{domxref("Cache")}} objects in the order they were created.
We use the [`Promise.all()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/all) method to iterate through that list of name cache promises. The `all()` method takes as input a list of iterable promises and returns a single `Promise`. For each name in the list of named caches, check if the cache is the currently active cache. If not, delete it with the `Cache` [`delete()`](/en-US/docs/Web/API/Cache/delete) method.
The last line, the `await clients.claim()` uses the [`claim()`](/en-US/docs/Web/API/Clients/claim) method of the [`Clients`](/en-US/docs/Web/API/Clients) interface to enable our service worker to set itself as the controller for our client; the "client" referring to a running instance of the PWA. The `claim()` method enables the service worker to "claim control" of all clients within its scope. This way, clients loaded in the same scope don't need to be reloaded.
```js
self.addEventListener("activate", (event) => {
event.waitUntil(
(async () => {
const names = await caches.keys();
await Promise.all(
names.map((name) => {
if (name !== CACHE_NAME) {
return caches.delete(name);
}
}),
);
await clients.claim();
})(),
);
});
```
#### Task
Add the above `activate` eventListener to your `sw.js` file.
### The fetch event
We can take advantage of the [`fetch`](/en-US/docs/Web/API/ServiceWorkerGlobalScope/fetch_event) event, to prevent an installed PWA from making requests if the user is online. Listening to the fetch event makes it possible to intercept all requests and respond with cached responses instead of going to the network. Most applications don't require this behavior. In fact, many business models want users to regularly make server requests for tracking and marketing purposes. So, while intercepting requests may be an anti-pattern for some, to improve the privacy of our CycleTracker app, we don't want the app to make unnecessary server requests.
As our PWA consists of a single page, for page navigation requests, we go back to the `index.html` home page. There are no other pages and we don't ever want to go to the server. If the Fetch API's [`Request`](/en-US/docs/Web/API/Request) readonly [`mode`](/en-US/docs/Web/API/Request/mode) property is `navigate`, meaning it's looking for a web page, we use the FetchEvent's [`respondWith()`](/en-US/docs/Web/API/FetchEvent/respondWith) method to prevent the browser's default fetch handling, providing our own response promise employing the [`caches.match()`](/en-US/docs/Web/API/CacheStorage/match) method.
For all other request modes, we open the caches as done in the [install event response](#saving_the_cache_on_pwa_installation), instead passing the event request to the same `match()` method. It checks if the request is a key for a stored {{domxref("Response")}}. If yes, it returns the cached response. If not, we return a [404 status](/en-US/docs/Web/HTTP/Status/404) as a response.
Using the [`Response()`](/en-US/docs/Web/API/Response/Response) constructor to pass a `null` body and a `status: 404` as options, doesn't mean there is an error in our PWA. Rather, everything we need should already be in the cache, and if it isn't, we're not going to the server to resolve this non-issue.
```js
self.addEventListener("fetch", (event) => {
// when seeking an HTML page
if (event.request.mode === "navigate") {
// Return to the index.html page
event.respondWith(caches.match("/"));
return;
}
// For every other request type
event.respondWith(
(async () => {
const cache = await caches.open(CACHE_NAME);
const cachedResponse = await cache.match(event.request.url);
if (cachedResponse) {
// Return the cached response if it's available.
return cachedResponse;
}
// Respond with a HTTP 404 response status.
return new Response(null, { status: 404 });
})(),
);
});
```
## Complete service worker file
Your `sw.js` file should look similar to the following JavaScript. Note that when updating any of the resources listed in the `APP_STATIC_RESOURCES` array, the only constant or function that must be updated within this service worker is the value of `VERSION`.
```js
// The version of the cache.
const VERSION = "v1";
// The name of the cache
const CACHE_NAME = `period-tracker-${VERSION}`;
// The static resources that the app needs to function.
const APP_STATIC_RESOURCES = [
"/",
"/index.html",
"/app.js",
"/style.css",
"/icons/wheel.svg",
];
// On install, cache the static resources
self.addEventListener("install", (event) => {
event.waitUntil(
(async () => {
const cache = await caches.open(CACHE_NAME);
cache.addAll(APP_STATIC_RESOURCES);
})(),
);
});
// delete old caches on activate
self.addEventListener("activate", (event) => {
event.waitUntil(
(async () => {
const names = await caches.keys();
await Promise.all(
names.map((name) => {
if (name !== CACHE_NAME) {
return caches.delete(name);
}
}),
);
await clients.claim();
})(),
);
});
// On fetch, intercept server requests
// and respond with cached responses instead of going to network
self.addEventListener("fetch", (event) => {
// As a single page app, direct app to always go to cached home page.
if (event.request.mode === "navigate") {
event.respondWith(caches.match("/"));
return;
}
// For all other requests, go to the cache first, and then the network.
event.respondWith(
(async () => {
const cache = await caches.open(CACHE_NAME);
const cachedResponse = await cache.match(event.request.url);
if (cachedResponse) {
// Return the cached response if it's available.
return cachedResponse;
}
// If resource isn't in the cache, return a 404.
return new Response(null, { status: 404 });
})(),
);
});
```
When updating a service worker, the VERSION constant doesn't need to be updated, as any change in the content of the service worker script itself will trigger the browser to install the new service worker. However, it is a good practice to update the version number as it makes it easier for devs, including yourself, to see which version of the service worker is currently running in the browser, by [checking the name of the Cache in the Application tool](#with_developer_tools) (or Sources tool).
**Note:** Updating VERSION is important when making changes to any application resource, including the CSS, HTML, and JS code, and image assets. The version number, or any change to the service worker file, is the only way to force an update of the app for your users.
## Register the service worker
Now that our service worker script is complete, we need to register the service worker.
We start by checking that the browser supports the [Service Worker API](/en-US/docs/Web/API/Service_Worker_API) by using [feature detection](/en-US/docs/Learn/Tools_and_testing/Cross_browser_testing/Feature_detection#the_concept_of_feature_detection) for the presence of the [`serviceWorker`](/en-US/docs/Web/API/ServiceWorker) property on the global [`navigator`](/en-US/docs/Web/API/Navigator) object:
```html
<script>
// Does "serviceWorker" exist
if ("serviceWorker" in navigator) {
// If yes, we register the service worker
}
</script>
```
If the property is supported, we can then use the [`register()`](/en-US/docs/Web/API/ServiceWorkerContainer/register) method of the service worker API's [`ServiceWorkerContainer`](/en-US/docs/Web/API/ServiceWorkerContainer) interface.
```html
<script>
if ("serviceWorker" in navigator) {
// Register the app's service worker
// Passing the filename where that worker is defined.
navigator.serviceWorker.register("sw.js");
}
</script>
```
While the above suffices for the CycleTracker app needs, the `register()` method does return a {{jsxref("Promise")}} that resolves with a {{domxref("ServiceWorkerRegistration")}} object. For a more robust application, error check the registration:
```js
if ("serviceWorker" in navigator) {
navigator.serviceWorker.register("sw.js").then(
(registration) => {
console.log("Service worker registration successful:", registration);
},
(error) => {
console.error(`Service worker registration failed: ${error}`);
},
);
} else {
console.error("Service workers are not supported.");
}
```
### Task
Open `index.html` and add the following {{HTMLElement("script")}} after the script to include `app.js` and before the closing `</body>` tag.
```html
<!-- Register the app's service worker. -->
<script>
if ("serviceWorker" in navigator) {
navigator.serviceWorker.register("sw.js");
}
</script>
```
You can try the fully functioning [CycleTracker period tracking web app](https://mdn.github.io/pwa-examples/cycletracker/service_workers) and view the [web app source code](https://github.com/mdn/pwa-examples/tree/main/cycletracker/service_workers) on GitHub. Yes, it works, and it is now, officially, a PWA!
## Debugging service workers
Because of the way we have set up the service worker, once it is registered, every request will pull from the cache instead of loading new content. When developing, you will be editing your code frequently. You likely want to test your edits in the browser regularly; likely with every save.
### By updating the version number and doing a hard reset
To get a new cache, you can change the [version number](#version_number) and then do a hard browser refresh. The way you do a hard refresh depends on the browser and operating system:
- On Windows: Ctrl+F5, Shift+F5, or Ctrl+Shift+R.
- On MacOS: Shift+Command+R.
- Safari on MacOS: Option+Command+E to empty the cache, then Option+Command+R.
- On Mobile: Go to the browser (Android) or operating system (Samsung, iOS) settings, under advanced setting find the browser (iOS) or website data (Android, Samsung) site settings, and delete the data for CycleTracker, before reloading the page.
### With developer tools
You likely don't want to update the version number with every save. Until you are ready to launch a new version of your PWA to production and give everyone a new version of your PWA, instead of changing the version number on save, you can unregister the service worker.
You can unregister a service worker by clicking on the `unregister` button in the [browser developer tools](/en-US/docs/Learn/Common_questions/Tools_and_setup/What_are_browser_developer_tools). Hard refreshing the page will re-register the service worker and create a new cache.
In some developer tools, you can manually unregister a service worker, or you can select the service workers "update on reload" option which sets the developer tools to reset and re-activate the service worker on every reload as long as the developer tools are open. There is also an option to bypass the service worker and load resources from the network. This panel includes features we are not covering in this tutorial, but will be helpful as you create more advanced PWAs that include [syncing](/en-US/docs/Web/Progressive_web_apps/Guides/Offline_and_background_operation#periodic_background_sync) and [push](/en-US/docs/Web/Progressive_web_apps/Guides/Offline_and_background_operation#push), which are both covered in the [offline and background operation guide](/en-US/docs/Web/Progressive_web_apps/Guides/Offline_and_background_operation).
The service worker window within the DevTools' application panel, provides a link to access to pop up window containing a list of all the registered service workers for the browser; not just the service worker for the application opened in the current tab. Each service worker list of workers has buttons to stop, start, or unregister that individual service worker.
In other words, as you are working on your PWA, you don't have to update the version number for every app view. But remember, when you are done with all your changes, update the service worker VERSION value before distributing the updated version of your PWA. If you forget, no one who has already installed your app or even visited your online PWA without installing it will ever get to see your changes!
## We're done!
At its core, a PWA is a web application that can be installed and that is progressively enhanced to work offline. We created a fully functional web application. We then added the two features - a manifest file and a service worker - required to convert it to a PWA. If you want to share your app with others, make it available via a secure connection. Alternatively, if you just want to use the cycle tracker yourself, [create a local development environment](/en-US/docs/Web/Progressive_web_apps/Tutorials/CycleTracker/Secure_connection), [install the PWA](/en-US/docs/Web/Progressive_web_apps/Guides/Installing), and enjoy! Once installed, you no longer need to run localhost.
Congratulations!
{{PreviousMenu("Web/Progressive_web_apps/Tutorials/CycleTracker/Manifest_file", "Web/Progressive_web_apps/Tutorials/CycleTracker")}}
| 0 |
data/mdn-content/files/en-us/web/progressive_web_apps/tutorials/cycletracker | data/mdn-content/files/en-us/web/progressive_web_apps/tutorials/cycletracker/secure_connection/index.md | ---
title: "CycleTracker: Secure connection"
short-title: Secure connection
slug: Web/Progressive_web_apps/Tutorials/CycleTracker/Secure_connection
page-type: tutorial-chapter
---
{{PreviousMenuNext("Web/Progressive_web_apps/Tutorials/CycleTracker/HTML_and_CSS", "Web/Progressive_web_apps/Tutorials/CycleTracker/JavaScript_functionality", "Web/Progressive_web_apps/Tutorials/CycleTracker")}}
{{PWASidebar}}
Service workers, and therefore PWAs, are [restricted to secure contexts](/en-US/docs/Web/Security/Secure_Contexts/features_restricted_to_secure_contexts). Secure contexts include TLS contexts served with the `https://` protocol and locally-delivered resources, including `127.0.0.1` and `localhost` URLs served with the `http://` protocol. In this section, we will discuss ways of serving the application locally and remotely with a secure connection.
In the previous section, we used HTML and CSS to create the shell of our period tracking application. In this section, we'll open the CycleTracker static content in a browser, view the content from a locally started development environment, and view the content on a remote, secure server.
## Viewing with the `file://` protocol
Any browser will render your HTML. To view the HTML file with the CSS applied you created in the previous section, open the `index.html` file by navigating to it via your computer's file structure or from your browser using the "Open File" menu option.
With the `index.html` updated, and the `style.css` housed in the same directory, viewing the page in a narrow browser window should look similar to this screenshot:
We are viewing our page using the `file://` protocol. This works for the current state of our codebase, and will continue to suffice as we [add JavaScript functionality](/en-US/docs/Web/Progressive_web_apps/Tutorials/CycleTracker/JavaScript_functionality). However, manifest files and service workers, both PWA requirements, require a secure connection, as do several other APIs. PWAs need to be served from a web server over `https` or a local development environment, using `localhost`, `127.0.0.1`, with or without a port number. If we view our finished app using the `file://` protocol, our [manifest file](/en-US/docs/Web/Progressive_web_apps/Tutorials/CycleTracker/Manifest_file) will be ignored and any [service workers](/en-US/docs/Web/Progressive_web_apps/Tutorials/CycleTracker/Service_workers) we add will fail.
> **Note:** Serving your app over `https` isn't only good for PWAs, but for all websites as it ensures the information that transits between your web server and the user's browser is encrypted end to end. Several [Web APIs require secure contexts](/en-US/docs/Web/Security/Secure_Contexts/features_restricted_to_secure_contexts). Even if you aren't creating installable PWAs, as you add features to any web app, you may run into cases where a secure context is required.
We need a local development environment to work through the tutorial. Part of [making a PWA installable](/en-US/docs/Web/Progressive_web_apps/Guides/Making_PWAs_installable) is a secure server. The files will need to be served over a secure connection on the web to access the benefits PWAs provide and to distribute our application as a PWA.
## localhost
The default method for setting up a local development environment varies by operating system. While the default location for the index and configuration files on your operating system may differ, most desktop operating systems enable a server configuration accessible to you, the developer.
For example, on macOS, at least on Sierra and Monterey, entering `sudo apachectl start` enables an Apache HTTP server. Once the server is started, entering `http://localhost` in the browser displays an basic web page that reads "It works!". By default, the HTML file displayed is `Library/WebServer/Documents/index.html.en`. To enable file extensions other than `.html.en` or to change the root directory away from `Library/WebServer/Documents/`, you have to edit the apache http configuration file, located at `/etc/apache2/httpd.conf`. The server can be stopped with `sudo apachectl stop`.
The OS's default `localhost` has an easy-to-remember URL, but a difficult to remember server root location and configuration process. It also only allows for one local server in one location at a time. Fortunately, there are more intuitive server set up method options to create one or more local development environments on multiple ports.
## localhost with a port number
There are several {{glossary("IDE")}} extensions and programming-language specific packages that enable starting a development environment with a single click or terminal command. You can even start multiple local servers, each with a different port number.
You can run a local HTTP server using a [VSCode plugin](/en-US/docs/Learn/Common_questions/Tools_and_setup/set_up_a_local_testing_server#using_an_extension_in_your_code_editor), which enables running a local server on a single or different port. The [Preview on Web Server extension](https://marketplace.visualstudio.com/items?itemName=yuichinukiyama.vscode-preview-server) for the [VSCode](https://code.visualstudio.com/download) IDE creates a server at the root of the directory currently opened by the editor, with a default port of `8080`. VS Code extensions are configurable. The `previewServer.port` setting is the port number of the web server. The extensions default setting of `8080` can be edited and changed. By default, entering `localhost:8080` in the browser URL bar will load the page.
> **Note:** that the Preview on Web Server extension uses Browsersync. When your development environment is started by this extension, `localhost:3001` provides a user interface for Browsersync, providing an overview of the current server environment.
Learn how to [set up a local testing server](/en-US/docs/Learn/Common_questions/Tools_and_setup/set_up_a_local_testing_server) using [Python](/en-US/docs/Learn/Common_questions/Tools_and_setup/set_up_a_local_testing_server#using_python) or [local server side language](/en-US/docs/Learn/Common_questions/Tools_and_setup/set_up_a_local_testing_server#running_server-side_languages_locally) like PHP.
## Localhost with npx
If you have node installed, you may have npm and npx installed as well. At the command line, enter `npx -v`. If a version number is returned, you can use [http-server](https://www.npmjs.com/package/http-server), a non-configurable static HTTP server, without needing to install any requirements. Enter `npx http-server [path]` at the command line, where `[path]` is the folder where your index file is stored.
By default, entering `localhost:8080` in the browser URL bar will load the page. If you already started a server at port `8080`, it will automatically change the port number, starting the developer environment using an available port, such at `8081`.
You can choose a different port number. Entering `npx http-server /user/yourName/CycleTracker -p 8787` will start local server at port `8787` if available. If not, if you enter a port number that is already being used, you will get an `address already in use` or similar error. If successful, entering `localhost:8787` in the browser URL bar will render the index file stored as `~/user/yourName/CycleTracker/index.html`, or will display the directory contents of `~/user/yourName/CycleTracker/` if no index file is present.
This non-configurable static HTTP server suffices for our basic app. Apps served via `localhost` and `127.0.0.1` are exempt from https and always considered secure. Browser insecure warnings, if given, can be bypassed. While not necessary, to configurable your local web server to be served over HTTPS, you can [add a built-in TLS certificate](https://github.com/lwsjs/local-web-server/wiki/How-to-get-the-%22green-padlock%22-using-the-built-in-certificate). With the certificate, you will be able to install and run [local-web-server](<https://github.com/lwsjs/local-web-server/wiki/How-to-launch-a-secure-local-web-server-(HTTPS)>) from the command line to serve your project locally over `https`, preventing any security warning.
```bash
npm install -g local-web-server
cd ~/user/yourName/CycleTracker/
ws --https
```
In the above, you may need to prefix the install with `sudo`.
> **Note:** If you are seeking privacy, realize you are building this PWA yourself and it can be installed on your own machine from your own development environment, without ever accessing the Internet. This app has no tracking. It's as private an app as you get.
## Secure external server
The previous options are fine, and necessary, for testing your application as you progress through this PWA tutorial, or any web development project. While you can host your web app on your device and make it available to anyone with an Internet connection, this is not recommended.
To get the added features of PWAs, including single click installation, a standalone UI, and admission to app stores, it needs to be a PWA, which means it needs a service worker, which means we will need a secure connection. To distribute your app, enabling others to view, use, and install your PWA, you'll want to have your content hosted and available on a secure _remote_ server.
When officially publishing a PWA, you will likely want to invest in a [domain name and web hosting](/en-US/docs/Learn/Common_questions/Tools_and_setup/How_much_does_it_cost#hosting). For open source projects, where developers can learn from the codebase and even contribute back to the project, you can host your progress on [GitHub Pages](https://pages.github.com/).
## GitHub Pages
The current state of the CycleTracker application is viewable on GitHub, served securely at [https://mdn.github.io/pwa-examples/cycletracker/html_and_css](https://mdn.github.io/pwa-examples/cycletracker/html_and_css). We've posted the files to the MDN GitHub account. Similarly, if you have a [GitHub](https://github.com) account, you can post it to yours. Just note that while securely served over TLS, actions on GitHub are not necessarily private, and all GitHub pages are public. If you live in an area with a repressive government that tracks menstrual cycles, consider copying and pasting the code rather than forking it.
To create a publicly available secure site, create a [GitHub Pages site](https://docs.github.com/en/pages/getting-started-with-github-pages/creating-a-github-pages-site). Create a repository named `<username>.github.io`, where `<username>` is your GitHub username. Create a `gh-pages` branch. This branch of your application will be available at `https://<username>.github.io`.
As noted, all GitHub Pages are publicly available on the internet, even if you set the repository to private. As the period data is saved using localStorage, the application will be available via the GitHub URL, but the user's data is only available in the one browser on the one device where the data was entered. Deleting the localStorage directly, which is done in the browser, will delete all the stored data.
If you don't want your PWA to be top level, you can make your app appear as if it is residing in a subdirectory. You can either create a subdirectory within the `<username>.github.io` repository, or publish from your PWA's separate repository. By [configuring a publishing source](https://docs.github.com/en/pages/getting-started-with-github-pages/configuring-a-publishing-source-for-your-github-pages-site) within your PWA repository, your app will be visible at `https://<username>.github.io/<repository>` where `<repository>` is the repository's name. You can set GitHub to auto-publish your site when changes are [published to a specific branch](https://docs.github.com/en/pages/getting-started-with-github-pages/configuring-a-publishing-source-for-your-github-pages-site#publishing-from-a-branch) within that repository, including `main`.
In the case of the CycleTracker demo app in the various stages of development, the `<username>` is `mdn` and the repository is `pwa-examples`. Because this repository has multiple example PWAs, each with progress at several steps in the development process, the files, and therefore the PWA, are nested a few levels deep.
Note that you can [configure a custom domain for a GitHub Pages site](https://docs.github.com/en/pages/configuring-a-custom-domain-for-your-github-pages-site).
## Up next
We are able to view a styled, static version of the CycleTracker application shell. Now that we know how to view the application we are about to build, let's get to building it. Up next, we create `app.js`, the JavaScript that converts our static design into a fully functional web application that stores data locally, on the users machine.
{{PreviousMenuNext("Web/Progressive_web_apps/Tutorials/CycleTracker/HTML_and_CSS", "Web/Progressive_web_apps/Tutorials/CycleTracker/JavaScript_functionality", "Web/Progressive_web_apps/Tutorials/CycleTracker")}}
| 0 |
data/mdn-content/files/en-us/web/progressive_web_apps | data/mdn-content/files/en-us/web/progressive_web_apps/guides/index.md | ---
title: Guides
slug: Web/Progressive_web_apps/Guides
page-type: landing-page
---
{{PWASidebar}}
This page lists guides to PWA technology. Guides give conceptual explanations of different aspects of PWAs. They're intended to help you understand what kinds of things are possible with PWAs, and to provide enough pointers to help you understand how to achieve them.
{{ListSubpages}}
| 0 |
data/mdn-content/files/en-us/web/progressive_web_apps/guides | data/mdn-content/files/en-us/web/progressive_web_apps/guides/best_practices/index.md | ---
title: Best practices for PWAs
slug: Web/Progressive_web_apps/Guides/Best_practices
page-type: guide
---
{{PWASidebar}}
[Progressive Web Apps](/en-US/docs/Web/Progressive_web_apps) (PWAs) can be installed on devices and used as traditional websites in web browsers. This means that PWAs need to be able to adapt to different environments and to different user expectations.
This article provides a list of best practices to help you make sure your PWA is as good as it can be.
## Adapt to all browsers
Your PWA is based on Web technologies. This means that, on top of being installable on devices, PWAs can run in web browsers too. To ensure compatibility, it's essential to [test your app](/en-US/docs/Learn/Tools_and_testing/Cross_browser_testing) across various browsers and operating systems.
Consider the diverse range of browsers your users may use and cater to a wide spectrum of potential users. Using [feature detection](/en-US/docs/Learn/Tools_and_testing/Cross_browser_testing/Feature_detection) allows you to deliver a usable experience to the broadest audience.
Feature detection also helps with {{Glossary("Progressive Enhancement")}}, a design philosophy that makes it possible to deliver a great experience to as many users as possible.
With Progressive Enhancement, you focus on making the core functionalities of your app work universally first by using the simplest technology, then enhancing the experience for supporting devices.
For example, handling form submissions with the HTML {{htmlelement("form")}} element means that the form will work on all browsers, including those that don't support JavaScript. You can then progressively enhance the form by adding client-side validation and JavaScript-based submission handling for a better experience on compatible devices.
## Adapt to all devices
Similar to how testing your app across various browsers is important, testing across devices ensures your app is accessible to the broadest audience.
[Responsive design](/en-US/docs/Learn/CSS/CSS_layout/Responsive_Design) is crucial for PWAs to ensure the content is accessible on any screen size. Users should be able to access all features and content regardless of their device's screen size. By rearranging content at different viewport sizes, you can prioritize important data and actions.
Ensure users can interact with your application no matter how they access your content. Support keyboard and mouse, as well as touch or stylus input methods. Make sure all your application features can be accessed through any input method.
Finally, use [semantic HTML elements](/en-US/docs/Glossary/Semantics#semantics_in_html) rather than recreating your own buttons or form elements as semantic HTML elements support all user input methods right out of the box.
## Provide an offline experience
Users of installed apps expect them to always work; even when connected to a slow or unreliable network or when their device is completely offline.
### Custom offline page
At the very least, your PWA should provide a custom offline page that informs the user that they are offline instead of showing the generic browser error page. A custom offline page provides a more consistent experience across browsers and devices and keeps the user engaged with your app.
You can provide a custom offline page by using a [service worker](/en-US/docs/Web/API/Service_Worker_API) to intercept network requests and respond with the custom offline page when the user is offline.
### Offline operation
To go further and provide an app-like experience, your PWA should function when the user is offline. This means that the user can continue using some, and preferably all, of your app's functionality even when they are offline.
Consider the following scenario: the user composes a long email and presses "Send", not realizing they have lost network connectivity. Because your app works offline, the email will be saved locally and sent automatically when the device is back online.
Learn more about [offline and background operations](/en-US/docs/Web/Progressive_web_apps/Guides/Offline_and_background_operation).
## Support deep links
Deep links are hyperlinks that point to specific pages within your app's domain. For example, your app's home page might be available at `https://example.com/`, but you can also link to a specific product page at `https://example.com/products/123`.
The ability to refer to any resource by a unique URL is one of the most powerful features of the web. Because they're built on web technologies, PWAs can, and should, take advantage of this feature.
Making different sections of your app available via unique URLs allows users to bookmark, navigate directly to, and share specific content within your app. It also allows search engines to index your app's content and make it discoverable through web searches.
## Make it fast
Users have different expectations for installed apps than they do for websites. Users anticipate websites to need time for loading and navigation, particularly on poor network connections. However, they expect installed apps to be always fast and responsive.
The speed at which your app loads and performs its core functions plays a key role in user engagement and retention. The longer it takes for your app to respond, the more users will abandon it.
There are tools, APIs, and best practices that help measure and improve performance. To learn more, see [web performance](/en-US/docs/Web/Performance).
## Make it accessible
Accessibility is crucial to ensure everyone can use your app, regardless of an individual's abilities or the device they use to access your app. Accessibility ensures that as many people can use your app as possible. Accessibility is also required by law. Furthermore, accessibility often leads to better user experience for everyone, not just those with permanent or temporary disabilities.
Learn how to make your app accessible in [accessibility](/en-US/docs/Web/Accessibility).
## Provide an app-like experience
### Integrate with the operating system
Users expect installed PWAs to behave like any installed platform-specific app. To provide the app-like experience that users expect, integrate your app with the operating system in some way. For example:
- Use the [Notifications API](/en-US/docs/Web/API/Notifications_API) to send notifications to the user's device.
- Handle files with the [`file_handlers`](/en-US/docs/Web/Manifest/file_handlers) web app manifest member.
- [Display badges](/en-US/docs/Web/Progressive_web_apps/How_to/Display_badge_on_app_icon) on the app icon.
- Enable [data sharing between apps](/en-US/docs/Web/Progressive_web_apps/How_to/Share_data_between_apps).
Many of the [web app manifest members](/en-US/docs/Web/Manifest#members) can be used to customize the way your app is displayed on the user's device and integrate more deeply within the operating system.
### App look and feel
Users install apps to get a more focused experience than what they get from websites and achieve tasks more efficiently. They expect apps to be more streamlined, with less clutter, and to focus on the most important tasks.
Make sure your PWA provides an app-like experience by considering the following guidelines:
- Use a [standalone display mode](/en-US/docs/Web/Progressive_web_apps/How_to/Create_a_standalone_app) to give your app its own dedicated window.
- [Define your app icon](/en-US/docs/Web/Progressive_web_apps/How_to/Define_app_icons).
- Detect the user's preferred theme with the {{cssxref("@media/prefers-color-scheme", "prefers-color-scheme")}} media feature and adapt your app's theme accordingly.
- [Customize your app's theme and background colors](/en-US/docs/Web/Progressive_web_apps/How_to/Customize_your_app_colors) to provide a more polished experience that feels more like a platform-specific app.
- De-clutter the content and focus on the most important tasks that your app lets users achieve. This may mean removing big headers and footers that are traditionally found on websites and replacing them with a menu metaphor instead.
- Use the `system-ui` {{cssxref("font-family")}} to make your content feel more platform-native and load faster without requiring users to download a custom font.
## See also
- [What makes a good Progressive Web App](https://web.dev/articles/pwa-checklist) on web.dev (2022).
- [Best practices for PWAs](https://learn.microsoft.com/microsoft-edge/progressive-web-apps-chromium/how-to/best-practices) on learn.microsoft.com (2023).
| 0 |
data/mdn-content/files/en-us/web/progressive_web_apps/guides | data/mdn-content/files/en-us/web/progressive_web_apps/guides/offline_and_background_operation/index.md | ---
title: Offline and background operation
slug: Web/Progressive_web_apps/Guides/Offline_and_background_operation
page-type: guide
---
{{PWASidebar}}
Usually, websites are very dependent on both reliable network connectivity and on the user having their pages open in a browser. Without network connectivity, most websites are just unusable, and if the user does not have the site open in a browser tab, most websites are unable to do anything.
However, consider the following scenarios:
- A music app enables the user to stream music while online, but can download tracks in the background and then continue to play while the user is offline.
- The user composes a long email, presses "Send", and then loses network connectivity. The device sends the email in the background, as soon as the network is available again.
- The user's chat app receives a message from one of their contacts, and although the app is not open, it displays a badge on the app icon to let the user know they have a new message.
These are the kinds of features that users expect from installed apps. In this guide, we'll introduce a set of technologies that enable a PWA to:
- Provide a good user experience even when the device has intermittent network connectivity
- Update its state when the app is not running
- Notify the user about important events that have happened while the app was not running
The technologies introduced in this guide are:
- [Service Worker API](/en-US/docs/Web/API/Service_Worker_API)
- [Background Synchronization API](/en-US/docs/Web/API/Background_Synchronization_API)
- [Background Fetch API](/en-US/docs/Web/API/Background_Fetch_API)
- [Periodic Background Synchronization API](/en-US/docs/Web/API/Web_Periodic_Background_Synchronization_API)
- [Push API](/en-US/docs/Web/API/Push_API)
- [Notifications API](/en-US/docs/Web/API/Notifications_API)
## Websites and workers
The foundation of all the technologies we'll discuss in this guide is the _service worker_. In this section we'll provide a little background about workers and how they change the architecture of a web app.
Normally, an entire website runs in a single thread. This includes the website's own JavaScript, and all the work to render the website's UI. One consequence of this is that if your JavaScript runs some long-running operation, the website's main UI is blocked, and the website appears unresponsive to the user.
A [service worker](/en-US/docs/Web/API/Service_Worker_API) is a specific type of [web worker](/en-US/docs/Web/API/Web_Workers_API) that's used to implement PWAs. Like all web workers, a service worker runs in a separate thread to the main JavaScript code. The main code creates the worker, passing in a URL to the worker's script. The worker and the main code can't directly access each other's state, but can communicate by sending each other messages. Workers can be used to run computationally expensive tasks in the background: because they run in a separate thread, the main JavaScript code in the app, that implements the app's UI, can stay responsive to the user.
So a PWA always has a high level architecture split between:
- The _main app_, with the HTML, CSS, and the part of the JavaScript that implements the app's UI (by handling user events, for example)
- The _service worker_, which handles offline and background tasks
In this guide, when we show code samples, we'll indicate which part of the app the code belongs in with a comment like `// main.js` or `// service-worker.js`.
## Offline operation
Offline operation allows a PWA to provide a good user experience even when the device does not have network connectivity. This is enabled by adding a service worker to an app.
A service worker _controls_ some or all of the app's pages. When the service worker is installed, it can fetch the resources from the server for the pages it controls (including pages, styles, scripts, and images, for example) and add them to a local cache. The {{domxref("Cache")}} interface is used to add resources to the cache. `Cache` instances are accessible through the {{domxref("caches")}} property in the service worker global scope.
Then whenever the app requests a resource (for example, because the user opened the app or clicked an internal link), the browser fires an event called {{domxref("ServiceWorkerGlobalScope.fetch_event", "fetch")}} in the service worker's global scope. By listening for this event, the service worker can intercept the request.
The event handler for the `fetch` event is passed a {{domxref("FetchEvent")}} object, which:
- Provides access to the request as a {{domxref("Request")}} instance
- Provides a {{domxref("FetchEvent.respondWith", "respondWith()")}} method to send a response to the request.
One way a service worker can handle requests is a "cache-first" strategy. In this strategy:
1. If the requested resource exists in the cache, get the resource from the cache and return the resource to the app.
2. If the requested resource does not exist in the cache, try to fetch the resource from the network.
1. If the resource could be fetched, add the resource to the cache for next time, and return the resource to the app.
2. If the resource could not be fetched, return some default fallback resource.
The following code sample shows an implementation of this:
```js
// service-worker.js
const putInCache = async (request, response) => {
const cache = await caches.open("v1");
await cache.put(request, response);
};
const cacheFirst = async ({ request, fallbackUrl }) => {
// First try to get the resource from the cache.
const responseFromCache = await caches.match(request);
if (responseFromCache) {
return responseFromCache;
}
// If the response was not found in the cache,
// try to get the resource from the network.
try {
const responseFromNetwork = await fetch(request);
// If the network request succeeded, clone the response:
// - put one copy in the cache, for the next time
// - return the original to the app
// Cloning is needed because a response can only be consumed once.
putInCache(request, responseFromNetwork.clone());
return responseFromNetwork;
} catch (error) {
// If the network request failed,
// get the fallback response from the cache.
const fallbackResponse = await caches.match(fallbackUrl);
if (fallbackResponse) {
return fallbackResponse;
}
// When even the fallback response is not available,
// there is nothing we can do, but we must always
// return a Response object.
return new Response("Network error happened", {
status: 408,
headers: { "Content-Type": "text/plain" },
});
}
};
self.addEventListener("fetch", (event) => {
event.respondWith(
cacheFirst({
request: event.request,
fallbackUrl: "/fallback.html",
}),
);
});
```
This means that in many situations, the web app will function well even if network connectivity is intermittent. From the point of view of the main app code, it is completely transparent: the app just makes network requests and gets responses. Also, because the service worker is in a separate thread, the main app code can stay responsive to user input while resources are fetched and cached.
> **Note:** The strategy described here is just one way a service worker could implement caching. Specifically, in a cache first strategy, we check the cache first before the network, meaning that we are more likely to return a quick response without incurring a network cost, but are more likely to return a stale response.
>
> An alternative would be a _network first_ strategy, in which we try to fetch the resource from the server first, and fall back to the cache if the device is offline.
>
> The optimal caching strategy is dependent on the particular web app and how it is used.
For much more detail about setting up service workers and using them to add offline functionality, see our [guide to using service workers](/en-US/docs/Web/API/Service_Worker_API/Using_Service_Workers).
## Background operation
While offline operations are the most common use for service workers, they also enable a PWA to operate even while the main app is closed. This is possible because the service worker can run while the main app is not running.
This doesn't mean service workers run all the time: browsers may stop service workers when they think it is appropriate. For example, if a service worker has been inactive for a while, it will be stopped. However, the browser will restart the service worker when an event has happened that it needs to take care of. This enables a PWA to implement background operations in the following way:
- In the main app, register a request for the service worker to perform some operation
- At the appropriate time, the service worker will be restarted if necessary, and an event will fire in the service worker's scope
- The service worker will perform the operation
In the next sections, we'll discuss a few different features that use this pattern to enable a PWA to work while the main app isn't open.
## Background sync
Suppose a user composes an email and presses "Send". In a traditional website, they must keep the tab open until the app has sent the email: if they close the tab, or the device loses connectivity, then the message will not be sent. Background sync, defined in the [Background Synchronization API](/en-US/docs/Web/API/Background_Synchronization_API), is the solution to this problem for PWAs.
Background sync enables the app to ask its service worker to perform a task on its behalf. As soon as the device has network connectivity, the browser will restart the service worker, if necessary, and fire an event named [`sync`](/en-US/docs/Web/API/ServiceWorkerGlobalScope/sync_event) in the service worker's scope. The service worker can then attempt to execute the task. If the task can't be completed, then the browser may retry a limited number of times by firing the event again.
### Registering a sync event
To ask the service worker to perform a task, the main app can access {{domxref("ServiceWorkerContainer/ready", "navigator.serviceWorker.ready")}}, which resolves with a {{domxref("ServiceWorkerRegistration")}} object. The app then calls {{domxref("SyncManager/register", "sync.register()")}} on the `ServiceWorkerRegistration` object, like this:
```js
// main.js
async function registerSync() {
const swRegistration = await navigator.serviceWorker.ready;
swRegistration.sync.register("send-message");
}
```
Note that the app passes a name for the task: `"send-message"` in this case.
### Handling a sync event
As soon as the device has network connectivity, the `sync` event fires in the service worker scope. The service worker checks the name of the task and runs the appropriate function, `sendMessage()` in this case:
```js
// service-worker.js
self.addEventListener("sync", (event) => {
if (event.tag == "send-message") {
event.waitUntil(sendMessage());
}
});
```
Note that we pass the result of the `sendMessage()` function into the event's {{domxref("ExtendableEvent/waitUntil", "waitUntil()")}} method. The `waitUntil()` method takes a {{jsxref("Promise")}} as a parameter and asks the browser not to stop the service worker until the promise has settled. This is also how the browser knows whether the operation succeeded or not: if the promise rejects, then the browser may retry by firing the `sync` event again.
The `waitUntil()` method is not a guarantee that the browser will not stop the service worker: if the operation takes too long, the service worker will be stopped anyway. If this happens, then the operation is aborted, and next time a `sync` event is fired, then the handler runs again from the start - it does not resume from where it left off.
How long is "too long" is browser-specific. For Chrome, the service worker is likely to be closed if:
- It has been idle for 30 seconds
- It has been running synchronous JavaScript for 30 seconds
- The promise passed to `waitUntil()` has taken more than 5 minutes to settle
## Background fetch
Background sync is useful for relatively short background operations, but as we just saw: if a service worker doesn't finish handling a sync event in a relatively short time, the browser will stop the service worker. This is an intentional measure to conserve battery life and protect the user's privacy by minimizing the time for which the user's IP address is exposed to the server while the app is in the background.
This makes background sync unsuitable for longer operations - downloading a movie, for example. For this scenario, you need the [Background Fetch API](/en-US/docs/Web/API/Background_Fetch_API). With background fetch, network requests can be performed while both the main app UI and the service worker are closed.
With background fetch:
- The request is initiated from the main app UI
- Whether or not the main app is open, the browser displays a persistent UI element that notifies the user about the ongoing request, and enables them to cancel it or check its progress
- When the request is completed with success or failure, or the user has asked to check the request's progress, then the browser starts the service worker (if necessary) and fires the appropriate event in the service worker's scope.
### Making a background fetch request
A background fetch request is initiated in the main app code, by calling {{domxref("BackgroundFetchManager/fetch", "backgroundFetch.fetch()")}} on the `ServiceWorkerRegistration` object, like this:
```js
// main.js
async function requestBackgroundFetch(movieData) {
const swRegistration = await navigator.serviceWorker.ready;
const fetchRegistration = await swRegistration.backgroundFetch.fetch(
"download-movie",
["/my-movie-part-1.webm", "/my-movie-part-2.webm"],
{
icons: movieIcons,
title: "Downloading my movie",
downloadTotal: 60 * 1024 * 1024,
},
);
//...
}
```
We're passing three arguments into `backgroundFetch.fetch()`:
1. An identifier for this fetch request
2. An array of {{domxref("Request")}} objects or URLs. A single background fetch request can include multiple network requests.
3. An object containing data for the UI that the browser uses to show the existence and progress of the request.
The `backgroundFetch.fetch()` call returns a {{jsxref("Promise")}} that resolves to a {{domxref("BackgroundFetchRegistration")}} object. This enables the main app to update its own UI as the request progresses. However, if the main app is closed, the fetch will continue in the background.
The browser will display a persistent UI element reminding the user that the request is ongoing, giving them the chance to find out more about the request and cancel it if they wish. The UI will include an icon and title taken from the `icons` and `title` arguments, and uses `downloadTotal` as an estimate of the total download size, to show the request's progress.
### Handling request outcomes
When the fetch has finished with success or failure, or the user has clicked the progress UI, then the browser starts the app's service worker, if necessary, and fires an event in the service worker's scope. The following events can be fired:
- `backgroundfetchsuccess`: all requests were successful
- `backgroundfetchfail`: at least one request failed
- `backgroundfetchabort`: the fetch was canceled by the user or by the main app
- `backgroundfetchclick`: the user clicked on the progress UI element that the browser is showing
#### Retrieving response data
In the handlers for the `backgroundfetchsuccess`, `backgroundfetchfail`, and `backgroundfetchabort` events, the service worker can retrieve the request and response data.
To get the response, the event handler accesses the event's {{domxref("BackgroundFetchEvent/registration", "registration")}} property. This is a {{domxref("BackgroundFetchRegistration")}} object, which has {{domxref("BackgroundFetchRegistration/matchAll", "matchAll()")}} and {{domxref("BackgroundFetchRegistration/match", "match()")}} methods that return {{domxref("BackgroundFetchRecord")}} objects matching the given URL (or, in the case of `matchAll()` all records if no URL is given).
Each `BackgroundFetchRecord` has a {{domxref("BackgroundFetchRecord/responseReady", "responseReady")}} property that is a `Promise` which resolves with the {{domxref("Response")}}, once the response is available.
So to access response data, the handler could do something like:
```js
// service-worker.js
self.addEventListener("backgroundfetchsuccess", (event) => {
const registration = event.registration;
event.waitUntil(async () => {
const registration = event.registration;
const records = await registration.matchAll();
const responsePromises = records.map(
async (record) => await record.responseReady,
);
const responses = Promise.all(responsePromises);
// do something with the responses
});
});
```
Since the response data won't be available after the handler exits, the handler should store the data (for example, in the {{domxref("Cache")}}) if the app still wants it.
#### Updating the browser's UI
The event object passed into `backgroundfetchsuccess` and `backgroundfetchfail` also has an {{domxref("BackgroundFetchUpdateUIEvent/updateUI", "updateUI()")}} method, which can be used to update the UI that the browser shows to keep the user informed about the fetch operation. With `updateUI()`, the handler can update the UI element's title and icon:
```js
// service-worker.js
self.addEventListener("backgroundfetchsuccess", (event) => {
// retrieve and store response data
// ...
event.updateUI({ title: "Finished your download!" });
});
self.addEventListener("backgroundfetchfail", (event) => {
event.updateUI({ title: "Could not complete download" });
});
```
#### Responding to user interaction
The `backgroundfetchclick` event is fired when the user has clicked on the UI element that the browser shows while the fetch is ongoing.
The expected response here is to open a window giving the user more information about the fetch operation, which can be done from the service worker using {{domxref("Clients/openWindow", "clients.openWindow()")}}. For example:
```js
// service-worker.js
self.addEventListener("backgroundfetchclick", (event) => {
const registration = event.registration;
if (registration.result === "success") {
clients.openWindow("/play-movie");
} else {
clients.openWindow("/movie-download-progress");
}
});
```
## Periodic background sync
The [Periodic Background Synchronization API](/en-US/docs/Web/API/Web_Periodic_Background_Synchronization_API) enables a PWA to periodically update its data in the background, while the main app is closed.
This can greatly improve the offline experience offered by a PWA. Consider an app that depends on reasonably fresh content, like a news app. If the device is offline when the user opens the app, then even with service worker-based caching the stories will only be as fresh as the last time the app was opened. With periodic background sync, the app could have refreshed its stories in the background, when the device had connectivity, and so could be able to show relatively fresh content to the user.
This takes advantage of the fact that on a mobile device especially, connectivity is not poor so much as _intermittent_: by taking advantage of the times that the device has connectivity, the app can smooth over the connectivity gaps.
### Registering a periodic sync event
The code for registering a periodic sync event follows the same pattern as that for [registering a sync event](#registering_a_sync_event). The {{domxref("ServiceWorkerRegistration")}} has a {{domxref("ServiceWorkerRegistration.periodicSync", "periodicSync")}} property, which has a {{domxref("PeriodicSyncManager/register", "register()")}} method taking the name of the periodic sync as a parameter.
However, `periodicSync.register()` takes an extra argument, which is an object with a `minInterval` property. This represents the minimum interval, in milliseconds, between synchronization attempts:
```js
// main.js
async function registerPeriodicSync() {
const swRegistration = await navigator.serviceWorker.ready;
swRegistration.periodicSync.register("update-news", {
// try to update every 24 hours
minInterval: 24 * 60 * 60 * 1000,
});
}
```
### Handling a periodic sync event
Although the PWA asks for a particular interval in the `register()` call, it's up to the browser how often to generate periodic sync events. Apps that users open and interact with often will be more likely to receive periodic sync events, and will receive them more often, than apps which the user rarely or never interacts with.
When the browser has decided to generate a periodic sync event, the pattern is the following: it starts the service worker, if necessary, and fires a {{domxref("ServiceWorkerGlobalScope.periodicsync_event", "periodicSync")}} event in the service worker's global scope.
The service worker's event handler checks the name of the event, and calls the appropriate function inside the event's {{domxref("ExtendableEvent/waitUntil", "waitUntil()")}} method:
```js
// service-worker.js
self.addEventListener("periodicsync", (event) => {
if (event.tag === "update-news") {
event.waitUntil(updateNews());
}
});
```
Inside `updateNews()`, the service worker can fetch and cache the latest stories. The `updateNews()` function should complete relatively quickly: if the service worker takes too long updating its content, the browser will stop it.
### Unregistering a periodic sync
When the PWA no longer needs periodic background updates, (for example, because the user has switched them off in the app's settings) then the PWA should ask the browser to stop generating periodic sync events, by calling the {{domxref("PeriodicSyncManager/unregister", "unregister()")}} method of {{domxref("serviceWorkerRegistration.periodicSync", "periodicSync")}}:
```js
// main.js
async function registerPeriodicSync() {
const swRegistration = await navigator.serviceWorker.ready;
swRegistration.periodicSync.unregister("update-news");
}
```
## Push
The [Push API](/en-US/docs/Web/API/Push_API) enables a PWA to receive messages pushed from the server, whether the app is running or not. When the message is received by the device, the app's service worker is started and handles the message, and a [notification](/en-US/docs/Web/API/Notifications_API) is shown to the user. The specification allows for "silent push" in which no notification is shown, but no browsers support this, because of privacy concerns (for example, that push could then be used to track a user's location).
Displaying a notification to the user distracts them from whatever they were doing and has the potential to be very annoying, so use push messages with care. In general, they are suitable for situations in which you need to alert the user about something, and can't wait until the next time they open your app.
A common use case for push notifications is chat apps: when the user receives a message from one of their contacts, it is delivered as a push message and the app shows a notification.
Push messages are not sent directly from the app server to the device. Instead, your app server sends messages to a push service, from which the device can retrieve them and deliver them to the app.
This also means that messages from your server to the push service need to be {{Glossary("Encryption", "encrypted")}} (so the push service can't read them) and {{Glossary("Signature/Security", "signed")}} (so the push service knows that the messages are really from your server, and not from someone impersonating your server).
The push service is operated by the browser vendor or by a third party, and the app server communicates with it using the [HTTP Push](https://datatracker.ietf.org/doc/html/rfc8030) protocol. The app server can use a third-party library such as [web-push](https://github.com/web-push-libs/web-push) to take care of the protocol details.
### Subscribing to push messages
The pattern for subscribing to push messages looks like this:
1. As a prerequisite, the app server needs to be provisioned with a {{Glossary("Public-key_cryptography", "public/private key pair")}}, so it can sign push messages. Signing messages needs to follow the [VAPID](https://datatracker.ietf.org/doc/html/draft-thomson-webpush-vapid-02) specification.
2. On the device, the app uses the {{domxref("PushManager.subscribe()")}} method to subscribe to messages from the server. The `subscribe()` method:
- Takes the app server's public key as an argument: this is what the push service will use to verify the signature on messages from the app server.
- Returns a `Promise` that resolves to a {{domxref("PushSubscription")}} object. This object includes:
- The [endpoint](/en-US/docs/Web/API/PushSubscription/endpoint) for the push service: this is how the app server knows where to send push messages.
- The [public encryption key](/en-US/docs/Web/API/PushSubscription/getKey) that your server will use to encrypt messages to the push service.
3. The app sends the endpoint and public encryption key to your server (for example, using {{domxref("fetch()")}}).
After this, the app server is able to start sending push messages.
### Sending, delivering, and handling push messages
When an event happens on the server that the server wants the app to handle, the server can send messages, and the sequence of steps is like this:
1. The app server signs the message using its private signing key and encrypts the message using the public encryption key for the push service. The app server can use a library such as [web-push](https://github.com/web-push-libs/web-push) to simplify this.
2. The app server sends the message to the endpoint for the push service, using the [HTTP Push](https://datatracker.ietf.org/doc/html/rfc8030) protocol, and again optionally using a library, like web-push.
3. The push service checks the signature on the message, and if the signature is valid, the push service queues the message for delivery.
4. When the device has network connectivity, the push service delivers the encrypted message to the browser.
5. When the browser receives the encrypted message, it decrypts the message.
6. The browser starts the service worker if necessary, and fires an event called {{domxref("ServiceWorkerGlobalScope.push_event", "push")}} in the service worker's global scope. The event handler is passed a {{domxref("PushEvent")}} object, which contains the message data.
7. In its event handler, the service worker does any processing of the message. As usual, the event handler calls `event.waitUntil()` to ask the browser to keep the service worker running.
8. In its event handler, the service worker creates a notification using {{domxref("ServiceWorkerRegistration/showNotification", "registration.showNotification()")}}.
9. If the user clicks the notification or closes it, the {{domxref("ServiceWorkerGlobalScope.notificationclick_event", "notificationclick")}} and {{domxref("ServiceWorkerGlobalScope.notificationclose_event", "notificationclose")}}, respectively, are fired in the service worker's global scope. These enable the app to handle the user's response to the notification.
## Permissions and restrictions
Browsers have to find a balance in which they can provide powerful APIs to web developers while protecting users from malicious, exploitative, or poorly-written websites. One of the main protections they offer is that users can close the website's pages, and it's then not active on their device any more. The APIs described in this article tend to violate that assurance, so browsers have to take extra steps to help ensure that users are aware of this, and that the APIs are used in ways that align with the interests of users.
In this section we'll outline these steps. Several of these APIs require explicit [user permission](/en-US/docs/Web/API/Permissions_API), and various other restrictions and design choices to help protect users.
- The Background Sync API does not need an explicit user permission, but issuing a background sync request may only be made while the main app is open, and browsers limit the number of retries and the length of time background sync operations can take.
- The Background Fetch API requires the `"background-fetch"` user permission, and the browser displays the ongoing progress of the fetch operation, enabling the user to cancel it.
- The Periodic Background Sync API requires the `"periodic-background-sync"` user permission, and browsers should allow users to disable periodic background sync completely. Also, browsers may tie the frequency of sync events to the extent to which the user chooses to interact with the app: so an app that the user rarely uses may receive few events (or even no events at all).
- The Push API requires the `"push"` user permission, and all browsers require push events to be user visible, meaning that they generate a user-visible notification.
## See also
### Reference
- [Service Worker API](/en-US/docs/Web/API/Service_Worker_API)
- [Background Synchronization API](/en-US/docs/Web/API/Background_Synchronization_API)
- [Background Fetch API](/en-US/docs/Web/API/Background_Fetch_API)
- [Periodic Background Synchronization API](/en-US/docs/Web/API/Web_Periodic_Background_Synchronization_API)
- [Push API](/en-US/docs/Web/API/Push_API)
- [Notifications API](/en-US/docs/Web/API/Notifications_API)
### Guides
- [Introducing Background Sync](https://developer.chrome.com/blog/background-sync/) on developer.chrome.com (2017)
- [Introducing Background Fetch](https://developer.chrome.com/blog/background-fetch/) on developer.chrome.com (2022)
- [The Periodic Background Sync API](https://developer.chrome.com/docs/capabilities/periodic-background-sync) on developer.chrome.com (2020)
- [Notifications](https://web.dev/explore/notifications) on web.dev
- [PWA with offline streaming](https://web.dev/articles/pwa-with-offline-streaming) on web.dev (2021)
| 0 |
data/mdn-content/files/en-us/web/progressive_web_apps/guides | data/mdn-content/files/en-us/web/progressive_web_apps/guides/offline_and_background_operation/push-messaging-2.svg | <svg xmlns="http://www.w3.org/2000/svg" style="background-color:#fff" xmlns:xlink="http://www.w3.org/1999/xlink" width="700" height="600" viewBox="-0.5 -0.5 700 600"><path fill="#FFF" stroke="#000" pointer-events="all" d="M395 50h90v40h-90z"/><switch transform="translate(-.5 -.5)"><foreignObject style="overflow:visible;text-align:left" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display:flex;align-items:unsafe center;justify-content:unsafe center;width:88px;height:1px;padding-top:70px;margin-left:396px"><div style="box-sizing:border-box;font-size:0;text-align:center" data-drawio-colors="color: rgb(0 0 0);"><div style="display:inline-block;font-size:14px;font-family:Helvetica;color:#000;line-height:1.2;pointer-events:all;white-space:normal;overflow-wrap:normal">App server</div></div></div></foreignObject><text x="440" y="74" font-family="Helvetica" font-size="14" text-anchor="middle">App server</text></switch><path fill="#FFF" stroke="#000" pointer-events="all" d="M40 180h90v40H40z"/><switch transform="translate(-.5 -.5)"><foreignObject style="overflow:visible;text-align:left" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display:flex;align-items:unsafe center;justify-content:unsafe center;width:88px;height:1px;padding-top:200px;margin-left:41px"><div style="box-sizing:border-box;font-size:0;text-align:center" data-drawio-colors="color: rgb(0 0 0);"><div style="display:inline-block;font-size:14px;font-family:Helvetica;color:#000;line-height:1.2;pointer-events:all;white-space:normal;overflow-wrap:normal">Push service</div></div></div></foreignObject><text x="85" y="204" font-family="Helvetica" font-size="14" text-anchor="middle">Push service</text></switch><path fill="#FFF" stroke="#000" pointer-events="all" d="M220 160h450v360H220z"/><path fill="#FFF" stroke="#000" pointer-events="all" d="M380 220h120v40H380z"/><switch transform="translate(-.5 -.5)"><foreignObject style="overflow:visible;text-align:left" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display:flex;align-items:unsafe center;justify-content:unsafe center;width:118px;height:1px;padding-top:240px;margin-left:381px"><div style="box-sizing:border-box;font-size:0;text-align:center" data-drawio-colors="color: rgb(0 0 0);"><div style="display:inline-block;font-size:14px;font-family:Helvetica;color:#000;line-height:1.2;pointer-events:all;white-space:normal;overflow-wrap:normal">Browser</div></div></div></foreignObject><text x="440" y="244" font-family="Helvetica" font-size="14" text-anchor="middle">Browser</text></switch><path fill="#FFF" stroke="#000" pointer-events="all" d="M380 435h120v40H380z"/><switch transform="translate(-.5 -.5)"><foreignObject style="overflow:visible;text-align:left" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display:flex;align-items:unsafe center;justify-content:unsafe center;width:118px;height:1px;padding-top:455px;margin-left:381px"><div style="box-sizing:border-box;font-size:0;text-align:center" data-drawio-colors="color: rgb(0 0 0);"><div style="display:inline-block;font-size:14px;font-family:Helvetica;color:#000;line-height:1.2;pointer-events:all;white-space:normal;overflow-wrap:normal">Service worker</div></div></div></foreignObject><text x="440" y="459" font-family="Helvetica" font-size="14" text-anchor="middle">Service worker</text></switch><path d="M395 70Q270 90 141.28 181.94" fill="none" stroke="#000" stroke-miterlimit="10" pointer-events="stroke"/><path d="m130.91 189.35 8.89-16.8 1.48 9.39 8.4 4.45Z" stroke="#000" stroke-miterlimit="10" pointer-events="all"/><switch transform="translate(-.5 -.5)"><foreignObject style="overflow:visible;text-align:left" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display:flex;align-items:unsafe center;justify-content:unsafe flex-start;width:1px;height:1px;padding-top:111px;margin-left:177px"><div style="box-sizing:border-box;font-size:0;text-align:left" data-drawio-colors="color: rgb(0 0 0); background-color: rgb(255 255 255);"><div style="display:inline-block;font-size:14px;font-family:Helvetica;color:#000;line-height:1.2;pointer-events:all;background-color:#fff;white-space:nowrap"><div align="left">2. Send push message</div></div></div></div></foreignObject><text x="177" y="115" font-family="Helvetica" font-size="14">2. Send push message</text></switch><path d="M85 220q45 110 281.95 24.7" fill="none" stroke="#000" stroke-miterlimit="10" pointer-events="stroke"/><path d="m378.95 240.38-13.12 13.75 1.12-9.43-6.88-6.56Z" stroke="#000" stroke-miterlimit="10" pointer-events="all"/><switch transform="translate(-.5 -.5)"><foreignObject style="overflow:visible;text-align:left" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display:flex;align-items:unsafe center;justify-content:unsafe flex-start;width:1px;height:1px;padding-top:278px;margin-left:58px"><div style="box-sizing:border-box;font-size:0;text-align:left" data-drawio-colors="color: rgb(0 0 0); background-color: rgb(255 255 255);"><div style="display:inline-block;font-size:14px;font-family:Helvetica;color:#000;line-height:1.2;pointer-events:all;background-color:#fff;white-space:nowrap"><div align="left">4. Deliver encrypted</div><div align="left">push message<br/></div></div></div></div></foreignObject><text x="58" y="282" font-family="Helvetica" font-size="14">4. Deliver encrypted...</text></switch><path d="M107.5 180q2.5-30-7.5-40t-20-10q-10 0-20 10t-2.83 27.2" fill="none" stroke="#000" stroke-miterlimit="10" pointer-events="stroke"/><path d="m62.07 178.97-14.38-12.43 9.48.66 6.21-7.19Z" stroke="#000" stroke-miterlimit="10" pointer-events="all"/><switch transform="translate(-.5 -.5)"><foreignObject style="overflow:visible;text-align:left" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display:flex;align-items:unsafe center;justify-content:unsafe flex-start;width:1px;height:1px;padding-top:100px;margin-left:52px"><div style="box-sizing:border-box;font-size:0;text-align:left" data-drawio-colors="color: rgb(0 0 0);"><div style="display:inline-block;font-size:14px;font-family:Helvetica;color:#000;line-height:1.2;pointer-events:all;white-space:nowrap"><div align="left">3. Verify</div><div align="left">push message<br/>signature</div></div></div></div></foreignObject><text x="52" y="104" font-family="Helvetica" font-size="14">3. Verif...</text></switch><path fill="#FFF" pointer-events="all" d="M570 170h80v40h-80z"/><switch transform="translate(-.5 -.5)"><foreignObject style="overflow:visible;text-align:left" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display:flex;align-items:unsafe center;justify-content:unsafe center;width:78px;height:1px;padding-top:190px;margin-left:571px"><div style="box-sizing:border-box;font-size:0;text-align:center" data-drawio-colors="color: rgb(0 0 0);"><div style="display:inline-block;font-size:14px;font-family:Helvetica;color:#000;line-height:1.2;pointer-events:all;white-space:normal;overflow-wrap:normal">Device</div></div></div></foreignObject><text x="610" y="194" font-family="Helvetica" font-size="14" text-anchor="middle">Device</text></switch><switch transform="translate(-.5 -.5)"><foreignObject style="overflow:visible;text-align:left" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display:flex;align-items:unsafe center;justify-content:unsafe flex-start;width:1px;height:1px;padding-top:241px;margin-left:562px"><div style="box-sizing:border-box;font-size:0;text-align:left" data-drawio-colors="color: rgb(0 0 0); background-color: rgb(255 255 255);"><div style="display:inline-block;font-size:14px;font-family:Helvetica;color:#000;line-height:1.2;pointer-events:all;background-color:#fff;white-space:nowrap"><div>5. Decrypt</div><div>push message<br/></div></div></div></div></foreignObject><text x="562" y="245" font-family="Helvetica" font-size="14">5. Decrypt...</text></switch><path d="M470 260v161.13" fill="none" stroke="#000" stroke-miterlimit="10" pointer-events="stroke"/><path d="m470 433.88-8.5-17 8.5 4.25 8.5-4.25Z" stroke="#000" stroke-miterlimit="10" pointer-events="all"/><switch transform="translate(-.5 -.5)"><foreignObject style="overflow:visible;text-align:left" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display:flex;align-items:unsafe center;justify-content:unsafe flex-start;width:1px;height:1px;padding-top:315px;margin-left:432px"><div style="box-sizing:border-box;font-size:0;text-align:left" data-drawio-colors="color: rgb(0 0 0); background-color: rgb(255 255 255);"><div style="display:inline-block;font-size:14px;font-family:Helvetica;color:#000;line-height:1.2;pointer-events:all;background-color:#fff;white-space:nowrap"><div align="left">6. Fire push event</div><div align="left">containing message<br/></div></div></div></div></foreignObject><text x="432" y="319" font-family="Helvetica" font-size="14">6. Fire push event...</text></switch><path fill="none" pointer-events="all" d="M560 435h130v30H560z"/><switch transform="translate(-.5 -.5)"><foreignObject style="overflow:visible;text-align:left" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display:flex;align-items:unsafe flex-start;justify-content:unsafe flex-start;width:128px;height:1px;padding-top:442px;margin-left:562px"><div style="box-sizing:border-box;font-size:0;text-align:left" data-drawio-colors="color: rgb(0 0 0);"><div style="display:inline-block;font-size:14px;font-family:Helvetica;color:#000;line-height:1.2;pointer-events:all;white-space:normal;overflow-wrap:normal"><div>7. Handle</div><div>message</div></div></div></div></foreignObject><text x="562" y="456" font-family="Helvetica" font-size="14">7. Handle...</text></switch><path d="M500 465q30 9 45-1t10-20q-5-10-41.46-1.98" fill="none" stroke="#000" stroke-miterlimit="10" pointer-events="stroke"/><path d="m501.09 444.76 14.78-11.95-2.33 9.21 5.98 7.39Z" stroke="#000" stroke-miterlimit="10" pointer-events="all"/><path d="M485 80q30 10 45 0t10-20q-5-10-41.4-2.72" fill="none" stroke="#000" stroke-miterlimit="10" pointer-events="stroke"/><path d="m486.1 59.78 15-11.67-2.5 9.17 5.83 7.5Z" stroke="#000" stroke-miterlimit="10" pointer-events="all"/><path d="M410 435V273.87" fill="none" stroke="#000" stroke-miterlimit="10" pointer-events="stroke"/><path d="m410 261.12 8.5 17-8.5-4.25-8.5 4.25Z" stroke="#000" stroke-miterlimit="10" pointer-events="all"/><switch transform="translate(-.5 -.5)"><foreignObject style="overflow:visible;text-align:left" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display:flex;align-items:unsafe center;justify-content:unsafe flex-start;width:1px;height:1px;padding-top:377px;margin-left:372px"><div style="box-sizing:border-box;font-size:0;text-align:left" data-drawio-colors="color: rgb(0 0 0); background-color: rgb(255 255 255);"><div style="display:inline-block;font-size:14px;font-family:Helvetica;color:#000;line-height:1.2;pointer-events:all;background-color:#fff;white-space:nowrap"><div align="left">8. Display</div><div align="left">notification<br/></div></div></div></div></foreignObject><text x="372" y="381" font-family="Helvetica" font-size="14">8. Display...</text></switch><path d="M500 250q30 10 45 0t10-20q-5-10-41.4-2.72" fill="none" stroke="#000" stroke-miterlimit="10" pointer-events="stroke"/><path d="m501.1 229.78 15-11.67-2.5 9.17 5.83 7.5Z" stroke="#000" stroke-miterlimit="10" pointer-events="all"/><switch transform="translate(-.5 -.5)"><foreignObject style="overflow:visible;text-align:left" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display:flex;align-items:unsafe center;justify-content:unsafe flex-start;width:1px;height:1px;padding-top:71px;margin-left:552px"><div style="box-sizing:border-box;font-size:0;text-align:left" data-drawio-colors="color: rgb(0 0 0); background-color: rgb(255 255 255);"><div style="display:inline-block;font-size:14px;font-family:Helvetica;color:#000;line-height:1.2;pointer-events:all;background-color:#fff;white-space:nowrap"><div>1. Encrypt and sign<br/></div><div>push message<br/></div></div></div></div></foreignObject><text x="552" y="75" font-family="Helvetica" font-size="14">1. Encrypt and sign...</text></switch><path d="M380 465q-60 15-65-10t51.44-12.91" fill="none" stroke="#000" stroke-miterlimit="10" pointer-events="stroke"/><path d="m378.91 444.77-18.41 4.75 5.94-7.43-2.37-9.2Z" stroke="#000" stroke-miterlimit="10" pointer-events="all"/><path fill="none" pointer-events="all" d="M240 420h130v30H240z"/><switch transform="translate(-.5 -.5)"><foreignObject style="overflow:visible;text-align:left" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display:flex;align-items:unsafe flex-start;justify-content:unsafe flex-start;width:128px;height:1px;padding-top:427px;margin-left:242px"><div style="box-sizing:border-box;font-size:0;text-align:left" data-drawio-colors="color: rgb(0 0 0);"><div style="display:inline-block;font-size:14px;font-family:Helvetica;color:#000;line-height:1.2;pointer-events:all;white-space:normal;overflow-wrap:normal"><div>9. Handle</div><div>notification</div><div>response<br/></div></div></div></div></foreignObject><text x="242" y="441" font-family="Helvetica" font-size="14">9. Handle...</text></switch></svg> | 0 |
data/mdn-content/files/en-us/web/progressive_web_apps/guides | data/mdn-content/files/en-us/web/progressive_web_apps/guides/offline_and_background_operation/push-messaging-1.svg | <svg xmlns="http://www.w3.org/2000/svg" style="background-color:#fff" xmlns:xlink="http://www.w3.org/1999/xlink" width="600" height="500" viewBox="-0.5 -0.5 600 500"><path fill="#FFF" stroke="#000" pointer-events="all" d="M274.9 60h90v40h-90z"/><switch transform="translate(-.5 -.5)"><foreignObject style="overflow:visible;text-align:left" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display:flex;align-items:unsafe center;justify-content:unsafe center;width:88px;height:1px;padding-top:80px;margin-left:276px"><div style="box-sizing:border-box;font-size:0;text-align:center" data-drawio-colors="color: rgb(0 0 0);"><div style="display:inline-block;font-size:14px;font-family:Helvetica;color:#000;line-height:1.2;pointer-events:all;white-space:normal;overflow-wrap:normal">App server</div></div></div></foreignObject><text x="320" y="84" font-family="Helvetica" font-size="14" text-anchor="middle">App server</text></switch><path fill="#FFF" stroke="#000" pointer-events="all" d="M219.9 231h260v209h-260z"/><path fill="#FFF" stroke="#000" pointer-events="all" d="M259.9 370h120v40h-120z"/><switch transform="translate(-.5 -.5)"><foreignObject style="overflow:visible;text-align:left" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display:flex;align-items:unsafe center;justify-content:unsafe center;width:118px;height:1px;padding-top:390px;margin-left:261px"><div style="box-sizing:border-box;font-size:0;text-align:center" data-drawio-colors="color: rgb(0 0 0);"><div style="display:inline-block;font-size:14px;font-family:Helvetica;color:#000;line-height:1.2;pointer-events:all;white-space:normal;overflow-wrap:normal">Browser</div></div></div></foreignObject><text x="320" y="394" font-family="Helvetica" font-size="14" text-anchor="middle">Browser</text></switch><path fill="#FFF" stroke="#000" pointer-events="all" d="M279.9 260h80v40h-80z"/><switch transform="translate(-.5 -.5)"><foreignObject style="overflow:visible;text-align:left" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display:flex;align-items:unsafe center;justify-content:unsafe center;width:78px;height:1px;padding-top:280px;margin-left:281px"><div style="box-sizing:border-box;font-size:0;text-align:center" data-drawio-colors="color: rgb(0 0 0);"><div style="display:inline-block;font-size:14px;font-family:Helvetica;color:#000;line-height:1.2;pointer-events:all;white-space:normal;overflow-wrap:normal">Main app</div></div></div></foreignObject><text x="320" y="284" font-family="Helvetica" font-size="14" text-anchor="middle">Main app</text></switch><path d="M274.9 70q-45-40-70-35t-25 40q0 35 81.43 17.86" fill="none" stroke="#000" stroke-miterlimit="10" pointer-events="stroke"/><path d="m273.81 90.23-14.89 11.82 2.41-9.19-5.91-7.45Z" stroke="#000" stroke-miterlimit="10" pointer-events="all"/><switch transform="translate(-.5 -.5)"><foreignObject style="overflow:visible;text-align:left" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display:flex;align-items:unsafe center;justify-content:unsafe center;width:1px;height:1px;padding-top:62px;margin-left:121px"><div style="box-sizing:border-box;font-size:0;text-align:center" data-drawio-colors="color: rgb(0 0 0); background-color: rgb(255 255 255);"><div style="display:inline-block;font-size:14px;font-family:Helvetica;color:#000;line-height:1.2;pointer-events:all;background-color:#fff;white-space:nowrap"><div style="font-size:14px">1. Provision server</div><div style="font-size:14px">with signing keys</div></div></div></div></foreignObject><text x="121" y="66" font-family="Helvetica" font-size="14" text-anchor="middle">1. Provision server...</text></switch><path d="M319.9 300v56.13" fill="none" stroke="#000" stroke-miterlimit="10" pointer-events="stroke"/><path d="m319.9 368.88-8.5-17 8.5 4.25 8.5-4.25Z" stroke="#000" stroke-miterlimit="10" pointer-events="all"/><switch transform="translate(-.5 -.5)"><foreignObject style="overflow:visible;text-align:left" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display:flex;align-items:unsafe center;justify-content:unsafe flex-start;width:1px;height:1px;padding-top:331px;margin-left:242px"><div style="box-sizing:border-box;font-size:0;text-align:left" data-drawio-colors="color: rgb(0 0 0); background-color: rgb(255 255 255);"><div style="display:inline-block;font-size:14px;font-family:Helvetica;color:#000;line-height:1.2;pointer-events:all;background-color:#fff;white-space:nowrap"><div style="font-size:14px" align="left">2. PushManager.subscribe()</div></div></div></div></foreignObject><text x="242" y="335" font-family="Helvetica" font-size="14">2. PushManager.subscribe()</text></switch><path d="M319.9 260V113.87" fill="none" stroke="#000" stroke-miterlimit="10" pointer-events="stroke"/><path d="m319.9 101.12 8.5 17-8.5-4.25-8.5 4.25Z" stroke="#000" stroke-miterlimit="10" pointer-events="all"/><switch transform="translate(-.5 -.5)"><foreignObject style="overflow:visible;text-align:left" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display:flex;align-items:unsafe center;justify-content:unsafe flex-start;width:1px;height:1px;padding-top:171px;margin-left:238px"><div style="box-sizing:border-box;font-size:0;text-align:left" data-drawio-colors="color: rgb(0 0 0); background-color: rgb(255 255 255);"><div style="display:inline-block;font-size:14px;font-family:Helvetica;color:#000;line-height:1.2;pointer-events:all;background-color:#fff;white-space:nowrap"><div style="font-size:14px" align="left">3. Send to app server:</div><div style="font-size:14px" align="left">- push service endpoint</div><div style="font-size:14px" align="left">- push service public encryption key</div></div></div></div></foreignObject><text x="238" y="175" font-family="Helvetica" font-size="14">3. Send to app server:...</text></switch><path fill="#FFF" pointer-events="all" d="M399.9 240h70v40h-70z"/><switch transform="translate(-.5 -.5)"><foreignObject style="overflow:visible;text-align:left" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display:flex;align-items:unsafe center;justify-content:unsafe center;width:68px;height:1px;padding-top:260px;margin-left:401px"><div style="box-sizing:border-box;font-size:0;text-align:center" data-drawio-colors="color: rgb(0 0 0);"><div style="display:inline-block;font-size:14px;font-family:Helvetica;color:#000;line-height:1.2;pointer-events:all;white-space:normal;overflow-wrap:normal">Device</div></div></div></foreignObject><text x="435" y="264" font-family="Helvetica" font-size="14" text-anchor="middle">Device</text></switch></svg> | 0 |
data/mdn-content/files/en-us/web/progressive_web_apps/guides | data/mdn-content/files/en-us/web/progressive_web_apps/guides/installing/index.md | ---
title: Installing and uninstalling web apps
slug: Web/Progressive_web_apps/Guides/Installing
page-type: guide
---
{{PWASidebar}}
This guide covers how users can install and uninstall PWAs on their devices. If you want to learn about making a web app installable as a PWA, see [Making PWAs installable](/en-US/docs/Web/Progressive_web_apps/Guides/Making_PWAs_installable) instead.
## History of web app installation
Browsers have always enabled saving shortcuts to websites, known as "bookmarking." These are just links to websites.
Some operating systems (OS) have enhanced bookmarking capabilities, enabling saving bookmarks to common places, such as the home screen or taskbar, with an icon launching the site in the OS's default browser. For many websites, this is also just a link to the site. If the site is a [Progressive Web Applications (PWA)](/en-US/docs/Web/Progressive_web_apps), saving to home screen installs the PWA on the user's device, fully integrating it into the operating systems like native applications on most devices. Just like PWAs can be installed, they can also be uninstalled.
We'll first cover the precursors — saving links to websites.
### Bookmarking websites
All browsers have add-to-favorites bookmark functionality. A bookmark, or favorite, is a clickable shortcut for a web page. Bookmarks enable quick access to websites without the user having to enter a URL or otherwise search for content. Bookmarking is especially useful for long URLs and accessing frequently visited content that is not the site's homepage.
All browsers enable users to view and manage their bookmarks, including renaming and deleting favorites. By default, the bookmark's display includes the text content of the bookmarked page's {{HTMLElement("title")}} element along with an icon consisting of the site's [favicon](/en-US/docs/Glossary/Favicon).
Browsers enable saving, editing, moving, deleting, and otherwise managing bookmarks. The UI for bookmark management differs by browser.
### Add to home screen
Smartphones, starting with the iPhone in 2007, added "save to home screen" functionality. For regular (non-PWA) websites, this feature is similar to bookmarks, but instead of adding the favicon and title of the page to the bookmarks menu — a browser feature — favoriting in this manner [adds an icon](/en-US/docs/Learn/HTML/Introduction_to_HTML/The_head_metadata_in_HTML#adding_custom_icons_to_your_site) to the OS's home screen.
Adding a non-PWA site to the home screen does not install the website on the device. Rather, it adds the developer-defined icon to the home screen, that, when clicked, opens the bookmarked link in the default browser.
If the site added to the home screen is a PWA, the PWA will be installed on the device.
Deleting the icon from the home screen removes the bookmark. The deletion confirmation provides information as to whether deleting the icon deletes a bookmark or entire application.
## Installing and uninstalling PWAs
While installing a PWA only takes a couple of clicks, depending on the web application features, the result of installing a PWA usually goes well beyond creating a link to a page on the Internet; installing a PWA more deeply integrates the web application on the user's device.
Depending on the PWA, device, and features of the operating system and browser, installing a PWA may enable native-like features, such as giving the app its own standalone window or registering it as a file handler. This also means uninstalling a PWA, which also only requires a couple of clicks, does more than just removing the PWA's icon.
### Installing PWAs
The UI for installing a PWA from the web varies from one browser to another, and from one platform to another.
The user interface for installing PWAs differs by device and OS combination. The "Add to homes screen" user interface installs the PWA on Safari on iOS. Other browsers, including Chrome for Android, include the app installation command in the browser setting menu. In Chrome and Edge on desktop, when the user navigates to the page, if the page is a PWA and the PWA is not currently installed by the browser, an installation icon will be visible in the URL bar:
When the user selects the icon, the browser displays a prompt asking if they want to install the PWA, and if they accept, the PWA is installed.
Once installed, the PWA will behave like other applications that are installed on the OS. For example, on macOS, the icon will appear in the dock, and will have the same icon options as other applications:
On most desktop browsers, the install prompt is in the URL bar. On mobile, the install prompt is generally found in the menu of browser options. No matter the browser or OS, the installation needs to be confirmed.
Once installed, the PWA behaves just like other installed applications: clicking on the application icon opens the PWA, even when the user is offline.
Installation is supported on all modern desktop and mobile devices. Whether the PWA can be installed by the browser on the operating system differs by browser/operating system combination. Most browsers support installing PWAs on all operating systems—ChromeOS, MacOS, Windows, Android, Linux, etc.—directly or when an extension is installed.
Firefox requires a [PWA extension](https://addons.mozilla.org/en-US/firefox/addon/pwas-for-firefox/).
Apple is unique when it comes to PWAs: PWAs can be installed on macOS from any browser **except** Safari. The opposite is true for iOS versions before 16.4, where PWAs could **only** be installed in Safari. PWAs can be installed on iOS/iPadOS 16.4 or later from any supporting browser.
When an installed PWA is launched, it can be displayed in its own standalone window (without the full browser UI) but it still effectively runs in a browser window, even if the usual browser UI elements, such as the address bar or back button, aren't visible. The application will be found where the OS saves other applications, within a folder specific to the browser.
PWAs installed by a browser remain specific to this browser. This means that the browser that was used to install a PWA is the one used to run that PWA. It also means that you can install the same PWA from a different browser and that the two apps will behave as two different instances and will not share any data.
The browser used to install the PWA will know the PWA is installed, but other browsers will not have access to the installed status. For example, if you install a PWA using MS Edge, Edge will prompt you to open the PWA when you visit the site while Chrome will continue to prompt you to install the application. If you install the PWA using Chrome as well, you will have two copies of the PWA. When multiple instances of a PWA are open, data is not shared between instances installed from different browsers.
When you tap the web app's icon, it opens up in the browser environment that installed the PWA, generally without the browser's UI around it, though that depends on the way the developer configured the [web app manifest](/en-US/docs/Web/Manifest). Similarly, the method used to uninstall the PWA depends on the browser that was used to install it.
### Uninstalling
On most mobile operating systems, uninstalling a PWA is accomplished in the same way as uninstalling other applications. On some mobile operating systems, PWAs appear in the same control panel where applications downloaded from app stores are managed and can be uninstalled there.
On iOS, PWAs installed from Safari are listed and searchable from the "App Library" screen, but are not listed along with other installed applications under "Settings". On iOS, long tapping an icon surfaces the delete bookmark UI; removing the icon from the home screen deletes the PWA.
In some desktop operating systems, uninstalling a PWA can be done directly in opened PWA. To uninstall, open the PWA. In the top right corner of the opened app, there will be an icon that must be expanded to see more tools. Depending on the browser used to install the PWA, there will either be a link to uninstall the PWA, or a settings link that opens the browser's settings page with an uninstall link. Either click on the uninstall option in the drop-down menu, if there, or navigate to the app settings in a browser tab and click uninstall.
Selecting app setting from the opened drop-down menu in Edge, opened the MS Edge browser `edge://apps` tab. There we are provided a list of installed applications with options for each, including `🗑️ Uninstall`. Confirm the uninstall. That's it!
In Edge, the installed PWAs are listed and can be managed by visiting [`edge://apps`](https://blogs.windows.com/msedgedev/2022/05/18/find-and-manage-your-installed-apps-and-sites/) in your Edge browser. In Chrome, the list of Google Apps and installed PWAs are viewable and managed by visiting `chrome://apps` in your Chrome browser.
## See also
- [Using PWAs in Chrome: computer and Android](https://support.google.com/chrome/answer/9658361)
- [Install, manage, or uninstall apps in Microsoft Edge](https://support.microsoft.com/en-us/topic/install-manage-or-uninstall-apps-in-microsoft-edge-0c156575-a94a-45e4-a54f-3a84846f6113)
| 0 |
data/mdn-content/files/en-us/web/progressive_web_apps/guides | data/mdn-content/files/en-us/web/progressive_web_apps/guides/what_is_a_progressive_web_app/index.md | ---
title: What is a progressive web app?
slug: Web/Progressive_web_apps/Guides/What_is_a_progressive_web_app
page-type: guide
---
{{PWASidebar}}
A progressive web app (PWA) is an app that's built using web platform technologies, but that provides a user experience like that of a platform-specific app.
## Platform-specific apps
_Platform-specific apps_ are developed for a specific operating system (OS) and/or class of device, like an iOS or Android device, generally using an SDK provided by the platform vendor. They are usually distributed using the vendor's app store, where the user can find and install them, and they subsequently seem to the user like a permanent extra feature of their device, expanding its capabilities in some way.
The benefits of platform-specific apps include:
- **Easy for users to access**: They get their own icon on the device, making it easy for users to find and open them.
- **Offline and background operation**: They are able to operate when the user is not interacting with them and when the device is offline. This, for example, enables a chat app to receive messages when it is not open, and display a notification to the user. It also enables a news app to update in the background so it can show fresh content even if the device is offline.
- **Dedicated UI**: They can implement their own distinctive, immersive UI.
- **OS integration**: They can be integrated into the host OS: for example, a messaging app can register as a share target, enabling users to select an image in the photo app and send it using the messaging app. They can also access device features such as the camera, GPS or accelerometer.
- **App store integration**: They are distributed using the app store, giving users a single place to find them and a consistent way to decide whether they want to install them.
## Traditional websites
Traditionally, websites are less like "something the user has" and more like "somewhere the user visits". Typically, a website: does not have a presence on the user's device when the user is not accessing it, can only be accessed by the user opening the browser and navigating to the site, and is highly dependent on network connectivity.
However, websites have some benefits over platform-specific apps, including:
- **Single codebase**: Because the web is inherently cross-platform, a website can run on different operating systems and device classes from a single codebase.
- **Distribution via the web**: The web is a great distribution platform. Websites are indexed by search engines, and can be shared and accessed just using URLs. A website can be distributed with no need to sign up to any vendor's app store.
## Progressive web apps
Progressive web apps combine the best features of traditional websites and platform-specific apps.
PWAs have the benefits of websites, including:
- PWAs are developed using standard web platform technologies, so they can run on multiple operating systems and device classes from a single codebase.
- PWAs can be accessed directly from the web.
PWAs also have many of the benefits of platform-specific apps, including:
- [**PWAs can be installed on the device**](/en-US/docs/Web/Progressive_web_apps/Guides/Making_PWAs_installable). This means:
- The PWA can be installed from platform's app store or installed directly from the web.
- The PWA can be installed like a platform-specific app, and can customize the install process.
- Once installed, the PWA gets an app icon on the device, alongside platform-specific apps.
- Once installed, the PWA can be launched as a standalone app, rather than a website in a browser.
- [**PWAs can operate in the background and offline**](/en-US/docs/Web/Progressive_web_apps/Guides/Offline_and_background_operation): a typical website is only active while the page is loaded in the browser. A PWA can:
- Work while the device does not have network connectivity.
- Update content in the background.
- Respond to [push messages](/en-US/docs/Web/API/Push_API) from the server.
- Display notifications using the OS [notifications](/en-US/docs/Web/API/Notifications_API) system.
- PWAs can [use the whole screen](/en-US/docs/Web/Progressive_web_apps/How_to/Create_a_standalone_app), rather than running in the browser UI.
- PWAs can be integrated into the device, registering as share targets and sources, and accessing device features.
- PWAs can be distributed in app stores, as well as openly via the web.
### PWAs and the browser
When you visit a website in the browser, it's visually apparent that the website is "running in the browser". The browser UI provides a visible frame around the website, including UI features like back/forward buttons and a title for the page. The Web APIs your website calls are implemented by the browser engine.
PWAs typically look like platform-specific apps － they are usually displayed without the browser UI around them － but they are, as a matter of technology, still websites. This means they need a browser engine, like the ones in Chrome or Firefox, to manage and run them. With a platform-specific app, the platform OS manages the app, providing the environment in which it runs. With a PWA, a browser engine performs this background role, just like it does for normal websites.
In our documentation for PWAs, we sometimes refer to the browser playing this background role. We might say, for example, "The browser starts a PWA's service worker when a push notification is received." Here, the browser's activity is entirely in the background. From the PWA's point of view, it might as well be the operating system that started it. For some systems, such as Chromebooks, there may not even be a distinction between "the browser" and "the operating system."
### Technical features of PWAs
Because PWAs are websites, they have the same basic features as any other website: at least one HTML page, which very probably loads some CSS and JavaScript. Like a normal website, the JavaScript loaded by the page has a global {{domxref("Window")}} object and can access all the Web APIs that are available through that object.
Beyond that, a PWA has some additional features:
- A [web app manifest](/en-US/docs/Web/Manifest) file, which, at a minimum, provides information that the browser needs to install the PWA, such as the app name and icon.
- A [service worker](/en-US/docs/Web/API/Service_Worker_API), which, at a minimum, provides a basic offline experience.
#### Web app manifest
A PWA must have a web app manifest, and the [manifest must include enough information for the browser to install the PWA](/en-US/docs/Web/Progressive_web_apps/Guides/Making_PWAs_installable#the_web_app_manifest).
The manifest can define many other aspects of the PWA's appearance, such as [theme color](/en-US/docs/Web/Manifest/theme_color) and [background color](/en-US/docs/Web/Manifest/background_color), and its behavior, including its ability to [act as a share target](/en-US/docs/Web/Manifest/share_target) for data from other apps or to [handle particular file types](/en-US/docs/Web/Manifest/file_handlers).
#### Service worker
A PWA must have a service worker, and the service worker must implement at least a minimal offline experience.
Service workers encourage an architecture in which the app's pages - that is, the traditional part of a website - implement the user interface, and the service worker implements a backend which can support [offline and background operation](/en-US/docs/Web/Progressive_web_apps/Guides/Offline_and_background_operation), making the PWA behave more like an app than a website. This is because service workers can be started by the browser in the background when they are needed (for example, to handle a push notification).
### PWAs and single-page apps
Traditionally a website is built as a collection of interlinked pages. When the user clicks a link from one page in the site to another page in the same site, the browser loads the new page as a completely new entity, including the HTML and the subresources that the HTML loads, like CSS and JavaScript. In a {{Glossary("SPA", "single-page app")}}, the site consists of a single HTML page, and when the user clicks internal links, this is handled by JavaScript fetching new content from the server and updating the relevant parts of the page.
Single-page apps can provide a user experience that is closer to platform-specific apps, so PWAs are often implemented as single-page apps. In particular, single-page apps make it easier to achieve a seamless user interface, in which the user is presented with a single, consistent page, and only the relevant parts of the page are updated as the user interacts with the app.
However, PWAs don't have to be single-page apps, and single-page apps don't have to be PWAs.
### Progressive enhancement
While {{Glossary("Progressive Enhancement", "progressive enhancement")}} is a desirable attribute for most websites, it is especially important for PWAs, which expect to run on a wide range of devices and often use advanced Web APIs which may not be supported by all browsers.
One basic component of progressive enhancement is that, if the user visits your PWA on the web by entering its URL in a browser, the user can interact with the app like a normal website. But if the browser can install it, the user will be prompted to install it and the app will appear as a new feature on their device.
PWAs should perform feature detection for advanced APIs and provide acceptable fallback experiences.
For example, the [Background Sync API](/en-US/docs/Web/API/Background_Synchronization_API) enables a PWA to ask a service worker to make a network request as soon as the device has connectivity. A classic use case for this is messaging. Suppose the user composes a message, but when the user tries to send the message, the device is offline. The Background Sync API enables the device to send the message in the background once the device is connected. On a device that does not support Background Sync, the app should let the user know the message could not be sent, giving them the chance to try again later.
| 0 |
data/mdn-content/files/en-us/web/progressive_web_apps/guides | data/mdn-content/files/en-us/web/progressive_web_apps/guides/what_is_a_progressive_web_app/pwa-environment.svg | <svg xmlns="http://www.w3.org/2000/svg" style="background-color:#fff" xmlns:xlink="http://www.w3.org/1999/xlink" width="561" height="382" viewBox="-0.5 -0.5 561 382"><path fill="#FFF" stroke="#000" pointer-events="all" d="M0 0h560v380H0z"/><path fill="#e6e6e6" stroke="#000" pointer-events="all" d="M22 292.25h130v60H22z"/><switch transform="translate(-.5 -.5)"><foreignObject style="overflow:visible;text-align:left" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display:flex;align-items:unsafe center;justify-content:unsafe center;width:128px;height:1px;padding-top:322px;margin-left:23px"><div style="box-sizing:border-box;font-size:0;text-align:center" data-drawio-colors="color: rgb(0 0 0);"><div style="display:inline-block;font-size:14px;font-family:Helvetica;color:#000;line-height:1.2;pointer-events:all;font-weight:700;white-space:normal;overflow-wrap:normal">Platform-specific app</div></div></div></foreignObject><text x="87" y="326" font-family="Helvetica" font-size="14" text-anchor="middle" font-weight="bold">Platform-specific...</text></switch><path fill="#e6e6e6" stroke="#000" pointer-events="all" d="M22 195.25h130v60H22z"/><switch transform="translate(-.5 -.5)"><foreignObject style="overflow:visible;text-align:left" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display:flex;align-items:unsafe center;justify-content:unsafe center;width:128px;height:1px;padding-top:225px;margin-left:23px"><div style="box-sizing:border-box;font-size:0;text-align:center" data-drawio-colors="color: rgb(0 0 0);"><div style="display:inline-block;font-size:14px;font-family:Helvetica;color:#000;line-height:1.2;pointer-events:all;font-weight:700;white-space:normal;overflow-wrap:normal">Progressive web app</div></div></div></foreignObject><text x="87" y="229" font-family="Helvetica" font-size="14" text-anchor="middle" font-weight="bold">Progressive web app</text></switch><path fill="#FFF" stroke="#000" pointer-events="all" d="M212 18.25h140v140H212zm-1 177h140v60H211z"/><switch transform="translate(-.5 -.5)"><foreignObject style="overflow:visible;text-align:left" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display:flex;align-items:unsafe center;justify-content:unsafe center;width:138px;height:1px;padding-top:225px;margin-left:212px"><div style="box-sizing:border-box;font-size:0;text-align:center" data-drawio-colors="color: rgb(0 0 0);"><div style="display:inline-block;font-size:14px;font-family:Helvetica;color:#000;line-height:1.2;pointer-events:all;white-space:normal;overflow-wrap:normal">Browser engine</div></div></div></foreignObject><text x="281" y="229" font-family="Helvetica" font-size="14" text-anchor="middle">Browser engine</text></switch><path fill="#FFF" stroke="#000" pointer-events="all" d="M413 18.25h120v330H413z"/><switch transform="translate(-.5 -.5)"><foreignObject style="overflow:visible;text-align:left" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display:flex;align-items:unsafe center;justify-content:unsafe center;width:118px;height:1px;padding-top:183px;margin-left:414px"><div style="box-sizing:border-box;font-size:0;text-align:center" data-drawio-colors="color: rgb(0 0 0);"><div style="display:inline-block;font-size:14px;font-family:Helvetica;color:#000;line-height:1.2;pointer-events:all;white-space:normal;overflow-wrap:normal">Operating system</div></div></div></foreignObject><text x="473" y="187" font-family="Helvetica" font-size="14" text-anchor="middle">Operating system</text></switch><path fill="#e6e6e6" stroke="#000" pointer-events="all" d="M222 68.25h120v60H222z"/><switch transform="translate(-.5 -.5)"><foreignObject style="overflow:visible;text-align:left" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display:flex;align-items:unsafe center;justify-content:unsafe center;width:118px;height:1px;padding-top:98px;margin-left:223px"><div style="box-sizing:border-box;font-size:0;text-align:center" data-drawio-colors="color: rgb(0 0 0);"><div style="display:inline-block;font-size:14px;font-family:Helvetica;color:#000;line-height:1.2;pointer-events:all;font-weight:700;white-space:normal;overflow-wrap:normal">Traditional website</div></div></div></foreignObject><text x="282" y="102" font-family="Helvetica" font-size="14" text-anchor="middle" font-weight="bold">Traditional websi...</text></switch><path fill="#FFF" pointer-events="all" d="M221 31.75h120v20H221z"/><switch transform="translate(-.5 -.5)"><foreignObject style="overflow:visible;text-align:left" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display:flex;align-items:unsafe center;justify-content:unsafe center;width:118px;height:1px;padding-top:42px;margin-left:222px"><div style="box-sizing:border-box;font-size:0;text-align:center" data-drawio-colors="color: rgb(0 0 0);"><div style="display:inline-block;font-size:14px;font-family:Helvetica;color:#000;line-height:1.2;pointer-events:all;white-space:normal;overflow-wrap:normal">Browser UI</div></div></div></foreignObject><text x="281" y="46" font-family="Helvetica" font-size="14" text-anchor="middle">Browser UI</text></switch><path d="m286.29 175.83 10.5.15-15.78 18.77-15.22-19.23 10.5.16.42-28.01-10.5-.15 15.78-18.77 15.22 19.23-10.5-.16Zm-93.79 44.42v-10.5l19 15.5-19 15.5v-10.5h-21v10.5l-19-15.5 19-15.5v10.5Z" fill="#FFF" stroke="#000" stroke-miterlimit="10" pointer-events="all"/><path d="M171.5 327.25v10.5l-19-15.5 19-15.5v10.5h223v-10.5l19 15.5-19 15.5v-10.5Zm199.99-96.97-.02 10.5-18.97-15.53 19.03-15.47-.02 10.5 22 .04.02-10.5 18.97 15.54-19.03 15.46.02-10.5Z" fill="none" stroke="#000" stroke-miterlimit="10" pointer-events="all"/><path fill="none" pointer-events="all" d="M22 18.25h60V59H22z"/><switch transform="translate(-.5 -.5)"><foreignObject style="overflow:visible;text-align:left" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display:flex;align-items:unsafe center;justify-content:unsafe center;width:58px;height:1px;padding-top:39px;margin-left:23px"><div style="box-sizing:border-box;font-size:0;text-align:center" data-drawio-colors="color: rgb(0 0 0);"><div style="display:inline-block;font-size:14px;font-family:Helvetica;color:#000;line-height:1.2;pointer-events:all;white-space:normal;overflow-wrap:normal">Device</div></div></div></foreignObject><text x="52" y="43" font-family="Helvetica" font-size="14" text-anchor="middle">Device</text></switch><path d="m371.49 99.86-.02 10.5-18.97-15.53 19.03-15.47-.02 10.5 22 .04.02-10.5 18.97 15.54-19.03 15.46.02-10.5Z" fill="none" stroke="#000" stroke-miterlimit="10" pointer-events="all"/></svg> | 0 |
data/mdn-content/files/en-us/web/progressive_web_apps/guides | data/mdn-content/files/en-us/web/progressive_web_apps/guides/caching/index.md | ---
title: Caching
slug: Web/Progressive_web_apps/Guides/Caching
page-type: guide
---
{{PWASidebar}}
When a user opens and interacts with a website, all the resources that the website needs, including the HTML, JavaScript, CSS, images, fonts, as well as any data explicitly requested by the app, are retrieved by making HTTP(S) requests. One of the most fundamental features of a PWA is the ability to explicitly cache some of the app's resources on the device, meaning that they can be retrieved without needing to send a request to the network.
There are two main benefits to caching resources locally: **offline operation** and **responsiveness**.
- **Offline operation**: Caching enables a PWA to function to a greater or lesser extent while the device does not have network connectivity.
- **Responsiveness**: Even if the device is online, a PWA will usually be much more responsive if its user interface is fetched from the cache, rather than the network.
The main drawback, of course, is **freshness**: caching is less appropriate for resources which need to be up to date. Also, for some types of requests, such as [POST](/en-US/docs/Web/HTTP/Methods/POST) requests, caching is never appropriate.
This means that whether and when you should cache a resource is very dependent on the resource in question, and a PWA will typically adopt different strategies for different resources. In this guide we'll look at some common caching strategies for PWAs, and see which strategies make sense for which resources.
## Caching technology overview
The main technologies on which a PWA can build a caching strategy are the [Fetch API](/en-US/docs/Web/API/Fetch_API), the [Service Worker API](/en-US/docs/Web/API/Service_Worker_API), and the [Cache API](/en-US/docs/Web/API/Cache).
### Fetch API
The Fetch API defines a global function {{domxref("fetch()")}} for fetching a network resource, and {{domxref("Request")}} and {{domxref("Response")}} interfaces that represent network requests and responses. The `fetch()` function takes a `Request` or a URL as an argument, and returns a {{jsxref("Promise")}} that resolves to a `Response`.
The `fetch()` function is available to service workers as well as to the main app thread.
### Service Worker API
A service worker is a part of a PWA: it's a separate script that runs in its own thread, separate from the app's main thread.
Once the service worker is active, then whenever the app requests a network resource controlled by the service worker, the browser fires an event called {{domxref("ServiceWorkerGlobalScope.fetch_event", "fetch")}} in the service worker's global scope. This event is fired not only for explicit `fetch()` calls from the main thread, but also implicit network requests to load pages and subresources (such as JavaScript, CSS, and images) made by the browser following page navigation.
By listening for the `fetch` event, the service worker can intercept the request and return a customized `Response`. In particular, it can return a locally cached response instead of always going to the network, or return a locally cached response if the device is offline.
### Cache API
The {{domxref("Cache")}} interface provides persistent storage for `Request`/`Response` pairs. It provides methods to add and delete `Request`/`Response` pairs, and to look up a cached `Response` matching a given `Request`. The cache is available in both the main app thread and the service worker: so it is possible for one thread to add a response there, and the other to retrieve it.
Most commonly, the service worker will add resources to the cache in its `install` or `fetch` event handlers.
## When to cache resources
A PWA can cache resources at any time, but in practice there are a few times when most PWAs will choose to cache them:
- **In the service worker's `install` event handler (precaching)**: When a service worker is installed, the browser fires an event called {{domxref("ServiceWorkerGlobalScope.install_event", "install")}} in the service worker's global scope. At this point the service worker can _precache_ resources, fetching them from the network and storing them in the cache.
> **Note:** Service worker install time is not the same as PWA install time. A service worker's `install` event fires as soon as the service worker has been downloaded and executes, which will typically happen as soon as the user visits your site.
>
> Even if the user never installs your site as a PWA, its service worker will be installed and activated.
- **In the service worker's `fetch` event handler**: When a service worker's `fetch` event fires, the service worker may forward the request to the network and cache the resulting response, either if the cache did not already contain a response, or to update the cached response with a more recent one.
- **In response to a user request**: A PWA might explicitly invite the user to download a resource to use later, when the device might be offline. For example, a music player might invite the user to download tracks to play later. In this case the main app thread could fetch the resource and add the response to the cache. Especially if the requested resource is big, the PWA might use the [Background Fetch API](/en-US/docs/Web/API/Background_Fetch_API), and in this case the response will be handled by the service worker, which will add it to the cache.
- **Periodically**: Using the [Periodic Background Sync API](/en-US/docs/Web/API/Web_Periodic_Background_Synchronization_API), a service worker might fetch resources periodically and cache the responses, to ensure that the PWA can serve reasonably fresh responses even while the device is offline.
## Caching strategies
A caching strategy is an algorithm for when to cache a resource, when to serve a cached resource, and when to get the resource from the network. In this section we'll summarize some common strategies.
This isn't an exhaustive list: it's just intended to illustrate the kinds of approaches a PWA can take.
A caching strategy balances offline operation, responsiveness, and freshness. Different resources have different requirements here: for example, the app's basic UI is likely to be relatively static, while it may be essential to have fresh data when displaying a product listing. This means that a PWA will typically adopt different strategies for different resources, and a single PWA might use all the strategies described here.
### Cache first
In this strategy we will precache some resources, and then implement a "cache first" strategy only for those resources. That is:
- For the precached resources, we will:
- Look in the cache for the resource, and return the resource if it is found.
- Otherwise, go to the network. If the network request succeeds, cache the resource for next time.
- For all other resources, we will always go to the network.
Precaching is an appropriate strategy for resources that the PWA is certain to need, that will not change for this version of the app, and that need to be fetched as quickly as possible. That includes, for example, the basic user interface of the app. If this is precached, then the app's UI can be rendered on launch without needing any network requests.
First, the service worker precaches static resources in its `install` event handler:
```js
const cacheName = "MyCache_1";
const precachedResources = ["/", "/app.js", "/style.css"];
async function precache() {
const cache = await caches.open(cacheName);
return cache.addAll(precachedResources);
}
self.addEventListener("install", (event) => {
event.waitUntil(precache());
});
```
In the `install` event handler, we pass the result of the caching operation into the event's {{domxref("ExtendableEvent.waitUntil", "waitUntil()")}} method. This means that if caching fails for any reason, the installation of the service worker fails: conversely, if installation succeeded, the service worker can be sure that the resource was added to the cache.
The `fetch` event handler looks like this:
```js
async function cacheFirst(request) {
const cachedResponse = await caches.match(request);
if (cachedResponse) {
return cachedResponse;
}
try {
const networkResponse = await fetch(request);
if (networkResponse.ok) {
const cache = await caches.open("MyCache_1");
cache.put(request, networkResponse.clone());
}
return networkResponse;
} catch (error) {
return Response.error();
}
}
self.addEventListener("fetch", (event) => {
if (precachedResources.includes(url.pathname)) {
event.respondWith(cacheFirst(event.request));
}
});
```
We return the resource by calling the event's {{domxref("FetchEvent.respondWith()", "respondWith()")}} method. If we don't call `respondWith()` for a given request, then the request is sent to the network as if the service worker had not intercepted it. So if a request is not precached, it just goes to the network.
When we add `networkResponse` to the cache, we must clone the response and add the copy to the cache, returning the original. This is because `Response` objects are streamable, so may only be read once.
You might wonder why we fall back to the network for precached resources. If they are precached, can't we be sure they will be in the cache? The reason is that it is possible for the cache to be cleared, either by the browser or by the user. Although this is unlikely, it would make the PWA unusable unless it can fall back to the network. See [Deleting cached data](#deleting_cached_data).
### Cache first with cache refresh
The drawback of "cache first" is that once a response is in the cache, it is never refreshed until a new version of the service worker is installed.
The "cache first with cache refresh" strategy, also known as "stale while revalidate", is similar to "cache first", except that we always send the request to the network, even after a cache hit, and use the response to refresh the cache. This means we get the responsiveness of "cache first", but get a fairly fresh response (as long as the request is made reasonably often).
This is a good choice when responsiveness is important, and freshness is somewhat important but not essential.
In this version we implement "cache first with cache refresh" for all resources except JSON.
```js
function isCacheable(request) {
const url = new URL(request.url);
return !url.pathname.endsWith(".json");
}
async function cacheFirstWithRefresh(request) {
const fetchResponsePromise = fetch(request).then(async (networkResponse) => {
if (networkResponse.ok) {
const cache = await caches.open("MyCache_1");
cache.put(request, networkResponse.clone());
}
return networkResponse;
});
return (await caches.match(request)) || (await fetchResponsePromise);
}
self.addEventListener("fetch", (event) => {
if (isCacheable(event.request)) {
event.respondWith(cacheFirstWithRefresh(event.request));
}
});
```
Note that we update the cache asynchronously (in a `then()` handler), so the app does not have to wait for the network response to be received before it can use the cached response.
### Network first
The last strategy we'll look at, "network first", is the inverse of cache first: we try to retrieve the resource from the network. If the network request succeeds, we return the response and update the cache. If it fails, we try the cache.
This is useful for requests for which it is important to get the most fresh response possible, but for which a cached resource is better than nothing. A messaging app's list of recent messages might fall into this category.
In the example below we use "network first" for requests to fetch all resources located under the app's "inbox" path.
```js
async function networkFirst(request) {
try {
const networkResponse = await fetch(request);
if (networkResponse.ok) {
const cache = await caches.open("MyCache_1");
cache.put(request, networkResponse.clone());
}
return networkResponse;
} catch (error) {
const cachedResponse = await caches.match(request);
return cachedResponse || Response.error();
}
}
self.addEventListener("fetch", (event) => {
const url = new URL(event.request.url);
if (url.pathname.match(/^\/inbox/)) {
event.respondWith(networkFirst(event.request));
}
});
```
There are still requests for which no response is better than a possibly-outdated response, and for which only a "network only" strategy is appropriate. For example, if an app is showing the list of available products, it will be frustrating to users if the list is out of date.
## Deleting cached data
Caches have a limited amount of storage space, and the browser may evict an app's cached data if the limit is exceeded. The specific limits and behavior are browser-specific: see [Storage quotas and eviction criteria](/en-US/docs/Web/API/Storage_API/Storage_quotas_and_eviction_criteria) for details. In practice, eviction of cached data is a very rare event. The user can also clear an app's cache at any time.
A PWA should clean up any old versions of its cache in the service worker's {{domxref("ServiceWorkerGlobalScope.activate_event", "activate")}} event: when this event fires, the service worker can be sure that no previous versions of the service worker are running, so old cached data is no longer needed.
## See also
- [Service Worker API](/en-US/docs/Web/API/Service_Worker_API)
- [Fetch API](/en-US/docs/Web/API/Fetch_API)
- [Storage quotas and eviction criteria](/en-US/docs/Web/API/Storage_API/Storage_quotas_and_eviction_criteria)
- [Strategies for service worker caching](https://developer.chrome.com/docs/workbox/caching-strategies-overview) on developer.chrome.com (2021)
- [The Offline Cookbook](https://web.dev/articles/offline-cookbook) on web.dev (2020)
| 0 |
data/mdn-content/files/en-us/web/progressive_web_apps/guides | data/mdn-content/files/en-us/web/progressive_web_apps/guides/making_pwas_installable/index.md | ---
title: Making PWAs installable
slug: Web/Progressive_web_apps/Guides/Making_PWAs_installable
page-type: guide
---
{{PWASidebar}}
One of the defining aspects of a PWA is that it can be promoted by the browser for installation on the device. Once installed, a PWA appears to users as a platform-specific app, a permanent feature of their device which they can launch directly from the operating system like any other app.
We can summarize this as follows:
- Supporting browsers promote the PWA to the user for installation on the device.
- The PWA can be installed like a platform-specific app, and can customize the install process.
- Once installed, the PWA gets an app icon on the device, alongside platform-specific apps.
- Once installed, the PWA can be launched as a standalone app, rather than a website in a browser.
We'll discuss each of these features in this guide. First, though, we'll discuss the requirements that a web app must meet for it to be promoted for installation.
## Installability
For a web app to be promoted for installation by a supporting browser, it needs to meet some technical requirements. We can consider these the minimum requirements for a web app to be a PWA.
### The web app manifest
A web app manifest is a JSON file that tells the browser how the PWA should appear and behave on the device. For a web app to be a PWA it must be installable, and for it to be installable it must include a manifest.
The manifest is included using a {{HTMLElement("link")}} element in the app's HTML:
```html
<!doctype html>
<html lang="en">
<head>
<link rel="manifest" href="manifest.json" />
<!-- ... -->
</head>
<body></body>
</html>
```
If the PWA has more than one page, every page must reference the manifest in this way.
The manifest contains a single JSON object containing a collection of members, each of which defines some aspect of the PWA's appearance or behavior. Here's a rather minimal manifest, containing just two members: `"name"` and `"icons"`.
```json
{
"name": "My PWA",
"icons": [
{
"src": "icons/512.png",
"type": "image/png",
"sizes": "512x512"
}
]
}
```
#### Required manifest members
Chromium-based browsers, including Google Chrome, Samsung Internet, and Microsoft Edge, require that the manifest includes the following members:
- [`name`](/en-US/docs/Web/Manifest/name)
- [`icons`](/en-US/docs/Web/Manifest/icons)
- [`start_url`](/en-US/docs/Web/Manifest/start_url)
- [`display`](/en-US/docs/Web/Manifest/display) and/or [`display_override`](/en-US/docs/Web/Manifest/display_override)
For a full description of every member, see the [web app manifest reference documentation](/en-US/docs/Web/Manifest).
### Secure context
For a web app to be installable, it must be served in a [secure context](/en-US/docs/Web/Progressive_web_apps). This usually means that it must be served over HTTPS. Local resources, such as localhost, `127.0.0.1` and `file://` are also considered secure.
### Service worker
For a web app to be installable, it must include a [service worker](/en-US/docs/Web/API/Service_Worker_API) with a [`fetch` event handler](/en-US/docs/Web/API/ServiceWorkerGlobalScope/fetch_event) that provides a basic offline experience.
## Installation from an app store
Users expect to find apps in the app store for their platform, like the Google Play Store or the Apple App Store.
If your app meets the installability prerequisites, you can package it and distribute it through app stores. The process is specific to each app store:
- [How to publish a PWA to the Google Play Store](https://chromeos.dev/en/publish/pwa-in-play)
- [How to publish a PWA to the Microsoft Store](https://learn.microsoft.com/en-us/microsoft-edge/progressive-web-apps-chromium/how-to/microsoft-store)
- [How to publish a PWA to the Meta Quest Store](https://developer.oculus.com/documentation/web/pwa-submit-app/)
The [PWABuilder](https://docs.pwabuilder.com/#/builder/quick-start) is a tool to simplify the process of packaging and publishing a PWA for various app stores. It supports the Google Play Store, Microsoft Store, Meta Quest Store, and iOS App Store.
If you have added your app to the app store, users can install it from there, just like a platform-specific app.
## Installation from the web
When a supporting browser determines that a web app meets the installability criteria described earlier, it will promote the app to the user for installation. The user will be offered the chance to install the app. This means you can distribute your PWA as a website, making it discoverable through web search, and also distribute it in app stores, so users can find it there.
This is a great example of the way PWAs can offer you the best of both worlds. It's also a good example of how progressive enhancement works with PWAs: if a user encounters your PWA on the web, using a browser that can't install it, they can use it just like a normal website.
The UI for installing a PWA from the web varies from one browser to another, and from one platform to another. For example, a browser might include an "Install" icon in the URL bar when the user navigates to the page:
When the user selects the icon, the browser displays a prompt asking if they want to install the PWA, and if they accept, the PWA is installed.
The prompt displays the name and icon for the PWA, taken from the [`name`](/en-US/docs/Web/Manifest/name) and [`icons`](/en-US/docs/Web/Manifest/icons) manifest members.
### Browser support
Support for PWA installation promotion from the web varies by browser and by platform.
On desktop:
- Firefox and Safari do not support installing PWAs on any desktop operating systems. See [Installing sites as apps](#installing_sites_as_apps), below.
- Chrome and Edge support installing PWAs on Linux, Windows, macOS, and Chromebooks.
On mobile:
- On Android, Firefox, Chrome, Edge, Opera, and Samsung Internet Browser all support installing PWAs.
- On iOS 16.3 and earlier, PWAs can only be installed with Safari.
- On iOS 16.4 and later, PWAs can be installed from the Share menu in Safari, Chrome, Edge, Firefox, and Orion.
### Installing sites as apps
Safari for desktop and mobile, and Edge for desktop also support installing any website as an app. However, this is not specific to PWA because the site doesn't need to meet the installability criteria described in this guide, and because the browser doesn't proactively promote the site for installation.
### Triggering the install prompt
A PWA can provide its own in-page UI for the user to open the install prompt, instead of relying on the UI provided by the browser by default. This enables a PWA to provide some context and a reason for the user to install the PWA, and can help make the install user flow easier to discover.
This technique relies on the [`beforeinstallprompt`](/en-US/docs/Web/API/Window/beforeinstallprompt_event) event, which is fired on the global [`Window`](/en-US/docs/Web/API/Window) object as soon as the browser has determined that the PWA is installable. This event has a [`prompt()`](/en-US/docs/Web/API/BeforeInstallPromptEvent/prompt) method that shows the install prompt. So a PWA can:
- add its own "Install" button
- listen for the `beforeinstallprompt` event
- cancel the event's default behavior by calling [`preventDefault()`](/en-US/docs/Web/API/Event/preventDefault)
- in the event handler for its own "Install" button, call [`prompt()`](/en-US/docs/Web/API/BeforeInstallPromptEvent/prompt).
This is not supported on iOS.
### Customizing the installation prompt
By default, the install prompt contains the name and icon for the PWA. If you provide values for the [`description`](/en-US/docs/Web/Manifest/description) and [`screenshots`](/en-US/docs/Web/Manifest/screenshots) manifest members, then, on Android only, these values will be shown in the install prompt, giving the user extra context and motivation to install the PWA.
The screenshot below shows what the install prompt for the [PWAmp demo](https://github.com/MicrosoftEdge/Demos/tree/main/pwamp) looks like on Google Chrome, running on Android:
## Launching the app
Once the PWA is installed, its icon is shown on the device alongside any other apps that the user has installed, and clicking the icon launches the app.
You can use the [`display`](/en-US/docs/Web/Manifest/display) manifest member to control the _display mode_: that is, how the PWA appears when it is launched. In particular:
- `"standalone"` indicates that the PWA should look and feel like a platform-specific application, with no browser UI elements
- `"browser"` indicates that the PWA should be opened as a new browser tab or window, just like a normal website.
If the browser does not support a given display mode, `display` will fall back to a supported display mode according to a predefined sequence. The [`display_override`](/en-US/docs/Web/Manifest/display_override) enables you to redefine the fallback sequence.
| 0 |
data/mdn-content/files/en-us/web/progressive_web_apps | data/mdn-content/files/en-us/web/progressive_web_apps/reference/index.md | ---
title: Progressive Web Apps reference
short-title: Reference
slug: Web/Progressive_web_apps/Reference
page-type: landing-page
---
{{PWASidebar}}
This reference describes the technologies, features, and APIs that [Progressive Web Apps](/en-US/docs/Web/Progressive_web_apps) (PWAs) can use to offer a great user experience.
## Web app manifest
- [Web app manifest members](/en-US/docs/Web/Manifest)
- : Developers can use web app manifest members to describe a PWA, customize its appearance, and more deeply integrate it into the operating system.
## Service Worker APIs
### Communication with the app
The following APIs can be used by a service worker to communicate with its associated client PWA:
- [`Client.postMessage()`](/en-US/docs/Web/API/Client/postMessage)
- : Allows a service worker to send a message to its client PWA.
- [Broadcast Channel API](/en-US/docs/Web/API/Broadcast_Channel_API)
- : Allows a service worker and its client PWA to establish a basic two-way communication channel.
### Offline operation
The following APIs can be used by a service worker to make your app work offline:
- [`Cache`](/en-US/docs/Web/API/Cache)
- : A persistent storage mechanism for HTTP responses used to store assets that can be reused when the app is offline.
- [`Clients`](/en-US/docs/Web/API/Clients)
- : An interface used to provide access to the documents that are controlled by the service worker.
- [`FetchEvent`](/en-US/docs/Web/API/FetchEvent)
- : An event, dispatched in the service worker with every HTTP request made by the client PWA. The event can be used to either send the request to the server as normal and save the response for future use, or intercept the request and immediately respond with a response cached previously.
### Background operation
The following APIs can be used by a service worker to perform tasks in the background, even when your app is not running:
- [Background Synchronization API](/en-US/docs/Web/API/Background_Synchronization_API)
- : A way to defer tasks to run in a service worker once there is a stable network connection.
- [Web Periodic Background Synchronization API](/en-US/docs/Web/API/Web_Periodic_Background_Synchronization_API)
- : A way to register tasks to be run in a service worker at periodic intervals with network connectivity.
- [Background Fetch API](/en-US/docs/Web/API/Background_Fetch_API)
- : A method for a service worker to manage downloads that may take a significant amount of time, such as video or audio files.
## Other web APIs
- [IndexedDB](/en-US/docs/Web/API/IndexedDB_API)
- : A client-side storage API for significant amounts of structured data, including files.
- [Badging API](/en-US/docs/Web/API/Badging_API)
- : A method of setting a badge on the application icon, providing a low-distraction notification.
- [Notifications API](/en-US/docs/Web/API/Notifications_API)
- : A way to send notifications that are displayed at the operating system level.
- [Web Share API](/en-US/docs/Web/API/Web_Share_API)
- : A mechanism for sharing text, links, files, and other content to other apps selected by the user on their device.
- [Window Controls Overlay API](/en-US/docs/Web/API/Window_Controls_Overlay_API)
- : An API for PWAs installed on desktop operating systems that enables hiding the default window title bar, enabling displaying the app over the full surface area of the app window.
| 0 |
data/mdn-content/files/en-us/web | data/mdn-content/files/en-us/web/mathml/index.md | ---
title: MathML
slug: Web/MathML
page-type: landing-page
browser-compat: mathml.elements.math
---
{{MathMLRef}}
**Mathematical Markup Language (MathML)** is an [XML](/en-US/docs/Web/XML)-based language for describing mathematical notation.
[MathML](https://w3c.github.io/mathml/) was originally designed as a general-purpose specification for browsers, office suites, [computer algebra systems](https://en.wikipedia.org/wiki/Computer_algebra_system), [EPUB](https://www.w3.org/publishing/epub33/) readers, [LaTeX](https://en.wikipedia.org/wiki/LaTeX)-based generators. However, this approach was not very adapted to the Web: the [subset focusing on semantics](https://w3c.github.io/mathml/#contm) has never been implemented in browsers while the [subset focusing on math layout](https://w3c.github.io/mathml/#presm) led to incomplete and inconsistent browser implementations.
[MathML Core](https://w3c.github.io/mathml-core/) is a subset with increased implementation details based on rules from [LaTeX](https://en.wikipedia.org/wiki/LaTeX) and the [Open Font Format](https://docs.microsoft.com/typography/opentype/spec/math). It is tailored for browsers and designed specifically to work well with other web standards including [HTML](/en-US/docs/Web/HTML), [CSS](/en-US/docs/Web/CSS), [DOM](/en-US/docs/Web/API/Document_Object_Model), [JavaScript](/en-US/docs/Web/JavaScript).
Below you will find links to documentation, examples, and tools to work with MathML. MDN uses [MathML Core](https://w3c.github.io/mathml-core/) as a reference specification but, due to an erratic standardization history, legacy MathML features may still show up in existing implementations and web content.
> **Note:** It is highly recommended that developers and authors switch to MathML Core, perhaps relying on other web technologies to cover missing use cases. The Math WG is maintaining a set of [MathML polyfills](https://github.com/mathml-refresh/mathml-polyfills) to facilitate that transition.
## MathML reference
- [MathML element reference](/en-US/docs/Web/MathML/Element)
- : Details about each MathML element and compatibility information for desktop and mobile browsers.
- [MathML attribute reference](/en-US/docs/Web/MathML/Attribute)
- : Information about MathML attributes that modify the appearance or behavior of elements.
- [MathML examples](/en-US/docs/Web/MathML/Examples)
- : MathML samples and examples to help you understand how it works.
- [Authoring MathML](/en-US/docs/Web/MathML/Authoring)
- : Suggestions and tips for writing MathML, including suggested MathML editors and how to integrate their output into Web content.
- [MathML tutorial](/en-US/docs/Learn/MathML)
- : A gentle introduction to MathML.
## Getting help from the community
- [W3C Math Home](https://www.w3.org/Math/)
- [Raise issues on GitHub w3c/mathml repository](https://github.com/w3c/mathml/issues)
- [www-math w3.org mail archive](https://lists.w3.org/Archives/Public/www-math/)
## Tools
- [W3C Validator](https://validator.w3.org)
- [W3C's wiki page](https://www.w3.org/wiki/Math_Tools)
## Related topics
- [CSS](/en-US/docs/Web/CSS)
- [HTML](/en-US/docs/Web/HTML)
- [SVG](/en-US/docs/Web/SVG)
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/mathml | data/mdn-content/files/en-us/web/mathml/authoring/index.md | ---
title: Authoring MathML
slug: Web/MathML/Authoring
page-type: guide
---
{{MathMLRef}}
This page explains how to write mathematics using the MathML language, which is described with tags and attributes in text format. Just like for HTML or SVG, this text can become very verbose for complex content and so requires [proper authoring tools](https://www.w3.org/wiki/Math_Tools#Authoring_tools) such as converters from a [lightweight markup language](https://en.wikipedia.org/wiki/Lightweight_markup_language) or [WYSIWYG](https://en.wikipedia.org/wiki/WYSIWYG) equation editors. Many such tools are available and it is impossible to provide an exhaustive list. Instead, this article focuses on common approaches and examples.
## Using MathML
Even if your MathML formulas will likely be generated by authoring tools, it is important to be aware of a few tips to properly integrate them in your document.
### MathML in HTML pages
Each MathML equation is represented by a root [`math`](/en-US/docs/Web/MathML/Element/math) element, which can be embedded directly in HTML pages. By default, the formula will be rendered inline, with extra adjustments to minimize its height. Use a `display="block"` attribute to render complex formulas normally, and in their own paragraph.
```html
<!doctype html>
<html lang="en-US">
<head>
<meta charset="UTF-8" />
<title>MathML in HTML5</title>
</head>
<body>
<h1>MathML in HTML5</h1>
<p>
One over square root of two (inline style):
<math>
<mfrac>
<mn>1</mn>
<msqrt>
<mn>2</mn>
</msqrt>
</mfrac>
</math>
</p>
<p>
One over square root of two (display style):
<math display="block">
<mfrac>
<mn>1</mn>
<msqrt>
<mn>2</mn>
</msqrt>
</mfrac>
</math>
</p>
</body>
</html>
```
> **Note:** To use MathML in XML documents (e.g. XHTML, EPUB or OpenDocument) place an explicit `xmlns="http://www.w3.org/1998/Math/MathML"` attribute on each `<math>` element.
> **Note:** Some email or instant messaging clients are able to send and receive messages in the HTML format. It is thus possible to embed mathematical formulas inside such messages, as long as MathML tags are not filtered out by markup sanitizers.
#### Fallback for browsers without MathML support
It is recommended to provide a fallback mechanism for browsers without MathML support. If your document contains only basic mathematical formulas then a small [mathml.css](https://github.com/fred-wang/mathml.css) stylesheet might be enough. To load it conditionally, just insert one line in your document header:
```html
<script src="https://fred-wang.github.io/mathml.css/mspace.js"></script>
```
If you need more complex constructions, you might instead consider using the heavier [MathJax](https://www.mathjax.org) library as a MathML polyfill:
```html
<script src="https://fred-wang.github.io/mathjax.js/mpadded-min.js"></script>
```
Alternatively, you can also just display a warning at the top of the page for browsers without good MathML support and let the users choose between one of the fallback above:
```html
<script src="https://fred-wang.github.io/mathml-warning.js/mpadded-min.js"></script>
```
> **Note:** These small scripts perform feature detection (of the [mspace](/en-US/docs/Web/MathML/Element/mspace) or [mpadded](/en-US/docs/Web/MathML/Element/mpadded) elements) which is preferred over [browser sniffing](/en-US/docs/Web/HTTP/Browser_detection_using_the_user_agent). Also, they are distributed under an open source license, so feel free to copy them on your own server and adapt them to your need.
#### Mathematical fonts
As explained on the [MathML Fonts](/en-US/docs/Web/MathML/Fonts) article, mathematical fonts are instrumental to render MathML content. It's thus always a good idea to share the [installation instructions for such fonts](/en-US/docs/Web/MathML/Fonts#installation_instructions) or to provide them as [Web fonts](/en-US/docs/Learn/CSS/Styling_text/Web_fonts).
The [MathFonts page](https://fred-wang.github.io/MathFonts/) provides such Web fonts together with proper style sheets. For example, just insert the following line in your document header in order to select the Latin Modern fonts with fallback Web fonts:
```html
<link
rel="stylesheet"
href="https://fred-wang.github.io/MathFonts/LatinModern/mathfonts.css" />
```
Several fonts are proposed and you can just select a different style, for example STIX:
```html
<link
rel="stylesheet"
href="https://fred-wang.github.io/MathFonts/STIX/mathfonts.css" />
```
> **Note:** The fonts and stylesheets from that MathFonts page are distributed under open source licenses, so feel free to copy them on your own server and adapt them to your need.
## Conversion from a simple syntax
In this section, we review some tools to convert MathML from a [lightweight markup language](https://en.wikipedia.org/wiki/Lightweight_markup_language) such as the popular [LaTeX](https://en.wikipedia.org/wiki/LaTeX) language.
### Client-side conversion
With this approach, formulas are written directly in Web pages and a JavaScript library takes care of performing their conversion to MathML. This is probably the easiest option, but it also has some issues: extra JavaScript code must be loaded and executed, authors must escape reserved characters, Web crawlers won't have access to the MathML output...
A [custom element](/en-US/docs/Web/API/Web_components/Using_custom_elements) can be used to host the source code and ensure the corresponding MathML output is inserted and rendered via a [shadow subtree](/en-US/docs/Web/API/Web_components/Using_shadow_DOM). For example, using [TeXZilla](https://github.com/fred-wang/TeXZilla)'s [`<la-tex>`](https://fred-wang.github.io/TeXZilla/examples/customElement.html) element, the [MathML example above](#mathml_in_html_pages) can just be rewritten more concisely as follows:
```html
<!doctype html>
<html lang="en-US">
<head>
<meta charset="UTF-8" />
<title>MathML in HTML5</title>
<script src="https://fred-wang.github.io/TeXZilla/TeXZilla-min.js"></script>
<script src="https://fred-wang.github.io/TeXZilla/examples/customElement.js"></script>
</head>
<body>
<h1>MathML in HTML5</h1>
<p>
One over square root of two (inline style):
<la-tex>\frac{1}{\sqrt{2}}</la-tex>
</p>
<p>
One over square root of two (display style):
<la-tex display="block">\frac{1}{\sqrt{2}}</la-tex>
</p>
</body>
</html>
```
For authors not familiar with LaTeX, alternative input methods are available such as the [ASCIIMath](http://asciimath.org/#syntax) or [jqMath](https://mathscribe.com/author/jqmath.html) syntax. Be sure to load the JavaScript libraries and use the proper delimiters:
```html
<!doctype html>
<html lang="en-US">
<head>
<meta charset="utf-8" />
<meta name="viewport" content="width=device-width" />
<title>ASCII MathML</title>
…
<!-- ASCIIMathML.js -->
<script src="/path/to/ASCIIMathML.js"></script>
…
<!-- jqMath -->
<script src="https://mathscribe.com/mathscribe/jquery-1.4.3.min.js"></script>
<script src="https://mathscribe.com/mathscribe/jqmath-etc-0.4.6.min.js"></script>
…
</head>
<body>
…
<p>One over square root of two (inline style, ASCIIMath): `1/(sqrt 2)`</p>
…
<p>One over square root of two (inline style, jqMath): $1/√2$</p>
…
<p>One over square root of two (display style, jqMath): $$1/√2$$</p>
…
</body>
</html>
```
### Command-line programs
Instead of generating MathML expression at page load, you can instead rely on command line tools. This will result in pages with static MathML content that will load faster. Let's consider again a page `input.html` with content from [client-side conversion](#client-side_conversion):
```html
<!doctype html>
<html lang="en-US">
<head>
<meta charset="UTF-8" />
<title>MathML in HTML5</title>
</head>
<body>
<h1>MathML in HTML5</h1>
<p>One over square root of two (inline style): $\frac{1}{\sqrt{2}}$</p>
<p>One over square root of two (display style): $$\frac{1}{\sqrt{2}}$$</p>
</body>
</html>
```
That page does contain any [`script`](/en-US/docs/Web/HTML/Element/script) tag. Instead, conversion is executed via the following command line using [Node.js](https://nodejs.org/) and [TeXZilla](https://github.com/fred-wang/TeXZilla/wiki/Using-TeXZilla#usage-from-the-command-line):
```bash
cat input.html | node TeXZilla.js streamfilter > output.html
```
After running that command, a file `output.html` containing the following HTML output is created. The formulas delimited by dollars have been converted into MathML:
```html-nolint
<!DOCTYPE html>
<html lang="en-US">
<head>
<meta charset="UTF-8" />
<title>MathML in HTML5</title>
</head>
<body>
<h1>MathML in HTML5</h1>
<p>
One over square root of two (inline style):
<math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mfrac><mn>1</mn><msqrt><mn>2</mn></msqrt></mfrac><annotation encoding="TeX">\frac{1}{\sqrt{2}}</annotation></semantics></math>
</p>
<p>
One over square root of two (display style):
<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><semantics><mfrac><mn>1</mn><msqrt><mn>2</mn></msqrt></mfrac><annotation encoding="TeX">\frac{1}{\sqrt{2}}</annotation></semantics></math>
</p>
</body>
</html>
```
There are more sophisticated tools that aim at converting an arbitrary LaTeX document into a document with MathML content. For example, using [LaTeXML](https://math.nist.gov/~BMiller/LaTeXML/) the following commands will convert `foo.tex` into an HTML or EPUB document:
```bash
latexmlc --dest foo.html foo.tex # Generate a HTML document foo.html
latexmlc --dest foo.epub foo.tex # Generate an EPUB document foo.epub
```
`latexmlc` accepts a `--javascript` parameter that you can use to include one of the [fallback scripts](#fallback_for_browsers_without_mathml_support) mentioned above:
```bash
latexmlc --dest foo.html --javascript=https://fred-wang.github.io/mathml.css/mspace.js foo.tex # Add the CSS fallback
latexmlc --dest foo.html --javascript=https://fred-wang.github.io/mathjax.js/mpadded-min.js foo.tex # Add the MathJax fallback
```
> **Note:** Command-line tools can be used server-side e.g. [MediaWiki](https://www.mediawiki.org/wiki/MediaWiki) performs LaTeX-to-MathML conversion via [Mathoid](https://github.com/wikimedia/mathoid).
## Graphical interfaces
In this section, we review a few editing tools providing graphical interfaces.
### Input box
A simple approach is to integrate [converters from a simple syntax](#conversion_from_a_simple_syntax) as simple input boxes for mathematics. For example, [Thunderbird](https://www.thunderbird.net/en-US/) and [SeaMonkey](https://www.seamonkey-project.org/) provide an **Insert > Math** command that will open a popup window, with a LaTeX-to-MathML input field and a live MathML preview:
> **Note:** You can also use the **Insert > HTML** command to paste any MathML content.
[LibreOffice](https://www.libreoffice.org/)'s equation editor (File → New → Formula) shows a possible enhancement: its input box for the _StartMath_ syntax provides extra equation panels to insert pre-defined mathematical constructions.
> **Note:** To obtain libreoffice's MathML code, save the document as `mml` and open it with your favorite text editor.
### WYSIYWG editors
Other editors provide math editing features that are directly integrated into their WYSIYWG interface. The following screenshots are taken from [LyX](https://www.lyx.org/) and [TeXmacs](https://www.texmacs.org/tmweb/home/welcome.en.html), both of them supporting HTML export:
> **Note:** By default Lyx and TeXmacs will use images of formulas in their HTML output. To choose MathML instead, [follow these instructions](https://github.com/brucemiller/LaTeXML/wiki/Integrating-LaTeXML-into-TeX-editors#lyx) for the former and select `User preference > Convert > Export mathematical formulas as MathML` for the latter.
### Optical character and handwriting recognitions
A final option to enter mathematics is to rely on user interface for [Optical character recognition](https://en.wikipedia.org/wiki/Optical_character_recognition) or [Handwriting recognition](https://en.wikipedia.org/wiki/Handwriting_recognition). Some of these tools support mathematical formulas and can export them as MathML. The following screenshot shows a [demo from MyScript](https://webdemo.myscript.com/views/math/index.html):
| 0 |
data/mdn-content/files/en-us/web/mathml | data/mdn-content/files/en-us/web/mathml/fonts/index.md | ---
title: Fonts for MathML
slug: Web/MathML/Fonts
page-type: guide
---
{{MathMLRef}}
Fonts with appropriate Unicode coverage and Open Font Format features are required for good math rendering.
This page describes how users can install such math fonts to properly display MathML in browsers.
## Installation instructions
As a general rule of thumb, it is recommended to install both _Latin Modern Math_ (which uses [Computer Modern](https://en.wikipedia.org/wiki/Computer_Modern) style popular for math formulas) and _STIX Two Math_ (which has large unicode coverage for scientific characters). In the next sections, you will find detailed instructions to install these fonts in various operating systems.
### Windows
Install the _Latin Modern Math_ and _STIX Two Math_ fonts as follows:
1. Download [latinmodern-math-1959.zip](https://www.gust.org.pl/projects/e-foundry/lm-math/download/latinmodern-math-1959.zip).
2. Open the ZIP archive, move inside the `latinmodern-math-1959` directory and then inside the `otf` directory. You will find a `latinmodern-math` font file.
3. Open the `latinmodern-math` font file and click the **Install** button.
4. Download [static_otf.zip](https://raw.githubusercontent.com/stipub/stixfonts/master/zipfiles/static_otf.zip).
5. Open the `static_otf.zip` ZIP archive, and then move inside the `static_otf` directory. Among the files there, you will find a `STIXTwoMath-Regular` file.
6. Open the `STIXTwoMath-Regular` file and click the **Install** button. If desired, you may also do the same for the other font files in the directory.
> **Note:** _Cambria Math_ is installed by default on Windows and should ensure relatively good MathML rendering.
### macOS
Install the _Latin Modern Math_ font as follows:
1. Download [latinmodern-math-1959.zip](https://www.gust.org.pl/projects/e-foundry/lm-math/download/latinmodern-math-1959.zip).
2. Extract the ZIP archive, move inside the `latinmodern-math-1959` directory and then inside the `otf` directory. You will find a `latinmodern-math` font file.
3. Double-click the `latinmodern-math` font file click the **Install font** button from the window that opens.
> **Note:** If you are using macOS Ventura (version 13) or higher, then _STIX Two Math_ is already pre-installed and you can skip the steps below.
Install the _STIX Two Math_ font as follows:
1. Download [static_otf.zip](https://raw.githubusercontent.com/stipub/stixfonts/master/zipfiles/static_otf.zip).
2. Open the `static_otf.zip` ZIP archive, and then move inside the `static_otf` directory. Among the files there, you will find a `STIXTwoMath-Regular.otf` file.
3. Open the `STIXTwoMath-Regular.otf` file and click the **Install Font** button from the window that opens. If desired, you may also do the same for the other font files in the directory.
> **Note:** A deprecated version of _STIX_ is preinstalled starting with OS X Lion (version 10.7). Although some browsers are able to make use of it, it is strongly recommended to follow the instructions above for optimal math rendering.
### Linux
Below, you can find commands to execute on popular Linux distributions
in order to install the _Latin Modern Math_ and _STIX Two Math_ fonts from your
package manager. Alternative approaches are also provided if your Linux
distribution does not provide dedicated packages for these fonts.
#### Debian-based distributions (including Ubuntu and Mint)
```bash
sudo apt-get install fonts-lmodern fonts-stix
```
#### Fedora-based distributions
```bash
sudo dnf install texlive-lm-math stix-math-fonts
```
#### openSUSE-based distributions
```bash
sudo zypper install texlive-lm-math stix-fonts
```
#### Arch Linux
```bash
sudo pacman -S otf-latinmodern-math otf-stix
```
#### TeXLive packages
If your Linux distribution does not provide packages for the _Latin Modern Math_ and _STIX_ fonts, consider instead installing the `texlive` packages containing the _Latin Modern Math_ and _XITS_ fonts. For example on Mageia:
```bash
sudo urpmi texlive-dist texlive-fontsextra
```
However, you will likely need to ensure that these fonts are known by your system. Add a fontconfig configuration `/etc/fonts/conf.avail/09-texlive-fonts.conf` that points to the `opentype` directory of TeXLive, such as:
```xml
<?xml version="1.0"?>
<!DOCTYPE fontconfig SYSTEM "fonts.dtd">
<fontconfig>
<dir>/your/path/to/texmf-dist/fonts/opentype</dir>
</fontconfig>
```
Finally, add this configuration file to the system font location list and regenerate the fontconfig cache:
```bash
ln -sf /etc/fonts/conf.avail/09-texlive-fonts.conf /etc/fonts/conf.d/
fc-cache -sf
```
#### Upstream packages
If no packages are available on your Linux distributions, or if you just want to install upstream packages then try this:
1. Download [latinmodern-math-1959.zip](https://www.gust.org.pl/projects/e-foundry/lm-math/download/latinmodern-math-1959.zip) and [static_otf.zip](https://raw.githubusercontent.com/stipub/stixfonts/master/zipfiles/static_otf.zip).
2. Create a `~/.fonts` if it does not exist already and place `latinmodern-math.otf` and `STIXTwoMath-Regular.otf` in that directory.
3. Run `fc-cache -f` to regenerate the fontconfig cache.
### Android
You must use the [MathML-fonts add-on](https://addons.mozilla.org/firefox/addon/mathml-fonts/).
> **Note:** Noto Sans Math provides good Unicode coverage for math symbols and [Google plans to add support for math layout features](https://github.com/notofonts/math/issues/14#issuecomment-1161414446).
### Other systems
On other systems, consider installing a [font with a MATH table](#fonts_with_a_math_table) using your package manager. Note that these fonts are generally delivered with TeX distributions such as [TeX Live](https://www.tug.org/texlive/), but you might need to follow specific instructions so that your system is aware of the fonts. As a last resort, install the [MathML fonts add-on](https://addons.mozilla.org/firefox/addon/mathml-fonts/).
## Advanced setup
In the next sections, you will find other useful tips for installation and
configuration of fonts for MathML.
### Arabic mathematical alphabetic symbols
Currently, very few fonts have appropriate glyphs for the Arabic Mathematical Alphabetic Symbols. If you are likely to need these characters, we recommend to install the _XITS_ or [Amiri](https://www.amirifont.org/) fonts.
### Installation without administrator privilege
If you need to install fonts on a system without administrator privilege, the easiest option is to use math font the [MathML-fonts add-on](https://addons.mozilla.org/firefox/addon/mathml-fonts/). Note that using the add-on is not optimal since it forces your Gecko browser to load a CSS stylesheet on each page you visit as well as Web math fonts on all pages with MathML content.
A better alternative on UNIX systems is to install the OTF files for [Latin Modern Math](https://www.gust.org.pl/projects/e-foundry/lm-math/download/latinmodern-math-1959.zip) and [STIX](https://github.com/stipub/stixfonts) into some local font folder and (if necessary) to run `fc-cache` on it. On macOS and Linux, the standard paths are respectively `~/Library/Fonts/` and `~/.fonts`.
### Fonts with a MATH table
You can actually install any [mathematical OpenType font](https://fred-wang.github.io/MathFonts/) and use them for MathML rendering. Some browsers provide a way to configure the default font for MathML in their font preference menu. Alternatively, you can try the [MathML-fontsettings add-on](https://addons.mozilla.org/en-US/firefox/addon/mathml-font-settings/).
- [Asana Math](https://www.ctan.org/tex-archive/fonts/Asana-Math/)
- [Cambria Math](https://docs.microsoft.com/typography/font-list/?FID=360)
- [DejaVu Math TeX Gyre](https://sourceforge.net/projects/dejavu/files/dejavu/)
- [Garamond Math](https://github.com/YuanshengZhao/Garamond-Math)
- [Latin Modern Math](https://www.gust.org.pl/projects/e-foundry/lm-math)
- [Libertinus Math](https://github.com/alerque/libertinus)
- [STIX Math](https://github.com/stipub/stixfonts)
- [TeX Gyre Bonum Math](https://www.gust.org.pl/projects/e-foundry/tg-math/download/index_html#Bonum_Math)
- [TeX Gyre Pagella Math](https://www.gust.org.pl/projects/e-foundry/tg-math/download/index_html#Pagella_Math)
- [TeX Gyre Schola Math](https://www.gust.org.pl/projects/e-foundry/tg-math/download/index_html#Schola_Math)
- [TeX Gyre Termes Math](https://www.gust.org.pl/projects/e-foundry/tg-math/download/index_html#Termes_Math)
- [XITS Math](https://github.com/aliftype/xits/releases)
- [Fira Math](https://github.com/firamath/firamath)
- [GFS Neohellenic Math](https://greekfontsociety-gfs.gr/typefaces/Math)
| 0 |
data/mdn-content/files/en-us/web/mathml | data/mdn-content/files/en-us/web/mathml/element/index.md | ---
title: MathML element reference
slug: Web/MathML/Element
page-type: landing-page
---
{{MathMLRef}}
This is an alphabetical list of MathML elements. All of them implement the {{domxref("MathMLElement")}} class.
> **Note:** As explained on the main [MathML](/en-US/docs/Web/MathML) page, MDN uses [MathML Core](https://w3c.github.io/mathml-core/) as a reference specification. However, legacy features that are still implemented by some browsers are also documented. You can find further details for these and other features in [MathML 4](https://w3c.github.io/mathml/).
## MathML elements A to Z
### math
- {{MathMLElement("math")}} (Top-level element)
### A
- {{MathMLElement("maction")}} {{deprecated_inline}} (Bound actions to sub-expressions)
- {{MathMLElement("annotation")}} (Data annotations)
- {{MathMLElement("annotation-xml")}} (XML annotations)
### E
- {{MathMLElement("menclose")}} {{non-standard_inline}} (Enclosed contents)
- {{MathMLElement("merror")}} (Enclosed syntax error messages)
### F
- {{MathMLElement("mfenced")}} {{non-standard_inline}}{{deprecated_inline}} (Parentheses)
- {{MathMLElement("mfrac")}} (Fraction)
### I
- {{MathMLElement("mi")}} (Identifier)
### M
- {{MathMLElement("mmultiscripts")}} (Prescripts and tensor indices)
### N
- {{MathMLElement("mn")}} (Number)
### O
- {{MathMLElement("mo")}} (Operator)
- {{MathMLElement("mover")}} (Overscript)
### P
- {{MathMLElement("mpadded")}} (Space around content)
- {{MathMLElement("mphantom")}} (Invisible content with reserved space)
- {{MathMLElement("mprescripts")}} (delimiter for prescripts)
### R
- {{MathMLElement("mroot")}} (Radical with specified index)
- {{MathMLElement("mrow")}} (Grouped sub-expressions)
### S
- {{MathMLElement("ms")}} (String literal)
- {{MathMLElement("semantics")}} (Container for semantic annotations)
- {{MathMLElement("mspace")}} (Space)
- {{MathMLElement("msqrt")}} (Square root without an index)
- {{MathMLElement("mstyle")}} (Style change)
- {{MathMLElement("msub")}} (Subscript)
- {{MathMLElement("msup")}} (Superscript)
- {{MathMLElement("msubsup")}} (Subscript-superscript pair)
### T
- {{MathMLElement("mtable")}} (Table or matrix)
- {{MathMLElement("mtd")}} (Cell in a table or a matrix)
- {{MathMLElement("mtext")}} (Text)
- {{MathMLElement("mtr")}} (Row in a table or a matrix)
### U
- {{MathMLElement("munder")}} (Underscript)
- {{MathMLElement("munderover")}} (Underscript-overscript pair)
## MathML elements by category
### Top-level elements
- {{MathMLElement("math")}} (Top-level element)
### Token elements
- {{MathMLElement("mi")}} (Identifier)
- {{MathMLElement("mn")}} (Number)
- {{MathMLElement("mo")}} (Operator)
- {{MathMLElement("ms")}} (String literal)
- {{MathMLElement("mspace")}} (Space)
- {{MathMLElement("mtext")}} (Text)
### General layout
- {{MathMLElement("menclose")}} {{non-standard_inline}} (Enclosed contents)
- {{MathMLElement("merror")}} (Enclosed syntax error messages)
- {{MathMLElement("mfenced")}} {{non-standard_inline}} {{deprecated_inline}} (Parentheses)
- {{MathMLElement("mfrac")}} (Fraction)
- {{MathMLElement("mpadded")}} (Space around content)
- {{MathMLElement("mphantom")}} (Invisible content with reserved space)
- {{MathMLElement("mroot")}} (Radical with specified index)
- {{MathMLElement("mrow")}} (Grouped sub-expressions)
- {{MathMLElement("msqrt")}} (Square root without an index)
- {{MathMLElement("mstyle")}} (Style change)
### Script and limit elements
- {{MathMLElement("mmultiscripts")}} (Prescripts and tensor indices)
- {{MathMLElement("mover")}} (Overscript)
- {{MathMLElement("mprescripts")}} (Delimiter for prescripts)
- {{MathMLElement("msub")}} (Subscript)
- {{MathMLElement("msubsup")}} (Subscript-superscript pair)
- {{MathMLElement("msup")}} (Superscript)
- {{MathMLElement("munder")}} (Underscript)
- {{MathMLElement("munderover")}} (Underscript-overscript pair)
### Tabular math
- {{MathMLElement("mtable")}} (Table or matrix)
- {{MathMLElement("mtd")}} (Cell in a table or a matrix)
- {{MathMLElement("mtr")}} (Row in a table or a matrix)
### Uncategorized elements
- {{MathMLElement("maction")}} {{deprecated_inline}} (Bound actions to sub-expressions)
## Semantic annotations
- {{MathMLElement("annotation")}} (Data annotations)
- {{MathMLElement("annotation-xml")}} (XML annotations)
- {{MathMLElement("semantics")}} (Container for semantic annotations)
## See also
- [MathML](/en-US/docs/Web/MathML)
- [MathML attribute reference](/en-US/docs/Web/MathML/Attribute)
| 0 |
data/mdn-content/files/en-us/web/mathml/element | data/mdn-content/files/en-us/web/mathml/element/mphantom/index.md | ---
title: <mphantom>
slug: Web/MathML/Element/mphantom
page-type: mathml-element
browser-compat: mathml.elements.mphantom
---
{{MathMLRef}}
The **`<mphantom>`** [MathML](/en-US/docs/Web/MathML) element is rendered invisibly, but dimensions (such as height, width, and baseline position) are still kept.
## Attributes
This element accepts the [global MathML attributes](/en-US/docs/Web/MathML/Global_attributes).
## Examples
```html
<math display="block">
<mrow>
<mi>x</mi>
<mo>+</mo>
<mphantom>
<mi>y</mi>
<mo>+</mo>
</mphantom>
<mi>z</mi>
</mrow>
</math>
```
{{EmbedLiveSample('Examples')}}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{ MathMLElement("mspace") }}
- {{ MathMLElement("mpadded") }}
| 0 |
data/mdn-content/files/en-us/web/mathml/element | data/mdn-content/files/en-us/web/mathml/element/merror/index.md | ---
title: <merror>
slug: Web/MathML/Element/merror
page-type: mathml-element
browser-compat: mathml.elements.merror
---
{{MathMLRef}}
The **`<merror>`** [MathML](/en-US/docs/Web/MathML) element is used to display contents as error messages. The intent of this element is to provide a standard way for programs that generate MathML from other input to report syntax errors.
## Attributes
This element accepts the [global MathML attributes](/en-US/docs/Web/MathML/Global_attributes).
## Examples
In the following example, `<merror>` is used to indicate a parsing error for some LaTeX-like input:
```html
<math display="block">
<mfrac>
<merror>
<mtext>Syntax error: \frac{1}</mtext>
</merror>
<mn>3</mn>
</mfrac>
</math>
```
{{ EmbedLiveSample('merror_example', 700, 200, "", "") }}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/mathml/element | data/mdn-content/files/en-us/web/mathml/element/maction/index.md | ---
title: <maction>
slug: Web/MathML/Element/maction
page-type: mathml-element
status:
- deprecated
browser-compat: mathml.elements.maction
---
{{MathMLRef}}{{Deprecated_Header}}
The **`<maction>`** [MathML](/en-US/docs/Web/MathML) element allows to bind actions to mathematical expressions. By default, only the first child is rendered but some browsers may take into account `actiontype` and `selection` attributes to implement custom behaviors.
> **Note:** Historically, this element provided a mechanism to make MathML formulas interactive. Nowadays, it is recommended to rely on [JavaScript](/en-US/docs/Web/JavaScript) and other Web technologies to implement this use case.
## Attributes
This element's attributes include the [global MathML attributes](/en-US/docs/Web/MathML/Global_attributes) as well as the following attributes:
- `actiontype` {{Deprecated_Inline}} {{Non-standard_Inline}}
- : The action which specifies what happens for this element. Special behavior
for the following values were implemented by some browsers:
- `statusline`: If there is a click on the _expression_ or the reader moves the pointer over it, the _message_ is sent to the browser's status line. The syntax is: `<maction actiontype="statusline"> expression message </maction>`.
- `toggle`: When there is a click on the subexpression, the rendering alternates the display of selected subexpressions. Therefore each click increments the `selection` value.
The syntax is: `<maction actiontype="toggle" selection="positive-integer" > expression1 expression2 expressionN </maction>`.
- `selection` {{Deprecated_Inline}} {{Non-standard_Inline}}
- : The child element currently visible, only taken into account for `actiontype="toggle"` or non-standard `actiontype` values. The default value is `1`, which is the first child element.
## Examples
The following example uses the "toggle" `actiontype`:
```html
<p>
Try clicking this formula several times:
<math display="block">
<maction actiontype="toggle">
<mfrac>
<mn>6</mn>
<mn>8</mn>
</mfrac>
<mfrac>
<mrow>
<mn>3</mn>
<mo>×</mo>
<mn>2</mn>
</mrow>
<mrow>
<mn>4</mn>
<mo>×</mo>
<mn>2</mn>
</mrow>
</mfrac>
<mfrac>
<mn>3</mn>
<mn>4</mn>
</mfrac>
</maction>
</math>
</p>
```
{{EmbedLiveSample('Examples', 700, 200)}}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/mathml/element | data/mdn-content/files/en-us/web/mathml/element/mrow/index.md | ---
title: <mrow>
slug: Web/MathML/Element/mrow
page-type: mathml-element
browser-compat: mathml.elements.mrow
---
{{MathMLRef}}
The **`<mrow>`** [MathML](/en-US/docs/Web/MathML) element is used to group sub-expressions, which usually contain one or more [operators](/en-US/docs/Web/MathML/Element/mo) with their respective operands (such as {{ MathMLElement("mi") }} and {{ MathMLElement("mn") }}). This element renders as a horizontal row containing its arguments.
When writing a MathML expression, you should group elements within an `<mrow>` in the same way as they are grouped in the mathematical interpretation of the expression. Proper grouping helps the rendering of the expression in several ways:
- It can improve the display by possibly affecting spacing and preventing line breaks.
- It simplifies the interpretation of the expression by automated systems such as computer algebra systems and audio renderers.
## Attributes
This element accepts the [global MathML attributes](/en-US/docs/Web/MathML/Global_attributes).
## Examples
```html
<math display="block">
<mfrac>
<mrow>
<!-- numerator content grouped in one mrow -->
<mn>1</mn>
<mo>+</mo>
<mi>K</mi>
</mrow>
<mrow>
<!-- denominator content grouped in one mrow -->
<mn>3</mn>
<mrow>
<!-- fenced expression grouped in one mrow -->
<mo>(</mo>
<mrow>
<!-- fenced content grouped in one mrow -->
<mi>x</mi>
<mo>+</mo>
<mi>y</mi>
</mrow>
<mo>)</mo>
</mrow>
</mrow>
</mfrac>
</math>
```
{{EmbedLiveSample('Examples')}}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- Grouping HTML elements: {{ HTMLElement("div") }}
| 0 |
data/mdn-content/files/en-us/web/mathml/element | data/mdn-content/files/en-us/web/mathml/element/msup/index.md | ---
title: <msup>
slug: Web/MathML/Element/msup
page-type: mathml-element
browser-compat: mathml.elements.msup
---
{{MathMLRef}}
The **`<msup>`** [MathML](/en-US/docs/Web/MathML) element is used to attach a superscript to an expression.
It uses the following syntax: `<msup> base superscript </msup>`.
## Attributes
This element's attributes include the [global MathML attributes](/en-US/docs/Web/MathML/Global_attributes) as well as the following deprecated attribute:
- `superscriptshift` {{deprecated_inline}} {{Non-standard_Inline}}
- : A {{cssxref("length-percentage")}} indicating the minimum amount to shift the baseline of the superscript up.
> **Note:** For the `superscriptshift` attribute, some browsers may also accept [legacy MathML lengths](/en-US/docs/Web/MathML/Values#legacy_mathml_lengths).
## Examples
```html
<math display="block">
<msup>
<mi>X</mi>
<mn>2</mn>
</msup>
</math>
```
{{EmbedLiveSample('Examples')}}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{ MathMLElement("msub") }} (Subscript)
- {{ MathMLElement("msubsup") }} (Subscript-superscript pair)
- {{ MathMLElement("mmultiscripts") }} (Prescripts and tensor indices)
| 0 |
data/mdn-content/files/en-us/web/mathml/element | data/mdn-content/files/en-us/web/mathml/element/msubsup/index.md | ---
title: <msubsup>
slug: Web/MathML/Element/msubsup
page-type: mathml-element
browser-compat: mathml.elements.msubsup
---
{{MathMLRef}}
The **`<msubsup>`** [MathML](/en-US/docs/Web/MathML) element is used to attach both a subscript and a superscript, together, to an expression.
It uses the following syntax: `<msubsup> base subscript superscript </msubsup>`.
## Attributes
This element's attributes include the [global MathML attributes](/en-US/docs/Web/MathML/Global_attributes) as well as the following deprecated attributes:
- `subscriptshift` {{deprecated_inline}} {{Non-standard_Inline}}
- : A {{cssxref("length-percentage")}} indicating the minimum amount to shift the baseline of the subscript down.
- `superscriptshift` {{deprecated_inline}} {{Non-standard_Inline}}
- : A {{cssxref("length-percentage")}} indicating the minimum amount to shift the baseline of the superscript up.
> **Note:** For the `subscriptshift` and `superscriptshift` attributes, some browsers may also accept [legacy MathML lengths](/en-US/docs/Web/MathML/Values#legacy_mathml_lengths).
## Examples
```html
<math display="block">
<msubsup>
<mo>∫<!--Integral --></mo>
<mn>0</mn>
<mn>1</mn>
</msubsup>
</math>
```
{{EmbedLiveSample('Examples')}}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{ MathMLElement("msub") }} (Subscript)
- {{ MathMLElement("msup") }} (Superscript)
- {{ MathMLElement("mmultiscripts") }} (Prescripts and tensor indices)
| 0 |
data/mdn-content/files/en-us/web/mathml/element | data/mdn-content/files/en-us/web/mathml/element/mmultiscripts/index.md | ---
title: <mmultiscripts>
slug: Web/MathML/Element/mmultiscripts
page-type: mathml-element
browser-compat: mathml.elements.mmultiscripts
---
{{MathMLRef}}
The **`<mmultiscripts>`** [MathML](/en-US/docs/Web/MathML) element is used to attach an arbitrary number of subscripts and superscripts to an expression at once, generalizing the {{ MathMLElement("msubsup") }} element. Scripts can be either prescripts (placed before the expression) or postscripts (placed after it).
MathML uses the syntax below, that is a base expression, followed by an arbitrary number of postsubscript-postsuperscript pairs (attached in the given order) optionally followed by an `<mprescripts>` and an arbitrary number of presubscript-presuperscript pairs (attached in the given order). In addition, empty `<mrow>` elements can be used to represent absent scripts.
```html-nolint
<mmultiscripts>
base
postsubscript1 postsuperscript1
postsubscript2 postsuperscript2
postsubscript3 postsuperscript3
...
postsubscriptN postsuperscriptN
<mprescripts/> ⎫
presubscript1 presuperscript1 ⎪
presubscript2 presuperscript2 ⎬ Optional
presubscript3 presuperscript3 ⎪
... ⎪
presubscriptM presuperscriptM ⎭
</mmultiscripts>
```
## Attributes
This element's attributes include the [global MathML attributes](/en-US/docs/Web/MathML/Global_attributes) as well as the following deprecated attributes:
- `subscriptshift` {{deprecated_inline}} {{Non-standard_Inline}}
- : A {{cssxref("length-percentage")}} indicating the minimum amount to shift the baseline of the subscript down.
- `superscriptshift` {{deprecated_inline}} {{Non-standard_Inline}}
- : A {{cssxref("length-percentage")}} indicating the minimum amount to shift the baseline of the superscript up.
> **Note:** For the `subscriptshift` and `superscriptshift` attributes, some browsers may also accept [legacy MathML lengths](/en-US/docs/Web/MathML/Values#legacy_mathml_lengths).
## Examples
### Using `<mprescripts/>`
Children after the `<mprescripts/>` element are placed as pre-scripts (before the base expression):
```html-nolint
<math display="block">
<mmultiscripts>
<mi>X</mi> <!-- base expression -->
<mi>d</mi> <!-- postsubscript -->
<mi>c</mi> <!-- postsuperscript -->
<mprescripts />
<mi>b</mi> <!-- presubscript -->
<mi>a</mi> <!-- presuperscript -->
</mmultiscripts>
</math>
```
{{ EmbedLiveSample('mprescripts_example', 700, 200, "", "") }}
### Empty scripts
Empty `<mrow>` elements can be used to represent absent scripts:
```html-nolint
<math display="block">
<mmultiscripts>
<mi>X</mi> <!-- base expression -->
<mrow></mrow> <!-- postsubscript -->
<mi>c</mi> <!-- postsuperscript -->
<mprescripts />
<mi>b</mi> <!-- presubscript -->
<mrow></mrow> <!-- presuperscript -->
</mmultiscripts>
</math>
```
{{ EmbedLiveSample('none_example', 700, 200, "", "") }}
### Order of scripts
Here is a more complex example with many scripts, so you can see in which order they are attached to the base:
```html
<math display="block">
<mmultiscripts>
<mtext>base</mtext>
<mtext>postsubscript1</mtext>
<mtext>postsupscript1</mtext>
<mtext>postsubscript2</mtext>
<mtext>postsupscript2</mtext>
<mtext>postsubscript3</mtext>
<mtext>postsupscript3</mtext>
<mtext>postsubscript4</mtext>
<mtext>postsupscript4</mtext>
<mprescripts />
<mtext>presubscript1</mtext>
<mtext>presupscript1</mtext>
<mtext>presubscript2</mtext>
<mtext>presupscript2</mtext>
<mtext>presubscript3</mtext>
<mtext>presupscript3</mtext>
</mmultiscripts>
</math>
```
{{ EmbedLiveSample('order_of_scripts_example', 700, 200, "", "") }}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{ MathMLElement("msub") }} (Subscript)
- {{ MathMLElement("msup") }} (Superscript)
- {{ MathMLElement("msubsup") }} (Subscript-superscript pair)
| 0 |
data/mdn-content/files/en-us/web/mathml/element | data/mdn-content/files/en-us/web/mathml/element/mtext/index.md | ---
title: <mtext>
slug: Web/MathML/Element/mtext
page-type: mathml-element
browser-compat: mathml.elements.mtext
---
{{MathMLRef}}
The **`<mtext>`** [MathML](/en-US/docs/Web/MathML) element is used to render arbitrary text with _no_ notational meaning, such as comments or annotations.
To display text _with_ notational meaning, use {{ MathMLElement("mi") }}, {{ MathMLElement("mn") }}, {{ MathMLElement("mo") }} or {{ MathMLElement("ms") }} instead.
## Attributes
This element accepts the [global MathML attributes](/en-US/docs/Web/MathML/Global_attributes).
## Examples
```html
<math display="block">
<mtext>Theorem of Pythagoras</mtext>
</math>
<math display="block">
<mtext>/* comment here */</mtext>
</math>
```
{{ EmbedLiveSample('mtext_example', 700, 200, "", "") }}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/mathml/element | data/mdn-content/files/en-us/web/mathml/element/mtr/index.md | ---
title: <mtr>
slug: Web/MathML/Element/mtr
page-type: mathml-element
browser-compat: mathml.elements.mtr
---
{{MathMLRef}}
The **`<mtr>`** [MathML](/en-US/docs/Web/MathML) element represents a row in a table or a matrix. It may only appear in a {{ MathMLElement("mtable") }} element and its children are {{ MathMLElement("mtd") }} elements representing cells. This element is similar to the {{ HTMLElement("tr") }} element of [HTML](/en-US/docs/Web/HTML).
## Attributes
This element's attributes include the [global MathML attributes](/en-US/docs/Web/MathML/Global_attributes). Some browsers may also support the following attributes:
- `columnalign` {{Non-standard_Inline}}
- : Overrides the horizontal alignment of cells specified by {{ MathMLElement("mtable") }} for this row. Multiple values separated by space are allowed and apply to the corresponding columns (e.g. `columnalign="left center right"`). Possible values are: `left`, `center` and `right`.
- `rowalign` {{Non-standard_Inline}}
- : Overrides the vertical alignment of cells specified by {{ MathMLElement("mtable") }} for this row. Possible values are: `axis`, `baseline`, `bottom`, `center` and `top`.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{ MathMLElement("mtable") }}
- {{ MathMLElement("mtd") }}
| 0 |
data/mdn-content/files/en-us/web/mathml/element | data/mdn-content/files/en-us/web/mathml/element/mn/index.md | ---
title: <mn>
slug: Web/MathML/Element/mn
page-type: mathml-element
browser-compat: mathml.elements.mn
---
{{MathMLRef}}
The **`<mn>`** [MathML](/en-US/docs/Web/MathML) element represents a **numeric** literal which is normally a sequence of digits with a possible separator (a dot or a comma). However, it is also allowed to have arbitrary text in it which is actually a numeric quantity, for example "eleven".
## Attributes
This element accepts the [global MathML attributes](/en-US/docs/Web/MathML/Global_attributes).
## Examples
```html
<math display="block">
<mn>0</mn>
</math>
<math display="block">
<mn>1.337</mn>
</math>
<math display="block">
<mn>twelve</mn>
</math>
<math display="block">
<mn>XVI</mn>
</math>
<math display="block">
<mn>2e10</mn>
</math>
```
{{ EmbedLiveSample('mi_example', 700, 200, "", "") }}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/mathml/element | data/mdn-content/files/en-us/web/mathml/element/mstyle/index.md | ---
title: <mstyle>
slug: Web/MathML/Element/mstyle
page-type: mathml-element
browser-compat: mathml.elements.mstyle
---
{{MathMLRef}}
The **`<mstyle>`** [MathML](/en-US/docs/Web/MathML) element is used to change the style of its children.
> **Note:** Historically, this element accepted almost all the MathML attributes and it was used to override the default attribute values of its descendants. It was later restricted to only a few relevant styling attributes that were used in existing web pages. Nowadays, these styling attributes are [common to all MathML elements](/en-US/docs/Web/MathML/Global_attributes) and so `<mstyle>` is really just equivalent to an [`<mrow>`](/en-US/docs/Web/MathML/Element/mrow) element. However, `<mstyle>` may still be relevant for compatibility with MathML implementations outside browsers.
## Attributes
This element's attributes include the [global MathML attributes](/en-US/docs/Web/MathML/Global_attributes) as well as the following deprecated attributes:
- `background` {{deprecated_inline}} {{Non-standard_Inline}}
- : Use <a href="/en-US/docs/Web/CSS/background-color"><code>background-color</code></a> instead.
- `color` {{deprecated_inline}} {{Non-standard_Inline}}
- : Use <a href="/en-US/docs/Web/CSS/color"><code>color</code></a> instead.
- `fontsize` {{deprecated_inline}} {{Non-standard_Inline}}
- : Use <a href="/en-US/docs/Web/CSS/font-size"><code>font-size</code></a> instead.
- `fontstyle` {{deprecated_inline}} {{Non-standard_Inline}}
- : Use <a href="/en-US/docs/Web/CSS/font-style"><code>font-style</code></a> instead.
- `fontweight` {{deprecated_inline}} {{Non-standard_Inline}}
- : Use <a href="/en-US/docs/Web/CSS/font-weight"><code>font-weight</code></a> instead.
- `scriptminsize` {{deprecated_inline}} {{Non-standard_Inline}}
- : Specifies a minimum font size allowed due to changes in `scriptlevel`. The default value is `8pt`.
- `scriptsizemultiplier` {{deprecated_inline}} {{Non-standard_Inline}}
- : Specifies the multiplier to be used to adjust font size due to changes in `scriptlevel`. The default value is `0.71`.
## Examples
### Attributes mapped to CSS
The following example uses [global attributes](/en-US/docs/Web/MathML/Global_attributes) `displaystyle` and `mathcolor` to respectively override the [`math-style`](/en-US/docs/Web/CSS/math-style) and [`color`](/en-US/docs/Web/CSS/color) of the `<munder>` and `<munderover>` children:
```html
<math display="block">
<mstyle displaystyle="false" mathcolor="teal">
<munder>
<mo>∑</mo>
<mi>I</mi>
</munder>
<munderover>
<mo>∏</mo>
<mrow>
<mi>i</mi>
<mo>=</mo>
<mn>1</mn>
</mrow>
<mi>N</mi>
</munderover>
</mstyle>
</math>
```
{{EmbedLiveSample('Attributes mapped to CSS')}}
### Legacy script attributes
The following example shows a formula with [`font-size`](/en-US/docs/Web/CSS/font-size) set to `128pt`. It contains numbers that are placed in nested superscripts as well as an `<mstyle>` element with legacy attributes `scriptsizemultiplier` and `scriptminsize`. The `font-size` is multiplied by `0.5` when entering each superscript as long as that does not make it smaller than `16pt`.
```html
<math display="block" style="font-size: 128pt">
<mstyle scriptsizemultiplier="0.5" scriptminsize="16pt">
<msup>
<mn>2</mn>
<msup>
<mn>2</mn>
<msup>
<mn>2</mn>
<msup>
<mn>2</mn>
<msup>
<mn>2</mn>
<msup>
<mn>2</mn>
<mn>2</mn>
</msup>
</msup>
</msup>
</msup>
</msup>
</msup>
</mstyle>
</math>
```
{{EmbedLiveSample('Legacy script attributes', 700, 400)}}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/mathml/element | data/mdn-content/files/en-us/web/mathml/element/menclose/index.md | ---
title: <menclose>
slug: Web/MathML/Element/menclose
page-type: mathml-element
status:
- non-standard
browser-compat: mathml.elements.menclose
---
{{MathMLRef}}{{Non-standard_header}}
The **`<menclose>`** [MathML](/en-US/docs/Web/MathML) element renders its content inside an enclosing notation specified by the `notation` attribute.
## Attributes
This element's attributes include the [global MathML attributes](/en-US/docs/Web/MathML/Global_attributes).
- `notation` {{Non-standard_Inline}}
- : A list of notations, separated by white space, to apply to the child elements. The symbols are each drawn as if the others are not present, and therefore may overlap. Possible values are:
| Value | Sample Rendering | Rendering in your browser | Description |
| -------------------- | ----------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------- |
| `longdiv` (default) |  | <math><menclose notation="longdiv"><msup><mi>a</mi><mn>2</mn></msup> <mo>+</mo> <msup><mi>b</mi><mn>2</mn></msup></menclose></math> | long division symbol |
| `actuarial` |  | <math><menclose notation="actuarial"><msup><mi>a</mi><mn>2</mn></msup> <mo>+</mo> <msup><mi>b</mi><mn>2</mn></msup></menclose></math> | [actuarial symbol](https://en.wikipedia.org/wiki/Actuarial_notation) |
| `box` |  | <math><menclose notation="box"><msup><mi>a</mi><mn>2</mn></msup> <mo>+</mo> <msup><mi>b</mi><mn>2</mn></msup></menclose></math> | box |
| `roundedbox` |  | <math><menclose notation="roundedbox"><msup><mi>a</mi><mn>2</mn></msup> <mo>+</mo> <msup><mi>b</mi><mn>2</mn></msup></menclose></math> | rounded box |
| `circle` |  | <math><menclose notation="circle"><msup><mi>a</mi><mn>2</mn></msup> <mo>+</mo> <msup><mi>b</mi><mn>2</mn></msup></menclose></math> | circle |
| `left` |  | <math><menclose notation="left"><msup><mi>a</mi><mn>2</mn></msup> <mo>+</mo> <msup><mi>b</mi><mn>2</mn></msup></menclose></math> | line to the left of the contents |
| `right` |  | <math><menclose notation="right"><msup><mi>a</mi><mn>2</mn></msup> <mo>+</mo> <msup><mi>b</mi><mn>2</mn></msup></menclose></math> | line to the right of the contents |
| `top` |  | <math><menclose notation="top"><msup><mi>a</mi><mn>2</mn></msup> <mo>+</mo> <msup><mi>b</mi><mn>2</mn></msup></menclose></math> | line above of the contents |
| `bottom` |  | <math><menclose notation="bottom"><msup><mi>a</mi><mn>2</mn></msup> <mo>+</mo> <msup><mi>b</mi><mn>2</mn></msup></menclose></math> | line below of the contents |
| `updiagonalstrike` |  | <math><menclose notation="updiagonalstrike"><msup><mi>a</mi><mn>2</mn></msup> <mo>+</mo> <msup><mi>b</mi><mn>2</mn></msup></menclose></math> | strikeout line through contents from lower left to upper right |
| `downdiagonalstrike` |  | <math><menclose notation="downdiagonalstrike"><msup><mi>a</mi><mn>2</mn></msup> <mo>+</mo> <msup><mi>b</mi><mn>2</mn></msup></menclose></math> | strikeout line through contents from upper left to lower right |
| `verticalstrike` |  | <math><menclose notation="verticalstrike"><msup><mi>a</mi><mn>2</mn></msup> <mo>+</mo> <msup><mi>b</mi><mn>2</mn></msup></menclose></math> | vertical strikeout line through contents |
| `horizontalstrike` |  | <math><menclose notation="horizontalstrike"><msup><mi>a</mi><mn>2</mn></msup> <mo>+</mo> <msup><mi>b</mi><mn>2</mn></msup></menclose></math> | horizontal strikeout line through contents |
| `madruwb` |  | <math><menclose notation="madruwb"><msup><mi>a</mi><mn>2</mn></msup> <mo>+</mo> <msup><mi>b</mi><mn>2</mn></msup></menclose></math> | [Arabic factorial symbol](https://en.wikipedia.org/wiki/Modern_Arabic_mathematical_notation#Arithmetic_and_algebra) |
| `updiagonalarrow` |  | <math><menclose notation="updiagonalarrow"><msup><mi>a</mi><mn>2</mn></msup> <mo>+</mo> <msup><mi>b</mi><mn>2</mn></msup></menclose></math> | diagonal arrow |
| `phasorangle` |  | <math><menclose notation="phasorangle"><msup><mi>a</mi><mn>2</mn></msup> <mo>+</mo> <msup><mi>b</mi><mn>2</mn></msup></menclose></math> | phasor angle |
## Examples
```html
<math display="block">
<menclose notation="circle box">
<mi>x</mi>
<mo>+</mo>
<mi>y</mi>
</menclose>
</math>
```
{{ EmbedLiveSample('menclose_example', 700, 200, "", "") }}
## Specifications
The `<menclose>` element is not defined in any browser-oriented specification but you can find a description in [MathML 4](https://w3c.github.io/mathml/#presm_menclose).
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/mathml/element | data/mdn-content/files/en-us/web/mathml/element/semantics/index.md | ---
title: <semantics>
slug: Web/MathML/Element/semantics
page-type: mathml-element
browser-compat: mathml.elements.semantics
---
{{MathMLRef}}
The **`<semantics>`** [MathML](/en-US/docs/Web/MathML) element associates annotations with a MathML expression, for example its text source as a [lightweight markup language](https://en.wikipedia.org/wiki/Lightweight_markup_language) or mathematical meaning expressed in a special {{glossary("XML")}} dialect. Typically, its structure is:
- a first child which is a MathML expression to be annotated.
- subsequent `<annotation>` or `<annotation-xml>` elements, the latter being reserved for XML formats such as [OpenMath](https://en.wikipedia.org/wiki/OpenMath).
By default, only the first child of the `<semantics>` element is rendered while the others have their [display](/en-US/docs/Web/CSS/display) set to `none`.
> **Note:** Legacy MathML specifications allowed renderers to decide the default rendering according to available annotations. The following rules for determining the visible child have been implemented in some browsers. See [MathML 4](https://w3c.github.io/mathml/) for the distinction between Presentation and Content MathML.
>
> - If no other rules apply: By default only the first child is rendered, which is supposed to be Presentation MathML.
> - If the first child is a Presentation MathML element other than `<annotation>` or `<annotation-xml>`, render the first child.
> - If no Presentation MathML is found, render the first `<annotation>` or `<annotation-xml>` child element of `<semantics>` without a `src` attribute. For `<annotation-xml>` elements the `encoding` attribute must be equal to one of following values:
> - `"application/mathml-presentation+xml"`
> - `"MathML-Presentation"`
> - `"SVG1.1"`
> - `"text/html"`
> - `"image/svg+xml"`
> - `"application/xml`".
>
> Note that `"application/mathml+xml"` is _not_ mentioned here as it does not distinguish between Content or Presentation MathML.
## Attributes
`<semantics>`, `<annotation>` and `<annotation-xml>` elements accept the [global MathML attributes](/en-US/docs/Web/MathML/Global_attributes). Additionally, the following attributes can be set on the `<annotation>` and `<annotation-xml>` elements:
- `encoding`
- : The encoding of the semantic information in the annotation (e.g. `"MathML-Content"`, `"MathML-Presentation"`, `"application/openmath+xml"`, `"image/png"`)
- `src` {{deprecated_inline}}
- : The location of an external source for semantic information.
## Example
```html
<math display="block">
<semantics>
<!-- The first child is the MathML expression rendered by default. -->
<mrow>
<msup>
<mi>x</mi>
<mn>2</mn>
</msup>
<mo>+</mo>
<mi>y</mi>
</mrow>
<!-- Annotate with "Content MathML", a dedicated XML dialect to
express the meaning of mathematical formulas. -->
<annotation-xml encoding="MathML-Content">
<apply>
<plus />
<apply>
<power />
<ci>x</ci>
<cn type="integer">2</cn>
</apply>
<ci>y</ci>
</apply>
</annotation-xml>
<!-- Annotate with a PNG image of the formula. -->
<annotation encoding="image/png" src="some/path/formula.png" />
<!-- Annotate with LaTeX, a lightweight markup language to write
mathematical formulas. -->
<annotation encoding="application/x-tex"> x^{2} + y </annotation>
</semantics>
</math>
```
{{ EmbedLiveSample('semantics_example', 700, 200, "", "") }}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/mathml/element | data/mdn-content/files/en-us/web/mathml/element/mspace/index.md | ---
title: <mspace>
slug: Web/MathML/Element/mspace
page-type: mathml-element
browser-compat: mathml.elements.mspace
---
{{MathMLRef}}
The **`<mspace>`** [MathML](/en-US/docs/Web/MathML) element is used to display a blank space, whose size is set by its attributes.
## Attributes
This element's attributes include the [global MathML attributes](/en-US/docs/Web/MathML/Global_attributes) as well as the following attributes:
- `depth`
- : A {{cssxref("length-percentage")}} indicating the desired depth (below the baseline) of the space.
- `height`
- : A {{cssxref("length-percentage")}} indicating the desired height (above the baseline) of the space.
- `width`
- : A {{cssxref("length-percentage")}} indicating the desired width of the space.
> **Note:** For the `depth`, `height`, `width` attributes, some browsers may also accept [legacy MathML lengths](/en-US/docs/Web/MathML/Values#legacy_mathml_lengths).
## Examples
```html-nolint
<math display="block">
<mn>1</mn>
<mspace depth="40px" height="20px" width="100px"
style="background: lightblue;"/>
<mn>2</mn>
</math>
```
{{EmbedLiveSample('Examples')}}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{ MathMLElement("mpadded") }}
- {{ MathMLElement("mphantom") }}
| 0 |
data/mdn-content/files/en-us/web/mathml/element | data/mdn-content/files/en-us/web/mathml/element/ms/index.md | ---
title: <ms>
slug: Web/MathML/Element/ms
page-type: mathml-element
browser-compat: mathml.elements.ms
---
{{MathMLRef}}
The **`<ms>`** [MathML](/en-US/docs/Web/MathML) element represents a **string** literal meant to be interpreted by programming languages and computer algebra systems.
## Attributes
This element's attributes include the [global MathML attributes](/en-US/docs/Web/MathML/Global_attributes).
Some browsers may also support the following deprecated attributes and will render the content of the `<ms>` element surrounded by the specified opening and closing quotes:
- `lquote`
- : The opening quote to enclose the content. The default value is `"`.
- `rquote`
- : The closing quote to enclose the content. The default value is `"`.
## Examples
### Default rendering
```html
<math display="block">
<ms>Hello World!</ms>
</math>
```
{{ EmbedLiveSample('default_rendering', 700, 200, "", "") }}
### Legacy quote attributes
```html
<math display="block">
<ms lquote="„" rquote="'">abc</ms>
</math>
```
{{ EmbedLiveSample('legacy_quote_attributes', 700, 200, "", "") }}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/mathml/element | data/mdn-content/files/en-us/web/mathml/element/mfrac/index.md | ---
title: <mfrac>
slug: Web/MathML/Element/mfrac
page-type: mathml-element
browser-compat: mathml.elements.mfrac
---
{{MathMLRef}}
The **`<mfrac>`** [MathML](/en-US/docs/Web/MathML) element is used to display fractions. It can also be used
to mark up fraction-like objects such as
[binomial coefficients](https://en.wikipedia.org/wiki/Binomial_coefficient)
and [Legendre symbols](https://en.wikipedia.org/wiki/Legendre_symbol).
## Syntax
```html
<mfrac>numerator denominator</mfrac>
```
## Attributes
This element's attributes include the [global MathML attributes](/en-US/docs/Web/MathML/Global_attributes) as well as the following attributes:
- `denomalign` {{deprecated_inline}} {{Non-standard_Inline}}
- : The alignment of the denominator under the fraction. Possible values are: `left`, `center` (default), and `right`.
- `linethickness`
- : A {{cssxref("length-percentage")}} indicating the thickness of the horizontal fraction line.
- `numalign` {{deprecated_inline}} {{Non-standard_Inline}}
- : The alignment of the numerator over the fraction. Possible values are: `left`, `center` (default), and `right`.
> **Note:** For the `linethickness` attribute, some browsers may also accept the deprecated values `medium`, `thin` and `thick` (whose exact interpretation is left to implementers) or [legacy MathML lengths](/en-US/docs/Web/MathML/Values#legacy_mathml_lengths).
## Examples
### Simple fraction
The following MathML code should render as a fraction with numerator "a + 2" and
denominator "3 − b":
```html
<math display="block">
<mfrac>
<mrow>
<mi>a</mi>
<mo>+</mo>
<mn>2</mn>
</mrow>
<mrow>
<mn>3</mn>
<mo>−</mo>
<mi>b</mi>
</mrow>
</mfrac>
</math>
```
{{ EmbedLiveSample('simple_fraction', 700, 200, "", "") }}
### Fraction without bar
The following MathML code should render as a [binomial coefficient](https://en.wikipedia.org/wiki/Binomial_coefficient):
```html
<math display="block">
<mrow>
<mo>(</mo>
<mfrac linethickness="0">
<mi>n</mi>
<mi>k</mi>
</mfrac>
<mo>)</mo>
</mrow>
</math>
```
{{ EmbedLiveSample('Fraction_without_bar', 700, 200, "", "") }}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/mathml/element | data/mdn-content/files/en-us/web/mathml/element/msub/index.md | ---
title: <msub>
slug: Web/MathML/Element/msub
page-type: mathml-element
browser-compat: mathml.elements.msub
---
{{MathMLRef}}
The **`<msub>`** [MathML](/en-US/docs/Web/MathML) element is used to attach a subscript to an expression.
It uses the following syntax: `<msub> base subscript </msub>`.
## Attributes
This element's attributes include the [global MathML attributes](/en-US/docs/Web/MathML/Global_attributes) as well as the following deprecated attribute:
- `subscriptshift` {{deprecated_inline}} {{Non-standard_Inline}}
- : A {{cssxref("length-percentage")}} indicating the minimum amount to shift the baseline of the subscript down.
> **Note:** For the `subscriptshift` attribute, some browsers may also accept [legacy MathML lengths](/en-US/docs/Web/MathML/Values#legacy_mathml_lengths).
## Examples
```html
<math display="block">
<msub>
<mi>X</mi>
<mn>1</mn>
</msub>
</math>
```
{{EmbedLiveSample('Examples')}}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{ MathMLElement("msup") }} (Superscript)
- {{ MathMLElement("msubsup") }} (Subscript-superscript pair)
- {{ MathMLElement("mmultiscripts") }} (Prescripts and tensor indices)
| 0 |
data/mdn-content/files/en-us/web/mathml/element | data/mdn-content/files/en-us/web/mathml/element/mover/index.md | ---
title: <mover>
slug: Web/MathML/Element/mover
page-type: mathml-element
browser-compat: mathml.elements.mover
---
{{MathMLRef}}
The **`<mover>`** [MathML](/en-US/docs/Web/MathML) element is used to attach an accent or a limit over an expression. Use the following syntax: `<mover> base overscript </mover>`
## Attributes
This element's attributes include the [global MathML attributes](/en-US/docs/Web/MathML/Global_attributes) as well as the following attribute:
- `accent`
- : A [`<boolean>`](/en-US/docs/Web/MathML/Values#mathml-specific_types) indicating whether the over script should be treated as an accent (i.e. drawn bigger and closer to the base expression).
## Examples
```html
<math display="block">
<mover accent="true">
<mrow>
<mi>x</mi>
<mo>+</mo>
<mi>y</mi>
<mo>+</mo>
<mi>z</mi>
</mrow>
<mo>⏞<!--TOP CURLY BRACKET--></mo>
</mover>
</math>
```
{{ EmbedLiveSample('mover_example', 700, 200, "", "") }}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{ MathMLElement("munder") }} (Underscript)
- {{ MathMLElement("munderover") }} (Underscript-overscript pair)
| 0 |
data/mdn-content/files/en-us/web/mathml/element | data/mdn-content/files/en-us/web/mathml/element/mtable/index.md | ---
title: <mtable>
slug: Web/MathML/Element/mtable
page-type: mathml-element
browser-compat: mathml.elements.mtable
---
{{MathMLRef}}
The **`<mtable>`** [MathML](/en-US/docs/Web/MathML) element allows you to create tables or matrices. Its children are {{ MathMLElement("mtr") }} elements (representing rows), each of them having {{ MathMLElement("mtd") }} elements as its children (representing cells). These elements are similar to {{ HTMLElement("table") }}, {{ HTMLElement("tr") }} and {{ HTMLElement("td") }} elements of [HTML](/en-US/docs/Web/HTML).
## Attributes
This element's attributes include the [global MathML attributes](/en-US/docs/Web/MathML/Global_attributes). Some browsers may also support the following attributes:
- `align` {{Non-standard_Inline}}
- : Specifies the **vertical** alignment of the table with respect to its environment.
Possible values are:
- `axis` (default): The vertical center of the table aligns on the environment's axis (typically the minus sign).
- `baseline`: The vertical center of the table aligns on the environment's baseline.
- `bottom`: The bottom of the table aligns on the environments baseline.
- `center`: See baseline.
- `top`: The top of the table aligns on the environments baseline.
In addition, values of the `align` attribute can end with a _rownumber_ (e.g. `align="center 3"`). This allows you to align the specified row of the table rather than the whole table. A negative Integer value counts rows from the bottom of the table.
- `columnalign` {{Non-standard_Inline}}
- : Specifies the horizontal alignment of the cells. Multiple values separated by space are allowed and apply to the corresponding columns (e.g. `columnalign="left right center"`). Possible values are: `left`, `center` (default) and `right`.
- `columnlines` {{Non-standard_Inline}}
- : Specifies column borders. Multiple values separated by space are allowed and apply to the corresponding columns (e.g. `columnlines="none none solid"`). Possible values are: `none` (default), `solid` and `dashed`.
- `columnspacing` {{Non-standard_Inline}}
- : Specifies the space between table columns. Multiple values separated by space are allowed and apply to the corresponding columns (e.g. `columnspacing="1em 2em"`). Possible values are {{cssxref("length-percentage")}}.
- `frame` {{Non-standard_Inline}}
- : Specifies borders of the entire table. Possible values are: `none` (default), `solid` and `dashed`.
- `framespacing` {{Non-standard_Inline}}
- : Specifies additional space added between the table and frame. The first value specifies the spacing on the right and left; the second value specifies the spacing above and below. Possible values are {{cssxref("length-percentage")}}.
- `rowalign` {{Non-standard_Inline}}
- : Specifies the vertical alignment of the cells. Multiple values separated by space are allowed and apply to the corresponding rows (e.g. `rowalign="top bottom axis"`). Possible values are: `axis`, `baseline` (default), `bottom`, `center` and `top`.
- `rowlines` {{Non-standard_Inline}}
- : Specifies row borders. Multiple values separated by space are allowed and apply to the corresponding rows (e.g. `rowlines="none none solid"`). Possible values are: `none` (default), `solid` and `dashed`.
- `rowspacing` {{Non-standard_Inline}}
- : Specifies the space between table rows. Multiple values separated by space are allowed and apply to the corresponding rows (e.g. `rowspacing="1em 2em"`). Possible values are {{cssxref("length-percentage")}}.
- `width` {{Non-standard_Inline}}
- : A {{cssxref("length-percentage")}} indicating the width of the entire table.
> **Note:** For the `width` attribute, some browsers may also accept [legacy MathML lengths](/en-US/docs/Web/MathML/Values#legacy_mathml_lengths).
## Examples
### Alignment with row number
```html
<math display="block">
<mi>X</mi>
<mo>=</mo>
<mtable frame="solid" rowlines="solid" align="axis 3">
<mtr>
<mtd><mi>A</mi></mtd>
<mtd><mi>B</mi></mtd>
</mtr>
<mtr>
<mtd><mi>C</mi></mtd>
<mtd><mi>D</mi></mtd>
</mtr>
<mtr>
<mtd><mi>E</mi></mtd>
<mtd><mi>F</mi></mtd>
</mtr>
</mtable>
</math>
```
{{EmbedLiveSample('Alignment with row number')}}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{ MathMLElement("mtd") }} (Table cell)
- {{ MathMLElement("mtr") }} (Table row)
| 0 |
data/mdn-content/files/en-us/web/mathml/element | data/mdn-content/files/en-us/web/mathml/element/mfenced/index.md | ---
title: <mfenced>
slug: Web/MathML/Element/mfenced
page-type: mathml-element
status:
- deprecated
- non-standard
browser-compat: mathml.elements.mfenced
---
{{MathMLRef}}{{Deprecated_Header}}{{Non-standard_Header}}
The **`<mfenced>`** [MathML](/en-US/docs/Web/MathML) element provides the possibility to add custom opening and closing brackets (such as parenthese) and separators (such as commas or semicolons) to an expression.
> **Note:** Historically, the `<mfenced>` element was defined as a shorthand for writing fenced expressions and equivalent to an expanded form involving {{MathMLElement("mrow")}} and {{MathMLElement("mo")}} elements. Nowadays, it is recommended to use that equivalent form instead.
## Attributes
This element's attributes include the [global MathML attributes](/en-US/docs/Web/MathML/Global_attributes).
- `close`
- : A string for the closing delimiter. The default value is `")`" and any white space is trimmed.
- `open`
- : A string for the opening delimiter. The default value is `"("` and any white space is trimmed.
- `separators`
- : A sequence of zero or more characters to be used for different separators, optionally divided by white space, which is ignored. The default value is ",". By specifying more than one character, it is possible to set different separators for each argument in the expression. If there are too many separators, all excess is ignored. If there are too few separators in the expression, the last specified separator is repeated.
## Examples
### The last separator is repeated (`,`)
```html
<math display="block">
<mfenced open="{" close="}" separators=";;,">
<mi>a</mi>
<mi>b</mi>
<mi>c</mi>
<mi>d</mi>
<mi>e</mi>
</mfenced>
</math>
```
Sample rendering: 
Rendering in your browser:
{{ EmbedLiveSample('mfenced_example1', 700, 200, "", "") }}
### All excess is ignored (`,`)
```html
<math display="block">
<mfenced open="[" close="]" separators="||||,">
<mi>a</mi>
<mi>b</mi>
<mi>c</mi>
<mi>d</mi>
<mi>e</mi>
</mfenced>
</math>
```
Sample rendering: ![[a|b|c|d|e]](mfenced02.png)
Rendering in your browser:
{{ EmbedLiveSample('mfenced_example1', 700, 200, "", "") }}
## Specifications
The `<mfenced>` element is not defined in any browser-oriented specification but you can find a description in [MathML 4](https://w3c.github.io/mathml/#presm_mfenced).
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/mathml/element | data/mdn-content/files/en-us/web/mathml/element/mtd/index.md | ---
title: <mtd>
slug: Web/MathML/Element/mtd
page-type: mathml-element
browser-compat: mathml.elements.mtd
---
{{MathMLRef}}
The **`<mtd>`** [MathML](/en-US/docs/Web/MathML) element represents a cell in a table or a matrix. It may only appear in a {{ MathMLElement("mtr") }} element. This element is similar to the {{ HTMLElement("td") }} element of [HTML](/en-US/docs/Web/HTML).
## Attributes
This element's attributes include the [global MathML attributes](/en-US/docs/Web/MathML/Global_attributes) as well as the following attributes:
- `columnspan`
- : A non-negative integer value that indicates on how many columns does the cell extend.
- `rowspan`
- : A non-negative integer value that indicates on how many rows does the cell extend.
Some browsers may also support the following attributes:
- `columnalign` {{Non-standard_Inline}}
- : Specifies the horizontal alignment of this cell and overrides values specified by {{ MathMLElement("mtable") }} or {{ MathMLElement("mtr") }}.
Possible values are: `left`, `center` and `right`.
- `rowalign` {{Non-standard_Inline}}
- : Specifies the vertical alignment of this cell and overrides values specified by {{ MathMLElement("mtable") }} or {{ MathMLElement("mtr") }}.
Possible values are: `axis`, `baseline`, `bottom`, `center` and `top`.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{ MathMLElement("mtable") }}
- {{ MathMLElement("mtr") }}
| 0 |
data/mdn-content/files/en-us/web/mathml/element | data/mdn-content/files/en-us/web/mathml/element/mo/index.md | ---
title: <mo>
slug: Web/MathML/Element/mo
page-type: mathml-element
browser-compat: mathml.elements.mo
---
{{MathMLRef}}
The **`<mo>`** [MathML](/en-US/docs/Web/MathML) element represents an **operator** in a broad sense. Besides operators in strict mathematical meaning, this element also includes "operators" like parentheses, separators like comma and semicolon, or "absolute value" bars.
## Attributes
In addition to the [global MathML attributes](/en-US/docs/Web/MathML/Global_attributes), this element accepts the following attributes [whose default values depend on the operator's form and content](https://w3c.github.io/mathml-core/#algorithm-for-determining-the-properties-of-an-embellished-operator):
- `accent` {{Non-standard_Inline}}
- : A [`<boolean>`](/en-US/docs/Web/MathML/Values#mathml-specific_types) indicating whether the operator should be treated as an accent when used as an [under](/en-US/docs/Web/MathML/Element/munder)- or [overscript](/en-US/docs/Web/MathML/Element/mover) (i.e. drawn bigger and closer to the base expression).
- `fence`
- : A [`<boolean>`](/en-US/docs/Web/MathML/Values#mathml-specific_types) indicating whether the operator is a fence (such as parentheses). There is no visual effect for this attribute.
- `largeop`
- : A [`<boolean>`](/en-US/docs/Web/MathML/Values#mathml-specific_types) indicating whether the operator should be drawn bigger when [`math-style`](/en-US/docs/Web/CSS/math-style) is set to `normal`.
- `lspace`
- : A {{cssxref("length-percentage")}} indicating the amount of space before the operator.
- `maxsize`
- : A {{cssxref("length-percentage")}} indicating the maximum size of the operator when it is stretchy.
- `minsize`
- : A {{cssxref("length-percentage")}} indicating the minimum size of the operator when it is stretchy.
- `movablelimits`
- : A [`<boolean>`](/en-US/docs/Web/MathML/Values#mathml-specific_types) indicating whether attached under- and overscripts move to sub- and superscript positions when [`math-style`](/en-US/docs/Web/CSS/math-style) is set to `compact`.
- `rspace`
- : A {{cssxref("length-percentage")}} indicating the amount of space after the operator.
- `separator`
- : A [`<boolean>`](/en-US/docs/Web/MathML/Values#mathml-specific_types) indicating whether the operator is a separator (such as commas). There is no visual effect for this attribute.
- `stretchy`
- : A [`<boolean>`](/en-US/docs/Web/MathML/Values#mathml-specific_types) indicating whether the operator stretches to the size of the adjacent element.
- `symmetric`
- : A [`<boolean>`](/en-US/docs/Web/MathML/Values#mathml-specific_types) indicating whether a stretchy operator should be vertically symmetric around the imaginary math axis (centered fraction line).
> **Note:** For the `lspace`, `maxsize`, `minsize` and `rspace` attributes, some browsers may also accept [legacy MathML lengths](/en-US/docs/Web/MathML/Values#legacy_mathml_lengths).
## Examples
```html-nolint
<math display="block">
<mrow>
<mn>5</mn>
<mo>+</mo>
<mn>5</mn>
</mrow>
</math>
<math display="block">
<mrow>
<mo>[</mo> <!-- default form value: prefix -->
<mrow>
<mn>0</mn>
<mo>;</mo> <!-- default form value: infix -->
<mn>1</mn>
</mrow>
<mo>)</mo> <!-- default form value: postfix -->
</mrow>
</math>
```
{{ EmbedLiveSample('mo_example', 700, 200, "", "") }}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/mathml/element | data/mdn-content/files/en-us/web/mathml/element/mpadded/index.md | ---
title: <mpadded>
slug: Web/MathML/Element/mpadded
page-type: mathml-element
browser-compat: mathml.elements.mpadded
---
{{MathMLRef}}
The **`<mpadded>`** [MathML](/en-US/docs/Web/MathML) element is used to add extra padding and to set the general adjustment of position and size of enclosed contents.
## Attributes
This element's attributes include the [global MathML attributes](/en-US/docs/Web/MathML/Global_attributes) as well as the following attributes:
- `depth`
- : A {{cssxref("length-percentage")}} indicating the desired depth (below the baseline) of the `<mpadded>` element.
- `height`
- : A {{cssxref("length-percentage")}} indicating the desired height (above the baseline) of the `<mpadded>` element.
- `lspace`
- : A {{cssxref("length-percentage")}} indicating the horizontal location of the positioning point of the child content with respect to the positioning point of the `<mpadded>` element.
- `voffset`
- : A {{cssxref("length-percentage")}} indicating the vertical location of the positioning point of the child content with respect to the positioning point of the `<mpadded>` element.
- `width`
- : A {{cssxref("length-percentage")}} indicating the desired horizontal length of the `<mpadded>` element.
### Legacy syntax
For the `depth`, `height`, `lspace`, `voffset` and `width` attributes, some browsers may instead accept a more complex syntax:
1. An optional `+` or `-` sign as a prefix, specifying an increment or decrement to the corresponding dimension (if absent, the corresponding dimension is set directly to specified value).
2. Followed by an [`<unsigned-number>`](/en-US/docs/Web/MathML/Values#mathml-specific_types) (let's call it α below).
3. Optionally followed by a value (if absent, the specified value is interpreted as "100 times α percent").
- A [unit](/en-US/docs/Web/MathML/Values#units). The specified value is interpreted the same as [legacy MathML lengths](/en-US/docs/Web/MathML/Values#legacy_mathml_lengths).
- A [namedspace constant](/en-US/docs/Web/MathML/Values#constants). The specified value is interpreted as α times the constant.
- A pseudo-unit `width`, `height` or `depth`. The specified value is interpreted as α times the corresponding dimension of the content.
- A percent sign followed by a pseudo-unit `width`, `height` or `depth`. The specified value is interpreted as α% the corresponding dimension of the content.
## Examples
### Dimensions and offsets
```html-nolint
<math display="block">
<mpadded width="400px" height="5em" depth="4em"
lspace="300px" voffset="-2em"
style="background: lightblue">
<mi>x</mi>
<mo>+</mo>
<mi>y</mi>
</mpadded>
</math>
```
{{ EmbedLiveSample('dimensions_and_offsets_example', 700, 200, "", "") }}
### Legacy syntax
```html
<math display="block">
<!-- increment by a length -->
<mpadded width="+20px" style="background: lightblue">
<mtext>+20px</mtext>
</mpadded>
<!-- set to a pseudo-unit -->
<mpadded width="2width" style="background: lightgreen">
<mtext>2width</mtext>
</mpadded>
<!-- increment by a percent of a pseudo-unit -->
<mpadded width="+400%height" style="background: lightyellow">
<mtext>+400%height</mtext>
</mpadded>
<!-- decrement to a multiple of a namedspace -->
<mpadded width="-1thickmathspace" style="background: pink">
<mtext>-.5thickmathspace</mtext>
</mpadded>
</math>
```
{{ EmbedLiveSample('legacy_syntax_example', 700, 200, "", "") }}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{ MathMLElement("mphantom") }}
- {{ MathMLElement("mspace") }}
| 0 |
data/mdn-content/files/en-us/web/mathml/element | data/mdn-content/files/en-us/web/mathml/element/msqrt/index.md | ---
title: <msqrt>
slug: Web/MathML/Element/msqrt
page-type: mathml-element
browser-compat: mathml.elements.msqrt
---
{{MathMLRef}}
The **`<msqrt>`** [MathML](/en-US/docs/Web/MathML) element is used to display square roots (no index is displayed). The square root accepts only one argument, which leads to the following syntax: `<msqrt> base </msqrt>`.
## Attributes
This element accepts the [global MathML attributes](/en-US/docs/Web/MathML/Global_attributes).
## Examples
```html
<math display="block">
<msqrt>
<mi>x</mi>
</msqrt>
</math>
```
{{EmbedLiveSample('Examples')}}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{ MathMLElement("mroot") }} (Radical with an index)
| 0 |
data/mdn-content/files/en-us/web/mathml/element | data/mdn-content/files/en-us/web/mathml/element/munderover/index.md | ---
title: <munderover>
slug: Web/MathML/Element/munderover
page-type: mathml-element
browser-compat: mathml.elements.munderover
---
{{MathMLRef}}
The **`<munderover>`** [MathML](/en-US/docs/Web/MathML) element is used to attach accents or limits both under and over an expression.
It uses the following syntax: `<munderover> base underscript overscript </munderover>`
## Attributes
This element's attributes include the [global MathML attributes](/en-US/docs/Web/MathML/Global_attributes) as well as the following attributes:
- `accent`
- : A [`<boolean>`](/en-US/docs/Web/MathML/Values#mathml-specific_types) indicating whether the over script should be treated as an accent (i.e. drawn bigger and closer to the base expression).
- `accentunder`
- : A [`<boolean>`](/en-US/docs/Web/MathML/Values#mathml-specific_types) indicating whether the under script should be treated as an accent (i.e. drawn bigger and closer to the base expression).
## Examples
```html
<math display="block">
<munderover>
<mo>∑</mo>
<mrow>
<mi>n</mi>
<mo>=</mo>
<mn>1</mn>
</mrow>
<mrow>
<mo>+</mo>
<mn>∞</mn>
</mrow>
</munderover>
</math>
```
{{ EmbedLiveSample('munderover_example', 700, 200, "", "") }}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{ MathMLElement("munder") }} (Underscript)
- {{ MathMLElement("mover") }} (Overscript)
| 0 |
data/mdn-content/files/en-us/web/mathml/element | data/mdn-content/files/en-us/web/mathml/element/math/index.md | ---
title: <math>
slug: Web/MathML/Element/math
page-type: mathml-element
browser-compat: mathml.elements.math
---
{{MathMLRef}}
The **`<math>`** [MathML](/en-US/docs/Web/MathML) element is the top-level MathML element, used to write a single mathematical formula. It can be placed in HTML content where [flow content](/en-US/docs/Web/HTML/Content_categories#flow_content) is permitted.
> **Note:** See the [Authoring MathML page](/en-US/docs/Web/MathML/Authoring#using_mathml) for tips to properly integrate MathML formulas in your web pages and the [Examples](/en-US/docs/Web/MathML/Examples) page for more demos.
## Attributes
This element's attributes include the [global MathML attributes](/en-US/docs/Web/MathML/Global_attributes) as well as the following attribute:
- `display`
- : This [enumerated](/en-US/docs/Glossary/Enumerated) attribute specifies how the enclosed MathML markup should be rendered. It can have one of the following values:
- `block`, which means that this element will be displayed in its own block outside the current span of text and with [`math-style`](/en-US/docs/Web/CSS/math-style) set to `normal`.
- `inline`, which means that this element will be displayed inside the current span of text and with [`math-style`](/en-US/docs/Web/CSS/math-style) set to `compact`.
If not present, its default value is `inline`.
## Examples
This example contains two MathML formula. The first one is rendered in its own centered block, taking as much space as needed. The second one is rendered inside the paragraph of text, with reduced size and spacing in order to minimize its height.
```html
<p>
The infinite sum
<math display="block">
<mrow>
<munderover>
<mo>∑</mo>
<mrow>
<mi>n</mi>
<mo>=</mo>
<mn>1</mn>
</mrow>
<mrow>
<mo>+</mo>
<mn>∞</mn>
</mrow>
</munderover>
<mfrac>
<mn>1</mn>
<msup>
<mi>n</mi>
<mn>2</mn>
</msup>
</mfrac>
</mrow>
</math>
is equal to the real number
<math display="inline">
<mfrac>
<msup>
<mi>π</mi>
<mn>2</mn>
</msup>
<mn>6</mn>
</mfrac></math
>.
</p>
```
{{ EmbedLiveSample('math_example', 700, 200, "", "") }}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- HTML top-level element: {{ HTMLElement("html") }}
- SVG top-level element: {{ SVGElement("svg") }}
| 0 |
data/mdn-content/files/en-us/web/mathml/element | data/mdn-content/files/en-us/web/mathml/element/munder/index.md | ---
title: <munder>
slug: Web/MathML/Element/munder
page-type: mathml-element
browser-compat: mathml.elements.munder
---
{{MathMLRef}}
The **`<munder>`** [MathML](/en-US/docs/Web/MathML) element is used to attach an accent or a limit under an expression. It uses the following syntax: `<munder> base underscript </munder>`
## Attributes
This element's attributes include the [global MathML attributes](/en-US/docs/Web/MathML/Global_attributes) as well as the following attribute:
- `accentunder`
- : A [`<boolean>`](/en-US/docs/Web/MathML/Values#mathml-specific_types) indicating whether the under script should be treated as an accent (i.e. drawn bigger and closer to the base expression).
## Examples
```html
<math display="block">
<munder accentunder="true">
<mrow>
<mi>x</mi>
<mo>+</mo>
<mi>y</mi>
<mo>+</mo>
<mi>z</mi>
</mrow>
<mo>⏟<!--BOTTOM CURLY BRACKET--></mo>
</munder>
</math>
```
{{ EmbedLiveSample('munder_example', 700, 200, "", "") }}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{ MathMLElement("mover") }} (Overscript)
- {{ MathMLElement("munderover") }} (Underscript-overscript pair)
| 0 |
data/mdn-content/files/en-us/web/mathml/element | data/mdn-content/files/en-us/web/mathml/element/mi/index.md | ---
title: <mi>
slug: Web/MathML/Element/mi
page-type: mathml-element
browser-compat: mathml.elements.mi
---
{{MathMLRef}}
The **`<mi>`** [MathML](/en-US/docs/Web/MathML) element indicates that the content should be rendered as an **identifier**, such as a function name, variable or symbolic constant.
By default `<mi>` elements that contain multiple characters are a rendered as normal text, while single character characters are rendered as italic: the same formatting behaviour as the [CSS `text-transform`](/en-US/docs/Web/CSS/text-transform) property with a value of `math-auto`.
The `mathvariant` attribute with a value of `normal` can be used to reset a single character to the normal font.
In order to use a particular form of a character such as bold/italic, serif, sans-serif, script/calligraphy, monospaced, double-struck, and so on, you should use the appropriate [Mathematical Alphanumeric Symbols](https://en.wikipedia.org/wiki/Mathematical_Alphanumeric_Symbols).
> **Note:** In a previous specification (MathML3), the `mathvariant` attribute was used to define logical classes that could apply the character formatting for mathematical alphanumeric symbols.
> The associated values are now deprecated, and expected to be removed from browsers in future releases.
## Attributes
- `mathvariant`
- : The only value allowed in the current specification is `normal` (case insensitive):
- `normal`
- : Use default/normal rendering, removing automatic styling of single characters to italic.
Deprecated legacy values are:
- `bold` {{deprecated_inline}}
- : Try and use bold characters e.g. "𝐀".
- `italic` {{deprecated_inline}}
- : Try and use italic characters e.g. "𝐴".
- `bold-italic` {{deprecated_inline}}
- : Try and use bold-italic characters e.g. "𝑨".
- `double-struck` {{deprecated_inline}}
- : Try and use double-struck characters e.g. "𝔸".
- `bold-fraktur` {{deprecated_inline}}
- : Try and use bold-fraktur characters e.g. "𝕬".
- `script` {{deprecated_inline}}
- : Try and use script characters e.g. "𝒜".
- `bold-script` {{deprecated_inline}}
- : Try and use bold-script characters e.g. "𝓐".
- `fraktur` {{deprecated_inline}}
- : Try and use fraktur characters e.g. "𝔄".
- `sans-serif` {{deprecated_inline}}
- : Try and use sans-serif characters e.g. "𝖠".
- `bold-sans-serif` {{deprecated_inline}}
- : Try and use bold-sans-serif characters e.g. "𝗔".
- `sans-serif-italic` {{deprecated_inline}}
- : Try and use sans-serif-italic characters e.g. "𝘈".
- `sans-serif-bold-italic` {{deprecated_inline}}
- : Try and use sans-serif-bold-italic characters e.g. "𝘼".
- `monospace` {{deprecated_inline}}
- : Try and use monospace characters e.g. "𝙰".
- `initial` {{deprecated_inline}}
- : Try and use initial characters e.g. "𞸢".
- `tailed` {{deprecated_inline}}
- : Try and use tailed characters e.g. "𞹂".
- `looped` {{deprecated_inline}}
- : Try and use looped characters e.g. "𞺂".
- `stretched` {{deprecated_inline}}
- : Try and use stretched characters e.g. "𞹢".
This element also accepts the [global MathML attributes](/en-US/docs/Web/MathML/Global_attributes).
## Examples
```html
<math display="block">
<!-- Multiple characters render as "normal" text -->
<mi>sin</mi>
</math>
<hr />
<math display="block">
<!-- Single characters render as italic by default (i.e. "A" renders as "𝐴") -->
<mi>A</mi>
</math>
<hr />
<math display="block">
<!-- Use mathvariant="normal" to make single character render as normal text -->
<mi mathvariant="normal">F</mi>
</math>
<hr />
<math display="block">
<!-- To use a specific variant, such as "B" in Fraktur -->
<mi>𝔅</mi>
</math>
```
{{ EmbedLiveSample('mi_example', 400, 100) }}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/mathml/element | data/mdn-content/files/en-us/web/mathml/element/mroot/index.md | ---
title: <mroot>
slug: Web/MathML/Element/mroot
page-type: mathml-element
browser-compat: mathml.elements.mroot
---
{{MathMLRef}}
The **`<mroot>`** [MathML](/en-US/docs/Web/MathML) element is used to display roots with an explicit index. Two arguments are accepted, which leads to the syntax: `<mroot> base index </mroot>`.
## Attributes
This element accepts the [global MathML attributes](/en-US/docs/Web/MathML/Global_attributes).
## Examples
```html
<math display="block">
<mroot>
<mi>x</mi>
<mn>3</mn>
</mroot>
</math>
```
{{EmbedLiveSample('Examples')}}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{ MathMLElement("msqrt") }} (Square root without an index)
| 0 |
data/mdn-content/files/en-us/web/mathml | data/mdn-content/files/en-us/web/mathml/values/index.md | ---
title: MathML Attribute Values
slug: Web/MathML/Values
page-type: guide
browser-compat: mathml.attribute_values
---
{{MathMLRef}}
## MathML-specific types
In addition to [CSS data types](/en-US/docs/Web/CSS/CSS_Types), some MathML attributes accept the following types:
- `<unsigned-integer>`: An [`<integer>`](/en-US/docs/Web/CSS/integer), whose first character is neither U+002D HYPHEN-MINUS character (-) nor U+002B PLUS SIGN (+); for example `1234`.
- `<boolean>`: A string `true` or `false` representing a boolean value.
## Legacy MathML lengths
{{deprecated_header}}
Instead of {{cssxref("length-percentage")}}, MathML used to define its own [type to describe lengths](https://www.w3.org/TR/MathML3/chapter2.html#type.length). Accepted values included non-zero unitless length values (e.g. `5` to mean `500%`), values containing numbers ending with a dot (e.g. `34.px`), or named spaces (e.g. `thinmathspace`). For compatibility reasons, it is recommended to replace non-zero unitless length values with equivalent {{cssxref("percentage")}} values, to remove unnecessary dots in numbers, and to use the following replacement for named lengths:
```plain
veryverythinmathspace => 0.05555555555555555em
verythinmathspace => 0.1111111111111111em
thinmathspace => 0.16666666666666666em
mediummathspace => 0.2222222222222222em
thickmathspace => 0.2777777777777778em
verythickmathspace => 0.3333333333333333em
veryverythickmathspace => 0.3888888888888889em
```
### Units
| Unit | Description |
| ---- | -------------------------------------------------------------------------------------------------------------- |
| `em` | {{ Cssxref("font-size", "Font-relative") }} unit |
| `ex` | {{ Cssxref("font-size", "Font-relative") }} unit. (The "x"-height of the element, `1ex ≈ 0.5em` in many fonts) |
| `px` | Pixels |
| `in` | Inches (1 inch = 2.54 centimeters) |
| `cm` | Centimeters |
| `mm` | Millimeters |
| `pt` | Points (1 point = 1/72 inch) |
| `pc` | Picas (1 pica = 12 points) |
| `%` | Percentage of the default value. |
### Constants
| Constant | Value |
| -------------------------------- | --------- |
| `veryverythinmathspace` | 1/18`em` |
| `verythinmathspace` | 2/18`em` |
| `thinmathspace` | 3/18`em` |
| `mediummathspace` | 4/18`em` |
| `thickmathspace` | 5/18`em` |
| `verythickmathspace` | 6/18`em` |
| `veryverythickmathspace` | 7/18`em` |
| `negativeveryverythinmathspace` | -1/18`em` |
| `negativeverythinmathspace` | -2/18`em` |
| `negativethinmathspace` | -3/18`em` |
| `negativemediummathspace` | -4/18`em` |
| `negativethickmathspace` | -5/18`em` |
| `negativeverythickmathspace` | -6/18`em` |
| `negativeveryverythickmathspace` | -7/18`em` |
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/mathml | data/mdn-content/files/en-us/web/mathml/examples/index.md | ---
title: Examples
slug: Web/MathML/Examples
page-type: landing-page
---
{{MathMLRef}}
Below you'll find some examples you can look at to help you to understand how to use MathML.
## MathML formulas
The following demos display increasingly complex mathematical concepts in Web content.
- [Pythagorean Theorem](/en-US/docs/Web/MathML/Examples/MathML_Pythagorean_Theorem)
- : Small example showing a proof of the Pythagorean Theorem.
- [Deriving the Quadratic Formula](/en-US/docs/Web/MathML/Examples/Deriving_the_Quadratic_Formula)
- : Outlines the derivation of the Quadratic Formula.
- [Mozilla MathML Test](https://fred-wang.github.io/MathFonts/mozilla_mathml_test/)
- : Original test from the Mozilla MathML project. It contains examples from the [TeXbook](https://en.wikipedia.org/wiki/Computers_and_Typesetting) with image references generated by TeX.
- [MathML Browser Test](http://eyeasme.com/Joe/MathML/MathML_browser_test.html)
- : A similar test with concrete formulas taken from Wikipedia.
## Other Web technologies
The following demos mix MathML with other Web technologies to produce advanced content.
- [`<la-tex>` custom element](https://fred-wang.github.io/TeXZilla/examples/customElement.html)
- : A [custom element](/en-US/docs/Web/API/Web_components/Using_custom_elements) that accepts [LaTeX](https://en.wikipedia.org/wiki/LaTeX) content.
- [Magnetic field demo](https://fred-wang.github.io/TeXZilla/examples/toImageWebGL.html)
- : A 3D representation of a magnetic field, using [SVG](/en-US/docs/Web/SVG) and [WebGL](/en-US/docs/Web/API/WebGL_API).
- [Συνάρτηση ζήτα Ρήμαν (el)](https://fred-wang.github.io/MathFonts/%CE%A3%CF%85%CE%BD%CE%AC%CF%81%CF%84%CE%B7%CF%83%CE%B7_%CE%B6%CE%AE%CF%84%CE%B1_%CE%A1%CE%AE%CE%BC%CE%B1%CE%BD.html)
- : A greek article about the Riemann zeta function, with [Web fonts](/en-US/docs/Learn/CSS/Styling_text/Web_fonts) from the [Greek Font Society](https://greekfontsociety-gfs.gr/).
- [Pell's equation](https://people.igalia.com/fwang/pell-bigint-mathml/)
- : A JavaScript program to solve Pell's equation using [`BigInt`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt).
- [Lovelace's program for Bernouilli numbers](https://people.igalia.com/fwang/lovelace-jsclass-mathml/)
- : An emulator for Ada Lovelace's program to calculate Bernouilli numbers, using [Private properties](/en-US/docs/Web/JavaScript/Reference/Classes/Private_properties).
| 0 |
data/mdn-content/files/en-us/web/mathml/examples | data/mdn-content/files/en-us/web/mathml/examples/mathml_pythagorean_theorem/index.md | ---
title: Proving the Pythagorean theorem
slug: Web/MathML/Examples/MathML_Pythagorean_Theorem
page-type: guide
---
{{MathMLRef}}
We will now prove the [Pythagorean theorem](https://en.wikipedia.org/wiki/Pythagorean_theorem):
**Statement**: In a right triangle, the square of the hypotenuse is equal to
the sum of the squares of the other two sides.
i.e., If a and b are the legs and c is the hypotenuse then
<!-- @prettier-ignore -->
<math>
<mrow>
<msup>
<mi>a</mi>
<mn>2</mn>
</msup>
<mo>+</mo>
<msup>
<mi>b</mi>
<mn>2</mn>
</msup>
<mo>=</mo>
<msup>
<mi>c</mi>
<mn>2</mn>
</msup>
</mrow>
</math>.
**Proof:** We can prove the theorem algebraically by showing that on
[this figure](http://www.cut-the-knot.org/pythagoras/proof31.gif)
the area of the big square equals the area of the inner square (hypotenuse
squared) plus the area of the four triangles:
<math display="block">
<mtable>
<mtr>
<mtd>
<msup>
<mrow>
<mo>(</mo>
<mi>a</mi>
<mo>+</mo>
<mi>b</mi>
<mo>)</mo>
</mrow>
<mn>2</mn>
</msup>
</mtd>
<mtd>
<mo>=</mo>
</mtd>
<mtd>
<msup>
<mi>c</mi>
<mn>2</mn>
</msup>
<mo>+</mo>
<mn>4</mn>
<mo>⋅</mo>
<mo>(</mo>
<mfrac>
<mn>1</mn>
<mn>2</mn>
</mfrac>
<mi>a</mi>
<mi>b</mi>
<mo>)</mo>
</mtd>
</mtr>
<mtr>
<mtd>
<msup>
<mi>a</mi>
<mn>2</mn>
</msup>
<mo>+</mo>
<mn>2</mn>
<mi>a</mi>
<mi>b</mi>
<mo>+</mo>
<msup>
<mi>b</mi>
<mn>2</mn>
</msup>
</mtd>
<mtd>
<mo>=</mo>
</mtd>
<mtd>
<msup>
<mi>c</mi>
<mn>2</mn>
</msup>
<mo>+</mo>
<mn>2</mn>
<mi>a</mi>
<mi>b</mi>
</mtd>
</mtr>
<mtr>
<mtd>
<msup>
<mi>a</mi>
<mn>2</mn>
</msup>
<mo>+</mo>
<msup>
<mi>b</mi>
<mn>2</mn>
</msup>
</mtd>
<mtd>
<mo>=</mo>
</mtd>
<mtd>
<msup>
<mi>c</mi>
<mn>2</mn>
</msup>
</mtd>
</mtr>
</mtable>
</math>
| 0 |
data/mdn-content/files/en-us/web/mathml/examples | data/mdn-content/files/en-us/web/mathml/examples/deriving_the_quadratic_formula/index.md | ---
title: Deriving the Quadratic Formula
slug: Web/MathML/Examples/Deriving_the_Quadratic_Formula
page-type: guide
---
{{MathMLRef}}
This page outlines the derivation of the [Quadratic Formula](https://en.wikipedia.org/wiki/Quadratic_formula).
We take a quadratic equation in its general form, and solve for x:
<math>
<mtable>
<mtr>
<mtd>
<mrow>
<mrow>
<mrow>
<mrow>
<mi>a</mi>
<mo>⁢<!-- INVISIBLE TIMES --></mo>
<msup>
<mi>x</mi>
<mn>2</mn>
</msup>
</mrow>
<mo>+</mo>
<mi>b</mi>
<mo>⁢<!-- INVISIBLE TIMES --></mo>
<mi>x</mi>
</mrow>
<mo>+</mo>
<mi>c</mi>
</mrow>
</mrow>
</mtd>
<mtd>
<mo>=</mo>
</mtd>
<mtd>
<mn>0</mn>
</mtd>
</mtr>
<mtr>
<mtd>
<mrow>
<mrow>
<mi>a</mi>
<mo>⁢<!-- INVISIBLE TIMES --></mo>
<msup>
<mi>x</mi>
<mn>2</mn>
</msup>
</mrow>
<mo>+</mo>
<mi>b</mi>
<mo>⁢<!-- INVISIBLE TIMES --></mo>
<mi>x</mi>
</mrow>
</mtd>
<mtd>
<mo>=</mo>
</mtd>
<mtd>
<mo>−</mo>
<mi>c</mi>
</mtd>
</mtr>
<mtr>
<mtd>
<mrow>
<mrow>
<msup>
<mi>x</mi>
<mn>2</mn>
</msup>
</mrow>
<mo>+</mo>
<mfrac>
<mi>b</mi>
<mi>a</mi>
</mfrac>
<mo></mo>
<mi>x</mi>
</mrow>
</mtd>
<mtd>
<mo>=</mo>
</mtd>
<mtd>
<mfrac>
<mrow>
<mo>−</mo>
<mi>c</mi>
</mrow>
<mi>a</mi>
</mfrac>
</mtd>
<mtd>
<mrow>
<mtext style="color: red; font-size: 10pt;">Divide out leading coefficient.</mtext>
</mrow>
</mtd>
</mtr>
<mtr>
<mtd>
<mrow>
<mrow>
<mrow>
<msup>
<mi>x</mi>
<mn>2</mn>
</msup>
</mrow>
<mo>+</mo>
<mfrac>
<mrow>
<mi>b</mi>
</mrow>
<mi>a</mi>
</mfrac>
<mo></mo>
<mi>x</mi>
<mo>+</mo>
<msup>
<mrow>
<mo>(</mo>
<mfrac>
<mrow>
<mi>b</mi>
</mrow>
<mrow>
<mn>2</mn>
<mi>a</mi>
</mrow>
</mfrac>
<mo>)</mo>
</mrow>
<mn>2</mn>
</msup>
</mrow>
</mrow>
</mtd>
<mtd>
<mo>=</mo>
</mtd>
<mtd>
<mrow>
<mfrac>
<mrow>
<mo>−</mo>
<mi>c</mi>
<mo>(</mo>
<mn>4</mn>
<mi>a</mi>
<mo>)</mo>
</mrow>
<mrow>
<mi>a</mi>
<mo>(</mo>
<mn>4</mn>
<mi>a</mi>
<mo>)</mo>
</mrow>
</mfrac>
<mo>+</mo>
<mfrac>
<mrow>
<msup>
<mi>b</mi>
<mn>2</mn>
</msup>
</mrow>
<mrow>
<mn>4</mn>
<msup>
<mi>a</mi>
<mn>2</mn>
</msup>
</mrow>
</mfrac>
</mrow>
</mtd>
<mtd>
<mrow>
<mtext style="color: red; font-size: 10pt;">Complete the square.</mtext>
</mrow>
</mtd>
</mtr>
<mtr>
<mtd>
<mrow>
<mrow>
<mo>(</mo>
<mi>x</mi>
<mo>+</mo>
<mfrac>
<mrow>
<mi>b</mi>
</mrow>
<mrow>
<mn>2</mn>
<mi>a</mi>
</mrow>
</mfrac>
<mo>)</mo>
<mo>(</mo>
<mi>x</mi>
<mo>+</mo>
<mfrac>
<mrow>
<mi>b</mi>
</mrow>
<mrow>
<mn>2</mn>
<mi>a</mi>
</mrow>
</mfrac>
<mo>)</mo>
</mrow>
</mrow>
</mtd>
<mtd>
<mo>=</mo>
</mtd>
<mtd>
<mfrac>
<mrow>
<msup>
<mi>b</mi>
<mn>2</mn>
</msup>
<mo>−</mo>
<mn>4</mn>
<mi>a</mi>
<mi>c</mi>
</mrow>
<mrow>
<mn>4</mn>
<msup>
<mi>a</mi>
<mn>2</mn>
</msup>
</mrow>
</mfrac>
</mtd>
<mtd>
<mrow>
<mtext style="color: red; font-size: 10pt;">Discriminant revealed.</mtext>
</mrow>
</mtd>
</mtr>
<mtr>
<mtd>
<mrow>
<mrow>
<msup>
<mrow>
<mo>(</mo>
<mi>x</mi>
<mo>+</mo>
<mfrac>
<mrow>
<mi>b</mi>
</mrow>
<mrow>
<mn>2</mn>
<mi>a</mi>
</mrow>
</mfrac>
<mo>)</mo>
</mrow>
<mn>2</mn>
</msup>
</mrow>
</mrow>
</mtd>
<mtd>
<mo>=</mo>
</mtd>
<mtd>
<mfrac>
<mrow>
<msup>
<mi>b</mi>
<mn>2</mn>
</msup>
<mo>−</mo>
<mn>4</mn>
<mi>a</mi>
<mi>c</mi>
</mrow>
<mrow>
<mn>4</mn>
<msup>
<mi>a</mi>
<mn>2</mn>
</msup>
</mrow>
</mfrac>
</mtd>
<mtd>
<mrow>
<mtext style="color: red; font-size: 10pt;"></mtext>
</mrow>
</mtd>
</mtr>
<mtr>
<mtd>
<mrow>
<mrow>
<mrow>
<mi>x</mi>
<mo>+</mo>
<mfrac>
<mrow>
<mi>b</mi>
</mrow>
<mrow>
<mn>2</mn>
<mi>a</mi>
</mrow>
</mfrac>
</mrow>
</mrow>
</mrow>
</mtd>
<mtd>
<mo>=</mo>
</mtd>
<mtd>
<msqrt>
<mfrac>
<mrow>
<msup>
<mi>b</mi>
<mn>2</mn>
</msup>
<mo>−</mo>
<mn>4</mn>
<mi>a</mi>
<mi>c</mi>
</mrow>
<mrow>
<mn>4</mn>
<msup>
<mi>a</mi>
<mn>2</mn>
</msup>
</mrow>
</mfrac>
</msqrt>
</mtd>
<mtd>
<mrow>
<mtext style="color: red; font-size: 10pt;"></mtext>
</mrow>
</mtd>
</mtr>
<mtr>
<mtd>
<mi>x</mi>
</mtd>
<mtd>
<mo>=</mo>
</mtd>
<mtd>
<mfrac>
<mrow>
<mo>−</mo>
<mi>b</mi>
</mrow>
<mrow>
<mn>2</mn>
<mi>a</mi>
</mrow>
</mfrac>
<mo>±</mo>
<mrow>
<mo>{</mo>
<mi>C</mi>
<mo>}</mo>
</mrow>
<msqrt>
<mfrac>
<mrow>
<msup>
<mi>b</mi>
<mn>2</mn>
</msup>
<mo>−</mo>
<mn>4</mn>
<mi>a</mi>
<mi>c</mi>
</mrow>
<mrow>
<mn>4</mn>
<msup>
<mi>a</mi>
<mn>2</mn>
</msup>
</mrow>
</mfrac>
</msqrt>
</mtd>
<mtd>
<mrow>
<mtext style="color: red; font-size: 10pt;">There's the vertex formula.</mtext>
</mrow>
</mtd>
</mtr>
<mtr>
<mtd>
<mi>x</mi>
</mtd>
<mtd>
<mo>=</mo>
</mtd>
<mtd>
<mfrac>
<mrow>
<mo>−</mo>
<mi>b</mi>
<mo>±</mo>
<mrow>
<mo>{</mo>
<mi>C</mi>
<mo>}</mo>
</mrow>
<msqrt>
<msup>
<mi>b</mi>
<mn>2</mn>
</msup>
<mo>−</mo>
<mn>4</mn>
<mi>a</mi>
<mi>c</mi>
</msqrt>
</mrow>
<mrow>
<mn>2</mn>
<mi>a</mi>
</mrow>
</mfrac>
</mtd>
<mtd>
<mrow>
<mtext style="color: red; font-size: 10pt;"></mtext>
</mrow>
</mtd>
</mtr>
</mtable>
</math>
| 0 |
data/mdn-content/files/en-us/web/mathml | data/mdn-content/files/en-us/web/mathml/attribute/index.md | ---
title: Attributes
slug: Web/MathML/Attribute
page-type: landing-page
---
{{MathMLRef}}
This is an alphabetical list of MathML attributes. More details for each attribute are available on relevant [MathML element pages](/en-US/docs/Web/MathML/Element) and on the [global attributes page](/en-US/docs/Web/MathML/Global_attributes). The [values](/en-US/docs/Web/MathML/Values) page also describes some notes on common values used by MathML attributes.
> **Note:** As explained on the main [MathML](/en-US/docs/Web/MathML) page, MDN uses [MathML Core](https://w3c.github.io/mathml-core/) as a reference specification. However, legacy features that are still implemented by some browsers are also documented. You can find further details for these and other features in [MathML 4](https://w3c.github.io/mathml/).
<table class="standard-table">
<thead>
<tr>
<th>Name</th>
<th>Elements accepting attribute</th>
<th>Description</th>
</tr>
</thead>
<tbody>
<tr>
<td><code>accent</code></td>
<td>
{{ MathMLElement("mo") }}
</td>
<td>
A <a href="/en-US/docs/Web/MathML/Values#mathml-specific_types"><code><boolean></code></a> indicating whether the operator should be treated as an accent when used as an under- or over-script.
</td>
</tr>
<tr>
<td><code>accent</code></td>
<td>
{{ MathMLElement("mover") }},
{{ MathMLElement("munderover") }}
</td>
<td>
A <a href="/en-US/docs/Web/MathML/Values#mathml-specific_types"><code><boolean></code></a> indicating whether the under script should be treated as an accent.
</td>
</tr>
<tr>
<td><code>accentunder</code></td>
<td>
{{ MathMLElement("munder") }},
{{ MathMLElement("munderover") }}
</td>
<td>
A <a href="/en-US/docs/Web/MathML/Values#mathml-specific_types"><code><boolean></code></a> indicating whether the over script should be treated as an accent.
</td>
</tr>
<tr>
<td><code>actiontype</code> {{deprecated_inline}}</td>
<td>{{ MathMLElement("maction") }}</td>
<td>A string value specifying the action happening for this element.</td>
</tr>
<tr>
<td><code>align</code></td>
<td>
{{ MathMLElement("mtable") }}
</td>
<td>
Specifies vertical alignment of the table with respect to its environment.
</td>
</tr>
<tr>
<td><code>background</code> {{deprecated_inline}}</td>
<td>{{ MathMLElement("mstyle") }}</td>
<td>
Use CSS <a href="/en-US/docs/Web/CSS/background-color"><code>background-color</code></a> instead.
</td>
</tr>
<tr>
<td><code>close</code> {{deprecated_inline}}</td>
<td>{{ MathMLElement("mfenced") }}</td>
<td>A string for the closing delimiter.</td>
</tr>
<tr>
<td><code>color</code> {{deprecated_inline}}</td>
<td>{{ MathMLElement("mstyle") }}</td>
<td>
Use CSS <a href="/en-US/docs/Web/CSS/color"><code>color</code></a> instead.
</td>
</tr>
<tr>
<td><code>columnalign</code></td>
<td>
{{ MathMLElement("mtable") }},
{{ MathMLElement("mtd") }},
{{ MathMLElement("mtr") }}
</td>
<td>Specifies the horizontal alignment of table cells.</td>
</tr>
<tr>
<td><code>columnlines</code></td>
<td>{{ MathMLElement("mtable") }}</td>
<td>Specifies table column borders.</td>
</tr>
<tr>
<td><code>columnspacing</code></td>
<td>{{ MathMLElement("mtable") }}</td>
<td>Specifies the space between table columns.</td>
</tr>
<tr>
<td><code>columnspan</code></td>
<td>{{ MathMLElement("mtd") }}</td>
<td>
A non-negative integer value that indicates over how many table columns
the cell extends.
</td>
</tr>
<tr>
<td><code>denomalign</code> {{deprecated_inline}}</td>
<td>{{ MathMLElement("mfrac") }}</td>
<td>The alignment of the denominator under the fraction.</td>
</tr>
<tr>
<td><code>depth</code></td>
<td>{{ MathMLElement("mpadded") }}</td>
<td>
A {{cssxref("length-percentage")}} indicating the desired depth (below the baseline).
</td>
</tr>
<tr>
<td><code>dir</code></td>
<td>
<a href="/en-US/docs/Web/MathML/Global_attributes">All MathML elements</a>
</td>
<td>
The text direction. Possible values are either <code>ltr</code> (left to right) or
<code>rtl</code> (right to left).
</td>
</tr>
<tr>
<td><code>display</code></td>
<td>{{ MathMLElement("math") }}</td>
<td>
Specifies the rendering mode. The values <code>block</code> and
<code>inline</code> are allowed.
</td>
</tr>
<tr>
<td><code>displaystyle</code></td>
<td><a href="/en-US/docs/Web/MathML/Global_attributes">All MathML elements</a></td>
<td>
<p>
A <a href="/en-US/docs/Web/MathML/Values#mathml-specific_types"><code><boolean></code></a> specifying whether to set the
<a href="/en-US/docs/Web/CSS/math-style">math-style</a>
to <code>normal</code> (if true) or <code>compact</code> (otherwise).
</p>
</td>
</tr>
<tr>
<td><code>fence</code></td>
<td>{{ MathMLElement("mo") }}</td>
<td>
A <a href="/en-US/docs/Web/MathML/Values#mathml-specific_types"><code><boolean></code></a> specifying whether the operator is a fence (such as
parentheses). There is no visual effect for this attribute.
</td>
</tr>
<tr>
<td><code>fontfamily</code> {{deprecated_inline}}</td>
<td>{{ MathMLElement("mstyle") }}</td>
<td>
Use CSS <a href="/en-US/docs/Web/CSS/font-family"><code>font-family</code></a> instead.
</td>
</tr>
<tr>
<td><code>fontsize</code> {{deprecated_inline}}</td>
<td>{{ MathMLElement("mstyle") }}</td>
<td>
Use CSS <a href="/en-US/docs/Web/CSS/font-size"><code>font-size</code></a> instead.
</td>
</tr>
<tr>
<td><code>fontstyle</code> {{deprecated_inline}}</td>
<td>{{ MathMLElement("mstyle") }}</td>
<td>
Use CSS <a href="/en-US/docs/Web/CSS/font-style"><code>font-style</code></a> instead.
</td>
</tr>
<tr>
<td><code>fontweight</code> {{deprecated_inline}}</td>
<td>{{ MathMLElement("mstyle") }}</td>
<td>
Use CSS <a href="/en-US/docs/Web/CSS/font-weight"><code>font-weight</code></a> instead.
</td>
</tr>
<tr>
<td><code>frame</code></td>
<td>{{ MathMLElement("mtable") }}</td>
<td>
Specifies borders of an entire {{ MathMLElement("mtable") }}.
Possible values are: <code>none</code> (default), <code>solid</code> and
<code>dashed</code>.
</td>
</tr>
<tr>
<td><code>framespacing</code></td>
<td>{{ MathMLElement("mtable") }}</td>
<td>
Specifies additional space added between the table and
<code>frame</code>.
</td>
</tr>
<tr>
<td><code>height</code></td>
<td>
{{ MathMLElement("mpadded") }},
{{ MathMLElement("mspace") }}
</td>
<td>
A {{cssxref("length-percentage")}} indicating the desired height (above the baseline).
</td>
</tr>
<tr>
<td><code>href</code></td>
<td><a href="/en-US/docs/Web/MathML/Global_attributes">All MathML elements</a></td>
<td>Used to set a hyperlink to a specified URI.</td>
</tr>
<tr>
<td><code>id</code></td>
<td><a href="/en-US/docs/Web/MathML/Global_attributes">All MathML elements</a></td>
<td>Sets up a unique identifier associated with the element.</td>
</tr>
<tr>
<td><code>linethickness</code></td>
<td>{{ MathMLElement("mfrac") }}</td>
<td>A {{cssxref("length-percentage")}} indicating the thickness of the horizontal fraction line.</td>
</tr>
<tr>
<td><code>lspace</code></td>
<td>
{{ MathMLElement("mo") }}
</td>
<td>
A {{cssxref("length-percentage")}} indicating amount of space before the operator.
</td>
</tr>
<tr>
<td><code>lspace</code></td>
<td>
{{ MathMLElement("mpadded") }}
</td>
<td>
A {{cssxref("length-percentage")}} indicating the horizontal location of the positioning point of the child content with respect to the positioning point of the element.
</td>
</tr>
<tr>
<td><code>lquote</code> {{deprecated_inline}}</td>
<td>{{ MathMLElement("ms") }}</td>
<td>
The opening quote to enclose the content. The default value is <code>&quot;</code>.
</td>
</tr>
<tr>
<td><code>mathbackground</code></td>
<td><a href="/en-US/docs/Web/MathML/Global_attributes">All MathML elements</a></td>
<td>
A <a href="/en-US/docs/Web/CSS/background-color">background-color</a> for the element.
</td>
</tr>
<tr>
<td><code>mathcolor</code></td>
<td><a href="/en-US/docs/Web/MathML/Global_attributes">All MathML elements</a></td>
<td>
A <a href="/en-US/docs/Web/CSS/color">color</a> for the element.
</td>
</tr>
<tr>
<td><code>mathsize</code></td>
<td><a href="/en-US/docs/Web/MathML/Global_attributes">All MathML elements</a></td>
<td>
A {{cssxref("length-percentage")}} used as a <a href="/en-US/docs/Web/CSS/font-size"><code>font-size</code></a> for the element.
</td>
</tr>
<tr>
<td><code>mathvariant</code></td>
<td><a href="/en-US/docs/Web/MathML/Global_attributes">All MathML elements</a></td>
<td>The logical class of token elements, which varies in typography.</td>
</tr>
<tr>
<td><code>maxsize</code></td>
<td>{{ MathMLElement("mo") }}</td>
<td>A {{cssxref("length-percentage")}} indicating the maximum size of the operator when it is stretchy.</td>
</tr>
<tr>
<td><code>minsize</code></td>
<td>{{ MathMLElement("mo") }}</td>
<td>A {{cssxref("length-percentage")}} indicating the minimum size of the operator when it is stretchy.</td>
</tr>
<tr>
<td><code>movablelimits</code></td>
<td>{{ MathMLElement("mo") }}</td>
<td>
A <a href="/en-US/docs/Web/MathML/Values#mathml-specific_types"><code><boolean></code></a> indicating whether attached under- and overscripts move to sub- and superscript positions when <a href="/en-US/docs/Web/CSS/math-style">math-style</a> is set to <code>compact</code>.
</td>
</tr>
<tr>
<td><code>notation</code></td>
<td>{{ MathMLElement("menclose") }}</td>
<td>
A list of notations, separated by white space, to apply to the child
elements.
</td>
</tr>
<tr>
<td><code>numalign</code> {{deprecated_inline}}</td>
<td>{{ MathMLElement("mfrac") }}</td>
<td>The alignment of the numerator over the fraction.</td>
</tr>
<tr>
<td><code>open</code> {{deprecated_inline}}</td>
<td>{{ MathMLElement("mfenced") }}</td>
<td>A string for the opening delimiter.</td>
</tr>
<tr>
<td><code>rowalign</code></td>
<td>
{{ MathMLElement("mtable") }},
{{ MathMLElement("mtd") }},
{{ MathMLElement("mtr") }}
</td>
<td>Specifies the vertical alignment of table cells.</td>
</tr>
<tr>
<td><code>rowlines</code></td>
<td>{{ MathMLElement("mtable") }}</td>
<td>Specifies table row borders.</td>
</tr>
<tr>
<td><code>rowspacing</code></td>
<td>{{ MathMLElement("mtable") }}</td>
<td>Specifies the space between table rows.</td>
</tr>
<tr>
<td><code>rowspan</code></td>
<td>{{ MathMLElement("mtd") }}</td>
<td>
A non-negative integer value that indicates on how many rows does the
cell extend.
</td>
</tr>
<tr>
<td><code>rspace</code></td>
<td>{{ MathMLElement("mo") }}</td>
<td>A {{cssxref("length-percentage")}} indicating the amount of space after the operator.</td>
</tr>
<tr>
<td><code>rquote</code> {{deprecated_inline}}</td>
<td>{{ MathMLElement("ms") }}</td>
<td>
The closing quote to enclose the content. The default value is <code>&quot;</code>.
</td>
</tr>
<tr>
<td><code>scriptlevel</code></td>
<td><a href="/en-US/docs/Web/MathML/Global_attributes">All MathML elements</a></td>
<td>
Specifies a <a href="/en-US/docs/Web/CSS/math-depth">math-depth</a> for the element. See the <a href="/en-US/docs/Web/MathML/Global_attributes/scriptlevel#values">scriptlevel page</a> for accepted values and mapping.
</td>
</tr>
<tr>
<td><code>scriptminsize</code> {{deprecated_inline}}</td>
<td>{{ MathMLElement("mstyle") }}</td>
<td>
Specifies a minimum font size allowed due to changes in
<code>scriptlevel</code>.
</td>
</tr>
<tr>
<td><code>scriptsizemultiplier</code> {{deprecated_inline}}</td>
<td>{{ MathMLElement("mstyle") }}</td>
<td>
Specifies the multiplier to be used to adjust font size due to changes
in <code>scriptlevel</code>.
</td>
</tr>
<tr>
<td><code>selection</code> {{deprecated_inline}}</td>
<td>{{ MathMLElement("maction") }}</td>
<td>The child element visible, only taken into account for some <code>actiontype</code> values.</td>
</tr>
<tr>
<td><code>separator</code></td>
<td>{{ MathMLElement("mo") }}</td>
<td>
A <a href="/en-US/docs/Web/MathML/Values#mathml-specific_types"><code><boolean></code></a> specifying whether
the operator is a separator (such as commas).
There is no visual effect for this attribute.
</td>
</tr>
<tr>
<td><code>separators</code> {{deprecated_inline}}</td>
<td>{{ MathMLElement("mfenced") }}</td>
<td>
A sequence of zero or more characters to be used for different
separators.
</td>
</tr>
<tr>
<td><code>stretchy</code></td>
<td>{{ MathMLElement("mo") }}</td>
<td>
A <a href="/en-US/docs/Web/MathML/Values#mathml-specific_types"><code><boolean></code></a> indicating whether the operator stretches to the size of the adjacent element.
</td>
</tr>
<tr>
<td><code>subscriptshift</code> {{deprecated_inline}}</td>
<td>
{{ MathMLElement("msub") }},
{{ MathMLElement("msubsup") }},
{{ MathMLElement("mmultiscripts") }}
</td>
<td>
A {{cssxref("length-percentage")}} indicating the minimum amount to shift the baseline of the subscript down.
</td>
</tr>
<tr>
<td><code>superscriptshift</code> {{deprecated_inline}}</td>
<td>
{{ MathMLElement("msup") }},
{{ MathMLElement("msubsup") }},
{{ MathMLElement("mmultiscripts") }}
</td>
<td>
A {{cssxref("length-percentage")}} indicating the minimum amount to shift the baseline of the superscript up.
</td>
</tr>
<tr>
<td><code>symmetric</code></td>
<td>{{ MathMLElement("mo") }}</td>
<td>
A <a href="/en-US/docs/Web/MathML/Values#mathml-specific_types"><code><boolean></code></a> indicating whether a stretchy operator should be vertically symmetric around the imaginary math axis (centered fraction line).
</td>
</tr>
<tr>
<td><code>voffset</code></td>
<td>{{ MathMLElement("mpadded") }}</td>
<td>A {{cssxref("length-percentage")}} indicating the vertical location of the positioning point of the child content with respect to the positioning point of the element.
</td>
</tr>
<tr>
<td><code>width</code></td>
<td>
{{ MathMLElement("mpadded") }},
{{ MathMLElement("mspace") }},
{{ MathMLElement("mtable") }}
</td>
<td>
A {{cssxref("length-percentage")}} indicating the desired width.
</td>
</tr>
<tr>
<td><code>xmlns</code></td>
<td>{{ MathMLElement("math") }}</td>
<td>
Specifies the URI for the MathML namespace (<code
><a href="https://www.w3.org/1998/Math/MathML"
>http://www.w3.org/1998/Math/MathML</a
></code
>)
</td>
</tr>
</tbody>
</table>
| 0 |
data/mdn-content/files/en-us/web/mathml | data/mdn-content/files/en-us/web/mathml/global_attributes/index.md | ---
title: Global attributes
slug: Web/MathML/Global_attributes
page-type: landing-page
browser-compat: mathml.global_attributes
---
{{MathMLRef}}
**Global attributes** are attributes common to all MathML elements; they can be used on all elements, though they may have no effect on some elements.
Global attributes may be specified on all [MathML elements](/en-US/docs/Web/MathML/Element), _even those not specified in the standard_. That means that any non-standard elements must still permit these attributes, even though using those elements means that the document is no longer MathML-compliant.
In addition to the basic MathML global attributes, the following global attributes also exist:
- The [event handler](/en-US/docs/Web/Events/Event_handlers) attributes such as **`onclick`**, **`onfocus`**, etc.
- The [`href`](/en-US/docs/Web/MathML/Global_attributes/href) attribute for making MathML element a hyperlink.
## List of global attributes
- [`class`](/en-US/docs/Web/HTML/Global_attributes/class)
- : A space-separated list of the classes of the element. Classes allow CSS and JavaScript to select and access specific elements via the [class selectors](/en-US/docs/Web/CSS/Class_selectors) or functions like the method {{DOMxRef("Document.getElementsByClassName()")}}.
- [`data-*`](/en-US/docs/Web/HTML/Global_attributes/data-*)
- : Forms a class of attributes, called custom data attributes, that allow proprietary information to be exchanged between the [MathML](/en-US/docs/Web/MathML) and its {{glossary("DOM")}} representation that may be used by scripts. All such custom data are available via the {{DOMxRef("MathMLElement")}} interface of the element the attribute is set on. The {{DOMxRef("HTMLElement.dataset")}} property gives access to them.
- [`dir`](/en-US/docs/Web/MathML/Global_attributes/dir)
- : An [enumerated](/en-US/docs/Glossary/Enumerated) attribute indicating the directionality of the MathML element. It can have the following values:
- `ltr`, which means _left to right_ and is used to render mathematical expressions from the left to the right (e.g. English or Moroccan style);
- `rtl`, which means _right to left_ and is used to render mathematical expressions from the right to the left (e.g. Maghreb or Machrek style);
- [`displaystyle`](/en-US/docs/Web/MathML/Global_attributes/displaystyle):
- : a boolean setting the [math-style](/en-US/docs/Web/CSS/math-style) for the element.
- `true`, which means `normal`.
- `false`, which means `compact`.
- [`id`](/en-US/docs/Web/HTML/Global_attributes/id)
- : Defines a unique identifier (ID) which must be unique in the whole document. Its purpose is to identify the element when linking (using a fragment identifier), scripting, or styling (with CSS).
- [`mathbackground`](/en-US/docs/Web/MathML/Global_attributes/mathbackground)
- : A [background-color](/en-US/docs/Web/CSS/background-color) for the element.
- [`mathcolor`](/en-US/docs/Web/MathML/Global_attributes/mathcolor)
- : A [color](/en-US/docs/Web/CSS/color) for the element.
- [`mathsize`](/en-US/docs/Web/MathML/Global_attributes/mathsize)
- : A {{cssxref("length-percentage")}} used as a [font-size](/en-US/docs/Web/CSS/font-size) for the element.
- [`nonce`](/en-US/docs/Web/HTML/Global_attributes/nonce)
- : A cryptographic nonce ("number used once") which can be used by [Content Security Policy](/en-US/docs/Web/HTTP/CSP) to determine whether a given fetch will be allowed to proceed.
- [`scriptlevel`](/en-US/docs/Web/MathML/Global_attributes/scriptlevel)
- : Specifies a [math-depth](/en-US/docs/Web/CSS/math-depth) for the element. See the [scriptlevel page](/en-US/docs/Web/MathML/Global_attributes/scriptlevel#values) for accepted values and mapping.
- [`style`](/en-US/docs/Web/HTML/Global_attributes/style)
- : Contains [CSS](/en-US/docs/Web/CSS) styling declarations to be applied to the element. Note that it is recommended for styles to be defined in a separate file or files. This attribute and the {{MathMLElement("style")}} element have mainly the purpose of allowing for quick styling, for example for testing purposes.
- [`tabindex`](/en-US/docs/Web/HTML/Global_attributes/tabindex)
- : An integer attribute indicating if the element can take input focus (is _focusable_), if it should participate to sequential keyboard navigation, and if so, at what position. It can take several values:
- a _negative value_ means that the element should be focusable, but should not be reachable via sequential keyboard navigation;
- `0` means that the element should be focusable and reachable via sequential keyboard navigation, but its relative order is defined by the platform convention;
- a _positive value_ means that the element should be focusable and reachable via sequential keyboard navigation; the order in which the elements are focused is the increasing value of the [**tabindex**](#tabindex). If several elements share the same tabindex, their relative order follows their relative positions in the document.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{DOMxRef("Element")}} interface that allows querying most global attributes.
| 0 |
data/mdn-content/files/en-us/web/mathml/global_attributes | data/mdn-content/files/en-us/web/mathml/global_attributes/dir/index.md | ---
title: dir
slug: Web/MathML/Global_attributes/dir
page-type: mathml-attribute
browser-compat: mathml.global_attributes.dir
---
{{MathMLRef}}
The **`dir`** [global attribute](/en-US/docs/Web/MathML/Global_attributes) is an [enumerated](/en-US/docs/Glossary/Enumerated) attribute that indicates the directionality of the MathML element.
## Syntax
```html
<!-- Moroccan style -->
<math dir="ltr">
<msqrt>
<mi>س</mi>
</msqrt>
<mo>=</mo>
<msup>
<mn>3</mn>
<mi>ب</mi>
</msup>
</math>
<!-- Maghreb/Machrek style -->
<math dir="rtl">
<msqrt>
<mi>س</mi>
</msqrt>
<mo>=</mo>
<msup>
<mn>٣</mn>
<mi>ب</mi>
</msup>
</math>
```
### Values
- `ltr`, which means _left to right_ and is used to render mathematical expressions from the left to the right (e.g. English or Moroccan style);
- `rtl`, which means _right to left_ and is used to render mathematical expressions from the right to the left (e.g. Maghreb or Machrek style);
> **Note:**
>
> - This attribute can be overridden by the CSS property {{ cssxref("direction") }}, if a CSS page is active and the element supports these properties.
> - As the directionality of mathematics is semantically related to its content and not to its presentation, it is recommended that web developers use this attribute instead of the related CSS properties when possible. That way, the formulas will display correctly even on a browser that doesn't support CSS or has the CSS deactivated.
> - The `dir` attribute is used to set the directionality of math formulas, which is often from right to left in Arabic-speaking world. However, languages written from right to left often embed mathematical content written from left to right. Consequently, the `auto` keyword from the HTML `dir` attribute is not recognized and by default the [user agent stylesheet](/en-US/docs/Web/CSS/Cascade#user-agent_stylesheets) resets the direction property on the [`math`](/en-US/docs/Web/MathML/Element/math) element.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- All [global attributes](/en-US/docs/Web/MathML/Global_attributes).
- {{cssxref("direction")}}
- The HTML [`dir`](/en-US/docs/Web/HTML/Global_attributes#dir) global attribute
| 0 |
data/mdn-content/files/en-us/web/mathml/global_attributes | data/mdn-content/files/en-us/web/mathml/global_attributes/mathcolor/index.md | ---
title: mathcolor
slug: Web/MathML/Global_attributes/mathcolor
page-type: mathml-attribute
status:
- deprecated
browser-compat: mathml.global_attributes.mathcolor
---
{{MathMLRef}}{{Deprecated_Header}}
The **`mathcolor`** [global attribute](/en-US/docs/Web/MathML/Global_attributes) sets the [color](/en-US/docs/Web/CSS/color) of a MathML element.
> **Note:** Use CSS for styling MathML whenever possible. The `mathcolor` attribute should only be included for applications that are not CSS-aware and will be overridden by the CSS `color` property, if set.
## Syntax
```html-nolint
<!-- Keyword values -->
<math mathcolor="currentcolor">
<!-- <named-color> values -->
<math mathcolor="red">
<math mathcolor="orange">
<math mathcolor="tan">
<math mathcolor="rebeccapurple">
<!-- <hex-color> values -->
<math mathcolor="#090">
<math mathcolor="#009900">
<math mathcolor="#090a">
<math mathcolor="#009900aa">
<!-- <rgb()> values -->
<math mathcolor="rgb(34, 12, 64, 0.6)">
<math mathcolor="rgb(34 12 64 / 0.6)">
<math mathcolor="rgb(34.6 12 64 / 60%)">
<!-- <hsl()> values -->
<math mathcolor="hsl(30, 100%, 50%, 0.6)">
<math mathcolor="hsl(30 100% 50% / 0.6)">
<math mathcolor="hsl(30.2 100% 50% / 60%)">
<!-- <hwb()> values -->
<math mathcolor="hwb(90 10% 10%)">
<math mathcolor="hwb(90 10% 10% / 0.5)">
<math mathcolor="hwb(90deg 10% 10%)">
<math mathcolor="hwb(1.5708rad 60% 0%)">
<math mathcolor="hwb(.25turn 0% 40% / 50%)">
```
### Values
- {{cssxref("<color>")}}
- : Sets the color of the textual and decorative parts of the element,
including e.g. fraction bars or radical symbols.
## Specifications
{{Specifications}}
- In MathML 3 and earlier versions, a more limited set of values was supported.
Since MathML Core, the syntax matches CSS {{cssxref("<color>")}}
values.
- This attribute was designed for MathML applications that are not CSS-aware.
Since MathML Core, the use of equivalent CSS is recommended instead.
## Browser compatibility
{{Compat}}
## See also
- All [global attributes](/en-US/docs/Web/MathML/Global_attributes).
- {{cssxref("color")}}
| 0 |
data/mdn-content/files/en-us/web/mathml/global_attributes | data/mdn-content/files/en-us/web/mathml/global_attributes/displaystyle/index.md | ---
title: displaystyle
slug: Web/MathML/Global_attributes/displaystyle
page-type: mathml-attribute
browser-compat: mathml.global_attributes.displaystyle
---
{{MathMLRef}}
The **`displaystyle`** [global attribute](/en-US/docs/Web/MathML/Global_attributes) is a boolean setting the [math-style](/en-US/docs/Web/CSS/math-style) of a MathML element.
## Example
In this example, an [munder](/en-US/docs/Web/MathML/Element/munder) element is used to attach a script "A" to a base "∑". By default, the summation symbol is rendered with the [font-size](/en-US/docs/Web/CSS/font-size) inherited from its parent and the A as a scaled down subscript. With the explicit `displaystyle="true"` attribute, the summation symbol is instead drawn bigger and the "A" becomes an underscript.
```html
<math>
<munder>
<mo>∑</mo>
<mi>A</mi>
</munder>
<munder displaystyle="true">
<mo>∑</mo>
<mi>A</mi>
</munder>
</math>
```
## Syntax
```html-nolint
<math displaystyle="true"></math>
<math displaystyle="false"></math>
```
### Values
- `true`
- : Sets the display style to `normal`.
- `false`
- : Sets the display style to `compact`.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- All [global attributes](/en-US/docs/Web/MathML/Global_attributes).
- The [scriptlevel](/en-US/docs/Web/MathML/Global_attributes/scriptlevel) global attribute.
- {{cssxref("font-size")}}
- {{cssxref("math-depth")}}
- {{cssxref("math-style")}}
| 0 |
data/mdn-content/files/en-us/web/mathml/global_attributes | data/mdn-content/files/en-us/web/mathml/global_attributes/href/index.md | ---
title: href
slug: Web/MathML/Global_attributes/href
page-type: mathml-attribute
status:
- non-standard
browser-compat: mathml.global_attributes.href
---
{{MathMLRef}}{{Non-standard_header}}
The **`href`** [global attribute](/en-US/docs/Web/MathML/Global_attributes) creates a hyperlink on the MathML element pointing to the specified URL.
## Example
```html
<!-- Make this math equation a link to Wikipedia's article
about the Pythagorean theorem. -->
<math href="https://en.wikipedia.org/wiki/Pythagorean_theorem">
<mi>c</mi>
<mo>=</mo>
<!-- Make this square root a link to corresponding
SageMath's calculation. -->
<msqrt href="https://sagecell.sagemath.org/?z=eJwrLiwq0TCOM9I2iTPSBAAeqgPO">
<msup>
<mn>3</mn>
<mn>2</mn>
</msup>
<mo>+</mo>
<msup>
<mn>4</mn>
<mn>2</mn>
</msup>
</msqrt>
<mo>=</mo>
<mn>5</mn>
</math>
```
## Specifications
The `href` attribute is not defined in any browser-oriented specification but you can find a description in [MathML 4](https://w3c.github.io/mathml/#interf_link).
## Browser compatibility
{{Compat}}
## See also
- All [global attributes](/en-US/docs/Web/MathML/Global_attributes).
| 0 |
data/mdn-content/files/en-us/web/mathml/global_attributes | data/mdn-content/files/en-us/web/mathml/global_attributes/mathsize/index.md | ---
title: mathsize
slug: Web/MathML/Global_attributes/mathsize
page-type: mathml-attribute
status:
- deprecated
browser-compat: mathml.global_attributes.mathsize
---
{{MathMLRef}}{{Deprecated_Header}}
The **`mathsize`** [global attribute](/en-US/docs/Web/MathML/Global_attributes) sets the [font-size](/en-US/docs/Web/CSS/font-size) of a MathML element.
> **Note:** Use CSS for styling MathML whenever possible. The `mathsize` attribute should only be included for applications that are not CSS-aware and will be overridden by the CSS `font-size` property, if set.
## Syntax
```html-nolint
<!-- <length> values -->
<math mathsize="12px">
<math mathsize="0.8em">
<!-- <percentage> values -->
<math mathsize="80%">
```
### Values
- {{cssxref("<length>")}}
- : A positive {{cssxref("<length>")}} value. For most font-relative units (such as `em` and `ex`), the font size is relative to the parent element's font size.
- {{cssxref("<percentage>")}}
- : A positive {{cssxref("<percentage>")}} value, relative to the parent element's font size.
> **Note:** Some browsers may also accept [legacy MathML lengths](/en-US/docs/Web/MathML/Values#legacy_mathml_lengths).
## Specifications
{{Specifications}}
- In MathML 3 and earlier versions, keywords `small`, `normal`, and `big` as
well as the MathML3-specific syntax for lengths was supported.
Since MathML Core, the syntax matches CSS
{{cssxref("<length-percentage>")}} values.
- This attribute was designed for MathML applications that are not CSS-aware.
Since MathML Core, the use of equivalent CSS is recommended instead.
## Browser compatibility
{{Compat}}
## See also
- All [global attributes](/en-US/docs/Web/MathML/Global_attributes).
- {{cssxref("font-size")}}
| 0 |
data/mdn-content/files/en-us/web/mathml/global_attributes | data/mdn-content/files/en-us/web/mathml/global_attributes/scriptlevel/index.md | ---
title: scriptlevel
slug: Web/MathML/Global_attributes/scriptlevel
page-type: mathml-attribute
browser-compat: mathml.global_attributes.scriptlevel
---
{{MathMLRef}}
The **`scriptlevel`** [global attribute](/en-US/docs/Web/MathML/Global_attributes) sets the [math-depth](/en-US/docs/Web/CSS/math-depth) of a MathML element. It allows overriding rules from the [user agent stylesheet](/en-US/docs/Web/CSS/Cascade#user-agent_stylesheets) that define automatic calculation of [font-size](/en-US/docs/Web/CSS/font-size) within MathML formulas.
## Example
```html
<!-- math-depth defaults to 0 on the <math> root. -->
<math style="font-size: 64pt">
<msubsup>
<!-- math-depth and font-size remain unchanged on the base. -->
<mtext>BASE</mtext>
<!-- math-depth defaults to add(1) within the subscript, so it
is incremented by 1 and the font-size is scaled down once. -->
<mtext>SUBSCRIPT</mtext>
<!-- math-depth defaults to add(1) within the superscript too, but
the scriptlevel attribute tells to increment it by 2 instead,
so the font-size is actually scaled down twice. -->
<mtext scriptlevel="+2">SUPERSCRIPT</mtext>
</msubsup>
</math>
```
## Syntax
```html-nolint
<math scriptlevel="-1"> <!-- decrease math-depth by 1 -->
<math scriptlevel="+2"> <!-- increase math-depth by 2 -->
<math scriptlevel="0"> <!-- reset math-depth to 0 -->
```
### Values
If `<U>` is an unsigned [integer](/en-US/docs/Web/CSS/integer) (i.e. with prefix sign symbol removed) then the accepted values are:
- `<U>`
- : Sets the `math-depth` to value `<U>`. This will set `font-size` of the element to the same value as the one of elements at the specified depth.
- `+<U>`
- : Sets the `math-depth` to value `add(<U>)`. This will scale down `font-size` on the element `<U>` times.
- `-<U>`
- : Sets the `math-depth` to value `add(-<U>)`. This will scale up `font-size` on the element `<U>` times.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- All [global attributes](/en-US/docs/Web/MathML/Global_attributes).
- The [displaystyle](/en-US/docs/Web/MathML/Global_attributes/displaystyle) global attribute.
- {{cssxref("font-size")}}
- {{cssxref("math-depth")}}
- {{cssxref("math-style")}}
| 0 |
data/mdn-content/files/en-us/web/mathml/global_attributes | data/mdn-content/files/en-us/web/mathml/global_attributes/mathbackground/index.md | ---
title: mathbackground
slug: Web/MathML/Global_attributes/mathbackground
page-type: mathml-attribute
status:
- deprecated
browser-compat: mathml.global_attributes.mathbackground
---
{{MathMLRef}}{{Deprecated_Header}}
The **`mathbackground`** [global attribute](/en-US/docs/Web/MathML/Global_attributes) sets the [background-color](/en-US/docs/Web/CSS/background-color) of a MathML element.
> **Note:** Use CSS for styling MathML whenever possible. The `mathbackground` attribute should only be included for applications that are not CSS-aware and will be overridden by the CSS `background-color` property value, if set.
## Syntax
```html-nolint
<!-- Keyword values -->
<math mathbackground="red">
<math mathbackground="indigo">
<!-- Hexadecimal value -->
<math mathbackground="#bbff00"> <!-- Fully opaque -->
<math mathbackground="#bf0"> <!-- Fully opaque shorthand -->
<math mathbackground="#11ffee00"> <!-- Fully transparent -->
<math mathbackground="#1fe0"> <!-- Fully transparent shorthand -->
<math mathbackground="#11ffeeff"> <!-- Fully opaque -->
<math mathbackground="#1fef"> <!-- Fully opaque shorthand -->
<!-- RGB value -->
<math mathbackground="rgb(255 255 128)"> <!-- Fully opaque -->
<math mathbackground="rgb(117 190 218 / 50%)"> <!-- 50% transparent -->
<!-- HSL value -->
<math mathbackground="hsl(50 33% 25%)"> <!-- Fully opaque -->
<math mathbackground="hsl(50 33% 25% / 75%)"> <!-- 75% opaque, i.e. 25% transparent -->
```
### Values
- {{cssxref("<color>")}}
- : The uniform color of the background.
## Specifications
{{Specifications}}
- In MathML 3 and earlier versions, a more limited set of values was supported.
Since MathML Core, the syntax matches CSS {{cssxref("<color>")}}
values.
- This attribute was designed for MathML applications that are not CSS-aware.
Since MathML Core, the use of equivalent CSS is recommended instead.
## Browser compatibility
{{Compat}}
## See also
- All [global attributes](/en-US/docs/Web/MathML/Global_attributes).
- {{cssxref("background-color")}}
| 0 |
data/mdn-content/files/en-us/web | data/mdn-content/files/en-us/web/text_fragments/index.md | ---
title: Text fragments
slug: Web/Text_fragments
page-type: guide
browser-compat:
- html.elements.a.text_fragments
- api.FragmentDirective
- css.selectors.target-text
---
**Text fragments** allow linking directly to a specific portion of text in a web document, without requiring the author to annotate it with an ID, using particular syntax in the URL fragment. Supporting browsers are free to choose how to draw attention to the linked text, e.g. with a color highlight and/or scrolling to the content on the page. This is useful because it allows web content authors to deep-link to other content they don't control, without relying on the presence of IDs to make that possible. Building on top of that, it could be used to generate more effective content-sharing links for users to pass to one another.
## Concepts and usage
Historically, one of the web's key features has always been its ability to provide links between different documents — it is what makes _the web_, a web:
- You can link to the top of a document by linking to its URL, for example:
- [https://developer.mozilla.org/en-US/docs/Web/HTML/Element/a](/en-US/docs/Web/HTML/Element/a).
- You can link to a specific section of a document by linking to its URL plus the _document fragment_ (ID) of that section, for example:
- [https://developer.mozilla.org/en-US/docs/Web/HTML/Element/a#browser_compatibility](/en-US/docs/Web/HTML/Element/a#browser_compatibility).
The issue with linking to specific document fragments is that the author of the linked page needs to put an anchor in place to _actually_ link to. The second example above links to an {{htmlelement("Heading_Elements", "h2")}} element with an ID of `browser_compatibility`:
```html
<h2 id="browser_compatibility">
<a href="#browser_compatibility">Browser compatibility</a>
</h2>
```
If the ID is changed or removed, the document fragment is ignored, and the link just links through to the top of the page. This is reasonable in terms of graceful degradation, but it would arguably be better if the author of the link had full control over where they link to, without needing to rely on the page author.
**Text fragments** make this a reality — they allow link authors to specify text content to link to, rather than document fragments, in a flexible manner.
## Syntax
In a similar manner to document fragments, text fragments are appended onto a URL after a hash symbol (`#`). The syntax however is a bit different:
```url
https://example.com#:~:text=[prefix-,]textStart[,textEnd][,-suffix]
```
The key parts to understand are as follows:
- `:~:`
- : Otherwise known as _the fragment directive_, this sequence of characters tells the browser that what comes next is one or more user-agent instructions, which are stripped from the URL during loading so that author scripts cannot directly interact with them. User-agent instructions are also called directives.
- `text=`
- : A text directive. This provides a text fragment to the browser, defining what text is to be linked to in the linked document.
- `textStart`
- : A text string specifying the start of the linked text.
- `textEnd` {{optional_inline}}
- : A text string specifying the end of the linked text.
- `prefix-` {{optional_inline}}
- : A text string followed by a hyphen specifying what text should precede the linked text. This helps the browser to select the correct linked text, in cases where there are multiple matches.
- `-suffix` {{optional_inline}}
- : A hyphen followed by a text string specifying what text should follow the linked text. This helps the browser to select the correct linked text, in cases where there are multiple matches.
Supporting browsers will scroll to and highlight the first text fragment in the linked document that matches the specified directive. Note that it is possible to specify multiple text fragments to highlight in the same URL by separating them with ampersand (`&`) characters.
### Usage notes
- Text strings used for the `textStart`, `textEnd`, `prefix-`, and `-suffix` values need to be [percent-encoded](/en-US/docs/Web/JavaScript/Reference/Global_Objects/encodeURIComponent).
- Matches are case-insensitive.
- Individual `textStart`, `textEnd`, `prefix-`, and `-suffix` strings need to reside wholly inside the same [block-level element](/en-US/docs/Glossary/Block-level_content), but complete matches can span across multiple element boundaries.
- For security reasons, the feature requires links to be opened in a noopener context — you need to add `rel="noopener"` to your {{htmlelement("a")}} elements, and add `noopener` to your {{domxref("window.open()")}} calls when using this feature.
- Text fragments are invoked only on full (non-same-page), user-initiated navigations.
- Text fragments are only applied to the main frame; text will not be searched inside {{htmlelement("iframe")}}s, and `iframe` navigation will not invoke a text fragment.
- For sites that wish to opt-out, Chromium-based browsers support a [Document Policy](https://wicg.github.io/document-policy/) header value that they can send so user agents will not process Text Fragments:
```http
Document-Policy: force-load-at-top
```
> **Note:** If the provided text fragment does not match any text in the linked document, or if the browser does not support text fragments, the whole text fragment is ignored and the top of the document is linked.
## Examples
### Simple text fragment with textStart
- [https://example.com#:~:text=for](https://example.com#:~:text=for) scrolls to and highlights the first instance of the text `for` in the document.
- [https://developer.mozilla.org/en-US/docs/Web/HTML/Element/a#:~:text=human](/en-US/docs/Web/HTML/Element/a#:~:text=human) scrolls to and highlights the first instance of the text `human` in the document.
- [https://developer.mozilla.org/en-US/docs/Web/HTML/Element/a#:~:text=linked%20URL](/en-US/docs/Web/HTML/Element/a#:~:text=linked%20URL) scrolls to and highlights the first instance of the text `linked URL` in the document.
### textStart and textEnd
- [https://developer.mozilla.org/en-US/docs/Web/HTML/Element/a#:~:text=human,URL](/en-US/docs/Web/HTML/Element/a#:~:text=human,url) scrolls to and highlights the first instance of a text string starting with `human` and ending with `URL`.
- [https://developer.mozilla.org/en-US/docs/Web/HTML/Element/a#:~:text=linked%20URL,defining%20a%20value](/en-US/docs/Web/HTML/Element/a#:~:text=linked%20URL,defining%20a%20value) scrolls to and highlights the first instance of a text string starting with `linked URL` and ending with `defining a value`. Note how the highlighted text spans across multiple block-level elements.
### Examples with prefix- and/or -suffix
- [https://example.com#:~:text=asking-,for](https://example.com#:~:text=asking-,for) scrolls to and highlights the second instance of the text `for` in the document.
- [https://developer.mozilla.org/en-US/docs/Web/HTML/Element/a#:~:text=sent-,referrer](/en-US/docs/Web/HTML/Element/a#:~:text=sent-,referrer) scrolls to and highlights the first instance of the text `referrer` that has the text `sent` directly before it. This is the 5th instance of `referrer` in the document; without the prefix, the first instance would be highlighted.
- [https://developer.mozilla.org/en-US/docs/Web/HTML/Element/a#:~:text=linked%20URL,-'s%20format](/en-US/docs/Web/HTML/Element/a#:~:text=linked%20URL,-'s%20format) scrolls to and highlights the first instance of the text `linked URL` that has the text `'s format` directly following it. This is the 5th instance of `linked URL` in the document; without the suffix, the first instance would be highlighted.
- [https://developer.mozilla.org/en-US/docs/Web/HTML/Element/a#:~:text=downgrade:-,The%20Referer,be%20sent,-to%20origins](/en-US/docs/Web/HTML/Element/a#:~:text=downgrade:-,The%20Referer,be%20sent,-to%20origins) scrolls to and highlights the instance of the text `The Referer ... be sent` that is prefixed by `downgrade:` and suffixed by `to origins`. This illustrates a more complex example where the prefix/suffix are used to home in on the specific text instance you want to link to. Try removing the prefix, for example, and seeing what is matched.
### URLs with multiple text fragments
You can specify multiple text fragments to highlight in the same URL by separating them with ampersand (`&`) characters. Let's look at a couple of examples:
- [https://developer.mozilla.org/en-US/docs/Web/HTML/Element/a#:~:text=Causes&text=linked](/en-US/docs/Web/HTML/Element/a#:~:text=causes&text=linked) scrolls to and highlights the first instances of the text strings `Causes` and `linked`.
- [https://developer.mozilla.org/en-US/docs/Web/HTML/Element/a#:~:text=linked%20URL,-'s%20format&text=Deprecated-,attributes,attribute](/en-US/docs/Web/HTML/Element/a#:~:text=linked%20URL,-'s%20format&text=Deprecated-,attributes,attribute) scrolls to and highlights two text instances:
- The first instance of the text `linked URL` that has the text `'s format` directly following it.
- The first instance of a text string starting with `attributes` and ending with `attribute`, which is prefixed by `Deprecated`.
If you don't see one or more of your text fragments highlighted and you are sure you've got the syntax correct, you might just be highlighting a different instance than the one you expected. It might be highlighted, but offscreen.
### Styling matched text fragments
Browsers are free to style the highlighted text in whatever default way they choose. The [CSS Pseudo-Elements Module Level 4](https://drafts.csswg.org/css-pseudo/#selectordef-target-text) defines a pseudo-element, {{cssxref("::target-text")}}, which allows you to specifying custom styling.
For example, in our [scroll-to-text demo](https://mdn.github.io/css-examples/target-text/index.html#:~:text=From%20the%20foregoing%20remarks%20we%20may%20gather%20an%20idea%20of%20the%20importance) we have the following CSS:
```css
::target-text {
background-color: rebeccapurple;
color: white;
}
```
Try following the above link in a supporting browser to see the effect this has.
### Feature Detectability
The {{domxref("FragmentDirective")}} object, which is accessed via the {{domxref("Document.fragmentDirective")}} property, can be used to test whether or not text fragments are supported in a browser.
Try running the following in a supporting browser's devtools, in a tab with one or more matched text fragments:
```js
document.fragmentDirective;
// returns an empty FragmentDirective object, if supported
// undefined otherwise
```
This functionality is mainly intended for feature detection at present. In the future, the `FragmentDirective` object could include additional information.
## Reference
### API
- {{domxref("FragmentDirective")}}
- : An object representing the text fragments. Currently empty and mainly intended for feature detection.
- {{domxref("Document.fragmentDirective")}}
- : Returns the {{domxref("FragmentDirective")}} for the current document.
### CSS
- {{cssxref("::target-text")}}
- : Represents the highlighted text fragments in the current document. It allows authors to customize the styling of text fragments.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Boldly link where no one has linked before: Text Fragments](https://web.dev/articles/text-fragments)
| 0 |
data/mdn-content/files/en-us/web | data/mdn-content/files/en-us/web/xml/index.md | ---
title: "XML: Extensible Markup Language"
slug: Web/XML
page-type: landing-page
---
{{QuickLinksWithSubpages("/en-US/docs/Web/XML")}}
The **Extensible Markup Language** is a strict serialization of the [Document Object Model](/en-US/docs/Web/API/Document_Object_Model).
{{LandingPageListSubpages}}
| 0 |
data/mdn-content/files/en-us/web/xml | data/mdn-content/files/en-us/web/xml/xml_introduction/index.md | ---
title: XML introduction
slug: Web/XML/XML_introduction
page-type: guide
---
{{QuickLinksWithSubpages("/en-US/docs/Web/XML")}}
XML (Extensible Markup Language) is a markup language similar to {{Glossary("HTML")}}, but without predefined tags to use. Instead, you define your own tags designed specifically for your needs. This is a powerful way to store data in a format that can be stored, searched, and shared. Most importantly, since the fundamental format of XML is standardized, if you share or transmit XML across systems or platforms, either locally or over the internet, the recipient can still parse the data due to the standardized XML syntax.
There are many languages based on XML, including [XHTML](/en-US/docs/Glossary/XHTML), [MathML](/en-US/docs/Web/MathML), [SVG](/en-US/docs/Web/SVG), [RSS](/en-US/docs/Glossary/RSS), and [RDF](/en-US/docs/Glossary/RDF). You can also define your own.
## Structure of an XML document
The whole structure of XML and XML-based languages is built on {{Glossary("tag")}}s.
### XML declaration
XML - declaration is not a tag. It is used for the transmission of the meta-data of a document.
```html
<?xml version="1.0" encoding="UTF-8"?>
```
#### Attributes
- `version`
- : Used version XML in this document.
- `encoding`
- : Used encoding in this document.
### Comments
```html
<!-- Comment -->
```
## "Correct" XML (valid and well-formed)
### Correct design rules
For an XML document to be correct, the following conditions must be fulfilled:
- Document must be well-formed.
- Document must conform to all XML syntax rules.
- Document must conform to semantic rules, which are usually set in an XML schema or a DTD (**[Document Type Definition](/en-US/docs/Glossary/Doctype))**.
### Example
```xml
<?xml version="1.0" encoding="UTF-8"?>
<message>
<warning>
Hello World
<!--missing </warning> -->
</message>
```
Now let's look at a corrected version of that same document:
```xml
<?xml version="1.0" encoding="UTF-8"?>
<message>
<warning>
Hello World
</warning>
</message>
```
A document that contains an undefined tag is invalid. For example, if we never defined the `<warning>` tag, the document above wouldn't be valid.
Most browsers offer a debugger that can identify poorly-formed XML documents.
## Entities
Like HTML, XML offers methods (called entities) for referring to some special reserved characters (such as a greater than sign which is used for tags). There are five of these characters that you should know:
| Entity | Character | Description |
| ---------- | --------- | ----------------------------------------- |
| &lt; | < | Less than sign |
| &gt; | > | Greater than sign |
| &amp; | & | Ampersand |
| &quot; | " | One double-quotation mark |
| &apos; | ' | One apostrophe (or single-quotation mark) |
Even though there are only 5 declared entities, more can be added using the document's [Document Type Definition](/en-US/docs/Glossary/Doctype). For example, to create a new `&warning;` entity, you can do this:
```xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE body [
<!ENTITY warning "Warning: Something bad happened... please refresh and try again.">
]>
<body>
<message> &warning; </message>
</body>
```
You can also use numeric character references to specify special characters; for example, \© is the "©" symbol.
## Displaying XML
XML is usually used for descriptive purposes, but there are ways to display XML data. If you don't define a specific way for the XML to be rendered, the raw XML is displayed in the browser.
One way to style XML output is to specify [CSS](/en-US/docs/Web/CSS) to apply to the document using the `xml-stylesheet` processing instruction.
```xml
<?xml-stylesheet type="text/css" href="stylesheet.css"?>
```
There is also another more powerful way to display XML: the **Extensible Stylesheet Language Transformations** ([XSLT](/en-US/docs/Web/XSLT)) which can be used to transform XML into other languages such as HTML. This makes XML incredibly versatile.
```xml
<?xml-stylesheet type="text/xsl" href="transform.xsl"?>
```
## Recommendations
This article is obviously only a very brief introduction to what XML is, with a few small examples and references to get you started. For more details about XML, you should look around on the Web for more in-depth articles.
Learning the HyperText Markup Language ([HTML](/en-US/docs/Web/HTML)) will help you better understand XML.
## See also
- [XML.com](https://www.xml.com/)
- [Extensible Markup Language (XML) @ W3.org](https://www.w3.org/XML/)
- [Using XML: A List Apart](https://alistapart.com/article/usingxml/)
| 0 |
data/mdn-content/files/en-us/web/xml | data/mdn-content/files/en-us/web/xml/parsing_and_serializing_xml/index.md | ---
title: Parsing and serializing XML
slug: Web/XML/Parsing_and_serializing_XML
page-type: guide
---
{{QuickLinksWithSubpages("/en-US/docs/Web/XML")}}
At times, you may need to parse {{Glossary("XML")}} content and convert it into a {{Glossary("DOM")}} tree, or, conversely, serialize an existing DOM tree into XML. In this article, we'll look at the objects provided by the web platform to make the common tasks of serializing and parsing XML easy.
- {{domxref("XMLSerializer")}}
- : Serializes DOM trees, converting them into strings containing XML.
- {{domxref("DOMParser")}}
- : Constructs a DOM tree by parsing a string containing XML, returning a {{domxref("XMLDocument")}} or {{domxref("Document")}} as appropriate based on the input data.
- {{domxref("fetch()")}}
- : Loads content from a URL. XML content is returned as a text string which you can parse using `DOMParser`.
- {{domxref("XMLHttpRequest")}}
- : The precursor to `fetch()`. Unlike the `fetch()` API, `XMLHttpRequest` can return a resource as a `Document`, via its {{domxref("XMLHttpRequest.responseXML", "responseXML")}} property.
- [XPath](/en-US/docs/Web/XPath)
- : A technology for creating strings that contain addresses for specific portions of an XML document, and locating XML nodes based on those addresses.
## Creating an XML document
Using one of the following approaches to create an XML document (which is an instance of {{domxref("Document")}}).
### Parsing strings into DOM trees
This example converts an XML fragment in a string into a DOM tree using a {{domxref("DOMParser")}}:
```js
const xmlStr = '<q id="a"><span id="b">hey!</span></q>';
const parser = new DOMParser();
const doc = parser.parseFromString(xmlStr, "application/xml");
// print the name of the root element or error message
const errorNode = doc.querySelector("parsererror");
if (errorNode) {
console.log("error while parsing");
} else {
console.log(doc.documentElement.nodeName);
}
```
### Parsing URL-addressable resources into DOM trees
#### Using XMLHttpRequest
Here is sample code that reads and parses a URL-addressable XML file into a DOM tree:
```js
fetch("example.xml")
.then((response) => response.text())
.then((text) => {
const parser = new DOMParser();
const doc = parser.parseFromString(text, "text/xml");
console.log(doc.documentElement.nodeName);
});
```
This code fetches the resource as a text string, then uses {{domxref("DOMParser.parseFromString()")}} to construct an {{domxref("XMLDocument")}}.
If the document is {{Glossary("HTML")}}, the code shown above will return a {{domxref("Document")}}. If the document is XML, the resulting object is actually an `XMLDocument`. The two types are essentially the same; the difference is largely historical, although differentiating has some practical benefits as well.
> **Note:** There is in fact an {{domxref("HTMLDocument")}} interface as well, but it is not necessarily an independent type. In some browsers it is, while in others it is an alias for the `Document` interface.
## Serializing an XML document
Given a {{domxref("Document")}}, you can serialize the document's DOM tree back into XML using the {{domxref("XMLSerializer.serializeToString()")}} method.
Use the following approaches to serialize the contents of the XML document you created in the previous section.
### Serializing DOM trees to strings
First, create a DOM tree as described in [How to Create a DOM tree](/en-US/docs/Web/API/Document_object_model/How_to_create_a_DOM_tree). Alternatively, use a DOM tree obtained from {{ domxref("fetch()") }}.
To serialize the DOM tree `doc` into XML text, call {{domxref("XMLSerializer.serializeToString()")}}:
```js
const serializer = new XMLSerializer();
const xmlStr = serializer.serializeToString(doc);
```
### Serializing HTML documents
If the DOM you have is an HTML document, you can serialize using `serializeToString()`, but there is a simpler option: just use the {{domxref("Element.innerHTML")}} property (if you want just the descendants of the specified node) or the {{domxref("Element.outerHTML")}} property if you want the node and all its descendants.
```js
const docInnerHtml = document.documentElement.innerHTML;
```
As a result, `docInnerHtml` is a string containing the HTML of the contents of the document; that is, the {{HTMLElement("body")}} element's contents.
You can get HTML corresponding to the `<body>` _and_ its descendants with this code:
```js
const docOuterHtml = document.documentElement.outerHTML;
```
## See also
- [XPath](/en-US/docs/Web/XPath)
- {{domxref("fetch()")}}
- {{domxref("XMLHttpRequest")}}
- {{domxref("Document")}}, {{domxref("XMLDocument")}}, and {{domxref("HTMLDocument")}}
| 0 |
data/mdn-content/files/en-us | data/mdn-content/files/en-us/related/index.md | ---
title: Web-related technologies
slug: Related
page-type: landing-page
---
This section of the site is a home for documentation on web-related technologies that aren't central to the MDN's remit (i.e. they aren't web standards technologies), but are nonetheless related to the web and of interest to web developers.
> **Note:** These documentation resources generally aren't maintained by the MDN writer's team — if you have suggestions or queries related to these resources, check out the landing pages for those technologies for contact details of the relevant maintenance team.
## Technology list
- [IMSC: subtitles and captioning for the Web](/en-US/docs/Related/IMSC)
- : IMSC (TTML Profiles for Internet Media Subtitles and Captions) is a file format for representing subtitles and captions. It uses XML to describe content, timing, layout, and styling. IMSC is very similar to HTML and CSS in concept — in fact, most IMSC styles have a direct equivalent in CSS.
| 0 |
data/mdn-content/files/en-us/related | data/mdn-content/files/en-us/related/imsc/index.md | ---
title: "IMSC: subtitles and captioning for the Web"
slug: Related/IMSC
page-type: guide
---
IMSC (TTML Profiles for Internet Media Subtitles and Captions) is a file format for representing subtitles and captions. It uses XML to describe content, timing, layout, and styling. IMSC is very similar to HTML and CSS in concept — in fact, most IMSC styles have a direct equivalent in CSS.
## Concepts and usage
IMSC is standardized by the W3C, and used around the world by content producers (e.g. 20th Century Fox), online services (e.g. Netflix), and traditional broadcasters (e.g. the BBC). Many platforms and players support it, e.g. iOS devices and the dashJS player.
IMSC supports a wide range of world languages and scripts, and rich styling. In addition to text-based subtitles, IMSC also supports PNG subtitles.
Each IMSC document is self-contained and combines content, timing, layout and styling information. The content of the document is structured using tags similar to those used in HTML such as `<body>`, `<div>`, `<p>`, `<span>`, and `<br>`. Timing and styling are expressed using attributes such as `begin`, `end`, `color`, `tts:backgroundColor`, `tts:fontSize`, `tts:fontFamily` — these are mostly familiar concepts to anyone familiar with CSS.
### Differences between IMSC, HTML, and CSS
IMSC differs from HTML in a number of ways:
- IMSC uses [namespaces](/en-US/docs/Related/IMSC/Namespaces), so that `tts:fontSize` is not the same as `fontSize`, and namespace declarations are required, like
`<tt xmlns="http://www.w3.org/ns/ttml" xmlns:tts="http://www.w3.org/ns/ttml#styling" …>`
- IMSC has stricter rules, for instance `<p>` elements can only be present within `<div>` elements, and cannot be direct children of `<body>` elements.
While attributes names and syntax are similar, styling differs from CSS in a couple of ways:
- Whereas CSS properties use hyphens, like `font-size`, IMSC uses {{Glossary("camel_case", "camel case")}}, like `tts:fontSize`.
- IMSC does not use external stylesheets.
### Differences between IMSC and WebVTT
IMSC is unrelated to [WebVTT](/en-US/docs/Web/API/WebVTT_API), which is another way of making subtitles and captions for the Web.
WebVTT is supported natively to some extent by browsers, while IMSC is not.
There is however an IMSC polyfill, called imscJS, which is used to render all the examples in this documentation. From a developer's perspective, imscJS allows a consistent experience across browsers.
IMSC also supports styles, like `tts:linePadding` and `tts:fillLineGap`, and features, such as support for HDR and stereoscopic 3D, that are useful for subtitle and captions, but not available in WebVTT.
Below is an example that uses `tts:fillLineGap`:
```xml
<tt xmlns="http://www.w3.org/ns/ttml"
xmlns:tts="http://www.w3.org/ns/ttml#styling"
xmlns:itts="http://www.w3.org/ns/ttml/profile/imsc1#styling"
xml:lang="en">
<head>
<styling>
<style xml:id="defaultStyle"
tts:fontSize="125%"
tts:lineHeight="120%"/>
<style xml:id="spanStyle"
tts:backgroundColor="black"
tts:color="white"/>
<style xml:id="fillGap"
itts:fillLineGap="true"/>
</styling>
<layout>
<region xml:id="top"
tts:origin="5% 5%"
tts:extent="90% 40%"
tts:textAlign="center"
tts:displayAlign="before"/>
<region xml:id="bottom"
tts:origin="5% 55%"
tts:extent="90% 40%"
tts:textAlign="center"
tts:displayAlign="after"/>
</layout>
</head>
<body style="defaultStyle">
<div>
<p region="top">
<span style="spanStyle">Without itts:fillLineGap<br/>
Gaps between lines appear.</span>
</p>
<p region="bottom" style="fillGap">
<span style="spanStyle">With itts:fillLineGap<br/>
Gaps between lines are "filled".<br/></span>
</p>
</div>
</body>
</tt>
```
{{EmbedGHLiveSample("imsc-examples/fillLineGap/fillLineGap.html", '100%', '256px')}}
… and an example that uses `ebutts:linePadding`:
{{EmbedGHLiveSample("imsc-examples/linePadding/linePadding.html", '100%', '256px')}}
Last but not least, IMSC is compatible with SMPTE-TT and EBU-TT-D, which are widely used in the USA and in Europe. IMSC is also actively used in the authoring of TV and movie content. Implementing IMSC support therefore removes the need for conversion to WebVTT.
In contrast to IMSC, which uses markup, WebVTT uses a combination of CSS and plaintext.
## Tutorials
- [IMSC basics](/en-US/docs/Related/IMSC/Basics)
- : This takes you through what you need to get started with IMSC, including basic document structure, and the basics of how to style, time, and position subtitles. These topics will be expanded on later in their own tutorials.
- [Using the imscJS polyfill](/en-US/docs/Related/IMSC/Using_the_imscJS_polyfill)
- : You currently need a polyfill to render IMSC on the web. imscJS is a good choice as it is actively maintained and has almost complete coverage of the IMSC features. This article hows you how to make use of imscJS and how to integrate it on your own website.
- [Styling IMSC documents](/en-US/docs/Related/IMSC/Styling)
- : IMSC offers many options for styling documents, and most of the IMSC styling properties have direct CSS equivalents, making them familiar to web developers. In this guide you'll learn a bit more about IMSC styling including the difference between inline and referential styling, and efficient styling using inheritance and region styling.
- [Subtitle placement in IMSC](/en-US/docs/Related/IMSC/Subtitle_placement)
- : IMSC allows the author to precisely control the position of subtitles, such that the text is positioned next to the speaker or to avoid obscuring an important content in your video. Learn how to define a subtitle region and how to define its width and height.
- [Namespaces in IMSC](/en-US/docs/Related/IMSC/Namespaces)
- : This article covers the subject of XML namespaces, giving you enough information to recognize their usage in IMSC, and be able to use it effectively.
- [Timing in IMSC](/en-US/docs/Related/IMSC/Timing_in_IMSC)
- : When building an IMSC document, each defined piece of text must include timing information to specify when it should appear. There are multiple ways to describe when a subtitle should start and stop displaying, with pros and cons to each method.
- [Mapping video time codes to IMSC](/en-US/docs/Related/IMSC/Mapping_video_time_codes_to_IMSC)
- : Mapping the time or time code value that is seen within a video track or video editor timeline to an IMSC document can be a little tricky. There are a few different issues that you'll need to be aware of, which we'll cover in this article.
- [IMSC and other standards](/en-US/docs/Related/IMSC/IMSC_and_other_standards)
- : IMSC is the result of an international effort to bring together popular profiles of [TTML](https://www.w3.org/TR/ttml/), like [EBU-TT-D](https://tech.ebu.ch/publications/tech3380) and [SMPTE-TT](https://ieeexplore.ieee.org/document/7291854/). This article provides an overview how IMSC is related to these other subtitle standards, and explains the differences between the versions of IMSC.
## Reference
- [TTML Profiles for Internet Media Subtitles and Captions](https://www.w3.org/TR/ttml-imsc/all/)
## Tools
- imscJS polyfill
- : IMSC documents can be rendered in browsers using the [imscJS](https://github.com/sandflow/imscJS) polyfill.
- [dash.js](https://github.com/Dash-Industry-Forum/dash.js/wiki)
- : The reference player of the DASH Industry Forum with IMSC support.
## Specifications
- [TTML Profiles for Internet Media Subtitles and Captions 1.2](https://w3c.github.io/imsc/imsc1/spec/ttml-ww-profiles.html)
## Browser compatibility
IMSC does not have native support in browsers at this current moment, but it can be used to effectively render timed text in web documents via the [imscJS](https://github.com/sandflow/imscJS) polyfill.
## See also
- [Timed Text Working Group](https://www.w3.org/AudioVideo/TT/)
- : The IMSC standard is developed by the W3C Timed Text Group, which you are encouraged to join if you wish to contribute directly to the standard.
- [IMSC standards repository](https://github.com/w3c/imsc)
- : At the IMSC GitHub repository you can provide feedback on the specifications and file issues
- [Web Video Text Tracks Format (WebVTT)](/en-US/docs/Web/API/WebVTT_API)
- : WebVTT is another mechanism for implementing captions and subtitles on the web, which has some native support in browsers and some useful features.
## Docs project team
Team:
- Dave Kneeland
- Pierre-Anthony Lemieux
- Andreas Tai
If you want to get involved with documenting IMSC, please contact [Andreas Tai](mailto:[email protected]).
<section id="Quick_links">
<ol>
<li><a href="/en-US/docs/Related/IMSC/"><strong>IMSC</strong></a></li>
<li class="toggle">
<details open>
<summary>IMSC guides</summary>
<ol>
<li><a href="/en-US/docs/Related/IMSC/Basics">IMSC basics</a></li>
<li><a href="/en-US/docs/Related/IMSC/Using_the_imscJS_polyfill">Using the imscJS polyfill</a></li>
<li><a href="/en-US/docs/Related/IMSC/Styling">Styling IMSC documents</a></li>
<li><a href="/en-US/docs/Related/IMSC/Subtitle_placement">Subtitle placement in IMSC</a></li>
<li><a href="/en-US/docs/Related/IMSC/Namespaces">Namespaces in IMSC</a></li>
<li><a href="/en-US/docs/Related/IMSC/Timing_in_IMSC">Timing in IMSC</a></li>
<li><a href="/en-US/docs/Related/IMSC/Mapping_video_time_codes_to_IMSC">Mapping video time codes to IMSC</a>
</li>
<li><a href="/en-US/docs/Related/IMSC/IMSC_and_other_standards">IMSC and other standards</a></li>
</ol>
</details>
</li>
</ol>
</section>
| 0 |
data/mdn-content/files/en-us/related/imsc | data/mdn-content/files/en-us/related/imsc/using_the_imscjs_polyfill/index.md | ---
title: Using the imscJS polyfill
slug: Related/IMSC/Using_the_imscJS_polyfill
page-type: guide
---
You currently need a polyfill to render IMSC on the web. imscJS is a good choice as it is actively maintained and has almost complete coverage of the IMSC features. This article shows you how to make use of imscJS and how to integrate it on your own website.
## Introducing imscJS
[imscJS](https://github.com/sandflow/imscJS) is a JavaScript library for rendering IMSC documents to HTML. Below we will first go through a simple example how to use imscJS, then we'll look at a more complex example that actually renders subtitles on top of video at appropriate times. You can find the source code of the [first sample on GitHub](https://github.com/mdn/imsc-examples/blob/main/imscjs-simple-sample/imscjs-simple-sample.html).
## Embedding imscJS
First you need to embed the imscJS library:
```html
<script src="https://unpkg.com/[email protected]/build/umd/imsc.all.min.js">
```
Once the imscJS library is loaded, it can be used to render an IMSC document in three distinct steps, explained in the below sections.
## Parsing the IMSC document
First of all, the IMSC document is parsed into an immutable JavaScript object (`doc`, in our case):
```js
const doc = imsc.fromXML(source);
```
This step needs to happen only once for every IMSC document. The `doc` object has a single method, `getMediaTimeEvents()`, which returns an array of time offsets (in seconds) indicating where the visual representation of the IMSC document changes.
```js
const t = doc.getMediaTimeEvents();
```
## Generating an IMSC snapshot
In the second step, a snapshot of the IMSC document at a particular point in time (`isd`) is created using `imsc.generateISD()`.
```js
const isd = imsc.generateISD(doc, t[1]);
```
This point in time does not have to be one of the values returned by `getMediaTimeEvents()`, but it usually is. In the example above, the snapshot is created at the second point in time that the IMSC document changes (`t[1]`). In a typical scenario, an application would, prior to media playback and for every offset returned by `getMediaTimeEvents()`, create a snapshot and schedule its presentation at the specified offset.
## Rendering an IMSC snapshot
In the third and final step, a snapshot is rendered into an HTML {{htmlelement("div")}} using `imsc.renderHTML()`:
```js
const vdiv = document.getElementById("render-div");
imsc.renderHTML(isd, vdiv);
```
## Building an IMSC player
Lets look at a more expanded example and show you how can render subtitles with imscJS on an embedded HTML video. As an example we use the below video with subtitles.
{{EmbedGHLiveSample("imsc-examples/imscjs-demo/imscjs-demo.html", '100%', 320)}}
You can find the [HTML markup](https://github.com/mdn/imsc-examples/blob/main/imscjs-demo/imscjs-demo.html) and the [JavaScript source code](https://github.com/mdn/imsc-examples/blob/main/imscjs-demo/js/index.js) on the [MDN repository for IMSC samples](https://github.com/mdn/imsc-examples).
## Accessing the DOM
An IMSC subtitle is rendered by HTML markup with inline CSS. It represents the IMSC subtitles during a specific period on the timeline of the associated media element. As we saw in the [Rendering an IMSC snapshot](#rendering_an_imsc_snapshot) section above, the markup is inserted into a `<div>` element using the `renderHtml()` method. We can think of this `<div>` element as a container for the HTML that was generated from IMSC code. Later we pass the corresponding DOM element as a parameter to `renderHtml()` method.
For convenience we assign this DOM element to a variable.
```js
const renderDiv = document.getElementById("render-div");
```
We use HTML cues associated with HTML text tracks to throw events whenever an IMSC subtitle should appear or disappear. In this example we use a {{htmlelement("track")}} element that we declared in the HTML markup, but we could also create a text track on the fly and add it to the {{htmlelement("video")}}.
```js
const myVideo = document.getElementById("imscVideo");
const myTrack = myVideo.textTracks[0];
```
We use the `src` attribute of the `<track>` element as a pointer to the IMSC document that contains our subtitle:
```js
const ttmlUrl = myVideo.getElementsByTagName("track")[0].src;
```
## Retrieving the IMSC file
The browser will not retrieve the document automatically for us. In most browsers only [WebVTT](/en-US/docs/Web/API/WebVTT_API) is implemented at the moment. Therefore, these browsers expect that the value of the `src` attribute points to a WebVTT file. If it doesn't, they don't use it, and we also have no direct access to the file the `src` attribute is pointing to. We use the `src` attribute therefore just to store the URL of the IMSC file. We need to do the work to retrieve the file and read it into a JavaScript string. In the example we use the {{domxref("fetch()")}} API for this task:
```js
const response = await fetch(ttmlUrl);
initTrack(await response.text());
```
## Setting the text track mode
There is one more side effect. Because browsers get no valid WebVTT file from the `src` attribute, they disable the track. The `mode` property of the text track is set to the value `disable`.
But this is not what we want. In disabled mode a cue does not throw events on its start and end times. Because we need these events for rendering the IMSC subtitles we change the mode of the text track to `hidden`. In this mode the browser will throw the events of the cues but will not render the value of the cue text property.
```js
myTrack.mode = "hidden";
```
After we have set up everything, we can concentrate on implementing the IMSC subtitle rendering.
## Generating "subtitle states"
Above we explained that we need to generate IMSC snapshots. In the following section we go a bit deeper into what that means and why this is necessary.
As we learned in [Parsing the IMSC document](#parsing_the_imsc_document), the first step is to parse the IMSC document into an imscJS object.
```js
const imscDoc = imsc.fromXML(text);
```
We want to use cues for rendering the IMSC subtitles. Each cue has properties representing its start time and end time. The browser engine fires events whenever the timeline of the media hits the start and the end time of a cue. We can register function calls for these events. We use them to render the HTML generated from imscJS and remove it again when required.
But the mapping of IMSC subtitles to start and end times of cues is not as straightforward as you may think. Of course, you could just use `<p>` elements with `begin` and `end` attributes. This would map perfectly to the cue interface with their `start` and `end` properties.
But take the following IMSC code:
```html
<p>
<span begin="1s" end="3s">Hello</span> <span begin="2s" end="3s">world!</span>
</p>
```
This can be taken as an example of an "accumulating" subtitle, where word after word is added to a line. In some countries this is common practice for live captioning.
What happens is the following:
- At second 0 there is no subtitle.
- At second 1 the text "Hello" must appear.
- At second 2 the text "Hello" must still stay "on screen" but the text "world!" needs to be added. So, from second 2 to 3 we have a subtitle representing the text "Hello world!".
To map this into HTML we need at least two cues: one that represents the text "Hello" from second 1-2 and the other representing the text "Hello world!" from second 2-3.
But this is a simplified easy scenario. Imagine that you have 5 more words accumulating. They may have all the same end time but different start times. Or imagine you have a subtitle in a different location (e.g. representing a different speaker). This subtitle is shown in parallel to the other subtitle but the accumulating words may have different start times and therefore different intervals.
Luckily in IMSC and imscJS this scenario is quite easy to cover, because IMSC has a mechanism of stateless subtitle rendering.
Let's have a closer look what that means.
In our HTML/CSS implementation we can think of IMSC subtitles as a rendering layer that is put on top of the video. At each point in time on the media timeline the rendering layer has one specific state. For these "states" IMSC has a conceptual model, the "intermediate synchronous document format", which represents what is eventually rendered in that layer. Each time the rendering needs to change, a new representation is created. What is created is called an **Intermediate Synchronous Document** or **ISD**. This ISD has no dependency on the ISD's that come before or after. It is completely stateless and has all information needed to render the subtitle.
So how can we get the times when the ISD changes?
This is easy: we just call the `getMediaTimeEvents()` method on the imscJS document object (see also [Parsing the IMSC document](#parsing_the_imsc_document)):
```js
const timeEvents = imscDoc.getMediaTimeEvents(); // timeEvents = [0,1,2,3]
```
To get an ISD document that corresponds to a time event we need to call the imscJS method `generateISD()`. We explained this briefly in [Generating an IMSC snapshot](#generating_an_imsc_snapshot). So for the ISD at second 2 we need to do the following:
```js
imsc.generateISD(imscDoc, 2);
```
## Creating text track cues
With two methods we can now generate all necessary states of the IMSC rendering layer. We do this as follows:
- Iterate over the array we get back from `getMediaEvents()`
- For each time event:
- Create a corresponding cue.
- Use an `onenter` event to render the ISD.
- Use an `onexit` event to remove the rendering layer again.
```js
for (let i = 0; i < timeEvents.length; i++) {
const Cue = window.VTTCue || window.TextTrackCue;
let myCue;
if (i < timeEvents.length - 1) {
myCue = new Cue(timeEvents[i], timeEvents[i + 1], "");
} else {
myCue = new Cue(timeEvents[i], myVideo.duration, "");
}
myCue.onenter = function () {
clearSubFromScreen();
const myIsd = imsc.generateISD(imscDoc, this.startTime);
imsc.renderHTML(myIsd, renderDiv);
};
myCue.onexit = function () {
clearSubFromScreen();
};
myTrack.addCue(myCue);
}
```
Let's look at it into more detail.
While we loop through the `timeEvents` we can take the value of the time event as the start time of the cue. We can then use the value of the next time event for the end time of the cue, because this indicates that the rendering layer needs to change:
```js
myCue = new Cue(timeEvents[i], timeEvents[i + 1], "");
```
> **Note:** In most browsers text track cues are currently only implemented for the WebVTT format. So usually you create a cue with all WebVTT properties including the WebVTT text property. We never use these properties but it is important to remember that they are still there. In the constructor we also have to add the VTTCue text as a third parameter.
But how should we calculate the end time of the last time event? It does not have a "next" time event we can take the end time from.
If there is no further time event this actually means that the rendering layer is active until the end of the playtime of the media. So we can set the end time to the duration of the associated media:
```js
myCue = new Cue(timeEvents[i], myVideo.duration, "");
```
Once we construct the cue object we can register the function that is called "on entering" the cue:
```js
myCue.onenter = function () {
clearSubFromScreen();
const myIsd = imsc.generateISD(imscDoc, this.startTime);
imsc.renderHTML(myIsd, renderDiv);
};
```
We generate the ISD that is associated with cue and then use the imscJS method `renderHTML()` to render its corresponding HTML in the "rendering container."
To be sure there is no remaining subtitle layer we first remove the subtitle layer if there is one. For this we define a function we can reuse later when the cue ends:
```js
function clearSubFromScreen() {
const subtitleActive = renderDiv.getElementsByTagName("div")[0];
if (subtitleActive) {
renderDiv.removeChild(subtitleActive);
}
}
```
We call this function again once the `onexit` event of the cue is thrown:
```js
myCue.onexit = function () {
clearSubFromScreen();
};
```
At the end we just need to add the generated cue to the text track:
```js
myTrack.addCue(myCue);
```
## Using native video player controls
Usually you want to give the user some options to control the video playback. At least they should be able to play, pause, and seek. The easiest method would be to use the native video controls of the web browser, right? Yes, this is true, when you do not want any additional features.
Native video player controls are part of the browser and not the HTML markup. Although they react to DOM events and generate some of their own, you do not have direct access to them as a web developer.
This causes two problems when using imscJS:
1. The IMSC HTML overlay covers the complete video. It sits on top of the `<video>` element. Although you can see the player controls (because most of the overlay has a transparent background), pointer events like mouse clicks are not coming through to the controls. Because they can't be accessed by standard CSS you can also not change the z-index of the controls to solve this problem. So, if you always have a subtitle overlay, you will not able be able to stop the video once it has started. This would be a very bad user experience.
2. Usually the native video player controls have a caption user interface. You can select a text track or to switch off the rendering of subtitles. Unfortunately, the caption interface only controls the rendering of WebVTT subtitles. The browser does not know that we are rendering subtitles with imscJS, so these controls will have no effect.
For the first problem there is a straightforward CSS solution. We need to set the CSS property `pointer-events` to `none` (see the [sample code](https://github.com/mdn/imsc-examples/blob/main/imscjs-demo/css/style.css) on GitHub for the complete CSS).
```css
#render-div {
pointer-events: none;
}
```
This has the effect that pointer events are going "through" the overlay (see [reference documentation for point events](/en-US/docs/Web/CSS/pointer-events) for more details).
The caption user interface problem is a bit harder to solve. Although we can listen to events, activating a track using the caption user interface will also activate the rendering of corresponding WebVTT. As we are using VTTCues for IMSC rendering, this can course undesired presentation behavior. The text property of the VTTCue has always the empty string as value but in some browser this may lead nonetheless to the rendering of artefacts.
the best solution is to building your own custom controls. Find out how in our [Creating a cross-browser video player](/en-US/docs/Web/Media/Audio_and_video_delivery/cross_browser_video_player) tutorial.
<section id="Quick_links">
<ol>
<li><a href="/en-US/docs/Related/IMSC/"><strong>IMSC</strong></a></li>
<li class="toggle">
<details open>
<summary>IMSC guides</summary>
<ol>
<li><a href="/en-US/docs/Related/IMSC/Basics">IMSC basics</a></li>
<li><a href="/en-US/docs/Related/IMSC/Using_the_imscJS_polyfill">Using the imscJS polyfill</a></li>
<li><a href="/en-US/docs/Related/IMSC/Styling">Styling IMSC documents</a></li>
<li><a href="/en-US/docs/Related/IMSC/Subtitle_placement">Subtitle placement in IMSC</a></li>
<li><a href="/en-US/docs/Related/IMSC/Namespaces">Namespaces in IMSC</a></li>
<li><a href="/en-US/docs/Related/IMSC/Timing_in_IMSC">Timing in IMSC</a></li>
<li><a href="/en-US/docs/Related/IMSC/Mapping_video_time_codes_to_IMSC">Mapping video time codes to IMSC</a>
</li>
<li><a href="/en-US/docs/Related/IMSC/IMSC_and_other_standards">IMSC and other standards</a></li>
</ol>
</details>
</li>
</ol>
</section>
| 0 |
data/mdn-content/files/en-us/related/imsc | data/mdn-content/files/en-us/related/imsc/timing_in_imsc/index.md | ---
title: Timing in IMSC
slug: Related/IMSC/Timing_in_IMSC
page-type: guide
---
When building an IMSC document, each defined piece of text must include timing information to specify when it should appear. There are multiple ways to describe when a subtitle should start and stop displaying, with pros and cons to each method. This article explains those different methods.
If you have not already read the [IMSC document with timing](/en-US/docs/Related/IMSC/Basics#timing) section in the [IMSC basics](/en-US/docs/Related/IMSC/Basics) article, you should do so now and then return here — it contains an initial overview of how to describe timing events.
## Different ways to describe timing
There are three primary ways of describing the time expression values within an IMSC document.
- [Seconds.fraction](#seconds.fraction): Specifying simple second values. This is the simplest approach to take; we've already seen this used earlier in the article series.
- [HH:MM:SS.fraction](#hhmmss.fraction): Specifying more complex times in the format `HH:MM:SS`. This is similar to only using Seconds, and is one of the most common time expressions in IMSC files.
- [Frames](#frames): Specifying start and end times in terms of numbers of frames rather than seconds. This is the other most common time expression used in IMSC files. The advantage to this approach is that the frame number directly corresponds to the frame number in the video file.
### Seconds.fraction
```xml
<p begin="1s" end="2s">Hello, I am Mork from Ork</p>
```
This method for describing the `begin` and `end` values in the IMSC document is very simple — you just include a number with "s" (seconds) appended. It does not require the user to declare the frame rate of the corresponding media. These values must be mapped to the video frame that the text is synchronized with. Fractional values will always round up to the nearest video frame.
### HH:MM:SS.fraction
```xml
<p begin="00:00:01.00" end="00:00:02.00">Hello, I am Mork from Ork</p>
```
This method for describing the begin and end values in the IMSC document is essentially the same as using seconds, except for the fact that you are expressing those values as hours, minutes, and seconds. This allows you to easily set longer, more precise times.
### Frames
```xml
<tt xmlns="http://www.w3.org/ns/ttml"
xml:lang="en"
ttp:frameRate="24"
ttp:frameRateMultiplier="1000 1001">
<body>
<div>
<p begin="24f" end="48f">Hello, I am Mork from Ork</p>
</div>
</body>
</tt>
```
This method requires that the `frameRate` and `frameRateMultiplier` attributes are declared in the root element of the IMSC document. The frame rate describes how many frames are in one second of the video. The multiplier is applied to the `frameRate` to declare how that one second of video is compared with one realtime second.
Let's explain this in little bit more detail.
The `frameRateMultiplier` stems from the problems associated with non-integer frame rates such as 23.98fps (as opposed to an integer frame rate such as 24fps). 24fps means that every second of video has 24 frames in it, and that second is the same as a realtime second. 23.98fps means that every second of video has 24 frames in it, and that second is slightly longer than a realtime second. The `frameRateMultiplier` defines the duration of each frame when compared to realtime.
Imagine that you had a stopwatch and timed yourself watching a movie. If that movie was playing back at a speed of 24fps, once your media player says you have watched exactly 1 hour of it, your stopwatch would say 01:00:00.00. Now if that movie was playing back at a speed of 23.98fps, once your media player says you have watched exactly 1 hour of it, your stopwatch would now say 01:00:03.6 (1 hour × (24/23.98)).
Make sense?
To describe a frame rate of 23.976fps, the following `frameRate` and `frameRateMultiplier` values would be used:
```xml
<tt xmlns="http://www.w3.org/ns/ttml"
xml:lang="en"
ttp:frameRate="24"
ttp:frameRateMultiplier="1000 1001">
```
This is actually saying that each second of 24 frames should play back at a speed of (24 \* (1000/1001)), or 23.98fps.
Now that a frame rate of 23.98 is declared, you are able to describe time expressions in frames, or f.
```xml
<p begin="24f" end="48f">Hello, I am Mork from Ork</p>
```
The advantage of using this method is that the time expression frame number is the same as the frame number of the media asset. A value of 86400f is frame number 86400 in the video file.
> **Note:** You can find an additional explanation of these values in [Mapping video time codes to IMSC](/en-US/docs/Related/IMSC/Mapping_video_time_codes_to_IMSC).
<section id="Quick_links">
<ol>
<li><a href="/en-US/docs/Related/IMSC/"><strong>IMSC</strong></a></li>
<li class="toggle">
<details open>
<summary>IMSC guides</summary>
<ol>
<li><a href="/en-US/docs/Related/IMSC/Basics">IMSC basics</a></li>
<li><a href="/en-US/docs/Related/IMSC/Using_the_imscJS_polyfill">Using the imscJS polyfill</a></li>
<li><a href="/en-US/docs/Related/IMSC/Styling">Styling IMSC documents</a></li>
<li><a href="/en-US/docs/Related/IMSC/Subtitle_placement">Subtitle placement in IMSC</a></li>
<li><a href="/en-US/docs/Related/IMSC/Namespaces">Namespaces in IMSC</a></li>
<li><a href="/en-US/docs/Related/IMSC/Timing_in_IMSC">Timing in IMSC</a></li>
<li><a href="/en-US/docs/Related/IMSC/Mapping_video_time_codes_to_IMSC">Mapping video time codes to IMSC</a>
</li>
<li><a href="/en-US/docs/Related/IMSC/IMSC_and_other_standards">IMSC and other standards</a></li>
</ol>
</details>
</li>
</ol>
</section>
| 0 |
data/mdn-content/files/en-us/related/imsc | data/mdn-content/files/en-us/related/imsc/basics/index.md | ---
title: IMSC basics
slug: Related/IMSC/Basics
page-type: guide
---
IMSC allows you to add subtitles or captions to your online video. In this article we'll take you through what you need to get started, including basic document structure, and the basics of how to style, time, and position subtitles.
> **Note:** IMSC can be used for any kind of timed text you might want to include on a web document, not just for subtitles and captions. But because subtitles and captions represent the most common use cases for IMSC, we will focus on those. For readability we only use the term subtitles. In the technical context we describe, the term "subtitles" is interchangeable with "captions".
## So what is IMSC?
IMSC is a markup language you can use to define timed text for adding subtitles to digital media. It defines the structure of your subtitle content in an XML document. It consists of a series of elements, which you can use to enclose, or wrap, different parts of your subtitle content to make it appear in a certain way or appear at a certain time. Many of these are similar or the same as HTML features.
If you are not already familiar with XML or HTML, read up on them first and then come back here:
- [XML Introduction](/en-US/docs/Web/XML/XML_introduction)
- [HTML Basics](/en-US/docs/Learn/Getting_started_with_the_web/HTML_basics)
> **Note:** If you want to know what you can do with IMSC in real-world scenarios have a look at the expanded example at the end of this tutorial.
## Minimal IMSC document
IMSC is always specified as a complete XML document. As a file it should have the extension "_ttml_".
> **Note:** IMSC does not have native support in browsers at this current moment, but the [imscJS](https://github.com/sandflow/imscJS) polyfill can be used to bridge this gap. All the examples below are rendered by using imscJS. It creates dynamically HTML and CSS from an IMSC XML document.
Let's look at a minimal IMSC document and how it is rendered:
{{EmbedGHLiveSample("imsc-examples/minimal_ttml/minimal.html", '100%', 560)}}
The most important features are as follows:
- `<tt></tt>` — You always start an IMSC document with the root element `<tt>`. You should also specify the default namespace of the document by using the `xmlns` attribute. Don't worry for now about namespaces. We will come to that in a separate guide.
- `xml:lang` — You must specify the language of your content with the `xml:lang` attribute. Note that the `lang` attribute must have the prefix `xml:`, unlike HTML. In IMSC `<tt lang="en">` is not correct — you always have to write `<tt xml:lang="en">`.
- `<body></body>` — As in HTML, the `<body>` element contains all content that you want to show. For IMSC this is typically subtitle content that you want to show at certain time intervals during the playback of a video.
- `<div></div>` — The `<div>` element is used as a container for subtitle content; you always need to have at least one of these. The `<p>` elements that contain the actual subtitle content always have a `<div>` element as their parent.
- `<p></p>` — Text content for subtitles must always be wrapped in a `<p>` element. The element describes a paragraph of text, in a similar fashion to HTML. The main difference is that it can be timed.
## Timing
The minimal IMSC document from the previous example had no timing. That means that the subtitle content will be shown during the complete duration of the video. Usually this is not what you want. Instead you want subtitles to show up at a certain time and then disappear. You can use a combination of the timing attributes `begin`, `end`, and `dur` to make this happen.
Consider the following editable example:
{{EmbedGHLiveSample("imsc-examples/minimal-timing/minimal-timing-player.html", '100%', 590)}}
This includes the following new attributes:
- `begin` — specifies when the subtitle shall start to show (in this case 1s after the video started).
- `end` — specifies when the subtitle shall disappear (in this case 2s after the video started).
Play around with the second values in the code sample and push the reload button when you are ready.
> **Note:** The end times in IMSC are not "inclusive". The subtitle "Hello, I am Mork from Ork." is not shown anymore when it reaches the second value in time.
You can also use the `dur` attribute for timing:
{{EmbedGHLiveSample("imsc-examples/minimal-timing/minimal-timing-player-dur.html", '100%', 590)}}
This attribute can be used as an alternative to the `end` attribute. It defines "how long" the subtitle is shown after the `begin` time has elapsed. In the example the second paragraph shall be displayed for 2s. As it starts at second 2 it shall disappear at second 4.
Note what has changed at second 2 compared to the previous example.
## Colors
Often subtitles are shown on an opaque or semi-opaque background to improve readability. You can use the `backgroundColor` and `color` attributes to change the colors, as demonstrated in this editable example:
{{EmbedGHLiveSample("imsc-examples/minimal-colors/minimal-colors.html", '100%', 620)}}
Here we've introduced the following:
- `tts:backgroundColor` — This attribute sets the background color on the element it is applied to. In this case it is applied to the `<p>` element, or more correctly to the area that is generated by the `<p>`
element. The default background color is `transparent`.
- `tts:color` — This attribute sets the text color on the element it is applied to. The default text color is `white`.
Try setting some other colors for the text and background colors:
- Try other named colors like `lime` or `aqua`.
- Use hexadecimal values like `#00ff00` or `#00ffff`.
- You can use other color schemes like `rgb(0 255 255)`.
- Finally, try semi-transparent variations, like `rgb(0 0 0 / 80%)`.
> **Note:** Don't worry for now about namespaces. We will explain the meaning of `xmlns:tts` and `tts:backgroundColor` in a separate guide.
As explained in the [IMSC Styling](/en-US/docs/Related/IMSC/Styling) guide, it is possible to define a collection of styling properties that can be used any number of times. The style `s1` below is applied three times:
```xml
<tt xmlns="http://www.w3.org/ns/ttml"
xmlns:tts="http://www.w3.org/ns/ttml#styling"
xml:lang="en">
<head>
<styling>
<style xml:id="s1" tts:color="yellow" tts:fontStyle="italic"/>
</styling>
</head>
<body>
<div>
<p>
Hello, I am <span style="s1">Mork</span> from <span style="s1">Ork</span>.<br/>
I come from another <span style="s1">planet</span>.
</p>
</div>
</body>
</tt>
```
## Position, width, and length
If you do not specify a position explicitly, the subtitle shows up by default in the top-left-hand corner of the video. Commonly however you will want to position your subtitle somewhere else, like the bottom center of the video. You need to specify a region to position a subtitle.
See below for a minimal document that uses regions for positioning.
```xml
<tt xmlns="http://www.w3.org/ns/ttml"
xmlns:tts="http://www.w3.org/ns/ttml#styling"
xml:lang="en">
<head>
<layout>
<region tts:origin="10% 80%"
tts:extent="80% 20%"
xml:id="bottom"/>
<region tts:origin="10% 10%"
tts:extent="80% 20%"
xml:id="top"/>
</layout>
</head>
<body>
<div>
<p region="bottom"
tts:backgroundColor="black">
Hello, I am Mork from Ork.
</p>
</div>
</body>
</tt>
```
This includes the following new features:
- `<head></head>` — As in HTML, the `<head>` element acts as a container for all the stuff you want to include in an IMSC document that isn't subtitle content, most commonly metadata about the content or document. You'll use it mostly to store positioning and styling information.
- `<layout></layout>` — This element acts as a wrapper for positioning information. It has `<region>` elements as its children.
- `<region></region>` — this element can be used to define `region`s, rectangular areas you can place on top of your video. They have a defined position, width, and height, plus an `id` to uniquely identify them. You can think of it as being similar to a `<div>` element in HTML that is given an absolute position, width, and height via CSS. If subtitle content is "linked" to a region (by specifying the region's `id` in its `region` attribute), it will be shown inside the area generated by that region.
- `xml:id` - the `xml:id` attribute. The value of the `xml:id` attribute is a string that can be used to link subtitle content to a `region`.
- `tts:origin` — This attribute defines the position of the top-left corner of the region. It uses the % (percentage) metric. The first value defines how far the top left corner of the region is pushed to the right — in this case the value `10%` places the region 10% of the video's width to the right. The second value defines how far the top left corner of the region is placed towards the bottom of the video — in this case the value `80%` pushes the top left corner of the region 80% of the video's height towards the bottom of the video.
- `tts:extent` — This attribute defines the width and height of the region. In this case `80%` sets the width to 80% of the video's width, and `20%` sets the height of the region to 20% of the video's height.
- `region` — setting this on some subtitle content and then giving it a region's `xml:id` as its value causes it to _reference_ that region, meaning that at the specified time, it will appear in the area defined by that region. So here, the value `bottom` places the subtitle content represented by this `<p>` element in the region with an `xml:id` of `bottom`.
This sample will be rendered as shown below. Give it a try and play around with the code in the two boxes. You could for example set the `tts:origin` attribute to "_0% 0%_". Or see what happens when you change the value of the `region` attribute of the `<p>` element to "_top_".
{{EmbedGHLiveSample("imsc-examples/minimal-region/minimal-region.html", '100%', 650)}}
## Expanded example
The more expanded example below gives you an idea what you can do with IMSC after you worked through our tutorials.
{{EmbedGHLiveSample("imsc-examples/basic-expanded/basics-expanded.html", '100%', 300)}}
```xml
<?xml version="1.0" encoding="UTF-8"?>
<tt
xmlns="http://www.w3.org/ns/ttml" xmlns:tts="http://www.w3.org/ns/ttml#styling"
xmlns:ttp="http://www.w3.org/ns/ttml#parameter" xml:lang="en" ttp:timeBase="media">
<head>
<styling>
<style xml:id="defaultStyle" tts:fontFamily="Verdana, Arial" tts:fontSize="100%"
tts:textAlign="center"/>
<style xml:id="alignStart" tts:textAlign="start"/>
<style xml:id="alignCenter" tts:textAlign="center"/>
<style xml:id="alignEnd" tts:textAlign="end"/>
<style xml:id="textWhite" tts:color="#FFFFFF"/>
<style xml:id="titleHeading" tts:fontSize="300%"/>
<style xml:id="spanDefaultStyle" tts:backgroundColor="#000000" tts:color="#FFFFFF"/>
<style xml:id="monoFont" tts:fontFamily="Lucida Console, Monaco, monospace"/>
<style xml:id="sansserifFont" tts:fontFamily="Impact, Charcoal, sans-serif"/>
<style xml:id="comicFont" tts:fontFamily="Comic Sans MS, cursive, sans-serif"/>
<style xml:id="blueText" tts:color="#00FFFF" tts:backgroundColor="#000000"/>
<style xml:id="limeText" tts:color="#00FF00" tts:backgroundColor="#000000"/>
<style xml:id="fuchsiaText" tts:color="#FF00FF" tts:backgroundColor="#000000"/>
<style xml:id="yellowText" tts:color="#FFFF00" tts:backgroundColor="#000000"/>
</styling>
<layout>
<region xml:id="rTop" tts:origin="10% 10%" tts:extent="80% 80%" tts:displayAlign="before"/>
<region xml:id="rCenter" tts:origin="10% 10%" tts:extent="80% 80%" tts:displayAlign="center"/>
<region xml:id="rBottom" tts:origin="10% 10%" tts:extent="80% 80%" tts:displayAlign="after"/>
</layout>
</head>
<body style="defaultStyle">
<div>
<p xml:id="p1" begin="00:00:01" end="00:00:03" region="rCenter" style="alignCenter">
<span style="titleHeading">IMSC Demo</span>
</p>
<p xml:id="p2" begin="00:00:03" end="00:00:05" region="rBottom" style="alignCenter">
<span style="spanDefaultStyle">You </span><span style="blueText">can</span><span
style="yellowText"> apply</span><span style="fuchsiaText"> different</span><span
style="limeText"> colors, </span>
</p>
<p xml:id="p3" begin="00:00:05" end="00:00:07" region="rBottom" style="alignCenter">
<span style="monoFont">use</span><span style="sansserifFont"> different</span><span
style="comicFont"> fonts,</span>
</p>
<p xml:id="p4" begin="00:00:07" end="00:00:09" region="rBottom" style="alignCenter">
<span>set </span><span tts:fontSize="150%">the</span><span tts:fontSize="200%"> font
size.</span>
</p>
<p xml:id="p5" begin="00:00:09" end="00:00:11" region="rBottom" style="alignStart">
<span style="spanDefaultStyle">Align at the start, </span><br/>
</p>
<p xml:id="p6" begin="00:00:11" end="00:00:13" region="rBottom" style="alignCenter">
<span style="spanDefaultStyle">center and</span>
</p>
<p xml:id="p7" begin="00:00:13" end="00:00:15" region="rBottom" style="alignEnd">
<span style="spanDefaultStyle">end</span><br/>
</p>
<p xml:id="p8" begin="00:00:15" end="00:00:17" region="rTop" style="alignCenter">
<span style="spanDefaultStyle">or vertically at the top, </span><br/>
</p>
<p xml:id="p9" begin="00:00:17" end="00:00:19" region="rCenter" style="alignCenter">
<span style="spanDefaultStyle">center and </span>
</p>
<p xml:id="p10" begin="00:00:19" end="00:00:21" region="rBottom" style="alignCenter">
<span style="spanDefaultStyle">bottom.</span>
</p>
</div>
</body>
</tt>
```
## Summary
That's it for your crash course in IMSC code basics! We've only really scratched the surface here, and you'll go much deeper into the above topics in subsequent articles.
<section id="Quick_links">
<ol>
<li><a href="/en-US/docs/Related/IMSC/"><strong>IMSC</strong></a></li>
<li class="toggle">
<details open>
<summary>IMSC guides</summary>
<ol>
<li><a href="/en-US/docs/Related/IMSC/Basics">IMSC basics</a></li>
<li><a href="/en-US/docs/Related/IMSC/Using_the_imscJS_polyfill">Using the imscJS polyfill</a></li>
<li><a href="/en-US/docs/Related/IMSC/Styling">Styling IMSC documents</a></li>
<li><a href="/en-US/docs/Related/IMSC/Subtitle_placement">Subtitle placement in IMSC</a></li>
<li><a href="/en-US/docs/Related/IMSC/Namespaces">Namespaces in IMSC</a></li>
<li><a href="/en-US/docs/Related/IMSC/Timing_in_IMSC">Timing in IMSC</a></li>
<li><a href="/en-US/docs/Related/IMSC/Mapping_video_time_codes_to_IMSC">Mapping video time codes to IMSC</a>
</li>
<li><a href="/en-US/docs/Related/IMSC/IMSC_and_other_standards">IMSC and other standards</a></li>
</ol>
</details>
</li>
</ol>
</section>
| 0 |
data/mdn-content/files/en-us/related/imsc | data/mdn-content/files/en-us/related/imsc/imsc_and_other_standards/index.md | ---
title: IMSC and other standards
slug: Related/IMSC/IMSC_and_other_standards
page-type: guide
---
IMSC is the result of an international effort to bring together popular profiles of [TTML](https://www.w3.org/TR/ttml/), like [EBU-TT-D](https://tech.ebu.ch/publications/tech3380) and [SMPTE-TT](https://ieeexplore.ieee.org/document/7291854). This article provides an overview how IMSC is related to these other subtitle standards, and explains the differences between the versions of IMSC.
## IMSC spec genealogy
[TTML Profiles for Internet Media Subtitles and Captions](https://www.w3.org/TR/ttml-imsc/all/) (or IMSC) is a constrained version of the Timed Text Markup Language for worldwide subtitles and captions family of specifications.
IMSC was designed to be a practical application of SMPTE-TT ([SMPTE ST 2052-1](https://ieeexplore.ieee.org/document/7291854/)), which is designated as a safe-harbor format by the [FCC](https://www.law.cornell.edu/cfr/text/47/79.103). As a result, most SMPTE-TT documents should render correctly using IMSC renderers (see [the limitations](https://www.w3.org/TR/ttml-imsc1.0.1/#smpte-tt-smpte-st-2052-1)), and the conversion guidelines from CTA 608/708 to SMPTE-TT ([SMPTE RP 2052-10](https://ieeexplore.ieee.org/document/7289645/) and [SMPTE RP 2052-11](https://ieeexplore.ieee.org/document/7290363/)) are also applicable to IMSC.
IMSC is also a syntactic superset of both [SDP-US](https://www.w3.org/TR/ttml10-sdp-us/) and [EBU-TT-D](https://tech.ebu.ch/publications/tech3380), such that documents that conform to either of these two formats are valid IMSC documents and can be rendered by IMSC renderers — see [Compatibility with other TTML-based specifications](https://www.w3.org/TR/2018/REC-ttml-imsc1.0.1-20180424/#interop-examples) for more details.
IMSC traces its origins to the CFF-TT format, and [CFF-TT documents](https://www.w3.org/TR/ttml-imsc1.1/#cff-tt) can be converted to IMSC relatively easily.
IMSC is unrelated to [WebVTT](https://www.w3.org/TR/webvtt1/), and does not use the same syntax. [Basic conversion guidelines](https://www.w3.org/TR/webvtt1/) exist.
## Active IMSC versions
Two versions of IMSC are in use today:
- [IMSC 1.0.1](https://www.w3.org/TR/ttml-imsc1.0.1/)
- [IMSC 1.1](https://www.w3.org/TR/ttml-imsc1.1/)
IMSC 1.1 was designed such that valid IMSC 1.0.1 documents are valid IMSC 1.1 documents and will render as intended on an IMSC 1.1 renderer. It does however add important features on top of IMSC 1.0.1:
- Japanese text layout features such as ruby.
- Support for author-controlled luminance when compositing onto absolute luminance High-Dynamic Range video.
- Support for stereoscopic 3D.
> **Note:** IMSC 1.1 also deprecates, but does not prohibit, a limited number features that have no practical use or for which better alternatives exist.
In summary, authors are encouraged to create IMSC 1.0.1 documents if possible and for maximal compatibility, and implementers are encouraged to implement support for IMSC 1.1 for worldwide coverage.
## Summary
This document gives you all you need to know about IMSC and its relationship with other specifications.
<section id="Quick_links">
<ol>
<li><a href="/en-US/docs/Related/IMSC/"><strong>IMSC</strong></a></li>
<li class="toggle">
<details open>
<summary>IMSC guides</summary>
<ol>
<li><a href="/en-US/docs/Related/IMSC/Basics">IMSC basics</a></li>
<li><a href="/en-US/docs/Related/IMSC/Using_the_imscJS_polyfill">Using the imscJS polyfill</a></li>
<li><a href="/en-US/docs/Related/IMSC/Styling">Styling IMSC documents</a></li>
<li><a href="/en-US/docs/Related/IMSC/Subtitle_placement">Subtitle placement in IMSC</a></li>
<li><a href="/en-US/docs/Related/IMSC/Namespaces">Namespaces in IMSC</a></li>
<li><a href="/en-US/docs/Related/IMSC/Timing_in_IMSC">Timing in IMSC</a></li>
<li><a href="/en-US/docs/Related/IMSC/Mapping_video_time_codes_to_IMSC">Mapping video time codes to IMSC</a>
</li>
<li><a href="/en-US/docs/Related/IMSC/IMSC_and_other_standards">IMSC and other standards</a></li>
</ol>
</details>
</li>
</ol>
</section>
| 0 |
data/mdn-content/files/en-us/related/imsc | data/mdn-content/files/en-us/related/imsc/styling/index.md | ---
title: Styling IMSC documents
slug: Related/IMSC/Styling
page-type: guide
---
IMSC offers many options for styling documents, and most of the IMSC styling properties have direct CSS equivalents, making them familiar to web developers. In this guide you'll learn a bit more about IMSC styling including the difference between inline and referential styling, and efficient styling using inheritance and region styling.
## Inline styling
The simplest way of styling content elements like `<p>` or `<span>` is by specifying one or more style attributes, such as `tts:color`, on them. For instance, the following
```xml
<p tts:textAlign="center"
tts:fontSize="64px"
tts:color="red"
tts:fontFamily="proportionalSansSerif"
tts:fontStyle="italic">
Hello, I am Mork from Ork
</p>
```
yields:
{{EmbedGHLiveSample("imsc-examples/inline-styles/inline-styles.html", '100%')}}
## Referential styling
Inline styling is usually avoided since it generates duplication.
Take for example the following two `<span>` elements, which have exactly the same style attributes:
```xml
<p>
<span tts:color="yellow" tts:backgroundColor="black">
Hello, I am Mork from Ork.
</span>
</p>
<p>
<span tts:color="yellow" tts:backgroundColor="black">
I come from another planet.
</span>
</p>
```
In referential styling, styles are defined once and reused throughout the document — in a similar way to how CSS rules can be declared once and then applied to multiple HTML elements via for example, element or class selectors. In IMSC this is achieved by defining a `<styling>` element inside the document `<head>`, inside which is placed one or more `<style>` elements — each one of which defines a set of styles that you can reuse elsewhere. This is illustrated below:
```xml
<tt xmlns="http://www.w3.org/ns/ttml"
xmlns:tts="http://www.w3.org/ns/ttml#styling"
xml:lang="en">
<head>
<styling>
<style xml:id="s1" tts:color="yellow" tts:backgroundColor="black"/>
</styling>
</head>
<body>
<div>
<p>
<span style="s1">Hello, I am Mork from Ork.</span>
</p>
<p>
<span style="s1">I come from another planet.</span>
</p>
</div>
</body>
</tt>
```
Each `<style>` element is given an `id` (`"s1"` in this example):
```xml
<style xml:id="s1" tts:color="yellow" tts:backgroundColor="black"/>
```
which can then be referred to later in the document:
```xml
<span style="s1">Hello, I am Mork from Ork.</span>
```
this is equivalent to:
```xml
<span tts:color="yellow" tts:backgroundColor="black">
Hello, I am Mork from Ork
</span>
```
In other words, referencing a `<style>` element via its `id` and the `style` attribute is equivalent to copying the style properties of the `<style>` element onto the referencing element, as if the style properties had been specified using inline styling.
## Style inheritance
If a style property is inheritable, like `tts:color`, then the style property will apply to all the descendants of an element it is specified on — again, this is similar to CSS and HTML. In the following example, the color `"yellow"` is applied to the text of both `<p>` elements because they are descendants of the `<body>` element.
```xml
<body tts:color="yellow">
<div>
<p>Hello, I am Mork from Ork.</p>
<p>I come from another planet.</p>
</div>
</body>
```
Specifying a style on an element overrides any style specified on an ancestor, for example in the following snippet, the color of the second `<p>`'s text would be set to `"aqua"`:
```xml
<body tts:color="yellow">
<div>
<p>Hello, I am Mork from Ork.</p>
<p tts:color="aqua">I come from another planet.</p>
</div>
</body>
```
## Region styling
Region styling plays a special role in IMSC since a style property specified on a region is inherited by all elements that are selected to the region, starting with the `<body>` element, as if the `<region>` element was the parent of the `<body>` element. For example, in the following example, the text "Hello, I am Mork from Ork" will appear in yellow.
```xml
<tt
xmlns="http://www.w3.org/ns/ttml"
xmlns:tts="http://www.w3.org/ns/ttml#styling"
xml:lang="en">
<head>
<layout>
<region xml:id="r1" tts:color="yellow" />
</layout>
</head>
<body>
<div>
<p region="r1">Hello, I am Mork from Ork</p>
</div>
</body>
</tt>
```
## Combining styles
Referential styling can be applied to style elements themselves:
```xml
<styling>
<style xml:id="s1"
tts:color="yellow"
tts:backgroundColor="black"/>
<style xml:id="s2"
style="s1"
tts:textAlign="left"/>
</styling>
```
Multiple styles can be also applied simultaneously on an element. For example, in the snippet below the style properties of both styles `s1` and `s2` are applied to the same `<p>` element.
```xml
<p style="s1 s2">Hello, I am Mork from Ork</p>
```
<section id="Quick_links">
<ol>
<li><a href="/en-US/docs/Related/IMSC/"><strong>IMSC</strong></a></li>
<li class="toggle">
<details open>
<summary>IMSC guides</summary>
<ol>
<li><a href="/en-US/docs/Related/IMSC/Basics">IMSC basics</a></li>
<li><a href="/en-US/docs/Related/IMSC/Using_the_imscJS_polyfill">Using the imscJS polyfill</a></li>
<li><a href="/en-US/docs/Related/IMSC/Styling">Styling IMSC documents</a></li>
<li><a href="/en-US/docs/Related/IMSC/Subtitle_placement">Subtitle placement in IMSC</a></li>
<li><a href="/en-US/docs/Related/IMSC/Namespaces">Namespaces in IMSC</a></li>
<li><a href="/en-US/docs/Related/IMSC/Timing_in_IMSC">Timing in IMSC</a></li>
<li><a href="/en-US/docs/Related/IMSC/Mapping_video_time_codes_to_IMSC">Mapping video time codes to IMSC</a>
</li>
<li><a href="/en-US/docs/Related/IMSC/IMSC_and_other_standards">IMSC and other standards</a></li>
</ol>
</details>
</li>
</ol>
</section>
| 0 |
data/mdn-content/files/en-us/related/imsc | data/mdn-content/files/en-us/related/imsc/mapping_video_time_codes_to_imsc/index.md | ---
title: Mapping video time codes to IMSC
slug: Related/IMSC/Mapping_video_time_codes_to_IMSC
page-type: guide
---
Mapping the time or time code value that is seen within a video track or video editor timeline to an IMSC document can be a little tricky. There are a few different issues that you'll need to be aware of, which we'll cover in this article.
## Considering time code start times
For the sake of simplicity, we will be assuming that the time code tracks within our video assets start at 00:00:00:00. By default, values within an IMSC document start at 0 and auto increment from there.
If the time code in a video track does not begin at 00:00:00:00, you will have to take the first timestamp in the video track and perform a calculation on that value and all following values so that the initial value is 00:00:00:00. For example, if the first time code value in the video track is 00:59:50:00, then you will have to subtract 00:59:50:00 from all time code values in the video track in order to synchronize it to the IMSC document.
## Frame rates
Mapping an IMSC document to a video asset is quite straightforward when you are working with integer frame rates, such as 24fps, 25fps, and 30fps. The value in your timeline will be the same as the value in the IMSC document. When you are working with fractional frame rates (such as 23.976fps or 29.97fps) however, this gets a bit more complicated.
A frame rate actually describes both the number of frames per second, and the velocity of those frames:
- 25fps describes that there are 25 frames per second (0-24), and those frames play at the same speed as a real time clock.
- 24fps describes that there are 24 frames per second (0-23), and those frames play at the same speed as a real time clock.
- 23.976fps is where things get weird. Like 24fps, it describes that there are 24 frames per second (0-23). Unlike 24fps, however, those 24 frames play at a slightly slower speed than a real time clock. As the frame rate number (23.976fps) implies, in one real time second you almost see 24 frames. It actually takes 1.001 seconds for 24 frames playing back at 23.976fps to display.
In a single second this is not a big deal. As you extend to a few minutes, however, 24fps and 23.976fps will already be a few frames different from one other. As you extend to an hour, they will differ by 3.6s. Here's some math to illustrate this:
01:00:00:00 @ 24fps
3600 (seconds in 1 hour) \* 1.000 (velocity) = 3600 real time seconds
01:00:00:00 @ 23.976fps
3600 (seconds in 1 hour) \* 1.001 (velocity) = 3603.6 real time seconds
This is especially important to understand with IMSC files, since all of the timings in the document represent real time values. For example, if you want to describe an event that synchronizes with 23.976fps video that begins at 01:00:00:00 time code in the video, and ends 1 second later, it would look like this:
`<p begin="3603.6s" end="3604.6s">Hello, I am Mork from Ork</p>`
The important takeaway from this is that if you are synchronizing a video with a fractional frame rate to an IMSC document, the timings will not match. The timings in the IMSC document will slowly get further and further away from the video timings.
## Mitigating the issue
That said, there is actually a different approach to describing the time expression values in the IMSC file, which addresses this problem. As discussed in the [Timing in IMSC](/en-US/docs/Related/IMSC/Timing_in_IMSC) guide, using a time expression syntax of frames will give you a 1:1 correlation of the frame number in the IMSC file and the frame number in the media asset.
The two attributes that must be included to use the frames method are `frameRate` and `frameRateMultiplier`. The frame rate describes how many frames are in one second, and the multiplier is applied to the `frameRate` to describe the actual frame rate in real time seconds. To describe a frame rate of 23.976fps, the following values would be used:
```xml
<tt ttp:frameRate="24" ttp:frameRateMultiplier="1000 1001">
…
</tt>
```
This is saying that there are 24 frames in a second, and those are playing back at a speed of 23.976 frames per real time second (24 \* (1000 / 1001)).
By describing this actual frame rate, you are now able to describe time expressions in frames, or f. This is the actual frame number that the event begins and ends. Here is the same example as above, where the event begins at 01:00:00:00, and ends one second later.
<section id="Quick_links">
<ol>
<li><a href="/en-US/docs/Related/IMSC/"><strong>IMSC</strong></a></li>
<li class="toggle">
<details open>
<summary>IMSC guides</summary>
<ol>
<li><a href="/en-US/docs/Related/IMSC/Basics">IMSC basics</a></li>
<li><a href="/en-US/docs/Related/IMSC/Using_the_imscJS_polyfill">Using the imscJS polyfill</a></li>
<li><a href="/en-US/docs/Related/IMSC/Styling">Styling IMSC documents</a></li>
<li><a href="/en-US/docs/Related/IMSC/Subtitle_placement">Subtitle placement in IMSC</a></li>
<li><a href="/en-US/docs/Related/IMSC/Namespaces">Namespaces in IMSC</a></li>
<li><a href="/en-US/docs/Related/IMSC/Timing_in_IMSC">Timing in IMSC</a></li>
<li><a href="/en-US/docs/Related/IMSC/Mapping_video_time_codes_to_IMSC">Mapping video time codes to IMSC</a>
</li>
<li><a href="/en-US/docs/Related/IMSC/IMSC_and_other_standards">IMSC and other standards</a></li>
</ol>
</details>
</li>
</ol>
</section>
| 0 |
data/mdn-content/files/en-us/related/imsc | data/mdn-content/files/en-us/related/imsc/namespaces/index.md | ---
title: Namespaces in IMSC
slug: Related/IMSC/Namespaces
page-type: guide
---
This article covers the subject of XML namespaces, giving you enough information to recognize their usage in IMSC, and be able to use it effectively.
## What are XML namespaces?
Namespaces are basically the mechanism that you use in XML to differentiate different families of markup (which may have features with the same name), and allow them to be used in the same document.
To help you understand what we mean by this, let's use a real-world example — human family names. There are many people in the world called Mary. One way to tell them apart is by their full names — there can be a Mary Smith and a Mary Jones.
In XML you can also give elements and attributes a "family name", which is their namespace. Namespaces define what family an XML vocabulary belongs to, and generally consist of an identifying string of characters. The `<p>` element is available in both HTML and IMSC, so perhaps you could use the namespace `html` to specify HTML's `<p>`, and `imsc` to specify IMSC's `<p>`?
As with many things, it's not that simple. There might be another XML vocabulary named IMSC and it may not be related to subtitles. This is the same with Mary Smith — There are many Mary Smiths in the world, so more information is needed to tell them apart — their birthdays, hair color, address, etc.
So normally you use longer strings as namespace names. A URL is a very popular form of namespace. It is easy to remember and can also point to further information about that XML vocabulary.
- The W3C standard IMSC uses the URL [`http://www.w3.org/ns/ttml`](https://www.w3.org/ns/ttml/) as the namespace for the `<p>` element.
- For the `<p>` in HTML the namespace is [`http://www.w3.org/1999/xhtml`](https://www.w3.org/1999/xhtml/).
If you use the namespace `http://www.w3.org/ns/ttml` it is quite safe to assume that you are referring to elements from the IMSC vocabulary.
## Setting namespaces in documents
So how do you express in an IMSC document that the `<p>` element belongs to the namespace `http://www.w3.org/ns/ttml`? You need to include the namespace in the document. The simple way to do this could be to include it in each element and attribute that comes from that namespace. You set the namespace of an element by specifying the namespace identifier inside its `xmlns` attribute:
```xml
<tt xmlns="http://www.w3.org/ns/ttml" xml:lang="en">
<body xmlns="http://www.w3.org/ns/ttml">
<div xmlns="http://www.w3.org/ns/ttml">
<p xmlns="http://www.w3.org/ns/ttml">Hello world</p>
</div>
</body>
</tt>
```
But this is not very efficient. Imagine a document with hundreds of subtitles. This would be very verbose.
### Default namespaces
Fortunately, you don't need to do the above — instead you can just use a default namespace. If you set the attribute `xmlns` on the document's root element to the value `http://www.w3.org/ns/ttml`, all elements nested inside the root will inherit this namespace — they will all have that namespace too.
```xml
<tt xmlns="http://www.w3.org/ns/ttml" xml:lang="en">
<body>
<div>
<p>Hello world</p>
</div>
</body>
</tt>
```
In this example the elements `<tt>`, `<body>`, `<div>` and `<p>` have all the namespace `http://www.w3.org/ns/ttml`.
Because nearly all XML elements you need in an IMSC document are in the namespace `http://www.w3.org/ns/ttml`, this makes life a lot easier. If you want to use an element from another vocabulary inside an IMSC document, you can still overwrite the default namespace.
```xml
<tt xmlns="http://www.w3.org/ns/ttml" xml:lang="en">
<head>
<metadata>
<documentPublisher xmlns="urn:ebu:tt:metadata">MDN</documentPublisher>
</metadata>
</head>
<body>
<div>
<p>Hello world</p>
</div>
</body>
</tt>
```
The element `<documentPublisher>` comes from the [EBU Part M metadata](https://tech.ebu.ch/publications/tech3390) vocabulary. The elements in this vocabulary have the namespace `urn:ebu:tt:metadata`. By setting the `xmlns` attribute on the element `<documentPublisher>` to `urn:ebu:tt:metadata`, the namespace `http://www.w3.org/ns/ttml` gets overwritten. Now the `<documentPublisher>` element and all its descendants have the namespace `urn:ebu:tt:metadata`.
A better way to overwrite a default namespace is by using prefixes.
```xml
<tt xmlns="http://www.w3.org/ns/ttml" xml:lang="en"
xmlns:ebuttm="urn:ebu:tt:metadata">
<head>
<metadata>
<ebuttm:documentPublisher>MDN</ebuttm:documentPublisher>
</metadata>
</head>
<body>
<div>
<p>Hello world</p>
</div>
</body>
</tt>
```
We explain in the following section how XML namespace prefixes work.
## Namespaced attributes
We've looked at elements, but how can we specify the namespace of IMSC attributes, and without being too verbose? Contrary to XML elements there is no default namespace for attributes.
In addition, IMSC attributes are contained in more than one namespace. Let's explain further — in IMSC there are different categories of attributes, styling attributes for example. The different categories have different namespaces. For example, all styling attributes have the namespace `http://www.w3.org/ns/ttml#styling`.
As for XML elements, it would be too verbose to always write the complete namespace for each attribute, e.g. `color_http://www.w3.org/ns/ttml#styling="yellow"`.
Luckily XML has the concept of prefixes. A prefix can be thought of as a "shortcut" for a namespace. For example, we can define an attribute namespace on the root element:
```xml
<tt xmlns="http://www.w3.org/ns/ttml" xml:lang="en"
xmlns:tts="http://www.w3.org/ns/ttml#styling"/>
```
By defining `xmlns:tts="http://www.w3.org/ns/ttml#styling` on the `<tt>` element you "bind" the prefix `tts` to the styling namespace. Subsequently, whenever you prefix an attribute (or element) with `tts` (plus a colon) it is given the namespace `http://www.w3.org/ns/ttml#styling`. This way you can write the prefix throughout your document, not the whole namespace each time.
```xml
<tt xmlns="http://www.w3.org/ns/ttml" xml:lang="en"
xmlns:tts="http://www.w3.org/ns/ttml#styling" >
<body>
<div>
<p tts:color="yellow" tts:fontSize="120%">
Hello world
</p>
<p tts:color="white" tts:fontSize="120%">
Hi!
</p>
</div>
</body>
</tt>
```
Much more readable, isn't it?
> **Note:** The namespace/prefix match is only a document-wide agreement. Theoretically you can use another prefix than `tts` to bind the styling namespace. It is completely legal to define `xmlns:foo="http://www.w3.org/ns/ttml#styling"` and then write `<p foo:color="yellow">`. But it makes your IMSC document much more readable if you use the official prefixes listed in [namespace section](https://www.w3.org/TR/ttml-imsc1.0.1/#namespaces) of the IMSC standard.
<section id="Quick_links">
<ol>
<li><a href="/en-US/docs/Related/IMSC/"><strong>IMSC</strong></a></li>
<li class="toggle">
<details open>
<summary>IMSC guides</summary>
<ol>
<li><a href="/en-US/docs/Related/IMSC/Basics">IMSC basics</a></li>
<li><a href="/en-US/docs/Related/IMSC/Using_the_imscJS_polyfill">Using the imscJS polyfill</a></li>
<li><a href="/en-US/docs/Related/IMSC/Styling">Styling IMSC documents</a></li>
<li><a href="/en-US/docs/Related/IMSC/Subtitle_placement">Subtitle placement in IMSC</a></li>
<li><a href="/en-US/docs/Related/IMSC/Namespaces">Namespaces in IMSC</a></li>
<li><a href="/en-US/docs/Related/IMSC/Timing_in_IMSC">Timing in IMSC</a></li>
<li><a href="/en-US/docs/Related/IMSC/Mapping_video_time_codes_to_IMSC">Mapping video time codes to IMSC</a>
</li>
<li><a href="/en-US/docs/Related/IMSC/IMSC_and_other_standards">IMSC and other standards</a></li>
</ol>
</details>
</li>
</ol>
</section>
| 0 |
data/mdn-content/files/en-us/related/imsc | data/mdn-content/files/en-us/related/imsc/subtitle_placement/index.md | ---
title: Subtitle placement in IMSC
slug: Related/IMSC/Subtitle_placement
page-type: guide
---
IMSC allows for very explicit positioning of the text over the video content you are displaying it against. There are a few tricks and best practices that can be used in order to simplify the placement of the on-screen text.
## Considering correct text placement
Creating an IMSC document that has the proper text placement and flow is one of the most crucial things to get correct. Unlike some other subtitle formats, IMSC allows for very explicit placement of the text anywhere on the screen. With that said, the most common subtitle styles used today are bottom centered and top centered on the screen.
## The \<region> element
The `<region>` element essentially creates a box on the screen for the text to appear inside. The on-screen text will never be displayed outside of this box. In addition to describing the size and position of the box in which the text can appear, the `<region>` element also defines the horizontal and vertical alignment of the text.
In the example below, we have defined two regions. Both region boxes are the same size, which is 80% of the image width and 80% of the image height. This box is centered on the screen.
{{EmbedGHLiveSample("imsc-examples/layout-top-bottom/layout-top-bottom.html", '100%', 1000)}}
The important items to consider here are:
- `tts:origin` — the upper left corner of the region box, specified as X Y coordinate values. This should be described in percentage values.
- `tts:extent` — describes how far to the right of the video the region box goes, then how far down.
- `tts:backgroundColor` — describes the color of the region box. This will most commonly be transparent, however you are welcome to fill it in with a color if that works for your design.
- `tts:showBackground` — should be set to `whenActive`. The other allowable value is `always`, which tells the IMSC decoder to display all region boxes with the value of `always` at the same time. This is very unlikely to be something you want to do.
- `tts:textAlign` — the horizontal text justification. Like a word processor, this can be set to `left`, `center`, or `right`. `center` is the most common text justification for subtitles.
- `tts:displayAlign` — the vertical alignment of the text. This can be set to `before`, `center`, or `after`. `before` means that the text will start from the very top of the region box, and flow downwards. `center` means the text will be vertically centered within the region box. After means that the text will start from the very bottom of the region box, and flow upwards.
<section id="Quick_links">
<ol>
<li><a href="/en-US/docs/Related/IMSC/"><strong>IMSC</strong></a></li>
<li class="toggle">
<details open>
<summary>IMSC guides</summary>
<ol>
<li><a href="/en-US/docs/Related/IMSC/Basics">IMSC basics</a></li>
<li><a href="/en-US/docs/Related/IMSC/Using_the_imscJS_polyfill">Using the imscJS polyfill</a></li>
<li><a href="/en-US/docs/Related/IMSC/Styling">Styling IMSC documents</a></li>
<li><a href="/en-US/docs/Related/IMSC/Subtitle_placement">Subtitle placement in IMSC</a></li>
<li><a href="/en-US/docs/Related/IMSC/Namespaces">Namespaces in IMSC</a></li>
<li><a href="/en-US/docs/Related/IMSC/Timing_in_IMSC">Timing in IMSC</a></li>
<li><a href="/en-US/docs/Related/IMSC/Mapping_video_time_codes_to_IMSC">Mapping video time codes to IMSC</a>
</li>
<li><a href="/en-US/docs/Related/IMSC/IMSC_and_other_standards">IMSC and other standards</a></li>
</ol>
</details>
</li>
</ol>
</section>
| 0 |
data/mdn-content/files/en-us | data/mdn-content/files/en-us/mdn/index.md | ---
title: The MDN Web Docs project
slug: MDN
page-type: landing-page
---
{{MDNSidebar}}
**MDN Web Docs** is free-to-use resource on which we document the open web platform. Our mission is to provide _developers_ with the _information_ they need to _easily_ build projects on the _web platform_.
This is the landing page for the MDN Web Docs project itself. Here you'll find guides on how the site works, how we do our documentation, the guidelines and conventions we adhere to, and how you can help.
We invite everyone to help! MDN Web Docs is an open-source project and accepts contributions. There are many different tasks you can help with, from the simple (proofreading and correcting typos) to the complex (writing API documentation).
To find out how to help, visit our [Getting started](/en-US/docs/MDN/Community/Contributing/Getting_started) page. If you want to talk to us and ask questions, join the discussion on the [MDN Web Docs chat rooms](/en-US/docs/MDN/Community/Communication_channels#chat_rooms).
- [Community guidelines](/en-US/docs/MDN/Community)
- : These guides help you get started with contributing to MDN Web Docs. They also cover topics such as how you can help with tasks and issues, open discussions, and suggest content. If you need help or want to contact us, you'll find the information here.
- [Writing guidelines](/en-US/docs/MDN/Writing_guidelines)
- : These guides provide all the information about how to write for MDN Web Docs. They outline the policies for the type of content we write and the type of content we don't write. You'll also find our writing style guide here, how-to guides to perform various content tasks, and also information about the structure of our different pages.
- [MDN Product Advisory Board](/en-US/docs/MDN/MDN_Product_Advisory_Board)
- : The MDN Product Advisory Board's mission is to build collaboration between Mozilla, its documentation team, and the key collaborating organizations that help the MDN community collectively maintain MDN Web Docs.
| 0 |
data/mdn-content/files/en-us/mdn | data/mdn-content/files/en-us/mdn/mdn_product_advisory_board/index.md | ---
title: MDN Product Advisory Board
slug: MDN/MDN_Product_Advisory_Board
page-type: guide
---
{{MDNSidebar}}
MDN Web Docs is a trusted source of technical documentation for web developers, built on an open-source web development documentation platform based on wiki technology, which allows virtually anyone to write and edit content.
The MDN Product Advisory Board's mission is to build collaboration between Mozilla, its documentation team, and the key collaborating organizations that help the MDN community collectively maintain MDN as the most comprehensive, complete, and trusted reference documenting the most important aspects of modern browsers and web standards.
The Product Advisory Board provides advice from external leaders, helping MDN in its mission to provide unbiased, browser-agnostic documentation of HTML, CSS, JavaScript, and Web APIs to ensure that it's the top reference for standards-based web development.
## Members
Current members of the MDN Product Advisory Board are:
- **Reeza Ali**
Principal Program Manager, Microsoft Edge Developer Experiences
- : Reeza Ali is a Program Manager at Microsoft, who leads the content strategy on the Edge developer relations team. Throughout his Microsoft career, he's been a strong advocate for developer success. Over the past 7+ years, he's led several web content documentation teams and projects at Microsoft. He believes that product content and learning experiences play a pivotal role in creating successful outcomes for developers. He's passionate about content strategy, technology, and technical communication.
- **Sukriti Chadha**
Product Manager, Spotify
- : Sukriti Chadha is a mobile developer-turned-product manager at Spotify where she leads efforts in cross-platform accessibility and developer experience on mobile. She also serves as an Invited Expert at the [W3C WCAG (Web Content Accessibility Guidelines) Working Group](https://www.w3.org/WAI/standards-guidelines/wcag/) and the [Mobile Accessibility Task Force (MATF)](https://www.w3.org/WAI/standards-guidelines/mobile/), where she contributes to industry guidelines for accessible web and mobile applications. She built a new way of making data visualization accessible for visually impaired users, and [open-sourced the Android solution in 2019](https://developer.yahoo.com/blogs/612790529269366784/). Sukriti's product role entails managing developer experience roadmaps, automated testing, and embedding accessibility in the product lifecycle.
- **Hermina Condei**
Head of Product CE, Marketing Operations, Mozilla
- : Hermina Condei leads product management and engineering for MDN Web Docs and platform engineering for SUMO at Mozilla. Over the past years, she's driven company-wide projects focused on access and identity management for employees and the community. She also led the product team in the **Open Innovation Group**, with a focus on managing internal and external stakeholders for the team's portfolio of projects.
- **Dominique Hazael-Massieux**
W3C Web Technology Expert including [Telecommunications Vertical champion](https://www.w3.org/Telco/), [Web Real-Time Communications Working Group](https://www.w3.org/groups/wg/webrtc), [Device and Sensors Working Group](https://www.w3.org/das/)
- : Dominique Hazael-Massieux is part of the W3C staff, leading W3C efforts in developer relations. Dom has been working for W3C since 2000, and in addition to devrel, is currently involved in the standardization of WebRTC, device APIs and WebVR.
- **Brian Kardell**
Developer Advocate, Igalia
- : Brian is a Developer Advocate at Igalia. He participates in W3C where he is Igalia's Advisory Committee Representative and participates in various working groups and community groups. He also has represented the Open JS Foundation there.
- **Joe Medley**
Senior Technical Writer, Web Developer Relations at Google
- : Joe has led Google's effort to create web platform reference documentation for the last five years, which means he spends a lot of time on MDN. In addition to editing the Chrome beta release announcements targeted at web developers, he writes the occasional article for web.dev. Joe came to Web Developer Relations after a long career writing developer reference documentation for enterprise applications and a degree in education from the University of Central Missouri.
- **Eric Meyer**
Developer Advocate, Igalia
- : [Eric](https://meyerweb.com/) ([@meyerweb](https://mastodon.social/@Meyerweb)) is an [author](https://meyerweb.com/eric/writing.html), speaker, blogger, sometimes teacher and consultant, Developer Advocate at [Igalia](https://www.igalia.com/), and co-founder of [An Event Apart](https://aneventapart.com/). He's been working on the Web since 1993 and still finds it deeply compelling.
- **Laura Morinigo**
Web Developer Advocate, Samsung
- : Laura is a software developer, advocate, and mentor. She is passionate about sharing her knowledge and connecting with different tech communities worldwide. Thanks to her contributions, she has been recognized as a Google Developer Expert and a Woman Techmakers Ambassador. As a mentor, she helped startups participating in accelerator programs like Google Launchpad and the World Food Programme by the United Nations. Currently, she is a web developer advocate for Samsung Internet. She contributes to web standards and spreads the word about advanced web features, helping developers create great and more inclusive web apps.
- **Sheila Moussavi**
Principal, Bocoup
- : Sheila is a Principal at [Bocoup](https://bocoup.com/about), where she leads a team working on web standards like HTML and CSS, and no-code programming tools like [Scratch](https://www.scratchfoundation.org/). Sheila oversees Bocoup's web standards strategy at the W3C, and is passionate about building more equitable spaces in web standards and stronger connections between the standards process and web developer education. Throughout her career in tech (and previously in health equity and disability justice), she has been focused on cultivating effective, justice-oriented organizations and work spaces.
- **Robert Nyman**
Global Lead for Programs & Initiatives, Web Developer Relations, at Google
- : Robert Nyman is the Global Lead for Developer Feedback & Communities, Web Platform at Google. In his role, he works to make the web the best platform for developers. Prior to Google, Robert was a technical evangelist at Mozilla, focused on the Open Web and the company's various products and initiatives. He lives in Stockholm, and has a passion for traveling and meeting people. He claims the title of "Most Well-Traveled Speaker" on Lanyrd, having presented in 42 countries.
- **Kyle Pflug**
Senior Program Manager, Microsoft Edge Developer Experiences
- : Kyle Pflug is a Program Manager at Microsoft, leading developer relations and community outreach for Microsoft Edge. Over the past five years, he has worked to champion web developer and partner perspectives within Microsoft. He is passionate about making the web more inclusive and accessible to developers across platforms and devices.
**MDN Product Advisory Board Alumni:**
- Ali Spivak, Okta
- Daniel Appelquist, Samsung
- Jory Burson, Bocoup
- Meggin Kearney, Google
- Erika Doyle Navara, Microsoft
- Patrick Kettner, Microsoft
- Travis Leithead, Microsoft
- Chris Mills, Mozilla
- Kadir Topal, Mozilla
## See also
- [Product Advisory Board Charter & Membership](/en-US/docs/MDN/MDN_Product_Advisory_Board/Membership)
| 0 |
data/mdn-content/files/en-us/mdn/mdn_product_advisory_board | data/mdn-content/files/en-us/mdn/mdn_product_advisory_board/membership/index.md | ---
title: Product Advisory Board Charter & Membership
slug: MDN/MDN_Product_Advisory_Board/Membership
page-type: guide
---
{{MDNSidebar}}
## 1. Purpose and Objectives
The primary purpose of the PAB is to provide advice, input, and feedback on content strategy, content prioritization, strategic direction, and platform/site features to MDN's Product Manager and Content Lead. Mozilla will consider input and advice from the PAB; however PAB input and recommendations are non-binding. The primary objectives of the PAB are:
- Provide feedback into content strategy and prioritization of standards documentation
- Help define product strategy, roadmap, and priorities including:
- Suggest and comment on Objectives and Key Results (OKRs)
- Suggest and comment on yearly and quarterly content roadmaps
- Make organizational and individual commitments to contribute to MDN based on the defined strategies, roadmaps and priorities
- Represent and promote user requirements, ensuring that MDN continues to evolve and meet users' needs and challenges
- Suggest and give feedback on new opportunities
- Provide feedback on recruiting and retaining contributors (both corporate and individual)
- Share experience and best practices
## 2. Membership Selection and Termination
a. The PAB shall consist of 10 to 12 Members (as defined in the MDN Product Advisory Board Agreement and including those individuals representing a Member organization), to be selected by Mozilla.
b. There are two types of membership: organizational and individual. Organizations who meet the membership criteria and are accepted as member organizations may nominate up to 2 individuals to serve as their representatives ("Member Representatives" as defined in the MDN Product Advisory Board Agreement) on the PAB.
c. Organizations/individuals who wish to become PAB members must submit a MDN Product Advisory Board Interest Form. Membership will be subject to review and approval by Mozilla, and notification will be sent to the applicant within 30 days of application.
d. Membership start dates will be based upon review meeting schedules; any new Members will begin their term on the PAB at the next scheduled review meeting.
e. Members of the PAB will serve terms of 1 year, renewed automatically for up to 3 years (unless terminated by either party). At the end of the 1-year term, the PAB Member and Mozilla will review membership and decide whether to continue Member participation.
f. Members may resign in writing, via email to the PAB mailing list. Member organizations can nominate replacements for resigned members before the start of the next review meeting.
g. Mozilla may terminate a Member in the case of violation of the MDN Advisory Board Agreement, violation of the MDN PAB Code of Conduct, violation of the Antitrust Policy, or if the Member fails to participate in two consecutive review meetings without notice. At that time, a notice will be sent to the principal contact stating that they have been removed as a Member.
## 3. PAB Membership Qualifications
a. PAB Members have in-depth industry knowledge and expertise. Members will be knowledgeable about web standards, with the ability and experience to align MDN's overall strategic goals and content plans with evolution of web standards, industry direction, and the needs of developers using MDN's documentation.
b. Membership in the PAB is limited to organizations and individuals who make significant contributions to MDN and/or the advancement, development, and implementation of web standards.
c. Member organizations must play a significant role in the creation, implementation, or adoption of Web standards and guidelines. It is also preferred that PAB Member organizations be members of an established Web standards group, such as W3C. Member organizations may nominate up to 2 individual representatives to serve on the board.
d. Individual Members of the PAB must have at least one of the following qualifications:
- Plays a significant role in the creation, implementation, or adoption of Web standards;
- Participates in a Web standards group dedicated to the development of specifications for features implemented in a Web browser or used in Web content that is sent to browsers. Participation in W3C or a similar standards group is preferred but not required. Individual Members may also meet this qualification by having served on a standards working group or as an invited expert on an established Web standards working group;
- Is a member of a Web-focused Developer Relations team;
- Works as part of a group doing technical documentation of Web standards; or
- Makes significant, sustained contributions to MDN Web standards documentation as a volunteer.
## 4. Member Responsibilities and Commitments
a. Members are expected to provide feedback and responses in a timely manner, and attend a minimum number of review meetings. Participation is welcome from all over the world. Members' expectations include:
Provide feedback on scheduling annual and quarterly meetings;
- Attend annual meeting;
- Attend at least 2 quarterly reviews per year;
- Review proposals and provide feedback;
- Join the PAB mailing list;
- and Agree not to promote a specific corporate or individual agenda, particularly in the creation or editing of content on MDN.
b. Members may be required to provide personal information and material (bios, etc.) for analyst, press, and/or trade publications and press releases.
c. All Members must sign the MDN Product Advisory Board Agreement and agree to the MDN PAB Code of Conduct and Antitrust Policy.
## 5. MDN PAB Member Benefits
It is anticipated that PAB membership will have the following benefits:
- Impact content strategy and priorities for MDN;
- Influence the strategic direction of MDN; Have advance knowledge of MDN plans and development;
- Make suggestions for features and platform improvements to grow MDN audience and contribution; and
- Provide feedback and technical reviews of content.
## 6. Scheduled and Ad Hoc Meetings
a. Members will be invited to the following meetings:
- Annual Product Strategy review meetings to take place between October and December of each calendar year;
- Quarterly content strategy and prioritization review meetings ("Quarterly Reviews); and
- Ad hoc product review/check-in meetings, which can be initiated by Mozilla or any Member as needed ("Ad Hoc Meetings").
b. Annual Product Strategy review meetings will review the previous year's progress and make recommendations for MDN's strategy and objectives for the following year.
c. Annual Product Strategy review meetings can take place in Mozilla headquarters or worldwide office, the offices of a Member, or external locations, as determined by vote of the PAB. Virtual attendance will be accommodated for Members who are unable to attend in person.
d. Quarterly Reviews and Ad Hoc Meetings will primarily be held via video/conference call, although in-person attendance will be possible at the discretion of Members.
e. Ad Hoc Meeting dates will depend upon the work in development. Review points will have a specific emphasis such as coordination around product release dates and major features or new specs and standards reaching broad release that require more in-depth coordination and planning beyond the Quarterly Review.
## 7. Time Commitment and Costs
a. Members are asked to make a commitment to the PAB for at least 12 months.
b. Members are asked to commit the time to prepare for, attend (sometimes in person), and participate in regularly scheduled and ad hoc PAB meetings.
c. Costs for participant travel and living expenses or other involvement are to be paid by the individual board member or the sponsoring organization.
## See also
- [Product Advisory Board home](/en-US/docs/MDN/MDN_Product_Advisory_Board)
| 0 |
data/mdn-content/files/en-us/mdn | data/mdn-content/files/en-us/mdn/kitchensink/index.md | ---
title: The MDN Content Kitchensink
slug: MDN/Kitchensink
page-type: guide
browser-compat: html.elements.video
---
> **Warning:** Don't delete this page. It's used by [mdn/yari](https://github.com/mdn/yari) for its automation.
## About this page
The **kitchensink** is a page that _attempts_ to incorporate every possible content element and Yari macro.
This page attempts to be the complete intersection of every other page. Not in terms of the text but in terms of the styles and macros.
Let's start with some notes…
Text that uses the `<kbd>` tag: <kbd>Shift</kbd>
> **Note:** Here's a block indicator note.
> **Warning:** Here's a block indicator warning.
## Prev/Next buttons
{{PreviousMenuNext("Games/Techniques/Control_mechanisms/Desktop_with_mouse_and_keyboard", "Games/Techniques/Control_mechanisms/Other", "Games/Techniques/Control_mechanisms")}}
### Another one…
{{PreviousNext("Games/Workflows/2D_Breakout_game_Phaser/Extra_lives", "Games/Workflows/2D_Breakout_game_Phaser/Buttons")}}
## Code snippets
### Plain text
```plain
___________________________
< I'm an expert in my field. >
---------------------------
\ ^__^
\ (oo)\_______
(__)\ )\/\
||----w |
|| ||
```
### HTML
```html
<pre></pre>
```
### JavaScript
```js
const f = () => {
return Math.random();
};
```
### CSS
```css
:root {
--first-color: #488cff;
--second-color: #ffff8c;
}
#firstParagraph {
background-color: var(--first-color);
color: var(--second-color);
}
```
### WebAssembly
```wasm
(func (param i32) (param f32) (local f64)
local.get 0
local.get 1
local.get 2)
```
### Rust
```rust
#[cfg(test)]
mod tests {
#[test]
fn it_works() {
assert_eq!(2 + 2, 4);
}
}
```
### Python
```python
class BookListView(generic.ListView):
model = Book
# your own name for the list as a template variable
context_object_name = 'my_book_list'
queryset = Book.objects.filter(title__icontains='war')[:5]
template_name = 'books/my_arbitrary_template_name_list.html'
```
### Formal syntax
_The formal syntax must be taken from the spec and added to the [MDN data repository](https://github.com/mdn/data). It is an important tool to get precise syntax information for advanced users._
{{CSSSyntax("font-stretch")}}
## Interactive Examples
{{EmbedInteractiveExample("pages/tabbed/abbr.html", "tabbed-shorter")}} {{EmbedInteractiveExample("pages/css/order.html")}} {{EmbedInteractiveExample("pages/js/regexp-assertions.html", "taller")}}
## Tables
### Markdown table
| Constant name | Value | Description |
| ---------------------------- | ------ | ---------------------------------------------------------------------- |
| `QUERY_COUNTER_BITS_EXT` | 0x8864 | The number of bits used to hold the query result for the given target. |
| `CURRENT_QUERY_EXT` | 0x8865 | The currently active query. |
| `QUERY_RESULT_EXT` | 0x8866 | The query result. |
| `QUERY_RESULT_AVAILABLE_EXT` | 0x8867 | A Boolean indicating whether a query result is available. |
| `TIME_ELAPSED_EXT` | 0x88BF | Elapsed time (in nanoseconds). |
| `TIMESTAMP_EXT` | 0x8E28 | The current time. |
| `GPU_DISJOINT_EXT` | 0x8FBB | A Boolean indicating whether the GPU performed any disjoint operation. |
### HTML table
<table class="properties">
<tbody>
<tr>
<th scope="row">
<a href="/en-US/docs/Web/HTML/Content_categories">Content categories</a>
</th>
<td>
<a href="/en-US/docs/Web/HTML/Content_categories#flow_content">Flow content</a>,
<a href="/en-US/docs/Web/HTML/Content_categories#phrasing_content">phrasing content</a>, palpable content.
</td>
</tr>
<tr>
<th scope="row">Permitted content</th>
<td>
<a href="/en-US/docs/Web/HTML/Content_categories#phrasing_content">Phrasing content</a>.
</td>
</tr>
<tr>
<th scope="row">Tag omission</th>
<td>{{no_tag_omission}}</td>
</tr>
<tr>
<th scope="row">Permitted parents</th>
<td>
Any element that accepts <a href="/en-US/docs/Web/HTML/Content_categories#phrasing_content">phrasing content</a>.
</td>
</tr>
<tr>
<th scope="row">Implicit ARIA role</th>
<td>
<a href="https://www.w3.org/TR/html-aria/#dfn-no-corresponding-role">No corresponding role</a>
</td>
</tr>
<tr>
<th scope="row">Permitted ARIA roles</th>
<td>Any</td>
</tr>
<tr>
<th scope="row">DOM interface</th>
<td>{{domxref("HTMLElement")}}</td>
</tr>
</tbody>
</table>
<table class="fullwidth-table">
<caption>
Values for the content of <code><meta name="viewport"></code>
</caption>
<thead>
<tr>
<th scope="col">Value</th>
<th scope="col">Possible subvalues</th>
<th scope="col">Description</th>
</tr>
</thead>
<tbody>
<tr>
<td><code>width</code></td>
<td>A positive integer number, or the text <code>device-width</code></td>
<td>
Defines the pixel width of the viewport that you want the website to be
rendered at.
</td>
</tr>
<tr>
<td><code>user-scalable</code> {{ReadOnlyInline}}</td>
<td><code>yes</code> or <code>no</code></td>
<td>
If set to <code>no</code>, the user is not able to zoom in the webpage.
The default is <code>yes</code>. Browser settings can ignore this rule,
and iOS10+ ignores it by default.
</td>
</tr>
<tr>
<td><code>viewport-fit</code></td>
<td><code>auto</code>, <code>contain</code> or <code>cover</code></td>
<td>
<p>
The <code>auto</code> value doesn't affect the initial layout viewport, and the whole web page is viewable.
</p>
<p>
The <code>contain</code> value means that the viewport is scaled to
fit the largest rectangle inscribed within the display.
</p>
<p>
The <code>cover</code> value means that the viewport is scaled to fill the device display.
It is highly recommended to make use of the <a href="/en-US/docs/Web/CSS/env">safe area inset</a> variables to
ensure that important content doesn't end up outside the display.
</p>
</td>
</tr>
</tbody>
</table>
## Every macro under the sun
**Well, almost every macro. Hopefully only the ones that are in active use.**
An {{Glossary("HTTP")}} error code meaning "Bad Gateway".
A {{Glossary("Server", "server")}} can act as a gateway or proxy (go-between) between a client (like your Web browser) and another, upstream server.
When you request to access a {{Glossary("URL")}}, the gateway server can relay your request to the upstream server.
"502" means that the upstream server has returned an invalid response.
- JavaScript {{jsxref("Array")}} on MDN
Listening for mouse movement is even easier than listening for key presses: all we need is the listener for the {{domxref("Element/mousemove_event", "mousemove")}} event.
## Browser compatibility
{{Compat}}
## Axis-Aligned Bounding Box
One of the simpler forms of collision detection is between two rectangles that are axis aligned — meaning no rotation.
The algorithm works by ensuring there is no gap between any of the 4 sides of the rectangles.
Any gap means a collision does not exist.
```js
var rect1 = { x: 5, y: 5, width: 50, height: 50 };
var rect2 = { x: 20, y: 10, width: 10, height: 10 };
if (
rect1.x < rect2.x + rect2.width &&
rect1.x + rect1.width > rect2.x &&
rect1.y < rect2.y + rect2.height &&
rect1.y + rect1.height > rect2.y
) {
// collision detected!
}
// filling in the values =>
if (5 < 30 && 55 > 20 && 5 < 20 && 55 > 10) {
// collision detected!
}
```
### Rect code
```html
<div id="cr-stage"></div>
<p>
Move the rectangle with arrow keys. Green means collision, blue means no
collision.
</p>
<script
type="text/javascript"
src="https://cdnjs.cloudflare.com/ajax/libs/crafty/0.5.4/crafty-min.js"></script>
```
```js
Crafty.init(200, 200);
var dim1 = {x: 5, y: 5, w: 50, h: 50}
var dim2 = {x: 20, y: 10, w: 60, h: 40}
var rect1 = Crafty.e("2D, Canvas, Color").attr(dim1).color("red");
var rect2 = Crafty.e("2D, Canvas, Color, Keyboard, Fourway").fourway(2).attr(dim2).color("blue");
rect2.bind("EnterFrame", function () {
if (rect1.x > rect2.x + rect2.w &&
rect1.x + rect1.w > rect2.x &&
rect1.y > rect2.y + rect2.h &&
rect1.h + rect1.y > rect2.y) {
// collision detected!
this.color("green");
} else {
// no collision
this.color("blue");
}
});
```
{{EmbedLiveSample('Rect_code', '700', '300') }}
{{APIRef("Bluetooth API")}}{{SeeCompatTable}}
{{WebExtAPIRef("tabs.mutedInfo")}}
### Obsolete CSSOM interfaces {{deprecated_inline}}
{{InheritanceDiagram}}
{{EmbedGHLiveSample("web-tech-games/index.html", '100%', 820)}}
- [Accessibility resources at MDN](/en-US/docs/Web/Accessibility)
- [Web accessibility](https://en.wikipedia.org/wiki/Web_accessibility) on Wikipedia
The [`AvailableInWorkers`](https://github.com/mdn/yari/blob/main/kumascript/macros/AvailableInWorkers.ejs) macro inserts a localized note box indicating that a feature is available in a [Web worker](/en-US/docs/Web/API/Web_Workers_API) context.
{{AvailableInWorkers}}
- [`button`](/en-US/docs/Web/Accessibility/ARIA/Roles/button_role)
- [`checkbox`](/en-US/docs/Web/Accessibility/ARIA/Roles/checkbox_role)
- [`menuitem`](/en-US/docs/Web/Accessibility/ARIA/Roles/menuitem_role)
- [`menuitemcheckbox`](/en-US/docs/Web/Accessibility/ARIA/Roles/menuitemcheckbox_role)
- [`menuitemradio`](/en-US/docs/Web/Accessibility/ARIA/Roles/menuitemradio_role)
- [`option`](/en-US/docs/Web/Accessibility/ARIA/Roles/option_role)
- [`radio`](/en-US/docs/Web/Accessibility/ARIA/Roles/radio_role)
- [`switch`](/en-US/docs/Web/Accessibility/ARIA/Roles/switch_role)
- [`tab`](/en-US/docs/Web/Accessibility/ARIA/Roles/tab_role)
- [`treeitem`](/en-US/docs/Web/Accessibility/ARIA/Roles/treeitem_role)
<!---->
- Create a {{htmlelement("canvas")}} element and set its `width` and `height` attributes to the original, smaller resolution.
- Set its CSS {{cssxref("width")}} and {{cssxref("height")}} properties to be 2x or 4x the value of the HTML `width` and `height`.
If the canvas was created with a 128 pixel width, for example, we would set the CSS `width` to `512px` if we wanted a 4x scale.
- Set the {{htmlelement("canvas")}} element's `image-rendering` CSS property to some value that does not make the image blurry.
Either `crisp-edges` or `pixelated` will work. Check out the {{cssxref("image-rendering")}} article for more information on the differences between these values, and which prefixes to use depending on the browser.
<!---->
- [MDN Web Docs Glossary](/en-US/docs/Glossary):
- {{Glossary("XMLHttpRequest", "XHR")}}
- [AJAX](https://en.wikipedia.org/wiki/AJAX) on Wikipedia
- [Ajax](/en-US/docs/Learn/JavaScript/Client-side_web_APIs/Fetching_data)
- {{DOMxRef("XMLHttpRequest")}}
- {{DOMxRef("Fetch API")}}
- [Using Fetch API](/en-US/docs/Web/API/Fetch_API/Using_Fetch)
- [Synchronous vs. Asynchronous Communications](https://peoplesofttutorial.com/difference-between-synchronous-and-asynchronous-messaging/)
<!---->
- {{SVGElement("feGaussianBlur")}}
- {{SVGAttr("keySplines")}} SVG attribute
- [dir](/en-US/docs/Web/HTML/Global_attributes#dir)
- [lang](/en-US/docs/Web/HTML/Global_attributes#lang)
- {{cssxref(":dir")}}
- {{cssxref("direction")}}
## Types
- {{WebExtAPIRef("alarms.Alarm")}}
- : Information about a particular alarm.
{{Non-standard_Header}}
{{Deprecated_Header}}
[](iceberg.jpg)
| 0 |
data/mdn-content/files/en-us/mdn | data/mdn-content/files/en-us/mdn/writing_guidelines/index.md | ---
title: Writing guidelines
slug: MDN/Writing_guidelines
page-type: mdn-writing-guide
---
{{MDNSidebar}}
MDN Web Docs is an open-source project. The sections outlined below describe our guidelines for _what_ we document and _how_ we do it on MDN Web Docs. To learn about _how to contribute_, see our [contribution guidelines](/en-US/docs/MDN/Community).
- [What we write](/en-US/docs/MDN/Writing_guidelines/What_we_write)
- : This section covers what we include on MDN Web Docs and what we don't, as well as a number of other policies, such as when we write about new technologies, the content suggestion process, and whether we accept external links. This is a good place to start if you're considering writing or updating content for us. This section also includes:
- [Inclusion criteria](/en-US/docs/MDN/Writing_guidelines/What_we_write/Criteria_for_inclusion)
- : Provides an in-depth criteria for content to be included on MDN Web Docs, the application process for getting new documentation added on MDN Web Docs, and the expectations and guidelines for a party applying.
- [Our writing style guide](/en-US/docs/MDN/Writing_guidelines/Writing_style_guide)
- : The writing style guide covers the language and style we use to write on MDN Web Docs. It also covers how to [format code examples](/en-US/docs/MDN/Writing_guidelines/Writing_style_guide/Code_style_guide).
- [How to write for MDN Web Docs](/en-US/docs/MDN/Writing_guidelines/Howto)
- : This section covers all the information for creating and editing pages, including certain processes and techniques we adhere to. This section provides information about getting started, a general overview into how pages are structured, and where to find how-tos on specific tasks. This section includes topics such as:
- [How to research a technology](/en-US/docs/MDN/Writing_guidelines/Howto/Research_technology)
- : This section provides some handy tips for researching a technology you are documenting.
- [How to create, move, and delete pages](/en-US/docs/MDN/Writing_guidelines/Howto/Creating_moving_deleting)
- : This section explains how we create, move, or delete a page on MDN Web Docs. It also explains how we redirect a page when moving or deleting the page.
- [How to use markdown](/en-US/docs/MDN/Writing_guidelines/Howto/Markdown_in_MDN)
- : The markdown format we use derives from [GitHub flavored markdown (GFM)](https://github.github.com/gfm/). This section is a guide to the markdown we use on MDN Web Docs, including formats for specific in-page components, such as notes and definition lists.
- [Adding images and media](/en-US/docs/MDN/Writing_guidelines/Howto/Images_media)
- : This section describes the requirements for including media in pages, such as images.
- [How to document a CSS property](/en-US/docs/MDN/Writing_guidelines/Howto/Document_a_CSS_property)
- : This article explains how to write a CSS property page, including layout and content.
- [How to document an API reference](/en-US/docs/MDN/Writing_guidelines/Howto/Write_an_api_reference)
- : This section explains how to approach documenting a Web API.
- [How to document an HTTP header](/en-US/docs/MDN/Writing_guidelines/Howto/Document_an_HTTP_header)
- : This article explains how to create a new reference page for an HTTP header.
- [How to add an entry to the glossary](/en-US/docs/MDN/Writing_guidelines/Howto/Write_a_new_entry_in_the_glossary)
- : This article explains how to add and link to entries in the MDN Web Docs glossary. It also provides guidelines about glossary entry layout and content.
- [Page types on MDN Web Docs](/en-US/docs/MDN/Writing_guidelines/Page_structures/Page_types)
- : Each page on MDN Web Docs has a specific page type, whether that's a CSS reference page or a JavaScript guide page. This section lists the different page types and provides templates for each type. It's a good idea to browse these to understand which page type you are writing.
- [Page structures on MDN Web Docs](/en-US/docs/MDN/Writing_guidelines/Page_structures)
- : This section covers the various page structures that we use to provide consistent presentation of information on MDN Web Docs. This includes:
- [Syntax sections](/en-US/docs/MDN/Writing_guidelines/Page_structures/Syntax_sections)
- : The syntax section of a reference page on MDN Web Docs contains a syntax box defining the exact syntax of a feature. This article explains how to write syntax boxes for reference articles.
- [Code examples](/en-US/docs/MDN/Writing_guidelines/Page_structures/Code_examples)
- : There are a lot of different ways to include code examples on pages. This section outlines them and provides syntax guidelines for the different languages.
- [Banners and notices](/en-US/docs/MDN/Writing_guidelines/Page_structures/Banners_and_notices)
- : Sometimes, an article needs a special notice added to it. This might happen if the page covers deprecated technology or other material that shouldn't be used in production code. This article covers the most common cases and how to handle them.
- [Specification tables](/en-US/docs/MDN/Writing_guidelines/Page_structures/Specification_tables)
- : Every reference page on MDN Web Docs should provide information about the specification or specifications in which that API or technology was defined. This article demonstrates what these tables look like and explains how to add them.
- [Compatibility tables](/en-US/docs/MDN/Writing_guidelines/Page_structures/Compatibility_tables)
- : MDN Web Docs has a standard format for compatibility tables for our open web documentation. This article explains how to add to and maintain the database that is used to generate the compatibility tables as well as how to integrate the tables into articles.
- [Macros](/en-US/docs/MDN/Writing_guidelines/Page_structures/Macros)
- : Macros are shortcuts that are used in pages to generate content, such as sidebars. This section lists the macros we use and what they do.
- [Attributions and copyright licensing information](/en-US/docs/MDN/Writing_guidelines/Attrib_copyright_license)
- : Describes our policy on using MDN Web Docs content elsewhere on the web, how to get permission to republish content on MDN, and hints for linking to MDN content.
- [How to label a technology](/en-US/docs/MDN/Writing_guidelines/Experimental_deprecated_obsolete)
- : This section covers our definitions for the terms obsolete, deprecated, and experimental and provides guidelines on how to label a technology with them, and when we remove content from MDN Web Docs.
| 0 |
data/mdn-content/files/en-us/mdn/writing_guidelines | data/mdn-content/files/en-us/mdn/writing_guidelines/what_we_write/index.md | ---
title: What we write
slug: MDN/Writing_guidelines/What_we_write
page-type: mdn-writing-guide
---
{{MDNSidebar}}
MDN Web Docs contains _browser-neutral_ documentation that enables web developers to write _browser-agnostic_ code. In this article, you'll find information about whether or not a given topic and/or type of content should be included on MDN Web Docs.
## Editorial Policies
This section describes the policies set by the Mozilla MDN staff to govern the content on MDN Web Docs. All contributors to MDN Web Docs are expected to abide by these policies.
### Relevance
All content on MDN Web Docs must be relevant to the technology section in which it appears. Spam (commercial advertisement) and other irrelevant content will never be accepted onto the site. Contributors who keep trying to submit spam may be banned from MDN at the discretion of Mozilla MDN staff.
Outbound links to commercial sites that are relevant to the topic from which they are linked will be judged on a case-by-case basis. Their value in aiding web developers must outweigh the commercial benefit to the linked site.
### Neutrality
Articles on MDN Web Docs must maintain a [neutral point-of-view](https://en.wikipedia.org/wiki/Wikipedia:Neutral_point_of_view), reporting on browser variations without editorial bias. Derogatory comments about any browser or user agent is not acceptable.
### Standardization
Web technologies to be documented on MDN Web Docs should be on a standards track and must be implemented by at least one rendering engine. Variations in browser support are documented in the [browser compatibility](/en-US/docs/MDN/Writing_guidelines/Page_structures/Compatibility_tables) section of an article.
## Suggesting content
If you'd like to suggest content for MDN Web Docs, please make sure you read this page before submitting to ensure what you are suggesting is appropriate.
For new reference pages or guides, please open a [new issue](https://github.com/mdn/mdn/issues/new/choose) outlining what content you are suggesting and why (please be as explicit as possible).
For suggesting larger projects that involve new sections of content, please refer to the [Criteria for inclusion](/en-US/docs/MDN/Writing_guidelines/What_we_write/Criteria_for_inclusion) page, which also outlines the application process.
## Topics that belong on MDN Web Docs
In general, if it's an open web technology, we document it on MDN Web Docs. This includes any feature that can be used by web developers to create websites and applications, now and in the near future.
If a feature is implemented by multiple browsers and either accepted as standard or is progressing towards standardization, then yes, we definitely document it here. If a feature is still very experimental and not implemented in multiple browsers and/or liable to change, then it is still suitable for inclusion but may not be seen as a priority for the writing team to work on.
In other words, web technologies to be documented on MDN Web Docs should fulfil all of the following criteria:
- Be on a standards track.
- Be specified in a specification published by a reliable standards body.
- Be implemented by at least one rendering engine.
- Be released in a stable browser version.
Our primary focus is to write about the following front-end web technologies:
- [HTML](/en-US/docs/Web/HTML)
- [CSS](/en-US/docs/Web/CSS)
- [JavaScript](/en-US/docs/Web/JavaScript)
- [Web APIs](/en-US/docs/Web/API)
- [HTTP](/en-US/docs/Web/HTTP)
We also document some broader topics, such as [SVG](/en-US/docs/Web/SVG), [XML](/en-US/docs/Web/XML), [WebAssembly](/en-US/docs/WebAssembly), and [Accessibility](/en-US/docs/Learn/Accessibility). In addition, we provide extensive [learning guides](/en-US/docs/Learn) for these technologies and also a [glossary](/en-US/docs/Glossary).
> **Note:** Backend technologies usually have their own documentation elsewhere that MDN Web Docs does not attempt to supersede, although we [do have some exceptions](/en-US/docs/Learn/Server-side).
All content on MDN Web Docs must be relevant to the technology section in which it appears. Contributors are expected to follow these [MDN writing guidelines](/en-US/docs/MDN/Writing_guidelines) for writing style, code samples, and other topics.
For more details about the criteria for whether or not a technology can be documented on MDN Web Docs, see the [Criteria for inclusion](/en-US/docs/MDN/Writing_guidelines/What_we_write/Criteria_for_inclusion) page.
### When we document a new technology
On MDN Web Docs, we are constantly looking to document new web standards technologies as appropriate.
We try to strike a balance between publishing the documentation early enough so that developers can learn about new features as soon as they need to and publishing it late enough so that the technology is mature and stable so that the documentation won't need constant updates or rapid removal.
In general, our definition of the earliest we'll consider documenting a new technology is: _When the feature is on a standards track and is implemented somewhere._
We consider documenting a new technology if it is:
- Specified in a specification document published under a reliable standards organization (such as W3C, WHATWG, Khronos, IETF, etc.) and has reached a reasonable level of stability (e.g., a W3C working draft or candidate recommendation or when the specification is looking fairly stable judging by the flow of issues filed against it), and
- Implemented consistently in at least one browser, with other browser developers showing signs of interest (such as an active ticket or an "intent to implement" process is in effect).
We do not document a new technology if:
- It doesn't have a specification or the specification is a rough note that looks liable to change,
- One or zero browsers have currently implemented it and non-supporting browsers are not showing signs of interest in implementing it. You can gauge this by asking engineers who work on those browsers and by looking at browser bug trackers and mailing lists, etc.,
- Isn't a web-exposed technology and/or is completely proprietary, or
- It's already showing signs of being deprecated or superseded by a similar feature.
## Topics that don't belong on MDN Web Docs
In general, anything that isn't an open web standard does not belong on MDN Web Docs. Spam (commercial advertisement) and other irrelevant content will never be accepted into the site. Contributors who keep trying to submit spam may be banned from MDN at the discretion of Mozilla MDN staff.
Examples of inappropriate topics for MDN Web Docs include:
- Technology that is not exposed to the web and is specific to a browser.
- Technology that is not related to the web.
- Documentation for end-users. For Mozilla products, for example, such documentation belongs on the [Mozilla support site](https://support.mozilla.org).
- Self-linking or self-promoting external links. Check out these guidelines in our [writing style guide](/en-US/docs/MDN/Writing_guidelines/Writing_style_guide#external_links) before adding an external link.
### When we remove documentation
Pages are deleted from MDN Web Docs if they don't contain information that is useful in any way anymore, are out-of-date enough, and/or might be incorrect to the point where keeping them around might be misleading.
The following examples describe situations when pages/content might be deleted:
- Articles contain information about features that weren't implemented across all browsers and were later withdrawn (usually experimental features such as prefixed functionality).
- Reference pages describe features that were removed from the specification before they were implemented in any browser.
- Articles cover techniques that were later shown to be bad practices and superseded by better techniques.
- Articles contain information that were later replaced by other, better quality articles.
- Articles contain content that is inappropriate for MDN Web Docs.
- Sections of MDN Web Docs are not focused on open web technologies and are a maintenance burden.
For more information on _how_ to delete documents, please see the [Creating, moving and deleting pages](/en-US/docs/MDN/Writing_guidelines/Howto/Creating_moving_deleting) guide.
## Types of documents allowed on MDN Web Docs
Generally, our documentation falls into the following categories:
- Reference
- Guide
- Glossary
- Learn/Tutorials
In general, MDN Web Docs is for _product_ documentation, not for _project_ or _process_ documentation. So, if the document is about "how to use a thing" or "how a thing works" (where, the "thing" is in one of the topic categories mentioned above), then it can go on MDN Web Docs.
If a document is about "who's working on developing a thing" or "plans for developing a thing", then it shouldn't go on MDN Web Docs.
Here are some examples of types of documents that should _not_ be placed on MDN Web Docs:
- Planning documents
- Design documents
- Project proposals
- Specifications or standards
- Promotional material, advertising, or personal information
| 0 |
data/mdn-content/files/en-us/mdn/writing_guidelines/what_we_write | data/mdn-content/files/en-us/mdn/writing_guidelines/what_we_write/criteria_for_inclusion/index.md | ---
title: Criteria for inclusion on MDN Web Docs
slug: MDN/Writing_guidelines/What_we_write/Criteria_for_inclusion
page-type: mdn-writing-guide
---
{{MDNSidebar}}
This article describes, in detail, criteria for content to be included on MDN Web Docs, the application process for including new documentation, and expectations and guidelines for a party applying.
This is aimed at larger projects. To suggest a new page or article, please refer to the [Suggesting content](/en-US/docs/MDN/Writing_guidelines/What_we_write#suggesting_content) section on the "What we write" page.
## Web standards technologies
The remit of MDN Web Docs is to document web standards technologies that are in a specification published by a reliable standards body and are supported in at least one stable browser. These criteria signal enough interest, stability, and "intent to implement" by the web industry at large. Therefore, we think those technologies are a safe bet for us to spend our time and effort in documenting them. Any earlier than that, a web technology or a feature might be prone to getting cancelled due to lack of interest or might be so unstable that it might change significantly, which will needlessly involve a lot of rewriting (which we try to avoid where possible).
## Non-web standards technologies
Non-web standards technologies are technologies that do not follow our criteria summarized above. We would not normally consider them for documentation on MDN Web Docs.
Our mission statement is _"to provide developers with the information they need to easily build projects on the open web"_. This suggests that we should consider documenting technologies that are useful to web developers, even if they are not open web standards, on the standards track, etc.
If you want to consider a non-web standard technology for inclusion on MDN Web Docs, you should make sure that it matches the criteria below.
## Criteria for inclusion on MDN Web Docs
Technologies should fulfill the criteria described here for being considered to be documented on MDN Web Docs.
### Be open and not proprietary
At MDN Web Docs, we are supporters of open technologies. We don't support closed technology ecosystems that are controlled by a single entity, that are not open for contributions by any interested party, and that are not interoperable across multiple platforms and systems. We believe that technology works better for everyone when created out in the open.
### Be web-exposed and be related to web technologies
Our central remit is web standards technologies; there is no point starting to document technologies that do not relate to the web or hold any interest to web developers.
### Show signs of interest and adoption
We don't want to spend our time documenting a technology that has no signal of interest and adoption from the industry. It may just be that it is too early to start documenting the technology, and we could consider it to be documented on MDN Web Docs in the future.
### Not show signs of being deprecated or superseded
Related to the above point, we also don't want to spend our time documenting a technology that is late in its lifecycle and is already showing signs of decline in interest.
### Not have an established documentation resource elsewhere
There are many libraries and frameworks in existence, which are not web standards but are built on top of web technologies and are very popular in the web industry. We do not document any of these because, in general, they all have established documentation resources already. It would be foolish to compete with the official resource of a popular framework — to do so would be a waste of time and probably end up confusing developers trying to learn the technology.
### Have a community willing to write and maintain the documentation
The MDN Web Docs team concentrates on documenting the open web platform. If you want a technology in this area to be considered for documentation on MDN Web Docs, you'll need to have a community assembled that is willing to write the documentation and maintain it after completion. Our team is happy to provide guidance in such cases, including edits and feedback, but we don't have the resource for more than that.
> **Note:** MDN Web Docs work is carried out on GitHub and 'in the open'. Your team should be versed in git & GitHub and be comfortable with working in open source.
## Process for selecting the new technology
If a technology looks like a good candidate for being documented on MDN Web Docs, you can start a discussion on the [GitHub community discussions](/en-US/docs/MDN/Community/Communication_channels#github_discussions) to propose and discuss the inclusion of this technology. This section describes what the proposal should include.
### Submitting the proposal
Technologies will be considered for inclusion on MDN Web Docs on a case-by-case basis. For consideration, you would need to submit a proposal titled "Proposal for documenting a new technology on MDN Web Docs". We would need the following information from you in the proposal:
- The technology, its core purpose/use cases, and target developer audience.
- What kind of industry or community buzz is there is around the technology?
- Are a lot web developers using it? What is the industry adoption like?
- Do a lot of web developers want or need this information?
- What is the size of the target audience for this information? Supporting statistics would help if you have them.
- How does the technology relate to core web technology and web browsers? Useful details include:
- Does it use HTML and CSS but generally not output to the web?
- Is it supported in web browsers via a polyfill?
- What documentation or resources are already available that cover the technology?
- How much documentation would need to be added to MDN Web Docs?
- List the expected number of guides, tutorials, reference pages for elements/methods/attributes, etc.
- Provide a high-level table of contents.
- Mention the kind of "advanced" features you think you might need for this resource, beyond the basic documentation pages. Are you expecting to include embedded videos, interactive code samples, etc.?
- Who will be writing the documentation? Who are they and why are they suited for the job?
- How will the documentation be maintained?
You don't need to provide us with hundreds of pages of detail at this stage (in fact, we'd prefer it if you didn't). A couple of paragraphs on each of the above points is more than adequate.
> **Note:** MDN Web Docs is primarily an English site (en-US). The primary language for your project should be in US English.
### Awaiting a response
We will consider the technology and the information you submit in the proposal and respond with one of the following answers:
- **No**: We don't think this meets the criteria for being documented on MDN Web Docs.
- **Maybe**: We are not sure if it is suitable for documenting on MDN Web Docs and would like to ask some further questions.
- **Yes**: We think it is appropriate for including it on MDN Web Docs.
If the technology is a good candidate, the team will assist you in getting started with the documentation.
## Project guidelines for documenting the new technology
If your chosen technology is accepted for documentation on MDN Web Docs, the next step is to get started.
To ensure that your project for documenting the new technology on MDN Web Docs is successful, we'll need you to have the following in place:
- A dedicated team
- A project plan and roadmap
- Writing guidelines and standards
- An intuitive documentation structure
- A maintenance plan
### Dedicated team
Make sure you have a dedicated team in place that will be there to both write the initial documentation as well as maintain it in future with the required updates.
Have a think about how much work there is and how many people you might need for that.
- If it is a large project, you might benefit from having a few writers, a technical reviewer to check that the work is technically accurate, a copy editor to clean up the language, someone to write code examples, etc.
- On a smaller project, you might have one or two people taking on multiple roles. However you want to build up the team is fine as long as it works for you.
A member of the MDN Web Docs team will be assigned to your project to provide guidance on the MDN Web Docs side of things.
You should assign one (or two) team leads who can liaise with the MDN Web Docs team member.
The MDN Web Docs representative will help get the required permissions to everyone on your team to work in the [MDN organization on GitHub](https://github.com/mdn).
### Project plan and roadmap
Create a plan for the project — tasks, estimate completion dates, and milestones you would want to track to ensure you're making steady progress.
If the project is large, you should consider assigning one of your team members as the project manager. You should also consider writing a subproject plan for an initial release that encompasses the minimum set of documentation that is useful to publish (a _minimum viable product_); you can follow it up with further additions later.
If the documentation project is small, you would still need to keep a record of what has been done and what hasn't, what stage each part of the documentation is at (e.g., not started, in progress, draft written, reviewed, done), and who is working on what.
### Writing guidelines and standards
These [guidelines](/en-US/docs/MDN/Writing_guidelines) state how we expect documents to be written for MDN Web Docs.
If you have additional guidelines for the documents you are writing, we expect this guide to be added to and kept up to date.
In terms of standards, you are expected to maintain a reasonable level of writing quality for your documentation to stay on MDN Web Docs. Your MDN Web Docs representative will work with you to make you clear on what is expected.
### Intuitive documentation structure
If you went through the proposal submission process, then you should already have a rough outline of what you are going to write for this technology. At this point, you should refine that into a site structure plan: think about what the document hierarchy will be and where everything will fit and link together.
Each project is different, but we'd roughly recommend something like this:
```plain
Landing page
|
------Reference
|
--------Elements
|
--------Methods
|
--------Other reference page type(s)?
|
------Guides/tutorials
|
------Examples
```
Each page type that you will use in your project should have a page template for others to copy the structure from. You should decide on these early on.
Please refer to our section on [page types](/en-US/docs/MDN/Writing_guidelines/Page_structures/Page_types). If additions need to be made, please liaise with your MDN Web Docs representative.
### Maintenance plan
The documentation for this technology will need to be maintained to remain on MDN Web Docs:
- The content and files for MDN Web Docs are stored on GitHub. When others make changes to the documentation for your technology, a member from your team needs to review those changes to make sure the content is still good. You can track the open pull requests (PRs) via GitHub's notification feature.
- When changes occur to the technology that require documentation to be updated, your team needs to make updates as appropriate, maintaining the same standards as the original documentation.
If positive changes are not observed over a period of six months and the documentation appears to be in any of the following states:
- Stale or unmaintained
- Stalled without being finished
- Low quality
- Becoming obsolete
Then the documentation for this technology will be considered dead. After a discussion between your team and the MDN Web Docs team representative, the documentation will be removed.
We hope you understand that we need to be strict on such matters — we can't let the site fill up with bad quality, incomplete, or obsolete documentation.
| 0 |
data/mdn-content/files/en-us/mdn/writing_guidelines | data/mdn-content/files/en-us/mdn/writing_guidelines/writing_style_guide/index.md | ---
title: Writing style guide
slug: MDN/Writing_guidelines/Writing_style_guide
page-type: mdn-writing-guide
---
{{MDNSidebar}}
This writing style guide describes how content should be written, organized, spelled, and formatted on MDN Web Docs.
These guidelines are for ensuring language and style consistency across the website. That said, we are more interested in content rather than its formatting, so don't feel obligated to learn the entire writing style guide before contributing. Do not be upset or surprised, however, if another contributor later edits your work to conform to this guide. The reviewers might also point you to this style guide when you submit a content pull request.
> **Note:** The language aspects of this guide apply primarily to English-language documentation. Other languages may have (and are welcome to create) their own style guides. These should be published as subpages of the respective localization team's page. However, this guide should still be consulted for formatting and organizing content.
After listing the general writing guidelines, this guide describes the recommended writing style for MDN Web Docs and then how to format different components on a page, such as lists and titles.
## General writing guidelines
The goal is to write pages that include all the information that readers may need for understanding the topic at hand.
The following subsections provide the recommendations to achieve this:
- [Consider your target audience](#consider_your_target_audience)
- [Consider the three Cs of writing](#consider_the_three_cs_of_writing)
- [Include relevant examples](#include_relevant_examples)
- [Provide a descriptive introduction](#provide_a_descriptive_introduction)
- [Use inclusive language](#use_inclusive_language)
- [Write with SEO in mind](#write_with_seo_in_mind)
### Consider your target audience
Keep the target audience for the content you are writing in mind. For example, a page on advanced network techniques likely doesn't need to go into as much detail about basic networking concepts as the typical page on networking. Keep in mind that these are guidelines. Some of these tips may not apply in every case.
### Consider the three Cs of writing
The three Cs of good writing are writing clearly, concisely, and consistently.
- **Clear**: Ensure that your writing is clear and simple. In general, use active voice and unambiguous pronouns. Write short sentences, sticking to one idea per sentence. Define new terms, keeping the target audience in, before using them.
- **Concise**: When writing any document, it's important to know how much to say. If you provide excessive detail, the page becomes tedious to read and it will rarely be used.
- **Consistent**: Ensure you use the same verbiage consistently throughout the page and across multiple pages.
### Include relevant examples
In general, add examples or real-life scenarios to better explain the content you are writing. This helps readers to understand conceptual and procedural information in a more tangible and practical way.
You should use examples to clarify what every parameter is used for and to clarify any edge cases that may exist.
You can also use examples to demonstrate solutions for common tasks and solutions to problems that may arise.
### Provide a descriptive introduction
Make sure that the opening paragraph(s) before the first heading adequately summarizes the information that the page will cover and perhaps what readers will be able to achieve after going through the content. This way a reader can determine quickly whether the page is relevant to their concerns and desired learning outputs.
In a guide or tutorial, the introductory paragraph(s) should inform the reader about the topics that will be covered as well as the prerequisite knowledge the reader is expected to have, if any. The opening paragraph should mention the technologies and/or APIs that are being documented or discussed, with links to the related information, and it should offer hints to situations in which the article's contents might be useful.
- **Example of short introduction**: This example of an introduction is far too short. It leaves out too much information, such as what it means exactly to "stroke" text, where the text is drawn, and so forth.
> **`CanvasRenderingContext2D.strokeText()`** draws a string.
- **Example of long introduction**: This example has an updated introduction, but now it's far too long.
Too much detail is included, and the text delves too deeply into describing other methods and properties.
Instead, the introduction should focus on the `strokeText()` method and should refer to the appropriate guides where the other details are described.
> When called, the Canvas 2D API method **`CanvasRenderingContext2D.strokeText()`** strokes the characters in the specified string beginning at the coordinates specified, using the current pen color.
> In the terminology of computer graphics, "stroking" text means to draw the outlines of the glyphs in the string without filling in the contents of each character with color.
>
> The text is drawn using the context's current font as specified in the context's {{domxref("CanvasRenderingContext2D.font", "font")}} property.
>
> The placement of the text relative to the specified coordinates are determined by the context's `textAlign`, `textBaseline`, and `direction` properties.
> `textAlign` controls the placement of the string relative to the X coordinate specified; if the value is `"center"`, then the string is drawn starting at `x - (stringWidth / 2)`, placing the specified X-coordinate in the middle of the string.
> If the value is `"left"`, the string is drawn starting at the specified value of `x`.
> And if `textAlign` is `"right"`, the text is drawn such that it ends at the specified X-coordinate.
>
> (…)
>
> You can, optionally, provide a fourth parameter that lets you specify a maximum width for the string, in pixels.
> If you provide this parameter, the text is compressed horizontally or scaled (or otherwise adjusted) to fit inside a space that wide when being drawn.
>
> You can call the **`fillText()`** method to draw a string's characters as filled with color instead of only drawing the outlines of the characters.
- **Example of an appropriate introduction**: Here we see a much better overview for the `strokeText()` method.
> The {{domxref("CanvasRenderingContext2D")}} method **`strokeText()`**, part of the [Canvas 2D API](/en-US/docs/Web/API/Canvas_API), strokes (draws the outlines of) the characters of a specified string, anchored at the position indicated by the given X and Y coordinates.
> The text is drawn using the context's current {{domxref("CanvasRenderingContext2D.font", "font")}}, and is justified and aligned according to the {{domxref("CanvasRenderingContext2D.textAlign", "textAlign")}}, {{domxref("CanvasRenderingContext2D.textBaseline", "textBaseline")}}, and {{domxref("CanvasRenderingContext2D.direction", "direction")}} properties.
>
> For more details and examples, see the [Text](/en-US/docs/Learn/JavaScript/Client-side_web_APIs/Drawing_graphics#text) section on the Drawing graphics page as well as our main article on the subject, [Drawing text](/en-US/docs/Web/API/Canvas_API/Tutorial/Drawing_text).
### Use inclusive language
MDN has a wide and diverse audience.
We strongly encourage keeping text as inclusive as possible.
Here are some alternatives to common terms used in documentation:
- Avoid using the terms **master** and **slave** and instead use **main** and **replica**.
- Replace **whitelist** and **blacklist** with **allowlist** and **denylist**.
- **Sanity** should be replaced with **coherence**.
- Instead of **dummy**, use **placeholder**.
- You should not need to use the terms **crazy** and **insane** in documentation; however, if the case arises, consider using **fantastic** instead.
It is best to use gender-neutral language in any writing where gender is irrelevant to the subject matter.
For example, if you are talking about the actions of a specific man, using "he"/"his" is fine; but if the subject is a person of either gender, "he"/"his" isn't appropriate.
Let's look at the following examples:
- **Incorrect**: "A confirmation dialog asks the user if he wants to allow the web page to make use of his webcam."
- **Incorrect**: "A confirmation dialog asks the user if she wants to allow the web page to make use of her webcam."
Both versions are gender-specific. To fix this, use gender-neutral pronouns like so:
- **Correct**: "A confirmation dialog asks the user if they want to allow the web page to make use of their webcam."
> **Note:** MDN Web Docs allows the use of third-person plural, commonly known as "[singular 'they'](https://en.wikipedia.org/wiki/Singular_they).". The gender-neutral pronouns include "they," "them", "their," and "theirs".
Another option is to make the users plural, like so:
- **Correct**: "A confirmation dialog asks the users if they want to allow the web page to make use of their webcams."
The best solution, of course, is to rewrite and eliminate the pronouns:
- **Correct**: "A confirmation dialog requesting the user's permission for webcam access appears."
- **Correct**: "A confirmation dialog box that asks the user for permission to use the webcam appears."
This last example of dealing with the problem is arguably better.
Not only is it grammatically more correct, but removes some of the complexity associated with dealing with genders across different languages that may have wildly different gender rules.
This solution can make translation easier for both readers and translators.
### Write with SEO in mind
While the primary goal of any writing on MDN Web Docs should always be to explain and inform about open web technology so developers can quickly learn to do what they want or to find the little details they need to know in order to perfect their code, it's important that they be able to _find_ the material we write. We can achieve this by keeping Search Engine Optimization ({{Glossary("SEO")}}) in mind while writing.
This section covers the standard practices, recommendations, and requirements for content to help ensure that search engines can easily categorize and index our material to ensure that readers can easily find what they need. The SEO guidelines include ensuring that each page that writers and editors work on is reasonably well-designed, written, and marked up to give search engines the context and clues they need to properly index the articles.
The following checklist is good to keep in mind while writing and reviewing content to help ensure that the page and its neighbors will be indexed properly by search engines:
- **Ensure that pages aren't too similar**: If the content on different pages is similar textually, search engines will assume that the pages are about the same thing even if they aren't.
For example, if an interface has the properties `width` and `height`, it's easy for the text to be surprisingly similar on the two pages documenting these two properties, with just a few words swapped out and using the same example. This makes it hard for search engines to know which is which, and they wind up sharing page rank, resulting in both being harder to find than they ought to be.
It's important, then, to ensure that every page has its own content. Here are some suggestions to help you accomplish that:
- **Explain more unique concepts**: Consider use cases where there might be more differences than one would think. For instance, in the case of documenting `width` and `height` properties, perhaps write about the ways horizontal space and vertical space are used differently, and provide a discussion about the appropriate concepts. Perhaps you can mention the use of `width` in terms of making room for a sidebar, while using `height` to handle vertical scrolling or footers. Including information about accessibility issues is a useful and important idea as well.
- **Use different examples**: Examples in these situations are often even more similar than the body text because the examples may use both (or all) of the similar methods or properties to begin with, thereby requiring no real changes when reused. So throw out the example and write a new one, or at least provide multiple examples, with at least some of them different.
- **Add descriptions for examples**: Both an overview of what the example does as well as coverage of how it works, in an appropriate level of detail given the complexity of the topic and the target audience, should be included.
The easiest way to avoid being overly similar is of course to write each article from scratch if time allows.
- **Ensure that pages aren't too short**: If the content on a page is too little (called "thin pages" in SEO parlance), search engines will not catalog such pages accurately (or at all). Overly-short content pages are hard to find. As a guiding principle, ensure that pages on MDN Web Docs are not shorter than around 300 words or so. Don't artificially inflate a page, but treat this guideline as a minimum target length when possible.
Here are some basic guidelines to help you create pages that have enough content to be properly searchable without resorting to cluttering them up with unnecessary text:
- **Avoid stubs**: Obviously, if the article is a stub or is missing content, add it. We try to avoid outright "stub" pages on MDN web Docs, although they do exist, but there are plenty of pages that are missing large portions of their content.
- **Review page structure**: Review the page to ensure that it's structured properly for its [page type](/en-US/docs/MDN/Writing_guidelines/Page_structures/Page_types) it is. Check to make sure that all sections are present and have appropriate content.
- **Ensure completeness**: Review sections to ensure that no information is missing. Ensure that all parameters are listed and explained. Ensure that any exceptions are covered — this is a particularly common place where content is missing.
- **Ensure all concepts are fully fleshed-out**: It's easy to give a quick explanation of something, but make sure that all the nuances are covered. Are there special cases? Are there any known restrictions that the reader might need to know about?
- **Add examples**: There should be examples covering all parameters or at least the parameters (or properties, or attributes) that users from the beginner-through-intermediate range are likely to use, as well as any advanced ones that require extra explanation. Each example should be preceded with an overview of what the example will do, what additional knowledge might be needed to understand it, and so forth. After the example (or interspersed among pieces of the example) should be text explaining how the code works. Don't skimp on the details or the handling of errors in examples. Keep in mind that users _will_ copy and paste your example to use in their own projects, and your code _will_ wind up used on production sites! See our [code example guidelines](/en-US/docs/MDN/Writing_guidelines/Writing_style_guide/Code_style_guide) for more useful information.
- **Explain use cases**: If there are particularly common use cases for the feature being described, talk about them! Instead of assuming that a user will figure out that the method being documented can be used to solve a common development problem, actually add a section about that use case with an example and text explaining how the example works.
- **Add image information**: Include proper [`alt`](/en-US/docs/Web/HTML/Element/img#alt) text on all images and diagrams. This text, as well as captions on tables and other figures, counts because spiders can't crawl images, and so `alt` text tells search engine crawlers what content the embedded media contains.
> **Note:** It is not recommended to include too many keywords or keywords not related to the feature in an attempt to manipulate search engine rankings; this type of behavior is easy to spot and tends to be penalized.
> Likewise, **do not** add repetitive, unhelpful material or blobs of keywords within the actual page, in an attempt to improve the page's size and search ranking. This does more harm than good, both to content readability and to our search results.
- **Focus on topic content**: It is far better to write content around the topic of the page than a specific keyword. It is highly likely that there will be many keywords you could include for a given topic; in fact, many SEOs compile a list of 5-100 different keywords (varying between short, medium, and long-tail keywords) to include within their article, depending on the length. Doing so will diversify your wording, leading to less repetition.
## Writing style
Other than writing grammatically correct sentences in English, we recommend you follow these guidelines to keep content consistent across MDN Web Docs.
- [Abbreviations and acronyms](#abbreviations_and_acronyms)
- [Capitalization](#capitalization)
- [Contractions](#contractions)
- [Numbers and numerals](#numbers_and_numerals)
- [Pluralization](#pluralization)
- [Apostrophes and quotation marks](#apostrophes_and_quotation_marks)
- [Commas](#commas)
- [Hyphens](#hyphens)
- [Spelling](#spelling)
- [Terminology](#terminology)
- [Voice](#voice)
### Abbreviations and acronyms
An abbreviation is a shortened version of a longer word, while an acronym is a new word created using the first letter of each word from a phrase. This section describes guidelines for abbreviations and acronyms.
- **Expansions**: On the first mention of a term on a page, expand acronyms that are likely to be unfamiliar to users. When in doubt, expand the term. Better yet, link it to the article or [glossary](/en-US/docs/Glossary) entry describing the technology.
- **Correct**: "XUL (XML User Interface Language) is Mozilla's XML-based language..."
- **Incorrect**: "XUL is Mozilla's XML-based language..."
- **Capitalization and periods**: Use full capitals and delete periods in all abbreviations and acronyms, including organizations such as "US" and "UN".
- **Correct**: XUL
- **Incorrect**: X.U.L.; Xul
- **Latin abbreviations**: You can use common Latin abbreviations (etc., i.e., e.g.) in parenthetical expressions and notes. Use periods in these abbreviations, followed by a comma or other appropriate punctuation.
- **Correct**: Web browsers (e.g., Firefox) can be used ...
- **Incorrect**: Web browsers e.g. Firefox can be used ...
- **Incorrect**: Web browsers, e.g. Firefox, can be used ...
- **Incorrect**: Web browsers, (eg: Firefox) can be used ...
In regular text (i.e., text outside of notes or parentheses), use the English equivalent of the abbreviation.
- **Correct**: ... web browsers, and so on.
- **Incorrect**: ... web browsers, etc.
- **Correct**: Web browsers such as Firefox can be used ...
- **Incorrect**: Web browsers e.g. Firefox can be used ...
The following table summarizes the meanings and English equivalents of Latin abbreviations:
| Abbrev | Latin | English |
| ------ | ---------------- | ----------------------- |
| cf. | _confer_ | compare |
| e.g. | _exempli gratia_ | for example |
| et al. | _et alii_ | and others |
| etc. | _et cetera_ | and so forth, and so on |
| i.e. | _id est_ | that is, in other words |
| N.B. | _nota bene_ | note well |
| P.S. | _post scriptum_ | postscript |
> **Note:** Always consider whether it's truly beneficial to use a Latin abbreviation. Some of these are used so rarely that many readers will either confuse or fail to understand their meanings.
>
> Also, be sure that _you_ use them correctly if you choose to do so. For example, be careful not to confuse "e.g." with "i.e.", which is a common error.
- **Plurals of abbreviations and acronyms**: For plurals of abbreviations and acronyms, add _s_. Don't use an apostrophe. Ever. Please.
- **Correct**: CD-ROMs
- **Incorrect**: CD-ROM's
- **"Versus", "vs.", and "v."**: If using the contraction, "vs." is preferred over "v." and can be used in headings. Elsewhere in text, use the spelled-out form "versus".
- **Correct**: this vs. that
- **Incorrect**: this v. that
- **Correct**: this versus that
### Capitalization
Use standard English capitalization rules in body text, and capitalize "World Wide Web." It is acceptable to use lower case for "web" (used alone or as a modifier) and "internet".
> **Note:** This guideline is a change from a previous version of this guide, so you may find many instances of "Web" and "Internet" on MDN.
> Feel free to change these as you are making other changes, but editing an article just to change capitalization is not necessary.
Keyboard keys should use sentence-style capitalization, not all-caps capitalization.
For example, "<kbd>Enter</kbd>" not "<kbd>ENTER</kbd>".
The only exception is that you can use "<kbd>ESC</kbd>" to abbreviate the "<kbd>Escape</kbd>" key.
Certain words should always be capitalized, such as trademarks that include capital letters or words that derive from the name of a person (unless the word is being used within code and the code syntax requires lower-casing).
Some examples include:
- Boolean (named for English mathematician and logician [George Boole](https://en.wikipedia.org/wiki/George_Boole))
- JavaScript (a trademark of Oracle Corporation, it should always be written as trademarked)
- Python, TypeScript, Django, and other programming languages and framework names
### Contractions
Our writing style tends to be casual, so you should feel free to use contractions (e.g., "don't", "can't", "shouldn't"), if you prefer.
### Numbers and numerals
- **Commas**: In running text, use commas only in five-digit and larger numbers.
- **Correct**: 4000; 54,000
- **Incorrect**: 4,000; 54000
- **Dates**: For dates (not including dates in code samples), use the format "January 1, 1900".
- **Correct**: February 24, 1906
- **Incorrect**: February 24th, 1906; 24 February, 1906; 24/02/1906
Alternately, you can use the YYYY/MM/DD format.
- **Correct**: 1906/02/24
- **Incorrect**: 02/24/1906; 24/02/1906; 02/24/06
- **Decades**: Use the format "1990s". Don't use an apostrophe.
- **Correct**: 1920s
- **Incorrect**: 1920's
- **Plurals of numerals**: Add "s". Don't use an apostrophe.
- **Correct**: 486s
- **Incorrect**: 486's
### Pluralization
Use English-style plurals, not the Latin- or Greek-influenced forms.
- **Correct**: syllabuses, octopuses
- **Incorrect**: syllabi, octopi
### Apostrophes and quotation marks
Do not use "curly" quotes and quotation marks. On MDN Web Docs, we only use straight quotes and apostrophes. This is because we need to choose one or the other for consistency. If curly quotes or apostrophes make their way into code snippets, even inline ones, readers may copy and paste them, expecting them to function (which they will not).
- **Correct**: Please don't use "curly quotes."
- **Incorrect**: Please don’t use “curly quotes.”
### Commas
The list below describes some of the common situations where we need to be aware of the comma usage rules:
- **After introductory clauses**: An introductory clause is a dependent clause, usually found at the beginning of a sentence. Use a comma after an introductory clause to separate it from the following independent clause.
- Example 1:
- **Correct**: "In this example, you will see how to use a comma."
- **Incorrect**: "In this example you will see how to use a comma."
- Example 2:
- **Correct**: "If you are looking for guidelines, you have come to the right place."
- **Incorrect**: "If you are looking for guidelines you have come to the right place."
- Example 3:
- **Correct**: "On mobile platforms, you tend to get a numeric keypad for entering data."
- **Incorrect**: "On mobile platforms you tend to get a numeric keypad for entering data."
- **Before conjunctions**: The serial comma (also known as "the Oxford comma") is the comma that appears before the conjunction in a series of three or more items. On MDN Web Docs, we use the serial comma. Commas also separate each item of the list.
- **Correct**: "I will travel on trains, planes, and automobiles."
- **Incorrect**: "I will travel on trains, planes and automobiles."
Don't use comma before "and" and "or" in a list that contains two items.
- **Correct**: "My dog is cute and smart."
- **Incorrect**: "My dog is cute, and smart."
Use comma before the conjunctions "and", "but", and "or" if they join two independent clauses. However, if the sentence is becoming very long or complex with the conjunction, consider rewriting it as two sentences.
- Example 1:
- **Correct**: "You can perform this step, but you need to pay attention to the file setting."
- **Incorrect**: "You can perform this step but you need to pay attention to the file setting."
- Example 2:
- **Correct**: "My father is strict but loving."
- **Incorrect**: "My father is strict, but loving."
- **Before "that" and "which"**: A restrictive clause is essential for the meaning of the sentence and does not need commas to be set off from the remaining sentence. A restrictive clause is usually introduced by "that" and **should not** be preceded by a comma.
- **Correct**: "We have put together a course that includes all the essential information you need to work towards your goal."
- **Incorrect**: "We have put together a course, that includes all the essential information you need to work towards your goal."
A nonrestrictive clause provides additional information and is not essential to the meaning of the sentence. A nonrestrictive clause is usually introduced by "which" and should be preceded by a comma.
- **Correct**: "You write a policy, which is an allowed list of origins for each feature."
- **Incorrect**: "You write a policy which is an allowed list of origins for each feature."
- **Before "such as"**: If "such as" is part of a nonrestrictive clause and the remaining sentence is an independent clause, use comma before "such as".
- **Correct**: "The Array object has methods for manipulating arrays in various ways, such as joining, reversing, and sorting them."
- **Incorrect**: "The Array object has methods for manipulating arrays in various ways such as joining, reversing, and sorting them."
The example below shows when not to use comma with "such as". Here the clause containing "such as" is essential for the meaning of the sentence.
- **Correct**: "Web applications are becoming more powerful by adding features such as audio and video manipulation and allowing access to raw data using WebSockets."
- **Incorrect**: "Web applications are becoming more powerful by adding features, such as audio and video manipulation, and allowing access to raw data using WebSockets."
### Hyphens
Compound words should be hyphenated only when the last letter of the prefix is a vowel and is the same as the first letter of the root.
- **Correct**: re-elect, co-op, email
- **Incorrect**: reelect, coop, e-mail
### Spelling
Use American-English spelling.
In general, use the first entry at [Dictionary.com](https://www.dictionary.com/), unless that entry is listed as a variant spelling or as being primarily used in a non-American form of English.
For example, if you [look up "behaviour"](https://www.dictionary.com/browse/behaviour)(with an additional _u_ added to the American standard form), you find the phrase "Chiefly British" followed by a link to the American standard form, ["behavior"](https://www.dictionary.com/browse/behavior).
Do not use variant spelling.
- **Correct**: localize, behavior, color
- **Incorrect**: localise, behaviour, colour
### Terminology
These are our recommendations for using certain technical terms:
- **HTML elements**: Use the term "element" to refer to HTML and XML elements, instead of "tag". In addition, the element should be wrapped in angle brackets "<>" and should be styled using backticks (\`). For example, using \<input\> inside backticks will style it as `<input>` as is expected.
- **Correct**: the `<span>` element
- **Incorrect**: the span tag
On MDN, you can optionally specify the HTML element in the [`HTMLElement` macro](/en-US/docs/MDN/Writing_guidelines/Page_structures/Macros/Commonly_used_macros#linking_to_pages_in_references), which will style the element, add the angle brackets "<>", as well as add a link to its reference page.
- **Using backticks**: `<span>`
- **Using the macro**: {{HTMLElement("span")}} (source in markdown: \\{{HTMLElement("span")\}})
- **Parameters vs. arguments**: The preferred term on MDN Web Docs is **parameters**. Please avoid the term "arguments" for consistency whenever possible.
- **User interface actions**: In task sequences, describe user interface actions using the imperative mood. Identify the user interface element by its label and type.
- **Correct**: "Click the Edit button."
- **Incorrect**: "Click Edit."
### Voice
While the active voice is preferred, the passive voice is also acceptable, given the informal feel of our content.
Try to be consistent, though.
## Page components
This section lists the guidelines to follow for different parts of each page, such as headings, notes, links, and examples.
- [Code examples](#code_examples)
- [Cross-references (linking)](#cross-references_linking)
- [External links](#external_links)
- [Shortened URLs (shortlinks)](#shortened_urls_shortlinks)
- [Heading levels](#heading_levels)
- [Images and other media](#images_and_other_media)
- [Lists](#lists)
- [See also section](#see_also_section)
- [Subpages](#subpages)
- [Slugs](#slugs)
- [Titles](#titles)
### Code examples
A page on MDN Web Docs can contain more than one code example. The following list presents some recommended practices when writing a code example for MDN Web Docs:
- Each piece of example code should include:
- **Heading**: A short `###` (`<h3>`) heading to describe the scenario being demonstrated through the code example. For example, "Using offset printing" and "Reverting to style in previous layer".
- **Description**: A short description preceding the example code that states the specifics of the example to which you want to draw the reader's attention. For example, "In the example below, two cascade layers are defined in the CSS, `base` and `special`."
- **Result explanation**: An explanation after the example code that describes the result and how the code works.
- In general, the code example should not only demonstrate the syntax of the feature and how it is used, but also highlight the purpose and situations in which a web developer might want or need to use the feature.
- If you are working with a large piece of example code, it may make sense to break it up into smaller logical parts so that they can be described individually.
- When adding [live samples](/en-US/docs/MDN/Writing_guidelines/Page_structures/Live_samples), it's helpful to be aware that all of the sample's code blocks that have the same type (HTML, CSS, and JavaScript) are concatenated together before running the example. This lets you break the code into multiple segments, each optionally with its own descriptions, headings, and so forth. This makes documenting code incredibly powerful and flexible.
To learn about how to style or format code examples for MDN Web Docs, see [Guidelines for styling code examples](/en-US/docs/MDN/Writing_guidelines/Writing_style_guide/Code_style_guide).
### Cross-references (linking)
When referencing another page or the section of a page on MDN by its title, follow sentence casing in the link text (match the page or section title). Use sentence casing in the link text even if it is different from the linked page title or section title (it might be that the case used in the page or section title is incorrect). Don't use quotation marks around the link text. To refer to a page on MDN by its title, use the following style:
- **Correct**: "See the [Ordering flex items](/en-US/docs/Web/CSS/CSS_flexible_box_layout/Ordering_flex_items) guide."
- **Incorrect**: "See the "[Ordering flex items](/en-US/docs/Web/CSS/CSS_flexible_box_layout/Ordering_flex_items)" guide."
Follow similar style when linking to a section on a page, as shown below:
- **Correct**: "For more information, see the [Allocation in JavaScript](/en-US/docs/Web/JavaScript/Memory_management#allocation_in_javascript) section on the _Memory management_ page."
If the section you're linking to is on the same page, you can hint at the location of the section using the words "above" or "below".
- **Correct**: "This concept is described in more detail in the [Accessibility concerns](/en-US/docs/Web/CSS/gradient/repeating-conic-gradient#accessibility_concerns) section below."
You can link part of a sentence to an article or the section of an article. Be mindful to use descriptive phrases as link texts to provide enough context for the page being linked.
- **Correct**: "Learn more about [how to order flex items](/en-US/docs/Web/CSS/CSS_flexible_box_layout/Ordering_flex_items)."
- **Incorrect**: "Click [here](/en-US/docs/Web/CSS/CSS_flexible_box_layout/Ordering_flex_items) to learn more."
- **Incorrect**: "Read [this article](/en-US/docs/Web/CSS/CSS_flexible_box_layout/Ordering_flex_items) to learn more."
On MDN, another way to link to a reference page is by using a macro. These macros are described on the [Commonly-used macros](/en-US/docs/MDN/Writing_guidelines/Page_structures/Macros/Commonly_used_macros#linking_to_pages_in_references) page. For example, to link to the reference page of an HTML element, use the `HTMLElement` macro, and to link to the reference page of a CSS property, use the `CSSxRef` macro.
We follow similar cross-referencing guidelines in the [See also](#see_also) sections at the end of reference pages, glossary pages, and guides.
### External links
External links are allowed on MDN Web Docs in specific situations. Use the guidelines described in this section to decide whether or not it is okay to include an external link on MDN Web Docs. Your pull request to add an external link will be rejected if it does not meet the guidelines described here.
In general, if you're considering adding an external link, you need to ensure that there is minimal risk of the following:
- Broken or outdated links
- Appearance of endorsement, especially for commercial products or services
- Attempt to use MDN Web Docs to distribute spam
- Shortlinks that obfuscate the link destination
> **Note:** Before adding an external link, consider cross-referencing content within MDN Web Docs. Internal links are easier to maintain and make the entirety of MDN Web Docs more valuable to readers.
- **Good external links**: Good external links take readers to resources that are relevant, durable, and widely trusted. You should prefer adding links to external content that is:
- Unique or indispensable (e.g., an IETF RFC)
- Necessary for attribution, citation, or acknowledgement (e.g., as part of a Creative Commons attribution)
- More likely to be maintained for the topic than incorporating such content on MDN Web Docs itself (e.g., a vendor's release notes)
- Open source or community-driven, like MDN Web Docs itself
- **Poor external links**: Poor external links lack relevance, maintainability, accessibility, or otherwise put up barriers to readers. Avoid adding links to external content that is:
- Generic or non-specific (e.g., a vendor's home page, instead of the related documentation)
- Ephemeral or unmaintained (e.g., a one-time announcement)
- Self-linking or self-promotional (e.g., the author's own work off of MDN Web Docs)
- Paywalled (e.g., an expensive course beyond the reach of hobbyists, students, or readers living in lower-income countries)
- Inaccessible (e.g., a video without captions)
- **Links that are self-promotional or spam**: While a personal blog post, conference talk, or GitHub repository has value, linking to your own resources can create the appearance of a conflict of interest. Think twice before linking to resources that you have a business or personal connection with.
> **Note:** If you have a business or personal relationship with the target of a link, you must disclose that relationship in your pull request. Failure to do so may imperil your continued participation with MDN Web Docs.
Sometimes such links are relevant and appropriate. For example, if you're the editor of a specification and you're contributing to documentation related to that specification, then linking to that specification is expected and acceptable. But you must disclose the relationship between you and the link.
### Shortened URLs (shortlinks)
A URL shortener (such as TinyURL or Bitly) can be great for shortening long links into small, easier-to-remember URLs (also known as "shortlinks"). However, they also obfuscate the destination of the URL. Additionally, with certain shorteners, the destination can be changed after their creation, a feature that could be utilized for malicious purposes.
Do not use links created via third-party (user-generatable) URL shorteners. For example, if `https://myshort.link/foobar` is a short URL generated by a random user and redirects to `https://example.com/somelongURL/details/show?page_id=foobar`, use the longer `example.com` URL.
On the other hand, first-party shorteners that are maintained by the organizations that also maintain the destination URLs are encouraged. `https://bugzil.la` is owned and operated by Mozilla and is a URL shortener that redirects to `https://bugzilla.mozilla.org/`, which is also a Mozilla-owned domain. In this case, use the shorter URL. For example, use `https://bugzil.la/1682349` instead of `https://bugzilla.mozilla.org/show_bug.cgi?id=1682349`.
### Heading levels
When a new paragraph starts a new section, a header should be added.
Use these markdown heading levels in decreasing order without skipping levels: `##`, then `###`, and then `####`; these translate to the [HTML heading tags](/en-US/docs/Web/HTML/Element/Heading_Elements) `<h2>`, `<h3>`, and `<h4>` tags, respectively.
`##` is the highest level allowed because `#` is reserved for the page title.
We recommend to not add more than three levels of headers. If you feel the need for adding the fourth header level, consider breaking up the article into several smaller articles with a landing page. Alternatively, see if you can present the information in bulleted points to avoid adding level four header.
Keep the following dos and don'ts in mind while creating headings for subsections:
- **Don't create single subsections.** Don't subdivide a topic into a single subtopic.
It's either two subheadings or more or none at all.
- **Don't use inline styles, classes, or macros within headings.** However, you can use backticks to indicate code terms (e.g. "Using `FooBar` interface").
- **Don't create "bumping heads".** These are headings followed immediately by a subheading, with no content text in between them.
This doesn't look good and leaves readers without any explanatory text at the beginning of the outer section.
### Images and other media
If you include images or other media on a page, follow these guidelines:
- Make sure the media license allows you to use them. Try to use media that has a very permissive license such as [CC0](https://creativecommons.org/share-your-work/public-domain/cc0/) or at least one that is compatible with our general content license — [Creative Commons Attribution-ShareAlike license](https://creativecommons.org/licenses/by-sa/2.5/) (CC-BY-SA).
- For images, run them through <https://tinypng.com> or <https://imageoptim.com> to reduce the page weight.
- For `SVG`, run the code through [SVGOMG](https://jakearchibald.github.io/svgomg/), and ensure that the `SVG` file has an empty line at the end of the file.
- Every image must [include descriptive `alt` text](/en-US/docs/MDN/Writing_guidelines/Howto/Images_media#adding_alternative_text_to_images).
### Lists
Lists should be formatted and structured consistently across all pages.
Individual list items should be written with suitable punctuation, regardless of the list format.
However, depending on the type of list you are creating, you will want to adjust your writing as described in the sections below. In both cases, include a lead-in sentence that describes the information in the list.
- **Bulleted lists**: Bulleted lists should be used to group related pieces of concise information. Each item in the list should follow a similar sentence structure. Sentences and phrases (i.e., sentence fragments missing a verb or a subject or both) in bulleted lists should include standard punctuation — sentences end with periods, phrases don't.
If there are multiple sentences in a list item, a period must appear at the end of each sentence, including the item's final sentence, just as would be expected in a paragraph. This is an example of a correctly structured bulleted list:
> In this example, we should include:
>
> - A condition, with a brief explanation.
> - A similar condition, with a brief explanation.
> - Yet another condition, with some further explanation.
Notice how the same sentence structure repeats from bullet to bullet. In this example, each bullet point states a condition followed by a comma and a brief explanation, and each item in the list ends with a period.
If the list items include incomplete sentences, no period is required at the end. For example:
> The following color-related properties will be helpful in this scenario:
>
> - propertyA: Sets the background color
> - propertyB: Adds shadow to text
If one or more list items are complete sentences, use a period after every list item, even if a list item contains three or fewer words. However, as far as possible, follow the same structure for all items in a list; ensure all list items are either complete sentences or phrases.
- **Numbered lists**: Numbered lists are used primarily to enumerate steps in a set of instructions. Because instructions can be complex, clarity is a priority, especially if the text in each list item is lengthy. As with bulleted lists, follow standard punctuation usage. This is an example of a correctly structured numbered list:
> In order to correctly structure a numbered list, you should:
>
> 1. Open with a heading or brief paragraph to introduce the instructions. It's important to provide the user with context before beginning the instructions.
> 2. Start creating your instructions, and keep each step in its own numbered item.
> Your instructions may be quite extensive, so it is important to write clearly and use correct punctuation.
> 3. After you have finished your instructions, follow the numbered list with a brief closing summary or explanation about the expected outcome upon completion.
The following is an example of writing a closing explanation for the above list:
> We have created a short numbered list that provides instructive steps to produce a numbered list with the correct formatting.
Notice how the items in numbered lists read like short paragraphs. Because numbered lists are routinely used for instructional purposes or to walk someone through an orderly procedure, be sure to keep each item focused: one numbered item per step.
### See also section
Most of the guides, reference pages, and even glossary pages on MDN Web Docs contain a _See also_ section at the end of the article. This section contains [cross-references](#cross-references_linking) to related topics within MDN and sometimes links to related external articles. For example, this is the [See also section](/en-US/docs/Web/CSS/@layer#see_also) for the `@layer` page.
In general, present the links in a See also section in a [bulleted list](#lists) format with each item in the list as a phrase. In the [Learn web development](/en-US/docs/Learn) area on MDN, however, the See also section follows the [definition list](/en-US/docs/MDN/Writing_guidelines/Howto/Markdown_in_MDN#definition_lists) format.
To maintain consistency across MDN Web Docs, keep the following guidelines in mind while adding or updating a See also section.
#### Link text
- The link text should be the same as the title of the page or the section being linked to. For example, the link text to this [ARIA](/en-US/docs/Web/Accessibility/ARIA/Attributes) page with the page title "ARIA states and properties" will be:
- **Correct**: [ARIA states and properties](/en-US/docs/Web/Accessibility/ARIA/Attributes)
- Use sentence casing in the link text even if it is different from the linked page title or section title. It might be that the case used in the page or section title is incorrect. For example, the link text to the [Quirks Mode](/en-US/docs/Web/HTML/Quirks_Mode_and_Standards_Mode) page in correct sentence case will be:
- **Correct**: [Quirks mode](/en-US/docs/Web/HTML/Quirks_Mode_and_Standards_Mode)
- For external links as well, use sentence casing even if the casing on the target article page is different. This is to ensure consistency across MDN Web Docs. Exceptions include names of books.
- On MDN, you can optionally use a macro to link to a page, as is explained in the [Linking to pages in references](/en-US/docs/MDN/Writing_guidelines/Page_structures/Macros/Commonly_used_macros#linking_to_pages_in_references) section on the _Commonly used macros_ page. The use of macro will add code formatting to the keyword in the link text, as shown in the next example.
- No article ("A", "An", "The") is needed at the beginning of the link list item. No punctuation is required at the end of the list item because it will invariably be a term or a phrase.
- **Correct**: [`revert-layer`](/en-US/docs/Web/CSS/revert-layer)
- **Incorrect**: The [`revert-layer`](/en-US/docs/Web/CSS/revert-layer) keyword.
- **Correct**: [HTML DOM API](/en-US/docs/Web/API/HTML_DOM_API)
- **Incorrect**: The [HTML DOM API](/en-US/docs/Web/API/HTML_DOM_API)
- As shown in the above examples, add code formatting using backticks (\`) to keywords and literals in the link text, even though the formatting is not used in page and section titles. For example, for the page title "Array() constructor", the link text will be [`Array()` constructor](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/Array).
#### Descriptive text
- Keep the descriptive text surrounding the link minimal. In case of a description, add it after the link text and a colon. Word the description as a phrase with no ending punctuation. Keep all linked text at the beginning to aid in scanning the list of links.
- **Correct**: {{cssxref(":checked")}}, {{cssxref(":indeterminate")}}: CSS selectors for styling checkboxes
- Don't use the conjunction "and" before the last item in the series.
- **Correct**: {{cssxref("background-color")}}, {{cssxref("border-color")}}, {{cssxref("color")}}, {{cssxref("caret-color")}}, {{cssxref("column-rule-color")}}, {{cssxref("outline-color")}}, {{cssxref("text-decoration-color")}}, {{cssxref("text-emphasis-color")}}, {{cssxref("text-shadow")}}: Other color-related properties
- For external links, aim to specify the source website and the year of publication or last update (in parentheses) whenever feasible and appropriate. Providing this information upfront gives readers a clear idea of the destination they'll reach upon clicking the link. The date of publication or last update guides readers in assessing the relevance of the linked article and also helps MDN maintainers to review links to articles that have not been updated in a long time. If you provide a link to an article on Wikipedia, for example, you can ignore the publish/update date. The following list item is an example of adding a link to the [Top-level await](https://v8.dev/features/top-level-await) external article in the See also section, along with the source and year information:
- **Correct**: [Top-level await](https://v8.dev/features/top-level-await) on v8.dev (2019)
- For external links to books, you can also provide author names. You can see a few examples for this in the [Further reading](#language_grammar_and_spelling) section below. Refrain from adding author names for blog posts or GitHub repositories you might link to.
#### Order of links
- List the links to MDN pages in the order of reference pages first, followed by links to the related guides and tutorial pages. This suggested order is mainly to aid in the scanability of the items in the list.
- If the list is a mix of internal and external links, list the internal links first and then the external ones.
- Within each group of internal and external links, follow alphabetical or simple-to-advanced order, whatever makes more sense for the context.
### Subpages
When you need to add some articles about a topic or subject area, you will typically do so by creating a landing page, then adding subpages for each of the individual articles.
The landing page should open with a paragraph or two describing the topic or technology, then provide a list of the subpages with descriptions of each page.
You can automate the insertion of pages into the list using some macros we've created.
For example, consider the [JavaScript](/en-US/docs/Web/JavaScript) guide, which is structured as follows:
- [JavaScript/Guide](/en-US/docs/Web/JavaScript/Guide) – Main table-of-contents page
- [JavaScript/Guide/JavaScript Overview](/en-US/docs/Web/JavaScript/Guide/Introduction)
- [JavaScript/Guide/Functions](/en-US/docs/Web/JavaScript/Guide/Functions)
- [JavaScript/Guide/Details of the Object Model](/en-US/docs/Web/JavaScript/Inheritance_and_the_prototype_chain)
Try to avoid putting your article at the top of the hierarchy, which slows the site down and makes search and site navigation less effective.
### Slugs
The page title, which is displayed at the top of the page, can be different from the page "slug", which is the portion of the page's URL following `<locale>/docs/`. Keep the following guidelines in mind when defining a slug:
- Slugs should be kept short. When creating a new level of hierarchy, the new level's component in the slug should just be a word or two.
- Slugs should use an underscore for a multi-word component, such as `Getting_started` in `/en-US/docs/Learn/HTML/Introduction_to_HTML/Getting_started`.
- Follow sentence casing in slugs as well for each component, such as `Getting_started` in the previous example.
### Titles
Page titles are used in search results and are also used to structure the page hierarchy in the breadcrumb list at the top of the page. A page title can be different from the page "slug", as explained in the [Slugs](#slugs) section.
Keep the following guidelines in mind when writing titles:
- **Capitalization style**: On MDN Web Docs, page titles and section headings should use sentence-style capitalization (only capitalize the first word and proper nouns) rather than headline-style capitalization:
- **Correct**: "A new method for creating JavaScript rollovers"
- **Incorrect**: "A New Method for Creating JavaScript Rollovers"
We have many older pages that were written before this style rule was established. Feel free to update them as needed if you like. We're gradually getting to them.
- **General guidelines**: Deciding what you want to document and how you will structure that content is one of the first steps in writing. Writing a table of contents can help you decide how you want to order information. Cover simple concepts first and then go on to more complicated and advanced concepts. Cover conceptual information first and then move on to action-oriented topics.
Keep the following guidelines in mind when writing titles for a page and sections or subsections:
- **Go higher to lower**: As stated in the [Heading levels](#heading_levels) section, go from higher `##` to lower `####`, without skipping levels. Use higher level headings for broader introductory titles, and use more specific titles as you progress to lower-level headings.
- **Group logically**: Make sure all related subsections are grouped together logically under a higher level heading. Naming titles of various sections can help you in this exercise.
- **Keep titles short**: Shorter titles are easier to scan in text and in table of contents.
- **Keep titles specific**: Use the title to convey the specific information that will be covered in the section. For example, for a section introducing HTML elements, use the title "HTML elements" instead of "Introduction" or "Overview".
- **Keep titles focused**: Use the title to convey one objective—a single idea or a concept that will be covered in that section. For that purpose, as far as possible, try not to use the conjunction "and" in a title.
- **Use parallel construction**: Use similar language for titles at the same heading level. For example, if a `###` heading level title uses gerunds, that is, words ending in "-ing", such as "Installing", then try to write all titles at that heading level using gerunds. If a title starts with an imperative verb, such as "Use", "Configure", then write all titles at that heading level starting with an imperative verb.
- **Avoid common term in lower-level heading**: Do not repeat the text in the title of a higher-level heading in lower-level titles. For example, in a section titled "Commas", name the title of a subsection "After introductory clauses" instead of "Commas after introductory clauses".
- **Don't begin with article**: Avoid starting titles with articles "a", "an", or "the".
- **Add lead-in information**: After a title, add some introductory text to explain what will be covered in the section.
## See also
- [Guidelines for writing code examples](/en-US/docs/MDN/Writing_guidelines/Writing_style_guide/Code_style_guide)
- [Guidelines for writing HTML code examples](/en-US/docs/MDN/Writing_guidelines/Writing_style_guide/Code_style_guide/HTML)
- [Guidelines for writing CSS code examples](/en-US/docs/MDN/Writing_guidelines/Writing_style_guide/Code_style_guide/CSS)
- [Guidelines for writing JavaScript code examples](/en-US/docs/MDN/Writing_guidelines/Writing_style_guide/Code_style_guide/JavaScript)
- [Guidelines for writing shell prompt code examples](/en-US/docs/MDN/Writing_guidelines/Writing_style_guide/Code_style_guide/Shell)
## Further reading
### Other style guides
If you have questions about usage and style not covered here, we recommend referring to the [Microsoft Writing Style Guide](https://docs.microsoft.com/style-guide/welcome/) or the [Chicago Manual of Style](https://www.chicagomanualofstyle.org).
An [unofficial crib sheet for the Chicago Manual of Style](https://faculty.cascadia.edu/cma/HIST148/cmscrib.pdf) is available online.
### Language, grammar, and spelling
If you're interested in improving your writing and editing skills, you may find the following resources to be helpful.
- [Common errors in English usage](https://brians.wsu.edu/common-errors-in-english-usage/) on brians.wsu.edu
- [English grammar FAQ](https://www-personal.umich.edu/~jlawler/aue.html) on alt-usage-english.org
- [English language and usage](https://english.stackexchange.com/) on english.stackexchange.com: Question and answer site for English language usage
- [Merriam-Webster's Concise Dictionary of English Usage](https://www.google.com/books/edition/Merriam_Webster_s_Dictionary_of_English/UDIjAQAAIAAJ) on google.com/books (published 2002): Scholarly but user-friendly, evidence-based advice; very good for non-native speakers, especially for preposition usage
- [On Writing Well](https://www.harpercollins.com/products/on-writing-well-william-zinsser) by William Zinsser on harpercollins.com (published 2016)
- [Style: Lessons in Clarity and Grace](https://www.google.ca/books/edition/Style/QjskvgEACAAJ) by Joseph Williams and Gregory Colomb on google.com/books (published 2019)
| 0 |
data/mdn-content/files/en-us/mdn/writing_guidelines/writing_style_guide | data/mdn-content/files/en-us/mdn/writing_guidelines/writing_style_guide/code_style_guide/index.md | ---
title: Guidelines for writing code examples
slug: MDN/Writing_guidelines/Writing_style_guide/Code_style_guide
page-type: mdn-writing-guide
---
{{MDNSidebar}}
The guidelines described in this article apply to the styling and formatting of code examples, irrespective of the language. For guidelines about what content to include while writing the code examples, see the [writing style guide](/en-US/docs/MDN/Writing_guidelines/Writing_style_guide#code_examples).
For technology-specific guidelines, see the following articles:
- [HTML guidelines](/en-US/docs/MDN/Writing_guidelines/Writing_style_guide/Code_style_guide/HTML)
- [CSS guidelines](/en-US/docs/MDN/Writing_guidelines/Writing_style_guide/Code_style_guide/CSS)
- [JavaScript guidelines](/en-US/docs/MDN/Writing_guidelines/Writing_style_guide/Code_style_guide/JavaScript)
- [Shell prompt guidelines](/en-US/docs/MDN/Writing_guidelines/Writing_style_guide/Code_style_guide/Shell)
## General best practices
This section provides the best practices for creating an understandable minimal code example to demonstrate the usage of a specific feature or function.
Code examples that you add to MDN Web Docs should be:
- simple enough to be understandable, but
- complex enough to do something interesting, and preferably useful.
There is one overarching consideration that you need to keep in mind: **Readers will copy and paste the code sample into their own code and may put it into production.**
Therefore, you should make sure that the code example is usable, follows generally accepted best practices, and **does not** do anything that will cause an application to be insecure, grossly inefficient, bloated, or inaccessible. If the code example is not runnable or production-worthy, be sure to include a warning in a code comment and in the explanatory text; for example, if it is only a snippet and not a full example, make this clear. This also means that you should provide **all** of the information necessary to run the example including any dependencies and setup information.
Code examples should be as self-contained and easy to understand as possible. The aim is not necessarily to produce efficient, clever code that impresses experts and has great functionality, but rather to produce reduced working examples that can be understood as quickly as possible.
Some more general best practices include:
- The code example should be short and ideally show only the feature you are immediately interested in.
- **Only** include code that is essential for the example. A large amount of non-relevant code can easily distract or confuse the reader. If you want to provide a full, more lengthy example, put it in one of our [GitHub repos](https://github.com/mdn/) (or a JSBin, Codepen, or similar) and then provide the link to the full version above or below the sample.
- Don't include unnecessary server-side code, libraries, frameworks, preprocessors, and other such dependencies. They make the code less portable and harder to run and understand. Use vanilla code where possible.
- Don't assume readers' knowledge of any libraries, frameworks, preprocessors, or other non-native features. For example, use class names that make sense within the example rather than class names that make sense to BEM or Bootstrap users.
- Write your code to be as clean and understandable as possible, even if it is not the most efficient way to write it.
- Be inclusive in your code examples; consider that MDN readers come from all over the world, and are diverse in their ethnicities, religions, ages, genders, etc. Ensure text in code examples reflects that diversity and is inclusive of all people.
- Don't use bad practices for brevity (such as presentation elements like {{HTMLElement("big")}} or {{domxref("Document.write", "document.write()")}}); do it correctly.
- In the case of API demos, if you are using multiple APIs together, point out which APIs are included and which features come from where.
## Guidelines for formatting
Opinions on correct indentation, whitespace, and line lengths have always been controversial. Discussions on these topics are a distraction from creating and maintaining content.
On MDN Web Docs, we use [Prettier](https://prettier.io/) as a code formatter to keep the code style consistent (and to avoid off-topic discussions). You can consult our [configuration file](https://github.com/mdn/content/blob/main/.prettierrc.json) to learn about the current rules, and read the [Prettier documentation](https://prettier.io/docs/en/index.html).
Prettier formats all the code and keeps the style consistent. Nevertheless, there are a few additional rules that you need to follow.
These MDN Web Docs guidelines for formatting code examples are also good practices when you are coding.
### Choosing a syntax language
To ensure proper formatting and syntax highlighting of code blocks, writers must specify the language of the code block they are writing in. See [Example code blocks in MDN Markdown](/en-US/docs/MDN/Writing_guidelines/Howto/Markdown_in_MDN#example_code_blocks) for a list of languages supported by MDN, as well as details on how to request a new language.
If the code block is pseudocode, the output of a command, or otherwise not a programming language, explicitly set the language to `plain`.
> **Warning:** if the desired language is not yet supported by MDN, do **not** set the language of a code block to a similar language, as doing so may have unintended side effects with Prettier formatting and syntax highlighting.
### Code line length
- Code lines shouldn't be so long that they require horizontal scrolling to read.
- As a recommended practice, keep code lines up to a maximum of 80 characters long (64 for [interactive examples](https://github.com/mdn/interactive-examples)).
- Break long lines at natural breaking points for the sake of readability, but not at the expense of best practices.
For example, this is not great:
```js example-bad
let tommyCat =
"Said Tommy the Cat as he reeled back to clear whatever foreign matter may have nestled its way into his mighty throat. Many a fat alley rat had met its demise while staring point blank down the cavernous barrel of this awesome prowling machine.";
```
This is better, but somewhat awkward:
```js
const tommyCat =
"Said Tommy the Cat as he reeled back to clear whatever foreign " +
"matter may have nestled its way into his mighty throat. Many a fat alley rat " +
"had met its demise while staring point blank down the cavernous barrel of " +
"this awesome prowling machine.";
```
Even better is to use a template literal:
```js example-good
const tommyCat = `Said Tommy the Cat as he reeled back to clear whatever foreign
matter may have nestled its way into his mighty throat. Many a fat alley rat
had met its demise while staring point blank down the cavernous barrel of
this awesome prowling machine.`;
```
```js example-good
if (
obj.CONDITION ||
obj.OTHER_CONDITION ||
obj.SOME_OTHER_CONDITION ||
obj.YET_ANOTHER_CONDITION
) {
/* something */
}
const toolkitProfileService = Components.classes[
"@mozilla.org/toolkit/profile-service;1"
].createInstance(Components.interfaces.nsIToolkitProfileService);
```
### Code block height
Code blocks should be as long as they need to be, but no longer. Ideally, aim for something short, like 15-25 lines. If a code block is going to be a lot longer, consider just showing the most useful snippet, and link to the complete example on a GitHub repo or CodePen, say.
#### Inline code formatting
Use inline code syntax (\`) to mark up function names, variable names, and method names. For example: "the `frenchText()` function".
**Method names should be followed by a pair of parentheses**: for example, `doSomethingUseful()`. The parentheses help differentiate methods from other code terms.
## Guidelines for proper rendering
These guidelines should be followed to ensure that the code examples you write display properly on MDN Web Docs. You should also consider responsiveness making writing code examples so that they are also useful on mobile devices.
### Size of the rendered code example
- **Set the width to 100%**: The main content pane on MDN Web Docs is about 700px wide on desktop, so the embedded code examples must look OK at that width.
- **Set height below 700px**: We recommend keeping this height for the rendered code example width for maximum onscreen legibility.
### Color in the rendered code example
- Use keywords for primary and other "basic" colors, for example:
```css example-good
color: black;
color: white;
color: red;
```
- Use `rgb()` for more complex colors (including semi-transparent ones):
```css example-good
color: rgb(0 0 0 / 50%);
color: rgb(248 242 230);
```
- For hex colors, use the short form where relevant:
```css example-good
color: #058ed9;
color: #a39a92c1;
color: #ff0;
color: #fbfa;
```
```css-nolint example-bad
color: #ffff00;
color: #ffbbffaa;
```
### Mark rendered examples as good or bad
You'll notice on this page that the code blocks that represent good practices to follow are rendered with a green check mark in the right corner, and the code blocks that demonstrate bad practices are rendered with a white cross in a red circle.
You can follow the same style while writing code examples. You don't need to use this style everywhere — only on pages where you want to specifically call out good and bad practices in your code examples.
To get this rendering, use "code fences" to demarcate the code block, followed by the language info string. For example:
```js
function myFunc() {
console.log("Hello!");
}
```
To represent the code block as a good or bad example, add `example-good` or `example-bad` after the language string, like so:
````md
```html example-good
<p></p>
```
```html example-bad
<p></p>
```
````
These will be rendered as:
```html example-good
<p class="brush: js example-good"></p>
```
```html example-bad
<p class="brush: js example-bad"></p>
```
| 0 |
data/mdn-content/files/en-us/mdn/writing_guidelines/writing_style_guide/code_style_guide | data/mdn-content/files/en-us/mdn/writing_guidelines/writing_style_guide/code_style_guide/shell/index.md | ---
title: Guidelines for writing shell prompt code examples
slug: MDN/Writing_guidelines/Writing_style_guide/Code_style_guide/Shell
page-type: mdn-writing-guide
---
{{MDNSidebar}}
The following guidelines cover how to write Shell prompt code examples for MDN Web Docs.
## What is a "shell"
A shell is a program that waits for you to type in a command and then press the return key. To indicate which commands you should type, content on MDN Web Docs lists them in a code block, similar to code examples.
Such a block looks like this:
```bash example-good
# This may take a while...
git clone https://github.com/mdn/content
cd content
```
## General guidelines for shell prompt code examples
### Choosing a format
Opinions on correct indentation, whitespace, and line lengths have always been controversial. Discussions on these topics are a distraction from creating and maintaining content.
On MDN Web Docs, we use [Prettier](https://prettier.io/) as a code formatter to keep the code style consistent (and to avoid off-topic discussions). You can consult our [configuration file](https://github.com/mdn/content/blob/main/.prettierrc.json) to learn about the current rules, and read the [Prettier documentation](https://prettier.io/docs/en/index.html).
Prettier formats all the code and keeps the style consistent. Nevertheless, there are a few additional rules that you need to follow.
### Writing shell code blocks
When writing a shell code block:
- Do not include a `$` or `>` at the beginning of a shell instruction. It confuses more than it helps and it is not useful when copying the instructions.
- Comments start with `#`.
- Choose "bash" to indicate the language in markdown.
## See also
[Django server-side development docs](/en-US/docs/Learn/Server-side/Django) show good practice presentation of shell prompt commands.
| 0 |
data/mdn-content/files/en-us/mdn/writing_guidelines/writing_style_guide/code_style_guide | data/mdn-content/files/en-us/mdn/writing_guidelines/writing_style_guide/code_style_guide/html/index.md | ---
title: Guidelines for writing HTML code examples
slug: MDN/Writing_guidelines/Writing_style_guide/Code_style_guide/HTML
page-type: mdn-writing-guide
---
{{MDNSidebar}}
The following guidelines cover how to write HTML example code for MDN Web Docs.
## General guidelines for HTML code examples
### Choosing a format
Opinions on correct indentation, whitespace, and line lengths have always been controversial. Discussions on these topics are a distraction from creating and maintaining content.
On MDN Web Docs, we use [Prettier](https://prettier.io/) as a code formatter to keep the code style consistent (and to avoid off-topic discussions). You can consult our [configuration file](https://github.com/mdn/content/blob/main/.prettierrc.json) to learn about the current rules, and read the [Prettier documentation](https://prettier.io/docs/en/index.html).
Prettier formats all the code and keeps the style consistent. Nevertheless, there are a few additional rules that you need to follow.
## Complete HTML document
> **Note:** The guidelines in this section apply only when you need to show a complete HTML document. A snippet is usually enough to demonstrate a feature. When using the [EmbedLiveSample macro](/en-US/docs/MDN/Writing_guidelines/Page_structures/Code_examples#traditional_live_samples), just include the HTML snippet; it will automatically be inserted into a full HTML document when displayed.
### Doctype
You should use the HTML5 doctype. It is short, easy to remember, and backwards compatible.
```html example-good
<!doctype html>
```
### Document language
Set the document language using the [`lang`](/en-US/docs/Web/HTML/Global_attributes#lang) attribute on your {{htmlelement("html")}} element:
```html example-good
<html lang="en-US"></html>
```
This is good for accessibility and search engines, helps with localizing content, and reminds people to use best practices.
### Document characterset
You should also define your document's characterset like so:
```html example-good
<meta charset="utf-8" />
```
Use UTF-8 unless you have a very good reason not to; it will cover all character needs pretty much regardless of what language you are using in your document.
### Viewport meta tag
Finally, you should always add the viewport meta tag into your HTML {{HTMLElement("head")}} to give the code example a better chance of working on mobile devices. You should include at least the following in your document, which can be modified later on as the need arises:
```html example-good
<meta name="viewport" content="width=device-width" />
```
See [Using the viewport meta tag to control layout on mobile browsers](/en-US/docs/Web/HTML/Viewport_meta_tag) for further details.
## Attributes
You should put all attribute values in double quotes. It is tempting to omit quotes since HTML5 allows this, but markup is neater and easier to read if you do include them. For example, this is better:
```html example-good
<img src="images/logo.jpg" alt="A circular globe icon" class="no-border" />
```
…than this:
```html-nolint example-bad
<img src=images/logo.jpg alt=A circular globe icon class=no-border>
```
Omitting quotes can also cause problems. In the above example, the `alt` attribute will be interpreted as multiple attributes because there are no quotes to specify that "A circular globe icon" is a single attribute value.
## Boolean attributes
Don't include values for boolean attributes (but do include values for {{glossary("enumerated")}} attributes); you can just write the attribute name to set it. For example, you can write:
```html example-good
<input required />
```
This is perfectly understandable and works fine. If a boolean HTML attribute is present, the value is true. While including a value will work, it is not necessary and incorrect:
```html example-bad
<input required="required" />
```
## Case
Use lowercase for all element names and attribute names/values because it looks neater and means you can write markup faster. For example:
```html example-good
<p class="nice">This looks nice and neat</p>
```
```html-nolint example-bad
<P CLASS="WHOA-THERE">Why is my markup shouting?</P>
```
## Class and ID names
Use semantic class/ID names, and separate multiple words with hyphens ({{Glossary("kebab_case", "kebab case")}}). Don't use {{Glossary("camel_case", "camel case")}}. For example:
```html example-good
<p class="editorial-summary">Blah blah blah</p>
```
```html example-bad
<p class="bigRedBox">Blah blah blah</p>
```
## Entity references
Don't use entity references unnecessarily — use the literal character wherever possible (you'll still need to escape characters like angle brackets and quote marks).
As an example, you could just write:
```html example-good
<p>© 2018 Me</p>
```
Instead of:
```html example-bad
<p>© 2018 Me</p>
```
## HTML elements
There are some rules for writing about HTML elements on MDN Web Docs. Adhering to these rules produces consistent descriptions of elements and their components and also ensures correct linking to detailed documentation.
- **Element names**: Use the [`HTMLElement`](https://github.com/mdn/yari/blob/main/kumascript/macros/HTMLElement.ejs) macro, which creates a link to the MDN Web Docs page for that element. For example, writing `\{{HTMLElement("title")}}` produces "{{HTMLElement("title")}}".
If you don't want to create a link, **enclose the name in angle brackets** and use the "Inline Code" style (e.g., `<title>`).
- **Attribute names**: Use "Inline Code" style to put attribute names in `code font`.
Additionally, put them in **`bold face`** when the attribute is mentioned in association with an explanation of what it does or when it is used for the first time on the page.
- **Attribute values**: Use the "Inline Code" style to apply `<code>` to attribute values, and don't use quotation marks around string values, unless needed by the syntax of a code sample. For example, "When the `type` attribute of an `<input>` element is set to `email` or `tel` ...".
| 0 |
data/mdn-content/files/en-us/mdn/writing_guidelines/writing_style_guide/code_style_guide | data/mdn-content/files/en-us/mdn/writing_guidelines/writing_style_guide/code_style_guide/javascript/index.md | ---
title: Guidelines for writing JavaScript code examples
slug: MDN/Writing_guidelines/Writing_style_guide/Code_style_guide/JavaScript
page-type: mdn-writing-guide
---
{{MDNSidebar}}
The following guidelines cover writing JavaScript example code for MDN Web Docs. This article is a list of rules for writing concise examples that will be understandable by as many people as possible.
## General guidelines for JavaScript code examples
This section explains the general guidelines to keep in mind while writing JavaScript code examples. The later sections will cover more specific details.
### Choosing a format
Opinions on correct indentation, whitespace, and line lengths have always been controversial. Discussions on these topics are a distraction from creating and maintaining content.
On MDN Web Docs, we use [Prettier](https://prettier.io/) as a code formatter to keep the code style consistent (and to avoid off-topic discussions). You can consult our [configuration file](https://github.com/mdn/content/blob/main/.prettierrc.json) to learn about the current rules, and read the [Prettier documentation](https://prettier.io/docs/en/index.html).
Prettier formats all the code and keeps the style consistent. Nevertheless, there are a few additional rules that you need to follow.
### Using modern JavaScript features
You can use new features once every major browser — Chrome, Edge, Firefox, and Safari — supports them.
## Arrays
### Array creation
For creating arrays, use literals and not constructors.
Create arrays like this:
```js example-good
const visitedCities = [];
```
Don't do this while creating arrays:
```js example-bad
const visitedCities = new Array(length);
```
### Item addition
When adding items to an array, use [`push()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/push) and not direct assignment. Consider the following array:
```js
const pets = [];
```
Add items to the array like this:
```js example-good
pets.push("cat");
```
Don't add items to the array like this:
```js example-bad
pets[pets.length] = "cat";
```
## Asynchronous methods
Writing asynchronous code improves performance and should be used when possible. In particular, you can use:
- [Promises](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise)
- [`async`](/en-US/docs/Web/JavaScript/Reference/Statements/async_function)/[`await`](/en-US/docs/Web/JavaScript/Reference/Operators/await)
When both techniques are possible, we prefer using the simpler `async`/`await` syntax. Unfortunately, you can't use `await` at the top level unless you are in an ECMAScript module. CommonJS modules used by Node.js are not ES modules. If your example is intended to be used everywhere, avoid top-level `await`.
## Comments
Comments are critical to writing good code examples. They clarify the intent of the code and help developers understand it. Pay special attention to them.
- If the purpose or logic of the code isn't obvious, add a comment with your intention, as shown below:
```js example-good
let total = 0;
// Calculate the sum of the four first elements of arr
for (let i = 0; i < 4; i++) {
total += arr[i];
}
```
On the other hand, restating the code in prose is not a good use of comments:
```js example-bad
let total = 0;
// For loop from 1 to 4
for (let i = 0; i < 4; i++) {
// Add value to the total
total += arr[i];
}
```
- Comments are also not necessary when functions have explicit names that describe what they're doing. Write:
```js example-good
closeConnection();
```
Don't write:
```js example-bad
closeConnection(); // Closing the connection
```
### Use single-line comments
Single-line comments are marked with `//`, as opposed to block comments enclosed between `/* … */`.
In general, use single-line comments to comment code. Writers must mark each line of the comment with `//`, so that it's easier to notice commented-out code visually. In addition, this convention allows to comment out sections of code using `/* … */` while debugging.
- Leave a space between the slashes and the comment. Start with a capital letter, like a sentence, but don't end the comment with a period.
```js example-good
// This is a well-written single-line comment
```
- If a comment doesn't start immediately after a new indentation level, add an empty line and then add the comment. It will create a code block, making it obvious what the comment refers to. Also, put your comments on separate lines preceding the code they are referring to. This is shown in the following example:
```js example-good
function checkout(goodsPrice, shipmentPrice, taxes) {
// Calculate the total price
const total = goodsPrice + shipmentPrice + taxes;
// Create and append a new paragraph to the document
const para = document.createElement("p");
para.textContent = `Total price is ${total}`;
document.body.appendChild(para);
}
```
### Output of logs
- In code intended to run in a production environment, you rarely need to comment when you log some data. In code examples, we often use `console.log()`, `console.error()`, or similar functions to output important values. To help the reader understand what will happen without running the code, you can put a comment _after_ the function with the log that will be produced. Write:
```js example-good
function exampleFunc(fruitBasket) {
console.log(fruitBasket); // ['banana', 'mango', 'orange']
}
```
Don't write:
```js example-bad
function exampleFunc(fruitBasket) {
// Logs: ['banana', 'mango', 'orange']
console.log(fruitBasket);
}
```
- In case the line becomes too long, put the comment _after_ the function, like this:
```js example-good
function exampleFunc(fruitBasket) {
console.log(fruitBasket);
// ['banana', 'mango', 'orange', 'apple', 'pear', 'durian', 'lemon']
}
```
### Multi-line comments
Short comments are usually better, so try to keep them in one line of 60–80 characters. If this is not possible, use `//` at the beginning of each line:
```js example-good
// This is an example of a multi-line comment.
// The imaginary function that follows has some unusual
// limitations that I want to call out.
// Limitation 1
// Limitation 2
```
Don't use `/* … */`:
```js example-bad
/* This is an example of a multi-line comment.
The imaginary function that follows has some unusual
limitations that I want to call out.
Limitation 1
Limitation 2 */
```
### Use comments to mark ellipsis
Skipping redundant code using ellipses (…) is necessary to keep examples short. Still, writers should do it thoughtfully as developers frequently copy & paste examples into their code, and all of our code samples should be valid JavaScript.
In JavaScript, you should put the ellipses (`…`) in a comment. When possible, indicate what action somebody reusing this snippet is expected to add.
Using a comment for the ellipses (…) is more explicit, preventing errors when a developer copies and pastes a sample code. Write:
```js example-good
function exampleFunc() {
// Add your code here
// …
}
```
Don't use ellipses (…) like this:
```js example-bad
function exampleFunc() {
…
}
```
### Comment out parameters
When writing code, you usually omit parameters you don't need. But in some code examples, you want to demonstrate that you didn't use some possible parameters.
To do so, use `/* … */` in the parameter list. This is an exception to the rule to only use single-line comments (`//`).
```js
array.forEach((value /* , index, array */) => {
// …
});
```
## Functions
### Function names
For function names, use {{Glossary("camel_case", "camel case")}}, starting with a lowercase character. Use concise, human-readable, and semantic names where appropriate.
The following is a correct example of a function name:
```js example-good
function sayHello() {
console.log("Hello!");
}
```
Don't use function names like these:
```js example-bad
function SayHello() {
console.log("Hello!");
}
function doIt() {
console.log("Hello!");
}
```
### Function declarations
- Where possible, use the function declaration over function expressions to define functions.
Here is the recommended way to declare a function:
```js example-good
function sum(a, b) {
return a + b;
}
```
This is not a good way to define a function:
```js example-bad
let sum = function (a, b) {
return a + b;
};
```
- When using anonymous functions as a callback (a function passed to another method invocation), if you do not need to access `this`, use an arrow function to make the code shorter and cleaner.
Here is the recommended way:
```js example-good
const array1 = [1, 2, 3, 4];
const sum = array1.reduce((a, b) => a + b);
```
Instead of this:
```js example-bad
const array1 = [1, 2, 3, 4];
const sum = array1.reduce(function (a, b) {
return a + b;
});
```
- Consider avoiding using arrow function to assign a function to an identifier. In particular, don't use arrow functions for methods. Use function declarations with the keyword `function`:
```js example-good
function x() {
// …
}
```
Don't do:
```js example-bad
const x = () => {
// …
};
```
- When using arrow functions, use [implicit return](/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions#function_body) (also known as _expression body_) when possible:
```js example-good
arr.map((e) => e.id);
```
And not:
```js example-bad
arr.map((e) => {
return e.id;
});
```
## Loops and conditional statements
### Loop initialization
When [loops](/en-US/docs/Learn/JavaScript/Building_blocks/Looping_code) are required, choose the appropriate one from [`for(;;)`](/en-US/docs/Web/JavaScript/Reference/Statements/for), [`for...of`](/en-US/docs/Web/JavaScript/Reference/Statements/for...of), [`while`](/en-US/docs/Web/JavaScript/Reference/Statements/while), etc.
- When iterating through all collection elements, avoid using the classical `for (;;)` loop; prefer `for...of` or `forEach()`. Note that if you are using a collection that is not an `Array`, you have to check that `for...of` is actually supported (it requires the variable to be iterable), or that the `forEach()` method is actually present.
Use `for...of`:
```js example-good
const dogs = ["Rex", "Lassie"];
for (const dog of dogs) {
console.log(dog);
}
```
Or `forEach()`:
```js example-good
const dogs = ["Rex", "Lassie"];
dogs.forEach((dog) => {
console.log(dog);
});
```
Do not use `for (;;)` — not only do you have to add an extra index, `i`, but you also have to track the length of the array. This can be error-prone for beginners.
```js example-bad
const dogs = ["Rex", "Lassie"];
for (let i = 0; i < dogs.length; i++) {
console.log(dogs[i]);
}
```
- Make sure that you define the initializer properly by using the `const` keyword for `for...of` or `let` for the other loops. Don't omit it. These are correct examples:
```js example-good
const cats = ["Athena", "Luna"];
for (const cat of cats) {
console.log(cat);
}
for (let i = 0; i < 4; i++) {
result += arr[i];
}
```
The example below does not follow the recommended guidelines for the initialization (it implicitly creates a global variable and will fail in strict mode):
```js example-bad
const cats = ["Athena", "Luna"];
for (i of cats) {
console.log(i);
}
```
- When you need to access both the value and the index, you can use `.forEach()` instead of `for (;;)`. Write:
```js example-good
const gerbils = ["Zoé", "Chloé"];
gerbils.forEach((gerbil, i) => {
console.log(`Gerbil #${i}: ${gerbil}`);
});
```
Do not write:
```js example-bad
const gerbils = ["Zoé", "Chloé"];
for (let i = 0; i < gerbils.length; i++) {
console.log(`Gerbil #${i}: ${gerbils[i]}`);
}
```
> **Warning:** Never use `for...in` with arrays and strings.
> **Note:** Consider not using a `for` loop at all. If you are using an [`Array`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array) (or a [`String`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/String) for some operations), consider using more semantic iteration methods instead, like [`map()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map), [`every()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/every), [`findIndex()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/findIndex), [`find()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find), [`includes()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/includes), and many more.
### Control statements
There is one notable case to keep in mind for the `if...else` control statements. If the `if` statement ends with a `return`, do not add an `else` statement.
Continue right after the `if` statement. Write:
```js example-good
if (test) {
// Perform something if test is true
// …
return;
}
// Perform something if test is false
// …
```
Do not write:
```js example-bad
if (test) {
// Perform something if test is true
// …
return;
} else {
// Perform something if test is false
// …
}
```
### Use braces with control flow statements and loops
While control flow statements like `if`, `for`, and `while` don't require the use of braces when the content is made of one single statement, you should always use braces. Write:
```js example-good
for (const car of storedCars) {
car.paint("red");
}
```
Don't write:
```js example-bad
for (const car of storedCars) car.paint("red");
```
This prevent forgetting to add the braces when adding more statements.
### Switch statements
Switch statements can be a little tricky.
- Don't add a `break` statement after a `return` statement in a specific case. Instead, write `return` statements like this:
```js example-good
switch (species) {
case "chicken":
return farm.shed;
case "horse":
return corral.entry;
default:
return "";
}
```
If you add a `break` statement, it will be unreachable. Do not write:
```js example-bad
switch (species) {
case "chicken":
return farm.shed;
break;
case "horse":
return corral.entry;
break;
default:
return "";
}
```
- Use `default` as the last case, and don't end it with a `break` statement. If you need to do it differently, add a comment explaining why.
- Remember that when you declare a local variable for a case, you need to use braces to define a scope:
```js
switch (fruits) {
case "Orange": {
const slice = fruit.slice();
eat(slice);
break;
}
case "Apple": {
const core = fruit.extractCore();
recycle(core);
break;
}
}
```
### Error handling
- If certain states of your program throw uncaught errors, they will halt execution and potentially reduce the usefulness of the example. You should, therefore, catch errors using a [`try...catch`](/en-US/docs/Web/JavaScript/Reference/Statements/try...catch) block, as shown below:
```js example-good
try {
console.log(getResult());
} catch (e) {
console.error(e);
}
```
- When you don't need the parameter of the `catch` statement, omit it:
```js example-good
try {
console.log(getResult());
} catch {
console.error("An error happened!");
}
```
> **Note:** Keep in mind that only _recoverable_ errors should be caught and handled. All non-recoverable errors should be let through and bubble up the call stack.
## Objects
### Object names
- When defining a class, use _PascalCase_ (starting with a capital letter) for the class name and _camelCase_ (starting with a lowercase letter) for the object property and method names.
- When defining an object instance, either a literal or via a constructor, use _camelCase_, starting with lower-case character, for the instance name. For example:
```js example-good
const hanSolo = new Person("Han Solo", 25, "he/him");
const luke = {
name: "Luke Skywalker",
age: 25,
pronouns: "he/him",
};
```
### Object creation
For creating general objects (i.e., when classes are not involved), use literals and not constructors.
For example, do this:
```js example-good
const object = {};
```
Don't create a general object like this:
```js example-bad
const object = new Object();
```
### Object classes
- Use ES class syntax for objects, not old-style constructors.
For example, this is the recommended way:
```js example-good
class Person {
constructor(name, age, pronouns) {
this.name = name;
this.age = age;
this.pronouns = pronouns;
}
greeting() {
console.log(`Hi! I'm ${this.name}`);
}
}
```
- Use `extends` for inheritance:
```js example-good
class Teacher extends Person {
// …
}
```
### Methods
To define methods, use the method definition syntax:
```js example-good
const obj = {
foo() {
// …
},
bar() {
// …
},
};
```
Instead of:
```js example-bad
const obj = {
foo: function () {
// …
},
bar: function () {
// …
},
};
```
### Object properties
- The [`Object.prototype.hasOwnProperty()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/hasOwnProperty) method has been deprecated in favor of [`Object.hasOwn()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/hasOwn).
- When possible, use the shorthand avoiding the duplication of the property identifier. Write:
```js example-good
function createObject(name, age) {
return { name, age };
}
```
Don't write:
```js example-bad
function createObject(name, age) {
return { name: name, age: age };
}
```
## Operators
This section lists our recommendations of which operators to use and when.
### Conditional operators
When you want to store to a variable a literal value depending on a condition, use a [conditional (ternary) operator](/en-US/docs/Web/JavaScript/Reference/Operators/Conditional_operator) instead of an `if...else` statement. This rule also applies when returning a value. Write:
```js example-good
const x = condition ? 1 : 2;
```
Do not write:
```js example-bad
let x;
if (condition) {
x = 1;
} else {
x = 2;
}
```
The conditional operator is helpful when creating strings to log information. In such cases, using a regular `if...else` statement leads to long blocks of code for a side operation like logging, obfuscating the central point of the example.
### Strict equality operator
Prefer the [strict equality](/en-US/docs/Web/JavaScript/Reference/Operators/Strict_equality) (triple equals) and inequality operators over the loose equality (double equals) and inequality operators.
Use the strict equality and inequality operators like this:
```js example-good
name === "Shilpa";
age !== 25;
```
Don't use the loose equality and inequality operators, as shown below:
```js example-bad
name == "Shilpa";
age != 25;
```
If you need to use `==` or `!=`, remember that `== null` is the only acceptable case. As TypeScript will fail on all other cases, we don't want to have them in our example code. Consider adding a comment to explain why you need it.
### Shortcuts for boolean tests
Prefer shortcuts for boolean tests. For example, use `if (x)` and `if (!x)`, not `if (x === true)` and `if (x === false)`, unless different kinds of truthy or falsy values are handled differently.
## Strings
String literals can be enclosed within single quotes, as in `'A string'`, or within double quotes, as in `"A string"`. Don't worry about which one to use; Prettier keeps it consistent.
### Template literals
For inserting values into strings, use [template literals](/en-US/docs/Web/JavaScript/Reference/Template_literals).
- Here is an example of the recommended way to use template literals. Their use prevents a lot of spacing errors.
```js example-good
const name = "Shilpa";
console.log(`Hi! I'm ${name}!`);
```
Don't concatenate strings like this:
```js example-bad
const name = "Shilpa";
console.log("Hi! I'm" + name + "!"); // Hi! I'mShilpa!
```
- Don't overuse template literals. If there are no substitutions, use a normal string literal instead.
## Variables
### Variable names
Good variable names are essential to understanding code.
- Use short identifiers, and avoid non-common abbreviations. Good variable names are usually between 3 to 10-character long, but as a hint only. For example, `accelerometer` is more descriptive than abbreviating to `acclmtr` for the sake of character length.
- Try to use real-world relevant examples where each variable has clear semantics. Only fall back to placeholder names like `foo` and `bar` when the example is simple and contrived.
- Do not use the [Hungarian notation](https://en.wikipedia.org/wiki/Hungarian_notation) naming convention. Do not prefix the variable name with its type. For example, write `bought = car.buyer !== null` rather than `bBought = oCar.sBuyer != null` or `name = "John Doe"` instead of `sName = "John Doe"`.
- For collections, avoid adding the type such as list, array, queue in the name. Use the content name in the plural form. For example, for an array of cars, use `cars` and not `carArray` or `carList`. There may be exceptions, like when you want to show the abstract form of a feature without the context of a particular application.
- For primitive values, use _camelCase_, starting with a lowercase character. Do not use `_`. Use concise, human-readable, and semantic names where appropriate. For example, use `currencyName` rather than `currency_name`.
- Avoid using articles and possessives. For example, use `car` instead of `myCar` or `aCar`. There may be exceptions, like when describing a feature in general without a practical context.
- Use variable names as shown here:
```js example-good
const playerScore = 0;
const speed = distance / time;
```
Don't name variables like this:
```js example-bad
const thisIsaveryLONGVariableThatRecordsPlayerscore345654 = 0;
const s = d / t;
```
> **Note:** The only place where it's allowed not to use human-readable, semantic names is where a very commonly recognized convention exists, such as using `i` and `j` for loop iterators.
### Variable declarations
When declaring variables and constants, use the [`let`](/en-US/docs/Web/JavaScript/Reference/Statements/let) and [`const`](/en-US/docs/Web/JavaScript/Reference/Statements/const) keywords, not [`var`](/en-US/docs/Web/JavaScript/Reference/Statements/var). The following examples show what's recommended and what's not on MDN Web Docs:
- If a variable will not be reassigned, prefer `const`, like so:
```js example-good
const name = "Shilpa";
console.log(name);
```
- If you'll change the value of a variable, use `let` as shown below:
```js example-good
let age = 40;
age++;
console.log("Happy birthday!");
```
- The example below uses `let` where it should be `const`. The code will work, but we want to avoid this usage in MDN Web Docs code examples.
```js example-bad
let name = "Shilpa";
console.log(name);
```
- The example below uses `const` for a variable that gets reassigned. The reassignment will throw an error.
```js example-bad
const age = 40;
age++;
console.log("Happy birthday!");
```
- The example below uses `var`, polluting the global scope:
```js example-bad
var age = 40;
var name = "Shilpa";
```
- Declare one variable per line, like so:
```js example-good
let var1;
let var2;
let var3 = "Apapou";
let var4 = var3;
```
Do not declare multiple variables in one line, separating them with commas or using chain declaration. Avoid declaring variables like this:
```js-nolint example-bad
let var1, var2;
let var3 = var4 = "Apapou"; // var4 is implicitly created as a global variable; fails in strict mode
```
### Type coercion
Avoid implicit type coercions. In particular, avoid `+val` to force a value to a number and `"" + val` to force it to a string. Use `Number()` and `String()`, without `new`, instead. Write:
```js example-good
class Person {
#name;
#birthYear;
constructor(name, year) {
this.#name = String(name);
this.#birthYear = Number(year);
}
}
```
Don't write:
```js example-bad
class Person {
#name;
#birthYear;
constructor(name, year) {
this.#name = "" + name;
this.#birthYear = +year;
}
}
```
## Web APIs to avoid
In addition to these JavaScript language features, we recommend a few guidelines related to Web APIs to keep in mind.
### Avoid browser prefixes
If all major browsers (Chrome, Edge, Firefox, and Safari) support a feature, don't prefix the feature. Write:
```js example-good
const context = new AudioContext();
```
Avoid the added complexity of prefixes. Don't write:
```js example-bad
const AudioContext = window.AudioContext || window.webkitAudioContext;
const context = new AudioContext();
```
The same rule applies to CSS prefixes.
### Avoid deprecated APIs
When a method, a property, or a whole interface is deprecated, do not use it (outside its documentation). Instead, use the modern API.
Here is a non-exhaustive list of Web APIs to avoid and what to replace them with:
- Use `fetch()` instead of XHR (`XMLHttpRequest`).
- Use `AudioWorklet` instead of `ScriptProcessorNode`, in the Web Audio API.
### Use safe and reliable APIs
- Do not use {{DOMxRef("Element.innerHTML")}} to insert purely textual content into an element; use {{DOMxRef("Node.textContent")}} instead. The property `innerHTML` leads to security problems if a developer doesn't control the parameter. The more we as writers avoid using it, the fewer security flaws are created when a developer copies and pastes our code.
The example below demonstrates the use of `textContent`.
```js example-good
const text = "Hello to all you good people";
const para = document.createElement("p");
para.textContent = text;
```
Don't use `innerHTML` to insert _pure text_ into DOM nodes.
```js example-bad
const text = "Hello to all you good people";
const para = document.createElement("p");
para.innerHTML = text;
```
- The `alert()` function is unreliable. It doesn't work in live examples on MDN Web Docs that are inside an {{HTMLElement("iframe")}}. Moreover, it is modal to the whole window, which is annoying. In static code examples, use `console.log()` or `console.error()`. In [live examples](/en-US/docs/MDN/Writing_guidelines/Page_structures/Live_samples), avoid `console.log()` and `console.error()` because they are not displayed. Use a dedicated UI element.
### Use the appropriate log method
- When logging a message, use `console.log()`.
- When logging an error, use `console.error()`.
## See also
[JavaScript language reference](/en-US/docs/Web/JavaScript/Reference) - browse through our JavaScript reference pages to check out some good, concise, meaningful JavaScript snippets.
| 0 |
data/mdn-content/files/en-us/mdn/writing_guidelines/writing_style_guide/code_style_guide | data/mdn-content/files/en-us/mdn/writing_guidelines/writing_style_guide/code_style_guide/css/index.md | ---
title: Guidelines for writing CSS code examples
slug: MDN/Writing_guidelines/Writing_style_guide/Code_style_guide/CSS
page-type: mdn-writing-guide
---
{{MDNSidebar}}
The following guidelines cover how to write CSS example code for MDN Web Docs.
## General guidelines for CSS code examples
### Choosing a format
Opinions on correct indentation, whitespace, and line lengths have always been controversial. Discussions on these topics are a distraction from creating and maintaining content.
On MDN Web Docs, we use [Prettier](https://prettier.io/) as a code formatter to keep the code style consistent (and to avoid off-topic discussions). You can consult our [configuration file](https://github.com/mdn/content/blob/main/.prettierrc.json) to learn about the current rules, and read the [Prettier documentation](https://prettier.io/docs/en/index.html).
Prettier formats all the code and keeps the style consistent. Nevertheless, there are a few additional rules that you need to follow.
### Plan your CSS
Before diving in and writing huge chunks of CSS, plan your styles carefully. What general styles are going to be needed, what different layouts do you need to create, what specific overrides need to be created, and are they reusable? Above all, you need to try to **avoid too much overriding**. If you keep finding yourself writing styles and then cancelling them again a few rules down, you probably need to rethink your strategy.
### Use flexible/relative units
For maximum flexibility over the widest possible range of devices, it is a good idea to size containers, padding, etc. using relative units like ems and rems or percentages and viewport units if you want them to vary depending on viewport width. You can read some more about this in our [guide to CSS values and units](/en-US/docs/Learn/CSS/Building_blocks/Values_and_units#relative_length_units).
### Don't use preprocessors
Don't use preprocessor syntax, such as [Sass](https://sass-lang.com/), [Less](https://lesscss.org/), or [Stylus](https://stylus-lang.com/), in the example code. On MDN Web Docs, we document the vanilla CSS language. Using preprocessors will only raise the bar to understanding the examples, potentially confusing readers.
### Don't use specific CSS methodologies
In the same spirit as the previous guideline, don't write example codes on MDN Web Docs using a specific CSS methodology such as [BEM](https://getbem.com/naming/) or [SMACSS](https://smacss.com/). Even though they are valid CSS syntax, the naming conventions can be confusing to people not familiar with those methodologies.
### Don't use resets
For maximum control over CSS across platforms, a lot of people used to use CSS resets to remove every style, before then building things back up themselves. This certainly has its merits, but especially in the modern world, CSS resets can be an overkill, resulting in a lot of extra time spent reimplementing things that weren't completely broken in the first place, like default margins, list styles, etc.
If you really feel like you need to use a reset, consider using [normalize.css by Nicolas Gallagher](https://necolas.github.io/normalize.css/), which aims to just make things more consistent across browsers, get rid of some default annoyances that we always remove (the margins on `<body>`, for example) and fix a few bugs.
## !important
`!important` is the last resort that is generally used only when you need to override something and there is no other way to do it. Using `!important` is a bad practice and you should avoid it wherever possible.
```css example-bad
.bad-code {
font-size: 4rem !important;
}
```
## CSS comments
Use CSS-style comments to comment code that isn't self-documenting. Also note that you should leave a space between the asterisks and the comment.
```css example-good
/* This is a CSS-style comment */
```
Put your comments on separate lines preceding the code they are referring to, like so:
```css example-good
h3 {
/* Creates a red drop shadow, offset 1px right and down, w/2px blur radius */
text-shadow: 1px 1px 2px red;
/* Sets the font-size to double the default document font size */
font-size: 2rem;
}
```
## Double quotes around values
Where quotes can or should be included, use them, and use double quotes. For example:
```css example-good
[data-vegetable="liquid"] {
background-color: goldenrod;
background-image: url("../../media/examples/lizard.png");
}
```
## Longhand vs. shorthand rules
Usually, when teaching the specifics of CSS syntax, it is clearer and more obvious to use longhand properties, rather than terse shorthand (unless, of course, you're explaining shorthand through the example). Remember that the point of examples on MDN Web Docs is to teach people, not to be clever or efficient. We explain here why writing with longhand rules is recommended.
- It is often harder to understand what the shorthand is doing. In the example below, it takes a while to pick apart exactly what the {{cssxref("font")}} syntax is doing.
```css
font: small-caps bold 2rem/1.5 sans-serif;
```
Whereas the following style is clearer:
```css
font-variant: small-caps;
font-weight: bold;
font-size: 2rem;
line-height: 1.5;
font-family: sans-serif;
```
- CSS shorthand comes with potential added pitfalls — default values are set for parts of the syntax that you don't explicitly set, which can produce unexpected resets of values you've set earlier in the cascade or other expected effects. The {{cssxref("grid")}} property, for example, sets all of the following default values for items that are not specified:
- {{cssxref("grid-template-rows")}}: `none`
- {{cssxref("grid-template-columns")}}: `none`
- {{cssxref("grid-template-areas")}}: `none`
- {{cssxref("grid-auto-rows")}}: `auto`
- {{cssxref("grid-auto-columns")}}: `auto`
- {{cssxref("grid-auto-flow")}}: `row`
- {{cssxref("column-gap")}}: `0`
- {{cssxref("row-gap")}}: `0`
- {{cssxref("column-gap")}}: `normal`
- {{cssxref("row-gap")}}: `normal`
- Some shorthands only work as expected if you include the different value components in a certain order. This is the case in CSS animations. In the example below, the expected order is written as a comment:
```css
/* duration | timing-function | delay | iteration-count
direction | fill-mode | play-state | name */
animation: 3s ease-in 1s 2 reverse both paused slidein;
```
In this example, the first value that can be parsed as a [`<time>`](/en-US/docs/Web/CSS/time) is assigned to the [`animation-duration`](/en-US/docs/Web/CSS/animation-duration) property, and the second value that can be parsed as time is assigned to [`animation-delay`](/en-US/docs/Web/CSS/animation-delay). (For more information, see [animation syntax](/en-US/docs/Web/CSS/animation#syntax) details.)
## Mobile-first media queries
In a stylesheet that contains [media query](/en-US/docs/Web/CSS/CSS_media_queries/Using_media_queries) styles for different target viewport sizes, first include the narrow screen/mobile styling before any other media queries are encountered. Add styling for wider viewport sizes via successive media queries. Following this rule has many advantages that are explained in the [Mobile First](/en-US/docs/Learn/CSS/CSS_layout/Responsive_Design) article.
```css example-good
/* Default CSS layout for narrow screens */
@media (min-width: 480px) {
/* CSS for medium width screens */
}
@media (min-width: 800px) {
/* CSS for wide screens */
}
@media (min-width: 1100px) {
/* CSS for really wide screens */
}
```
## Selectors
- Don't use ID selectors because they are:
- less flexible; you can't add more if you discover you need more than one.
- harder to override because they have higher specificity than classes.
```css example-good
.editorial-summary {
/* ... */
}
```
```css example-bad
#editorial-summary {
/* ... */
}
```
## Value to turn off properties
When turning off borders (and any other properties that can take `0` or `none` as values), use `0` rather than `none`:
```css example-good
border: 0;
```
## See also
[CSS reference index](/en-US/docs/Web/CSS/Reference#index) - browse through our CSS property reference pages to check out some good, concise, meaningful CSS snippets. Our interactive examples in the "Try it" section are generally written to follow the guidelines described on this page.
| 0 |
data/mdn-content/files/en-us/mdn/writing_guidelines | data/mdn-content/files/en-us/mdn/writing_guidelines/experimental_deprecated_obsolete/index.md | ---
title: Experimental, deprecated, and obsolete
slug: MDN/Writing_guidelines/Experimental_deprecated_obsolete
page-type: mdn-writing-guide
---
{{MDNSidebar}}
These terms are commonly associated with technologies and specifications and are used on MDN Web Docs to label the status of a technology. For the definition of these terms, MDN Web Docs align with the [Browser Compatibility Data (BCD)](https://github.com/mdn/browser-compat-data/blob/main/schemas/compat-data-schema.md#status-information) repository.
These terms are described below in the context of their use on MDN Web Docs.
## Experimental
When a technology is described as experimental on MDN Web Docs, it means that the technology is nascent and immature and is currently _in the process_ of being added to the web platform (or being considered for addition).
Marking a technology as experimental indicates that readers should think carefully before using that technology in any kind of production project (i.e., a project that is not just a demo or experiment). Readers are [encouraged to try out experimental features](https://github.com/mdn/browser-compat-data/blob/main/schemas/compat-data-schema.md#status-information) and provide feedback to browser vendors and standards authors.
For a technology marked **experimental**, one or more of the following conditions apply:
- It is implemented and enabled by default in the release build of **only one** modern major browser rendering engine.
- It is only supported through configuration changes such as preferences or flags, regardless of the number of supported rendering engines.
- Its defining specification is likely to change significantly in backwards-incompatible ways (i.e., it may break existing code that relies on the feature).
> **Note:** A feature that is only released on one rendering engine is still considered experimental even if it is available on preview builds of other rendering engines (or by setting a preference or flag).
The **experimental** status of a technology may expire if one or more of the following conditions is met:
- It is supported by default in **two or more** major browser rendering engines.
- It is supported by default by a single browser rendering engine for two or more years and undergoes no major changes.
- Its defining specification is unlikely to change in ways that will break compatibility.
For examples of these conditions, see the [experimental flag](https://github.com/mdn/browser-compat-data/blob/main/docs/data-guidelines/index.md#setting-experimental) BCD documentation.
Usually, if a technology is supported across several major browsers, the specification will be stable, but this is not always the case.
On the other hand, some technologies might have a stable specification, but do not have native support in browsers. [IMSC](/en-US/docs/Related/IMSC) for example is used via a JavaScript polyfill. <!-- need to revisit link -->
A feature or technology that is part of an active specification or standardization process and not marked **deprecated** is said to be on a **standards track**.
## Deprecated
The term **deprecated** on MDN Web Docs is used to mark an API or technology that is no longer recommended. A deprecated API or technology might be removed in the future or might only be kept for compatibility purposes and may still work. We recommend to avoid using the functionality marked as deprecated.
For more information on the definition of **deprecated**, see the [deprecated flag](https://github.com/mdn/browser-compat-data/blob/main/docs/data-guidelines/index.md#setting-deprecated) BCD documentation.
## Obsolete
On MDN Web Docs, the term **obsolete** was historically used to indicate an API or technology that is not only no longer recommended but is also no longer implemented in browsers.
Because the distinction between **obsolete** and **deprecated** is not very helpful, we do not use the term **obsolete** on MDN Web Docs anymore.
> **Note:** If you come across any instance of **obsolete**, it should be removed or replaced with the term **deprecated**.
## Guidelines for removing content
Sometimes during the development of a new specification or over the course of the evolution of living standards such as HTML, new elements, methods, properties, and so forth are added to the specification, kept there for a while, and then removed. Sometimes this happens very quickly, and sometimes these new items remain in the specification for months or even years before being removed. This can make it tricky to decide how to handle the removal of the item from the specification.
Here are some guidelines to help you decide what to do when something is removed from the specification.
> **Note:** For the purposes of this discussion, the word "item" is used to mean anything that can be part of a specification: an element or an attribute of an element, an interface or any individual method, a property, or other member of an interface, and so forth.
### If the item was never implemented
If the item was _never_ implemented in a release version of _any_ browser, not even behind a preference or a flag, delete any references to the item from the documentation.
- If the item has any documentation pages describing only that one item (such as {{domxref("RTCPeerConnection.close()")}}), delete that page.
If the removed item is an interface, this means removing any subpages describing the properties and methods on that interface as well.
- Remove the item from any lists of properties, attributes, methods, and so forth. For methods of an interface, for example, this means removing it from the "Methods" section on the interface's overview page.
- Search the text of the overview page for that interface, element, etc., for any references to the removed item. Remove those references, being sure not to leave weird grammar issues or other problems with the text. This may mean not just deleting words but rewriting a sentence or paragraph to make more sense. It may also mean removing entire sections of content if the description of the item's use is lengthy.
- Similarly, look for any discussion of the item in the guides and tutorials about the relevant API or technology. Remove those references, being sure not to leave weird grammar issues or other problems with the text. This may mean not just deleting words but rewriting a sentence or paragraph to make more sense. It may also mean removing entire sections of content if the description of the item's use is lengthy.
- Search MDN Web Docs for references to the removed item, in case there are discussions elsewhere. It's unlikely that there are, since if it was never implemented, it's unlikely to be widely discussed. Remove those mentions as well.
- If the JSON files in the [Browser Compatibility Data repository](https://github.com/mdn/browser-compat-data) contain data for the removed items, delete those objects from the JSON code and submit a pull request with that change, explaining the reason in the commit message and the pull request description. Be careful to check that you don't break the JSON syntax while doing this.
### If the item was implemented in a browser behind a flag
If the item was implemented in any release version of any one or more browsers but _only_ behind a preference or a flag, do not delete the item from the documentation immediately. Instead, mark the item as **deprecated** as follows:
- If the item has any documentation pages describing only that one item (such as {{domxref("RTCPeerConnection.close()")}}), add the [`deprecated_header`](https://github.com/mdn/yari/blob/main/kumascript/macros/Deprecated_Header.ejs) macro to the top of the page and add the following `status:` front-matter entry:
```yaml
status:
- deprecated
```
- On the overview page for the element, interface, or API, find the list of items that includes the item that's been removed from the specification and add the [`deprecated_inline`](https://github.com/mdn/yari/blob/main/kumascript/macros/Deprecated_Inline.ejs) macro after the item's name in that list.
- Search the informative text of the overview page for that interface, element, etc., for any references to the removed item. Add warning boxes in appropriate places with text along the lines of "\[item] has been removed from the specification and will be removed from browsers soon. See \[link to page] for a new way to do this."
- Similarly, look for any discussion of the item in the guides and tutorials about the relevant API or technology. Add similar warnings.
- Search MDN Web Docs for references to the removed item, in case there are discussions elsewhere. Add similar warning boxes there as well.
- At some point in the future, a decision may be made to actually remove the item from the documentation; we don't normally do this but if the item was especially unutilized or uninteresting, we may decide to do so.
- Update any relevant entries in the [Browser Compatibility Data repository](https://github.com/mdn/browser-compat-data) to reflect the obsolescence of the item(s) affected.
### If the item was implemented in a browser without a flag
If the item was implemented in one or more release builds of browsers without requiring a preference or a flag, mark the item as **deprecated**, as follows:
- If the item has any documentation pages describing only that one item (such as {{domxref("RTCPeerConnection.close()")}}), add the [`deprecated_header`](https://github.com/mdn/yari/blob/main/kumascript/macros/Deprecated_Header.ejs) macro to the top of the page and add the following `status:` front-matter entry:
```yaml
status:
- deprecated
```
- On the overview page for the element, interface, or API, find the list of items that includes the item that's been removed from the specification and add the [`deprecated_inline`](https://github.com/mdn/yari/blob/main/kumascript/macros/Deprecated_Inline.ejs) macro after the item's name in that list.
- Search the informative text of the overview page for that interface, element, etc., for any references to the removed item. Add warning boxes in appropriate places with text along the lines of "\[item] has been removed from the specification and is deprecated. It may be removed from browsers in the future, so you should not use it. See \[link to page] for a new way to do this."
- Similarly, look for any discussion of the item in the guides and tutorials about the relevant API or technology. Add similar warnings.
- Search MDN Web Docs for references to the removed item, in case there are discussions elsewhere. Add similar warning boxes there as well.
- It's unlikely that these items will be removed from the documentation anytime soon, if ever.
- Update any relevant entries in the [Browser Compatibility Data repository](https://github.com/mdn/browser-compat-data) to reflect the deprecation of the item(s) affected.
Please use common sense with wording of warning messages and other changes to the text suggested in the guidelines above.
Different items will require different wording and handling of the situation.
When in doubt, feel free to ask for advice on the [MDN Web Docs chat rooms](/en-US/docs/MDN/Community/Communication_channels#chat_rooms).
## Guidelines for documenting a specification conflict
Sometimes, but rarely, there might be a conflict between different specification versions (usually W3C versus WHATWG). For example, one version might have a feature listed as deprecated, while the other doesn't.
In such cases, consider what the reality is, that is, consider what browsers are actually doing, and write an "important" note to summarize that latest status.
For example, as of Jan 2019, the [`inputmode`](/en-US/docs/Web/HTML/Global_attributes/inputmode) global attribute has a conflict, which was summarized like so: <!--this warning example for spec conflict does not exist anymore on that page. couldn't find any other examples as well -->
> **Warning:** Specification conflict: The WHATWG specification lists [`inputmode`](https://html.spec.whatwg.org/multipage/interaction.html#attr-inputmode) and modern browsers are working towards supporting it.
> The [W3C HTML 5.2 spec](https://html.spec.whatwg.org/multipage/index.html#contents), however, no longer lists it (i.e. marks it as obsolete).
> You should consider the WHATWG definition as correct, until a consensus is reached.
| 0 |
data/mdn-content/files/en-us/mdn/writing_guidelines | data/mdn-content/files/en-us/mdn/writing_guidelines/howto/index.md | ---
title: How-to guides
slug: MDN/Writing_guidelines/Howto
page-type: mdn-writing-guide
---
{{MDNSidebar}}
This section of MDN Web Docs writing guidelines contains all the step-by-step information for accomplishing specific tasks when contributing to MDN Web Docs: how we use markdown, how we add an entry to the glossary, how we move or delete pages, and more. To find out more about _how to contribute_ (which happens through GitHub), see our [contribution guidelines](/en-US/docs/MDN/Community/Contributing).
> **Note:** All the way through this section, we assume that you've read the contribution guidelines, are familiar with the `mdn/content` repository, and know how to use git and GitHub.
{{LandingPageListSubpages}}
| 0 |
data/mdn-content/files/en-us/mdn/writing_guidelines/howto | data/mdn-content/files/en-us/mdn/writing_guidelines/howto/document_a_css_property/index.md | ---
title: How to document a CSS property
slug: MDN/Writing_guidelines/Howto/Document_a_CSS_property
page-type: mdn-writing-guide
---
{{MDNSidebar}}
As the [CSS](/en-US/docs/Web/CSS) standards evolve, new properties are always being added. The [CSS Reference](/en-US/docs/Web/CSS/Reference) on MDN Web Docs needs to be kept up-to-date with these developments. This article provides step-by-step instructions for creating a CSS property reference page.
Each CSS property reference page follows the same structure. This helps readers find information more easily, especially after they are familiar with the standard reference page format.
## Step 1 — Determine the property to document
First, you will need to find out the CSS property you want to document. You might have noticed that a page is missing, or you might have seen missing content reported in our [issues list](https://github.com/mdn/content/issues). For details about the CSS property, you will need to find a relevant specification for it (e.g., a [W3C specification](https://www.w3.org/Style/CSS/), or a bug report for a non-standard property used in rendering engines like Gecko or Blink).
> **Note:** When using a W3C specification, always use the **Editor's Draft** (note the red banner on the left side) and not a published version (e.g., Working Draft). The Editor's Draft is always closer to the final version!
If the implementation and specification diverge, feel free to mention it in the implementation bug. One of the following situations are possible:
- It may be a bug in the implementation (and a follow-up bug will be filed).
- It may be because of a delay in the publication of a new specification.
- It may be an error in the specification (in which case, a specification bug is worth filing).
## Step 2 — Check the database of CSS properties
Several characteristics of a CSS property, such as its syntax or if it can be animated, are mentioned in several pages and are therefore, stored in an ad hoc database. Macros that you'll use on the page need information about the property that is stored there, so start by [checking that this information is there](https://github.com/mdn/data/blob/main/docs/updating_css_json.md).
## Step 3 — Create the CSS property page
Preparations finished! Now we can add the actual CSS property page. The easiest way to create a new CSS property page is to copy the content of an existing CSS property page and edit it for the new property. To create a new page, see the instructions in our [how to create a page](/en-US/docs/MDN/Writing_guidelines/Howto/Creating_moving_deleting) guide.
When creating a reference page, you'll want to add _Examples_. To do that, follow this [tutorial about live samples](/en-US/docs/MDN/Writing_guidelines/Page_structures/Live_samples). Remember that the property page you're creating is for a single property, so the examples you add will need to show how this property works in isolation, not how the whole specification is used. Therefore, examples for the `list-style-type` property should show the results using different values for the property, not how to combine it with other properties, pseudo-classes, or pseudo-elements to generate nice effects. Tutorials and guides can be written to show more.
## Step 4 — Get the content reviewed
After you've created the property page, submit it as a pull request. A member of our review team will be assigned automatically to review your page.
| 0 |
data/mdn-content/files/en-us/mdn/writing_guidelines/howto | data/mdn-content/files/en-us/mdn/writing_guidelines/howto/json_structured_data/index.md | ---
title: How to use structured data
slug: MDN/Writing_guidelines/Howto/JSON_Structured_data
page-type: mdn-writing-guide
---
{{MDNSidebar}}
MDN stores data in well-defined structures when possible. This information is then centralized and can be updated once, while being used in numerous places.
There are several such files, and this document describes their purpose, structure, and maintenance process.
## GroupData: logical grouping of APIs
`GroupData` is a JSON file collecting information about Web APIs. The grouping of APIs is somewhat fuzzy: any interface, method or property can be part of several APIs. The set of APIs grouped under a name is a convention used to communicate about a feature, without any technical enforcement.
Yet, MDN needs this information to create coherent Web-API sidebars (like with the `\{{APIRef}}` macro) with the proper reference pages, guides, and overview articles.
GroupData does exactly that: for each API, it lists the interfaces, properties, methods, guides, and overview pages. In the past, it also listed dictionaries and callbacks. But that use, though still supported, is deprecated and will be removed in the future.
### Structure of GroupData
> **Warning:** Non-existent pages listed in this file are ignored (in en-US).
An entry in `GroupData.json` has the following structure:
```json
"Name_of_the_API": {
"overview": ["name_of_the_overview_page"],
"guides": [
"name_of_guide_1",
(…)
],
"interfaces": [
"name_of_interface_1",
(…)
],
"methods": [
"name_of_additional_method_1",
(…)
],
"properties": [
"name_of_additional_property_1",
(…)
],
"events": [
"name_of_additional_property_1",
(…)
]
}
```
…where:
- `"Name_of_the_API"`
- : This key is both an ID used by sidebar macros like `\{{APIRef("Name_of_the_API")}}` and the name displayed in the sidebar itself. Choose it wisely.
> **Warning:** If you want to change the name displayed in the sidebar, you must edit all the pages displaying it.
- `"overview"`
- : This is a list containing one page: the overview page, used as the link for the `"Name_of_the_API"` text. The value is the _title of the page_, and the page must be in the `web/api/` directory.
- `"guides"`
- : This is a list of guides to display in the sidebar, in the given order. The values are _paths to the page_, starting with `/docs/`.
- `"interfaces"`
- : This lists the interfaces that are part of the API.
- `"methods"`
- : This lists the methods that are part of the API.
> **Note:** The methods of the interfaces listed in `"interfaces"` **must** not be listed there. They are automatically added to the sidebar if the `page-type` key for that page is `web-api-static-method` or `web-api-instance-method`.
- `"properties"`
- : This lists the methods on other interfaces that are part of the API, like `navigator.xr` (a property that the WebXR API adds to the `navigator` object)
> **Note:** The properties of the interfaces listed in `"interfaces"` **must** not be listed there. They are automatically added to the sidebar if the `page-type` key for that page is `web-api-static-property` or `web-api-instance-property`.
- `"events"`
- : This lists events of other interfaces that are part of the API. The values are the _title of the pages_ (that must reside under `Web/Events`)
> **Note:** The events targeting the interfaces listed in `"interfaces"` **must** not be listed there. They are automatically added to the sidebar if the `page-type` key for that page is `web-api-event`.
There are two other keys, `"dictionaries"` and `"callbacks"`, operating on the same principle. As we no longer document these entities in their own pages, their use is deprecated, and no new entry should be added to them (and we remove them little by little).
> **Note:** Also, none of the keys are mandatory; it is good practice (and we'll enforce this) to add the non-deprecated ones with an empty list rather than omitting them. It shows that the absence of value is a conscious choice.
### Update process for GroupData
This file should be updated in the same PR where changes affecting the sidebar happens. That way, the sidebar is always up-to-date. Reviewers shouldn't merge PRs that don't adopt it.
To test your changes, check that the sidebar in the files in your PR displays all entries correctly.
The `GroupData.json` file is located [here](https://github.com/mdn/content/blob/main/files/jsondata/GroupData.json) on GitHub.
## InterfaceData: recording interface inheritance
> **Note:** We hope to generate this file automatically from the data available via w3c/webref in the future.
`InterfaceData` describes the hierarchy of the interfaces. It lists inheritance. In the past, it also listed mixins implemented by each interface; but that usage is deprecated, and we remove mixins from this file at the same rate MDN is updated.
This inheritance data is used when building API sidebars and by the `\{{InheritanceDiagram}}` in the interface pages.
### Structure of InterfaceData
An entry in `InterfaceData.json` has the following structure:
```json
"Name_of_the_interface": {
"inh": "Name_of_the_parent_interface",
"impl": []
}
```
> **Note:** As mixins are deprecated, `"impl"` must be an empty list for all new interfaces.
The value of `"Name_of_the_parent_interface"` is not a list but a single entry, mandatory; we must not list any interface that don't inherit from another one.
### Update process for InterfaceData
The same PR adding a new interface that inherits from another one must update this file. Reviewers shouldn't merge PRs that don't do so.
To test your changes, check that the sidebars of each interface you edited in your PR display inheritance correctly.
The `InterfaceData.json` file is located [here](https://github.com/mdn/content/blob/main/files/jsondata/InterfaceData.json) on GitHub.
## SpecData: Specification information
> **Warning:** The `SpecData.json` file is no longer maintained. Canonical specification information is stored at w3c/browser-spec and in the `spec_url` key of features at mdn/browser-compat-data.
The `\{{SpecName}}` and `\{{Spec2}}` macros that we are removing use the `SpecData.json` file. We do not accept any further contributions to the `SpecData.json` file; instead, either try to insert a specification table, using the `\{{Specifications}}` macro, or try to hardcode the (good) link to the specification. Note that most of the time, mentioning or linking to a specification outside the _Specifications_ section is a sign of something not appropriately documented on MDN.
The `SpecData.json` file is located [here](https://github.com/mdn/content/blob/main/files/jsondata/SpecData.json) on GitHub.
| 0 |
Subsets and Splits