Svelte preprocess CSS Modules

Generate CSS Modules classnames on Svelte components

1npm install --save-dev svelte-preprocess-cssmodules

for svelte 4 and below, use version 2 of the preprocessor.

Table of Content

• Usage
  • Approach
  • Class objects and arrays
  • Class directive
  • Local selector
  • CSS binding
  • Scoped class on child components
• Import styles from an external stylesheet
  • Destructuring import
  • kebab-case situation
  • Unnamed import
  • Directive and dynamic class
• Preprocessor Modes
  • Native
  • Mixed
  • Scoped
  • Comparative
• Why CSS Modules over Svelte scoping?
• Configuration
  • Rollup
  • Webpack
  • SvelteKit
  • Svelte Preprocess
  • Vite
  • Options
• Code example

Usage

Add the module attribute to <style>

1<style module>
2  .red { color: red; }
3</style>
4
5<p class="red">My red text</p>

The component will be compiled to

1<style>
2  .red-30_1IC { color: red; }
3</style>
4
5<p class="red-30_1IC">My red text</p>

Approach

The default svelte scoping appends every css selectors with a unique class to only affect the elements of the component.

CSS Modules scopes each class name with a unique id/name in order to affect the elements of the component. As the other selectors are not scoped, it is recommended to write each selector with a class.

1<!-- Component A -->
2<p>lorem ipsum tut moue</p>
3<p class="red">lorem ipsum tut moue</p>
4
5<style module>
6  p { font-size: 14px; }
7  .red { color: red; }
8</style>

1<!-- Component B -->
2<p class="text">lorem ipsum tut moue</p>
3<p class="text red">lorem ipsum tut moue</p>
4
5<style module>
6  .text { font-size: 14px; }
7  .red { color: red; }
8</style>

transformed to

1<!-- Component A -->
2<p>lorem ipsum tut moue</p>
3<p class="red-123qwe">lorem ipsum tut moue</p>
4
5<style module>
6  p { font-size: 14px; } /* global rule */
7  .red-123qwe { color: red; }
8</style>

1<!-- Component B -->
2<p class="text-456rty">lorem ipsum tut moue</p>
3<p class="text-456rty red-123qwe">lorem ipsum tut moue</p>
4
5<style> /* all scoped to component */
6  .text-456rty { font-size: 14px; }
7  .red-123qwe { color: red; }
8</style>

Class objects and arrays

Object with thruthy values

1<script>
2	let active = $state(true);
3</script>
4
5<div class={{ active, red: !active, 'bold': active }}>...</div>
6
7<style module>
8  .active { color: green; }
9  .red { color: red; }
10  .bold { font-weight: bold; }
11</style>

generating

1<div class="active-aft3ew bold-sfkje6">...</div>
2<!-- OR -->
3<div class="red-bft3ed">...</div>
4
5<style>
6  .active-aft3ew { color: green; }
7  .red-bft3ed { color: red; }
8  .bold-sfkje6 { font-weight: bold; }
9</style>

Array with thruthy values

1<script>
2	let active = $state(true);
3</script>
4
5<div class={[ active && 'green bold', 'italic', !active && 'red' ]}>...</div>
6
7<style module>
8  .green { color: green; }
9  .red { color: red; }
10  .bold { font-weight: bold; }
11  .italic { font-style: italic; }
12</style>

generating

1<div class="green-dhy6wu bold-uytsge italic-b65wfq">...</div>
2<!-- OR -->
3<div class="red-uyqrw4 italic-b65wfq">...</div>
4
5<style>
6  .green-dhy6wu { color: green; }
7  .red-uyqrw4 { color: red; }
8  .bold-uytsge { font-weight: bold; }
9  .italic-b65wfq { font-style: italic; }
10</style>

Class directive

Toggle a class on an element.

1<script>
2  let route = $state('home');
3  let isActive = $derived(route === 'home');
4</script>
5
6<style module>
7  .active { font-weight: bold; }
8</style>
9
10<a class:active={isActive} href="/">Home</a>
11<!-- or -->
12<a class="{isActive ? 'active' : ''}" href="/">Home</a>

generating

1<style>
2  .active-2jIMhI { font-weight: bold; }
3</style>
4
5<a class="active-2jIMhI" href="/">Home</a>

Use of shorthand

1<script>
2  let route = $state('home');
3  let active = $derived(route === 'home');
4</script>
5
6<style module>
7  .active { font-weight: bold; }
8</style>
9
10<a class:active href="/">Home</a>

generating

1<style>
2  .active-2jIMhI { font-weight: bold; }
3</style>
4
5<a class="active-2jIMhI" href="/">Home</a>

Local selector

Force a selector to be scoped within its component to prevent style inheritance on child components.

:local() is doing the opposite of :global() and can only be used with the native and mixed modes (see preprocessor modes). The svelte scoping is applied to the selector inside :local().

1<!-- Parent Component -->
2
3<style module>
4  .main em { color: grey; }
5  .main :local(strong) { font-weight: 900; }
6</style>
7
8<div class="main">
9  <p>My <em>main</em> lorem <strong>ipsum tuye</strong></p>
10  <ChildComponent />
11</div>

1<!-- Child Component-->
2
3<style module>
4  /** Rule to override parent style **/
5  .child em { color: black; }
6
7  /** 
8   * Unnecessary rule because of the use of :local()
9   .child strong { font-weight: 700 }
10   */
11</style>
12
13<p class="child">My <em>secondary</em> lorem <strong>ipsum tuye</strong></p>

generating

1<!-- Parent Component-->
2
3<style>
4  .main-Yu78Wr em { color: grey; }
5  .main-Yu78Wr strong.svelte-ery8ts { font-weight: 900; }
6</style>
7
8<div class="main-Yu78Wr">
9  <p>My <em>main</em> lorem <strong class="svelte-ery8ts">ipsum tuye</strong></p>
10  <ChildComponent />
11</div>

1<!-- Child Component-->
2
3<style>
4  .child-uhRt2j em { color: black; }
5</style>
6
7<p class="child-uhRt2j">My <em>secondary</em> lorem <strong>ipsum tuye</strong></p>

When used with a class, :local() cssModules is replaced by the svelte scoping system. This could be useful when targetting global classnames.

1<style module>
2  .actions {
3    padding: 10px;
4  }
5  /* target a css framework classname without replacing it*/
6  :local(.btn-primary) {
7    margin-right: 10px;
8  }
9</style>
10
11<div class="actions">
12  <button class="btn btn-primary">Ok</button>
13  <button class="btn btn-default">Cancel</button>
14</div>

generating

1<style>
2  .actions-7Fhti9 {
3    padding: 10px;
4  }
5  .btn-primary.svelte-saq8ts {
6    margin-right: 10px;
7  }
8</style>
9
10<div class="actions-7Fhti9">
11  <button class="btn btn-primary svelte-saq8ts">Ok</button>
12  <button class="btn btn-default">Cancel</button>
13</div>

CSS binding

Link the value of a CSS property to a dynamic variable by using bind().

1<script>
2  let color = $state('red');
3</script>
4
5<p class="text">My lorem ipsum text</p>
6
7<style module>
8  .text {
9    font-size: 18px;
10    font-weight: bold;
11    color: bind(color);
12  }
13</style>

A scoped css variable, binding the declared statement, will be created on the component root elements which the css property will inherit from.

1<script>
2  let color = 'red';
3</script>
4
5<p class="text-t56rwy" style="--color-eh7sp:{color}">
6  My lorem ipsum text
7</p>
8
9<style>
10  .text-t56rwy {
11    font-size: 18px;
12    font-weight: bold;
13    color: var(--color-eh7sp);
14  }
15</style>

An object property can also be targetted and must be wrapped with quotes.

1<script>
2  const style = $state({
3    opacity: 0;
4  });
5</script>
6
7<div class="content">
8  <h1>Heading</h1>
9  <p class="text">My lorem ipsum text</p>
10</div>
11
12<style module>
13  .content {
14    padding: 10px 20px;
15    background-color: #fff;
16  }
17  .text {
18    opacity: bind('style.opacity');
19  }
20</style>

generating

1<script>
2  const style = $state({
3    opacity: 0;
4  });
5</script>
6
7<div class="content-dhye8T" style="--opacity-r1gf51:{style.opacity}">
8  <h1>Heading</h1>
9  <p class="text-iTsx5A">My lorem ipsum text</p>
10</div>
11
12<style>
13  .content-dhye8T {
14    padding: 10px 20px;
15    background-color: #fff;
16  }
17  .text-iTsx5A {
18    opacity: var(--opacity-r1gf51);
19  }
20</style>

Scoped class on child components

CSS Modules allows you to pass a scoped classname to a child component giving the possibility to style it from its parent. (Only with the native and mixed modes – See preprocessor modes).

1<!-- Child Component Button.svelte -->
2<script>
3  let props = $props();
4</script>
5
6<button class={['btn', props.class]}>
7  {@render props.children?.()}
8</button>
9
10<style module>
11  .btn {
12    background: red;
13    color: white;
14  }
15</style>

1<!-- Parent Component -->
2
3<script>
4  import Button from './Button.svelte';
5</script>
6
7<div class="wrapper">
8  <h1>Welcome</h1>
9  <p>Lorem ipsum tut ewou tu po</p>
10  <Button class="btn">Start</Button>
11</div>
12
13<style module>
14  .wrapper {
15    margin: 0 auto;
16    padding: 16px;
17    max-width: 400px;
18  }
19  .btn {
20    margin-top: 30px;
21  }
22</style>

generating

1<div class="wrapper-tyaW3">
2  <h1>Welcome</h1>
3  <p>Lorem ipsum tut ewou tu po</p>
4  <button class="btn-dtg87W btn-rtY6ad">Start</button>
5</div>
6
7<style>
8  .wrapper-tyaW3 {
9    margin: 0 auto;
10    padding: 16px;
11    max-width: 400px;
12  }
13  .btn-dtg87W {
14    margin-top: 30px;
15  }
16  .btn-rtY6ad {
17    background: red;
18    color: white;
19  }
20</style>

Import styles from an external stylesheet

Alternatively, styles can be created into an external file and imported onto a svelte component. The name referring to the import can then be used on the markup to target any existing classname of the stylesheet.

• The option parseExternalStylesheet need to be enabled.
• The css file must follow the convention [FILENAME].module.css in order to be processed.

Note: That import is only meant for stylesheets relative to the component. You will have to set your own bundler in order to import node_modules css files.

1/** style.module.css **/
2.red { color: red; }
3.blue { color: blue; }

1<!-- Svelte component -->
2<script>
3  import style from './style.module.css';
4</script>
5
6<p class={style.red}>My red text</p>
7<p class={style.blue}>My blue text</p>

generating

1<style>
2  .red-en-6pb { color: red; }
3  .blue-oVk-n1 { color: blue; }
4</style>
5
6<p class="red-en-6pb">My red text</p>
7<p class="blue-oVk-n1">My blue text</p>

Destructuring import

1/** style.module.css **/
2section { padding: 10px; }
3.red { color: red; }
4.blue { color: blue; }
5.bold { font-weight: bold; }

1<!-- Svelte component -->
2<script>
3  import { red, blue } from './style.module.css';
4</script>
5
6<section>
7  <p class={red}>My <span class="bold">red</span> text</p>
8  <p class="{blue} bold">My blue text</p>
9</section>

generating

1<style>
2  section { padding: 10px; }
3  .red-1sPexk { color: red; }
4  .blue-oVkn13 { color: blue; }
5  .bold-18te3n { font-weight: bold; }
6</style>
7
8<section>
9  <p class="red-1sPexk">My <span class="bold-18te3n">red</span> text</p>
10  <p class="blue-oVkn13 bold-18te3n">My blue text</p>
11</section>

kebab-case situation

The kebab-case class names are being transformed to a camelCase version to facilitate their use on Markup and Javascript.

1/** style.module.css **/
2.success { color: green; }
3.error-message {
4  color: red;
5  text-decoration: line-through;
6}

1<script>
2  import css from './style.module.css';
3</script>
4
5<p class={css.success}>My success text</p>
6<p class="{css.errorMessage}">My error message</p>
7
8<!-- OR -->
9
10<script>
11  import { success, errorMessage } from './style.module.css';
12</script>
13
14<p class={success}>My success message</p>
15<p class={errorMessage}>My error message</p>

generating

1<style>
2  .success-3BIYsG { color: green; }
3  .error-message-16LSOn {
4    color: red;
5    text-decoration: line-through;
6  }
7</style>
8
9<p class="success-3BIYsG">My success messge</p>
10<p class="error-message-16LSOn">My error message</p>

Unnamed import

If a css file is being imported without a name, CSS Modules will still apply to the classes of the stylesheet.

1/** style.module.css **/
2p { font-size: 18px; }
3.success { color: green; }

1<script>
2  import './style.module.css'
3</script>
4
5<p class="success">My success message</p>
6<p>My another message</p>

generating

1<style>
2  p { font-size: 18px; }
3  .success-vg78j0 { color: green; }
4</style>
5
6<p class="success-vg78j0">My success messge</p>
7<p>My error message</p>

Directive and Dynamic class

Use the Svelte's builtin class: directive or javascript template to display a class dynamically.
Note: the shorthand directive is NOT working with imported CSS Module identifiers.

1<script>
2  import { success, error } from './style.module.css';
3
4  let isSuccess = $state(true);
5  let notice = $derived(isSuccess ? success : error);
6</script>
7
8<button on:click={() => isSuccess = !isSuccess}>Toggle</button>
9
10<!-- Error -->
11<p class:success>Success</p>
12
13<!-- Ok -->
14<p 
15  class:success={isSuccess}
16  class:error={!isSuccess}>Notice</p>
17
18<p class={notice}>Notice</p>
19<p class={isSuccess ? success : error}>Notice</p>

Preprocessor Modes

The mode can be set globally from the config or locally to override the global setting.

Native

Scopes classes with CSS Modules, anything else is unscoped.

Pros:

• uses default CSS Modules approach
• creates unique ID to avoid classname conflicts and unexpected inheritances
• passes scoped class name to child components

Cons:

• does not scope non class selectors.
• forces to write selectors with classes.
• needs to consider third party plugins with useAsDefaultScoping on – Read more.

Mixed

Scopes non-class selectors with svelte scoping in addition to native (same as preprocessor v1)

1<style module="mixed">
2  p { font-size: 14px; }
3  .red { color: red; }
4</style>
5
6<p class="red">My red text</p>

generating

1<style>
2  p.svelte-teyu13r { font-size: 14px; }
3  .red-30_1IC { color: red; }
4</style>
5
6<p class="red-30_1IC svelte-teyu13r">My red text</p>

Pros:

• creates class names with unique ID to avoid conflicts and unexpected inheritances
• uses svelte scoping on non class selectors
• passes scoped class name to child components

Cons:

• adds more weight to tag selectors than class selectors (because of the svelte scoping)

1<ul>
2 <li>Home</li>
3 <li class="active">About</li>
4</ul>
5
6<style module="mixed">
7 li {
8   color: gray; 
9 }
10 /* this will never be applied */
11 .active {
12   color: blue;
13 }
14 /* forcing us to write that instead */
15 li.active {
16   color: blue;
17 }
18</style>
19
20<!-- or rewriting the component -->
21
22<ul>
23 <li class="item">Home</li>
24 <li class="item active">About</li>
25</ul>
26
27<style module="mixed">
28 .item {
29   color: gray; 
30 }
31 .active {
32   color: blue;
33 }
34</style>

Scoped

Scopes classes with svelte scoping in addition to mixed.

1<style module="scoped">
2  p { font-size: 14px; }
3  .red { color: red; }
4</style>
5
6<p class="red">My red text</p>

generating

1<style>
2  p.svelte-teyu13r { font-size: 14px; }
3  .red-30_1IC.svelte-teyu13r { color: red; }
4</style>
5
6<p class="red-30_1IC svelte-teyu13r">My red text</p>

Pros:

• creates class names with unique ID to avoid conflicts and unexpected inheritances
• scopes every selectors at equal weight

Cons:

• does not pass scoped classname to child components

Comparative

	Svelte scoping	Preprocessor Native	Preprocessor Mixed	Preprocessor Scoped
Scopes classes	O	O	O	O
Scopes non class selectors	O	X	O	O
Creates unique class ID	X	O	O	O
Has equal selector weight	O	O	X	O
Passes scoped classname to a child component	X	O	O	X

Why CSS Modules over Svelte scoping?

• On a full svelte application: it is just a question of taste as the default svelte scoping is largely enough. Component styles will never inherit from other styling.

• On a hybrid project (like using svelte to enhance a web page): the default scoping may actually inherits from a class of the same name belonging to the style of the page. In that case using CSS Modules to create a unique ID and to avoid class inheritance might be advantageous.

Configuration

Rollup

To be used with the plugin rollup-plugin-svelte.

1import svelte from 'rollup-plugin-svelte';
2import { cssModules } from 'svelte-preprocess-cssmodules';
3
4export default {
5  ...
6  plugins: [
7    svelte({
8      preprocess: [
9        cssModules(),
10      ]
11    }),
12  ]
13  ...
14}

Webpack

To be used with the loader svelte-loader.

1const { cssModules } = require('svelte-preprocess-cssmodules');
2
3module.exports = {
4  ...
5  module: {
6    rules: [
7      {
8        test: /\.svelte$/,
9        exclude: /node_modules/,
10        use: [
11          {
12            loader: 'svelte-loader',
13            options: {
14              preprocess: [
15                cssModules(),
16              ]
17            }
18          }
19        ]
20      }
21    ]
22  }
23  ...
24}

SvelteKit

As the module distribution is targetting esnext, Node.js 14 or above is required in order to work.

1// svelte.config.js
2
3import { cssModules } from 'svelte-preprocess-cssmodules';
4
5const config = {
6  ...
7  preprocess: [
8    cssModules(),
9  ]
10};
11
12export default config;

Svelte Preprocess

The CSS Modules preprocessor requires the compoment to be a standard svelte component (using vanilla js and vanilla css). if any other code, such as Typescript or Sass, is encountered, an error will be thrown. Therefore CSS Modules needs to be run at the very end.

1import { typescript, scss } from 'svelte-preprocess';
2import { cssModules } from 'svelte-preprocess-cssmodules';
3
4...
5// svelte config:
6  preprocess: [
7    typescript(),
8    scss(),
9    cssModules(), // run last
10  ],
11...

Vite

Set the svelte.config.js accordingly.

1import { vitePreprocess } from '@sveltejs/vite-plugin-svelte';
2import { cssModules } from 'svelte-preprocess-cssmodules';
3
4export default {
5  preprocess: [
6    vitePreprocess(),
7    cssModules()
8  ]
9};

Options

Pass an object of the following properties

Name	Type	Default	Description
cssVariableHash	{String}	[hash:base64:6]	The hash type (see locatonIdentName)
getLocalIdent	Function	undefined	Generate the classname by specifying a function instead of using the built-in interpolation
hashSeeder	{Array}	['style', 'filepath', 'classname']	An array of keys to base the hash on
includeAttributes	{Array}	[]	An array of attributes to parse along with class
includePaths	{Array}	[] (Any)	An array of paths to be processed
localIdentName	{String}	"[local]-[hash:base64:6]"	A rule using any available token
mode	native|mixed|scoped	native	The preprocess mode to use
parseExternalStylesheet	{Boolean}	false	Enable parsing on imported external stylesheet
parseStyleTag	{Boolean}	true	Enable parsing on style tag
useAsDefaultScoping	{Boolean}	false	Replace svelte scoping globally

getLocalIdent

Customize the creation of the classname instead of relying on the built-in function.

1function getLocalIdent(
2  context: {
3    context: string, // the context path
4    resourcePath: string, // path + filename
5  },
6  localIdentName: {
7    template: string, // the template rule
8    interpolatedName: string, // the built-in generated classname
9  },
10  className: string, // the classname string
11  content: { 
12    markup: string, // the markup content
13    style: string,  // the style content
14  }
15): string {
16  return `your_generated_classname`;
17}

Example of use

1# Directory
2SvelteApp
3└─ src
4   ├─ App.svelte
5   └─ components
6      └─ Button.svelte

1<!-- Button.svelte -->
2<button class="red">Ok</button>
3
4<style>
5  .red { background-color: red; }
6</style>

1// Preprocess config
2...
3preprocess: [
4  cssModules({
5    localIdentName: '[path][name]__[local]',
6    getLocalIdent: (context, { interpolatedName }) => {
7      return interpolatedName.toLowerCase().replace('src_', '');
8      // svelteapp_components_button__red;
9    }
10  })
11],
12...

hashSeeder

Set the source of the hash (when using [hash] / [contenthash]).

The list of available keys are:

• style the content of the style tag (or the imported stylesheet)
• filepath the path of the component
• classname the local classname

Example of use: creating a common hash per component

1// Preprocess config
2...
3preprocess: [
4  cssModules({
5    hashSeeder: ['filepath', 'style'],
6  })
7],
8...

1<button class="success">Ok</button>
2<button class="cancel">Cancel</button>
3<style module>
4  .success { background-color: green; }
5  .cancel { background-color: gray; }
6</style>

generating

1<button class="success-yr6RT">Ok</button>
2<button class="cancel-yr6RT">Cancel</button>
3<style>
4  .success-yr6RT { background-color: green; }
5  .cancel-yr6RT { background-color: gray; }
6</style>

includeAttributes

Add other attributes than class to be parsed by the preprocesser

1// Preprocess config
2...
3preprocess: [
4  cssModules({
5    includeAttributes: ['data-color', 'classname'],
6  })
7],
8...

1<button class="red" data-color="red">Red</button>
2<button class="red" classname="blue">Red or Blue</button>
3<style module>
4  .red { background-color: red; }
5  .blue { background-color: blue; }
6</style>

generating

1<button class="red-yr6RT" data-color="red-yr6RT">Red</button>
2<button class="red-yr6RT" classname="blue-aE4qW">Red or Blue</button>
3<style>
4  .red-yr6RT { background-color: red; }
5  .blue-aE4qW { background-color: blue; }
6</style>

localIdentName

Inspired by webpack interpolateName, here is the list of tokens:

• [local] the targeted classname
• [ext] the extension of the resource
• [name] the basename of the resource
• [path] the path of the resource
• [folder] the folder the resource is in
• [contenthash] or [hash] (they are the same) the hash of the resource content (by default it's the hex digest of the md5 hash)
• [<hashType>:contenthash:<digestType>:<length>] optionally one can configure
  • other hashTypes, i. e. sha1, md5, sha256, sha512
  • other digestTypes, i. e. hex, base26, base32, base36, base49, base52, base58, base62, base64
  • and length the length in chars

useAsDefaultScoping

Globally replace the default svelte scoping by the CSS Modules scoping. As a result, the module attribute to <style> becomes unnecessary.

1// Preprocess config
2...
3preprocess: [
4  cssModules({
5    useAsDefaultScoping: true
6  }),
7],
8...

1<h1 class="title">Welcome</h1>
2<style>
3  .title { color: blue }
4</style>

generating

1<h1 class="title-erYt1">Welcome</h1>
2<style>
3  .title-erYt1 { color: blue }
4</style>

Potential issue with third party plugins

The preprocessor requires you to add the module attribute to <style> in order to apply CSS Modules to a component. When enabling useAsDefaultScoping the module attribute is not required anymore and CSS Modules will apply to all svelte components of your application, including plugins. If a third party component is relying on svelte scoping and non class selectors, its styling will apply globally and may cause unexpected results.

To prevent any scoping conflict, it is recommended to set the includePaths option to your source folder in order to target your components only.

1// Preprocess config
2...
3preprocess: [
4  cssModules({
5    useAsDefaultScoping: true,
6    includePaths: ['./src'],
7  }),
8],
9...

Code Example

Rollup Config

1export default {
2  ...
3  plugins: [
4    svelte({
5      preprocess: [
6        cssModules({
7          includePaths: ['src'],
8          localIdentName: '[hash:base64:10]',
9        }),
10      ]
11    }),
12  ]
13  ...
14}

Svelte Component

1<style module>
2  .modal {
3    position: fixed;
4  }
5  .wrapper {
6    padding: 0.5rem 1rem;
7  }
8  .body {
9    flex: 1 0 0;
10  }
11  .modal button {
12    background-color: white;
13  }
14  .cancel {
15    background-color: #f2f2f2;
16  }
17</style>
18
19<section class="modal">
20  <header class="wrapper">My Modal Title</header>
21  <div class="body wrapper">
22    <p>Lorem ipsum dolor sit, amet consectetur.</p>
23  </div>
24  <footer class="wrapper">
25    <button>Ok</button>
26    <button class="cancel">Cancel</button>
27  </footer>
28</section>

Final html code generated by svelte

1<style>
2  ._329TyLUs9c {
3    position: fixed;
4  }
5  .Re123xDTGv {
6    padding: 0.5rem 1rem;
7  }
8  ._1HPUBXtzNG {
9    flex: 1 0 0;
10  }
11  ._329TyLUs9c button {
12    background-color: white;
13  }
14  ._1xhJxRwWs7 {
15    background-color: #f2f2f2;
16  }
17</style>
18
19<section class="_329TyLUs9c">
20  <header class="Re123xDTGv">My Modal Title</header>
21  <div class="_1HPUBXtzNG Re123xDTGv">
22    <p>Lorem ipsum dolor sit, amet consectetur.</p>
23  </div>
24  <footer class="Re123xDTGv">
25    <button>Ok</button>
26    <button class="_1xhJxRwWs7">Cancel</button>
27  </footer>
28</section>

License

MIT