@aegisjsproject/styles/styles.cjs

Pre-made and reusable styles for `@aegisjsproject/core`

'use strict';

/**
 * Bootstrap Colors mapped to JS arrays.
 * `export const red[100` maps to `red[0]` and `export const red[900` maps to `red[9]`
 * or generally `(### / 100) - 1`.
 */
const red$1 = [
	'#f8d7da', '#f1aeb5', '#ea868f', '#e35d6a',
	'#dc3545', '#b02a37', '#842029', '#58151c', '#2c0b0e',
];

const blue$1 = [
	'#cfe2ff', '#9ec5fe', '#6ea8fe', '#3d8bfd',
	'#0d6efd', '#0a58ca', '#084298', '#052c65', '#031633',
];

const indigo = [
	'#e0cffc', '#c29ffa', '#a370f7', '#8540f5',
	'#6610f2', '#520dc2', '#3d0a91', '#290661', '#140330',
];

const purple$1 = [
	'#e2d9f3', '#c5b3e6', '#a98eda', '#8c68cd',
	'#6f42c1', '#59359a', '#432874', '#2c1a4d', '#160d27',
];

const pink = [
	'#f7d6e6', '#efadce', '#e685b5', '#de5c9d',
	'#d63384', '#ab296a', '#801f4f', '#561435', '#2b0a1a',
];

const orange$1 = [
	'#ffe5d0', '#fecba1', '#feb272', '#fd9843',
	'#fd7e14', '#ca6510', '#984c0c', '#653208', '#331904'
];

const yellow$1 = [
	'#fff3cd', '#ffe69c', '#ffda6a', '#ffcd39',
	'#ffc107', '#cc9a06', '#997404', '#664d03', '#332701',
];

const green$1 = [
	'#d1e7dd', '#a3cfbb', '#75b798', '#479f76',
	'#198754', '#146c43', '#0f5132', '#0a3622', '#051b11',
];

const teal = [
	'#d2f4ea', '#a6e9d5', '#79dfc1', '#4dd4ac',
	'#20c997', '#1aa179', '#13795b', '#0d503c', '#06281e',
];

const cyan = [
	'#cff4fc', '#9eeaf9', '#6edff6', '#3dd5f3',
	'#0dcaf0', '#0aa2c0', '#087990', '#055160', '#032830',
];

const gray = [
	'#f8f9fa', '#e9ecef', '#dee2e6', '#ced4da',
	'#adb5bd', '#6c757d', '#495057', '#343a40', '#212529',
];

const light$2 = gray[0];
const grayDark = gray[7];
const dark$2 = gray[8];

const primary$1 = blue$1[4];
const secondary$1 = gray[5];
const success$1 = green$1[4];
const info$1 = cyan[4];
const warning$1 = yellow$1[4];
const danger$1 = red$1[4];

var bootstrap = /*#__PURE__*/Object.freeze({
	__proto__: null,
	blue: blue$1,
	cyan: cyan,
	danger: danger$1,
	dark: dark$2,
	gray: gray,
	grayDark: grayDark,
	green: green$1,
	indigo: indigo,
	info: info$1,
	light: light$2,
	orange: orange$1,
	pink: pink,
	primary: primary$1,
	purple: purple$1,
	red: red$1,
	secondary: secondary$1,
	success: success$1,
	teal: teal,
	warning: warning$1,
	yellow: yellow$1
});

const blue = ['#99c1f1', '#62a0ea', '#3584e4', '#1c71d8', '#1a5fb4'];
const green = ['#8ff0a4', '#57e389', '#33d17a', '#2ec27e', '#26a269'];
const yellow = ['#f9f06b', '#f8e45c', '#f6d32d', '#f5c211', '#e5a50a'];
const orange = ['#ffbe6f', '#ffa348', '#ff7800', '#e66100', '#c64600'];
const red = ['#f66151', '#ed333b', '#e01b24', '#c01c28', '#a51d2d'];
const purple = ['#dc8add', '#c061cb', '#9141ac', '#813d9c', '#613583'];
const brown = ['#cdab8f', '#b5835a', '#986a44', '#865e3c', '#63452c'];
const light$1 = ['#ffffff', '#f6f5f4', '#deddda', '#c0bfbc', '#9a9996'];
const dark$1 = ['#77767b', '#5e5c64', '#3d3846', '#241f31', '#000000'];

var gnome = /*#__PURE__*/Object.freeze({
	__proto__: null,
	blue: blue,
	brown: brown,
	dark: dark$1,
	green: green,
	light: light$1,
	orange: orange,
	purple: purple,
	red: red,
	yellow: yellow
});

const colorLight = dark$2;
const colorDark = light$2;
const bgLight = light$2;
const bgDark = dark$2;
const borderLight = gray[2];
const borderDark = gray[6];
const btnPrimary = primary$1;
const btnPrimaryActive = blue$1[6];
const btnPrimaryHover = blue$1[5];
const btnSecondary = secondary$1;
const btnSecondaryActive = gray[7];
const btnSecondaryHover = gray[6];
const btnDisabled = gray[5];
const btnSuccess = success$1;
const btnSuccessActive = green$1[6];
const btnSuccessHover = green$1[5];
const btnInfo = info$1;
const btnInfoActive = cyan[5];
const btnInfoHover = cyan[6];
const btnWarning = warning$1;
const btnWarningActive = yellow$1[6];
const btnWarningHover = yellow$1[5];
const btnDanger = danger$1;
const btnDangerActive = red$1[6];
const btnDangerHover = red$1[5];
const btnLight = light$2;
const btnLightActive = gray[2];
const btnLightHover = gray[1];
const btnDark = dark$2;
const btnDarkActive = gray[7];
const btnDarkHover = gray[6];
const btnLink = 'transparent'; // Link button background should be transparent
const btnLinkHover = 'transparent';
const btnLinkActive = 'transparent';
const linkColor = 'LinkText';
const scrollbarColor = primary$1;
const scrollbarTrack = gray[8];

var aegis = /*#__PURE__*/Object.freeze({
	__proto__: null,
	bgDark: bgDark,
	bgLight: bgLight,
	borderDark: borderDark,
	borderLight: borderLight,
	btnDanger: btnDanger,
	btnDangerActive: btnDangerActive,
	btnDangerHover: btnDangerHover,
	btnDark: btnDark,
	btnDarkActive: btnDarkActive,
	btnDarkHover: btnDarkHover,
	btnDisabled: btnDisabled,
	btnInfo: btnInfo,
	btnInfoActive: btnInfoActive,
	btnInfoHover: btnInfoHover,
	btnLight: btnLight,
	btnLightActive: btnLightActive,
	btnLightHover: btnLightHover,
	btnLink: btnLink,
	btnLinkActive: btnLinkActive,
	btnLinkHover: btnLinkHover,
	btnPrimary: btnPrimary,
	btnPrimaryActive: btnPrimaryActive,
	btnPrimaryHover: btnPrimaryHover,
	btnSecondary: btnSecondary,
	btnSecondaryActive: btnSecondaryActive,
	btnSecondaryHover: btnSecondaryHover,
	btnSuccess: btnSuccess,
	btnSuccessActive: btnSuccessActive,
	btnSuccessHover: btnSuccessHover,
	btnWarning: btnWarning,
	btnWarningActive: btnWarningActive,
	btnWarningHover: btnWarningHover,
	colorDark: colorDark,
	colorLight: colorLight,
	linkColor: linkColor,
	scrollbarColor: scrollbarColor,
	scrollbarTrack: scrollbarTrack
});

const stringify = thing => {
	switch(typeof thing) {
		case 'undefined':
			return '';

		case 'boolean':
			return thing ? 'true' : 'false';

		case 'object':
			if (thing === null) {
				return '';
			} else if (thing instanceof CSSStyleSheet) {
				return [...thing.cssRules].map(rule => rule.cssText).join('\n\n');
			} else if (thing instanceof CSSRule) {
				return thing.cssText;
			} else if (thing instanceof HTMLLinkElement) {
				return stringify(thing.sheet);
			} else if (thing instanceof ArrayBuffer && Uint8Array.prototype.toBase64 instanceof Function) {
				return new Uint8Array(thing).toBase64();
			} else if (ArrayBuffer.isView(thing) && thing.toBase64 instanceof Function) {
				return thing.toBase64();
			} else if (thing instanceof Blob) {
				return URL.createObjectURL(thing);
			} else {
				return thing.toString();
			}

		default:
			return thing.toString();
	}
};

function createStyleSheet(cssRules, { media, disabled, baseURL } = {}) {
	const sheet = new CSSStyleSheet({
		media: media instanceof MediaQueryList ? media.media : media,
		disabled,
		baseURL
	});

	sheet.replace(cssRules).catch(reportError);
	return sheet;
}

function createStyleSheetSync(cssRules, { media, disabled, baseURL } = {}) {
	const sheet = new CSSStyleSheet({
		media: media instanceof MediaQueryList ? media.media : media,
		disabled,
		baseURL
	});

	sheet.replaceSync(cssRules);
	return sheet;
}

const createCSSParser = ({ media, disabled, baseURL, sync = false } = {}) => sync
	? (strings, ...args) => createStyleSheetSync(String.raw(strings, ...args.map(stringify)).trim(), { media, disabled, baseURL })
	: (strings, ...args) => createStyleSheet(String.raw(strings, ...args.map(stringify)).trim(), { media, disabled, baseURL });

const css = createCSSParser();

const layers = css`@layer reset, vendor, base, layout, components, utilities;`;

const reset = css`@layer reset.aegisjsproject {
	:root {
		color-scheme: light dark;
		interpolate-size: allow-keywords;
		-webkit-text-size-adjust: none;
		text-size-adjust: none;
	}

	body {
		margin: 0;
		hanging-punctuation: first last;
		-webkit-font-smoothing: antialiased;
	}

	*, ::before, *::after {
		box-sizing: border-box;
		transition-behavior: allow-discrete;
	}

	h1, h2, h3, h4, h5, h6 {
		text-wrap: balance;
	}

	p {
		text-wrap: pretty;
	}

	p, h1, h2, h3, h4, h5, h6 {
		overflow-wrap: break-word;
	}

	input, button, textarea, select {
		font: inherit;
		color: inherit;
	}
}`;

const customProperties = {
	'font': { initialValue: 'system-ui', syntax: '<custom-ident> | <string>' },
	'btn-border-radius': { initialValue: '5px', syntax: '<length>' },
	'btn-border-width': { initialValue: '0px', syntax: '<length>' },
	'color-light': { initialValue: colorLight, syntax: '<color>' },
	'color-dark': { initialValue: colorDark, syntax: '<color>' },
	'bg-light': { initialValue: bgLight, syntax: '<color>' },
	'bg-dark': { initialValue: bgDark, syntax: '<color>' },
	'border-color-light': { initialValue: borderLight, syntax: '<color>' },
	'border-color-dark': { initialValue: borderDark, syntax: '<color>' },
	'border-radius': { initialValue: '8px', syntax: '<length>' },
	'btn-primary': { initialValue: btnPrimary, syntax: '<color>' },
	'btn-primary-hover': { initialValue: btnPrimaryHover, syntax: '<color>' },
	'btn-primary-active': { initialValue: btnPrimaryActive, syntax: '<color>' },
	'btn-primary-disabled': { initialValue: btnDisabled, syntax: '<color>' },
	'btn-secondary': { initialValue: btnSecondary, syntax: '<color>' },
	'btn-secondary-hover': { initialValue: btnSecondaryHover, syntax: '<color>' },
	'btn-secondary-active': { initialValue: btnSecondaryActive, syntax: '<color>' },
	'btn-success': { initialValue: btnSuccess, syntax: '<color>' },
	'btn-success-hover': { initialValue: btnSuccessHover, syntax: '<color>' },
	'btn-success-active': { initialValue: btnSuccessActive, syntax: '<color>' },
	'btn-success-disabled': { initialValue: btnDisabled, syntax: '<color>' },
	'btn-info': { initialValue: btnInfo, syntax: '<color>' },
	'btn-info-hover': { initialValue: btnInfoHover, syntax: '<color>' },
	'btn-info-active': { initialValue: btnInfoActive, syntax: '<color>' },
	'btn-info-disabled': { initialValue: btnDisabled, syntax: '<color>' },
	'btn-warning': { initialValue: btnWarning, syntax: '<color>' },
	'btn-warning-hover': { initialValue: btnWarningHover, syntax: '<color>' },
	'btn-warning-active': { initialValue: btnWarningActive, syntax: '<color>' },
	'btn-warning-disabled': { initialValue: btnDisabled, syntax: '<color>' },
	'btn-danger': { initialValue: btnDanger, syntax: '<color>' },
	'btn-danger-hover': { initialValue: btnDangerHover, syntax: '<color>' },
	'btn-danger-active': { initialValue: btnDangerActive, syntax: '<color>' },
	'btn-danger-disabled': { initialValue: btnDisabled, syntax: '<color>' },
	'btn-dark': { initialValue: btnDark, syntax: '<color>' },
	'btn-dark-hover': { initialValue: btnDarkHover, syntax: '<color>' },
	'btn-dark-active': { initialValue: btnDarkActive, syntax: '<color>' },
	'btn-dark-disabled': { initialValue: btnDisabled, syntax: '<color>' },
	'btn-light': { initialValue: btnLight, syntax: '<color>' },
	'btn-light-hover': { initialValue: btnLightHover, syntax: '<color>' },
	'btn-light-active': { initialValue: btnLightActive, syntax: '<color>' },
	'btn-light-disabled': { initialValue: btnDisabled, syntax: '<color>' },
	'btn-link': { initialValue: btnLink, syntax: '<color>' },
	'btn-link-hover': { initialValue: btnLinkHover, syntax: '<color>' },
	'btn-link-active': { initialValue: btnLinkActive, syntax: '<color>' },
	'btn-link-disabled': { initialValue: btnDisabled, syntax: '<color>' },
	'link-color': { initialValue: linkColor, syntax: '<color>' },
	'scrollbar-color': { initialValue: scrollbarColor, syntax: '<color>' },
	'scrollbar-track': { initialValue: scrollbarTrack, syntax: '<color>' },
	'scrollbar-width': { initialValue: 'auto', syntax: '<custom-ident>' },
	'blink-speed': { initialValue: '200ms', syntax: '<time>' },
	'fast-speed': { initialValue: '400ms', syntax: '<time>' },
	'normal-speed': { initialValue: '600ms', syntax: '<time>' },
	'slow-speed': { initialValue: '800ms', syntax: '<time>' },
	'crawl-speed': { initialValue: '1200ms', syntax: '<time>' },
	'btn-disabled-opacity': { initialValue: 0.65, syntax: '<number>' },
	'btn-disabled-saturation': { initialValue: '50%', syntax: '<percentage>' },
	'btn-disabled-brightness': { initialValue: '90%', syntax: '<percentage>' },
};

const SUPPORTS_CUSTOM_STATES = CSS.supports('selector(:state(foo))');

const LAYER_PREFIX = 'vendor.aegis';

const properties = css`${Object.entries(customProperties).map(
	([name, { initialValue, inherits = true, syntax = '*' }]) => `@property --aegis-${name} {
		syntax: "${syntax}";
		inherits: ${inherits};
		initial-value: ${initialValue};
	}`
).join('\n\n')}`;

const baseTheme = css`@layer base.aegisjsproject.theme {
	:root {
		color-scheme: light dark;
		font-family: var(--aegis-font, system-ui);
	}

	[data-theme="light"] {
		color-scheme: only light;
	}

	[data-theme="dark"] {
		color-scheme: only dark;
	}

	:root, [data-theme] {
		color: light-dark(var(--aegis-color-light, ${dark$2}), var(--aegis-color-dark, ${light$2}));
		background-color: light-dark(var(--aegis-bg-light, ${light$2}), var(--aegis-bg-dark, ${dark$2}));
	}
}`;

const componentBase = css`@layer components.aegisjsproject.theme {
	:host {
		color: var(--aegis-color-light, ${dark$2});
		color: light-dark(var(--aegis-color-light, ${dark$2}), var(--aegis-color-dark, ${light$2}));
		background-color: var(--aegis-bg-light, ${light$2});
		background-color: light-dark(var(--aegis-bg-light, ${light$2}), var(--aegis-bg-dark, ${dark$2}));
		font-family: system-ui;
	}

	:host(:not([hidden]):not([popover])) {
		display: block;
	}

	:host([theme="light"]) {
		color-scheme: only light;
	}

	:host([theme="dark"]) {
		color-scheme: only dark;
	}
}`;

const componentBorder = css`@layer components.aegisjsproject.theme {
	:host {
		border-width: 1px;
		border-style: solid;
		border-color: light-dark(var(--aegis-border-color-light, ${gray[2]}), var(--aegis-border-color-dark, ${gray[6]}));
		border-radius: var(--aegis-border-radius, 8px);
	}
}`;

/**
 * @deprecated
 *
 * Preserving sheets just to avoid breaking on import. Now using `color-scheme` & `light-dark()` only.
 */
const componentDarkTheme = new CSSStyleSheet({ disabled: true });

/**
 * @deprecated
 *
 * Preserving sheets just to avoid breaking on import. Now using `color-scheme` & `light-dark()` only.
 */
const componentLightTheme = new CSSStyleSheet({ disabled: true });

/**
 * @deprecated
 *
 * Preserving sheets just to avoid breaking on import. Now using `color-scheme` & `light-dark()` only.
 */
const darkTheme = new CSSStyleSheet({ disabled: true });

/**
 * @deprecated
 *
 * Preserving sheets just to avoid breaking on import. Now using `color-scheme` & `light-dark()` only.
 */
const lightTheme = new CSSStyleSheet({ disabled: true });

const DISABLED_STATE = SUPPORTS_CUSTOM_STATES ? ':state(disabled)' : '._state--disabled';

const DISABLED = `:disabled, .disabled, ${DISABLED_STATE}`;
const LAYER = 'components.aegisjsproject.button';

const btn = css`@layer ${LAYER} {
	.btn:not([hidden]) {
		cursor: pointer;
		display: inline-block;
		padding: 0.6em 1.3em;
		border-width: var(--aegis-btn-border-width, 0px);
		border-style: solid;
		appearance: button;
		line-height: 1.5;
		text-align: center;
		vertical-align: middle;
		font-family: inherit;
		font-size: 1rem;
		border-radius: var(--aegis-btn-border-radius, 5px);
		text-decoration: none;
		transition: background-color 150ms ease-in-out, border-color 150ms ease-in-out, color 150ms ease-in-out;
	}

	.btn${DISABLED} {
		pointer-events: none;
	}

	.btn.btn-sm {
		padding: 0.5em 1em;
		font-size: 0.7rem;
	}

	.btn.btn-lg {
		padding: 0.5em 1.1em;
		font-size: 1.3rem;
	}

	.btn.btn-block {
		display: block;
		width: 100%;
	}

	.btn:disabled:not(.btn-system, .btn-system-accent), .btn.disabled:not(.btn-system, .btn-system-accent), .btn${DISABLED} {
		cursor: not-allowed;
		opacity: var(--aegis-btn-disabled-opacity, 0.65);
		filter: saturate(var(--aegis-btn-disabled-saturation, 50%)) brightness(var(--aegis-btn-disabled-brightness, 90%));
	}

	.btn.disabled, .btn${DISABLED_STATE} {
		pointer-events: none;
	}

	.btn:focus-visible {
		outline: 2px solid;
		outline-offset: 2px;
	}
}`;

const system = css`@layer ${LAYER} {
	.btn.btn-system {
		background-color: ButtonFace;
		color: ButtonText;
		border-color: hsl(from ButtonFace h s calc(l - 0.2));
	}

	.btn.btn-system:hover {
		background-color: hsl(from ButtonFace h s calc(l * 1.1));
		border-color: hsl(from ButtonFace h s calc(l * 1.1));
	}

	.btn.btn-system:focus-visible {
		background-color: hsl(from ButtonFace h calc(s * 1.05) calc(l * 1.05));
		border-color: hsl(from ButtonFace h calc(s * 1.05) calc(l * 1.05));
		outline: 2px solid ButtonText;
		outline-offset: 2px;
	}

	.btn.btn-system:active {
		background-color: hsl(from ButtonFace h s calc(l * 0.8));
		border-color: hsl(from ButtonFace h s calc(l * 0.8));
	}

	.btn.btn-system:disabled, .btn.btn-system.disabled, .btn.btn-system${DISABLED_STATE} {
		background-color: hsl(from ButtonFace h calc(s * 0.2) l);
		border-color: hsl(from ButtonFace h calc(s * 0.2) l);
		color: GrayText;
	}
}`;

const systemAccent = css`@layer ${LAYER} {
	.btn.btn-system-accent {
		background-color: AccentColor;
		color: AccentColorText;
		border-color: hsl(from AccentColor h s calc(l - 0.2));
	}

	.btn.btn-system-accent:hover {
		background-color: hsl(from AccentColor h s calc(l * 1.1));
		border-color: hsl(from AccentColor h s calc(l * 1.1));
	}

	.btn.btn-system-accent:focus-visible {
		background-color: hsl(from AccentColor h calc(s * 1.05) calc(l * 1.05));
		border-color: hsl(from AccentColor h calc(s * 1.05) calc(l * 1.05));
		outline: 2px solid hsl(from AccentColor h s calc(l - 0.3));
		outline-offset: 2px;
	}

	.btn.btn-system-accent:active {
		background-color: hsl(from AccentColor h s calc(l * 0.8));
		border-color: hsl(from AccentColor h s calc(l * 0.8));
	}

	.btn.btn-system-accent:disabled, .btn.btn-system-accent.disabled, .btn.btn-system${DISABLED_STATE} {
		background-color: hsl(from AccentColor h calc(s * 0.2) l);
		border-color: hsl(from AccentColor h calc(s * 0.2) l);
		color: GrayText;
	}
}`;

const primary = css`@layer ${LAYER} {
	.btn.btn-primary {
		background-color: var(--aegis-btn-primary, ${btnPrimary});
		color: var(--aegis-color-dark, ${colorDark});
		border-color: ${blue$1[6]};
	}

	.btn.btn-primary:hover:not(${DISABLED}), .btn.btn-primary:focus-visible {
		background-color: var(--aegis-btn-primary-hover, ${btnPrimaryHover});
		border-color: ${blue$1[7]};
	}

	.btn.btn-primary:focus-visible {
		outline-color: var(--aegis-btn-primary, ${btnPrimary});
	}

	.btn.btn-primary:active {
		background-color: var(--aegis-btn-primary-active, ${btnPrimaryActive});
		border-color: ${blue$1[8]};
	}
}`;

const btnOutlinePrimary = css`@layer ${LAYER} {
	.btn.btn-outline-primary {
		background-color: transparent;
		color: var(--aegis-btn-primary, ${btnPrimary});
		border-color: currentColor;
	}

	.btn.btn-outline-primary:focus-visible {
		outline-color: var(--aegis-btn-primary, ${btnPrimary});
	}

	.btn.btn-outline-primary:hover:not(${DISABLED}), .btn.btn-outline-primary:focus-visible {
		background-color: var(--aegis-btn-primary-hover, ${btnPrimaryHover});
		border-color: ${blue$1[7]};
		color: var(--aegis-color-dark, ${colorDark});
	}

	.btn.btn-outline-primary:active {
		background-color: var(--aegis-btn-primary-active, ${btnPrimaryActive});
		border-color: ${blue$1[8]};
		color: var(--aegis-color-dark, ${colorDark});
	}
}`;

const secondary = css`@layer ${LAYER} {
	.btn.btn-secondary {
		background-color: var(--aegis-btn-secondary, ${btnSecondary});
		color: var(--aegis-color-dark, ${colorDark});
		border-color: ${gray[7]};
	}

	.btn.btn-secondary:hover:not(${DISABLED}), .btn.btn-secondary:focus-visible {
		background-color: var(--aegis-btn-secondary-hover, ${btnSecondaryHover});
		border-color: ${gray[8]};
	}

	.btn.btn-secondary:focus-visible {
		outline-color: var(--aegis-btn-secondary, ${btnSecondary});
	}

	.btn.btn-secondary:active {
		background-color: var(--aegis-btn-secondary-active, ${btnSecondaryActive});
		border-color: ${gray[8]};
	}
}`;

const btnOutlineSecondary = css`@layer ${LAYER} {
	.btn.btn-outline-secondary {
		background-color: transparent;
		color: var(--aegis-btn-secondary, ${btnSecondary});
		border-color: currentColor;
	}

	.btn.btn-outline-secondary:hover:not(${DISABLED}), .btn.btn-outline-secondary:focus-visible {
		background-color: var(--aegis-btn-secondary-hover, ${btnSecondaryHover});
		border-color: ${gray[8]};
		color: var(--aegis-color-dark, ${colorDark});
	}

	.btn.btn-outline-secondary:focus-visible {
		outline-color: var(--aegis-btn-secondary, ${btnSecondary});
	}

	.btn.btn-outline-secondary:active {
		background-color: var(--aegis-btn-secondary-active, ${btnSecondaryActive});
		border-color: ${gray[8]};
		color: var(--aegis-color-dark, ${colorDark});
	}

	.btn.btn-outline-secondary:disabled, .btn.btn-outline-secondary.disabled, .btn.btn-outline-seconday${DISABLED_STATE} {
		color: var(--aegis-btn-active-disabled, ${btnDisabled});
	}
}`;

const success = css`@layer ${LAYER} {
	.btn.btn-success {
		background-color: var(--aegis-btn-success, ${btnSuccess});
		color: var(--aegis-color-dark, ${colorDark});
		border-color: ${green$1[6]};
	}

	.btn.btn-success:hover:not(${DISABLED}), .btn.btn-success:focus-visible {
		background-color: var(--aegis-btn-success-hover, ${btnSuccessHover});
		border-color: ${green$1[7]};
	}

	.btn.btn-success:focus-visible {
		outline-color: var(--aegis-btn-success, ${btnSuccess});
	}

	.btn.btn-success:active {
		background-color: var(--aegis-btn-success-active, ${btnSuccessActive});
		border-color: ${green$1[8]};
	}
}`;

const btnOutlineSuccess = css`@layer ${LAYER} {
	.btn.btn-outline-success {
		background-color: transparent;
		color: var(--aegis-btn-success, ${btnSuccess});
		border-color: currentColor;
	}

	.btn.btn-outline-success:hover:not(${DISABLED}), .btn.btn-outline-success:focus-visible {
		background-color: var(--aegis-btn-success-hover, ${btnSuccessHover});
		border-color: ${green$1[7]};
		color: var(--aegis-color-dark, ${colorDark});
	}

	.btn.btn-outline-success:focus-visible {
		outline-color: var(--aegis-btn-success, ${btnSuccess});
	}

	.btn.btn-outline-success:active {
		background-color: var(--aegis-btn-success-active, ${btnSuccessActive});
		border-color: ${green$1[8]};
		color: var(--aegis-color-dark, ${colorDark});
	}
}`;

const info = css`@layer ${LAYER} {
	.btn.btn-info {
		background-color: var(--aegis-btn-info, ${btnInfo});
		color: var(--aegis-color-dark, ${colorDark});
		border-color: ${cyan[6]};
	}

	.btn.btn-info:not(${DISABLED}), .btn.btn-info:focus-visible {
		background-color: var(--aegis-btn-info-hover, ${btnInfoHover});
		border-color: ${cyan[7]};
	}

	.btn.btn-info:focus-visible {
		outline-color: var(--aegis-btn-info, ${btnInfo});
	}

	.btn.btn-info:active {
		background-color: var(--aegis-btn-info-active, ${btnInfoActive});
		border-color: ${cyan[8]};
	}
}`;

const btnOutlineInfo = css`@layer ${LAYER} {
	.btn.btn-outline-info {
		background-color: transparent;
		color: var(--aegis-btn-info, ${btnInfo});
		border-color: currentColor;
	}

	.btn.btn-outline-info:hover:not(${DISABLED}), .btn.btn-outline-info:focus-visible {
		background-color: var(--aegis-btn-info-hover, ${btnInfoHover});
		border-color: ${cyan[7]};
		color: var(--aegis-color-dark, ${colorDark});
	}

	.btn.btn-outline-info:focus-visible {
		outline-color: var(--aegis-btn-info, ${btnInfo});
	}

	.btn.btn-outline-info:active {
		background-color: var(--aegis-btn-info-active, ${btnInfoActive});
		border-color: ${cyan[8]};
		color: var(--aegis-color-dark, ${colorDark});
	}
}`;

const danger = css`@layer ${LAYER} {
	.btn.btn-danger {
		background-color: var(--aegis-btn-danger, ${btnDanger});
		color: var(--aegis-color-dark, ${colorDark});
		border-color: ${red$1[6]};
	}

	.btn.btn-danger:hover:not(${DISABLED}), .btn.btn-danger:focus-visible {
		background-color: var(--aegis-btn-danger-hover, ${btnDangerHover});
		border-color: ${red$1[7]};
	}

	.btn.btn-danger:focus-visible {
		outline-color: var(--aegis-btn-danger, ${btnDanger});
	}

	.btn.btn-danger:active {
		background-color: var(--aegis-btn-danger-active, ${btnDangerActive});
		border-color: ${red$1[8]};
	}
}`;

const btnOutlineDanger = css`@layer ${LAYER} {
	.btn.btn-outline-danger {
		background-color: transparent;
		color: var(--aegis-btn-danger, ${btnDanger});
		border-color: currentColor;
	}

	.btn.btn-outline-danger:hover:not(${DISABLED}), .btn.btn-outline-danger:focus-visible {
		background-color: var(--aegis-btn-danger-hover, ${btnDangerHover});
		border-color: ${red$1[7]};
		color: var(--aegis-color-dark, ${colorDark});
	}

	.btn.btn-outline-danger:focus-visible {
		outline-color: var(--aegis-btn-danger, ${btnDanger});
	}

	.btn.btn-outline-danger:active {
		background-color: var(--aegis-btn-danger-active, ${btnDangerActive});
		border-color: ${red$1[8]};
		color: var(--aegis-color-dark, ${colorDark});
	}
}`;

const warning = css`@layer ${LAYER} {
	.btn.btn-warning {
		background-color: var(--aegis-btn-warning, ${btnWarning});
		color: var(--aegis-color-light, ${colorLight});
		border-color: ${yellow$1[6]};
	}

	.btn.btn-warning:hover:not(${DISABLED}), .btn.btn-warning:focus-visible {
		background-color: var(--aegis-btn-warning-hover, ${btnWarningHover});
		border-color: ${yellow$1[7]};
	}

	.btn.btn-warning:focus-visible {
		outline-color: var(--aegis-btn-warning, ${btnWarning});
	}

	.btn.btn-warning:active {
		background-color: var(--aegis-btn-warning-active, ${btnWarningActive});
		border-color: ${yellow$1[8]};
	}
}`;

const btnOutlineWarning = css`@layer ${LAYER} {
	.btn.btn-outline-warning {
		background-color: transparent;
		color: var(--aegis-btn-warning, ${btnWarning});
		border-color: currentColor;
	}

	.btn.btn-outline-warning:hover:not(${DISABLED}), .btn.btn-outline-warning:focus-visible {
		background-color: var(--aegis-btn-warning-hover, ${btnWarningHover});
		border-color: ${yellow$1[7]};
		color: var(--aegis-color-light, ${colorLight});
	}

	.btn.btn-outline-warning:active {
		background-color: var(--aegis-btn-warning-active, ${btnWarningActive});
		border-color: ${yellow$1[8]};
		color: var(--aegis-color-light, ${colorLight});
	}

	.btn.btn-outline-warning:focus-visible {
		outline-color: var(--aegis-btn-warning, ${btnWarning});
	}
}`;

const light = css`@layer ${LAYER} {
	.btn.btn-light {
		background-color: var(--aegis-btn-light, ${btnLight});
		color: var(--aegis-color-light, ${colorLight});
		border-color: ${gray[2]};
	}

	.btn.btn-light:hover:not(${DISABLED}), .btn.btn-light:focus-visible {
		background-color: var(--aegis-btn-light-hover, ${btnLightHover});
		border-color: ${gray[3]};
	}

	.btn.btn-light:focus-visible {
		outline-color: var(--aegis-btn-light, ${btnLight});
	}

	.btn.btn-light:active {
		background-color: var(--aegis-btn-light-active, ${btnLightActive});
		border-color: ${gray[4]};
	}
}`;

const btnOutlineLight = css`@layer ${LAYER} {
	.btn.btn-outline-light {
		background-color: transparent;
		color: var(--aegis-btn-light, ${btnLight});
		border-color: currentColor;
	}

	.btn.btn-outline-light:hover:not(${DISABLED}), .btn.btn-outline-light:focus-visible {
		background-color: var(--aegis-btn-light-hover, ${btnLightHover});
		border-color: ${gray[3]};
		color: var(--aegis-color-light, ${colorLight});
	}

	.btn.btn-outline-light:focus-visible {
		outline-color: var(--aegis-btn-light, ${btnLight});
	}

	.btn.btn-outline-light:active {
		background-color: var(--aegis-btn-light-active, ${btnLightActive});
		border-color: ${gray[4]};
		color: var(--aegis-btn-light-active, ${btnLightActive});
	}
}`;

const dark = css`@layer ${LAYER} {
	.btn.btn-dark {
		background-color: var(--aegis-btn-dark, ${btnDark});
		color: var(--aegis-color-dark, ${colorDark});
		border-color: ${gray[7]};
	}

	.btn.btn-dark:hover:not(${DISABLED}), .btn.btn-dark:focus-visible {
		background-color: var(--aegis-btn-dark-hover, ${btnDarkHover});
		border-color: ${gray[8]};
	}

	.btn.btn-dark:focus-visible {
		outline-color: var(--aegis-btn-dark, ${btnDark});
	}

	.btn.btn-dark:active {
		background-color: var(--aegis-btn-dark-active, ${btnDarkActive});
		border-color: ${gray[8]};
	}
}`;

const btnOutlineDark = css`@layer ${LAYER} {
	.btn.btn-outline-dark {
		background-color: transparent;
		color: var(--aegis-btn-dar, ${btnDark});
		border-color: currentColor;
	}

	.btn.btn-outline-dark:hover:not(${DISABLED}), .btn.btn-outline-dark:focus-visible {
		background-color: var(--aegis-btn-dark-hover, ${btnDarkHover});
		border-color: ${gray[8]};
		color: var(--aegis-color-dark, ${colorDark});
	}

	.btn.btn-outline-dark:focus-visible {
		outline-color: var(--aegis-btn-dark, ${btnDark});
	}

	.btn.btn-outline-dark:active {
		background-color: var(--aegis-btn-dark-active, ${btnDarkActive});
		border-color: ${gray[8]};
		color: var(--aegis-color-dark, ${colorDark});
	}

	.btn.btn-outline-secondary:disabled, .btn.btn-outline-secondary.disabled, .btn.btn-outline-secondary${DISABLED_STATE} {
		color: var(--aegis-btn-active-disabled, ${btnDisabled});
	}
}`;

const link = css`@layer ${LAYER} {
	.btn.btn-link {
		background-color: var(--aegis-btn-link, ${btnLink});
		color: ${linkColor};
		border-color: transparent;
		text-decoration: none;
	}

	.btn.btn-link:hover:not(${DISABLED}), .btn.btn-link:focus-visible {
		background-color: var(--aegis-btn-link-hover, ${btnLinkHover});
		text-decoration: underline;
	}

	.btn.btn-link:focus-visible {
		outline-color: var(--aegis-btn-link, ${btnLink});
	}

	.btn.btn-link:active {
		background-color: var(--aegis-btn-link-active, ${btnLinkActive});
		text-decoration: underline;
	}
}`;

const DISABLED_SELECTOR = ':state(disabled)';

const customButton = css`@layer components.aegisjsproject.button {
	:host {
		display: inline flow-root;
		appearance: button;
		user-select: none;
		white-space: nowrap;
		align-items: flex-start;
		text-align: center;
		cursor: default;
		box-sizing: border-box;
		background-color: ButtonFace;
		color: ButtonText;
		border: 1px outset ButtonBorder;
		border-radius: 2px;
		padding: 2px 6px;
		font-family: system-ui, -apple-system, sans-serif;
		font-size: small;
	}

	:host(:focus-visible) {
		/* Universal fallback for older engines or high contrast overrides */
		outline: auto;
		outline: 2px solid CanvasText;
		outline-offset: 2px;
	}

	/* WebKit & Blink (Chrome, Safari, Edge) native focus ring targeting */
	@supports (outline-color: -webkit-focus-ring-color) {
		:host(:focus-visible) {
			outline: 5px auto -webkit-focus-ring-color;
		}
	}

	/* Firefox cross-platform fallback (Windows, Android, Linux) */
	@supports (-moz-appearance: none) {
		:host(:focus-visible) {
			outline: 2px solid AccentColor;
		}
	}

	:host(${DISABLED_SELECTOR}) {
		color: GrayText;
		border-color: color-mix(in srgb, GrayText, transparent 50%);
		background-color: color-mix(in srgb, ButtonFace, transparent 50%);
		pointer-events: none;
	}

	:host(:hover:not(${DISABLED_SELECTOR})) {
		background-color: color-mix(in srgb, ButtonFace, ButtonText 10%);
	}

	:host(:active:not(${DISABLED_SELECTOR})) {
		background-color: color-mix(in srgb, ButtonFace, ButtonText 20%);
	}
}`;

const displays = css`@layer layout.aegisjsproject.displays {
	.block:not([hidden]):not([popover]) {
		display: block;
	}

	.inline:not([hidden]):not([popover]) {
		display: inline;
	}

	.inline-block:not([hidden]):not([popover]) {
		display: inline-block;
	}

	.flex:not([hidden]):not([popover]) {
		display: flex;
	}

	.inline-flex:not([hidden]):not([popover]) {
		display: inline-flex;
	}

	.grid:not([hidden]):not([popover]) {
		display: grid;
	}

	.inline-grid:not([hidden]):not([popover]) {
		display: inline-grid;
	}
}`;

const positions = css`@layer layout.aegisjsproject.positions {
	.fixed {
		position: fixed;
	}

	.relative {
		position: relative;
	}

	.absolute {
		position: absolute;
	}

	.sticky {
		position: sticky;
	}

	.top {
		top: 0;
	}

	.bottom {
		bottom: 0;
	}

	.left {
		left: 0;
	}

	.right {
		right: 0;
	}

	.z-0 {
		z-index: 0;
	}

	.z-1 {
		z-index: 1;
	}

	.z-2 {
		z-index: 2;
	}

	.z-3 {
		z-index: 3;
	}

	.z-4 {
		z-index: 4;
	}

	.z-top {
		z-index: var(--z-top, 9999);
	}

	.z-max {
		z-index: 2147483647;
	}
}`;

const floats = css`@layer layout.aegisjsproject.floats {
	.float-left {
		float: left;
	}

	.float-right {
		float: right;
	}

	.float-none {
		float: none;
	}

	.clear-left {
		clear: left;
	}

	.clear-right {
		clear: right;
	}

	.clear-both {
		clear: both;
}
}`;

const fonts = css`@layer base.aegisjsproject.fonts {
	.system-ui {
		font-family: system-ui, sans-serif;
	}

	.ui-sans-serif {
		font-family: ui-sans-serif, sans-serif;
	}

	.ui-serif {
		font-family: ui-serif, serif;
	}

	.ui-monospace {
		font-family: ui-monospace, monospace;
	}
}`;

const overflows = css`@layer layout.aegisjsproject.overflows {
	.overflow-hidden {
		overflow: hidden;
	}

	.overflow-visible {
		overflow: visible;
	}

	.overflow-scroll {
		overflow: scroll;
	}

	.overflow-auto {
		overflow: auto;
	}

	.overflow-x-hidden {
		overflow-x: hidden;
	}

	.overflow-x-visible {
		overflow-x: visible;
	}

	.overflow-x-scroll {
		overflow-x: scroll;
	}

	.overflow-x-auto {
		overflow-x: auto;
	}

	.overflow-y-hidden {
		overflow-y: hidden;
	}

	.overflow-y-visible {
		overflow-y: visible;
	}

	.overflow-y-scroll {
		overflow-y: scroll;
	}

	.overflow-y-auto {
		overflow-y: auto;
	}
}`;

const colors = css`@layer base.aegisjsproject.colors {
	.current-color {
		fill: currentColor;
	}

	.color-initial {
		color: initial;
	}

	.color-inherit {
		color: inherit;
	}
}`;

const objectFits = css`@layer layout.aegisjsproject.fit {
	.fit-contain {
		object-fit: contain;
	}

	.fit-cover {
		object-fit: cover;
	}

	.fit-fill {
		object-fit: fill;
	}

	.fit-none {
		object-fit: none;
	}

	.fit-scale-down {
		object-fit: scale-down;
	}
}`;

const textRules = css`@layer base.aegisjsproject.text {
	.text-align-left {
		text-align: left;
	}

	.text-align-right {
		text-align: right;
	}

	.text-align-center {
		text-align: center;
	}

	.text-align-justify {
		text-align: justify;
	}

	.text-align-justify-all {
		text-align: justify-all;
	}

	.text-align-start {
		text-align: start;
	}

	.text-align-end {
		text-align: end;
	}

	.text-decoration-solid {
		text-decoration-style: solid;
	}

	.text-decoration-wavy {
		text-decoration-style: wavy;
	}

	.text-decoration-dotted {
		text-decoration-style: dotted;
	}

	.text-decoration-dashed {
		text-decoration-style: dashed;
	}

	.text-decoration-double {
		text-decoration-style: double;
	}

	.no-text-decoration, .no-text-decoration * {
		text-decoration: none;
	}

	.underline {
		text-decoration-line: underline;
	}

	.overline {
		text-decoration-line: overline;
	}

	.line-through {
		text-decoration-line: line-through;
	}

	.optimize-speed {
		text-rendering: optimizeSpeed;
	}

	.optimize-legibility {
		text-rendering: optimizeLegibility;
	}

	.geometric-precision {
		text-rendering: geometricPrecision;
	}

	.capitalize {
		text-transform: capitalize;
	}

	.uppercase {
		text-transform: uppercase;
	}

	.lowercase {
		text-transform: lowercase;
	}

	.center, .align-center {
		text-align: center;
	}

	.align-left {
		text-align: left;
	}

	.align-right {
		text-align: right;
	}

	.indent {
		text-indent: var(--indent, 4ch);
	}

	.indent-all {
		text-indent: var(--indent, 4ch) each-line;
	}

	.indent-hanging {
		text-indent: var(--indent, 4ch) hanging;
	}
}`;

const cursors = css`@layer base.aegisjsproject.cursors {
	.no-pointer-events {
		pointer-events: none;
	}

	.cursor-auto {
		cursor: auto;
	}

	.cursor-default {
		cursor: var(--default-cursor, default);
	}

	.cursor-none {
		cursor: none;
	}

	.cursor-context-menu {
		cursor: context-menu;
	}

	.cursor-help {
		cursor: help;
	}

	.cursor-pointer {
		cursor: var(--pointer-cursor, pointer);
	}

	.cursor-progress {
		cursor: var(--progress-cursor, progress);
	}

	.cursor-wait {
		cursor: var(--wait-cursor, wait);
	}

	.cursor-cell {
		cursor: cell;
	}

	.cursor-crosshair {
		cursor: crosshair;
	}

	.cursor-text {
		cursor: text;
	}

	.cursor-vertical-text, .cursor-text-vertical {
		cursor: vertical-text;
	}

	.cursor-alias {
		cursor: alias;
	}

	.cursor-copy {
		cursor: copy;
	}

	.cursor-move {
		cursor: move;
	}

	.cursor-no-drop {
		cursor: no-drop;
	}

	.cursor-not-allowed {
		cursor: not-allowed;
	}

	.cursor-all-scroll {
		cursor: all-scroll;
	}

	.cursor-col-resize {
		cursor: col-resize;
	}

	.cursor-row-resize {
		cursor: row-resize;
	}

	.cursor-n-resize {
		cursor: n-resize;
	}

	.cursor-e-resize {
		cursor: e-resize;
	}

	.cursor-s-resize {
		cursor: s-resize;
	}

	.cursor-w-resize {
		cursor: w-resize;
	}

	.cursor-ne-resize {
		cursor: ne-resize;
	}

	.cursor-nw-resize {
		cursor: nw-resize;
	}

	.cursor-se-resize {
		cursor: se-resize;
	}

	.cursor-sw-resize {
		cursor: sw-resize;
	}

	.cursor-zoom-in {
		cursor: zoom-in;
	}

	.cursor-zoom-out {
		cursor: zoom-out;
	}

	.cursor-grab {
		cursor: grab;
	}

	.cursor-grabbing {
		cursor: grabbing;
	}
}`;

const utilities = css`@layer utilities.aegisjsproject {
	.clearfix::after {
		clear: both;
		content: '';
		display: block;
	}

	.shadow {
		box-shadow: var(--shadow-x, 0) var(--shadow-y, 2px) var(--shadow-blur, 10px) var(--shadow-spread, 0) var(--shadow-color, rgba(0,0,0,.2));
	}

	.shadow-dark {
		box-shadow: var(--shadow-x, 0) var(--shadow-y, 2px) var(--shadow-blur, 10px) var(--shadow-spread, 0) var(--shadow-dark-color, rgba(0,0,0,.6));
	}

	.icon, .icon * {
		color: inherit;
		max-width: 100%;
		max-height: 100%;
		width: var(--icon-size, 1em);
		height: var(--icon-size, 1em);
		vertical-align: middle;
	}

	.round {
		border-radius: 50%;
	}
}

@layer component.aegisjsproject {
	.card {
		border: var(--card-border, 1px solid #ccc);
		border-radius: var(--card-radius, 2px);
		background: var(--card-bg, var(--primary-color, white));
		padding: var(--card-padding, 0.7em);
	}

	.custom-element:not(:defined) .if-defined[slot], .custom-element.if-defined:not(:defined) {
		display: none;
	}
}`;

const statusBoxes = css`@layer component.aegisjsproject.status-box {
	.status-box {
		padding: 1.2em;
		border: 1px dashed currentColor;
		text-align: center;
		margin-top: 0.7em;
		border-radius: 8px;
	}

	.status-box.alert, .status-box.error {
		color: var(--alert-color, #6f0606);
		background-color: var(--alert-background, #e88a8a);
	}

	.status-box.warn {
		color: var(--warn-color, #51430c);
		background-color: var(--warn-background, #f0d155);
	}

	.status-box.info {
		color: var(--info-color, #555553);
		background-color: var(--info-background, #d2d2d2);
	}

	.status-box.success {
		color: var(--success-color, #1d4f01);
		background-color: var(--success-background, #8cee69);
	}
}`;

const forms = css`@layer component.aegisjsproject.forms {
	.form-group {
		border: 1px solid transparent;
		padding: var(--form-group-padding, 0.4em 0.8em);
		margin-bottom: 0.4em;
		border-radius: 6px;
		transition: border-color 200ms ease-in-out;
	}

	.form-group:focus-within {
		border-color: var(--form-group-border, #cacaca);
	}

	.form-group .input-label {
		display: block;
		margin: 0.4em 0;
	}

	.form-group .input-label.required::after {
		content: ' *';
		display: inline;
		font-size: 0.8em;
		font-weight: 800;
	}

	.form-group .input, .form-group .input:required:invalid:placeholder-shown {
		display: block;
		width: var(--input-width, 100%);
		max-width: 100%;
		color: currentColor;
		border-style: solid;
		border-color: var(--input-border, #cacaca);
		border-width: 0 0 1px 0;
		background: transparent;
		padding: var(--form-group-padding, 0.5em 0.3em);
		transition: color 300ms ease-in-out, background-color 300ms ease-in-out;
	}

	.form-group textarea.input {
		resize: vertical;
	}

	.form-group .input:invalid {
		box-shadow: none;
	}

	.form-group .input:invalid:not(:focus) {
		color: var(--invalid-color, #-871717);
		border-color: currentColor;
		background-color: var(--invalid-background, #F7C1C1);
	}

	.form-group input[hidden] + label[for].btn-toggle {
		background-color: var(--button-disabled-background);
		margin: var(--form-group-margin, 0.3rem);
		transition: background-color 300ms ease-in-out;
	}

	.form-group input[hidden]:checked + label[for].btn-toggle {
		background-color: var(--button-background);
	}

	.form-group input[hidden]:not(:checked) + label[for].btn-toggle .when-checked {
		display: none;
	}

	.form-group input[hidden]:checked + label[for].btn-toggle .when-unchecked {
		display: none;
	}
}`;

const scrollbarFallback = css`@layer base.aegisjsproject.scrollbar {
	@supports not (scrollbar-color: currentColor transparent) {
		::-webkit-scrollbar {
			display: block;
		}

		::-webkit-scrollbar-thumb {
			background-color: var(--aegis-scrollbar-color, ${scrollbarColor});
		}

		::-webkit-scrollbar-track {
			background-color: var(--aegis-scrollbar-track, ${scrollbarTrack});
		}
	}
}`;

const scrollbar = css`@layer base.aegisjsproject.scrollbar {
	:root {
		scrollbar-color: var(--aegis-scrollbar-color, ${scrollbarColor}) var(--aegis-scrollbar-track, ${scrollbarTrack});
		scrollbar-width: var(----aegis-scrollbar-width, auto);
	}
}`;

const componentScrollbar = css`@layer component.aegisjsproject.scrollbar {
	:host {
		scrollbar-color: var(--aegis-scrollbar-color, ${scrollbarColor}) var(--aegis-scrollbar-track, ${scrollbarTrack});
		scrollbar-width: var(----aegis-scrollbar-width, auto);
	}
}`;

const transform = css`@layer utilities.aegisjsproject.animations {
	.transform-origin-center {
		transform-origin: center;
	}

	.transform-origin-top {
		transform-origin: top;
	}

	.transform-origin-bottom {
		transform-origin: bottom;
	}

	.transform-origin-left {
		transform-origin: left;
	}

	.transform-origin-right {
		transform-origin: right;
	}

	.transform-origin-top-center {
		transform-origin: top center;
	}

	.transform-origin-top-left {
		transform-origin: top left;
	}

	.transform-origin-top-right {
		transform-origin: top right;
	}

	.transform-origin-bottom-left {
		transform-origin: bottom left;
	}

	.transform-origin-bottom-right {
		transform-origin: bottom right;
	}
}`;

const transition = css`@layer utilities.aegisjsproject.animations {
	.transition-linear {
		transition-timing-function: linear;
	}

	.transition-ease {
		transition-timing-function: ease;
	}

	.transition-ease-in {
		transition-timing-function: ease-in;
	}

	.transition-ease-out {
		transition-timing-function: ease-out;
	}

	.transition-ease-in-out {
		transition-timing-function: ease-in-out;
	}

	.transition-speed-blink {
		transition-duration: var(--aegis-blink-speed, 200ms);
	}

	.transition-speed-fast {
		transition-duration: var(--aegis-fast-speed, 400ms);
	}

	.transition-speed-normal {
		transition-duration: var(--aegis-normal-speed, 600ms);
	}

	.transition-speed-slow {
		transition-duration: var(--aegis-slow-speed, 800ms);
	}

	.transition-speed-crawl {
		transition-duration: var(--aegis-crawl-speed, 1600ms);
	}

	.transition-none {
		transition-property: none;
	}

	.transition-all {
		transition-property: all;
	}

	.transition-transform {
		transition-property: transform;
	}

	.transition-opacity {
		transition-property: opacity;
	}

	.transition-filter {
		transition-property: filter;
	}

	.transition-background-position {
		transition-property: background-position;
	}

	.transition-top {
		transition-property: top;
	}

	.transition-right {
		transition-property: right;
	}

	.transition-bottom {
		transition-property: bottom;
	}

	.transition-left {
		transition-property: left;
	}

	.transition-margin {
		transition-property: margin;
	}

	.transition-padding {
		transition-property: padding;
	}

	.transtion-color {
		transition-property: color;
	}

	.transition-background-color {
		transition-property: background-color;
	}

	.transition-color {
		transition-property: color;
	}

	.transition-background {
		transition-property: background;
	}


	.transition-width {
		transition-property: width;
	}

	.transition-height {
		transition-property: height;
	}

	.transition-max-width {
		transition-property: max-width;
	}

	.transition-max-height {
		transition-property: max-height;
	}

	.transition-stagger > :nth-child(5n+1) {
		transition-delay: calc(1 * var(--aegis-transition-stagger, 200ms));
	}

	.transition-stagger > :nth-child(5n+2) {
		transition-delay: calc(2 * var(--aegis-transition-stagger, 200ms));
	}

	.transition-stagger > :nth-child(5n+3) {
		transition-delay: calc(3 * var(--aegis-transition-stagger, 200ms));
	}

	.transition-stagger > :nth-child(5n+4) {
		transition-delay: calc(4 * var(--aegis-transition-stagger, 200ms));
	}

	.transition-stagger > :nth-child(5n+5) {
		transition-delay: calc(5 * var(--aegis-transition-stagger, 200ms));
	}
}`;

const animate = css`@layer utilities.aegisjsproject.animations {
	.animation-trampoline {
		animation-name: trampoline;
	}

	.animation-fade-in {
		animation-name: fade-in;
	}

	.animation-fade-out {
		animation-name: fade-out;
	}

	.animation-shrink {
		animation-name: shrink;
	}

	.animation-grow {
		animation-name: grow;
	}

	.animation-fly-in {
		animation-name: fly-in;
	}

	.animation-slide-up {
		animation-name: slide-up;
	}

	.animation-flip-down {
		animation-name: flip-down;
	}

	.animation-tear-off {
		animation-name: tear-off;
	}

	.animation-blink {
		animation-name: blink;
	}

	.animation-paused {
		animation-play-state: paused;
	}

	.animation-running {
		animation-play-state: running;
	}

	.animation-speed-blink {
		animation-duration: var(--aegis-blink-speed, 200ms);
	}

	.animation-speed-fast {
		animation-duration: var(--aegis-fast-speed, 400ms);
	}

	.animation-speed-normal {
		animation-duration: var(--aegis-normal-speed, 600ms);
	}

	.animation-speed-slow {
		animation-duration: var(--aegis-slow-speed, 800ms);
	}

	.animation-speed-crawl {
		animation-duration: var(--aegis-crawl-speed, 1200ms);
	}

	.animation-infinite {
		animation-iteration-count: infinite;
	}

	.animation-alternate {
		animation-direction: alternate;
	}

	.animation-reverse {
		animation-direction: reverse;
	}

	.animation-alternate-reverse {
		animation-direction: alternate-reverse;
	}

	.animation-normal {
		animation-direction: normal;
	}

	.animation-fill-forwards {
		animation-fill-mode: forwards;
	}

	.animation-fill-backwards {
		animation-fill-mode: backwards;
	}

	.animation-fill-both {
		animation-fill-mode: both;
	}

	.animation-fill-none {
		animation-fill-mode: none;
	}

	.animation-linear {
		animation-timing-function: linear;
	}

	.animation-ease {
		animation-timing-function: ease;
	}

	.animation-ease-in {
		animation-timing-function: ease-in;
	}

	.animation-ease-out {
		animation-timing-function: ease-out;
	}

	.animation-ease-in-out {
		animation-timing-function: ease-in-out;
	}

	.animation-overshoot {
		animation-timing-function: cubic-bezier(.59,1.16,.83,1.11);
	}

	.animation-stagger > :nth-child(5n+1) {
		animation-delay: calc(1 * var(--aegis-animation-stagger, 200ms));
	}

	.animation-stagger > :nth-child(5n+2) {
		animation-delay: calc(2 * var(--aegis-animation-stagger, 200ms));
	}

	.animation-stagger > :nth-child(5n+3) {
		animation-delay: calc(3 * var(--aegis-animation-stagger, 200ms));
	}

	.animation-stagger > :nth-child(5n+4) {
		animation-delay: calc(4 * var(--aegis-animation-stagger, 200ms));
	}

	.animation-stagger > :nth-child(5n+5) {
		animation-delay: calc(5 * var(--aegis-animation-stagger, 200ms));
	}
}`;


const keyframes = css`@layer base.aegisjsproject.animations {
	@keyframes trampoline {
		from {
			transform: scaleY(.85);
			filter: drop-shadow(0 0.3em 0.1em rgba(0,0,0,0.7));
		}

		to {
			filter: drop-shadow(0 0.7em 0.3em rgba(0,0,0,0.7));
			transform: translateY(-1.2em);
		}
	}

	@keyframes fade-in {
		from {
			opacity: 0;
		}
	}

	@keyframes fade-out {
		to {
			opacity: 0;
		}
	}

	@keyframes shrink {
		to {
			transform: scale(0);
		}
	}

	@keyframes grow {
		from {
			transform: scale(0);
		}
	}

	@keyframes fly-in {
		from {
			transform: translate(100vw, -3vh) scaleX(0.1) skew(-20deg);
		}
	}

	@keyframes flip-down {
		from {
			transform: rotateX(-90deg);
		}
	}

	@keyframes tear-off {
		40% {
			transform: rotateZ(30deg) rotateX(40deg) skew(-20deg);
		}

		99% {
			transform: rotateZ(40deg)  translate(-30vw, 120vh) skew(20deg);
			opacity: 1;
		}

		to {
			opacity: 0;
		}
	}

	@keyframes slide {
		from {
			left: 100%;
		}

		to {
			left: 0;
		}
	}

	@keyframes slide-up {
		from {
			top: 100%;
		}

		to {
			top: 0%;
		}
	}

	@keyframes progress {
		to {
			background-position: right;
		}
	}

	@keyframes hanger {
		from {
			transform: rotateX(-90deg);
			transform-origin: center -40%;
		}
	}

	@keyframes door {
		from {
			transform: rotateY(90deg);
		}
	}

	@keyframes sidekick {
		from {
			left: 100%;
			transform: rotate(270deg) scale(0);
		}
	}

	@keyframes cube {
		from {
			left: 100%;
			transform: matrix(0.133,-0.489,-0.200,2.489,-100.667,80.000);
		}
	}

	@keyframes shine {
		0% {
			text-shadow: 4px 8px 2px #ddd;
		}

		25% {
			text-shadow: 4px -8px 2px #ddd;
		}

		50% {
			text-shadow: -2px -8px 2px #ddd;
		}

		75% {
			text-shadow: -2px 8px 2px #ddd;
		}

		100% {
			text-shadow: 4px 8px 2px #ddd;
		}
	}

	@keyframes blink {
		from {
			opacity: 0;
		}
	}
}`;

const presentation = css` @layer utilities.aegisjsproject.presentation {
	[data-width] { width: attr(data-width rem); }
	[data-min-width] { min-width: attr(data-min-width rem); }
	[data-max-width] { max-width: attr(data-max-width rem); }
	[data-height] { height: attr(data-height rem); }
	[data-min-height] { min-height: attr(data-min-height rem); }
	[data-max-height] { max-height: attr(data-max-height rem); }
	[data-aspect-ratio] { aspect-ratio: attr(data-aspect-ratio type(<number>)); }

	[data-padding-block] { padding-block: attr(data-padding-block rem); }
	[data-padding-inline] { padding-inline: attr(data-padding-inline rem); }
	[data-padding-block-end] { padding-block-end: attr(data-padding-block-end rem); }
	[data-padding-inline-end] { padding-inline-end: attr(data-padding-inline-end rem); }
	[data-padding-block-start] { padding-block-start: attr(data-padding-block-start rem); }
	[data-padding-inline-start] { padding-inline-start: attr(data-padding-inline-start rem); }

	[data-margin-block] { margin-block: attr(data-margin-block rem); }
	[data-margin-inline] { margin-inline: attr(data-margin-inline rem); }
	[data-margin-block-end] { margin-block-end: attr(data-margin-block