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/css | data/mdn-content/files/en-us/web/css/ruby-position/index.md | ---
title: ruby-position
slug: Web/CSS/ruby-position
page-type: css-property
browser-compat: css.properties.ruby-position
---
{{CSSRef}}
The **`ruby-position`** CSS property defines the position of a ruby element relatives to its base element. It can be positioned over the element (`over`), under it (`under`), or between the characters on their right side (`inter-character`).
{{EmbedInteractiveExample("pages/css/ruby-position.html")}}
## Syntax
```css
/* Keyword values */
ruby-position: over;
ruby-position: under;
ruby-position: inter-character;
ruby-position: alternate;
/* Global values */
ruby-position: inherit;
ruby-position: initial;
ruby-position: revert;
ruby-position: revert-layer;
ruby-position: unset;
```
### Values
- `over`
- : Is a keyword indicating that the ruby has to be placed over the main text for horizontal scripts and right to it for vertical scripts.
- `under`
- : Is a keyword indicating that the ruby has to be placed under the main text for horizontal scripts and left to it for vertical scripts.
- `inter-character` {{Experimental_Inline}}
- : Is a keyword indicating that the ruby has to be placed between the different characters.
- `alternate` {{Experimental_Inline}}
- : Is a keyword indicating that the ruby alternates between over and under, when there are multiple levels of annotation.
## Formal definition
{{cssinfo}}
## Formal syntax
{{csssyntax}}
## Examples
### Ruby positioned over the text
#### HTML
```html
<ruby>
<rb>超電磁砲</rb>
<rp>（</rp><rt>レールガン</rt><rp>）</rp>
</ruby>
```
#### CSS
```css
ruby {
ruby-position: over;
}
```
#### Result
{{EmbedLiveSample("Ruby_positioned_over_the_text", 100, 40)}}
### Ruby positioned under the text
#### HTML
```html
<ruby>
<rb>超電磁砲</rb>
<rp>（</rp><rt>レールガン</rt><rp>）</rp>
</ruby>
```
#### CSS
```css
ruby {
ruby-position: under;
}
```
#### Result
{{EmbedLiveSample("Ruby_positioned_under_the_text", 100, 40)}}
### Ruby alternate
#### HTML
```html
<ruby>
<rb>A</rb><rb>B</rb><rb>C</rb>
<rtc>Above</rtc>
<rtc>Below</rtc>
</ruby>
```
#### CSS
```css
ruby {
ruby-position: alternate; /* this is also the initial value */
}
```
#### Result
{{EmbedLiveSample("Ruby_alternate", 100, 40)}}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- HTML Ruby elements: {{HTMLElement("ruby")}}, {{HTMLElement("rt")}}, {{HTMLElement("rp")}}, and {{HTMLElement("rtc")}}.
- CSS Ruby properties: {{cssxref("ruby-align")}}, {{cssxref("ruby-merge")}}.
| 0 |
data/mdn-content/files/en-us/web/css | data/mdn-content/files/en-us/web/css/basic-shape/index.md | ---
title: <basic-shape>
slug: Web/CSS/basic-shape
page-type: css-type
browser-compat: css.types.basic-shape
---
{{CSSRef}}
The **`<basic-shape>`** [CSS](/en-US/docs/Web/CSS) [data type](/en-US/docs/Web/CSS/CSS_Types) represents a shape used in the {{cssxref("clip-path")}}, {{cssxref("shape-outside")}}, and {{cssxref("offset-path")}} properties.
{{EmbedInteractiveExample("pages/css/type-basic-shape.html")}}
## Syntax
The `<basic-shape>` data type is defined with one of the basic shape functions listed below.
When creating a shape, the reference box is defined by each property that uses `<basic-shape>` values. The coordinate system for the shape has its origin at the top-left corner of the reference box, with the x-axis running to the right and the y-axis running downwards. All the lengths expressed in percentages are resolved from the used dimensions of the reference box.
The default reference box is the `margin-box`, as demonstrated in the below image which shows a circle created using `shape-outside: circle(50%)`. The shape is being defined with reference to the margin box.
### Shape functions
The following shapes are supported. All `<basic-shape>` values use functional notation and are defined here using the [value definition syntax](/en-US/docs/Web/CSS/Value_definition_syntax).
- `{{cssxref("basic-shape/inset","inset()")}}`
- : Defines an inset rectangle.
```css
inset( <length-percentage>{1,4} [ round <`border-radius`> ]? )
```
When all of the first four arguments are supplied, they represent the top, right, bottom and left offsets from the reference box inward that define the position of the edges of the inset rectangle. These arguments follow the syntax of the {{cssxref("margin")}} shorthand, which lets you set all four insets with one, two, three, or four values.
The optional `round <'border-radius'>` parameter defines rounded corners for the inset rectangle using the same syntax as the CSS [`border-radius`](/en-US/docs/Web/CSS/border-radius) shorthand property.
A pair of insets in either dimension that add up to more than the used dimension (such as left and right insets of 75% apiece) define a shape enclosing no area. For this specification, this results in an empty float area.
- `{{cssxref("basic-shape/rect","rect()")}}`
- : Defines a rectangle using the specified distances from the top and left edges of the reference box.
```css
rect( [ <length-percentage> | auto ]{4} [ round <`border-radius`> ]? )
```
You specify four values to create the rectangle. Each of the four values is either a `<length>`, a `<percentage>`, or the keyword `auto`. When using the `rect()` function, you do not define the width and height of the rectangle. The rectangle's dimensions depend on the size of the reference box and the offset values.
The optional `round <'border-radius'>` parameter defines rounded corners for the inset rectangle using the same syntax as the CSS [`border-radius`](/en-US/docs/Web/CSS/border-radius) shorthand property.
- `{{cssxref("basic-shape/xywh","xywh()")}}`
- : Defines a rectangle using the specified distances from the top and left edges of the reference box and the specified width and height of the rectangle.
```css
xywh( <length-percentage>{2} <length-percentage [0,∞]>{2} [ round <`border-radius`> ]? )
```
The optional `round <'border-radius'>` parameter defines rounded corners for the inset rectangle using the [`border-radius`](/en-US/docs/Web/CSS/border-radius) shorthand syntax.
- `{{cssxref("basic-shape/circle","circle()")}}`
- : Defines a circle using a radius and a position.
```css
circle( <shape-radius>? [ at <position> ]? )
```
The `<shape-radius>` argument represents _r_, the radius of the circle. Negative values are invalid. A percentage value here is resolved from the used width and height of the reference box as `sqrt(width^2+height^2)/sqrt(2)`.
The {{cssxref("<position>")}} argument defines the center of the circle. This defaults to center if omitted.
- `{{cssxref("basic-shape/ellipse","ellipse()")}}`
- : Defines an ellipse using two radii and a position.
```css
ellipse( [ <shape-radius>{2} ]? [ at <position> ]? )
```
The `<shape-radius>` arguments represent rx and ry, the x-axis and y-axis radii of the ellipse, in that order. Negative values for either radius are invalid. Percentage values here are resolved against the used width (for the rx value) and the used height (for the ry value) of the reference box.
The position argument defines the center of the ellipse. This defaults to center if omitted.
- `{{cssxref("basic-shape/polygon","polygon()")}}`
- : Defines a polygon using an SVG {{SVGAttr("fill-rule")}} and a set of vertices.
```css
polygon( <fill-rule>? [ <shape-arg> <shape-arg> ]# )
```
`<fill-rule>` represents the {{SVGAttr("fill-rule")}} used to determine the interior of the polygon. Possible values are `nonzero` and `evenodd`. Default value when omitted is `nonzero`.
Each pair argument in the list represents _xi_ and _yi_ - the x and y axis coordinates of the vertex of the polygon at position i.
- `{{cssxref("path","path()")}}`
- : Defines a shape using an SVG {{SVGAttr("fill-rule")}} and an SVG [path definition](/en-US/docs/Web/SVG/Attribute/d).
```css
path( [ <fill-rule>, ]? <string> )
```
The optional `<fill-rule>` represents the {{SVGAttr("fill-rule")}} used to determine the interior of the path. Possible values are `nonzero` and `evenodd`. Default value when omitted is `nonzero`.
The required \<string> is an [SVG Path](/en-US/docs/Web/SVG/Attribute/d) string encompassed in quotes
The arguments not defined above are defined as follows:
```css
<shape-arg> = <length> | <percentage>
<shape-radius> = <length> | <percentage> | closest-side | farthest-side
```
Defines a radius for a circle or ellipse. If omitted it defaults to `closest-side`.
`closest-side` uses the length from the center of the shape to the closest side of the reference box. For circles, this is the closest side in any dimension. For ellipses, this is the closest side in the radius dimension.
`farthest-side` uses the length from the center of the shape to the farthest side of the reference box. For circles, this is the farthest side in any dimension. For ellipses, this is the farthest side in the radius dimension.
## Description
### Computed values of basic shapes
The values in a `<basic-shape>` function are computed as specified, with these exceptions:
- Omitted values are included and compute to their defaults.
- A {{cssxref("<position>")}} value in `circle()` or `ellipse()` is computed as a pair of offsets (horizontal then vertical) from the top left origin, each given as a combination of an absolute length and a percentage.
- A [`<border-radius>`](/en-US/docs/Web/CSS/border-radius) value in `inset()` is computed as an expanded list of all eight {{cssxref("length")}} or percentage values.
### Interpolation of basic shapes
When animating between one `<basic-shape>` and another, the rules below are applied. The values in the shape functions {{Glossary("interpolation", "interpolate")}} as a simple list. The list values interpolate as {{cssxref("<length>")}}, {{cssxref("<percentage>")}}, or {{cssxref("calc", "calc()")}} where possible. If list values are not one of those types but are identical, those values do interpolate.
- Both shapes must use the same reference box.
- If both shapes are the same type, that type is `ellipse()` or `circle()`, and none of the radii use the `closest-side` or `farthest-side` keywords, interpolate between each value in the shape functions.
- If both shapes are of type `inset()`, interpolate between each value in the shape functions.
- If both shapes are of type `polygon()`, both polygons have the same number of vertices, and use the same `<fill-rule>`, interpolate between each value in the shape functions.
- If both shapes are of type `path()`, both paths strings have the same number and types of path data commands in the same order, interpolate each path data command as real numbers.
- In all other cases no interpolation occurs.
## Examples
### Animated polygon
In this example, we use the [@keyframes](/en-US/docs/Web/CSS/@keyframes) at-rule to animate a clip path between two polygons. Note that both polygons have the same number of vertices, which is necessary for this type of animation to work.
#### HTML
```html
<div></div>
```
#### CSS
```css
div {
width: 300px;
height: 300px;
background: repeating-linear-gradient(red, orange 50px);
clip-path: polygon(
50% 0%,
60% 40%,
100% 50%,
60% 60%,
50% 100%,
40% 60%,
0% 50%,
40% 40%
);
animation: 4s poly infinite alternate ease-in-out;
margin: 10px auto;
}
@keyframes poly {
from {
clip-path: polygon(
50% 0%,
60% 40%,
100% 50%,
60% 60%,
50% 100%,
40% 60%,
0% 50%,
40% 40%
);
}
to {
clip-path: polygon(
50% 30%,
100% 0%,
70% 50%,
100% 100%,
50% 70%,
0% 100%,
30% 50%,
0% 0%
);
}
}
```
#### Result
{{EmbedLiveSample('Animated_polygon','340', '340')}}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- Properties that use this data type: {{cssxref("clip-path")}}, {{cssxref("shape-outside")}}
- [CSS shapes](/en-US/docs/Web/CSS/CSS_shapes) module
- [Overview of CSS shapes](/en-US/docs/Web/CSS/CSS_shapes/Overview_of_shapes)
- [Edit Shape Paths in CSS — Firefox Developer Tools](https://firefox-source-docs.mozilla.org/devtools-user/page_inspector/how_to/edit_css_shapes/index.html)
| 0 |
data/mdn-content/files/en-us/web/css/basic-shape | data/mdn-content/files/en-us/web/css/basic-shape/xywh/index.md | ---
title: xywh()
slug: Web/CSS/basic-shape/xywh
page-type: css-function
browser-compat: css.types.basic-shape.xywh
---
{{CSSRef}}
The **`xywh()`** [CSS](/en-US/docs/Web/CSS) function creates a rectangle using the specified distances from the left (`x`) and top (`y`) edges of the containing block and the specified width (`w`) and height (`h`) of the rectangle. It is a basic shape function of the {{cssxref("<basic-shape>")}} [data type](/en-US/docs/Web/CSS/CSS_Types). You can use the `xywh()` function in CSS properties such as {{cssxref("offset-path")}} to create the rectangular path along which an element moves and in {{cssxref("clip-path")}} to define the shape of the clipping region.
## Syntax
```css
offset-path: xywh(0 1% 2px 3% round 0 1px 2% 3px);
clip-path: xywh(1px 2% 3px 4em round 0 1% 2px 3em);
```
### Values
- `<length-percentage>`
- : Specifies the {{cssxref("<length-percentage>")}} values for the `x` and `y` coordinates of the rectangle.
- `<length-percentage [0,∞]>`
- : Specifies non-negative {{cssxref("<length-percentage>")}} values for the width and height of the rectangle. The minimum value can be zero, and the maximum value has no limit.
- `round <'border-radius'>`
- : Specifies the radius of the rounded corners of the rectangle using the same syntax as the CSS [`border-radius`](/en-US/docs/Web/CSS/border-radius) shorthand property. This parameter is optional.
## Examples
### Creating offset-path using xywh()
In the example below, the {{cssxref("offset-path")}} property uses the `xywh()` function to define the shape of the path on which the element, a magenta box in this case, moves. Two different scenarios are shown, each with different values for the `xywh()` function. The arrow inside the boxes points to the right edge of the box.
```html
<div class="container">
Rectangular path 1
<div class="path xywh-path-1">→</div>
</div>
<div class="container">
Rectangular path 2
<div class="path xywh-path-2">→</div>
</div>
```
```css
.container {
position: relative;
display: inline-block;
width: 200px;
height: 200px;
border: 1px solid black;
margin: 30px;
text-align: center;
}
.path {
width: 50px;
height: 50px;
position: absolute;
background-color: magenta;
animation: move 10s linear infinite;
}
.xywh-path-1 {
offset-path: xywh(20px 20px 100% 100% round 10%);
}
.xywh-path-2 {
offset-path: xywh(20px 30% 150% 200%);
}
@keyframes move {
0% {
offset-distance: 0%;
}
100% {
offset-distance: 100%;
}
}
```
#### Result
{{EmbedLiveSample("Creating offset-path using xywh", "100%", 600)}}
- The path 1 rectangle is offset by `20px` from the left and top edges of the containing block. This path rectangle has the same dimension as the containing block, that is, the width is `100%` of the width of the containing block, and the height is `100%` of the height of the containing block. Notice how the arrow inside the box follows the `10%` curve (defined by `round 10%`) at the rectangular path corners.
- As the upper limit of both width and height in `xywh()` is infinity, setting the height to `200%` in the path 2 rectangle makes the generated rectangle twice as tall as the containing block. Notice how the arrow inside the box behaves at the corners when no `round <'border-radius'>` is specified.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [`inset()`](/en-US/docs/Web/CSS/basic-shape#inset) function
- [`rect()`](/en-US/docs/Web/CSS/basic-shape#rect) function
- {{cssxref("clip-path")}} property
- {{cssxref("offset-path")}} property
- {{cssxref("<basic-shape>")}} data type
- [CSS shapes](/en-US/docs/Web/CSS/CSS_shapes) module
- [Guide to basic shapes](/en-US/docs/Web/CSS/CSS_shapes/Basic_shapes)
| 0 |
data/mdn-content/files/en-us/web/css/basic-shape | data/mdn-content/files/en-us/web/css/basic-shape/circle/index.md | ---
title: circle()
slug: Web/CSS/basic-shape/circle
page-type: css-function
browser-compat: css.types.basic-shape.circle
---
{{CSSRef}}
The **`circle()`** [CSS](/en-US/docs/Web/CSS) function is one of the {{cssxref("<basic-shape>")}} [data types](/en-US/docs/Web/CSS/CSS_Types).
{{EmbedInteractiveExample("pages/css/function-circle.html")}}
## Syntax
```css
shape-outside: circle(50%);
clip-path: circle(6rem at 12rem 8rem);
```
### Values
- `<shape-radius>`
- : This may be a {{cssxref("length")}}, or a {{cssxref("percentage")}} or values `closest-side` and `farthest-side`.
- `closest-side`
- : Uses the length from the center of the shape to the closest side of the reference box. For circles, this is the closest side in any dimension.
- `farthest-side`
- : Uses the length from the center of the shape to the farthest side of the reference box. For circles, this is the closest side in any dimension.
- `<position>`
- : Moves the center of the circle. May be a {{cssxref("length")}}, or a {{cssxref("percentage")}}, or a values such as `left`. The `<position>` value defaults to center if omitted.
## Examples
### Basic circle
In the example below, the {{cssxref("shape-outside")}} property has a value of `circle(50%)`, which defines a circle on a floated element for the text to flow round.
{{EmbedGHLiveSample("css-examples/shapes/overview/circle.html", '100%', 720)}}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- Properties that use this data type: {{cssxref("clip-path")}}, {{cssxref("shape-outside")}}
- [Guide to Basic Shapes](/en-US/docs/Web/CSS/CSS_shapes/Basic_shapes)
| 0 |
data/mdn-content/files/en-us/web/css/basic-shape | data/mdn-content/files/en-us/web/css/basic-shape/rect/index.md | ---
title: rect()
slug: Web/CSS/basic-shape/rect
page-type: css-function
browser-compat: css.types.basic-shape.rect
---
{{CSSRef}}
The **`rect()`** [CSS](/en-US/docs/Web/CSS) function creates a rectangle at the specified distance from the top and left edges of the containing block. It is a basic shape function of the {{cssxref("<basic-shape>")}} [data type](/en-US/docs/Web/CSS/CSS_Types). You can use the `rect()` function in CSS properties such as {{cssxref("offset-path")}} to create the rectangular path along which an element moves and in {{cssxref("clip-path")}} to define the shape of the clipping region.
## Syntax
```css
offset-path: rect(0 1% auto 3% round 0 1px);
clip-path: rect(50px 70px 80% 20%);
```
### Values
The inset rectangle is defined by specifying four offset values, starting with the top edge offset and going clockwise, and an optional `round` keyword with the `border-radius` parameter to add rounded corners to the rectangle. Each offset value can be either a `<length>`, a `<percentage>`, or the keyword `auto`.
- `<length-percentage>`
- : Specifies the {{cssxref("<length-percentage>")}} value of the distance of the top, right, bottom, or left edge of the rectangle from the top or left edge of the containing block. The first (top) and third (bottom) values are distances from the top edge of the containing block, and the second (right) and fourth (left) values are distances from the left edge of the containing block. The second (right) and third (bottom) values are clamped by the fourth (left) and first (top) values, respectively, to prevent the bottom edge from crossing over the top edge and right edge from crossing over the left edge. For example, `rect(10px 0 0 20px)` is clamped to `rect(10px 20px 10px 20px)`.
- `auto`
- : Makes the edge for which this value is used to coincide with the corresponding edge of the containing block. If `auto` is used for the first (top) or fourth (left) value, the value of `auto` is `0`, and if used for the second (right) or third (bottom) value, the value of `auto` is `100%`.
- `round <'border-radius'>`
- : Specifies the radius of the rounded corners of the rectangle using the same syntax as the CSS [`border-radius`](/en-US/docs/Web/CSS/border-radius) shorthand property. This parameter is optional.
## Examples
### Creating offset-path using rect()
In this example, the {{cssxref("offset-path")}} property uses the `rect()` function to define the shape of the path on which the element, a red box in this case, moves. Three different scenarios are shown, each using different values for the `rect()` function. The arrow inside the boxes points to the right edge of the box.
```html
<div class="container">
Rectangular path 1
<div class="path rect-path-1">→</div>
</div>
<div class="container">
Rectangular path 2
<div class="path rect-path-2">→</div>
</div>
<div class="container">
Rectangular path 3
<div class="path rect-path-3">→</div>
</div>
```
```css
.container {
position: relative;
display: inline-block;
width: 200px;
height: 200px;
border: 1px solid black;
margin: 15px;
text-align: center;
}
.path {
width: 40px;
height: 40px;
background-color: red;
position: absolute;
animation: move 10s linear infinite;
}
.rect-path-1 {
offset-path: rect(50px 150px 200px 50px round 20%);
}
.rect-path-2 {
offset-path: rect(50px auto 200px 50px round 20%);
}
.rect-path-3 {
offset-path: rect(50px auto 200px auto);
}
@keyframes move {
0% {
offset-distance: 0%;
}
100% {
offset-distance: 100%;
}
}
```
#### Result
{{EmbedLiveSample("Creating an offset-path using rect", "100%", 400)}}
- The path 1 rectangle specifies the distances of the four edges (top, right, bottom, and left) from the containing block. The top and bottom values are distances from the top edge of the containing block. The right and left values are distances from the left edge of the containing block. In addition, the corner of the rectangle is rounded at `20%`, making the red box element follow the rounded corners as it moves along this path. Notice how the arrow inside the box follows curve at the rectangular path corners.
- The path 2 rectangle is similar to the path 1 rectangle, except that the right value is `auto`, which is equal to the value `100%`. This causes the right edge of the rectangle to match the right edge of the containing block, creating a wider rectangle than path 1.
- The path 3 rectangle specifies both the left and right edge parameters as `auto` and omits the `round <'border-radius'>` parameter. This creates a rectangle that has the width of the containing block and rectangular corners instead of rounded corners like in path 1 and path 2 rectangles. Notice the movement of the arrow inside this box at the corners.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [`inset()`](/en-US/docs/Web/CSS/basic-shape#inset) function
- [`xywh()`](/en-US/docs/Web/CSS/basic-shape#xywh) function
- {{cssxref("clip-path")}} property
- {{cssxref("offset-path")}} property
- {{cssxref("<basic-shape>")}} data type
- [CSS shapes](/en-US/docs/Web/CSS/CSS_shapes) module
- [Guide to basic shapes](/en-US/docs/Web/CSS/CSS_shapes/Basic_shapes)
| 0 |
data/mdn-content/files/en-us/web/css/basic-shape | data/mdn-content/files/en-us/web/css/basic-shape/polygon/index.md | ---
title: polygon()
slug: Web/CSS/basic-shape/polygon
page-type: css-function
browser-compat: css.types.basic-shape.polygon
---
{{CSSRef}}
The **`polygon()`** [CSS](/en-US/docs/Web/CSS) function is one of the {{cssxref("<basic-shape>")}} [data types](/en-US/docs/Web/CSS/CSS_Types). It's used to draw a [polygon](https://en.wikipedia.org/wiki/Polygon) by providing one or more pairs of coordinates, each of which represents a vertex of the shape.
{{EmbedInteractiveExample("pages/css/function-polygon.html")}}
## Syntax
```css-nolint
/* Specified as coordinate list */
/* polygon(<length-percentage> <length-percentage>, ... )*/
polygon(50% 2.4%, 34.5% 33.8%, 0% 38.8%, 25% 63.1%, 19.1% 97.6%)
polygon(0px 0px, 200px 100px, 0px 200px)
polygon(0% 0px, 100% 100px, 0px 100%)
polygon(0 0, 50% 1rem, 100% 2vw, calc(100% - 20px) 100%, 0 100%)
/* Specified as coordinate list and fill rule*/
/* polygon(<fill-rule> <length-percentage> <length-percentage>, ... )*/
polygon(nonzero, 0% 0%, 50% 50%, 0% 100%)
polygon(evenodd, 0% 0%, 50% 50%, 0% 100%)
```
The `polygon()` parameters are separated by a comma and optional whitespace. The first parameter is an optional [`<fill-rule>`](/en-US/docs/Web/SVG/Attribute/fill-rule) value. Additional parameters are points that define the polygon. Each point is a pair of x/y coordinate {{cssxref("length-percentage")}} values separated by a space, e.g. "0 0" and "100% 100%" for the left/top and bottom right corners, respectively.
Note: The SVG [`<polygon>`](/en-US/docs/Web/SVG/Element/polygon) element has separate attributes for [`fill-rule`](/en-US/docs/Web/SVG/Attribute/fill-rule) and [`points`](/en-US/docs/Web/SVG/Attribute/points), and `points` is flexible about the use of space and comma separators. CSS `polygon()` rules for separators are strictly enforced.
### Parameters
- [`<fill-rule>`](/en-US/docs/Web/SVG/Attribute/fill-rule) {{optional_inline}}
- : An optional value of `nonzero` (the default when omitted) or `evenodd`, which specifies the filling rule.
- {{cssxref("length-percentage")}}
- : Each vertex of the polygon is represented by a pair of `<length-percentage>` values, which give the x/y coordinates of the vertex relative to the shape's [reference box](/en-US/docs/Web/CSS/CSS_shapes/Basic_shapes#the_reference_box).
### Return value
Returns a {{cssxref("basic-shape")}} value.
## Description
You can create almost any shape with the `polygon()` function by specifying the coordinates of its points. The order in which you define the points matters and can result in different shapes. The `polygon()` function requires at least 3 points, which creates a triangle, but there's no upper limit.
The `polygon()` function accepts comma-separated coordinates or points as its values. Each point is represented by a pair of space-separated `x` and `y` values, which indicate the points' coordinates within the polygon.
<code>polygon(x<sub>1</sub> y<sub>1</sub>, x<sub>2</sub> y<sub>2</sub>, x<sub>3</sub> y<sub>3</sub>, x<sub>4</sub> y<sub>4</sub>, x<sub>n</sub> y<sub>n</sub>)</code>
Given the above, mapping the coordinates of the container can be visualized as:
| axis | point 1 | point 2 | point 3 | point 4 | point n |
| ---- | ------- | ------- | ------- | ------- | ------------- |
| x | 0% | 100% | 100% | 0% | x<sub>n</sub> |
| y | 0% | 0% | 100% | 100% | y<sub>n</sub> |
Applying those coordinates to the CSS {{cssxref("clip-path")}} property using the `polygon()` function:
```css
clip-path: polygon(0% 0%, 100% 0%, 100% 100%, 0% 100%);
```
This would create a rectangle shape the size of its parent content by specifying the coordinates of its four corners: top-left (`0% 0%`), top-right (`100% 0%`), bottom-right (`100% 100%`), and bottom-left (`0% 100%`).
## Formal syntax
{{csssyntax}}
## Examples
### Create a triangle
In this example, a triangle is formed by defining the coordinates of its three points.
#### HTML
```html
<div class="triangle"></div>
```
#### CSS
```css
.triangle {
width: 400px;
height: 400px;
background-color: magenta;
clip-path: polygon(100% 0%, 50% 50%, 100% 100%);
}
```
#### Result
{{EmbedLiveSample("Create a triangle", '100%', 400)}}
The coordinates for the triangle are the top-right corner (`100% 0%`), the center point (`50% 50%`), and the bottom-right corner (`100% 100%`) of the container.
### Setting a polygon for shape-outside
In this example a shape is created for text to follow using the {{cssxref("shape-outside")}} property.
```html
<div class="box">
<div class="shape"></div>
<p>
One November night in the year 1782, so the story runs, two brothers sat
over their winter fire in the little French town of Annonay, watching the
grey smoke-wreaths from the hearth curl up the wide chimney. Their names
were Stephen and Joseph Montgolfier, they were papermakers by trade, and
were noted as possessing thoughtful minds and a deep interest in all
scientific knowledge and new discovery. Before that night—a memorable night,
as it was to prove—hundreds of millions of people had watched the rising
smoke-wreaths of their fires without drawing any special inspiration from
the fact.
</p>
</div>
```
```css
.box {
width: 250px;
}
.shape {
float: left;
shape-outside: polygon(
0 5%,
15% 12%,
30% 15%,
40% 26%,
45% 35%,
45% 45%,
40% 55%,
10% 90%,
10% 98%,
8% 100%,
0 100%
);
width: 300px;
height: 320px;
}
p {
font-size: 0.9rem;
}
```
{{EmbedLiveSample("Setting a polygon for shape-outside", '100%', 400)}}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- Properties that use this data type: {{cssxref("clip-path")}}, {{cssxref("shape-outside")}}
- [Guide to Basic Shapes](/en-US/docs/Web/CSS/CSS_shapes/Basic_shapes)
| 0 |
data/mdn-content/files/en-us/web/css/basic-shape | data/mdn-content/files/en-us/web/css/basic-shape/inset/index.md | ---
title: inset()
slug: Web/CSS/basic-shape/inset
page-type: css-function
browser-compat: css.types.basic-shape.inset
---
{{CSSRef}}
The **`inset()`** [CSS](/en-US/docs/Web/CSS) function defines a rectangle at the specified inset distances from each side of the reference box. It is a basic shape function used to define one of the {{cssxref("<basic-shape>")}} [data types](/en-US/docs/Web/CSS/CSS_Types).
{{EmbedInteractiveExample("pages/css/function-inset.html")}}
## Syntax
```css
shape-outside: inset(20px 50px 10px 0 round 50px);
```
### Values
- `<length-percentage>{1,4}`
- : When all of the four arguments are supplied they represent the top, right, bottom and left offsets from the reference box inward that define the positions of the edges of the inset rectangle. These arguments follow the syntax of the margin shorthand, that let you set all four insets with one, two or four values.
- `<border-radius>`
- : The optional [`<border-radius>`](/en-US/docs/Web/CSS/border-radius) argument(s) define rounded corners for the inset rectangle using the border-radius shorthand syntax.
## Examples
### Basic inset example
In the example below we have an `inset()` shape used to pull content over the floated element. Change the offset values to see how the shape changes.
{{EmbedGHLiveSample("css-examples/shapes/basic-shape/inset.html", '100%', 800)}}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- Properties that use this data type: {{cssxref("clip-path")}}, {{cssxref("shape-outside")}}
- [CSS shapes](/en-US/docs/Web/CSS/CSS_shapes) module
- [Guide to basic shapes](/en-US/docs/Web/CSS/CSS_shapes/Basic_shapes)
| 0 |
data/mdn-content/files/en-us/web/css/basic-shape | data/mdn-content/files/en-us/web/css/basic-shape/ellipse/index.md | ---
title: ellipse()
slug: Web/CSS/basic-shape/ellipse
page-type: css-function
browser-compat: css.types.basic-shape.ellipse
---
{{CSSRef}}
The **`ellipse()`** [CSS](/en-US/docs/Web/CSS) function is one of the {{cssxref("<basic-shape>")}} [data types](/en-US/docs/Web/CSS/CSS_Types).
{{EmbedInteractiveExample("pages/css/function-ellipse.html")}}
## Syntax
```css
shape-outside: ellipse(40% 50% at left);
shape-outside: ellipse(closest-side farthest-side at 30%);
```
An ellipse is essentially a squashed circle and so `ellipse()` acts in a very similar way to {{cssxref("basic-shape/circle","circle()")}} except that we have to specify two radii x and y.
### Values
- `<shape-radius>`
- : Two radii, x and y in that order. These may be a {{cssxref("length")}}, or a {{cssxref("percentage")}} or values `closest-side` and `farthest-side`.
- `closest-side`
- : Uses the length from the center of the shape to the closest side of the reference box. For ellipses, this is the closest side in the radius dimension.
- `farthest-side`
- : Uses the length from the center of the shape to the farthest side of the reference box. For ellipses, this is the farthest side in the radius dimension.
- `<position>`
- : Moves the center of the ellipse. May be a {{cssxref("length")}}, or a {{cssxref("percentage")}}, or a values such as `left`. The `<position>` value defaults to center if omitted.
## Examples
### Basic ellipse() example
This example shows an ellipse with an x radius of 40%, a y radius of 50% and the position being left. This means that the center of the ellipse is on the left edge of the box giving us a half ellipse shape to wrap our text around. You can change these values to see how the ellipse changes.
{{EmbedGHLiveSample("css-examples/shapes/basic-shape/ellipse.html", '100%', 800)}}
### Using closest-side / farthest-side values
The keyword values of `closest-side` and `farthest-side` are useful to create a quick ellipse based on the size of the floated element reference box.
{{EmbedGHLiveSample("css-examples/shapes/basic-shape/ellipse-keywords.html", '100%', 800)}}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- Properties that use this data type: {{cssxref("clip-path")}}, {{cssxref("shape-outside")}}
- [Guide to Basic Shapes](/en-US/docs/Web/CSS/CSS_shapes/Basic_shapes)
| 0 |
data/mdn-content/files/en-us/web/css | data/mdn-content/files/en-us/web/css/sqrt/index.md | ---
title: sqrt()
slug: Web/CSS/sqrt
page-type: css-function
browser-compat: css.types.sqrt
---
{{CSSRef}}
The **`sqrt()`** [CSS](/en-US/docs/Web/CSS) [function](/en-US/docs/Web/CSS/CSS_Functions) is an exponential function that returns the [square root](https://en.wikipedia.org/wiki/Square_root) of a number.
The function `pow(x, 0.5)` is equivalent to `sqrt(x)`.
## Syntax
```css
/* A <number> value */
width: calc(100px * sqrt(9)); /* 300px */
width: calc(100px * sqrt(25)); /* 500px */
width: calc(100px * sqrt(100)); /* 1000px */
```
### Parameters
The `sqrt(x)` function accepts only one value as its parameter.
- `x`
- : A calculation which resolves to a {{cssxref("<number>")}} greater than or equal to 0.
### Return value
Returns a {{cssxref("<number>")}} which is the square root of `x`.
- if `x` is `+∞`, the result is `+∞`.
- If `x` is `0⁻`, the result is `0⁻`.
- If `x` is less than `0`, the result is `NaN`.
### Formal syntax
{{CSSSyntax}}
## Examples
### Scale sizes based on square root
This example shows how you can use the `sqrt()` function to calculate sizes.
#### HTML
```html
<div class="boxes">
<div class="box">50px</div>
<div class="box one">100px</div>
<div class="box two">150px</div>
<div class="box three">200px</div>
</div>
```
#### CSS
Here we are using [CSS custom properties](/en-US/docs/Web/CSS/Using_CSS_custom_properties) to define the sizes to be used. First, we declare the first size (`--size-0`), which is then used to calculate the other sizes.
- `--size-1` is calculated by multiplying the value of `--size-0` (50px) by the square root of 4 (2), which results in 100px.
- `--size-2` is calculated by multiplying the value of `--size-0` (50px) by the square root of 9 (3), which results in 150px.
- `--size-3` is calculated by multiplying the value of `--size-0` (50px) by the square root of 16 (4), which results in 200px.
```css
:root {
--size-0: 50px;
--size-1: calc(var(--size-0) * sqrt(4)); /* 100px */
--size-2: calc(var(--size-0) * sqrt(9)); /* 150px */
--size-3: calc(var(--size-0) * sqrt(16)); /* 200px */
}
```
```css hidden
.boxes {
display: flex;
flex-wrap: wrap;
justify-content: space-around;
}
.box {
width: var(--size-0);
height: var(--size-0);
background-color: tomato;
color: white;
display: flex;
align-items: center;
justify-content: center;
}
```
The sizes are then applied as the `width` and `height` values of the selectors.
```css
.one {
width: var(--size-1);
height: var(--size-1);
}
.two {
width: var(--size-2);
height: var(--size-2);
}
.three {
width: var(--size-3);
height: var(--size-3);
}
```
#### Result
{{EmbedLiveSample('Scale sizes based on square root', '100%', '220px')}}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{CSSxRef("pow")}}
- {{CSSxRef("hypot")}}
- {{CSSxRef("log")}}
- {{CSSxRef("exp")}}
| 0 |
data/mdn-content/files/en-us/web/css | data/mdn-content/files/en-us/web/css/list-style-image/index.md | ---
title: list-style-image
slug: Web/CSS/list-style-image
page-type: css-property
browser-compat: css.properties.list-style-image
---
{{CSSRef}}
The **`list-style-image`** [CSS](/en-US/docs/Web/CSS) property sets an image to be used as the list item marker.
It is often more convenient to use the shorthand {{ cssxref("list-style") }}.
{{EmbedInteractiveExample("pages/css/list-style-image.html")}}
> **Note:** This property is applied to list items, i.e. elements with `{{cssxref("display")}}: list-item;` [by default](https://html.spec.whatwg.org/multipage/rendering.html#lists) this includes {{HTMLElement("li")}} elements. Because this property is inherited, it can be set on the parent element (normally {{HTMLElement("ol")}} or {{HTMLElement("ul")}}) to let it apply to all list items.
## Syntax
```css
/* Keyword values */
list-style-image: none;
/* <url> values */
list-style-image: url("starsolid.gif");
/* valid image values */
list-style-image: linear-gradient(to left bottom, red, blue);
/* Global values */
list-style-image: inherit;
list-style-image: initial;
list-style-image: revert;
list-style-image: revert-layer;
list-style-image: unset;
```
### Values
- {{cssxref("<image>")}}
- : A valid image to use as the marker.
- `none`
- : Specifies that no image is used as the marker. If this value is set, the marker defined in {{ Cssxref("list-style-type") }} will be used instead. This is the default value for {{cssxref("list-style")}}.
## Formal definition
{{cssinfo}}
## Formal syntax
{{csssyntax}}
## Examples
### Using a url value
This example has a star as a marker, which we include using the {{cssxref("url", "url()")}} image function.
#### HTML
```html
<ul>
<li>Item 1</li>
<li>Item 2</li>
</ul>
```
#### CSS
```css
ul {
list-style-image: url("starsolid.gif");
}
```
#### Result
{{ EmbedLiveSample('Using_a_url_value') }}
### Using a gradient
This example has a [CSS gradient](/en-US/docs/Web/CSS/CSS_images/Using_CSS_gradients) as a marker, which we create uses the {{cssxref("gradient/linear-gradient", "linear-gradient()")}} image function.
#### HTML
```html
<ul>
<li>Item 1</li>
<li>Item 2</li>
</ul>
```
#### CSS
```css
ul {
font-size: 200%;
list-style-image: linear-gradient(to left bottom, red, blue);
}
```
#### Result
{{ EmbedLiveSample('Using_a_gradient') }}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{Cssxref("list-style")}} shorthand
- {{Cssxref("list-style-type")}} property
- {{Cssxref("list-style-position")}} property
- {{cssxref("::marker")}} pseudo-element
- [CSS lists and counters](/en-US/docs/Web/CSS/CSS_lists) module
- [CSS counter styles](/en-US/docs/Web/CSS/CSS_counter_styles) module
| 0 |
data/mdn-content/files/en-us/web/css | data/mdn-content/files/en-us/web/css/overflow-wrap/index.md | ---
title: overflow-wrap
slug: Web/CSS/overflow-wrap
page-type: css-property
browser-compat: css.properties.overflow-wrap
---
{{CSSRef}}
The **`overflow-wrap`** [CSS](/en-US/docs/Web/CSS) property applies to text, setting whether the browser should insert line breaks within an otherwise unbreakable string to prevent text from overflowing its line box.
{{EmbedInteractiveExample("pages/css/overflow-wrap.html")}}
> **Note:** In contrast to {{cssxref("word-break")}}, `overflow-wrap` will only create a break if an entire word cannot be placed on its own line without overflowing.
The property was originally a nonstandard and unprefixed Microsoft extension called `word-wrap`, and was implemented by most browsers with the same name. It has since been renamed to `overflow-wrap`, with `word-wrap` being an alias.
## Syntax
```css
/* Keyword values */
overflow-wrap: normal;
overflow-wrap: break-word;
overflow-wrap: anywhere;
/* Global values */
overflow-wrap: inherit;
overflow-wrap: initial;
overflow-wrap: revert;
overflow-wrap: revert-layer;
overflow-wrap: unset;
```
The `overflow-wrap` property is specified as a single keyword chosen from the list of values below.
### Values
- `normal`
- : Lines may only break at normal word break points (such as a space between two words).
- `anywhere`
- : To prevent overflow, an otherwise unbreakable string of characters — like a long word or URL — may be broken at any point if there are no otherwise-acceptable break points in the line. No hyphenation character is inserted at the break point. Soft wrap opportunities introduced by the word break are considered when calculating min-content intrinsic sizes.
- `break-word`
- : The same as the `anywhere` value, with normally unbreakable words allowed to be broken at arbitrary points if there are no otherwise acceptable break points in the line, but soft wrap opportunities introduced by the word break are NOT considered when calculating min-content intrinsic sizes.
## Formal definition
{{cssinfo}}
## Formal syntax
{{csssyntax}}
## Examples
### Comparing overflow-wrap, word-break, and hyphens
This example compares the results of `overflow-wrap`, `word-break`, and `hyphens` when breaking up a long word.
#### HTML
```html
<p>
They say the fishing is excellent at Lake
<em class="normal">Chargoggagoggmanchauggagoggchaubunagungamaugg</em>, though
I've never been there myself. (<code>normal</code>)
</p>
<p>
They say the fishing is excellent at Lake
<em class="ow-anywhere">Chargoggagoggmanchauggagoggchaubunagungamaugg</em>,
though I've never been there myself. (<code>overflow-wrap: anywhere</code>)
</p>
<p>
They say the fishing is excellent at Lake
<em class="ow-break-word">Chargoggagoggmanchauggagoggchaubunagungamaugg</em>,
though I've never been there myself. (<code>overflow-wrap: break-word</code>)
</p>
<p>
They say the fishing is excellent at Lake
<em class="word-break">Chargoggagoggmanchauggagoggchaubunagungamaugg</em>,
though I've never been there myself. (<code>word-break</code>)
</p>
<p>
They say the fishing is excellent at Lake
<em class="hyphens">Chargoggagoggmanchauggagoggchaubunagungamaugg</em>, though
I've never been there myself. (<code>hyphens</code>, without
<code>lang</code> attribute)
</p>
<p lang="en">
They say the fishing is excellent at Lake
<em class="hyphens">Chargoggagoggmanchauggagoggchaubunagungamaugg</em>, though
I've never been there myself. (<code>hyphens</code>, English rules)
</p>
<p class="hyphens" lang="de">
They say the fishing is excellent at Lake
<em class="hyphens">Chargoggagoggmanchauggagoggchaubunagungamaugg</em>, though
I've never been there myself. (<code>hyphens</code>, German rules)
</p>
```
#### CSS
```css
p {
width: 13em;
margin: 2px;
background: gold;
}
.ow-anywhere {
overflow-wrap: anywhere;
}
.ow-break-word {
overflow-wrap: break-word;
}
.word-break {
word-break: break-all;
}
.hyphens {
hyphens: auto;
}
```
#### Result
{{ EmbedLiveSample('Comparing_overflow-wrap_word-break_and_hyphens', '100%', 260) }}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{cssxref("word-break")}}
- {{cssxref("hyphens")}}
- {{cssxref("text-overflow")}}
- [Guide to wrapping and breaking text](/en-US/docs/Web/CSS/CSS_text/Wrapping_breaking_text)
| 0 |
data/mdn-content/files/en-us/web/css | data/mdn-content/files/en-us/web/css/caret-color/index.md | ---
title: caret-color
slug: Web/CSS/caret-color
page-type: css-property
browser-compat: css.properties.caret-color
---
{{CSSRef}}
The **`caret-color`** CSS property sets the color of the **insertion caret**, the visible marker where the next character typed will be inserted. This is sometimes referred to as the **text input cursor**. The caret appears in elements such as {{HTMLElement("input")}} or those with the [`contenteditable`](/en-US/docs/Web/HTML/Global_attributes#contenteditable) attribute. The caret is typically a thin vertical line that flashes to help make it more noticeable. By default, it is black, but its color can be altered with this property.
{{EmbedInteractiveExample("pages/css/caret-color.html")}}
Note that the insertion caret is only one type of caret. For example, many browsers have a "navigation caret," which acts similarly to an insertion caret but can be moved around in non-editable text. On the other hand, the mouse cursor image shown when hovering over text where the {{cssxref("cursor")}} property is `auto`, or when hovering over an element where the `cursor` property is `text` or `vertical-text`, though it sometimes looks like a caret, is not a caret (it's a cursor).
## Syntax
```css
/* Keyword values */
caret-color: auto;
caret-color: transparent;
caret-color: currentcolor;
/* <color> values */
caret-color: red;
caret-color: #5729e9;
caret-color: rgb(0 200 0);
caret-color: hsl(228deg 4% 24% / 80%);
/* Global values */
caret-color: inherit;
caret-color: initial;
caret-color: revert;
caret-color: revert-layer;
caret-color: unset;
```
### Values
- `auto`
- : The user agent selects an appropriate color for the caret. This is generally {{cssxref("<color>","currentcolor","#currentcolor_keyword")}}, but the user agent may choose a different color to ensure good visibility and contrast with the surrounding content, taking into account the value of `currentcolor`, the background, shadows, and other factors.
> **Note:** While user agents may use `currentcolor` (which is usually animatable) for the `auto` value, `auto` is not interpolated in transitions and animations.
- {{cssxref("<color>")}}
- : The color of the caret.
## Formal definition
{{cssinfo}}
## Formal syntax
{{csssyntax}}
## Examples
### Setting a custom caret color
#### HTML
```html
<input value="This field uses a default caret." size="64" />
<input class="custom" value="I have a custom caret color!" size="64" />
<p contenteditable class="custom">
This paragraph can be edited, and its caret has a custom color as well!
</p>
```
#### CSS
```css
input {
caret-color: auto;
display: block;
margin-bottom: 0.5em;
}
input.custom {
caret-color: red;
}
p.custom {
caret-color: green;
}
```
#### Result
{{EmbedLiveSample('Setting_a_custom_caret_color', 500, 200)}}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- The {{HTMLElement("input")}} element
- The HTML [`contenteditable`](/en-US/docs/Web/HTML/Global_attributes#contenteditable) attribute, which can be used to make any element's text editable
- [Applying color to HTML elements using CSS](/en-US/docs/Web/CSS/CSS_colors/Applying_color)
- The {{cssxref("<color>")}} data type
- Other color-related properties: {{cssxref("color")}}, {{cssxref("background-color")}}, {{cssxref("border-color")}}, {{cssxref("outline-color")}}, {{cssxref("text-decoration-color")}}, {{cssxref("text-emphasis-color")}}, {{cssxref("text-shadow")}}, {{cssxref("caret-color")}}, and {{cssxref("column-rule-color")}}
| 0 |
data/mdn-content/files/en-us/web/css | data/mdn-content/files/en-us/web/css/margin-block-start/index.md | ---
title: margin-block-start
slug: Web/CSS/margin-block-start
page-type: css-property
browser-compat: css.properties.margin-block-start
---
{{CSSRef}}
The **`margin-block-start`** [CSS](/en-US/docs/Web/CSS) property defines the logical block start margin of an element, which maps to a physical margin depending on the element's writing mode, directionality, and text orientation.
{{EmbedInteractiveExample("pages/css/margin-block-start.html")}}
## Syntax
```css
/* <length> values */
margin-block-start: 10px; /* An absolute length */
margin-block-start: 1em; /* relative to the text size */
margin-block-start: 5%; /* relative to the nearest block container's width */
/* Keyword values */
margin-block-start: auto;
/* Global values */
margin-block-start: inherit;
margin-block-start: initial;
margin-block-start: revert;
margin-block-start: revert-layer;
margin-block-start: unset;
```
It corresponds to the {{cssxref("margin-top")}}, {{cssxref("margin-right")}}, {{cssxref("margin-bottom")}}, or {{cssxref("margin-left")}} property depending on the values defined for {{cssxref("writing-mode")}}, {{cssxref("direction")}}, and {{cssxref("text-orientation")}}.
It relates to {{cssxref("margin-block-end")}}, {{cssxref("margin-inline-start")}}, and {{cssxref("margin-inline-end")}}, which define the other margins of the element.
### Values
The `margin-block-start` property takes the same values as the {{cssxref("margin-left")}} property.
## Formal definition
{{cssinfo}}
## Formal syntax
{{csssyntax}}
## Examples
### Setting block start margin
#### HTML
```html
<div>
<p class="exampleText">Example text</p>
</div>
```
#### CSS
```css
div {
background-color: yellow;
width: 120px;
height: 120px;
}
.exampleText {
writing-mode: vertical-lr;
margin-block-start: 20px;
background-color: #c8c800;
}
```
#### Result
{{EmbedLiveSample("Setting_block_start_margin", 140, 140)}}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [CSS Logical Properties and Values](/en-US/docs/Web/CSS/CSS_logical_properties_and_values)
- The mapped physical properties: {{cssxref("margin-top")}}, {{cssxref("margin-right")}}, {{cssxref("margin-bottom")}}, and {{cssxref("margin-left")}}
- {{cssxref("writing-mode")}}, {{cssxref("direction")}}, {{cssxref("text-orientation")}}
| 0 |
data/mdn-content/files/en-us/web/css | data/mdn-content/files/en-us/web/css/text-align-last/index.md | ---
title: text-align-last
slug: Web/CSS/text-align-last
page-type: css-property
browser-compat: css.properties.text-align-last
---
{{CSSRef}}
The **`text-align-last`** CSS property sets how the last line of a block or a line, right before a forced line break, is aligned.
{{EmbedInteractiveExample("pages/css/text-align-last.html")}}
## Syntax
```css
/* Keyword values */
text-align-last: auto;
text-align-last: start;
text-align-last: end;
text-align-last: left;
text-align-last: right;
text-align-last: center;
text-align-last: justify;
/* Global values */
text-align-last: inherit;
text-align-last: initial;
text-align-last: revert;
text-align-last: revert-layer;
text-align-last: unset;
```
### Values
- `auto`
- : The affected line is aligned per the value of {{cssxref("text-align")}}, unless {{cssxref("text-align")}} is `justify`, in which case the effect is the same as setting `text-align-last` to `start`.
- `start`
- : The same as `left` if direction is left-to-right and `right` if direction is right-to-left.
- `end`
- : The same as `right` if direction is left-to-right and `left` if direction is right-to-left.
- `left`
- : The inline contents are aligned to the left edge of the line box.
- `right`
- : The inline contents are aligned to the right edge of the line box.
- `center`
- : The inline contents are centered within the line box.
- `justify`
- : The text is justified. Text should line up their left and right edges to the left and right content edges of the paragraph.
## Formal definition
{{CSSInfo}}
## Formal syntax
{{csssyntax}}
## Examples
### Justifying the last line
```html hidden
<p>
Integer elementum massa at nulla placerat varius. Suspendisse in libero risus,
in interdum massa. Vestibulum ac leo vitae metus faucibus gravida ac in neque.
Nullam est eros, suscipit sed dictum quis, accumsan a ligula.
</p>
```
#### CSS
```css
p {
font-size: 1.4em;
text-align: justify;
text-align-last: center;
}
```
#### Results
{{EmbedLiveSample('Justifying_the_last_line','560')}}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{cssxref("text-align")}}
| 0 |
data/mdn-content/files/en-us/web/css | data/mdn-content/files/en-us/web/css/font-variant-caps/index.md | ---
title: font-variant-caps
slug: Web/CSS/font-variant-caps
page-type: css-property
browser-compat: css.properties.font-variant-caps
---
{{CSSRef}}
The **`font-variant-caps`** [CSS](/en-US/docs/Web/CSS) property controls the use of alternate glyphs used for small or petite capitals or for titling.
{{EmbedInteractiveExample("pages/css/font-variant-caps.html")}}
When a given font includes capital letter glyphs of multiple different sizes, this property selects the most appropriate ones. If petite capital glyphs are not available, they are rendered using small capital glyphs. If these are not present, the browser synthesizes them from the uppercase glyphs.
Fonts sometimes include special glyphs for various caseless characters (such as punctuation marks) to better match the capitalized characters around them. However, small capital glyphs are never synthesized for caseless characters.
### Language-specific rules
This property accounts for language-specific case mapping rules. For example:
- In Turkic languages, such as Turkish (tr), Azerbaijani (az), Crimean Tatar (crh), Volga Tatar (tt), and Bashkir (ba), there are two kinds of `i` (one with the dot, one without) and two case pairings: `i`/`İ` and `ı`/`I`.
- In German (de), the `ß` may become `ẞ` (U+1E9E) in uppercase.
- In Greek (el), vowels lose their accent when the whole word is in uppercase (`ά`/`Α`), except for the disjunctive eta (`ή`/`Ή`). Also, diphthongs with an accent on the first vowel lose the accent and gain a diacritic on the second vowel (`άι`/`ΑΪ`).
## Syntax
```css
/* Keyword values */
font-variant-caps: normal;
font-variant-caps: small-caps;
font-variant-caps: all-small-caps;
font-variant-caps: petite-caps;
font-variant-caps: all-petite-caps;
font-variant-caps: unicase;
font-variant-caps: titling-caps;
/* Global values */
font-variant-caps: inherit;
font-variant-caps: initial;
font-variant-caps: revert;
font-variant-caps: revert-layer;
font-variant-caps: unset;
```
The `font-variant-caps` property is specified using a single keyword value from the list below. In each case, if the font doesn't support the OpenType value, then it synthesizes the glyphs.
### Values
- `normal`
- : Deactivates of the use of alternate glyphs.
- `small-caps`
- : Enables display of small capitals (OpenType feature: `smcp`). Small-caps glyphs typically use the form of uppercase letters but are displayed using the same size as lowercase letters.
- `all-small-caps`
- : Enables display of small capitals for both upper and lowercase letters (OpenType features: `c2sc`, `smcp`).
- `petite-caps`
- : Enables display of petite capitals (OpenType feature: `pcap`).
- `all-petite-caps`
- : Enables display of petite capitals for both upper and lowercase letters (OpenType features: `c2pc`, `pcap`).
- `unicase`
- : Enables display of mixture of small capitals for uppercase letters with normal lowercase letters (OpenType feature: `unic`).
- `titling-caps`
- : Enables display of titling capitals (OpenType feature: `titl`). Uppercase letter glyphs are often designed for use with lowercase letters. When used in all uppercase titling sequences they can appear too strong. Titling capitals are designed specifically for this situation.
## Accessibility concerns
Large sections of text set with a `font-variant` value of `all-small-caps` or `all-petite-caps` may be difficult for people with cognitive concerns such as Dyslexia to read.
- [MDN Understanding WCAG, Guideline 1.4 explanations](/en-US/docs/Web/Accessibility/Understanding_WCAG/Perceivable#guideline_1.4_make_it_easier_for_users_to_see_and_hear_content_including_separating_foreground_from_background)
- [W3C Understanding WCAG 2.1](https://www.w3.org/TR/WCAG21/#visual-presentation)
## Formal definition
{{cssinfo}}
## Formal syntax
{{csssyntax}}
## Examples
### Setting the small-caps font variant
#### HTML
```html
<p class="small-caps">Firefox rocks, small caps!</p>
<p class="normal">Firefox rocks, normal caps!</p>
```
#### CSS
```css
.small-caps {
font-variant-caps: small-caps;
font-style: italic;
}
.normal {
font-variant-caps: normal;
font-style: italic;
}
```
#### Result
{{ EmbedLiveSample('Setting_the_small-caps_font_variant') }}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [`font-variant`](/en-US/docs/Web/CSS/font-variant)
- [`font-variant-alternates`](/en-US/docs/Web/CSS/font-variant-alternates)
- [`font-variant-east-asian`](/en-US/docs/Web/CSS/font-variant-east-asian)
- [`font-variant-emoji`](/en-US/docs/Web/CSS/font-variant-emoji)
- [`font-variant-ligatures`](/en-US/docs/Web/CSS/font-variant-ligatures)
- [`font-variant-numeric`](/en-US/docs/Web/CSS/font-variant-numeric)
- [`font-variant-position`](/en-US/docs/Web/CSS/font-variant-position)
| 0 |
data/mdn-content/files/en-us/web/css | data/mdn-content/files/en-us/web/css/@media/index.md | ---
title: "@media"
slug: Web/CSS/@media
page-type: css-at-rule
browser-compat: css.at-rules.media
---
{{CSSRef}}
The **`@media`** [CSS](/en-US/docs/Web/CSS) [at-rule](/en-US/docs/Web/CSS/At-rule) can be used to apply part of a style sheet based on the result of one or more [media queries](/en-US/docs/Web/CSS/CSS_media_queries/Using_media_queries). With it, you specify a media query and a block of CSS to apply to the document if and only if the media query matches the device on which the content is being used.
> **Note:** In JavaScript, the rules created using `@media` can be accessed with the {{domxref("CSSMediaRule")}} CSS object model interface.
{{EmbedInteractiveExample("pages/tabbed/at-rule-media.html", "tabbed-standard")}}
## Syntax
The `@media` at-rule may be placed at the top level of your code or nested inside any other [conditional group at-rule](/en-US/docs/Web/CSS/At-rule#conditional_group_rules).
```css
/* At the top level of your code */
@media screen and (min-width: 900px) {
article {
padding: 1rem 3rem;
}
}
/* Nested within another conditional at-rule */
@supports (display: flex) {
@media screen and (min-width: 900px) {
article {
display: flex;
}
}
}
```
For a discussion of media query syntax, please see [Using media queries](/en-US/docs/Web/CSS/CSS_media_queries/Using_media_queries#syntax).
## Description
### Media types
_Media types_ describe the general category of a device.
Except when using the `not` or `only` logical operators, the media type is optional and the `all` type is implied.
- `all`
- : Suitable for all devices.
- `print`
- : Intended for paged material and documents viewed on a screen in print preview mode. (Please see [paged media](/en-US/docs/Web/CSS/CSS_paged_media) for information about formatting issues that are specific to these formats.)
- `screen`
- : Intended primarily for screens.
> **Note:** CSS2.1 and [Media Queries 3](https://drafts.csswg.org/mediaqueries-3/#background) defined several additional media types (`tty`, `tv`, `projection`, `handheld`, `braille`, `embossed`, and `aural`), but they were deprecated in [Media Queries 4](https://drafts.csswg.org/mediaqueries/#media-types) and shouldn't be used.
### Media features
_Media features_ describe specific characteristics of the {{glossary("user agent")}}, output device, or environment.
Media feature expressions test for their presence or value, and are entirely optional. Each media feature expression must be surrounded by parentheses.
- {{cssxref("@media/any-hover", "any-hover")}}
- : Does any available input mechanism allow the user to hover over elements?
Added in Media Queries Level 4.
- {{cssxref("@media/any-pointer", "any-pointer")}}
- : Is any available input mechanism a pointing device, and if so, how accurate is it?
Added in Media Queries Level 4.
- {{cssxref("@media/aspect-ratio", "aspect-ratio")}}
- : Width-to-height aspect ratio of the viewport
- {{cssxref("@media/color", "color")}}
- : Number of bits per color component of the output device, or zero if the device isn't color
- {{cssxref("@media/color-gamut", "color-gamut")}}
- : Approximate range of colors that are supported by the user agent and output device.
Added in Media Queries Level 4.
- {{cssxref("@media/color-index", "color-index")}}
- : Number of entries in the output device's color lookup table, or zero if the device does not use such a table
- {{cssxref("@media/device-aspect-ratio", "device-aspect-ratio")}} {{deprecated_inline}}
- : Width-to-height aspect ratio of the output device.
Deprecated in Media Queries Level 4.
- {{cssxref("@media/device-height", "device-height")}} {{deprecated_inline}}
- : Height of the rendering surface of the output device.
Deprecated in Media Queries Level 4.
- {{cssxref("@media/device-width", "device-width")}} {{deprecated_inline}}
- : Width of the rendering surface of the output device. Deprecated in Media Queries Level 4.
- {{cssxref("@media/display-mode", "display-mode")}}
- : The display mode of the application, as specified in the web app manifest's [`display`](/en-US/docs/Web/Manifest#display) member.
Defined in the [Web App Manifest spec](https://w3c.github.io/manifest/#the-display-mode-media-feature).
- {{cssxref("@media/dynamic-range", "dynamic-range")}}
- : Combination of brightness, contrast ratio, and color depth that are supported by the user agent and the output device. Added in Media Queries Level 5.
- {{cssxref("@media/forced-colors", "forced-colors")}}
- : Detect whether user agent restricts color palette.
Added in Media Queries Level 5.
- {{cssxref("@media/grid", "grid")}}
- : Does the device use a grid or bitmap screen?
- {{cssxref("@media/height", "height")}}
- : Height of the viewport.
- {{cssxref("@media/hover", "hover")}}
- : Does the primary input mechanism allow the user to hover over elements?
Added in Media Queries Level 4.
- {{cssxref("@media/inverted-colors", "inverted-colors")}}
- : Is the user agent or underlying OS inverting colors?
Added in Media Queries Level 5.
- {{cssxref("@media/monochrome", "monochrome")}}
- : Bits per pixel in the output device's monochrome frame buffer, or zero if the device isn't monochrome.
- {{cssxref("@media/orientation", "orientation")}}
- : Orientation of the viewport.
- {{cssxref("@media/overflow-block", "overflow-block")}}
- : How does the output device handle content that overflows the viewport along the block axis?
Added in Media Queries Level 4.
- {{cssxref("@media/overflow-inline", "overflow-inline")}}
- : Can content that overflows the viewport along the inline axis be scrolled?
Added in Media Queries Level 4.
- {{cssxref("@media/pointer", "pointer")}}
- : Is the primary input mechanism a pointing device, and if so, how accurate is it?
Added in Media Queries Level 4.
- {{cssxref("@media/prefers-color-scheme", "prefers-color-scheme")}}
- : Detect if the user prefers a light or dark color scheme.
Added in Media Queries Level 5.
- {{cssxref("@media/prefers-contrast", "prefers-contrast")}}
- : Detects if the user has requested the system increase or decrease the amount of contrast between adjacent colors.
Added in Media Queries Level 5.
- {{cssxref("@media/prefers-reduced-motion", "prefers-reduced-motion")}}
- : The user prefers less motion on the page.
Added in Media Queries Level 5.
- {{cssxref("@media/resolution", "resolution")}}
- : Pixel density of the output device.
- {{cssxref("@media/scan", "scan")}}
- : Whether display output is progressive or interlaced.
- {{cssxref("@media/scripting", "scripting")}}
- : Detects whether scripting (i.e. JavaScript) is available.
Added in Media Queries Level 5.
- {{cssxref("@media/update", "update")}}
- : How frequently the output device can modify the appearance of content.
Added in Media Queries Level 4.
- {{cssxref("@media/video-dynamic-range", "video-dynamic-range")}}
- : Combination of brightness, contrast ratio, and color depth that are supported by the video plane of user agent and the output device. Added in Media Queries Level 5.
- {{cssxref("@media/width", "width")}}
- : Width of the viewport including width of scrollbar.
### Logical operators
The _logical operators_ `not`, `and`, `only`, and `or` can be used to compose a complex media query.
You can also combine multiple media queries into a single rule by separating them with commas.
- `and`
- : Used for combining multiple media features together into a single media query, requiring each chained feature to return `true` for the query to be `true`.
It is also used for joining media features with media types.
- `not`
- : Used to negate a media query, returning `true` if the query would otherwise return `false`.
If present in a comma-separated list of queries, it will only negate the specific query to which it is applied.
If you use the `not` operator, you _must also_ specify a media type.
> **Note:** In Level 3, the `not` keyword can't be used to negate an individual media feature expression, only an entire media query.
- `only`
- : Applies a style only if an entire query matches.
It is useful for preventing older browsers from applying selected styles.
When not using `only`, older browsers would interpret the query `screen and (max-width: 500px)` as `screen`, ignoring the remainder of the query, and applying its styles on all screens.
If you use the `only` operator, you _must also_ specify a media type.
- `,` (comma)
- : Commas are used to combine multiple media queries into a single rule.
Each query in a comma-separated list is treated separately from the others
Thus, if any of the queries in a list is `true`, the entire media statement returns `true`.
In other words, lists behave like a logical `or` operator.
- `or`
- : Equivalent to the `,` operator. Added in Media Queries Level 4.
### User agent client hints
Some media queries have corresponding [user agent client hints](/en-US/docs/Web/HTTP/Client_hints).
These are HTTP headers that request content that is pre-optimized for the particular media requirement.
They include {{HTTPHeader("Sec-CH-Prefers-Color-Scheme")}} and {{HTTPHeader("Sec-CH-Prefers-Reduced-Motion")}}.
## Accessibility concerns
To best accommodate people who adjust a site's text size, use [`em`](/en-US/docs/Learn/CSS/Building_blocks/Values_and_units#numeric_values)s when you need a {{cssxref("<length>")}} for your [media queries](/en-US/docs/Web/CSS/CSS_media_queries/Using_media_queries).
Both [`em`](/en-US/docs/Learn/CSS/Building_blocks/Values_and_units#numeric_values) and [`px`](/en-US/docs/Learn/CSS/Building_blocks/Values_and_units#numeric_values) are valid units, but [`em`](/en-US/docs/Learn/CSS/Building_blocks/Values_and_units#numeric_values) works better if the user changes the browser text size.
Also consider media queries or [HTTP user agent client hints](/en-US/docs/Web/HTTP/Client_hints#user-agent_client_hints) to improve the user's experience.
For example, the media query [`prefers-reduced-motion`](/en-US/docs/Web/CSS/@media/prefers-reduced-motion) or the equivalent HTTP header {{HTTPHeader("Sec-CH-Prefers-Reduced-Motion")}}) can be used to minimize the amount of animation or motion used based on user preferences.
## Security
Because media queries provide insights into the capabilities—and by extension, the features and design—of the device the user is working with, there is the potential that they could be abused to construct a ["fingerprint"](/en-US/docs/Glossary/Fingerprinting) which identifies the device, or at least categorizes it to some degree of detail that may be undesirable to users.
Because of this potential, a browser may opt to fudge the returned values in some manner in order to prevent them from being used to precisely identify a computer. A browser might also offer additional measures in this area; for example, if Firefox's "Resist Fingerprinting" setting is enabled, many media queries report default values rather than values representing the actual device state.
## Formal syntax
{{csssyntax}}
## Examples
### Testing for print and screen media types
```css
@media print {
body {
font-size: 10pt;
}
}
@media screen {
body {
font-size: 13px;
}
}
@media screen, print {
body {
line-height: 1.2;
}
}
@media only screen and (min-width: 320px) and (max-width: 480px) and (resolution: 150dpi) {
body {
line-height: 1.4;
}
}
```
Introduced in Media Queries Level 4 is a new range syntax that allows for less verbose media queries when testing for any feature accepting a range, as shown in the below examples:
```css
@media (height > 600px) {
body {
line-height: 1.4;
}
}
@media (400px <= width <= 700px) {
body {
line-height: 1.4;
}
}
```
For more examples, please see [Using media queries](/en-US/docs/Web/CSS/CSS_media_queries/Using_media_queries).
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [CSS media queries](/en-US/docs/Web/CSS/CSS_media_queries) module
- [Using media queries](/en-US/docs/Web/CSS/CSS_media_queries/Using_media_queries)
- In JavaScript, `@media` can be accessed via the CSS object model interface {{domxref("CSSMediaRule")}}.
- [Extended Mozilla media features](/en-US/docs/Web/CSS/Mozilla_Extensions#media_features)
- [Extended WebKit media features](/en-US/docs/Web/CSS/WebKit_Extensions#media_features)
| 0 |
data/mdn-content/files/en-us/web/css/@media | data/mdn-content/files/en-us/web/css/@media/prefers-contrast/index.md | ---
title: prefers-contrast
slug: Web/CSS/@media/prefers-contrast
page-type: css-media-feature
browser-compat: css.at-rules.media.prefers-contrast
---
{{CSSRef}}
The **`prefers-contrast`** [CSS](/en-US/docs/Web/CSS) [media feature](/en-US/docs/Web/CSS/@media#media_features) is used to detect whether the user has requested the web content to be presented with a lower or higher contrast.
## Syntax
- `no-preference`
- : Indicates that the user has made no preference known to the system. This keyword value evaluates as false in the Boolean context.
- `more`
- : Indicates that user has notified the system that they prefer an interface that has a higher level of contrast.
- `less`
- : Indicates that user has notified the system that they prefer an interface that has a lower level of contrast.
- `custom`
- : Indicates that user has notified the system for using a specific set of colors, and the contrast implied by these colors matches neither `more` nor `less`. This value will match the color palette specified by users of [`forced-colors: active`](/en-US/docs/Web/CSS/@media/forced-colors).
## User preferences
Various operating systems do support such preferences and user agents are likely to rely on the settings provided by the operating system.
## Examples
This example has an annoying low contrast by default.
### HTML
```html
<div class="contrast">low contrast box</div>
```
### CSS
```css
.contrast {
width: 100px;
height: 100px;
outline: 2px dashed black;
}
@media (prefers-contrast: more) {
.contrast {
outline: 2px solid black;
}
}
```
### Result
{{EmbedLiveSample("Examples")}}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- CSS [forced-colors](/en-US/docs/Web/CSS/@media/forced-colors) media query
| 0 |
data/mdn-content/files/en-us/web/css/@media | data/mdn-content/files/en-us/web/css/@media/color/index.md | ---
title: color
slug: Web/CSS/@media/color
page-type: css-media-feature
browser-compat: css.at-rules.media.color
---
{{CSSRef}}
The **`color`** [CSS](/en-US/docs/Web/CSS) [media feature](/en-US/docs/Web/CSS/@media#media_features) can be used to test the number of bits per color component (red, green, blue) of the output device.
## Syntax
The `color` feature is specified as an {{cssxref("<integer>")}} value that represents the number of bits per color component (red, green, blue) of the output device. If the device is not a color device, the value is zero. It is a range feature, meaning that you can also use the prefixed **`min-color`** and **`max-color`** variants to query minimum and maximum values, respectively.
> **Note:** If the various color components are represented by different numbers of bits, the smallest number is used. For example, if a display uses 5 bits for blue and red and 6 bits for green, then the device is considered to use 5 bits per color component. If the device uses indexed colors, the minimum number of bits per color component in the color table is used.
See [Applying color to HTML elements using CSS](/en-US/docs/Web/CSS/CSS_colors/Applying_color) to learn more about using CSS to apply color to HTML.
## Examples
### HTML
```html
<p>
This text should be black on non-color devices, red on devices with a low
number of colors, and greenish on devices with a high number of colors.
</p>
```
### CSS
```css
p {
color: black;
}
/* Any color device */
@media (color) {
p {
color: red;
}
}
/* Any color device with at least 8 bits per color component */
@media (min-color: 8) {
p {
color: #24ba13;
}
}
```
### Result
{{EmbedLiveSample("Examples")}}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Applying color to HTML elements using CSS](/en-US/docs/Web/CSS/CSS_colors/Applying_color)
- The CSS {{cssxref("color")}} property
- The CSS {{cssxref("<color>")}} data unit
| 0 |
data/mdn-content/files/en-us/web/css/@media | data/mdn-content/files/en-us/web/css/@media/pointer/index.md | ---
title: pointer
slug: Web/CSS/@media/pointer
page-type: css-media-feature
browser-compat: css.at-rules.media.pointer
---
{{CSSRef}}
The **`pointer`** [CSS](/en-US/docs/Web/CSS) [media feature](/en-US/docs/Web/CSS/@media#media_features) tests whether the user has a pointing device (such as a mouse), and if so, how accurate the _primary_ pointing device is.
> **Note:** If you want to test the accuracy of _any_ pointing device, use [`any-pointer`](/en-US/docs/Web/CSS/@media/any-pointer) instead.
## Syntax
The `pointer` feature is specified as a keyword value chosen from the list below.
- `none`
- : The primary input mechanism does not include a pointing device.
- `coarse`
- : The primary input mechanism includes a pointing device of limited accuracy, such as a finger on a touchscreen.
- `fine`
- : The primary input mechanism includes an accurate pointing device, such as a mouse.
## Examples
This example creates a small checkbox for users with fine primary pointers and a large checkbox for users with coarse primary pointers.
### HTML
```html
<input id="test" type="checkbox" /> <label for="test">Look at me!</label>
```
### CSS
```css
input[type="checkbox"] {
appearance: none;
border: solid;
margin: 0;
}
input[type="checkbox"]:checked {
background: gray;
}
@media (pointer: fine) {
input[type="checkbox"] {
width: 15px;
height: 15px;
border-width: 1px;
border-color: blue;
}
}
@media (pointer: coarse) {
input[type="checkbox"] {
width: 30px;
height: 30px;
border-width: 2px;
border-color: red;
}
}
```
### Result
{{EmbedLiveSample("Examples")}}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [The `any-pointer` media feature](/en-US/docs/Web/CSS/@media/any-pointer)
| 0 |
data/mdn-content/files/en-us/web/css/@media | data/mdn-content/files/en-us/web/css/@media/-moz-device-pixel-ratio/index.md | ---
title: "-moz-device-pixel-ratio"
slug: Web/CSS/@media/-moz-device-pixel-ratio
page-type: css-media-feature
status:
- deprecated
- non-standard
browser-compat: css.at-rules.media.-moz-device-pixel-ratio
---
{{CSSRef}} {{Non-standard_header}} {{Deprecated_header}}
The **`-moz-device-pixel-ratio`** Gecko-only [CSS](/en-US/docs/Web/CSS) [media feature](/en-US/docs/Web/CSS/@media#media_features) can be used to apply styles based on the number of device pixels per CSS pixel.
> **Warning:** Do not use this feature. Use the [`resolution`](/en-US/docs/Web/CSS/@media/resolution) feature with the `dppx` unit instead.
> **Note:** This media feature is also implemented by WebKit as `-webkit-device-pixel-ratio`. The min and max prefixes as implemented by Gecko are named `min--moz-device-pixel-ratio` and `max--moz-device-pixel-ratio`; but the same prefixes as implemented by Webkit are named `-webkit-min-device-pixel-ratio` and `-webkit-max-device-pixel-ratio`.
## Syntax
- {{cssxref("<number>")}}
- : The number of device pixels per CSS pixel.
**Media:** {{cssxref("@media")}}
**Accepts min/max prefixes:** yes
## Examples
### Basic compatibility example
`-moz-device-pixel-ratio` may be used for compatibility with Firefox older than 16, and alongside `-webkit-device-pixel-ratio` for compatibility with WebKit-based browsers that do not support `dppx`.
Example:
```css
/* First, set for Webkit-based browsers */
@media (-webkit-min-device-pixel-ratio: 2),
(min--moz-device-pixel-ratio: 2) /* Older Firefox browsers (prior to firefox 16) */,
(min-resolution: 2dppx) /* The standard way */,
(min-resolution: 192dpi); /* dppx fallback */
```
> **Note:** See this [CSSWG article](https://www.w3.org/blog/CSS/2012/06/14/unprefix-webkit-device-pixel-ratio/) for compatibility good practices regarding `resolution` and `dppx`.
## Specifications
Not part of any standard.
## Browser compatibility
{{Compat}}
## See also
- [Using Media Queries](/en-US/docs/Web/CSS/CSS_media_queries/Using_media_queries)
- [@media](/en-US/docs/Web/CSS/@media)
| 0 |
data/mdn-content/files/en-us/web/css/@media | data/mdn-content/files/en-us/web/css/@media/prefers-reduced-motion/index.md | ---
title: prefers-reduced-motion
slug: Web/CSS/@media/prefers-reduced-motion
page-type: css-media-feature
browser-compat: css.at-rules.media.prefers-reduced-motion
---
{{CSSRef}}
> **Warning:** An embedded example at the bottom of this page has a scaling movement that may be problematic for some readers. Readers with vestibular motion disorders may wish to enable the reduce motion feature on their device before viewing the animation.
The **`prefers-reduced-motion`** [CSS](/en-US/docs/Web/CSS) [media feature](/en-US/docs/Web/CSS/@media#media_features) is used to detect if a user has enabled a setting on their device to minimize the amount of non-essential motion. The setting is used to convey to the browser on the device that the user prefers an interface that removes, reduces, or replaces motion-based animations.
Such animations can trigger discomfort for those with [vestibular motion disorders](https://www.a11yproject.com/posts/understanding-vestibular-disorders/). Animations such as scaling or panning large objects can be vestibular motion triggers.
```css
@media (prefers-reduced-motion) {
/* styles to apply if a user's device settings are set to reduced motion */
}
```
## Syntax
- `no-preference`
- : Indicates that a user has made no preference known on the device. This keyword value evaluates as false.
- `reduce`
- : Indicates that a user has enabled the setting on their device for reduced motion. This keyword value evaluates as true.
## User preferences
For Firefox, the `reduce` request is honoured if:
- In GTK/GNOME: Settings > Accessibility > Seeing > Reduced animation is turned on.
- In older versions of GNOME, GNOME Tweaks > General tab (or Appearance, depending on version) > Animations is turned off.
- Alternatively, add `gtk-enable-animations = false` to the `[Settings]` block of [the GTK 3 configuration file](https://wiki.archlinux.org/title/GTK#Configuration).
- In Plasma/KDE: System Settings > Workspace Behavior -> General Behavior > "Animation speed" is set all the way to right to "Instant".
- In Windows 10: Settings > Ease of Access > Display > Show animations in Windows.
- In Windows 11: Settings > Accessibility > Visual Effects > Animation Effects
- In macOS: System Preferences > Accessibility > Display > Reduce motion.
- In iOS: Settings > Accessibility > Motion.
- In Android 9+: Settings > Accessibility > Remove animations.
- In Firefox `about:config`: Add a number preference called `ui.prefersReducedMotion` and set its value to either `0` for full animation or to `1` to indicate a preference for reduced motion. Changes to this preference take effect immediately.
## Examples
This example uses a scaling animation for the purpose of demonstrating `prefers-reduced-motion`. If you enable the setting for reducing motion in the accessibility preferences on your device, the `prefers-reduced-motion` media query will detect your preference and the CSS within the reduced motion rules, with the same [specificity](/en-US/docs/Web/CSS/Specificity) but coming later in the [CSS source order](/en-US/docs/Learn/CSS/Building_blocks/Cascade_and_inheritance#source_order), will take precedence. As a result, the [animation](/en-US/docs/Web/CSS/CSS_animations/Using_CSS_animations) on the box will tone down to the `dissolve` animation, which is a more muted animation that is not a vestibular motion trigger.
### Toning down the animation scaling
#### HTML
```html
<div class="animation">animated box</div>
```
#### CSS
```css
.animation {
animation: pulse 1s linear infinite both;
background-color: purple;
}
/* Tone down the animation to avoid vestibular motion triggers. */
@media (prefers-reduced-motion) {
.animation {
animation: dissolve 4s linear infinite both;
background-color: green;
text-decoration: overline;
}
}
```
```css hidden
.animation {
color: #fff;
font: 1.2em sans-serif;
width: 10em;
padding: 1em;
border-radius: 1em;
text-align: center;
}
@keyframes pulse {
0% {
transform: scale(1);
}
25% {
transform: scale(0.9);
}
50% {
transform: scale(1);
}
75% {
transform: scale(1.1);
}
100% {
transform: scale(1);
}
}
@keyframes dissolve {
0% {
opacity: 1;
}
50% {
opacity: 0.3;
}
100% {
opacity: 1;
}
}
```
#### Result
{{EmbedLiveSample("Toning down the animation scaling")}}
You can enable the setting for reducing motion on [your device](#user_preferences) to view the change in animation scaling. This example uses the background color and the line over the text to visually highlight when the keyframe animation switches in response to the setting being enabled or disabled.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{HTTPHeader("Sec-CH-Prefers-Reduced-Motion")}} HTTP Header [User Agent Client Hint](/en-US/docs/Web/HTTP/Client_hints#user-agent_client_hints)
- [An introduction to the reduced motion media query](https://css-tricks.com/introduction-reduced-motion-media-query/) on CSS-Tricks (2019)
- [Responsive design for motion](https://webkit.org/blog/7551/responsive-design-for-motion/) on WebKit Blog (2017)
| 0 |
data/mdn-content/files/en-us/web/css/@media | data/mdn-content/files/en-us/web/css/@media/device-aspect-ratio/index.md | ---
title: device-aspect-ratio
slug: Web/CSS/@media/device-aspect-ratio
page-type: css-media-feature
status:
- deprecated
browser-compat: css.at-rules.media.device-aspect-ratio
---
{{CSSRef}} {{deprecated_header}}
> **Note:** To query for the aspect ratio of the viewport, developers should use the [`aspect-ratio`](/en-US/docs/Web/CSS/@media/aspect-ratio) media feature instead.
The **`device-aspect-ratio`** [CSS](/en-US/docs/Web/CSS) [media feature](/en-US/docs/Web/CSS/@media#media_features) can be used to test the width-to-height aspect ratio of an output device.
## Syntax
The `device-aspect-ratio` feature is specified as a {{cssxref("<ratio>")}}. It is a range feature, meaning that you can also use the prefixed **`min-device-aspect-ratio`** and **`max-device-aspect-ratio`** variants to query minimum and maximum values, respectively.
## Examples
### Using min-device-aspect-ratio
```css
article {
padding: 1rem;
}
@media screen and (min-device-aspect-ratio: 16/9) {
article {
padding: 1rem 5vw;
}
}
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/css/@media | data/mdn-content/files/en-us/web/css/@media/grid/index.md | ---
title: grid
slug: Web/CSS/@media/grid
page-type: css-media-feature
browser-compat: css.at-rules.media.grid
---
{{CSSRef}}
The **`grid`** [CSS](/en-US/docs/Web/CSS) [media feature](/en-US/docs/Web/CSS/@media#media_features) can be used to test whether the output device uses a grid-based screen.
Most modern computers and smartphones have bitmap-based screens. Examples of grid-based devices include text-only terminals and basic phones with only one fixed font.
## Syntax
The `grid` feature is specified as a {{cssxref("CSS_media_queries/Using_media_queries", "<mq-boolean>")}} value (`0` or `1`) representing whether or not the output device is grid-based.
## Examples
### HTML
```html
<p class="unknown">I don't know if you're using a grid device. :-(</p>
<p class="bitmap">You are using a bitmap device.</p>
<p class="grid">You are using a grid device! Neato!</p>
```
### CSS
```css
:not(.unknown) {
color: lightgray;
}
@media (grid: 0) {
.unknown {
color: lightgray;
}
.bitmap {
color: red;
text-transform: uppercase;
}
}
@media (grid: 1) {
.unknown {
color: lightgray;
}
.grid {
color: black;
text-transform: uppercase;
}
}
```
### Result
{{EmbedLiveSample("Examples")}}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using Media Queries](/en-US/docs/Web/CSS/CSS_media_queries/Using_media_queries)
- [@media](/en-US/docs/Web/CSS/@media)
| 0 |
data/mdn-content/files/en-us/web/css/@media | data/mdn-content/files/en-us/web/css/@media/color-index/index.md | ---
title: color-index
slug: Web/CSS/@media/color-index
page-type: css-media-feature
browser-compat: css.at-rules.media.color-index
---
{{CSSRef}}
The **`color-index`** [CSS](/en-US/docs/Web/CSS) [media feature](/en-US/docs/Web/CSS/@media#media_features) can be used to test the number of entries in the output device's color lookup table.
## Syntax
The `color-index` feature is specified as an {{cssxref("<integer>")}} value representing the number of entries in the output device's color lookup table. (This value is zero if the device does not use such a table.) It is a range feature, meaning that you can also use the prefixed **`min-color-index`** and **`max-color-index`** variants to query minimum and maximum values, respectively.
## Examples
### Basic example
#### HTML
```html
<p>This is a test.</p>
```
#### CSS
```css
p {
color: black;
}
@media (color-index) {
p {
color: red;
}
}
@media (min-color-index: 15000) {
p {
color: #1475ef;
}
}
```
#### Result
{{EmbedLiveSample("Basic_example")}}
### Custom stylesheet
This HTML will apply a special stylesheet for devices that have at least 256 colors.
```html
<link rel="stylesheet" href="http://foo.bar.com/base.css" />
<link
rel="stylesheet"
media="all and (min-color-index: 256)"
href="http://foo.bar.com/color-stylesheet.css" />
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using Media Queries](/en-US/docs/Web/CSS/CSS_media_queries/Using_media_queries)
- [@media](/en-US/docs/Web/CSS/@media)
| 0 |
data/mdn-content/files/en-us/web/css/@media | data/mdn-content/files/en-us/web/css/@media/prefers-reduced-data/index.md | ---
title: prefers-reduced-data
slug: Web/CSS/@media/prefers-reduced-data
page-type: css-media-feature
status:
- experimental
browser-compat: css.at-rules.media.prefers-reduced-data
---
{{CSSRef}}{{SeeCompatTable}}
> **Note:** This feature is not supported by any user agent and its specifics are subject to change.
The **`prefers-reduced-data`** [CSS](/en-US/docs/Web/CSS) [media feature](/en-US/docs/Web/CSS/@media#media_features) is used to detect if the user has requested the web content that consumes less internet traffic.
## Syntax
- `no-preference`
- : Indicates that the user has made no preference known to the system. This keyword value evaluates as false in the boolean context.
- `reduce`
- : Indicates that user has expressed the preference for lightweight alternate content.
## User preferences
Currently no user agent implements this feature, although various operating systems do support such preferences and if this media query is ever implemented user agents will likely rely on the settings provided by the operating system.
## Examples
> **Note:** No browser currently implements this feature so the following example will not work.
In this example the `montserrat-regular.woff2` font file will neither be preloaded nor downloaded if the user prefers reduced data, in this case the "[system font stack](https://css-tricks.com/snippets/css/system-font-stack/)" will serve as the fallback font:
### HTML
```html
<head>
<link
rel="preload"
href="fonts/montserrat-regular.woff2"
as="font"
media="(prefers-reduced-data: no-preference)"
crossorigin />
<link rel="stylesheet" href="style.css" />
</head>
```
### CSS
```css
@media (prefers-reduced-data: no-preference) {
@font-face {
font-family: Montserrat;
font-style: normal;
font-weight: 400;
font-display: swap;
/* latin */
src:
local("Montserrat Regular"),
local("Montserrat-Regular"),
url("fonts/montserrat-regular.woff2") format("woff2");
unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6,
U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193,
U+2212, U+2215, U+FEFF, U+FFFD;
}
}
body {
font-family:
Montserrat,
-apple-system,
BlinkMacSystemFont,
"Segoe UI",
Roboto,
Helvetica,
Arial,
"Microsoft YaHei",
sans-serif,
"Apple Color Emoji",
"Segoe UI Emoji",
"Segoe UI Symbol";
}
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{HTTPHeader("Save-Data")}} HTTP header
| 0 |
data/mdn-content/files/en-us/web/css/@media | data/mdn-content/files/en-us/web/css/@media/-webkit-transform-2d/index.md | ---
title: "-webkit-transform-2d"
slug: Web/CSS/@media/-webkit-transform-2d
page-type: css-media-feature
status:
- non-standard
browser-compat: css.at-rules.media.-webkit-transform-2d
---
{{CSSRef}} {{ Non-standard_header }}
> **Note:** All browsers support the [`transform`](/en-US/docs/Web/CSS/transform#browser_compatibility) property without vendor prefixes. Only WebKit (Safari), and not Chromium, based browsers supports the `-webkit-transform-2d` media feature. No browsers support `transform`, without the prefix or `2d` extension, as a media query. Use the [`@supports (transform)`](/en-US/docs/Web/CSS/@supports) feature query instead.
The **`-webkit-transform-2d`** Boolean [CSS](/en-US/docs/Web/CSS) [media feature](/en-US/docs/Web/CSS/@media#media_features) is a [WebKit extension](/en-US/docs/Web/CSS/WebKit_Extensions) whose value is `true` if vendor-prefixed CSS 2D {{cssxref("transform")}}s and non-standard vendor-prefixed media queries are supported.
Apple has [a description in Safari CSS Reference](https://developer.apple.com/library/archive/documentation/AppleApplications/Reference/SafariCSSRef/Articles/OtherStandardCSS3Features.html#//apple_ref/doc/uid/TP40007601-SW3).
## Syntax
`-webkit-transform-2d` is a Boolean [CSS](/en-US/docs/Web/CSS) [media feature](/en-US/docs/Web/CSS/@media#media_features) whose value is `true` if the browser supports `-webkit` prefixed CSS 2D {{cssxref("transform")}}s.
### Values
- `true`
- : The browser supports the 2D CSS transforms with the `-webkit` prefix.
- `false`
- : The 2D CSS transforms prefixed with `-webkit` are not supported by the browser.
## Examples
### Basic example
```css
@media (-webkit-transform-2d) {
div {
-webkit-transform: translate(100px, 100px);
}
}
```
This media feature is only supported by WebKit. The unprefixed [`transform`](/en-US/docs/Web/CSS/transform) property is supported in all modern browsers. If possible, use an {{cssxref("@supports")}} feature query instead:
```css
@supports (-webkit-transform: translate(100px, 100px)) {
div {
-webkit-transform: translate(100px, 100px);
}
}
```
## Specifications
Not part of any standard.
## Browser compatibility
{{Compat}}
## See also
- {{cssxref("@media/-webkit-transform-3d", "-webkit-transform-3d")}}
- {{cssxref("@media/-webkit-transition", "-webkit-transition")}}
- {{cssxref("@media/-webkit-animation", "-webkit-animation")}}
- [Test page at quirksmode.org](https://www.quirksmode.org/css/tests/mediaqueries/animation.html)
- {{cssxref("transform")}} and [using CSS transforms](/en-US/docs/Web/CSS/CSS_transforms/Using_CSS_transforms)
- {{cssxref("@media")}} and [Using media queries](/en-US/docs/Web/CSS/CSS_media_queries/Using_media_queries)
- {{cssxref("@supports")}} and [using feature queries](/en-US/docs/Web/CSS/CSS_conditional_rules/Using_feature_queries)
| 0 |
data/mdn-content/files/en-us/web/css/@media | data/mdn-content/files/en-us/web/css/@media/any-hover/index.md | ---
title: any-hover
slug: Web/CSS/@media/any-hover
page-type: css-media-feature
browser-compat: css.at-rules.media.any-hover
---
{{CSSRef}}
The **`any-hover`** [CSS](/en-US/docs/Web/CSS) [media feature](/en-US/docs/Web/CSS/@media#media_features) can be used to test whether _any_ available input mechanism can hover over elements.
## Syntax
The `any-hover` feature is specified as a keyword value chosen from the list below.
- `none`
- : None of the available input mechanism(s) can hover conveniently, or there is no pointing input mechanism.
- `hover`
- : One or more available input mechanisms can conveniently hover over elements.
## Examples
### Testing whether input methods can hover
#### HTML
```html
<a href="#">Try hovering over me!</a>
```
#### CSS
```css
@media (any-hover: hover) {
a:hover {
background: yellow;
}
}
```
#### Result
{{EmbedLiveSample("Testing_whether_input_methods_can_hover")}}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [the `hover` media feature](/en-US/docs/Web/CSS/@media/hover)
| 0 |
data/mdn-content/files/en-us/web/css/@media | data/mdn-content/files/en-us/web/css/@media/-webkit-animation/index.md | ---
title: "-webkit-animation"
slug: Web/CSS/@media/-webkit-animation
page-type: css-media-feature
status:
- deprecated
- non-standard
browser-compat: css.at-rules.media.-webkit-animation
---
{{CSSRef}}{{Non-standard_header}}{{Deprecated_Header}}
> **Note:** All browsers support the [`animation`](/en-US/docs/Web/CSS/animation#browser_compatibility) property without vendor prefixes. Only WebKit (Safari), and not Chromium, based browsers supports the `-webkit-animation` media feature. No browsers support `animation`, without the prefix, as a media query. Use the [`@supports (animation)`](/en-US/docs/Web/CSS/@supports) feature query instead.
The **`-webkit-animation`** Boolean [CSS](/en-US/docs/Web/CSS) [media feature](/en-US/docs/Web/CSS/@media#media_features) is a [WebKit extension](/en-US/docs/Web/CSS/WebKit_Extensions) whose value is `true` if vendor-prefixed CSS {{cssxref("animation")}}s are supported.
Apple has [a description in Safari CSS Reference](https://developer.apple.com/library/archive/documentation/AppleApplications/Reference/SafariCSSRef/Articles/OtherStandardCSS3Features.html#//apple_ref/doc/uid/TP40007601-SW3).
> **Note:** This media feature is only supported by WebKit. If possible, use an {{cssxref("@supports")}} feature query instead.
## Syntax
The `-webkit-animation` media feature is a Boolean whose value is `true` if the vendor-prefixed CSS animation properties are supported _and_ the browser supports prefixed property media queries.
### Values
- `true`
- : The browser supports `-webkit` prefixed CSS {{cssxref("animation")}}.
- `false`
- : The browser doesn't support these prefixed CSS animations.
## Examples
### Example of -webkit-animation
```css
@media (-webkit-animation) {
/* CSS to use if -webkit- prefixed animations are supported AND the browser supports prefixed properties as media queries */
}
```
## Specifications
Not part of any standard.
## Browser compatibility
{{Compat}}
## See also
- [`-webkit-transform-3d`](/en-US/docs/Web/CSS/@media/-webkit-transform-3d)
- [`-webkit-transform-2d`](/en-US/docs/Web/CSS/@media/-webkit-transform-2d)
- [`-webkit-transition`](/en-US/docs/Web/CSS/@media/-webkit-transition)
- [Test page at quirksmode.org](https://www.quirksmode.org/css/tests/mediaqueries/animation.html)
- {{cssxref("animation")}} and [using CSS animations](/en-US/docs/Web/CSS/CSS_animations/Using_CSS_animations)
- {{cssxref("@media")}} and [Using media queries](/en-US/docs/Web/CSS/CSS_media_queries/Using_media_queries)
- {{cssxref("@supports")}} and [using feature queries](/en-US/docs/Web/CSS/CSS_conditional_rules/Using_feature_queries)
| 0 |
data/mdn-content/files/en-us/web/css/@media | data/mdn-content/files/en-us/web/css/@media/overflow-inline/index.md | ---
title: overflow-inline
slug: Web/CSS/@media/overflow-inline
page-type: css-media-feature
browser-compat: css.at-rules.media.overflow-inline
---
{{CSSRef}}
The **`overflow-inline`** [CSS](/en-US/docs/Web/CSS) [media feature](/en-US/docs/Web/CSS/@media#media_features) can be used to test how the output device handles content that overflows the initial [containing block](/en-US/docs/Web/CSS/Containing_block) along the inline axis.
## Syntax
The `overflow-inline` feature is specified as a keyword value chosen from the list below.
- `none`
- : Content that overflows the inline axis is not displayed.
- `scroll`
- : Content that overflows the inline axis can be seen by scrolling to it.
## Examples
### HTML
```html
<p>
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nullam ac turpis
eleifend, fringilla velit ac, aliquam tellus. Vestibulum ante ipsum primis in
faucibus orci luctus et ultrices posuere cubilia Curae; Nunc velit erat,
tempus id rutrum sed, dapibus ut urna. Integer vehicula nibh a justo imperdiet
rutrum. Nam faucibus pretium orci imperdiet sollicitudin. Nunc id facilisis
dui. Proin elementum et massa et feugiat. Integer rutrum ullamcorper eleifend.
Proin sit amet tincidunt risus. Sed nec augue congue eros accumsan tincidunt
sed eget ex.
</p>
```
### CSS
```css
p {
white-space: nowrap;
}
@media (overflow-inline: scroll) {
p {
color: red;
}
}
```
### Result
{{EmbedLiveSample("Examples")}}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/css/@media | data/mdn-content/files/en-us/web/css/@media/orientation/index.md | ---
title: orientation
slug: Web/CSS/@media/orientation
page-type: css-media-feature
browser-compat: css.at-rules.media.orientation
---
{{CSSRef}}
The **`orientation`** [CSS](/en-US/docs/Web/CSS) [media feature](/en-US/docs/Web/CSS/@media#media_features) can be used to test the orientation of the {{glossary("viewport")}} (or the page box, for [paged media](/en-US/docs/Web/CSS/CSS_paged_media)).
> **Note:** This feature does not correspond to _device_ orientation. Opening the soft keyboard on many devices in portrait orientation will cause the viewport to become wider than it is tall, thereby causing the browser to use landscape styles instead of portrait.
## Syntax
The `orientation` feature is specified as a keyword value chosen from the list below.
### Keyword values
- `portrait`
- : The viewport is in a portrait orientation, i.e., the height is greater than or equal to the width.
- `landscape`
- : The viewport is in a landscape orientation, i.e., the width is greater than the height.
## Examples
### Portrait orientation
In this example we have three boxes in the HTML, and use the `orientation` media feature to switch between a row layout (in landscape) and a column layout (in portrait).
The example output is embedded in an {{HTMLElement("iframe")}} whose height is greater than its width, so the boxes get a column layout.
#### HTML
```html
<div>Box 1</div>
<div>Box 2</div>
<div>Box 3</div>
```
#### CSS
```css
body {
display: flex;
}
div {
background: yellow;
width: 200px;
height: 200px;
margin: 0.5rem;
padding: 0.5rem;
}
@media (orientation: landscape) {
body {
flex-direction: row;
}
}
@media (orientation: portrait) {
body {
flex-direction: column;
}
}
```
#### Result
{{EmbedLiveSample("Portrait orientation", "", "800")}}
### Landscape orientation
This example has exactly the same code as the previous example: it has three boxes in the HTML, and uses the `orientation` media feature to switch between a row layout (in landscape) and a column layout (in portrait).
However, in this example, the example output is embedded in an {{HTMLElement("iframe")}} whose height is less than its width, so the boxes get a row layout.
#### HTML
```html
<div>Box 1</div>
<div>Box 2</div>
<div>Box 3</div>
```
#### CSS
```css
body {
display: flex;
}
div {
background: yellow;
width: 200px;
height: 200px;
margin: 0.5rem;
padding: 0.5rem;
}
@media (orientation: landscape) {
body {
flex-direction: row;
}
}
@media (orientation: portrait) {
body {
flex-direction: column;
}
}
```
{{EmbedLiveSample("Landscape orientation", "", "300")}}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/css/@media | data/mdn-content/files/en-us/web/css/@media/-webkit-device-pixel-ratio/index.md | ---
title: "-webkit-device-pixel-ratio"
slug: Web/CSS/@media/-webkit-device-pixel-ratio
page-type: css-media-feature
browser-compat: css.at-rules.media.-webkit-device-pixel-ratio
---
{{CSSRef}}
The **`-webkit-device-pixel-ratio`** is a non-standard Boolean [CSS](/en-US/docs/Web/CSS) [media feature](/en-US/docs/Web/CSS/@media#media_features) which is an alternative to the standard [`resolution`](/en-US/docs/Web/CSS/@media/resolution) media feature.
> **Note:** If possible, use the [`resolution`](/en-US/docs/Web/CSS/@media/resolution) media feature query instead, which is a standard media feature. While this prefixed media feature is a WebKit feature, other browser engines may support it. See [browser compatibility](#browser_compatibility) below.
## Syntax
The `-webkit-device-pixel-ratio` feature is specified as a {{cssxref("<number>")}} value. It is a range feature, meaning that you can also use the prefixed **`-webkit-min-device-pixel-ratio`** and **`-webkit-max-device-pixel-ratio`** variants to query minimum and maximum values, respectively.
### Values
- {{cssxref("<number>")}}
- : The number of device pixels used to represent each CSS [`px`](/en-US/docs/Web/CSS/length#absolute_length_units). Although the value is a `<number>`, and thus doesn't syntactically allow units, its implicit unit is [`dppx`](/en-US/docs/Web/CSS/resolution#units).
## Implementation
```css
/* A unit of "dppx" is implied: */
@media (-webkit-min-device-pixel-ratio: 2) {
/* … */
}
/* It is equivalent to: */
@media (min-resolution: 2dppx) {
/* … */
}
/* Similarly: */
@media (-webkit-max-device-pixel-ratio: 2) {
/* … */
}
/* It is equivalent to: */
@media (max-resolution: 2dppx) {
/* … */
}
```
## Examples
### HTML
```html
<p>This is a test of your device's pixel density.</p>
```
### CSS
```css
/* Exact resolution */
@media (-webkit-device-pixel-ratio: 1) {
p {
color: red;
}
}
/* Minimum resolution */
@media (-webkit-min-device-pixel-ratio: 1.1) {
p {
font-size: 1.5em;
}
}
/* Maximum resolution */
@media (-webkit-max-device-pixel-ratio: 3) {
p {
background: yellow;
}
}
```
### Result
{{EmbedLiveSample("Examples")}}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using media queries](/en-US/docs/Web/CSS/CSS_media_queries/Using_media_queries)
- {{cssxref("resolution")}}
- [`-webkit-transform-2d`](/en-US/docs/Web/CSS/@media/-webkit-transform-2d)
- [`-webkit-transform-3d`](/en-US/docs/Web/CSS/@media/-webkit-transform-3d)
- [`-webkit-transition`](/en-US/docs/Web/CSS/@media/-webkit-transition)
- [`-webkit-animation`](/en-US/docs/Web/CSS/@media/-webkit-animation)
- [W3C Suggested Method to UnPrefix](https://www.w3.org/blog/CSS/2012/06/14/unprefix-webkit-device-pixel-ratio/)
| 0 |
data/mdn-content/files/en-us/web/css/@media | data/mdn-content/files/en-us/web/css/@media/dynamic-range/index.md | ---
title: dynamic-range
slug: Web/CSS/@media/dynamic-range
page-type: css-media-feature
browser-compat: css.at-rules.media.dynamic-range
---
{{CSSRef}}
The **`dynamic-range`** [CSS](/en-US/docs/Web/CSS) [media feature](/en-US/docs/Web/CSS/@media#media_features) can be used to test the combination of brightness, contrast ratio, and color depth that are supported by the {{glossary("user agent")}} and the output device.
> **Note:** Some devices have high dynamic range capabilities that are not always 'on' and need to be activated (sometimes programmatically, sometimes by the user, sometimes based on the content). This media feature does not test whether the dynamic range capability is active; it only tests whether the device is capable of high dynamic range visuals.
## Syntax
The `dynamic-range` feature is specified as a keyword value chosen from the list below.
- `standard`
- : This value matches any visual device and excludes devices lacking visual capabilities. A user agent or an output device that matches `high` will also match the `standard` value.
- `high`
- : This value matches user agents and output devices that support high peak brightness, high contrast ratio, and color depth greater than 24 bit or 8 bit per color component of RGB. **Peak brightness** refers to how bright the brightest point a light-emitting device, such as an LCD screen, can produce. In the case of a light-reflective device, such as paper or e-ink, peak brightness refers to the point that at least absorbs light. **Contrast ratio** refers to the ratio of the luminance of the brightest color to that of the darkest color that the system is capable of producing. Currently, there is no precise way to measure peak brightness and contrast ratio, and the determination of what counts as high peak brightness and high contrast ratio depends on the user agent.
## Examples
```css
@media (dynamic-range: standard) {
p {
color: red;
}
}
@media (dynamic-range: high) {
p {
color: green;
}
}
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using Media Queries](/en-US/docs/Web/CSS/CSS_media_queries/Using_media_queries)
- [@media](/en-US/docs/Web/CSS/@media)
| 0 |
data/mdn-content/files/en-us/web/css/@media | data/mdn-content/files/en-us/web/css/@media/resolution/index.md | ---
title: resolution
slug: Web/CSS/@media/resolution
page-type: css-media-feature
browser-compat: css.at-rules.media.resolution
---
{{CSSRef}}
The **`resolution`** [CSS](/en-US/docs/Web/CSS) [media feature](/en-US/docs/Web/CSS/@media#media_features) can be used to test the pixel density of the output device.
## Syntax
The `resolution` feature is specified as a {{cssxref("<resolution>")}} value representing the pixel density of the output device. It is a range feature, meaning that you can also use the prefixed **`min-resolution`** and **`max-resolution`** variants to query minimum and maximum values, respectively.
## Examples
### HTML
```html
<p>This is a test of your device's pixel density.</p>
```
### CSS
```css
/* Exact resolution */
@media (resolution: 150dpi) {
p {
color: red;
}
}
/* Minimum resolution */
@media (min-resolution: 72dpi) {
p {
text-decoration: underline;
}
}
/* Maximum resolution */
@media (max-resolution: 300dpi) {
p {
background: yellow;
}
}
```
### Result
{{EmbedLiveSample("Examples")}}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{domxref("window.devicePixelRatio")}}
- The {{cssxref("image-resolution")}} property
| 0 |
data/mdn-content/files/en-us/web/css/@media | data/mdn-content/files/en-us/web/css/@media/-webkit-transition/index.md | ---
title: "-webkit-transition"
slug: Web/CSS/@media/-webkit-transition
page-type: css-media-feature
status:
- deprecated
- non-standard
browser-compat: css.at-rules.media.-webkit-transition
---
{{CSSRef}} {{deprecated_header}} {{ Non-standard_header }}
> **Note:** All browsers support the [`transition`](/en-US/docs/Web/CSS/animation#browser_compatibility) property without vendor prefixes. Only WebKit (Safari), and not Chromium, based browsers support the `-webkit-transition` media feature. No browsers support `transition` without the prefix as a media query (though some browsers do support - {{cssxref("@media/-webkit-transform-3d", "-webkit-transform-3d")}}). Use the [`@supports (transition)`](/en-US/docs/Web/CSS/@supports) feature query instead.
The **`-webkit-transition`** Boolean non-standard[CSS](/en-US/docs/Web/CSS) [media feature](/en-US/docs/Web/CSS/@media#media_features) is a [WebKit extension](/en-US/docs/Web/CSS/WebKit_Extensions) whose value is `true` if the browsing context supports [CSS transitions](/en-US/docs/Web/CSS/CSS_transitions).
Apple has [a description in Safari CSS Reference](https://developer.apple.com/library/archive/documentation/AppleApplications/Reference/SafariCSSRef/Articles/OtherStandardCSS3Features.html#//apple_ref/doc/uid/TP40007601-SW3); this is now called `transition` there.
> **Note:** You should not use this media feature; it was never specified, has never been widely implemented, and has been [removed from most browsers](#browser_compatibility). Use a {{cssxref("@supports")}} feature query instead.
## Syntax
```css
@media (-webkit-transition) {
/* CSS to use if this media feature and prefixed transitions are supported */
}
```
## Examples
### Use @supports instead
Do not use the `-webkit-transition` media feature. Instead, test for transition support using the CSS {{cssxref("@supports")}} [at-rule](/en-US/docs/Web/CSS/At-rule), like this:
```css
@supports (transition: initial) {
/* CSS to use if transitions are supported */
}
```
### Obsolete example
Before this became obsolete, you could use `-webkit-transition` in your CSS like this:
```css
@media (-webkit-transition) {
/* CSS to use if transitions are supported */
}
```
## Specifications
Not part of any standard.
## Browser compatibility
{{Compat}}
## See also
- {{cssxref("@media/-webkit-transform-3d", "-webkit-transform-3d")}}
- {{cssxref("@media/-webkit-transform-2d", "-webkit-transform-2d")}}
- {{cssxref("@media/-webkit-animation", "-webkit-animation")}}
- [Test page at quirksmode.org](https://www.quirksmode.org/css/tests/mediaqueries/animation.html)
- {{cssxref("transition")}} and [using CSS transitions](/en-US/docs/Web/CSS/CSS_transitions/Using_CSS_transitions)
- {{cssxref("@media")}} and [Using media queries](/en-US/docs/Web/CSS/CSS_media_queries/Using_media_queries)
- {{cssxref("@supports")}} and [using feature queries](/en-US/docs/Web/CSS/CSS_conditional_rules/Using_feature_queries)
| 0 |
data/mdn-content/files/en-us/web/css/@media | data/mdn-content/files/en-us/web/css/@media/aural/index.md | ---
title: aural
slug: Web/CSS/@media/aural
page-type: css-media-feature
status:
- deprecated
spec-urls: https://www.w3.org/TR/CSS22/aural.html
---
{{CSSRef}} {{deprecated_header}}
The `aural` [CSS](/en-US/docs/Web/CSS) [media type](/en-US/docs/Web/CSS/@media#media_types) is used for devices that have speech output capabilities.
## Syntax
The `aural` CSS media type was used to specify a block of CSS that applied only when the content is being presented using a speech synthesis device.
```css
@media aural {
/* speech-specific styles here */
}
```
## Examples
### Basic example
```css
@media aural {
body {
voice-family: Paul;
}
}
```
## Specifications
{{Specifications}}
## See also
- [Media queries](/en-US/docs/Web/CSS/CSS_media_queries)
- [Using media queries](/en-US/docs/Web/CSS/CSS_media_queries/Using_media_queries)
- [`@media`](/en-US/docs/Web/CSS/@media)
| 0 |
data/mdn-content/files/en-us/web/css/@media | data/mdn-content/files/en-us/web/css/@media/scan/index.md | ---
title: scan
slug: Web/CSS/@media/scan
page-type: css-media-feature
browser-compat: css.at-rules.media.scan
---
{{CSSRef}}
The **`scan`** [CSS](/en-US/docs/Web/CSS) [media feature](/en-US/docs/Web/CSS/@media#media_features) is used to apply CSS styles based on the scanning process of the output device.
## Syntax
The `scan` feature is specified as one of the following keyword values:
- `interlace`
- : The output device uses "interlaced" rendering, where video frames alternate between specifying only the "even" lines on the screen and only the "odd" lines.
- `progressive`
- : The output device renders content to the screen with no special treatment.
## Description
Most modern screens (and all computer screens) use progressive rendering, displaying each screen fully with no special treatment.
Interlacing was used by CRT monitors and some plasma TVs to enable the appearance of faster frames per second (FPS) while reducing bandwidth. With interlacing, video frames alternate between rendering the even lines and the odd lines on the screen, downloading and rendering only half the screen for each frame, exploiting the human image-smoothing ability so the brain simulates a higher FPS broadcast at half the bandwidth cost.
When targeting interlaced screens, avoid very fast movement across the screen and ensure animated details are wider than 1px to reduce flickering.
## Examples
### HTML
```html
<p>This is a test.</p>
```
### CSS
```css
p {
padding: 10px;
border: solid;
}
@media screen and (scan: interlace) {
p {
background: #f4ae8a;
}
}
@media screen and (scan: progressive) {
p {
text-decoration: underline;
}
}
@media not screen and (scan: progressive) {
p {
border-style: dashed;
}
}
@media not screen and (scan: interlaced) {
p {
color: purple;
}
}
```
### Result
{{EmbedLiveSample("Examples")}}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- The [@media](/en-US/docs/Web/CSS/@media) at-rule, which is used to specify the scan expression.
- [Using media queries](/en-US/docs/Web/CSS/CSS_media_queries/Using_media_queries) to understand when and how to use a media query.
| 0 |
data/mdn-content/files/en-us/web/css/@media | data/mdn-content/files/en-us/web/css/@media/update/index.md | ---
title: update
slug: Web/CSS/@media/update
page-type: css-media-feature
browser-compat: css.at-rules.media.update
---
{{CSSRef}}
The **`update`** [CSS](/en-US/docs/Web/CSS) [media feature](/en-US/docs/Web/CSS/@media#media_features) can be used to test how frequently (if at all) the output device is able to modify the appearance of content once rendered.
```css
@media (update: < none | slow | fast >) {
/* styles to apply if the update frequency of the output device is a match */
}
```
## Syntax
The `update` feature is specified as a single keyword value chosen from the list below.
- `none`
- : Once it has been rendered, the layout can no longer be updated. Example: documents printed on paper.
- `slow`
- : The layout may change dynamically according to the usual rules of CSS, but the output device is not able to render or display changes quickly enough for them to be perceived as a smooth animation. Examples: e-book readers or severely underpowered devices.
- `fast`
- : The layout may change dynamically according to the usual rules of CSS, and the output device is not unusually constrained in speed, so regularly-updating things like [CSS Animations](/en-US/docs/Web/CSS/CSS_animations) can be used. Example: computer screens.
## Examples
### HTML
```html
<p>
If this text animates for you, your browser supports `update` and you are
using a fast-updating device.
</p>
```
### CSS
```css
@keyframes jiggle {
from {
transform: translateY(0);
}
to {
transform: translateY(25px);
}
}
@media (update: fast) {
p {
animation: 1s jiggle linear alternate infinite;
}
}
```
### Result
{{EmbedLiveSample("Examples")}}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using Media Queries](/en-US/docs/Web/CSS/CSS_media_queries/Using_media_queries)
- [@media](/en-US/docs/Web/CSS/@media)
| 0 |
data/mdn-content/files/en-us/web/css/@media | data/mdn-content/files/en-us/web/css/@media/color-gamut/index.md | ---
title: color-gamut
slug: Web/CSS/@media/color-gamut
page-type: css-media-feature
browser-compat: css.at-rules.media.color-gamut
---
{{CSSRef}}
The **`color-gamut`** [CSS](/en-US/docs/Web/CSS) [media feature](/en-US/docs/Web/CSS/@media#media_features) is used to apply CSS styles based on the approximate range of color {{glossary("gamut")}} supported by the {{glossary("user agent")}} and the output device.
## Syntax
The `color-gamut` feature is specified as one of the following keyword values:
- `srgb`
- : The user agent and the output device can support approximately the [sRGB](https://en.wikipedia.org/wiki/SRGB) gamut or more. This includes the vast majority of color displays.
- `p3`
- : The user agent and the output device can support approximately the gamut specified by the [Display P3](https://www.color.org/chardata/rgb/DisplayP3.xalter) color space or more. The P3 gamut is larger than and includes the sRGB gamut.
- `rec2020`
- : The user agent and the output device can support approximately the gamut specified by the [ITU-R Recommendation BT.2020](https://en.wikipedia.org/wiki/Rec._2020) color space or more. The REC. 2020 gamut is larger than and includes the P3 gamut.
## Examples
### HTML
```html
<p>This is a test.</p>
```
### CSS
```css
p {
padding: 10px;
border: solid;
}
@media (color-gamut: srgb) {
p {
background: #f4ae8a;
}
}
```
### Result
{{EmbedLiveSample("Examples")}}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [color()](/en-US/docs/Web/CSS/color_value/color) function to specify colors in a defined colorspace.
- [@media](/en-US/docs/Web/CSS/@media) at-rule that is used to specify the color-gamut expression.
- [Using media queries](/en-US/docs/Web/CSS/CSS_media_queries/Using_media_queries) to understand when and how to use a media query.
| 0 |
data/mdn-content/files/en-us/web/css/@media | data/mdn-content/files/en-us/web/css/@media/monochrome/index.md | ---
title: monochrome
slug: Web/CSS/@media/monochrome
page-type: css-media-feature
browser-compat: css.at-rules.media.monochrome
---
{{CSSRef}}
The **`monochrome`** [CSS](/en-US/docs/Web/CSS) [media feature](/en-US/docs/Web/CSS/@media#media_features) can be used to test the number of bits per pixel in the monochrome frame buffer of the output device.
## Syntax
The `monochrome` feature is specified as an {{cssxref("<integer>")}} representing the number of bits per pixel in the monochrome frame buffer. If the device is not a monochrome device, the value is zero. It is a range feature, meaning that you can also use the prefixed **`min-monochrome`** and **`max-monochrome`** variants to query minimum and maximum values, respectively.
## Examples
### HTML
```html
<p class="mono">Your device supports monochrome pixels!</p>
<p class="no-mono">Your device doesn't support monochrome pixels.</p>
```
### CSS
```css
p {
display: none;
}
/* Any monochrome device */
@media (monochrome) {
p.mono {
display: block;
color: #333;
}
}
/* Any non-monochrome device */
@media (monochrome: 0) {
p.no-mono {
display: block;
color: #ee3636;
}
}
```
### Result
{{EmbedLiveSample("Examples")}}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/css/@media | data/mdn-content/files/en-us/web/css/@media/video-dynamic-range/index.md | ---
title: video-dynamic-range
slug: Web/CSS/@media/video-dynamic-range
page-type: css-media-feature
browser-compat: css.at-rules.media.video-dynamic-range
---
{{CSSRef}}
The **`video-dynamic-range`** [CSS](/en-US/docs/Web/CSS) [media feature](/en-US/docs/Web/CSS/@media#media_features) can be used to test the combination of brightness, contrast ratio, and color depth that are supported by the video plane of the {{glossary("user agent")}} and the output device.
Some user agents, including many TVs, render video and graphics in two separate planes (bi-plane) with distinct screen characteristics. The `video-dynamic-range` feature is used to test the characteristics in the video plane.
## Syntax
The `video-dynamic-range` feature is specified as a keyword value chosen from the list below.
- `standard`
- : This value matches any visual device and excludes devices lacking visual capabilities. A user agent or an output device that matches `high` will also match the `standard` value.
- `high`
- : This value matches user agents and output devices that support high peak brightness, high contrast ratio, and color depth greater than 24 bit or 8 bit per color component of RGB. **Peak brightness** refers to how bright the brightest point a light-emitting device, such as an LCD screen, can produce. In the case of a light-reflective device, such as paper or e-ink, peak brightness refers to the point that at least absorbs light. **Contrast ratio** refers to the ratio of the luminance of the brightest color to that of the darkest color that the system is capable of producing. Currently, there is no precise way to measure peak brightness and contrast ratio, and the determination of what counts as high peak brightness and high contrast ratio depends on the user agent.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using Media Queries](/en-US/docs/Web/CSS/CSS_media_queries/Using_media_queries)
- [@media](/en-US/docs/Web/CSS/@media)
| 0 |
data/mdn-content/files/en-us/web/css/@media | data/mdn-content/files/en-us/web/css/@media/device-height/index.md | ---
title: device-height
slug: Web/CSS/@media/device-height
page-type: css-media-feature
status:
- deprecated
browser-compat: css.at-rules.media.device-height
---
{{CSSRef}} {{deprecated_header}}
> **Note:** To query for the height of the viewport, developers should use the [`height`](/en-US/docs/Web/CSS/@media/height) media feature instead.
The **`device-height`** [CSS](/en-US/docs/Web/CSS) [media feature](/en-US/docs/Web/CSS/@media#media_features) can be used to test the height of an output device's rendering surface.
## Syntax
The `device-height` feature is specified as a {{cssxref("<length>")}} value. It is a range feature, meaning that you can also use the prefixed **`min-device-height`** and **`max-device-height`** variants to query minimum and maximum values, respectively.
## Examples
### Applying a special stylesheet for devices that are shorter than 800 pixels
```html
<link
rel="stylesheet"
media="screen and (max-device-height: 799px)"
href="http://foo.bar.com/short-styles.css" />
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using Media Queries](/en-US/docs/Web/CSS/CSS_media_queries/Using_media_queries)
- [@media](/en-US/docs/Web/CSS/@media)
| 0 |
data/mdn-content/files/en-us/web/css/@media | data/mdn-content/files/en-us/web/css/@media/display-mode/index.md | ---
title: display-mode
slug: Web/CSS/@media/display-mode
page-type: css-media-feature
browser-compat: css.at-rules.media.display-mode
---
{{CSSRef}}
The **`display-mode`** [CSS](/en-US/docs/Web/CSS) [media feature](/en-US/docs/Web/CSS/@media#media_features) can be used to test the display mode of an application. You can use it to provide a consistent user experience between launching a site from a URL and launching it from a desktop icon.
This feature corresponds to the Web app manifest's [`display`](/en-US/docs/Web/Manifest#display) member. Both apply to the top-level browsing context and any child browsing contexts. The feature query applies regardless of whether a web app manifest is present.
## Syntax
The `display-mode` feature is specified as a keyword value chosen from the list below.
| Display mode | Description | Fallback display mode |
| ------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------- |
| `fullscreen` | All of the available display area is used and no user agent {{glossary("chrome")}} is shown. | `standalone` |
| `standalone` | The application will look and feel like a standalone application. This can include the application having a different window, its own icon in the application launcher, etc. In this mode, the user agent will exclude UI elements for controlling navigation, but can include other UI elements such as a status bar. | `minimal-ui` |
| `minimal-ui` | The application will look and feel like a standalone application, but will have a minimal set of UI elements for controlling navigation. The elements will vary by browser. | `browser` |
| `browser` | The application opens in a conventional browser tab or new window, depending on the browser and platform. | (none) |
| `window-controls-overlay` | In this mode, the application looks and feels like a standalone desktop application, and the [Window Controls Overlay](/en-US/docs/Web/API/Window_Controls_Overlay_API) feature is enabled. | (none) |
## Examples
### The CSS is used if the device is at fullscreen
```css
@media all and (display-mode: fullscreen) {
body {
margin: 0;
border: 5px solid black;
}
}
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using Media Queries](/en-US/docs/Web/CSS/CSS_media_queries/Using_media_queries)
- [@media](/en-US/docs/Web/CSS/@media)
| 0 |
data/mdn-content/files/en-us/web/css/@media | data/mdn-content/files/en-us/web/css/@media/any-pointer/index.md | ---
title: any-pointer
slug: Web/CSS/@media/any-pointer
page-type: css-media-feature
browser-compat: css.at-rules.media.any-pointer
---
{{CSSRef}}
The **`any-pointer`** [CSS](/en-US/docs/Web/CSS) [media feature](/en-US/docs/Web/CSS/@media#media_features) tests whether the user has _any_ pointing device (such as a mouse), and if so, how accurate it is.
> **Note:** If you want to test the accuracy of the _primary_ pointing device, use [`pointer`](/en-US/docs/Web/CSS/@media/pointer) instead.
## Syntax
The `any-pointer` feature is specified as a keyword value chosen from the list below.
- `none`
- : No pointing device is available.
- `coarse`
- : At least one input mechanism includes a pointing device of limited accuracy.
- `fine`
- : At least one input mechanism includes an accurate pointing device.
> **Note:** More than one value can match if the available devices have different characteristics, although `none` only matches when none of them are pointing devices.
## Examples
This example creates a small checkbox for users with at least one fine pointer and a large checkbox for users with at least one coarse pointer. The big checkbox takes precedence because it is declared after the small one.
### HTML
```html
<input id="test" type="checkbox" /> <label for="test">Look at me!</label>
```
### CSS
```css
input[type="checkbox"]:checked {
background: gray;
}
@media (any-pointer: fine) {
input[type="checkbox"] {
appearance: none;
width: 15px;
height: 15px;
border: 1px solid blue;
}
}
@media (any-pointer: coarse) {
input[type="checkbox"] {
appearance: none;
width: 30px;
height: 30px;
border: 2px solid red;
}
}
```
### Result
{{EmbedLiveSample("Examples")}}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [The `pointer` media feature](/en-US/docs/Web/CSS/@media/pointer)
| 0 |
data/mdn-content/files/en-us/web/css/@media | data/mdn-content/files/en-us/web/css/@media/width/index.md | ---
title: width
slug: Web/CSS/@media/width
page-type: css-media-feature
browser-compat: css.at-rules.media.width
---
{{CSSRef}}
The **`width`** [CSS](/en-US/docs/Web/CSS) [media feature](/en-US/docs/Web/CSS/@media#media_features) can be used to test the width of the {{glossary("viewport")}} (or the page box, for [paged media](/en-US/docs/Web/CSS/CSS_paged_media)).
## Syntax
The `width` feature is specified as a {{cssxref("<length>")}} value representing the viewport width. It is a range feature, meaning that you can also use the prefixed **`min-width`** and **`max-width`** variants to query minimum and maximum values, respectively.
## Examples
### HTML
```html
<div>Watch this element as you resize your viewport's width.</div>
```
### CSS
```css
/* Exact width */
@media (width: 360px) {
div {
color: red;
}
}
/* Minimum width */
@media (min-width: 35rem) {
div {
background: yellow;
}
}
/* Maximum width */
@media (max-width: 50rem) {
div {
border: 2px solid blue;
}
}
```
### Result
{{EmbedLiveSample('Examples','90%')}}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using media queries](/en-US/docs/Web/CSS/CSS_media_queries/Using_media_queries)
- [@media](/en-US/docs/Web/CSS/@media)
| 0 |
data/mdn-content/files/en-us/web/css/@media | data/mdn-content/files/en-us/web/css/@media/hover/index.md | ---
title: hover
slug: Web/CSS/@media/hover
page-type: css-media-feature
browser-compat: css.at-rules.media.hover
---
{{CSSRef}}
The **`hover`** [CSS](/en-US/docs/Web/CSS) [media feature](/en-US/docs/Web/CSS/@media#media_features) can be used to test whether the user's _primary_ input mechanism can hover over elements.
## Syntax
The `hover` feature is specified as a keyword value chosen from the list below.
- `none`
- : The primary input mechanism cannot hover at all or cannot conveniently hover (e.g., many mobile devices emulate hovering when the user performs an inconvenient long tap), or there is no primary pointing input mechanism.
- `hover`
- : The primary input mechanism can conveniently hover over elements.
## Examples
### HTML
```html
<a href="#">Try hovering over me!</a>
```
### CSS
```css
/* default hover effect */
a:hover {
color: black;
background: yellow;
}
@media (hover: hover) {
/* when hover is supported */
a:hover {
color: white;
background: black;
}
}
```
### Result
{{EmbedLiveSample("Examples")}}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using Media Queries](/en-US/docs/Web/CSS/CSS_media_queries/Using_media_queries)
- [@media](/en-US/docs/Web/CSS/@media)
| 0 |
data/mdn-content/files/en-us/web/css/@media | data/mdn-content/files/en-us/web/css/@media/height/index.md | ---
title: height
slug: Web/CSS/@media/height
page-type: css-media-feature
browser-compat: css.at-rules.media.height
---
{{CSSRef}}
The **`height`** [CSS](/en-US/docs/Web/CSS) [media feature](/en-US/docs/Web/CSS/@media#media_features) can be used to apply styles based on the height of the {{glossary("viewport")}} (or the page box, for [paged media](/en-US/docs/Web/CSS/CSS_paged_media)).
## Syntax
The `height` feature is specified as a {{cssxref("<length>")}} value representing the viewport height. It is a range feature, meaning that you can also use the prefixed **`min-height`** and **`max-height`** variants to query minimum and maximum values, respectively.
## Examples
### HTML
```html
<div>Watch this element as you resize your viewport's height.</div>
```
### CSS
```css
/* Exact height */
@media (height: 360px) {
div {
color: red;
}
}
/* Minimum height */
@media (min-height: 25rem) {
div {
background: yellow;
}
}
/* Maximum height */
@media (max-height: 40rem) {
div {
border: 2px solid blue;
}
}
```
### Result
{{EmbedLiveSample('Examples','90%')}}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using media queries](/en-US/docs/Web/CSS/CSS_media_queries/Using_media_queries)
- [@media](/en-US/docs/Web/CSS/@media)
| 0 |
data/mdn-content/files/en-us/web/css/@media | data/mdn-content/files/en-us/web/css/@media/aspect-ratio/index.md | ---
title: aspect-ratio
slug: Web/CSS/@media/aspect-ratio
page-type: css-media-feature
browser-compat: css.at-rules.media.aspect-ratio
---
{{CSSRef}}
The **`aspect-ratio`** [CSS](/en-US/docs/Web/CSS) [media feature](/en-US/docs/Web/CSS/@media#media_features) can be used to test the aspect ratio of the {{glossary("viewport")}}.
## Syntax
The `aspect-ratio` feature is specified as a {{cssxref("<ratio>")}} value representing the width-to-height aspect ratio of the viewport. It is a range feature, meaning you can also use the prefixed **`min-aspect-ratio`** and **`max-aspect-ratio`** variants to query minimum and maximum values, respectively.
## Examples
The example below is contained in an {{htmlElement("iframe")}}, which creates its own viewport. Resize the `<iframe>` to see `aspect-ratio` in action.
Note that, when none of the media query conditions are true, the background will turn white because none of the below rules will be applied to the `<div>` inside the `<iframe>`. See if you can find which width and height values trigger this!
### HTML
```html
<div id="inner">
Watch this element as you resize your viewport's width and height.
</div>
```
### CSS
```css
/* Minimum aspect ratio */
@media (min-aspect-ratio: 8/5) {
div {
background: #9af; /* blue */
}
}
/* Maximum aspect ratio */
@media (max-aspect-ratio: 3/2) {
div {
background: #9ff; /* cyan */
}
}
/* Exact aspect ratio, put it at the bottom to avoid override*/
@media (aspect-ratio: 1/1) {
div {
background: #f9a; /* red */
}
}
```
### Result
```html hidden
<label id="wf" for="w">width:165</label>
<input id="w" name="w" type="range" min="100" max="250" step="5" value="165" />
<label id="hf" for="w">height:165</label>
<input id="h" name="h" type="range" min="100" max="250" step="5" value="165" />
<iframe
id="outer"
srcdoc="<style> @media (min-aspect-ratio: 8/5) { div { background: #9af; } } @media (max-aspect-ratio: 3/2) { div { background: #9ff; } } @media (aspect-ratio: 1/1) { div { background: #f9a; } }</style><div id='inner'> Watch this element as you resize your viewport's width and height.</div>">
</iframe>
```
```css hidden
iframe {
display: block;
}
```
```js hidden
outer.style.width = outer.style.height = "165px";
w.onchange = w.oninput = () => {
outer.style.width = `${w.value}px`;
wf.textContent = `width: ${w.value}`;
};
h.onchange = h.oninput = () => {
outer.style.height = `${h.value}px`;
hf.textContent = `height: ${h.value}`;
};
```
{{ EmbedLiveSample('Result', '300px', '350px') }}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using Media Queries](/en-US/docs/Web/CSS/CSS_media_queries/Using_media_queries)
- [@media](/en-US/docs/Web/CSS/@media)
| 0 |
data/mdn-content/files/en-us/web/css/@media | data/mdn-content/files/en-us/web/css/@media/device-width/index.md | ---
title: device-width
slug: Web/CSS/@media/device-width
page-type: css-media-feature
status:
- deprecated
browser-compat: css.at-rules.media.device-width
---
{{CSSRef}} {{deprecated_header}}
> **Note:** To query for the width of the viewport, developers should use the [`width`](/en-US/docs/Web/CSS/@media/width) media feature instead.
The **`device-width`** [CSS](/en-US/docs/Web/CSS) [media feature](/en-US/docs/Web/CSS/@media#media_features) can be used to test the width of an output device's rendering surface.
## Syntax
The `device-width` feature is specified as a {{cssxref("<length>")}} value. It is a range feature, meaning that you can also use the prefixed **`min-device-width`** and **`max-device-width`** variants to query minimum and maximum values, respectively.
## Examples
### Applying a special stylesheet for devices that are narrower than 800 pixels
```html
<link
rel="stylesheet"
media="screen and (max-device-width: 799px)"
href="http://foo.bar.com/narrow-styles.css" />
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using Media Queries](/en-US/docs/Web/CSS/CSS_media_queries/Using_media_queries)
- [@media](/en-US/docs/Web/CSS/@media)
| 0 |
data/mdn-content/files/en-us/web/css/@media | data/mdn-content/files/en-us/web/css/@media/shape/index.md | ---
title: shape
slug: Web/CSS/@media/shape
page-type: css-media-feature
status:
- experimental
spec-urls: https://drafts.csswg.org/css-round-display/#shape-media-feature
---
{{CSSRef}}{{SeeCompatTable}}
The `shape` [CSS](/en-US/docs/Web/CSS) [media feature](/en-US/docs/Web/CSS/@media#media_features) can be used to test the shape of the device to distinguish rectangular and round displays.
## Syntax
The `shape` discrete feature is specified as one of two acceptable strings, either `rect` representing a rectangular screen or `round` representing a circular, oval or elliptical screen.
- `rect`
- : The shape is an axis aligned rectangle or square, or a similar shape such as rounded rectangle for which the traditional designs are appropriate.
- `round`
- : The shape is rounded or a similar shape to the circle such as an oval, an ellipse for which distinctively rounded designs are appropriate.
## Examples
### Basic example
#### HTML
```html
<h1>Hello World!</h1>
```
#### CSS
```css
h1 {
text-align: left;
}
@media (shape: rect) {
h1 {
text-align: left;
}
}
@media (shape: round) {
h1 {
text-align: center;
}
}
```
### Custom stylesheet
This HTML will apply a special stylesheet for devices that have round screens.
```html
<head>
<link rel="stylesheet" href="default.css" />
<link
media="screen and (shape: rect)"
rel="stylesheet"
href="rectangle.css" />
<link media="screen and (shape: round)" rel="stylesheet" href="round.css" />
</head>
```
## Specifications
{{Specifications}}
## Browser compatibility
There is no browser implementing this feature.
## See also
- [Using Media Queries](/en-US/docs/Web/CSS/CSS_media_queries/Using_media_queries)
- [@media](/en-US/docs/Web/CSS/@media)
| 0 |
data/mdn-content/files/en-us/web/css/@media | data/mdn-content/files/en-us/web/css/@media/inverted-colors/index.md | ---
title: inverted-colors
slug: Web/CSS/@media/inverted-colors
page-type: css-media-feature
browser-compat: css.at-rules.media.inverted-colors
---
{{CSSRef}}
The **`inverted-colors`** [CSS](/en-US/docs/Web/CSS) [media feature](/en-US/docs/Web/CSS/@media#media_features) is used to test if the {{glossary("user agent")}} or the underlying operating system has inverted all colors.
Inversion of colors can have unpleasant side effects, such as shadows turning into highlights, which can reduce the readability of the content. Using this media feature, you can detect if inversion is happening and style the content accordingly while respecting user preference.
## Syntax
```css
/* Keyword value */
@media (inverted-colors: inverted) {
/* styles to apply if inversion of colors is detected */
}
```
The `inverted-colors` feature is specified as one of the following keyword values:
- `none`
- : Indicates that the colors are displayed normally and no inversion of colors has happened. This keyword value evaluates as false.
- `inverted`
- : Indicates that all pixels within the displayed area have been inverted. This keyword value evaluates as true.
## Examples
### Applying styles if color inversion is detected
This example demonstrates the effects of both `inverted-colors` media feature keyword values and when the `inverted-colors` media feature is not supported.
#### HTML
```html
<p>
If color inversion is detected, this text will appear blue on white (the
inverse of yellow on black) along with a line over the text. If no color
inversion is happening, the text will appear red on light gray without the
line over the text.
</p>
<p>
If the text is gray and no overline is present, it means your browser doesn't
support the
<code>inverted-colors</code> media feature.
</p>
```
#### CSS
```css
p {
color: gray;
}
@media (inverted-colors: inverted) {
p {
background: black;
color: yellow;
text-decoration: overline;
}
}
@media (inverted-colors: none) {
p {
background: #eee;
color: red;
}
}
```
#### Result
{{EmbedLiveSample("Applying styles if color inversion is detected")}}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [@media](/en-US/docs/Web/CSS/@media)
- [CSS media queries](/en-US/docs/Web/CSS/CSS_media_queries) module
- [Using media queries](/en-US/docs/Web/CSS/CSS_media_queries/Using_media_queries)
| 0 |
data/mdn-content/files/en-us/web/css/@media | data/mdn-content/files/en-us/web/css/@media/scripting/index.md | ---
title: scripting
slug: Web/CSS/@media/scripting
page-type: css-media-feature
browser-compat: css.at-rules.media.scripting
---
{{CSSRef}}
The **`scripting`** [CSS](/en-US/docs/Web/CSS) [media feature](/en-US/docs/Web/CSS/@media#media_features) can be used to test whether scripting (such as JavaScript) is available.
## Syntax
The `scripting` feature is specified as a keyword value chosen from the list below.
- `none`
- : Scripting is completely unavailable on the current document.
- `initial-only`
- : Scripting is enabled during the initial page load, but not afterwards.
- `enabled`
- : Scripting is supported and active on the current document.
## Examples
### HTML
```html
<p class="script-none">You do not have scripting available. :-(</p>
<p class="script-initial-only">
Your scripting is only enabled during the initial page load. Weird.
</p>
<p class="script-enabled">You have scripting enabled! :-)</p>
```
### CSS
```css
p {
color: lightgray;
}
@media (scripting: none) {
.script-none {
color: red;
}
}
@media (scripting: initial-only) {
.script-initial-only {
color: red;
}
}
@media (scripting: enabled) {
.script-enabled {
color: red;
}
}
```
### Result
{{EmbedLiveSample("Examples")}}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [@media](/en-US/docs/Web/CSS/@media)
- [Using media queries](/en-US/docs/Web/CSS/CSS_media_queries/Using_media_queries)
| 0 |
data/mdn-content/files/en-us/web/css/@media | data/mdn-content/files/en-us/web/css/@media/forced-colors/index.md | ---
title: forced-colors
slug: Web/CSS/@media/forced-colors
page-type: css-media-feature
browser-compat: css.at-rules.media.forced-colors
---
{{CSSRef}}
The **`forced-colors`** [CSS](/en-US/docs/Web/CSS) [media feature](/en-US/docs/Web/CSS/@media#media_features) is used to detect if the {{Glossary("user agent")}} has enabled a forced colors mode where it enforces a user-chosen limited color palette on the page. An example of a forced colors mode is Windows High Contrast mode.
## Syntax
The `forced-colors` media feature indicates whether or not the browser is currently in forced-colors mode.
### Values
- `none`
- : Forced colors mode is not active; the page's colors are not being forced into a limited palette.
- `active`
- : Indicates that forced colors mode is active. The browser provides the color palette to authors through the [CSS system color](/en-US/docs/Web/CSS/system-color) keywords and, if appropriate, triggers the appropriate value of [`prefers-color-scheme`](/en-US/docs/Web/CSS/@media/prefers-color-scheme) so that authors can adapt the page. The browser selects the value for `prefers-color-scheme` based on the lightness of the `Canvas` system color (see the [color adjust spec](https://www.w3.org/TR/css-color-adjust-1/#forced) for more details).
## Usage notes
### Properties affected by forced-color mode
In forced colors mode, the values of the following properties are treated as if they have no author-level values specified. That is, browser-specified values are used instead. The browser-specified values do not affect the style cascade; the values are instead forced by the browser at paint time.
These browser-specified values are selected from the set of system colors — this ensures a consistent contrast for common UI elements for users that have forced colors enabled.
- {{cssxref("color")}}
- {{cssxref("background-color")}}
- {{cssxref("text-decoration-color")}}
- {{cssxref("text-emphasis-color")}}
- {{cssxref("border-color")}}
- {{cssxref("outline-color")}}
- {{cssxref("column-rule-color")}}
- {{cssxref("-webkit-tap-highlight-color")}}
- [SVG fill attribute](/en-US/docs/Web/SVG/Attribute/fill)
- [SVG stroke attribute](/en-US/docs/Web/SVG/Attribute/stroke)
Additionally the following properties have special behavior in forced colors mode:
- {{cssxref("box-shadow")}} is forced to 'none'
- {{cssxref("text-shadow")}} is forced to 'none'
- {{cssxref("background-image")}} is forced to 'none' for values that are not url-based
- {{cssxref("color-scheme")}} is forced to 'light dark'
- {{cssxref("scrollbar-color")}} is forced to 'auto'
The system colors that are forced for the above properties depend on the context of the element. For example the {{cssxref("color")}} property on button element will be forced to `ButtonText`. On normal text it will be forced to `CanvasText`. See the [list of system colors](/en-US/docs/Web/CSS/system-color) for additional details of when each might be appropriate in various UI contexts.
> **Note:** user agents choose system colors based on native element semantics, _not_ on added ARIA roles.
> As an example, adding `role="button"` to a `div` will **not** cause an element's color to be forced to `ButtonText`
In addition to these adjustments, browsers will help ensure text legibility by drawing "backplates" behind text. This is particularly important for preserving contrast when text is placed on top of images.
There are two cases where the user agent does not force the values for the above properties — when a {{cssxref("forced-color-adjust")}} value of `none` is applied to an element, or when a system color is specified by the author.
When forced-color-adjust is set to `none` on an element, none of the forced color values will apply, and author styles will be applied as normal. Additionally, the backplate for text will be disabled.
When a system color is specified, it will be used instead of the value that would otherwise have been forced.
You can also use system colors with any property _other_ than those listed above, to ensure that the rest of the page integrates with the restricted color palette available in forced colors mode.
### Accessibility concerns
In general, web authors should **not** be using the `forced-colors` media feature to create a separate design for users with this feature enabled. Instead, its intended usage is to make small tweaks to improve usability or legibility when the default application of forced colors does not work well for a given portion of a page.
The high contrast provided by forced colors mode's reduced palette and text backplates is often essential for some users to be able to read or use a given website, so adjustments that affect content should be chosen carefully and targeted to content that is otherwise not legible.
### User preferences
This media feature is active only if the user has enabled color scheme preferences in their operating system. One example of such a feature is High Contrast mode on Windows.
## Examples
> **Note:** The below example will only work when using a browser that supports this media feature, and with a preference such as High Contrast mode enabled in your OS.
This example is a button that normally gets its contrast via {{cssxref("box-shadow")}}. Under forced colors mode, box-shadow is forced to none, so the example uses the forced-colors media feature to ensure there is a border of the appropriate color (ButtonText in this case)
### HTML
```html
<button class="button">Press me!</button>
```
### CSS
```css
.button {
border: 0;
padding: 10px;
box-shadow:
-2px -2px 5px gray,
2px 2px 5px gray;
}
@media (forced-colors: active) {
.button {
/* Use a border instead, since box-shadow is forced to 'none' in forced-colors mode */
border: 2px ButtonText solid;
}
}
```
### Result
{{EmbedLiveSample("Examples")}}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [@media](/en-US/docs/Web/CSS/@media)
- [Styling for Windows high contrast with standards for forced colors.](https://blogs.windows.com/msedgedev/2020/09/17/styling-for-windows-high-contrast-with-new-standards-for-forced-colors/)
- {{cssxref("forced-color-adjust")}}
| 0 |
data/mdn-content/files/en-us/web/css/@media | data/mdn-content/files/en-us/web/css/@media/prefers-color-scheme/index.md | ---
title: prefers-color-scheme
slug: Web/CSS/@media/prefers-color-scheme
page-type: css-media-feature
browser-compat: css.at-rules.media.prefers-color-scheme
---
{{CSSRef}}
The **`prefers-color-scheme`** [CSS](/en-US/docs/Web/CSS) [media feature](/en-US/docs/Web/CSS/CSS_media_queries/Using_media_queries#targeting_media_features) is used to detect if a user has requested light or dark color themes.
A user indicates their preference through an operating system setting (e.g. light or dark mode) or a user agent setting.
## Embedded elements
For SVG and iframes, `prefers-color-scheme` lets you set a CSS style for the SVG or iframe based on the [`color-scheme`](/en-US/docs/Web/CSS/color-scheme) of the parent element in the web page.
SVGs must be used embedded (i.e., `<img src="circle.svg" alt="circle" />`) as opposed to [inlined in HTML](/en-US/docs/Web/SVG/Tutorial/SVG_In_HTML_Introduction#basic_example).
An example of using `prefers-color-scheme` in SVGs can be found in the [Color scheme inheritance](#color_scheme_inheritance) section.
Using `prefers-color-scheme` is allowed in [cross-origin](/en-US/docs/Web/Security/Same-origin_policy#cross-origin_network_access) `<svg>` and `<iframe>` elements. Cross-origin elements are elements retrieved from a different host than the page that is referencing them.
To learn more about SVGs, see the [SVG documentation](/en-US/docs/Web/SVG) and for more information about iframes, see the [iframe documentation](/en-US/docs/Web/HTML/Element/iframe).
## Syntax
- `light`
- : Indicates that user has notified that they prefer an interface that has a light theme, or has not expressed an active preference.
- `dark`
- : Indicates that user has notified that they prefer an interface that has a dark theme.
## Examples
### Detecting a dark or light theme
A common usage is to use a light color scheme by default, and then use `prefers-color-scheme: dark` to override the colors to a darker variant. It is also possible to do it the other way around.
This example shows both options: Theme A uses light colors, but can be overridden to dark colors. Theme B uses dark colors, but can be overridden to light colors. In the end, if the browser supports `prefers-color-scheme`, both themes will be light or dark.
#### HTML
```html
<div class="box theme-a">Theme A (initial)</div>
<div class="box theme-a adaptive">Theme A (changed if dark preferred)</div>
<br />
<div class="box theme-b">Theme B (initial)</div>
<div class="box theme-b adaptive">Theme B (changed if light preferred)</div>
```
#### CSS
```css hidden
div.box {
display: inline-block;
padding: 1em;
margin: 6px;
outline: 2px solid #000;
width: 12em;
height: 2em;
vertical-align: middle;
}
```
Theme A (brown) uses a light color scheme by default, but will switch to a dark scheme based on the media query:
```css
.theme-a {
background: #dca;
color: #731;
}
@media (prefers-color-scheme: dark) {
.theme-a.adaptive {
background: #753;
color: #dcb;
outline: 5px dashed #000;
}
}
```
Theme B (blue) uses a dark color scheme by default, but will switch to a light scheme based on the media query:
```css
.theme-b {
background: #447;
color: #bbd;
}
@media (prefers-color-scheme: light) {
.theme-b.adaptive {
background: #bcd;
color: #334;
outline: 5px dotted #000;
}
}
```
#### Result
The left boxes shows Theme A and Theme B as they would appear without the `prefers-color-scheme` media query. The right boxes show the same themes, but one of them will be changed to a darker or lighter variant based on the user's active color scheme. The outline of one box will be dashed or dotted if it was changed based on your browser or operating systems settings.
{{EmbedLiveSample("Detecting_a_dark_or_light_theme")}}
### Color scheme inheritance
The following example shows how to use `prefers-color-scheme` with the [`color-scheme` property](/en-US/docs/Web/CSS/color-scheme) inherited from a parent element.
A script is used to set the source of the `<img>` elements and their `alt` attributes. This would normally be done in HTML as `<img src="circle.svg" alt="circle" />`.
You should see three circles, with one drawn in a different color.
The first circle inherits the `color-scheme` from the OS and can be toggled using the system OS's theme switcher.
The second and third circles inherit the `color-scheme` from the embedding element; the `@media` query allows setting styles of the SVG content based on the parent element's `color-scheme`.
In this case, the parent element with a `color-scheme` CSS property is a `<div>`.
```html
<div>
<img />
</div>
<div style="color-scheme: light">
<img />
</div>
<div style="color-scheme: dark">
<img />
</div>
<!-- Embed an SVG for all <img> elements -->
<script>
for (let img of document.querySelectorAll("img")) {
img.alt = "circle";
img.src =
"data:image/svg+xml;base64," +
btoa(`
<svg width="32" height="32" viewBox="0 0 32 32" xmlns="http://www.w3.org/2000/svg">
<style>
:root { color: blue }
@media (prefers-color-scheme: dark) {
:root { color: purple }
}
</style>
<circle fill="currentColor" cx="16" cy="16" r="16"/>
</svg>
`);
}
</script>
```
{{EmbedLiveSample("Color_scheme_inheritance")}}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{cssxref("color-scheme")}} CSS property
- {{HTTPHeader("Sec-CH-Prefers-Color-Scheme")}} HTTP Header [User Agent Client Hint](/en-US/docs/Web/HTTP/Client_hints#user-agent_client_hints)
- [Simulate prefers-color-scheme in Firefox](https://firefox-source-docs.mozilla.org/devtools-user/page_inspector/how_to/examine_and_edit_css/index.html#view-media-rules-for-prefers-color-scheme) (Firefox Page Inspector > Examine and edit CSS)
- [Video tutorial: Coding a Dark Mode for your Website](https://www.youtube.com/watch?v=jmepqJ5UbuM)
- [Redesigning your product and website for dark mode](https://stuffandnonsense.co.uk/blog/redesigning-your-product-and-website-for-dark-mode)
- Changing color schemes in [Windows](https://blogs.windows.com/windowsexperience/2019/04/01/windows-10-tip-dark-theme-in-file-explorer/), [macOS](https://developer.apple.com/design/human-interface-guidelines/macos/visual-design/dark-mode/), [Android](https://www.theverge.com/2019/5/7/18530599/google-android-q-features-hands-on-dark-mode-gestures-accessibility-io-2019), or [other platforms](https://support.mozilla.org/en-US/questions/1271928).
| 0 |
data/mdn-content/files/en-us/web/css/@media | data/mdn-content/files/en-us/web/css/@media/overflow-block/index.md | ---
title: overflow-block
slug: Web/CSS/@media/overflow-block
page-type: css-media-feature
browser-compat: css.at-rules.media.overflow-block
---
{{CSSRef}}
The **`overflow-block`** [CSS](/en-US/docs/Web/CSS) [media feature](/en-US/docs/Web/CSS/@media#media_features) can be used to test how the output device handles content that overflows the initial [containing block](/en-US/docs/Web/CSS/Containing_block) along the block axis.
## Syntax
The `overflow-block` feature is specified as a keyword value chosen from the list below.
- `none`
- : Content that overflows the block axis is not displayed.
- `scroll`
- : Content that overflows the block axis can be seen by scrolling to it.
- `optional-paged`
- : Content that overflows the block axis can be seen by scrolling to it, but page breaks can be manually triggered (such as via {{cssxref("break-inside")}}, etc.) to cause the following content to display on the following page.
- `paged`
- : Content is broken up into discrete pages; content that overflows one page in the block axis is displayed on the following page.
## Examples
### HTML
```html
<p>
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nullam ac turpis
eleifend, fringilla velit ac, aliquam tellus. Vestibulum ante ipsum primis in
faucibus orci luctus et ultrices posuere cubilia Curae; Nunc velit erat,
tempus id rutrum sed, dapibus ut urna. Integer vehicula nibh a justo imperdiet
rutrum. Nam faucibus pretium orci imperdiet sollicitudin. Nunc id facilisis
dui. Proin elementum et massa et feugiat. Integer rutrum ullamcorper eleifend.
Proin sit amet tincidunt risus. Sed nec augue congue eros accumsan tincidunt
sed eget ex.
</p>
```
### CSS
```css
@media (overflow-block: scroll) {
p {
color: red;
}
}
```
### Result
{{EmbedLiveSample("Examples")}}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using Media Queries](/en-US/docs/Web/CSS/CSS_media_queries/Using_media_queries)
- [@media](/en-US/docs/Web/CSS/@media)
| 0 |
data/mdn-content/files/en-us/web/css/@media | data/mdn-content/files/en-us/web/css/@media/-webkit-transform-3d/index.md | ---
title: "-webkit-transform-3d"
slug: Web/CSS/@media/-webkit-transform-3d
page-type: css-media-feature
browser-compat: css.at-rules.media.-webkit-transform-3d
---
{{CSSRef}}
The **`-webkit-transform-3d`** Boolean [CSS](/en-US/docs/Web/CSS) [media feature](/en-US/docs/Web/CSS/@media#media_features) is a [WebKit extension](/en-US/docs/Web/CSS/WebKit_Extensions) whose value is `true` if vendor-prefixed CSS 3D {{cssxref("transform")}}s are supported.
> **Note:** While this media feature is currently [supported by most browsers](#browser_compatibility). If possible, use an {{cssxref("@supports")}} feature query instead.
## Syntax
`-webkit-transform-3d` is a Boolean [CSS](/en-US/docs/Web/CSS) [media feature](/en-US/docs/Web/CSS/@media#media_features) whose value is `true` if the browser supports `-webkit` prefixed CSS 3D {{cssxref("transform")}}s.
### Values
- `true`
- : The browser supports the 3D CSS transforms with the `-webkit` prefix and supports non-standard, prefixed media queries.
- `false`
- : The 3D CSS transforms prefixed with `-webkit` are not supported by the browser.
## Examples
### Examples of media queries with -webkit-transform-3d
```css
@media (-webkit-transform-3d) {
.foo {
transform-style: preserve-3d;
}
}
```
A better method for checking for browser support is using a feature query:
```css
@supports (transform-style) {
.foo {
transform-style: preserve-3d;
}
}
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{cssxref("@media/-webkit-transform-2d", "-webkit-transform-2d")}}
- {{cssxref("@media/-webkit-transition", "-webkit-transition")}}
- {{cssxref("@media/-webkit-animation", "-webkit-animation")}}
- [Test page at quirksmode.org](https://www.quirksmode.org/css/tests/mediaqueries/animation.html)
- {{cssxref("transform")}} and [using CSS transforms](/en-US/docs/Web/CSS/CSS_transforms/Using_CSS_transforms)
- {{cssxref("@media")}} and [Using media queries](/en-US/docs/Web/CSS/CSS_media_queries/Using_media_queries)
- {{cssxref("@supports")}} and [using feature queries](/en-US/docs/Web/CSS/CSS_conditional_rules/Using_feature_queries)
| 0 |
data/mdn-content/files/en-us/web/css/@media | data/mdn-content/files/en-us/web/css/@media/prefers-reduced-transparency/index.md | ---
title: prefers-reduced-transparency
slug: Web/CSS/@media/prefers-reduced-transparency
page-type: css-media-feature
status:
- experimental
browser-compat: css.at-rules.media.prefers-reduced-transparency
---
{{CSSRef}}{{SeeCompatTable}}
The **`prefers-reduced-transparency`** [CSS](/en-US/docs/Web/CSS) [media feature](/en-US/docs/Web/CSS/CSS_media_queries/Using_media_queries#media_features) is used to detect if a user has enabled a setting on their device to reduce the transparent or translucent layer effects used on the device. Switching on such a setting can help improve contrast and readability for some users.
## Syntax
- `no-preference`
- : Indicates that a user has made no preference known on the device. This keyword value evaluates as false in the boolean context.
- `reduce`
- : Indicates that a user has enabled the setting on their device to minimize the amount of transparent or translucent layer effects.
## User preferences
Various operating systems provide a preference for reducing transparency, and user agents are likely to rely on these system settings.
They may also rely on less explicit signals on platforms which don't offer a specific setting.
- In Windows 10/11: Settings > Personalization > Colors > Transparency effects.
- In macOS: System Preferences > Accessibility > Display > Reduce transparency.
- In iOS: Settings > Accessibility > Display & Text Size > Reduce Transparency.
## Examples
This example has a translucent box by default. If the setting to reduce transparency is enabled in the accessibility preferences on your device, the translucent box becomes more opaque.
### HTML
```html
<div class="translucent">translucent box</div>
```
### CSS
```css
.translucent {
opacity: 0.4;
}
@media (prefers-reduced-transparency) {
.translucent {
opacity: 0.8;
}
}
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- CSS [prefers-reduced-motion](/en-US/docs/Web/CSS/@media/prefers-reduced-motion) media query
- [Using media queries](/en-US/docs/Web/CSS/CSS_media_queries/Using_media_queries)
| 0 |
data/mdn-content/files/en-us/web/css | data/mdn-content/files/en-us/web/css/column-rule-color/index.md | ---
title: column-rule-color
slug: Web/CSS/column-rule-color
page-type: css-property
browser-compat: css.properties.column-rule-color
---
{{CSSRef}}
The **`column-rule-color`** [CSS](/en-US/docs/Web/CSS) property sets the color of the line drawn between columns in a multi-column layout.
{{EmbedInteractiveExample("pages/css/column-rule-color.html")}}
## Syntax
```css
/* <color> values */
column-rule-color: red;
column-rule-color: rgb(192 56 78);
column-rule-color: transparent;
column-rule-color: hsl(0 100% 50% / 60%);
/* Global values */
column-rule-color: inherit;
column-rule-color: initial;
column-rule-color: revert;
column-rule-color: revert-layer;
column-rule-color: unset;
```
The `column-rule-color` property is specified as a single `<color>` value.
### Values
- {{cssxref("<color>")}}
- : The color of the rule that separates columns.
## Formal definition
{{cssinfo}}
## Formal syntax
{{csssyntax}}
## Examples
### Setting a blue column rule
#### HTML
```html
<p>
This is a bunch of text split into three columns. The `column-rule-color`
property is used to change the color of the line that is drawn between
columns. Don't you think that's wonderful?
</p>
```
#### CSS
```css
p {
column-count: 3;
column-rule-style: solid;
column-rule-color: blue;
}
```
#### Result
{{EmbedLiveSample("Setting_a_blue_column_rule")}}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- The {{cssxref("<color>")}} data type
- Other color-related properties: {{cssxref("color")}}, {{cssxref("background-color")}}, {{cssxref("border-color")}}, {{cssxref("outline-color")}}, {{cssxref("text-decoration-color")}}, {{cssxref("text-emphasis-color")}}, {{cssxref("text-shadow")}}, and {{cssxref("caret-color")}}
- [Applying color to HTML elements using CSS](/en-US/docs/Web/CSS/CSS_colors/Applying_color)
| 0 |
data/mdn-content/files/en-us/web/css | data/mdn-content/files/en-us/web/css/css_overscroll_behavior/index.md | ---
title: CSS overscroll behavior
slug: Web/CSS/CSS_overscroll_behavior
page-type: css-module
spec-urls: https://drafts.csswg.org/css-overscroll/
---
{{CSSRef}}
The **CSS overscroll behavior** module provides properties to control the behavior of a {{Glossary("Scroll_container", "scroll container")}} when its scroll position reaches the {{Glossary("Scroll_boundary", "scroll boundary")}}. Controlling this aspect is particularly useful in scenarios where embedded scrollable areas should not trigger scrolling of the parent container.
When commenting on a blog, you might notice that if your comment exceeds the length of the provided {{htmlelement("textarea")}}, scrolling beyond the end of the text area causes the entire blog to scroll. This is because reaching the end of a scrollable area, known as the {{Glossary("Scroll_boundary", "scroll boundary")}}, can lead to scrolling other content or the entire page. This continuous scrolling experience is called {{Glossary("Scroll_chaining", "scroll chaining")}}.
In situations where the contents of an element are larger than its container and {{cssxref("overflow")}} allows or defaults to scrolling (like in `<textarea>`), continued scrolling past the element's scrollable area will initiate scrolling in the parent element or the underlying page.
Conversely, scrolling through a website's terms and conditions and reaching the end of the content to enable a checkbox, may not force the page to scroll or bounce (as on a phone). This example shows that you can control overscroll behavior and prevent scroll chaining.
This module defines the overscroll behavior, enabling you to specify the actions when a user scrolls beyond the boundaries of a scrollable element.
## Reference
### CSS properties
- {{CSSxRef("overscroll-behavior")}} shorthand
- {{CSSxRef("overscroll-behavior-block")}}
- {{CSSxRef("overscroll-behavior-inline")}}
- {{CSSxRef("overscroll-behavior-x")}}
- {{CSSxRef("overscroll-behavior-y")}}
### Glossary terms
- {{Glossary("Scroll_boundary", "Scroll boundary")}}
- {{Glossary("Scroll_chaining", "Scroll chaining")}}
## Guides
- [CSS building blocks: Overflowing content](/en-US/docs/Learn/CSS/Building_blocks/Overflowing_content)
- : Learn what overflow is and how to manage it.
## Related concepts
- [`scrollbar`](/en-US/docs/Web/Accessibility/ARIA/Roles/scrollbar_role) ARIA role
- [Containing block](/en-US/docs/Web/CSS/Containing_block) concept
- [CSS overflow](/en-US/docs/Web/CSS/CSS_overflow) module:
- {{cssxref("overflow")}} shorthand property
- {{Cssxref("overflow-x")}}
- {{Cssxref("overflow-y")}}
- {{CSSxRef("overflow-block")}}
- {{CSSxRef("overflow-inline")}}
- {{CSSxRef("overflow-clip-margin")}} property
- {{CSSxRef("scroll-behavior")}} property
- {{CSSxRef("text-overflow")}} property
- {{Glossary("Scroll_container", "Scroll container")}} and [scrollport](/en-US/docs/Glossary/Scroll_container#scrollport) glossary terms
- [CSS scroll snap](/en-US/docs/Web/CSS/CSS_scroll_snap) module:
- {{cssxref("scroll-padding")}} shorthand property
- {{cssxref("scroll-snap-type")}} property
- {{cssxref("scroll-margin")}} shorthand property
- {{cssxref("scroll-snap-stop")}} property
- {{cssxref("scroll-snap-align")}} property
- [CSSOM view](/en-US/docs/Web/CSS/CSSOM_view) module:
- {{domxref("Element.getBoundingClientRect()")}} method
- {{domxref("Element.scroll()")}} method
- {{domxref("Element.scrollBy()")}} method
- {{domxref("Element.scrollIntoView()")}} method
- {{domxref("Element.scrollTo()")}} method
- {{domxref("Document.scroll_event", "scroll")}} Document event
## Specifications
{{Specifications}}
## See also
- [CSS box model](/en-US/docs/Web/CSS/CSS_box_model) module
- [CSS logical properties and values](/en-US/docs/Web/CSS/CSS_logical_properties_and_values) module
- [CSS scroll snap](/en-US/docs/Web/CSS/CSS_scroll_snap) module
- [Take control of your scroll - customizing pull-to-refresh and overflow effects](https://developer.chrome.com/blog/overscroll-behavior) on developer.chrome.com (2017)
| 0 |
data/mdn-content/files/en-us/web/css | data/mdn-content/files/en-us/web/css/_colon_first-of-type/index.md | ---
title: ":first-of-type"
slug: Web/CSS/:first-of-type
page-type: css-pseudo-class
browser-compat: css.selectors.first-of-type
---
{{CSSRef}}
The **`:first-of-type`** [CSS](/en-US/docs/Web/CSS) [pseudo-class](/en-US/docs/Web/CSS/Pseudo-classes) represents the first element of its type among a group of sibling elements.
{{EmbedInteractiveExample("pages/tabbed/pseudo-class-first-of-type.html", "tabbed-shorter")}}
## Syntax
```css
:first-of-type {
/* ... */
}
```
## Examples
### Styling the first paragraph
#### HTML
```html
<h2>Heading</h2>
<p>Paragraph 1</p>
<p>Paragraph 2</p>
```
#### CSS
```css
p:first-of-type {
color: red;
font-style: italic;
}
```
#### Result
{{EmbedLiveSample('Styling_the_first_paragraph')}}
### Nested elements
This example shows how nested elements can also be targeted. Note that the [universal selector](/en-US/docs/Web/CSS/Universal_selectors) (`*`) is implied when no type selector is written.
#### HTML
```html
<article>
<div>This `div` is first!</div>
<div>This <span>nested `span` is first</span>!</div>
<div>
This <em>nested `em` is first</em>, but this <em>nested `em` is last</em>!
</div>
<div>This <span>nested `span` gets styled</span>!</div>
<p>This `p` qualifies!</p>
<div>This is the final `div`.</div>
</article>
```
#### CSS
```css
article :first-of-type {
background-color: pink;
}
```
#### Result
{{EmbedLiveSample('Nested_elements', 500)}}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{Cssxref(":first-child")}}, {{Cssxref(":last-of-type")}}, {{Cssxref(":nth-of-type")}}
| 0 |
data/mdn-content/files/en-us/web/css | data/mdn-content/files/en-us/web/css/border-inline-start-style/index.md | ---
title: border-inline-start-style
slug: Web/CSS/border-inline-start-style
page-type: css-property
browser-compat: css.properties.border-inline-start-style
---
{{CSSRef}}
The **`border-inline-start-style`** [CSS](/en-US/docs/Web/CSS) property defines the style of the logical inline start border of an element, which maps to a physical border style depending on the element's writing mode, directionality, and text orientation. It corresponds to the {{cssxref("border-top-style")}}, {{cssxref("border-right-style")}}, {{cssxref("border-bottom-style")}}, or {{cssxref("border-left-style")}} property depending on the values defined for {{cssxref("writing-mode")}}, {{cssxref("direction")}}, and {{cssxref("text-orientation")}}.
{{EmbedInteractiveExample("pages/css/border-inline-start-style.html")}}
## Syntax
```css
/* <'border-style'> values */
border-inline-start-style: dashed;
border-inline-start-style: dotted;
border-inline-start-style: groove;
/* Global values */
border-inline-start-style: inherit;
border-inline-start-style: initial;
border-inline-start-style: revert;
border-inline-start-style: revert-layer;
border-inline-start-style: unset;
```
Related properties are {{cssxref("border-block-start-style")}}, {{cssxref("border-block-end-style")}}, and {{cssxref("border-inline-end-style")}}, which define the other border styles of the element.
### Values
- `<'border-style'>`
- : The line style of the border. See {{ cssxref("border-style") }}.
## Formal definition
{{CSSInfo}}
## Formal syntax
{{csssyntax}}
## Examples
### HTML
```html
<div>
<p class="exampleText">Example text</p>
</div>
```
### CSS
```css
div {
background-color: yellow;
width: 120px;
height: 120px;
}
.exampleText {
writing-mode: vertical-lr;
border: 5px solid blue;
border-inline-start-style: dashed;
}
```
{{EmbedLiveSample("Examples", 140, 140)}}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [CSS Logical Properties and Values](/en-US/docs/Web/CSS/CSS_logical_properties_and_values)
- This property maps to one of the physical border properties: {{cssxref("border-top-style")}}, {{cssxref("border-right-style")}}, {{cssxref("border-bottom-style")}}, or {{cssxref("border-left-style")}}.
- {{cssxref("writing-mode")}}, {{cssxref("direction")}}, {{cssxref("text-orientation")}}
| 0 |
data/mdn-content/files/en-us/web/css | data/mdn-content/files/en-us/web/css/_colon_user-invalid/index.md | ---
title: ":user-invalid"
slug: Web/CSS/:user-invalid
page-type: css-pseudo-class
browser-compat: css.selectors.user-invalid
---
{{CSSRef}}
The **`:user-invalid`** CSS [pseudo-class](/en-US/docs/Web/CSS/Pseudo-classes) represents any validated form element whose value isn't valid based on their [validation constraints](/en-US/docs/Learn/Forms#constraint_validation), after the user has interacted with it.
The `:user-invalid` pseudo-class must match an {{CSSxRef(":invalid")}}, {{CSSxRef(":out-of-range")}}, or blank-but {{CSSxRef(":required")}} element between the time the user has attempted to submit the form and before the user has interacted again with the form element.
## Syntax
```css
:user-invalid {
/* ... */
}
```
## Examples
### Setting a color and symbol on :user-invalid
In the following example, the red border and ❌ only display once the user has interacted with the field.
Try typing something other than an email address to see it in action.
```html
<form>
<label for="email">Email *: </label>
<input id="email" name="email" type="email" required />
<span></span>
</form>
```
```css
input:user-invalid {
border: 2px solid red;
}
input:user-invalid + span::before {
content: "✖";
color: red;
}
```
{{EmbedLiveSample("Setting_a_color_and_symbol_on_user-invalid", 140, 100)}}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{CSSxRef(":valid")}}
- {{CSSxRef(":invalid")}}
- {{CSSxRef(":required")}}
- {{CSSxRef(":optional")}}
- {{CSSxRef(":user-valid")}}
| 0 |
data/mdn-content/files/en-us/web | data/mdn-content/files/en-us/web/demos/index.md | ---
title: Demos of open web technologies
slug: Web/Demos
page-type: landing-page
---
Mozilla supports a wide variety of exciting open web technologies, and we encourage their use. This page offers links to interesting demonstrations of these technologies.
If you know of a good demonstration or application of open web technology, please add a link to the appropriate section here.
## 2D Graphics
### Canvas
- [Blob Sallad: an interactive blob using JavaScript and canvas](https://www.blobsallad.se/) ([code demos)](https://web.archive.org/web/20190807191003/https://blobsallad.se/article/)
- [miniPaint: Image editor](https://viliusle.github.io/miniPaint/) ([source code](https://github.com/viliusle/miniPaint))
- [Zen Photon Garden](https://zenphoton.com) ([source code](https://github.com/billyoc/zenphoton))
- [Multi touch in canvas demo](https://maximumroulette.com/) ([source code](https://github.com/zlatnaspirala/multi-touch-canvas-handler))
### SVG
- [Bubblemenu](https://starkravingfinkle.org/projects/demo/svg-bubblemenu-in-html.xml) (visual effects and interaction)
- [Blobular](https://www.themaninblue.com/experiment/Blobular/) (interactive)
- [Summer HTML image map creator](https://summerstyle.github.io/summer/) ([source code](https://github.com/summerstyle/summer))
### Video
- [Video 3D Animation "mozilla constantly evolving"](https://vimeo.com/172328210)
- [Video 3D Animation "Floating Dance"](https://vimeo.com/173851395)
- [Video 3D Animation "The Gravel Institute: Monopoly](https://vimeo.com/560300715)
## 3D Graphics
### WebGL
- [Web Audio Fireworks](https://ondras.github.io/fireworks-webgl/)
- [Aquarium](https://webglsamples.org/aquarium/aquarium.html)
- [Dynamic cubemap](https://webglsamples.org/dynamic-cubemap/dynamic-cubemap.html)
- [Kai 'Opua](https://collinhover.github.io/kaiopua/) ([source code](https://github.com/collinhover/kaiopua))
### Virtual Reality
- The Polar Sea ([source code](https://github.com/MozillaReality/polarsea))
- [Sechelt fly-through](https://mozvr.github.io/sechelt/) ([source code](https://github.com/MozillaReality/sechelt))
## CSS
- [CSS floating logo "mozilla"](https://codepen.io/SoftwareRVGdesignS/pen/OXZOWj)
- [CSS Blockout](https://ondras.github.io/blockout/)
- [Rubik's cube](https://ondras.github.io/rubik/)
- [Loader with blend modes](https://codepen.io/equinusocio/full/qjyXPP/)
- [CSS-based single page application](https://dmytsv.github.io/sass-spa/index.html#home) ([source code](https://github.com/dmytsv/sass-spa))
### Transformations
- [Impress.js](https://impress.js.org/) ([source code](https://github.com/impress/impress.js))
- [Flickr Polaroid Stack](https://ohiodave.com/tests/css2d/flickr.html)
## Games
- IoQuake3 ([source code](https://github.com/klaussilveira/ioquake3.js))
- [Kai 'Opua](https://collinhover.github.io/kaiopua/) ([source code](https://github.com/collinhover/kaiopua))
## Web APIs
### Notifications API
- [HTML Notifications](https://elfoxero.github.io/html5notifications/) ([source code](https://github.com/elfoxero/html5notifications))
### Web Audio API
- [Audio Context states demo](https://mdn.github.io/webaudio-examples/audiocontext-states/)
- [Audio analyser - graphical visualization of an audio signal](https://mdn.github.io/webaudio-examples/audio-analyser/)
- [IIR filter node](https://mdn.github.io/webaudio-examples/iirfilter-node/)
- [Multi track](https://mdn.github.io/webaudio-examples/multi-track/)
- [Stereo-panner-node](https://mdn.github.io/webaudio-examples/stereo-panner-node/)
### File API
- [Slide My Text - presentation from plain text files](https://palerdot.in/slide-my-text/)
### Web Workers
- [Web Worker Fractals](https://ondras.github.io/fractal/)
- [Photo editor](https://ondras.github.io/photo/)
- [Coral generator](https://ondras.github.io/coral/)
- [Raytracer](https://nerget.com/rayjs-mt/rayjs.html)
- [Fibonacci](https://mdn.github.io/dom-examples/web-workers/fibonacci-worker/)
| 0 |
data/mdn-content/files/en-us/web | data/mdn-content/files/en-us/web/exslt/index.md | ---
title: EXSLT
slug: Web/EXSLT
page-type: landing-page
---
EXSLT is a set of extensions to [XSLT](/en-US/docs/Web/XSLT). There are a number of modules; those that are supported by Firefox are listed below:
{{SubpagesWithSummaries}}
## EXSLT modules
To use an EXSLT function, you need to declare the namespace the function is in, and then use the appropriate prefix when calling the function. For example, to use the regular expressions package:
```xml
<xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:regexp="http://exslt.org/regular-expressions">
<xsl:template match="/">
…
<xsl:value-of select="regexp:replace(/root/@value, 'before', 'gi', 'AFTER')"/>
…
</xsl:template>
</xsl:stylesheet>
```
### Common
The EXSLT Common package provides basic functions that expand upon the capabilities of XSLT. The namespace for the Common package is `http://exslt.org/common`.
#### Functions
- [`exsl:node-set()`](/en-US/docs/Web/EXSLT/exsl/node-set)
- [`exsl:object-type()`](/en-US/docs/Web/EXSLT/exsl/object-type)
### Math
The EXSLT Math package provides functions for working with numeric values and comparing nodes. The namespace for the Math package is `http://exslt.org/math`.
#### Functions
- [`math:highest()`](/en-US/docs/Web/EXSLT/math/highest)
- [`math:lowest()`](/en-US/docs/Web/EXSLT/math/lowest)
- [`math:max()`](/en-US/docs/Web/EXSLT/math/max)
- [`math:min()`](/en-US/docs/Web/EXSLT/math/min)
### Regular expressions
The EXSLT Regular Expressions package provides functions that allow testing, matching, and replacing text using JavaScript style regular expressions.
The EXSLT Regular Expressions namespace is `http://exslt.org/regular-expressions`.
#### Functions
- [`regexp:match()`](/en-US/docs/Web/EXSLT/regexp/match)
- [`regexp:replace()`](/en-US/docs/Web/EXSLT/regexp/replace)
- [`regexp:test()`](/en-US/docs/Web/EXSLT/regexp/test)
### Sets
The EXSLT Sets package offers functions that let you perform set manipulation. The namespace for these functions is `http://exslt.org/sets`.
#### Functions
- [`set:difference()`](/en-US/docs/Web/EXSLT/set/difference)
- [`set:distinct()`](/en-US/docs/Web/EXSLT/set/distinct)
- [`set:intersection()`](/en-US/docs/Web/EXSLT/set/intersection)
- [`set:has-same-node()`](/en-US/docs/Web/EXSLT/set/has-same-node)
- [`set:leading()`](/en-US/docs/Web/EXSLT/set/leading)
- [`set:trailing()`](/en-US/docs/Web/EXSLT/set/trailing)
### Strings
The EXSLT Strings package provides functions that allow the manipulation of strings. The namespace for the Strings package is `http://exslt.org/strings`.
#### Functions
- [`str:concat()`](/en-US/docs/Web/EXSLT/str/concat)
- [`str:split()`](/en-US/docs/Web/EXSLT/str/split)
- [`str:tokenize()`](/en-US/docs/Web/EXSLT/str/tokenize)
## See also
- [EXSLT website](https://exslt.github.io/)
<section id="Quick_links">
<ol>
<li><strong><a href="/en-US/docs/Web/XSLT">XSLT</a></strong></li>
<li><strong><a href="/en-US/docs/Web/XPath">XPath</a></strong></li>
<li><strong><a href="/en-US/docs/Web/EXSLT">EXSLT</a></strong></li>
<li class="toggle">
<details open>
<summary><a href="/en-US/docs/Web/EXSLT/exsl">Common (exsl)</a></summary>
{{ListSubpagesForSidebar("/en-US/docs/Web/EXSLT/exsl", "", "", "exsl:", ")")}}
</details>
</li>
<li class="toggle">
<details open>
<summary><a href="/en-US/docs/Web/EXSLT/math">Math (math)</a></summary>
{{ListSubpagesForSidebar("/en-US/docs/Web/EXSLT/math", "", "", "math:", ")")}}
</details>
</li>
<li class="toggle">
<details open>
<summary><a href="/en-US/docs/Web/EXSLT/regexp">Regular expressions (regexp)</a></summary>
{{ListSubpagesForSidebar("/en-US/docs/Web/EXSLT/regexp", "", "", "regexp:", ")")}}
</details>
</li>
<li class="toggle">
<details open>
<summary><a href="/en-US/docs/Web/EXSLT/set">Sets (set)</a></summary>
{{ListSubpagesForSidebar("/en-US/docs/Web/EXSLT/set", "", "", "set:", ")")}}
</details>
</li>
<li class="toggle">
<details open>
<summary><a href="/en-US/docs/Web/EXSLT/str">Strings (str)</a></summary>
{{ListSubpagesForSidebar("/en-US/docs/Web/EXSLT/str", "", "", "str:", ")")}}
</details>
</li>
</ol>
</section>
| 0 |
data/mdn-content/files/en-us/web/exslt | data/mdn-content/files/en-us/web/exslt/set/index.md | ---
title: Sets (set)
slug: Web/EXSLT/set
page-type: landing-page
---
{{XSLTRef}}{{QuickLinksWithSubpages("/en-US/docs/Web/EXSLT")}}
The EXSLT Sets package offers functions that let you perform set manipulation. The namespace for these functions is `http://exslt.org/sets`.
{{SubpagesWithSummaries}}
| 0 |
data/mdn-content/files/en-us/web/exslt/set | data/mdn-content/files/en-us/web/exslt/set/trailing/index.md | ---
title: set:trailing()
slug: Web/EXSLT/set/trailing
page-type: exslt-function
---
{{XSLTRef}}{{QuickLinksWithSubpages("/en-US/docs/Web/EXSLT")}}
`set:trailing()` returns the nodes in one node-set that come after the first node in the other node-set.
## Syntax
```plain
set:trailing(nodeSet1, nodeSet2)
```
### Parameters
- `nodeSet1`
- : The node set to find nodes in that follow the first node in the second node set.
- `nodeSet2`
- : The node set to compare against.
### Returns
A node-set containing the nodes from `nodeSet1` whose values follow the first node in `nodeSet2`.
> **Note:** If the first node in `nodeSet2` isn't contained in `nodeSet1`, an empty set is returned. If `nodeSet2` is empty, then the result is `nodeSet1`.
## Specifications
[EXSLT - SET:TRAILING](https://exslt.github.io/set/functions/trailing/index.html)
| 0 |
data/mdn-content/files/en-us/web/exslt/set | data/mdn-content/files/en-us/web/exslt/set/intersection/index.md | ---
title: set:intersection()
slug: Web/EXSLT/set/intersection
page-type: exslt-function
---
{{XSLTRef}}{{QuickLinksWithSubpages("/en-US/docs/Web/EXSLT")}}
`set:intersection()` returns the intersection of two node-sets. In other words, it returns a node-set containing all the nodes that exist in both `nodeSet1` and `nodeSet2`.
## Syntax
```plain
set:intersection(nodeSet1, nodeSet2)
```
### Arguments
- `nodeSet1`
- : The first node-set.
- `nodeSet2`
- : The second node-set.
### Returns
A node-set containing the nodes that existed in both `nodeSet1` and in `nodeSet2`.
## Specifications
[EXSLT - SET:INTERSECTION](https://exslt.github.io/set/functions/intersection/index.html)
| 0 |
data/mdn-content/files/en-us/web/exslt/set | data/mdn-content/files/en-us/web/exslt/set/has-same-node/index.md | ---
title: set:has-same-node()
slug: Web/EXSLT/set/has-same-node
page-type: exslt-function
---
{{XSLTRef}}{{QuickLinksWithSubpages("/en-US/docs/Web/EXSLT")}}
`set:has-same-node()` determines whether two node-sets have any nodes in common.
## Syntax
```plain
set:has-same-node(nodeSet1, nodeSet2)
```
### Parameters
- `nodeSet1`
- : The first node set to check.
- `nodeSet2`
- : The second node set to check.
### Returns
`true` if the two node-sets have any nodes in common; otherwise `false`.
## Specifications
[EXSLT - SET:HAS-SAME-NODE](https://exslt.github.io/set/functions/has-same-node/index.html)
| 0 |
data/mdn-content/files/en-us/web/exslt/set | data/mdn-content/files/en-us/web/exslt/set/leading/index.md | ---
title: set:leading()
slug: Web/EXSLT/set/leading
page-type: exslt-function
---
{{XSLTRef}}{{QuickLinksWithSubpages("/en-US/docs/Web/EXSLT")}}
`set:leading()` returns the nodes in one node-set that come before the first node in the other node-set.
## Syntax
```js-nolint
set:leading(nodeSet1, nodeSet2)
```
### Parameters
- `nodeSet1`
- : The node set to find nodes in that precede the first node in the second node set.
- `nodeSet2`
- : The node set to compare against.
### Returns
A node-set containing the nodes from `nodeSet1` whose values precede the first node in `nodeSet2`.
> **Note:** If the first node in `nodeSet2` isn't contained in `nodeSet1`, an empty set is returned. If `nodeSet2` is empty, then the result is `nodeSet1`.
## Specifications
[EXSLT - SET:LEADING](https://exslt.github.io/set/functions/leading/index.html)
| 0 |
data/mdn-content/files/en-us/web/exslt/set | data/mdn-content/files/en-us/web/exslt/set/distinct/index.md | ---
title: set:distinct()
slug: Web/EXSLT/set/distinct
page-type: exslt-function
---
{{XSLTRef}}{{QuickLinksWithSubpages("/en-US/docs/Web/EXSLT")}}
`set:distinct()` returns a subset of the nodes in the specified node-set, returning only nodes with unique string values.
## Syntax
```plain
set:distinct(nodeSet)
```
### Parameters
- `nodeSet`
- : The node-set in which to find unique nodes.
### Returns
A node-set containing the nodes that have unique string values.
## Specifications
[EXSLT - SET:DISTINCT](https://exslt.github.io/set/functions/distinct/index.html)
| 0 |
data/mdn-content/files/en-us/web/exslt/set | data/mdn-content/files/en-us/web/exslt/set/difference/index.md | ---
title: set:difference()
slug: Web/EXSLT/set/difference
page-type: exslt-function
---
{{XSLTRef}}{{QuickLinksWithSubpages("/en-US/docs/Web/EXSLT")}}
`set:difference()` returns the difference between two node-sets. In other words, it returns a node-set whose nodes are in one node-set but not in the other.
The template version of `set:difference` applies templates to these nodes in `set:difference` mode, copying the nodes so that a result tree fragment consisting of the nodes is returned.
## Syntax
```plain
set:difference(nodeSet1, nodeSet2)
```
### Parameters
- `nodeSet1`
- : The node-set from which to subtract nodes.
- `nodeSet2`
- : The set of nodes to subtract from `nodeSet1`.
### Returns
A node-set containing the nodes that are in `nodeSet1` but not in `nodeSet2`.
## Specifications
[EXSLT - SET:DIFFERENCE](https://exslt.github.io/set/functions/difference/index.html)
| 0 |
data/mdn-content/files/en-us/web/exslt | data/mdn-content/files/en-us/web/exslt/str/index.md | ---
title: Strings (str)
slug: Web/EXSLT/str
page-type: landing-page
---
{{XSLTRef}}{{QuickLinksWithSubpages("/en-US/docs/Web/EXSLT")}}
The EXSLT Strings package provides functions that allow the manipulation of strings. The namespace for the Strings package is `http://exslt.org/strings`.
{{SubpagesWithSummaries}}
| 0 |
data/mdn-content/files/en-us/web/exslt/str | data/mdn-content/files/en-us/web/exslt/str/split/index.md | ---
title: str:split()
slug: Web/EXSLT/str/split
page-type: exslt-function
---
{{XSLTRef}}{{QuickLinksWithSubpages("/en-US/docs/Web/EXSLT")}}
`str:split()` splits a string using a pattern string to determine where the splits should occur, returning a node-set containing the resulting strings.
## Syntax
```plain
str:split(string, pattern)
```
### Parameters
- `string`
- : The string to split.
- `pattern`
- : The pattern indicating where to split the string.
### Returns
A node-set of `token` elements, each containing one token from the `string`.
## Example
```plain
str:split('book, phone, computer, chair', ', ')
```
Returns a node set like:
```xml
<token>book</token>
<token>phone</token>
<token>computer</token>
<token>chair</token>
```
## Specifications
[EXSLT - STR:SPLIT](https://exslt.github.io/str/functions/split/index.html)
## See also
- [`str:tokenize()`](/en-US/docs/Web/EXSLT/str/tokenize)
| 0 |
data/mdn-content/files/en-us/web/exslt/str | data/mdn-content/files/en-us/web/exslt/str/tokenize/index.md | ---
title: str:tokenize()
slug: Web/EXSLT/str/tokenize
page-type: exslt-function
---
{{XSLTRef}}{{QuickLinksWithSubpages("/en-US/docs/Web/EXSLT")}}
`str:tokenize()` splits a string using a set of characters as delimiters that determine where the splits should occur, returning a node-set containing the resulting strings.
## Syntax
```plain
str:tokenize(string, delimiters)
```
### Parameters
- `string`
- : The string to tokenize.
- `delimiters`
- : Each character in this string is used as a word separator while tokenizing.
### Returns
A node-set of `token` elements, each containing one token from the `string`.
## Example
```plain
str:tokenize('2007-09-14-03T11:40:23', '-T:')
```
Returns a node set like this:
```xml
<token>2007</token>
<token>09</token>
<token>14</token>
<token>11</token>
<token>40</token>
<token>23</token>
```
## Specifications
[EXSLT - STR:TOKENIZE](https://exslt.github.io/str/functions/tokenize/index.html)
## See also
- [`str:split()`](/en-US/docs/Web/EXSLT/str/split)
| 0 |
data/mdn-content/files/en-us/web/exslt/str | data/mdn-content/files/en-us/web/exslt/str/concat/index.md | ---
title: str:concat()
slug: Web/EXSLT/str/concat
page-type: exslt-function
---
{{XSLTRef}}{{QuickLinksWithSubpages("/en-US/docs/Web/EXSLT")}}
`str:concat()` returns a string containing all the string values in a node-set concatenated together.
## Syntax
```plain
str:concat(nodeSet)
```
### Parameters
- `nodeSet`
- : The node-set whose nodes' string values should be concatenated into one string.
### Returns
A string whose value is all the string values of the nodes in `nodeSet` concatenated together. If `nodeSet` is empty, an empty string is returned.
## Specifications
[EXSLT - STR:CONCAT](https://exslt.github.io/str/functions/concat/index.html)
| 0 |
data/mdn-content/files/en-us/web/exslt | data/mdn-content/files/en-us/web/exslt/exsl/index.md | ---
title: Common (exsl)
slug: Web/EXSLT/exsl
page-type: landing-page
---
{{XSLTRef}}{{QuickLinksWithSubpages("/en-US/docs/Web/EXSLT")}}
The EXSLT Common package provides basic functions that expand upon the capabilities of XSLT. The namespace for the Common package is `http://exslt.org/common`.
{{SubpagesWithSummaries}}
| 0 |
data/mdn-content/files/en-us/web/exslt/exsl | data/mdn-content/files/en-us/web/exslt/exsl/node-set/index.md | ---
title: exsl:node-set()
slug: Web/EXSLT/exsl/node-set
page-type: exslt-function
---
{{XSLTRef}}{{QuickLinksWithSubpages("/en-US/docs/Web/EXSLT")}}
`exsl:node-set()` returns a node-set from a result tree fragment, which is what you get when you look at the `xsl:variable` instead of its select attribute to fetch a variable's value. This lets you process the XML created within a variable to process it in multiple steps.
You can also use `exsl:node-set()` to turn strings into text nodes.
## Syntax
```plain
exsl:node-set(object)
```
### Parameters
- `object`
- : The object for which to return the corresponding node-set.
### Returns
The node-set corresponding to the specified `object`.
## Specifications
[EXSLT - EXSL:NODE-SET](https://exslt.github.io/exsl/functions/node-set/index.html)
| 0 |
data/mdn-content/files/en-us/web/exslt/exsl | data/mdn-content/files/en-us/web/exslt/exsl/object-type/index.md | ---
title: exsl:object-type()
slug: Web/EXSLT/exsl/object-type
page-type: exslt-function
---
{{XSLTRef}}{{QuickLinksWithSubpages("/en-US/docs/Web/EXSLT")}}
`exsl:object-type()` returns a string that indicates the type of the specified object.
> **Note:** Most [XSLT](/en-US/docs/Web/XSLT) object types can be coerced into each other safely; however, certain coercions to raise error conditions. In particular, treating something that's not a node-set as a node-set will do so. This function lets authors of named templates and extension functions easily provide flexibility in parameter values.
## Syntax
```plain
exsl:object-type(object)
```
### Parameters
- `object`
- : The object whose type is to be returned.
### Returns
The object's type, which will be one of the following:
- `string`
- `number`
- `boolean`
- `node-set`
- `RTF`
- `external`
## Specifications
[EXSLT - EXSL:OBJECT-TYPE](https://exslt.github.io/exsl/functions/object-type/index.html)
| 0 |
data/mdn-content/files/en-us/web/exslt | data/mdn-content/files/en-us/web/exslt/regexp/index.md | ---
title: Regular expressions (regexp)
slug: Web/EXSLT/regexp
page-type: landing-page
---
{{XSLTRef}}{{QuickLinksWithSubpages("/en-US/docs/Web/EXSLT")}}
The EXSLT Regular Expressions package provides functions that allow testing, matching, and replacing text using JavaScript style regular expressions. The namespace for the Regular Expressions package is `http://exslt.org/regular-expressions`.
{{SubpagesWithSummaries}}
| 0 |
data/mdn-content/files/en-us/web/exslt/regexp | data/mdn-content/files/en-us/web/exslt/regexp/test/index.md | ---
title: regexp:test()
slug: Web/EXSLT/regexp/test
page-type: exslt-function
---
{{XSLTRef}}{{QuickLinksWithSubpages("/en-US/docs/Web/EXSLT")}}
`regexp:test()` tests to see whether a string matches a specified regular expression.
## Syntax
```js-nolint
regexp:test(testString, regExpString[, flagsString])
```
### Parameters
- `testString`
- : The string to test.
- `regExpString`
- : The JavaScript style regular expression to evaluate.
- `flagsString` {{optional_inline}}
- : An optional string containing character flags.
The character flags are:
- `g`
- : Global match. Has no effect for this function; it's allowed for consistency with other regexp functions.
- `i`
- : Case insensitive match<. If this flag is specified, the match is performed in a case insensitive fashion.
### Returns
`true` if the specified regexp matches the test string.
## Specifications
[EXSLT - REGEXP:TEST](https://exslt.github.io/regexp/functions/test/index.html)
| 0 |
data/mdn-content/files/en-us/web/exslt/regexp | data/mdn-content/files/en-us/web/exslt/regexp/match/index.md | ---
title: regexp:match()
slug: Web/EXSLT/regexp/match
page-type: exslt-function
---
{{XSLTRef}}{{QuickLinksWithSubpages("/en-US/docs/Web/EXSLT")}}
`regexp:match()` performs regular expression matching on a string, returning the submatches found as a result.
## Syntax
```js-nolint
regexp:match(targetString, regExpString[, flagsString])
```
### Parameters
- `targetString`
- : The string to perform regular expression matching upon.
- `regExpString`
- : The JavaScript style regular expression to evaluate.
- `flagsString` {{optional_inline}}
- : An optional string containing character flags.
The character flags are:
- `g`
- : Global match. The submatches from every match in the string are returned. If this flag isn't specified, only the submatches from the first match are returned.
- `i`
- : Case insensitive match. If this flag is specified, the match is performed in a case insensitive fashion.
### Returns
A node set of `match` elements, each of which has the string value equal to a portion of the first parameter string as captured by the regular expression. If the match isn't a global one, the first match element has the value of the portion of the string matched by the entire regular expression.
For example:
```xml
<xsl:for-each select="regExp:match('https://developer.mozilla.org/en/docs/Firefox_3_for_developers',
'(\w+):\/\/([^/:]+)(:\d*)?([^# ]*)')">
Part <xsl:value-of select="position()" /> = <xsl:value-of select="." />
</xsl:for-each>
```
This code generates the following output:
```plain
Part 1 = https://developer.mozilla.org/en/docs/Firefox_3_for_developers
Part 2 = https
Part 3 = developer.mozilla.org
Part 4 =
Part 5 = /en/docs/Firefox_3_for_developers
```
## Specifications
[EXSLT - REGEXP:MATCH](https://exslt.github.io/regexp/functions/match/index.html)
| 0 |
data/mdn-content/files/en-us/web/exslt/regexp | data/mdn-content/files/en-us/web/exslt/regexp/replace/index.md | ---
title: regexp:replace()
slug: Web/EXSLT/regexp/replace
page-type: exslt-function
---
{{XSLTRef}}{{QuickLinksWithSubpages("/en-US/docs/Web/EXSLT")}}
`regexp:replace()` replaces the portions of a string that match a given regular expression with the contents of another string.
## Syntax
```plain
regexp:replace(originalString, regExpString, flagsString, replaceString)
```
### Parameters
- `originalString`
- : The string perform a search-and-replace operation upon.
- `regExpString`
- : The JavaScript style regular expression to evaluate.
- `flagsString`
- : The string containing character flags.
- `replaceString`
- : The string with which the matched substrings are to be replaced.
The character flags are:
- `g` - Global replace
- : If this flag is specified, all occurrences of the regular expression within the `originalString` are replaced. Otherwise only the first occurrence is replaced.
- `i` - Case insensitive match
- : If this flag is specified, the match is performed in a case insensitive fashion.
### Returns
The revised version of the string.
## Specifications
[EXSLT - REGEXP:REPLACE](https://exslt.github.io/regexp/functions/replace/index.html)
| 0 |
data/mdn-content/files/en-us/web/exslt | data/mdn-content/files/en-us/web/exslt/math/index.md | ---
title: Math (math)
slug: Web/EXSLT/math
page-type: landing-page
---
{{XSLTRef}}{{QuickLinksWithSubpages("/en-US/docs/Web/EXSLT")}}
The EXSLT Math package provides functions for working with numeric values and comparing nodes. The namespace for the Math package is `http://exslt.org/math`.
{{SubpagesWithSummaries}}
| 0 |
data/mdn-content/files/en-us/web/exslt/math | data/mdn-content/files/en-us/web/exslt/math/min/index.md | ---
title: math:min()
slug: Web/EXSLT/math/min
page-type: exslt-function
---
{{XSLTRef}}{{QuickLinksWithSubpages("/en-US/docs/Web/EXSLT")}}
`math:min()` returns the minimum value of a node-set.
To compute the minimum value of the node-set, the node set is sorted into ascending order as it would be using [`xsl:sort()`](/en-US/docs/Web/XSLT/Element/sort) with a data type of `number`. The minimum value is then the first node in the sorted list, converted into a number.
## Syntax
```plain
math:min(nodeSet)
```
### Parameters
- `nodeSet`
- : The node-set whose lowest value is to be returned.
### Returns
A result tree fragment representing the lowest valued node's numeric value as a string.
## Specifications
[EXSLT - MATH:MIN](https://exslt.github.io/math/functions/min/index.html)
| 0 |
data/mdn-content/files/en-us/web/exslt/math | data/mdn-content/files/en-us/web/exslt/math/highest/index.md | ---
title: math:highest()
slug: Web/EXSLT/math/highest
page-type: exslt-function
---
{{XSLTRef}}{{QuickLinksWithSubpages("/en-US/docs/Web/EXSLT")}}
`math:highest()` returns the node in the specified node-set with the highest value (where the highest value calculated using [`math:max()`](/en-US/docs/Web/EXSLT/math/max)).
A node has this maximum value if converting its string value to a number equals the maximum value.
## Syntax
```plain
math:highest(nodeSet)
```
### Parameters
- `nodeSet`
- : The node-set whose highest value is to be returned.
### Returns
A result tree fragment consisting of copies of the nodes returned by [`math:max()`](/en-US/docs/Web/EXSLT/math/max).
## Specifications
[EXSLT - MATH:HIGHEST](https://exslt.github.io/math/functions/highest/index.html)
| 0 |
data/mdn-content/files/en-us/web/exslt/math | data/mdn-content/files/en-us/web/exslt/math/lowest/index.md | ---
title: math:lowest()
slug: Web/EXSLT/math/lowest
page-type: exslt-function
---
{{XSLTRef}}{{QuickLinksWithSubpages("/en-US/docs/Web/EXSLT")}}
`math:lowest()` returns the node in the specified node-set with the lowest value (where the lowest value calculated using [`math:min()`](/en-US/docs/Web/EXSLT/math/min)).
A node has this minimum value if converting its string value to a number equals the minimum value.
## Syntax
```plain
math:lowest(nodeSet)
```
### Parameters
- `nodeSet`
- : The node-set whose lowest value is to be returned.
### Returns
A result tree fragment consisting of copies of the nodes returned by [`math:min()`](/en-US/docs/Web/EXSLT/math/min).
## Specifications
[EXSLT - MATH:LOWEST](https://exslt.github.io/math/functions/lowest/index.html)
| 0 |
data/mdn-content/files/en-us/web/exslt/math | data/mdn-content/files/en-us/web/exslt/math/max/index.md | ---
title: math:max()
slug: Web/EXSLT/math/max
page-type: exslt-function
---
{{XSLTRef}}{{QuickLinksWithSubpages("/en-US/docs/Web/EXSLT")}}
`math:max()` returns the maximum value of a node-set.
To compute the maximum value of the node-set, the node set is sorted into descending order as it would be using [`xsl:sort()`](/en-US/docs/Web/XSLT/Element/sort) with a data type of `number`. The maximum value is then the first node in the sorted list, converted into a number.
## Syntax
```plain
math:max(nodeSet)
```
### Parameters
- `nodeSet`
- : The node-set whose highest value is to be returned.
### Returns
A result tree fragment representing the highest valued node's numeric value as a string.
## Specifications
[EXSLT - MATH:MAX](https://exslt.github.io/math/functions/max/index.html)
| 0 |
data/mdn-content/files/en-us/web | data/mdn-content/files/en-us/web/progressive_web_apps/index.md | ---
title: Progressive web apps
slug: Web/Progressive_web_apps
page-type: landing-page
---
{{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.
Like a website, a PWA can run on multiple platforms and devices from a single codebase. Like a platform-specific app, it can be installed on the device, can operate while offline and in the background, and can integrate with the device and with other installed apps.
## Guides
These 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.
- [What is a progressive web app?](/en-US/docs/Web/Progressive_web_apps/Guides/What_is_a_progressive_web_app)
- : An introduction to PWAs, comparing them with traditional websites and with platform-specific apps, and outlining their main features.
- [Making PWAs installable](/en-US/docs/Web/Progressive_web_apps/Guides/Making_PWAs_installable)
- : One of the defining aspects of a PWA is that it can be installed on the device, and then 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. In this guide we'll explore what "installable" means, what a PWA needs to provide for it to be installable, and how you can customize the install experience.
- [Installing and uninstalling web apps](/en-US/docs/Web/Progressive_web_apps/Guides/Installing)
- : This guide covers how users can install and uninstall PWAs on their devices.
- [Offline and background operation](/en-US/docs/Web/Progressive_web_apps/Guides/Offline_and_background_operation)
- : 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 and to perform operations in the background, even when the main app is not running.
- [Caching](/en-US/docs/Web/Progressive_web_apps/Guides/Caching)
- : An overview of the APIs that enable a PWA to cache resources locally, and some common strategies used by PWAs to implement offline functionality.
- [Best practices for PWAs](/en-US/docs/Web/Progressive_web_apps/Guides/Best_practices)
- : PWAs should adapt to different browsers and devices, be accessible, have good performance, and integrate well with the operating system. This guide provides a list of best practices to help you make sure your PWA is as good as it can be.
## How to
These guides give concrete detailed instructions for how to implement specific PWA features.
- [Create a standalone app](/en-US/docs/Web/Progressive_web_apps/How_to/Create_a_standalone_app)
- : Describes how to specify that a PWA should be launched in its own dedicated window when it is launched, rather than a browser tab.
- [Define your app icons](/en-US/docs/Web/Progressive_web_apps/How_to/Define_app_icons)
- : Describes how to define your own set of icons to be used when the PWA is installed on a device.
- [Customize your app's colors](/en-US/docs/Web/Progressive_web_apps/How_to/Customize_your_app_colors)
- : Describes how to set background and theme colors for a PWA.
- [Display badges](/en-US/docs/Web/Progressive_web_apps/How_to/Display_badge_on_app_icon)
- : Describes how to display a badge on the PWA's icon: for example to let the user know that they have received new messages.
- [Expose common app actions as shortcuts](/en-US/docs/Web/Progressive_web_apps/How_to/Expose_common_actions_as_shortcuts)
- : Describes how to expose common actions for a PWA that can be launched from the operating system's app shortcut menu.
- [Share data between apps](/en-US/docs/Web/Progressive_web_apps/How_to/Share_data_between_apps)
- : Describes how PWAs can share data with each other by using the operating system's app sharing mechanism.
- [Trigger installation from your PWA](/en-US/docs/Web/Progressive_web_apps/How_to/Trigger_install_prompt)
- : Describes how developers can provide their own UI to invite users to install their PWA.
- [Associate files with your PWA](/en-US/docs/Web/Progressive_web_apps/How_to/Associate_files_with_your_PWA)
- : Describes how you can create an association between file types and your PWA, so that when the user clicks on the file, your PWA is launched to handle it.
## Tutorials
In these tutorials, you'll build a PWA from scratch. Tutorials walk through the steps of creating an app, from start to finish, explaining how the different features of the app are implemented.
- [Creating your first PWA](/en-US/docs/Web/Progressive_web_apps/Tutorials/CycleTracker)
- : This novice-level tutorial walks through the creation of a PWA to track menstrual cycles. Lessons include a walk through of the HTML, CSS, and JavaScript required to create a fully functional web app, setting up a testing environment, and complete explanations guiding the learner through upgrading the web app into a PWA; including developing and inspecting a manifest, adding a service worker, and using the service worker to delete stale caches.
- [Deep dive into PWA](/en-US/docs/Web/Progressive_web_apps/Tutorials/js13kGames)
- : This intermediate-level tutorial walks through the creation of a PWA that lists information about games submitted to the A-Frame category in the [js13kGames 2017](https://2017.js13kgames.com/) competition. This tutorial includes all the basics for creating a PWA, with additional features, including notifications, push, and app performance.
## Reference
Reference documentation for the web technologies you will use to build a PWA.
### 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.
## See also
- [Progressive web apps](https://web.dev/explore/progressive-web-apps) on web.dev
- [Learn PWA](https://web.dev/learn/pwa/) on web.dev
- [Progressive web apps](https://learn.microsoft.com/en-us/microsoft-edge/progressive-web-apps-chromium/) on learn.microsoft.com (2023)
| 0 |
data/mdn-content/files/en-us/web/progressive_web_apps | data/mdn-content/files/en-us/web/progressive_web_apps/how_to/index.md | ---
title: How to
slug: Web/Progressive_web_apps/How_to
page-type: landing-page
---
{{PWASidebar}}
How-to guides explain in detail how to accomplish a specific task related to PWAs.
{{ListSubpages}}
| 0 |
data/mdn-content/files/en-us/web/progressive_web_apps/how_to | data/mdn-content/files/en-us/web/progressive_web_apps/how_to/define_app_icons/index.md | ---
title: Define your app icons
slug: Web/Progressive_web_apps/How_to/Define_app_icons
page-type: how-to
---
{{PWASidebar}}
[Progressive Web Apps (PWAs)](/en-US/docs/Web/Progressive_web_apps) can be installed on devices just like other apps. Once a PWA is installed, its app icon appears on the device's home screen, dock, taskbar, or any other place where operating system native apps normally appear.
For example, on Windows, the taskbar can contain icons for both native and PWA apps side by side:
When creating a PWA, you can define your own set of icons to be used when the app is installed on a device. This article explains how to define your own app icons, which icon sizes to create, and how to make your icons support masking.
> **Note:** The PWA app icon is not the same as the {{glossary("favicon")}} image, which is displayed in places like the browser's address bar. PWAs can have both a favicon and an app icon. To learn more about favicons, see [Adding custom icons to your site](/en-US/docs/Learn/HTML/Introduction_to_HTML/The_head_metadata_in_HTML#adding_custom_icons_to_your_site).
## Design your icon
The first step in defining your app icon is to design it.
Most users recognize applications by their icons. Icons appear in many places through the operating system, including the home screen, taskbar, app launcher, or setting panels. Make sure your users can easily find your app by making its icon both visually appealing, and representative of your application.
The image should have a transparent background so it can be displayed on a variety of backgrounds. It should be at least 1024x1024 pixels, or scalable to that size, as this is the largest size your icon may be displayed at. You may also want to create icon versions with fewer details, to be used in places where the icon is displayed at smaller sizes.
Designing your icon as an SVG file is a good idea, as this will allow it to be scaled to any size without loss of quality.
## Reference your icons in the web app manifest
Use the [`icons`](/en-US/docs/Web/Manifest/icons) web app manifest member to define a set of icons for your PWA.
As described in [Create the necessary icon sizes](#create_the_necessary_icon_sizes), you should create multiple versions of your icon to ensure it appears correctly in all the places where it's used. This is why the `icons` member is an array of objects, each of which represents an icon, with its own size, type, and purpose. Each icon object has the following properties:
- `src`
- : The URL of the icon image file.
- `sizes`
- : The sizes the icon can be used for.
- `type`
- : The {{Glossary("MIME type")}} of the image file which the operating system can use to quickly ignore images it does not support.
- `purpose`
- : The OS-specific purpose of the image.
For example, the following web app manifest defines five PNG icons, each with a different size:
```json
{
"name": "My PWA",
"start_url": "/",
"display": "standalone",
"icons": [
{
"src": "icon-72.png",
"sizes": "72x72",
"type": "image/png"
},
{
"src": "icon-128.png",
"sizes": "128x128",
"type": "image/png"
},
{
"src": "icon-144.png",
"sizes": "144x144",
"type": "image/png"
},
{
"src": "icon-192.png",
"sizes": "192x192",
"type": "image/png"
},
{
"src": "icon-512.png",
"sizes": "512x512",
"type": "image/png"
}
]
}
```
## Create the necessary icon sizes
Various operating systems use different icon sizes in different places and for different device capabilities. It's important to create multiple versions of your icon so it appears correctly in all the places where it's used.
For example, Windows can display your app icon as a 44x44 pixels image in the taskbar, or as a 150x150 pixels image in the start menu. Use the links below for more information about the icon sizes used by different operating systems and tips for creating effective icons:
- For Windows, see [Define icons and a theme color](https://learn.microsoft.com/microsoft-edge/progressive-web-apps-chromium/how-to/icon-theme-color) on learn.microsoft.com.
- For Android, see [Google Play icon design specifications](https://developer.android.com/distribute/google-play/resources/icon-design-specifications) on developer.android.com.
- For iOS and macOS, see [App icons](https://developer.apple.com/design/human-interface-guidelines/app-icons#App-icon-sizes) on developer.apple.com.
The sizes at which your icon is displayed depend on the operating system and may change over time. It's best to test your icon on all the devices and operating systems you want to support, and generate the sizes and image types that lead to the best results. You can also use a tool like [PWA Image Generator](https://www.pwabuilder.com/imageGenerator) to generate the necessary icon sizes for you from a single high-definition image.
Note that some operating systems support [SVG](/en-US/docs/Web/SVG) icons which can help reduce the number of images you need to create since SVG can be scaled to any size automatically. If your SVG icon doesn't scale down to small sizes nicely. creating additional icons with fewer details and less complexity may be necessary. To support all OSs and small sizes, create PNG versions of your icon as well.
The following web app manifest example uses a WebP image for the small icon, an ICO image for medium size icons, and a scalable SVG image for higher resolution icons:
```json
{
"name": "My PWA",
"start_url": "/",
"display": "standalone",
"icons": [
{
"src": "icon-small.webp",
"sizes": "48x48",
"type": "image/webp"
},
{
"src": "icon-medium.ico",
"sizes": "72x72 96x96 128x128 256x256"
},
{
"src": "icon-high.svg",
"sizes": "257x257"
}
]
}
```
Learn more about how to reference the various icon sizes in [Reference your icons in the web app manifest](#reference_your_icons_in_the_web_app_manifest).
## Support masking
Depending on the operating system and the device capabilities, a mask may be applied to your icon to match a particular shape. Maskable icons are adaptive icons that can be displayed in a variety of shapes that operating systems provide. For example, on Android, app icons can have a circular mask.
Your PWA app icon should specifically support masking to look well integrated with operating systems that apply masks. Icons that do not support masking may appear cropped or smaller than expected. On Android, non-maskable icons are centered within the circular mask and given a white background, which may not look good with your icon.
The following image illustrates the difference between a maskable and a non-maskable icon on Android:
To start making your app icon maskable, use the `purpose` property in the icon objects of your web app manifest, and set its value to `maskable`. For example:
```json
{
"icons": [
{
"src": "icon-192-maskable.png",
"sizes": "192x192",
"type": "image/png",
"purpose": "maskable"
}
]
}
```
Using the `purpose` property is just the last step in making your icon maskable. You need to start by making sure your icon looks well integrated with the host operating system by ensuring the important parts of the icon appear well within the mask's _safe zone_.
The safe zone is the area that's guaranteed to always be visible when the mask is applied and is defined as a circle which diameter is 80% of the icon's minimum dimension.
For example, if your icon is a square, make sure that the square is entirely visible within the safe zone and that its corners are not cut off.
Finally, give your maskable icon an opaque background color to fill the entire icon area.
You can also use tools like [Maskable.app](https://maskable.app/) to preview how your icon will look when masked on different operating systems.
## See also
- [`icons` manifest member](/en-US/docs/Web/Manifest/icons)
- [App design](https://web.dev/learn/pwa/app-design#the_icon) on web.dev
- [Adaptive icon support in PWAs with maskable icons](https://web.dev/articles/maskable-icon) on web.dev
- [Define icons and a theme color](https://learn.microsoft.com/microsoft-edge/progressive-web-apps-chromium/how-to/icon-theme-color) on microsoft.com
- [PWA Image Generator](https://www.pwabuilder.com/imageGenerator) on pwabuilder.com
| 0 |
data/mdn-content/files/en-us/web/progressive_web_apps/how_to | data/mdn-content/files/en-us/web/progressive_web_apps/how_to/create_a_standalone_app/index.md | ---
title: Create a standalone app
slug: Web/Progressive_web_apps/How_to/Create_a_standalone_app
page-type: how-to
---
{{PWASidebar}}
[Progressive Web Apps](/en-US/docs/Web/Progressive_web_apps) (PWAs) that are installed on a user's device can define how they appear when the user launches them. They can choose to be displayed in a web browser, just like websites, or have their own dedicated windows similar to how OS-native applications work.
Users tend to have specific expectations of how installed applications behave on their devices. One of these expectations is that applications have their own dedicated windows.
By using the [web app manifest](/en-US/docs/Web/Manifest)'s [`display`](/en-US/docs/Web/Manifest/display) member, you can define whether the installed PWA is displayed in a browser or has its own dedicated window when the PWA is launched from the user's device.
## Use the standalone display mode
To use a standalone display mode and give your PWA its own dedicated window, add the [`display`](/en-US/docs/Web/Manifest/display) member to your [web app manifest](/en-US/docs/Web/Manifest) and set its value to `standalone`:
```json
{
"name": "My app",
"start_url": "/",
"icons": [
{
"src": "icon.webp",
"sizes": "48x48",
"type": "image/webp"
}
],
"display": "standalone"
}
```
Note that there are other display modes available, such as `browser`, `minimal-ui`, and `fullscreen`. The display mode you choose changes how much of the browser user interface is shown to the user, from showing all of it, to having your own dedicated window. To learn more about all the available display mode and about how they fallback when one is not supported, see the documentation about the [`display`](/en-US/docs/Web/Manifest/display) member.
## Best practices
### Handle multi-page navigation
If your application is built using several navigable HTML pages, make sure to include UI elements for controlling navigation within your application.
If you don't have your own navigation elements, use the `minimal-ui` display mode to make sure users can still go between pages using previous and next buttons rendered by the browser in your app's title bar.
## Customize your app depending on the display mode
When you define a display mode other than `browser` in your web app manifest, it only applies when the application is installed. Like any other webpage, a manifest's `display` member has no effect when the PWA is not installed. You can check the display mode at runtime to detect if the app is installed or not.
Using the CSS {{cssxref("@media/display-mode", "display-mode")}} media feature or the {{domxref("Window.matchMedia()")}} JavaScript feature, you can selectively apply CSS styles or run JavaScript code in your app based on its display mode.
Here is an example showing how to use the {{cssxref("@media")}} CSS at-rule to only reveal an element on a webpage when the `standalone` display mode is enabled:
```css
.app-button {
display: none;
}
@media (display-mode: standalone) {
.app-button {
display: block;
}
}
```
In this example, the `.app-button` element will be hidden by default unless the display mode is set to `standalone`, which happens if the `display` manifest member was set to `standalone` and the app is installed on the user's device.
Here is another example showing how to use the {{domxref("window.matchMedia()")}} method to detect if the `standalone` display mode is enabled:
```js
function isStandaloneApp() {
return window.matchMedia("(display-mode: standalone)").matches;
}
```
## See also
- [Web App Manifests](/en-US/docs/Web/Manifest).
- [Display modes](https://web.dev/learn/pwa/app-design/#display_modes).
- Customize your app's title bar on desktop operating systems by using the [Window Controls Overlay API](/en-US/docs/Web/API/Window_Controls_Overlay_API).
| 0 |
data/mdn-content/files/en-us/web/progressive_web_apps/how_to | data/mdn-content/files/en-us/web/progressive_web_apps/how_to/trigger_install_prompt/index.md | ---
title: Trigger installation from your PWA
slug: Web/Progressive_web_apps/How_to/Trigger_install_prompt
page-type: how-to
---
{{PWASidebar}}
> **Warning:** The technique described here depends on the {{domxref("Window.beforeinstallprompt_event", "beforeinstallprompt")}} event, which is non-standard and currently only implemented in Chromium-based browsers.
By default, if the user visits your website, and the browser determines that the site is [installable as a PWA](/en-US/docs/Web/Progressive_web_apps/Guides/Making_PWAs_installable#installability), then the browser will display some built-in UI — an icon in the URL bar, for example — to install the site. If the user clicks the icon, then the browser shows an install prompt containing, at a minimum, the app's [name](/en-US/docs/Web/Manifest/name) and [icon](/en-US/docs/Web/Manifest/icons). If the user agrees to install the app, then it will be installed.
However, you can implement your own in-app UI to ask the user if they want to install the app, which will trigger the install prompt. The benefits of this are:
- You can provide more context about the app, explaining to the user why they might want to install it as a PWA.
- An in-app install UI is likely to be easier for users to discover and understand than the browser's default UI.
## Adding an in-app install UI
First, add some UI to the app indicating that the user can install it. For example:
```html
<button id="install" hidden>Install</button>
```
We're setting the button's [`hidden`](/en-US/docs/Web/HTML/Global_attributes/hidden) attribute, because if the user visits the app with a browser that can't install it, we don't want the install UI to be visible. Next, we'll see how to make the button visible only on browsers that support installing PWAs locally.
## Listening for beforeinstallprompt
As soon as the browser has determined that it can install the app, it fires the {{domxref("Window.beforeinstallprompt_event", "beforeinstallprompt")}} event in the global {{domxref("Window")}} scope.
In our main app code, we will listen for this event:
```js
// main.js
let installPrompt = null;
const installButton = document.querySelector("#install");
window.addEventListener("beforeinstallprompt", (event) => {
event.preventDefault();
installPrompt = event;
installButton.removeAttribute("hidden");
});
```
The event handler here does three things:
- Call {{domxref("Event.preventDefault()","preventDefault()")}} on the event. This prevents the browser from displaying its own install UI.
- Take a reference to the event object that's passed into the handler. This is an instance of {{domxref("BeforeInstallPromptEvent")}}, and is what will enable us to prompt the user to install the app.
- Reveal our in-app install UI by removing the `hidden` attribute on the button.
## Triggering the install prompt
Next, we need to add a click handler to our in-app install button:
```js
// main.js
installButton.addEventListener("click", async () => {
if (!installPrompt) {
return;
}
const result = await installPrompt.prompt();
console.log(`Install prompt was: ${result.outcome}`);
disableInAppInstallPrompt();
});
function disableInAppInstallPrompt() {
installPrompt = null;
installButton.setAttribute("hidden", "");
}
```
The `installPrompt` variable was initialized with the `BeforeInstallPromptEvent` object in our `beforeinstallprompt` event handler. If `installPrompt` hasn't been initialized, for any reason, we do nothing.
Otherwise we call its {{domxref("BeforeInstallPromptEvent.prompt()", "prompt()")}} method. This shows the install prompt, and returns a {{jsxref("Promise")}} which resolves with an object indicating whether the app was installed or not. In particular, its `outcome` property is `"accepted"` if the user chose to install the app, or `"dismissed"` if they dismissed the prompt.
Either way, we must reset our state after calling `prompt()`, because we can only call it once for each `BeforeInstallPromptEvent` instance. So we reset our `installPrompt` variable and hide the install button again.
## Responding to app install
Depending on the browser and platform, the browser may still offer its own UI to install the app. This means that the app may still be installed without going through our in-app install UI. If this happens, we want to disable the in-app install UI, or we will show it in an app that's already been installed.
To do this we can listen to the {{domxref("Window.appinstalled_event", "appinstalled")}} event, which fires in the global {{domxref("Window")}} scope when the app has been installed:
```js
// main.js
window.addEventListener("appinstalled", () => {
disableInAppInstallPrompt();
});
function disableInAppInstallPrompt() {
installPrompt = null;
installButton.setAttribute("hidden", "");
}
```
## Responding to platform-specific apps being installed
One case not covered by the above examples is where you have a platform-specific version of the app as well as a web app, and you want to personalize the web app experience depending on whether the platform-specific app is already installed. You might not want to invite users to install the PWA if they already have the platform-specific app installed, and/or you might want to invite them to head over to the platform-specific app to view content.
This can be handled with the {{domxref("Navigator.getInstalledRelatedApps()")}} method, which allows you to detect installed related platform-specific apps (or PWAs) and respond appropriately.
For example:
```js
const relatedApps = await navigator.getInstalledRelatedApps();
// Search for a specific installed platform-specific app
const psApp = relatedApps.find((app) => app.id === "com.example.myapp");
if (psApp) {
// Update UI as appropriate
}
```
This method could also be combined with `beforeinstallprompt` to suppress the browser's install UI based on the availability of a platform-specific app:
```js
window.addEventListener("beforeinstallprompt", async (event) => {
const relatedApps = await navigator.getInstalledRelatedApps();
// Search for a specific installed platform-specific app
const psApp = relatedApps.find((app) => app.id === "com.example.myapp");
if (psApp) {
event.preventDefault();
// Update UI as appropriate
}
});
```
## See also
- [Making PWAs installable](/en-US/docs/Web/Progressive_web_apps/Guides/Making_PWAs_installable)
- {{domxref("Window.beforeinstallprompt_event", "beforeinstallprompt")}} event
- [How to provide your own in-app install experience](https://web.dev/articles/customize-install) on web.dev (2021)
| 0 |
data/mdn-content/files/en-us/web/progressive_web_apps/how_to | data/mdn-content/files/en-us/web/progressive_web_apps/how_to/customize_your_app_colors/index.md | ---
title: Customize your app's theme and background colors
slug: Web/Progressive_web_apps/How_to/Customize_your_app_colors
page-type: how-to
---
{{PWASidebar}}
When building [Progressive Web Apps (PWAs)](/en-US/docs/Web/Progressive_web_apps), it's important to not only consider the appearance of your app's content, but also the way the app appears on the user's device once the app is installed.
One way to customize the window in which your app appears is by using the [`theme_color`](/en-US/docs/Web/Manifest/theme_color) and [`background_color`](/en-US/docs/Web/Manifest/background_color) [web app manifest](/en-US/docs/Web/Manifest) members.
By defining the `theme_color` and `background_color` members in your PWA manifest, you can create a more polished experience for your users. These small details can help make your PWA feel more like an OS-native app, and more familiar to your users.
## Customize the app window background color
The [`background_color`](/en-US/docs/Web/Manifest/background_color) manifest member defines the color that appears in the application window before your app's stylesheets have loaded.
Because this color appears before your stylesheets have loaded, set its value to the same color value as the `background-color` CSS property in your application's stylesheet. This will ensure a smooth visual transition between launching the web application and loading its content.
The value can be any valid CSS [`<color>`](/en-US/docs/Web/CSS/color_value). In this web app manifest file example, the application's background color is set to the [named color](/en-US/docs/Web/CSS/named-color) `peachpuff`. :
```json
{
"name": "My app",
"start_url": "/",
"icons": [
{
"src": "icon.webp",
"sizes": "256x256",
"type": "image/webp"
}
],
"display": "standalone",
"background_color": "peachpuff"
}
```
The application also loads a stylesheet that applies the same color to the background of the body element:
```css
body {
background-color: peachpuff;
}
```
The following screenshot shows the above code in action. The PWA that uses this code is installed on Windows, and the screenshot shows what the application window looks like before the content of the app has loaded:
## Define a theme color
The [`theme_color`](/en-US/docs/Web/Manifest/theme_color) member in your PWA manifest defines the default color of operating system and browser UI elements used in the application.
Different devices, operating systems, and browsers apply the `theme_color` member differently. For example:
- On mobile devices, the theme color is applied to the status bar.
- On desktop operating systems, the theme color is used to customize the title bar of your [standalone app window](/en-US/docs/Web/Progressive_web_apps/How_to/Create_a_standalone_app).
Choose a `theme_color` that complements the overall design and branding of your PWA and works well across a variety of devices and platforms to ensure a consistent user experience.
As with `background_color`, any [`<color>`](/en-US/docs/Web/CSS/color_value) value is valid. In this web app manifest file example, the `theme_color` is set to the `rgb(255 218 185)`, the [RGB](/en-US/docs/Web/CSS/color_value/rgb) equivalent of `peachpuff`:
```json
{
"name": "My app",
"start_url": "/",
"icons": [
{
"src": "icon.webp",
"sizes": "48x48",
"type": "image/webp"
}
],
"display": "standalone",
"background_color": "peachpuff",
"theme_color": "rgb(255 218 185)"
}
```
The following screenshot shows the above code in action when the app is installed on Windows, where the `theme_color` manifest member is used as the color of the title bar:
### Relationship with the `theme-color` meta element value
The [`theme-color`](/en-US/docs/Web/HTML/Element/meta/name/theme-color) value for the [`name`](/en-US/docs/Web/HTML/Element/meta/name) attribute of the {{htmlelement("meta")}} HTML element can be used to define a theme color per webpage. This is different from the `theme_color` manifest member which you define only once, globally, for your app.
If both are set, the `theme-color` meta element value overrides the `theme_color` manifest member. This lets you define a global color for your app and override it on specific pages.
Note that on some browsers, like Safari on macOS and Chrome on Android, the `theme-color` meta element value is used to style the browser UI too.
## See also
- [Web App Manifests](/en-US/docs/Web/Manifest).
- [Meta Theme Color and Trickery on css-tricks.com](https://css-tricks.com/meta-theme-color-and-trickery/) (2021)
- [Recommended fields on web.dev](https://web.dev/learn/pwa/web-app-manifest#recommended_fields)
| 0 |
data/mdn-content/files/en-us/web/progressive_web_apps/how_to | data/mdn-content/files/en-us/web/progressive_web_apps/how_to/display_badge_on_app_icon/index.md | ---
title: Display a badge on the app icon
slug: Web/Progressive_web_apps/How_to/Display_badge_on_app_icon
page-type: how-to
---
{{PWASidebar}}
Applications native to mobile and desktop operating systems can display badges on top of their app icons to inform users that new content is available. For example, an email client application can display the total number of unread messages in a badge and update this number even if the app is not running.
Here is an example showing the Mail application on an iOS device with a badge in its top right corner:
[Progressive Web Apps](/en-US/docs/Web/Progressive_web_apps) (PWAs) can display and update badges on their app icons too.
Displaying and updating a badge is done by using the [Badging API](/en-US/docs/Web/API/Badging_API). You can call this API from the app's [service worker](/en-US/docs/Web/API/Service_Worker_API/Using_Service_Workers), to display or update the badge even when the app is not running.
## Support for badges
App badges are only supported when a PWA is installed on its host operating system. Badges appear on the app icon which only exists after the app has been installed.
> **Note:** This article focuses on the {{domxref("Navigator.setAppBadge()")}} and {{domxref("Navigator.clearAppBadge()")}} methods from the Badging API and ignores the `Navigator.setClientBadge` and `Navigator.clearClientBadge`. Although these methods are defined in the [Badging API specification](https://w3c.github.io/badging/) too, they are for displaying badges on documents, not on application icons.
### Desktop support
On desktop operating systems, badges are only supported on Windows and macOS, and only when the PWA is installed from Chrome or Edge. While the Badging API is supported on Chromium-based browsers on Linux, badges are not displayed on this operating system.
Safari and Firefox on desktop do not support the Badging API and do not support installing PWAs.
### Mobile support
Badges are supported on mobile operating systems, including Chromium-based browsers running on Android and in Safari on iOS and iPadOS, starting with iPadOS 16.4.
## Badge best practices
Before learning how to use badges, consider these best practices to ensure your app uses badges in the most effective and useful way for your users.
### Check for support
To ensure the Badging API is [supported](#support_for_badges) in the user's browser and operating system, to prevent throwing a JavaScript error, check for support before using the API:
```js
if (navigator.setAppBadge) {
// The API is supported, use it.
} else {
// The API is not supported, don't use it.
}
```
Do not rely solely on badges to inform users about the availability of new content. Browsers that support the Badging API may be installed on operating systems that do not support displaying a badge. For example, while Chrome supports the Badging API, badges will not appear on installed application icons on Linux.
### Request notification permissions for iOS and/or iPadOS
While notification badges are supported on iOS and iPadOS, badges will not appear until the application is granted notification permissions. To request notification permissions, call the [`Notification.requestPermission()`](/en-US/docs/Web/API/Notifications_API/Using_the_Notifications_API#getting_permission) method:
```js
Notification.requestPermission().then((result) => {
console.log(result);
});
```
Optionally, you can check if a user has previously granted notification permissions using the [Permissions API](/en-US/docs/Web/API/Permissions_API).
### Use badges sparingly
Like notifications, badges can be a very effective way to re-engage users with your app when used sparingly. Make sure to use badges to only signal new content that's important for your users to know about.
### Update badges in real-time
Make sure to update your application badge in real-time. This means updating the badge count to reflect how many new items are actually left for the user to consume, and clearing the app badge when there are no new items.
For example, if an email client app receives new messages in the background, it should update its badge to display the right number of unread messages in the inbox, potentially filtering out messages from other folders such as a spam folder. It's possible to [update badges in the background](#updating_the_badge_in_the_background) by using the `navigator.setAppBadge()` method from a service worker.
Once the user launches the app and starts reading messages, the email client app should update its badge accordingly by calling `navigator.setAppBadge()` with the new unread messages count, or by calling `navigator.clearAppBadge()` when there are no unread messages.
### Highlight new content in the app
When your app receives new content and adds a badge on the app icon, make sure to highlight that new content for users when they launch the app.
For example, if an email client app displays the unread messages count on the app icon badge, then those messages should be bolded or highlighted in some way when the app is opened.
## Displaying and updating the badge
To display a badge on your PWA's app icon that shows a number of unread messages, use the {{domxref("Navigator.setAppBadge()")}} method:
```js
// Check for support first.
if (navigator.setAppBadge) {
// Display the number of unread messages.
navigator.setAppBadge(numberOfUnreadMessages);
}
```
You can also display an empty badge using the same method by omitting the count parameter, or setting it to `0`:
```js
// Check for support first.
if (navigator.setAppBadge) {
// Just display the badge, with no number in it.
navigator.setAppBadge();
}
```
To remove the badge on the app icon, use the {{domxref("Navigator.clearAppBadge()")}} method:
```js
// Check for support first.
if (navigator.clearAppBadge) {
// Remove the badge on the app icon.
navigator.clearAppBadge();
}
```
## Updating the badge in the background
Badges can be useful to re-engage users with your app when they're not already using the app. This means that your app must be able to update its badge even when it's not running.
PWAs can use the following mechanisms to update in the background and display, update, or hide their badges:
- [Push API](/en-US/docs/Web/API/Push_API)
- : PWAs can use this API to receive messages from a server even when the app is not running.
- [Background Synchronization API](/en-US/docs/Web/API/Background_Synchronization_API)
- : PWAs can use this API to run code in the background when a stable network connection is detected.
- [Web Periodic Background Synchronization API](/en-US/docs/Web/API/Web_Periodic_Background_Synchronization_API)
- : PWAs can use this API to run code in the background at periodic intervals of time.
Here is a service worker code example showing how to listen to a server's Push messages and update the app badge to reflect an unread messages count:
```js
// Listen to "push" events in the service worker.
self.addEventListener("push", (event) => {
// Extract the unread count from the push message data.
const message = event.data.json();
const unreadCount = message.unreadCount;
// Set or clear the badge.
if (navigator.setAppBadge) {
if (unreadCount && unreadCount > 0) {
navigator.setAppBadge(unreadCount);
} else {
navigator.clearAppBadge();
}
}
});
```
## See also
- [How to create an app badge](https://web.dev/patterns/web-apps/badges/)
- [Re-engage users with badges, notifications, and push messages](https://learn.microsoft.com/microsoft-edge/progressive-web-apps-chromium/how-to/notifications-badges)
- [Codelab: Build a push notification server](https://web.dev/articles/push-notifications-server-codelab)
| 0 |
data/mdn-content/files/en-us/web/progressive_web_apps/how_to | data/mdn-content/files/en-us/web/progressive_web_apps/how_to/associate_files_with_your_pwa/index.md | ---
title: Associate files with your PWA
slug: Web/Progressive_web_apps/How_to/Associate_files_with_your_PWA
page-type: how-to
---
{{PWASidebar}}
On a device, files are usually associated with apps, so when the user opens the file, the operating system launches the appropriate app and passes the file to it. For example, HTML files are often opened in a web browser, text files in a text editor, and videos in a video player.
Progressive Web Apps can participate in this feature, so when the user clicks on files of specific types, the PWA may be launched to handle it.
There are two parts to adding support for file handling:
- Declare support for certain file types using the [`file_handlers`](/en-US/docs/Web/Manifest/file_handlers) web app manifest member.
- Handling files using the {{domxref("LaunchQueue")}} interface.
> **Note:** At present this feature is only available on Chromium-based browsers, and only on desktop operating systems.
## Declaring support for file types
To declare support for particular file types, include the [`file_handlers`](/en-US/docs/Web/Manifest/file_handlers) member in your [manifest file](/en-US/docs/Web/Manifest).
The `file_handlers` member is an array of file handler objects. Each file handler object has two mandatory properties, `action` and `accept`.
- The `accept` property contains {{Glossary("MIME_Type", "MIME types")}} and associated file extensions for files that the handler knows how to handle.
- The `action` property is a URL to which the PWA will navigate when the user opens the file. This page must be in the PWA's scope.
The manifest file below includes a `file_handlers` member with a single handler, which can handle {{Glossary("JPEG")}} and {{Glossary("PNG")}} files, and will navigate to the PWA's root page when the user clicks one of these files.
```json
{
"name": "File handling demo",
"icons": [
{
"src": "icons/lightbulb.png",
"sizes": "512x512",
"type": "image/png"
}
],
"start_url": "/",
"display": "standalone",
"file_handlers": [
{
"action": "/",
"accept": {
"image/jpeg": [".jpg", ".jpeg"],
"image/png": [".png"]
}
}
]
}
```
With this manifest, once the PWA is installed, it may be opened when the user opens files of these types.
More than one app can usually open files of any given type, so the operating system usually provides a feature enabling the user to choose which app to use to open a file, and to set a default handler. For example, on macOS, the user can right-click a file, select "Get Info", and configure the default handler in the resulting dialog:
## Asking permission
The first time the browser is about to launch your PWA to handle one or more files that the user opened, it will ask the user to confirm that they want to use your PWA to open it. For example, the Chrome dialog looks like this:
## Handling the files
When the browser launches your PWA and navigates to the page you specified in the `action` property of the `file_handlers` manifest member, you'll need to run some code to handle the file. This code will run in the page that was specified in the `action` property.
The key interface here is {{domxref("LaunchQueue")}}, which is available as a property of the global {{domxref("Window")}} object.
The `LaunchQueue` interface has a single method, {{domxref("LaunchQueue/setConsumer", "setConsumer()")}}, which takes as an argument a callback function which will be called when the browser has launched the PWA with one or more files to handle.
The callback is passed a {{domxref("LaunchParams")}} object, which includes a {{domxref("LaunchParams/files", "files")}} property containing an array of {{domxref("FileSystemHandle")}} objects, each of which represents one of the files that the user opened.
For example, the code below reads the files and assigns their contents to {{HTMLElement("img")}} elements, which it adds to the page:
```js
const imageContainer = document.querySelector("#container");
if ("launchQueue" in window) {
launchQueue.setConsumer(async (launchParams) => {
for (const file of launchParams.files) {
const img = document.createElement("img");
img.src = URL.createObjectURL(await file.getFile());
imageContainer.appendChild(img);
}
});
}
```
Note that the code checks that `launchQueue` exists before using it, to ensure the app behaves gracefully in browsers that don't support the API.
## See also
- [`file_handlers`](/en-US/docs/Web/Manifest/file_handlers) manifest member
- {{domxref("LaunchQueue")}} interface
- [File System API](/en-US/docs/Web/API/File_System_API)
- [File API](/en-US/docs/Web/API/File_API)
- [Let installed web applications be file handlers](https://developer.chrome.com/docs/capabilities/web-apis/file-handling) on developer.chrome.com (2022)
- [Handle files in Progressive Web Apps](https://learn.microsoft.com/en-us/microsoft-edge/progressive-web-apps-chromium/how-to/handle-files) on learn.microsoft.com (2023)
| 0 |
data/mdn-content/files/en-us/web/progressive_web_apps/how_to | data/mdn-content/files/en-us/web/progressive_web_apps/how_to/share_data_between_apps/index.md | ---
title: Share data between apps
slug: Web/Progressive_web_apps/How_to/Share_data_between_apps
page-type: how-to
---
{{PWASidebar}}
Application sharing is the ability of one application to pass information or data to another application on the same device. This feature is useful for users as it allows them to share information between two applications without the need for these applications to have prior knowledge of each other.
For example, on your mobile device, you can share photos or videos from your photo app with another application that accepts images, such as an email application. This sharing pattern is orchestrated by the operating system (OS) where the two applications are installed:
1. When the photo sharing is initiated by the user, the photo application prepares the data for the selected image, and hands it over to the operating system.
2. The operating system selects the list of applications that are able to handle the shared image data and displays them to the user.
3. Once the user selects one of the target applications, the operating system launches it with the shared image.
[Progressive Web Apps](/en-US/docs/Web/Progressive_web_apps) (PWAs) also have the ability to share information using the same OS-orchestrated pattern. PWAs can both share data and accept shared data.
When building a PWA, accepting shared data can make your PWA feel more familiar and naturally integrated into your user's devices.
## Sharing data with other apps
To make it possible for users to share data with other apps from your PWA, use the [Web Share API](/en-US/docs/Web/API/Web_Share_API). The Web Share API allows your app to share text, links, or files with other apps via the underlying operating system share mechanism.
To share data, use the {{domxref("navigator.share()")}} method in response to a user action, such as a button click.
### Checking for support
Before displaying content-sharing UI in your application, check to ensure the Web Share API feature is supported. Even the browsers that support the Web Share API don't all support sharing all types of data. Therefore, it's a good practice to use the {{domxref("navigator.canShare()")}} method first to validate whether the data you intend to share is, indeed, shareable from the browser that's running your app.
This example shows how to check if the Web Share API is supported and if the data can be shared:
```js
function canBrowserShareData(data) {
if (!navigator.share || !navigator.canShare) {
return false;
}
return navigator.canShare(data);
}
const sharedDataSample = {
title: "Some text title",
text: "More text",
url: "A url we want to share",
};
if (canBrowserShareData(sharedDataSample)) {
// Enable the share button in the UI.
renderAppSharingUI();
} else {
// We can't share on this browser/operating system.
}
```
### Handling exceptions
The {{domxref("navigator.share()")}} method returns a {{jsxref("Promise")}} that may be rejected in cases such as when the shared data is incorrect, when the user aborts the share operation, or when the data transmission failed.
It's therefore important to catch the promise rejection in order to avoid errors in your app's JavaScript code.
```js
async function shareData(data) {
try {
await navigator.share(data);
// The data was shared successfully.
} catch (e) {
// The data could not be shared.
console.error(`Error: ${e}`);
}
}
```
### Sharing text data
The following example demonstrates how to share a link and some text when a button in the app is clicked. The `canBrowserShareData` function used in the example is described in [Checking for support](#checking_for_support) and not repeated here.
```js
// Retrieve the button from the DOM. The button is hidden for now.
const button = document.querySelector("#share");
if (canBrowserShareData({ text: "text", url: "https://example.com" })) {
// Show the button.
button.style.display = "inline";
// Listen for click events on the button to share data.
button.addEventListener("click", async () => {
try {
await navigator.share({
text: "An MDN article to learn how to share data between apps",
url: "https://developer.mozilla.org/docs/Web/Progressive_web_apps/How_to/Share_data_between_apps",
});
console.log("The URL was successfully shared");
} catch (err) {
console.error(`The URL could not be shared: ${err}`);
}
});
}
```
### Sharing files
The following code example demonstrates how to share a file when a button in the app is clicked. The `canBrowserShareFiles` function is used to display the share button only if the browser supports sharing files.
```js
function canBrowserShareFiles() {
if (!navigator.share || !navigator.canShare) {
return false;
}
// Create some test data with a file, to check if the browser supports
// sharing it.
const testFile = new File(["foo"], "foo.txt", { type: "text/plain" });
const data = { files: [testFile] };
return navigator.canShare(data);
}
// Retrieve the button from the DOM. The button is hidden for now.
const button = document.querySelector("#share");
if (canBrowserShareFiles()) {
// The browser supports sharing files. Show the button.
button.style.display = "inline";
// Listen for clicks on the button and share a file.
button.addEventListener("click", async () => {
try {
// Get the file to be shared. This function should return a File
// object, perhaps by creating it dynamically, or retrieving it
// from IndexedDB.
const file = await getTheFileToShare();
await navigator.share({
title: "My shared file",
files: [file],
});
console.log("The file was successfully shared");
} catch (err) {
console.error(`The file could not be shared: ${err}`);
}
});
}
```
For more information, see the [sharing files example](/en-US/docs/Web/API/Navigator/share#sharing_files) on the `navigator.share()` method page.
## Handling shared data from other apps
To register your PWA as a target of other apps' shared data, use the [Web Share Target API](https://developer.chrome.com/en/articles/web-share-target/) and, in particular, the [`share_target`](/en-US/docs/Web/Manifest/share_target) web app manifest member.
The `share_target` manifest member allows an installed PWA to be registered, at the operating system level, as a potential target for content shared by other apps. This means that when a user shares some data that's compatible with your PWA, from another app, the operating system will list your PWA alongside other typical share targets like email or messaging apps. Note that the PWA must be installed to be displayed as a potential target for receiving shared data.
The information you provide with the `share_target` member, in your manifest file, defines which data your app can be a target for, and how the operating system should launch your app when the user selects it as the target.
### Handling text data
Here is a web app manifest example using the `share_target` member:
```json
{
"name": "ChattyBox",
"start_url": "/",
"display": "standalone",
"icons": [
{
"src": "images/icon-256.png",
"sizes": "256x256",
"type": "image/png"
}
],
"share_target": {
"action": "/share-handler",
"method": "GET",
"params": {
"text": "description",
"url": "link"
}
}
}
```
When your app is selected by the user to handle another apps' shared content, your app is launched and the shared content is passed to it in a similar way to that in which {{htmlelement("form")}} elements are submitted.
In the previous web app manifest code example, when the ChattyBox app is selected as a target, it is launched by making an HTTP [`GET`](/en-US/docs/Web/HTTP/Methods/GET) request at the `/share-handler` URL, with the shared data passed as request parameters named `description` and `link`.
The `GET` request will look like this: `/shared-handler?description=...&link=...`.
Your app's main JavaScript code can then retrieve the shared data by using the [URLSearchParams](/en-US/docs/Web/API/URLSearchParams) interface:
```js
const url = new URL(document.location);
const sharedDescription = url.searchParams.get("description");
const sharedLink = url.searchParams.get("link");
```
For more information, see the example [Receive share data using GET](/en-US/docs/Web/Manifest/share_target#receiving_share_data_using_get) on the `share_target` web app manifest member page.
### Handling shared files
In the previous example, text data was handled as a `GET` request. However, handling files requires the use of a [`POST`](/en-US/docs/Web/HTTP/Methods/POST) request with a `multipart/form-data` [encoding type](/en-US/docs/Web/API/HTMLFormElement/enctype).
The following code snippet shows how a PWA can be configured to accept different types of shared files:
```json
{
"name": "ChattyBox",
"start_url": "/",
"display": "standalone",
"icons": [
{
"src": "images/icon-256.png",
"sizes": "256x256",
"type": "image/png"
}
],
"share_target": {
"action": "/share-file-handler",
"method": "POST",
"enctype": "multipart/form-data",
"params": {
"files": [
{
"name": "textFiles",
"accept": ["text/plain", ".txt"]
},
{
"name": "htmlFiles",
"accept": ["text/html", ".html"]
},
{
"name": "images",
"accept": ["image/jpeg", "image/png", "image/webp", "image/gif"]
}
]
}
}
}
```
As this example shows, each file object in the `files` property must have a `name` property and an `accept` property. The `accept` property must specify the accepted [MIME types](/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types) or file extensions.
When the app is selected by the user to handle a shared file (or files), the app is launched with a `POST` request at the `/share-file-handler` URL, with encoded form data.
Because this is a `POST` request, your app's main JavaScript code can't access the form data directly. You can handle the submitted files in your server-side code, by receiving them at the `/share-file-handler` URL end point. However, for a better user experience that works offline, you can handle the files in your service worker code with a [`fetch` event handler](/en-US/docs/Web/API/ServiceWorkerGlobalScope/fetch_event), as shown here:
```js
// service-worker.js
self.addEventListener("fetch", (event) => {
// Only use this event listener for POST requests sent to /share-file-handler.
const url = new URL(event.request.url);
if (
event.request.method !== "POST" ||
url.pathname !== "/share-file-handler"
) {
return;
}
event.respondWith(
(async () => {
// Get the data from the submitted form.
const formData = await event.request.formData();
// Get the submitted files.
const textFiles = formData.getAll("textFiles");
const htmlFiles = formData.getAll("htmlFiles");
const imageFiles = formData.getAll("images");
// Send the files to the frontend app.
sendFilesToFrontend(textFiles, htmlFiles, imageFiles);
// Redirect the user to a URL that shows the imported files.
return Response.redirect("/display-new-files", 303);
})(),
);
});
```
In this code example, the shared files are extracted from the form data and the user is redirected to a different page. It's up to you, using the code in your service worker, to handle the extracted files as you want. For example, you can send them to your app's main JavaScript code using the {{domxref("Worker.postMessage()")}} method or store them in an {{domxref("IndexedDB")}} database which can be accessed both by your service worker and app's main JavaScript code.
For more information, see the [receiving shared files](/en-US/docs/Web/Manifest/share_target#receiving_shared_files) example on the `share_target` web app manifest member page.
## See also
- [Web Share API](/en-US/docs/Web/API/Web_Share_API)
- [`share_target` manifest member](/en-US/docs/Web/Manifest/share_target)
- [Integrate with the OS sharing UI with the Web Share API](https://web.dev/articles/web-share) on web.dev
- [Receiving shared data with the Web Share Target API](https://developer.chrome.com/docs/capabilities/web-apis/web-share-target) on developer.chrome.com
- [Share content with other apps](https://learn.microsoft.com/microsoft-edge/progressive-web-apps-chromium/how-to/share) on microsoft.com
| 0 |
data/mdn-content/files/en-us/web/progressive_web_apps/how_to | data/mdn-content/files/en-us/web/progressive_web_apps/how_to/expose_common_actions_as_shortcuts/index.md | ---
title: Expose common app actions as shortcuts
slug: Web/Progressive_web_apps/How_to/Expose_common_actions_as_shortcuts
page-type: how-to
---
{{PWASidebar}}
Many operating systems support showing shortcut menus, or jump-list, when the user right-clicks or long-presses an app icon. For example, on Windows, right-clicking on any pinned program in the taskbar shows a list of program-specific actions and recently opened files:
On Android, long-pressing an app icon also shows a list of common app actions:
[Progressive Web Apps (PWAs)](/en-US/docs/Web/Progressive_web_apps) can be installed on devices just like platform-native apps and, like their native counterparts, they can also define app shortcut menus to let users access common actions.
Shortcuts are only displayed by right-clicking or long-pressing the app icon, meaning they're only available once the PWA is installed on the user's device. To learn how to make your PWA installable, see [making PWAs installable](/en-US/docs/Web/Progressive_web_apps/Guides/Making_PWAs_installable).
## Why use shortcuts?
Defining shortcuts for your PWA can make users more productive by letting them access your app's main actions directly from their home screen. Additionally, defining shortcuts can help make your PWA feel more platform-native and therefore more familiar to your users.
## Define shortcuts in the web app manifest
To define shortcuts for your PWA, use the [`shortcuts`](/en-US/docs/Web/Manifest/shortcuts) member of the [web app manifest](/en-US/docs/Web/Manifest). This member is an array of objects defining each shortcut's name and URL, as well as the optional short name, description, and icons. For example, here's the web app manifest of a calendar app that defines two shortcuts:
```json
{
"name": "Calendar",
"start_url": "/",
"display": "standalone",
"icons": [
{
"src": "images/icon-256.png",
"sizes": "256x256",
"type": "image/png"
}
],
"shortcuts": [
{
"name": "New event",
"url": "/new-event"
},
{
"name": "View today's events",
"url": "/today"
}
]
}
```
The most important properties of each shortcut object are:
- `name`
- : The name of the shortcut, which is displayed in the shortcut menu. Make sure to keep it short but also descriptive enough to let users know what the shortcut does.
- `url`
- : The URL to launch the PWA with when the user selects the shortcut. This URL can be absolute, in which case it should exist within the [scope](/en-US/docs/Web/Manifest/scope) of the web app manifest. The URL can also be relative, in which case it's resolved relative to the PWA's [start URL](/en-US/docs/Web/Manifest/start_url).
All other shortcut object properties are optional, but you should consider providing them to make the shortcut more useful to users:
- `short_name`
- : A short name for the shortcut, which is displayed when there's not enough space to display the full name.
- `description`
- : A description of the shortcut. This string can be accessed by assistive technologies, such as screen readers, to help users understand what the shortcut does.
- `icons`
- : An array of image objects to display in the shortcut menu. Each image object is processed just like the [`icons`](/en-US/docs/Web/Manifest/icons) member of the web app manifest, and can be used to provide different-sized icons for different device requirements.
## See also
- [`shortcuts` manifest member](/en-US/docs/Web/Manifest/shortcuts)
- [Get things done quickly with app shortcuts](https://web.dev/articles/app-shortcuts) on web.dev (2022)
- [Define app shortcuts](https://learn.microsoft.com/microsoft-edge/progressive-web-apps-chromium/how-to/shortcuts) on learn.microsoft.com (2023)
| 0 |
data/mdn-content/files/en-us/web/progressive_web_apps | data/mdn-content/files/en-us/web/progressive_web_apps/tutorials/index.md | ---
title: Tutorials
slug: Web/Progressive_web_apps/Tutorials
page-type: landing-page
---
{{PWASidebar}}
This page lists tutorials to help learn how to develop PWAs. Tutorials walk through the steps of creating an app, from start to finish, explaining how the different features of the app are implemented.
- [Creating your first PWA](/en-US/docs/Web/Progressive_web_apps/Tutorials/CycleTracker)
- : This novice-level tutorial walks through the creation of a PWA to track menstrual cycles. Lessons include a walk through of the HTML, CSS, and JavaScript required to create a fully functional web app, setting up a testing environment, and complete explanations guiding the learner through upgrading the web app into a PWA; including developing and inspecting a manifest, adding a service worker, and using the service worker to delete stale caches.
- [Deep dive into PWA](/en-US/docs/Web/Progressive_web_apps/Tutorials/js13kGames)
- : This intermediate-level tutorial walks through the creation of a PWA that lists information about games submitted to the A-Frame category in the [js13kGames 2017](https://2017.js13kgames.com/) competition. This tutorial includes all the basics for creating a PWA, with additional features, including notifications, push, and app performance.
| 0 |
data/mdn-content/files/en-us/web/progressive_web_apps/tutorials | data/mdn-content/files/en-us/web/progressive_web_apps/tutorials/js13kgames/index.md | ---
title: js13kGames
slug: Web/Progressive_web_apps/Tutorials/js13kGames
page-type: landing-page
---
{{NextMenu("Web/Progressive_web_apps/Tutorials/js13kGames/App_structure", "Web/Progressive_web_apps/Tutorials/js13kGames")}}
{{PWASidebar}}
In this tutorial we will examine the source code of a website that lists information about games submitted to the _A-Frame_ category in the [js13kGames 2017](https://2017.js13kgames.com/) competition. You don't have to think about what the actual content on the website is; the main point is to learn how to use PWA features in your own projects.
You can [see this app in action](https://mdn.github.io/pwa-examples/js13kpwa/) online, and the source code is [available on GitHub](https://github.com/mdn/pwa-examples/tree/main/js13kpwa). We'll be examining this code carefully over the course of this tutorial.
Let's start by looking at the structure of our example app.
{{NextMenu("Web/Progressive_web_apps/Tutorials/js13kGames/App_structure", "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/installable_pwas/index.md | ---
title: How to make PWAs installable
slug: Web/Progressive_web_apps/Tutorials/js13kGames/Installable_PWAs
page-type: guide
---
{{PreviousMenuNext("Web/Progressive_web_apps/Tutorials/js13kGames/Offline_Service_workers", "Web/Progressive_web_apps/Tutorials/js13kGames/Re-engageable_Notifications_Push", "Web/Progressive_web_apps/Tutorials/js13kGames")}}
{{PWASidebar}}
In the last step of this tutorial, we read about how the example application, [js13kPWA](https://mdn.github.io/pwa-examples/js13kpwa/), works offline thanks to its [service worker](/en-US/docs/Web/API/Service_Worker_API), but we can go even further and allow users to install the web app on their device. The installed web app can then be launched by users just as if it were any OS-native app. This article explains how to achieve this using the web app's manifest.
The web app manifest allows the app to be launched directly from the device's home screen, taskbar, or dock, rather than the user having to open the browser and then navigate to the site by using a bookmark or typing the URL. Your web app can sit next to native applications, which makes it easier for users to access. Additionally, you can specify that the app be launched in fullscreen or standalone mode, thus removing the default browser user interface that would otherwise be present, creating an even more seamless and native-like feel.
To learn more, see [Making PWAs installable](/en-US/docs/Web/Progressive_web_apps/Guides/Making_PWAs_installable).
## Requirements
To make our example application installable, the following things are needed:
- A web application manifest, with the [correct members filled in](/en-US/docs/Web/Progressive_web_apps/Guides/Making_PWAs_installable#the_web_app_manifest).
- The website to be served from a secure (HTTPS) domain.
- An icon to represent the app on the device.
- A [service worker](/en-US/docs/Web/API/Service_Worker_API) registered, to allow the app to work offline.
### The web app manifest file
The key element is a web application manifest file, which lists all the information about the website in a JSON format.
It usually resides in the root folder of a web app. It contains useful information, such as the app's title, paths to different-sized icons that can be used to represent the app on an OS (such as an icon on the home screen, an entry in the Start menu, or an icon on the desktop), and a background color to use in loading or splash screens. This information is needed for the browser to present the web app properly during the installation process, as well as within the device's app-launching interface, such as the home screen of a mobile device.
The `js13kpwa.webmanifest` file of the [js13kPWA](https://mdn.github.io/pwa-examples/js13kpwa/) web app is included in the {{HTMLElement("head")}} block of the `index.html` file using the following line of code:
```html
<link rel="manifest" href="js13kpwa.webmanifest" />
```
> **Note:** many use `manifest.json` for web app manifests as the contents are organized in a JSON structure. However, the `.webmanifest` file format is explicitly mentioned in the [W3C manifest specification](https://w3c.github.io/manifest/), so that's what we'll use here.
The content of the file looks like this:
```json
{
"name": "js13kGames Progressive Web App",
"short_name": "js13kPWA",
"description": "Progressive Web App that lists games submitted to the A-Frame category in the js13kGames 2017 competition.",
"icons": [
{
"src": "icons/icon-32.png",
"sizes": "32x32",
"type": "image/png"
},
// ...
{
"src": "icons/icon-512.png",
"sizes": "512x512",
"type": "image/png"
}
],
"start_url": "/pwa-examples/js13kpwa/index.html",
"display": "fullscreen",
"theme_color": "#B12A34",
"background_color": "#B12A34"
}
```
Most of the members are self-explanatory. Here is a description of the members shown in the previous code sample:
- `name`: The full name of your web app.
- `short_name`: Short name to be shown on the home screen.
- `description`: A sentence or two explaining what your app does.
- `icons`: Information about the app icons — source URLs, sizes, and types. Be sure to include at least a few, so that one that fits best will be chosen for the user's device. See [Define your app icons](/en-US/docs/Web/Progressive_web_apps/How_to/Define_app_icons).
- `start_url`: The index document to launch when starting the app.
- `display`: How the app is displayed; can be `fullscreen`, `standalone`, `minimal-ui`, or `browser`.
- `theme_color`: A primary color for the UI, used by operating system.
- `background_color`: A color used as the app's default background, used during install and on the splash screen.
There are even more members you can use than listed above — be sure to check the [Web App Manifest reference](/en-US/docs/Web/Manifest) for details.
## Installing the PWA
Using the information found in our web app manifest, supporting browsers can display an installation prompt to the user. When the user visits the PWA, they can be prompted to install it on their device. When they accept the prompt, the PWA is installed just like other OS-native apps and the user can launch and use the web app as normal.
To learn more about how users can install PWAs, see [Installing and uninstalling web apps](/en-US/docs/Web/Progressive_web_apps/Guides/Installing).
### Splash screen
On certain devices, a splash screen is also generated from the information in the manifest, which is shown when the PWA is launched and while it's being loaded.
The icon and the theme and background colors are used to create this screen.
## Summary
In this article, we learned about how we can make PWAs installable with a properly-configured web app manifest, and how the user can then install the PWA on their devices.
Now let's move to the last step in our PWA tutorial: using push notifications to share announcements with the user, and to help the user re-engage with our app.
{{PreviousMenuNext("Web/Progressive_web_apps/Tutorials/js13kGames/Offline_Service_workers", "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/re-engageable_notifications_push/index.md | ---
title: How to make PWAs re-engageable using Notifications and Push
slug: Web/Progressive_web_apps/Tutorials/js13kGames/Re-engageable_Notifications_Push
page-type: guide
---
{{PreviousMenuNext("Web/Progressive_web_apps/Tutorials/js13kGames/Installable_PWAs", "Web/Progressive_web_apps/Tutorials/js13kGames/Loading", "Web/Progressive_web_apps/Tutorials/js13kGames")}}
{{PWASidebar}}
Having the ability to cache the contents of an app to work offline is a great feature. Allowing the user to install the web app on their device is even better. But instead of relying only on user actions, we can do more, using push messages and notifications to automatically re-engage and deliver new content whenever it is available.
## Two APIs, one goal
The [Push API](/en-US/docs/Web/API/Push_API) and [Notifications API](/en-US/docs/Web/API/Notifications_API) are two separate APIs, but they work well together when you want to provide engaging functionality in your app. Push is used to deliver new content from the server to the app without any client-side intervention, and its operation is handled by the app's service worker. Notifications can be used by the service worker to show new information to the user, or at least alert them when something has been updated.
They work outside of the browser window, just like service workers, so updates can be pushed and notifications can be shown when the app's page is out of focus or even closed.
## Notifications
Let's start with notifications — they can work by themselves, but become more useful when combined with push. Let's look at notifications in isolation to begin with.
### Request permission
To show a notification, we have to request permission to do so first. Instead of showing the notification immediately though, best practice dictates that we should show the popup when the user requests it by clicking on a button:
```js
const button = document.getElementById("notifications");
button.addEventListener("click", () => {
Notification.requestPermission().then((result) => {
if (result === "granted") {
randomNotification();
}
});
});
```
This shows a popup using the operating system's own notifications service:
When the user confirms to receive notifications, the app can then show them. The result of the user action can be default, granted or denied. The default option is chosen when the user won't make a choice, and the other two are set when the user clicks yes or no respectively.
When accepted, the permission works for both notifications and push.
### Create a notification
The example app creates a notification out of the available data — a game is picked at random, and the chosen one feeds the notification with the content: it sets the game's name as the title, mentioning the author in the body, and showing the image as an icon:
```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);
}
```
A new random notification is created every 30 seconds until it becomes too annoying and is disabled by the user. (For a real app, the notifications should be much less frequent, and more useful.) The advantage of the Notifications API is that it uses the operating system's notification functionality. This means that notifications can be displayed to the user even when they are not looking at the web app, and the notifications look similar to ones displayed by native apps.
## Push
Push is more complicated than notifications — we need to subscribe to a server that will then send the data back to the app. The app's Service Worker will receive data from the push server, which can then be shown using the notifications system, or another mechanism if desired.
The technology is still at a very early stage — some working examples use the Google Cloud Messaging platform, but are being rewritten to support [VAPID](https://blog.mozilla.org/services/2016/08/23/sending-vapid-identified-webpush-notifications-via-mozillas-push-service/) (Voluntary Application Identification), which offers an extra layer of security for your app.
You can examine the [Service Workers Cookbook examples](https://github.com/mdn/serviceworker-cookbook/tree/master/push-payload), try to set up a push messaging server using [Firebase](https://firebase.google.com/), or build your own server (using Node.js for example).
As mentioned before, to be able to receive push messages, you have to have a service worker, the basics of which are already explained in the [Making PWAs work offline with Service workers](/en-US/docs/Web/Progressive_web_apps/Tutorials/js13kGames/Offline_Service_workers) article. Inside the service worker, a push-service subscription mechanism is created by calling the [`getSubscription()`](/en-US/docs/Web/API/PushManager/getSubscription) method of the [`PushManager`](/en-US/docs/Web/API/PushManager) interface.
```js
navigator.serviceWorker.register("service-worker.js").then((registration) => {
return registration.pushManager.getSubscription().then(/* ... */);
});
```
Once the user is subscribed, they can receive push notifications from the server.
From the server-side, the whole process has to be encrypted with public and private keys for security reasons — allowing everyone to send push messages unsecured using your app would be a terrible idea. See the [Web Push data encryption test page](https://jrconlin.github.io/WebPushDataTestPage/) for detailed information about securing the server. The server stores all the information received when the user subscribed, so the messages can be sent later on when needed.
To receive push messages, we can listen to the {{domxref("ServiceWorkerGlobalScope.push_event", "push")}} event in the Service Worker file:
```js
self.addEventListener("push", (e) => {
/* ... */
});
```
The data can be retrieved and then shown as a notification to the user immediately. This, for example, can be used to remind the user about something, or let them know about new content being available in the app.
### Push example
Push needs the server part to work, so we're not able to include it in the js13kPWA example hosted on GitHub Pages, as it offers hosting of static files only. It is all explained in the [Service Worker Cookbook](https://github.com/mdn/serviceworker-cookbook) — see the [Push Payload Demo](https://github.com/mdn/serviceworker-cookbook/tree/master/push-payload).
This demo consists of three files:
- [index.js](https://github.com/mdn/serviceworker-cookbook/blob/master/push-payload/index.js), which contains the source code of our app
- [server.js](https://github.com/mdn/serviceworker-cookbook/blob/master/push-payload/server.js), which contains the server part (written in Node.js)
- [service-worker.js](https://github.com/mdn/serviceworker-cookbook/blob/master/push-payload/service-worker.js), which contains the Service Worker-specific code.
Let's explore all of these
#### index.js
The `index.js` file starts by registering the service worker:
```js
navigator.serviceWorker
.register("service-worker.js")
.then((registration) => {
return registration.pushManager
.getSubscription()
.then(async (subscription) => {
// registration part
});
})
.then((subscription) => {
// subscription part
});
```
It is a little bit more complicated than the service worker we saw in the [js13kPWA demo](https://mdn.github.io/pwa-examples/js13kpwa/). In this particular case, after registering, we use the registration object to subscribe, and then use the resulting subscription object to complete the whole process.
In the registration part, the code looks like this:
```js
async (subscription) => {
if (subscription) {
return subscription;
}
};
```
If the user has already subscribed, we then return the subscription object and move to the subscription part. If not, we initialize a new subscription:
```js
const response = await fetch("./vapidPublicKey");
const vapidPublicKey = await response.text();
const convertedVapidKey = urlBase64ToUint8Array(vapidPublicKey);
```
The app fetches the server's public key and converts the response to text; then it needs to be converted to a Uint8Array (to support Chrome). To learn more about VAPID keys you can read the [Sending VAPID identified WebPush Notifications via Mozilla's Push Service](https://blog.mozilla.org/services/2016/08/23/sending-vapid-identified-webpush-notifications-via-mozillas-push-service/) blog post.
The app can now use the {{domxref("PushManager")}} to subscribe the new user. There are two options passed to the {{domxref("PushManager.subscribe()")}} method — the first is `userVisibleOnly: true`, which means all the notifications sent to the user will be visible to them, and the second one is the `applicationServerKey`, which contains our successfully acquired and converted VAPID key.
```js
registration.pushManager.subscribe({
userVisibleOnly: true,
applicationServerKey: convertedVapidKey,
});
```
Now let's move to the subscription part — the app first sends the subscription details as JSON to the server using Fetch.
```js
fetch("./register", {
method: "post",
headers: {
"Content-type": "application/json",
},
body: JSON.stringify({ subscription }),
});
```
Then the {{domxref("Element.click_event", "onclick")}} function on the _Subscribe_ button is defined:
```js
document.getElementById("doIt").onclick = () => {
const payload = document.getElementById("notification-payload").value;
const delay = document.getElementById("notification-delay").value;
const ttl = document.getElementById("notification-ttl").value;
fetch("./sendNotification", {
method: "post",
headers: {
"Content-type": "application/json",
},
body: JSON.stringify({
subscription,
payload,
delay,
ttl,
}),
});
};
```
When the button is clicked, `fetch` asks the server to send the notification with the given parameters: `payload` is the text that to be shown in the notification, `delay` defines a delay in seconds until the notification will be shown, and `ttl` is the time-to-live setting that keeps the notification available on the server for a specified amount of time, also defined in seconds.
Now, onto the next JavaScript file.
#### server.js
The server part is written in Node.js and needs to be hosted somewhere suitable, which is a subject for an entirely separate article. We will only provide a high-level overview here.
The [web-push module](https://www.npmjs.com/package/web-push) is used to set the VAPID keys, and optionally generate them if they are not available yet.
```js
const webPush = require("web-push");
if (!process.env.VAPID_PUBLIC_KEY || !process.env.VAPID_PRIVATE_KEY) {
console.log(
"You must set the VAPID_PUBLIC_KEY and VAPID_PRIVATE_KEY " +
"environment variables. You can use the following ones:",
);
console.log(webPush.generateVAPIDKeys());
return;
}
webPush.setVapidDetails(
"https://example.com",
process.env.VAPID_PUBLIC_KEY,
process.env.VAPID_PRIVATE_KEY,
);
```
Next, a module defines and exports all the routes an app needs to handle: getting the VAPID public key, registering, and then sending notifications.
You can see the variables from the `index.js` file being used: `payload`, `delay` and `ttl`.
```js
module.exports = (app, route) => {
app.get(`${route}vapidPublicKey`, (req, res) => {
res.send(process.env.VAPID_PUBLIC_KEY);
});
app.post(`${route}register`, (req, res) => {
res.sendStatus(201);
});
app.post(`${route}sendNotification`, (req, res) => {
const subscription = req.body.subscription;
const payload = req.body.payload;
const options = {
TTL: req.body.ttl,
};
setTimeout(() => {
webPush
.sendNotification(subscription, payload, options)
.then(() => {
res.sendStatus(201);
})
.catch((error) => {
console.log(error);
res.sendStatus(500);
});
}, req.body.delay * 1000);
});
};
```
#### service-worker.js
The last file we will look at is the service worker:
```js
self.addEventListener("push", (event) => {
const payload = event.data?.text() ?? "no payload";
event.waitUntil(
self.registration.showNotification("ServiceWorker Cookbook", {
body: payload,
}),
);
});
```
All it does is add a listener for the {{domxref("ServiceWorkerGlobalScope.push_event", "push")}} event, create the payload variable consisting of the text taken from the data (or create a string to use if data is empty), and then wait until the notification is shown to the user.
Feel free to explore the rest of the examples in the [Service Worker Cookbook](https://github.com/mdn/serviceworker-cookbook) if you want to know how they are handled.
There's a big collection of working examples showing general use, but also web push, caching strategies, performance, working offline, and more.
{{PreviousMenuNext("Web/Progressive_web_apps/Tutorials/js13kGames/Installable_PWAs", "Web/Progressive_web_apps/Tutorials/js13kGames/Loading", "Web/Progressive_web_apps/Tutorials/js13kGames")}}
| 0 |
Subsets and Splits