pasika 0.3.1 → 0.3.3

package/dist/eslint/pasika/rules/css/base-layer-pair.js

@@ -0,0 +1,49 @@
+/**
+ * ESLint rule: pasika/base-layer-pair
+ *
+ * The global base layer MUST apply base-canvas and base-ink to the document
+ * body as the default page pair.
+ *
+ * @see docs/styling-guide/rules/global-stylesheet-rule.md
+ */
+import { atrulesNamed, blockChildren, preludeIdentifiers, selectorNames } from "./helpers.js";
+export const baseLayerPairRule = {
+    meta: {
+        schema: [],
+        type: "problem",
+        docs: {
+            description: "Require the base layer to apply base-canvas and base-ink to the body.",
+        },
+    },
+    create(context) {
+        return {
+            "StyleSheet:exit"(node) {
+                const baseLayers = atrulesNamed(node, "layer").filter((layer) => preludeIdentifiers(layer).includes("base"));
+                if (baseLayers.length === 0)
+                    return;
+                const applied = [];
+                for (const layer of baseLayers) {
+                    for (const child of blockChildren(layer)) {
+                        if (child.type !== "Rule")
+                            continue;
+                        if (!selectorNames(child).includes("body"))
+                            continue;
+                        for (const declaration of blockChildren(child)) {
+                            if (declaration.type !== "Atrule" || declaration.name !== "apply")
+                                continue;
+                            applied.push(...preludeIdentifiers(declaration));
+                        }
+                    }
+                }
+                const hasCanvas = applied.some((name) => name.includes("canvas"));
+                const hasInk = applied.some((name) => name.includes("ink"));
+                if (!hasCanvas || !hasInk) {
+                    context.report({
+                        node,
+                        message: "The global base layer must apply a canvas and an ink utility to the document body as the default page pair.",
+                    });
+                }
+            },
+        };
+    },
+};

package/dist/eslint/pasika/rules/css/css-variable-naming.d.ts

@@ -0,0 +1,10 @@
+/**
+ * ESLint rule: pasika/css-variable-naming
+ *
+ * A CSS variable intended only for a background MUST be named --<role>-canvas,
+ * and one intended only for readable text MUST be named --<role>-ink.
+ *
+ * @see docs/styling-guide/rules/theme-and-utility-definition-rule.md
+ */
+import type { CSSRuleDefinition } from "@eslint/css";
+export declare const cssVariableNamingRule: CSSRuleDefinition;

package/dist/eslint/pasika/rules/css/css-variable-naming.js

@@ -0,0 +1,39 @@
+/**
+ * ESLint rule: pasika/css-variable-naming
+ *
+ * A CSS variable intended only for a background MUST be named --<role>-canvas,
+ * and one intended only for readable text MUST be named --<role>-ink.
+ *
+ * @see docs/styling-guide/rules/theme-and-utility-definition-rule.md
+ */
+export const cssVariableNamingRule = {
+    meta: {
+        schema: [],
+        type: "problem",
+        docs: {
+            description: "Require background variables to end in -canvas and text variables to end in -ink.",
+        },
+    },
+    create(context) {
+        return {
+            Declaration(node) {
+                const property = node.property;
+                if (!property.startsWith("--"))
+                    return;
+                const lower = property.toLowerCase();
+                if ((lower.includes("bg") || lower.includes("background")) && !lower.endsWith("-canvas")) {
+                    context.report({
+                        node,
+                        message: `CSS variable "${property}" looks like a background token; name it --<role>-canvas instead.`,
+                    });
+                }
+                if (lower.includes("text") && !lower.endsWith("-ink")) {
+                    context.report({
+                        node,
+                        message: `CSS variable "${property}" looks like a text token; name it --<role>-ink instead.`,
+                    });
+                }
+            },
+        };
+    },
+};

package/dist/eslint/pasika/rules/css/custom-utility-apply.d.ts

@@ -0,0 +1,11 @@
+/**
+ * ESLint rule: pasika/custom-utility-apply
+ *
+ * A custom utility MUST use @apply for every styling declaration added by the
+ * project. When no named built-in utility represents a property value, it MUST
+ * apply the Tailwind custom-property or arbitrary-property utility instead.
+ *
+ * @see docs/styling-guide/rules/theme-and-utility-definition-rule.md
+ */
+import type { CSSRuleDefinition } from "@eslint/css";
+export declare const customUtilityApplyRule: CSSRuleDefinition;

package/dist/eslint/pasika/rules/css/custom-utility-apply.js

@@ -0,0 +1,52 @@
+/**
+ * ESLint rule: pasika/custom-utility-apply
+ *
+ * A custom utility MUST use @apply for every styling declaration added by the
+ * project. When no named built-in utility represents a property value, it MUST
+ * apply the Tailwind custom-property or arbitrary-property utility instead.
+ *
+ * @see docs/styling-guide/rules/theme-and-utility-definition-rule.md
+ */
+import { atrulesNamed, blockChildren } from "./helpers.js";
+/** The property name when a tolerant-mode `Raw` is actually `property: value`. */
+function rawProperty(raw) {
+    const match = /^\s*(?<property>[a-z][a-z-]*)\s*:/.exec(raw);
+    return match?.groups?.property;
+}
+export const customUtilityApplyRule = {
+    meta: {
+        schema: [],
+        type: "problem",
+        docs: {
+            description: "Require @utility blocks to style through @apply.",
+        },
+    },
+    create(context) {
+        return {
+            "StyleSheet:exit"(node) {
+                for (const utility of atrulesNamed(node, "utility")) {
+                    for (const child of blockChildren(utility)) {
+                        if (child.type === "Atrule" && child.name === "apply")
+                            continue;
+                        if (child.type === "Declaration") {
+                            context.report({
+                                node: child,
+                                message: `Custom utility must use @apply for styling declaration "${child.property}".`,
+                            });
+                            continue;
+                        }
+                        if (child.type === "Raw") {
+                            const property = rawProperty(child.value);
+                            if (property !== undefined) {
+                                context.report({
+                                    node: child,
+                                    message: `Custom utility must use @apply for styling declaration "${property}".`,
+                                });
+                            }
+                        }
+                    }
+                }
+            },
+        };
+    },
+};

package/dist/eslint/pasika/rules/css/global-css-location.d.ts

@@ -0,0 +1,10 @@
+/**
+ * ESLint rule: pasika/global-css-location
+ *
+ * The project's global CSS MUST live in the global stylesheet entry point and
+ * MUST NOT be imported from another file.
+ *
+ * @see docs/styling-guide/rules/global-stylesheet-rule.md
+ */
+import type { CSSRuleDefinition } from "@eslint/css";
+export declare const globalCssLocationRule: CSSRuleDefinition;

package/dist/eslint/pasika/rules/css/global-css-location.js

@@ -0,0 +1,42 @@
+/**
+ * ESLint rule: pasika/global-css-location
+ *
+ * The project's global CSS MUST live in the global stylesheet entry point and
+ * MUST NOT be imported from another file.
+ *
+ * @see docs/styling-guide/rules/global-stylesheet-rule.md
+ */
+export const globalCssLocationRule = {
+    meta: {
+        schema: [],
+        type: "problem",
+        docs: {
+            description: "Require project global CSS to live only in the entry point stylesheet.",
+        },
+    },
+    create(context) {
+        return {
+            "StyleSheet:exit"(node) {
+                // The entry point registers Tailwind. Any other stylesheet with
+                // project CSS — or that imports the entry point — splits global CSS
+                // out of the entry point.
+                const registersTailwind = node.children.some((child) => child.type === "Atrule" && child.name === "import" && JSON.stringify(child.prelude).includes("tailwindcss"));
+                if (registersTailwind)
+                    return;
+                const hasProjectCss = node.children.some((child) => {
+                    if (child.type === "Atrule" && child.name === "import")
+                        return false;
+                    if (child.type === "Comment")
+                        return false;
+                    return true;
+                });
+                if (!hasProjectCss)
+                    return;
+                context.report({
+                    node,
+                    message: "Global CSS must live in the global stylesheet entry point that registers Tailwind, not in this file.",
+                });
+            },
+        };
+    },
+};

package/dist/eslint/pasika/rules/css/helpers.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Shared AST walkers for the CSS rules.
+ *
+ * The @eslint/css language parses with css-tree in tolerant mode, so constructs
+ * Tailwind v4 extends beyond the CSS grammar — `--*: initial`, arbitrary
+ * properties inside `@apply`, nested `@media` inside `@theme` — survive as
+ * `Raw` nodes instead of structured ones. Rules therefore walk the plain AST
+ * and fall back to raw text when a construct came through unparsed.
+ */
+import type { CssNodePlain } from "@eslint/css-tree";
+/** Visits `node` and every descendant, in document order. */
+export declare function walkNodes(node: CssNodePlain, visit: (current: CssNodePlain) => void): void;
+/** Every `Atrule` node in the sheet, in document order. */
+export declare function atrules(node: CssNodePlain): CssNodePlain[];
+/** Every `Atrule` with the given name. */
+export declare function atrulesNamed(node: CssNodePlain, name: string): CssNodePlain[];
+/** The children of a block-bearing node. */
+export declare function blockChildren(node: CssNodePlain | undefined): CssNodePlain[];
+/**
+ * The names in an at-rule prelude: `Identifier`s (the classes of an `@apply`,
+ * the `inline` of `@theme inline`) and `Layer`s (the layers of `@layer base`).
+ */
+export declare function preludeIdentifiers(node: CssNodePlain | undefined): string[];
+/** The text of a `Raw` node, or the empty string. */
+export declare function rawValue(node: CssNodePlain | undefined): string;
+/** Every `Rule` node in the sheet, in document order. */
+export declare function rules(node: CssNodePlain): CssNodePlain[];
+/** The selector names of a rule's prelude, e.g. `root` for `:root`. */
+export declare function selectorNames(node: CssNodePlain | undefined): string[];

package/dist/eslint/pasika/rules/css/helpers.js

@@ -0,0 +1,93 @@
+/**
+ * Shared AST walkers for the CSS rules.
+ *
+ * The @eslint/css language parses with css-tree in tolerant mode, so constructs
+ * Tailwind v4 extends beyond the CSS grammar — `--*: initial`, arbitrary
+ * properties inside `@apply`, nested `@media` inside `@theme` — survive as
+ * `Raw` nodes instead of structured ones. Rules therefore walk the plain AST
+ * and fall back to raw text when a construct came through unparsed.
+ */
+/** Visits `node` and every descendant, in document order. */
+export function walkNodes(node, visit) {
+    visit(node);
+    if ("children" in node && node.children) {
+        for (const child of node.children)
+            walkNodes(child, visit);
+    }
+    if ("prelude" in node && node.prelude) {
+        walkNodes(node.prelude, visit);
+    }
+    if ("block" in node && node.block) {
+        walkNodes(node.block, visit);
+    }
+}
+/** Every `Atrule` node in the sheet, in document order. */
+export function atrules(node) {
+    const result = [];
+    walkNodes(node, (current) => {
+        if (current.type === "Atrule")
+            result.push(current);
+    });
+    return result;
+}
+/** Every `Atrule` with the given name. */
+export function atrulesNamed(node, name) {
+    return atrules(node).filter((candidate) => candidate.type === "Atrule" && candidate.name === name);
+}
+/** The children of a block-bearing node. */
+export function blockChildren(node) {
+    if (!node)
+        return [];
+    if (!("block" in node) || !node.block)
+        return [];
+    return node.block.children;
+}
+/**
+ * The names in an at-rule prelude: `Identifier`s (the classes of an `@apply`,
+ * the `inline` of `@theme inline`) and `Layer`s (the layers of `@layer base`).
+ */
+export function preludeIdentifiers(node) {
+    if (!node)
+        return [];
+    if (!("prelude" in node) || !node.prelude)
+        return [];
+    const names = [];
+    walkNodes(node.prelude, (current) => {
+        if (current.type === "Identifier")
+            names.push(current.name);
+        if (current.type === "Layer")
+            names.push(current.name);
+    });
+    return names;
+}
+/** The text of a `Raw` node, or the empty string. */
+export function rawValue(node) {
+    if (!node)
+        return "";
+    if (node.type === "Raw")
+        return node.value;
+    return "";
+}
+/** Every `Rule` node in the sheet, in document order. */
+export function rules(node) {
+    const result = [];
+    walkNodes(node, (current) => {
+        if (current.type === "Rule")
+            result.push(current);
+    });
+    return result;
+}
+/** The selector names of a rule's prelude, e.g. `root` for `:root`. */
+export function selectorNames(node) {
+    if (!node)
+        return [];
+    if (!("prelude" in node) || !node.prelude)
+        return [];
+    const names = [];
+    walkNodes(node.prelude, (current) => {
+        if (current.type === "PseudoClassSelector" || current.type === "TypeSelector" || current.type === "ClassSelector") {
+            names.push(current.name);
+        }
+    });
+    return names;
+}

package/dist/eslint/pasika/rules/css/index.d.ts

@@ -0,0 +1,13 @@
+export declare const cssRules: {
+    "theme-reset": import("@eslint/css").CSSRuleDefinition;
+    "root-variables": import("@eslint/css").CSSRuleDefinition;
+    "apply-usage": import("@eslint/css").CSSRuleDefinition;
+    "base-layer-pair": import("@eslint/css").CSSRuleDefinition;
+    "stylesheet-ordering": import("@eslint/css").CSSRuleDefinition;
+    "css-variable-naming": import("@eslint/css").CSSRuleDefinition;
+    "custom-utility-apply": import("@eslint/css").CSSRuleDefinition;
+    "surface-utility": import("@eslint/css").CSSRuleDefinition;
+    "theme-variable-namespace": import("@eslint/css").CSSRuleDefinition;
+    "global-css-location": import("@eslint/css").CSSRuleDefinition;
+};
+export type CssRuleName = keyof typeof cssRules;

package/dist/eslint/pasika/rules/css/index.js

@@ -0,0 +1,25 @@
+/**
+ * All CSS rules for the global stylesheet checks.
+ */
+import { themeResetRule } from "./theme-reset.js";
+import { rootVariablesRule } from "./root-variables.js";
+import { applyUsageRule } from "./apply-usage.js";
+import { baseLayerPairRule } from "./base-layer-pair.js";
+import { stylesheetOrderingRule } from "./stylesheet-ordering.js";
+import { cssVariableNamingRule } from "./css-variable-naming.js";
+import { customUtilityApplyRule } from "./custom-utility-apply.js";
+import { surfaceUtilityRule } from "./surface-utility.js";
+import { themeVariableNamespaceRule } from "./theme-variable-namespace.js";
+import { globalCssLocationRule } from "./global-css-location.js";
+export const cssRules = {
+    "theme-reset": themeResetRule,
+    "root-variables": rootVariablesRule,
+    "apply-usage": applyUsageRule,
+    "base-layer-pair": baseLayerPairRule,
+    "stylesheet-ordering": stylesheetOrderingRule,
+    "css-variable-naming": cssVariableNamingRule,
+    "custom-utility-apply": customUtilityApplyRule,
+    "surface-utility": surfaceUtilityRule,
+    "theme-variable-namespace": themeVariableNamespaceRule,
+    "global-css-location": globalCssLocationRule,
+};

package/dist/eslint/pasika/rules/css/root-variables.d.ts

@@ -0,0 +1,11 @@
+/**
+ * ESLint rule: pasika/root-variables
+ *
+ * Every value used for the project's styling MUST be defined as a CSS variable
+ * in :root, and a Tailwind theme variable MUST reference that CSS variable
+ * through @theme inline.
+ *
+ * @see docs/styling-guide/rules/global-stylesheet-rule.md
+ */
+import type { CSSRuleDefinition } from "@eslint/css";
+export declare const rootVariablesRule: CSSRuleDefinition;

package/dist/eslint/pasika/rules/css/root-variables.js

@@ -0,0 +1,53 @@
+/**
+ * ESLint rule: pasika/root-variables
+ *
+ * Every value used for the project's styling MUST be defined as a CSS variable
+ * in :root, and a Tailwind theme variable MUST reference that CSS variable
+ * through @theme inline.
+ *
+ * @see docs/styling-guide/rules/global-stylesheet-rule.md
+ */
+import { atrulesNamed, blockChildren, preludeIdentifiers, rules, selectorNames } from "./helpers.js";
+export const rootVariablesRule = {
+    meta: {
+        schema: [],
+        type: "problem",
+        docs: {
+            description: "Require styling values to be CSS variables in :root referenced through @theme inline.",
+        },
+    },
+    create(context) {
+        return {
+            "StyleSheet:exit"(node) {
+                const hasRootVars = rules(node).some((rule) => {
+                    if (!selectorNames(rule).includes("root"))
+                        return false;
+                    return blockChildren(rule).some((child) => child.type === "Declaration");
+                });
+                if (!hasRootVars) {
+                    context.report({
+                        node,
+                        message: "Styling values must be defined as CSS variables in a :root block.",
+                    });
+                }
+                // A Tailwind theme variable that references a CSS variable must go
+                // through @theme inline; a bare @theme block would generate values
+                // instead of referencing the :root variables.
+                const referencingThemes = atrulesNamed(node, "theme").filter((theme) => blockChildren(theme).some((child) => {
+                    if (child.type === "Raw")
+                        return child.value.includes("var(");
+                    if (child.type === "Declaration")
+                        return JSON.stringify(child.value).includes("var(");
+                    return false;
+                }));
+                const inlineThemes = atrulesNamed(node, "theme").filter((theme) => preludeIdentifiers(theme).includes("inline"));
+                if (referencingThemes.length > 0 && inlineThemes.length === 0) {
+                    context.report({
+                        node,
+                        message: "Tailwind theme variables that reference CSS variables must use @theme inline.",
+                    });
+                }
+            },
+        };
+    },
+};

package/dist/eslint/pasika/rules/css/rule-tester.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Shared RuleTester wiring for the CSS rule tests.
+ *
+ * Each `describe` title in a rule test is the exact text of the requirement the
+ * case pins, which is how `pasika coverage` verifies that a requirement recorded
+ * as lint-enforced has a test behind it.
+ */
+import { describe } from "node:test";
+import { RuleTester } from "eslint";
+export declare const cssRuleTester: RuleTester;
+export { describe };

package/dist/eslint/pasika/rules/css/rule-tester.js

@@ -0,0 +1,22 @@
+/**
+ * Shared RuleTester wiring for the CSS rule tests.
+ *
+ * Each `describe` title in a rule test is the exact text of the requirement the
+ * case pins, which is how `pasika coverage` verifies that a requirement recorded
+ * as lint-enforced has a test behind it.
+ */
+import { describe, it } from "node:test";
+import { RuleTester } from "eslint";
+import css from "@eslint/css";
+import { cssRules } from "../../index.js";
+RuleTester.describe = describe;
+RuleTester.it = it;
+export const cssRuleTester = new RuleTester({
+    language: "css/css",
+    languageOptions: { tolerant: true },
+    plugins: {
+        css,
+        pasika: { rules: cssRules },
+    },
+});
+export { describe };

package/dist/eslint/pasika/rules/css/stylesheet-ordering.d.ts

@@ -0,0 +1,11 @@
+/**
+ * ESLint rule: pasika/stylesheet-ordering
+ *
+ * The global stylesheet MUST order imports, @custom-variant definitions, :root
+ * variables and the selectors that override them, @theme definitions, custom
+ * utilities, base styles, and keyframes in that order.
+ *
+ * @see docs/styling-guide/rules/global-stylesheet-rule.md
+ */
+import type { CSSRuleDefinition } from "@eslint/css";
+export declare const stylesheetOrderingRule: CSSRuleDefinition;

package/dist/eslint/pasika/rules/css/stylesheet-ordering.js

@@ -0,0 +1,76 @@
+/**
+ * ESLint rule: pasika/stylesheet-ordering
+ *
+ * The global stylesheet MUST order imports, @custom-variant definitions, :root
+ * variables and the selectors that override them, @theme definitions, custom
+ * utilities, base styles, and keyframes in that order.
+ *
+ * @see docs/styling-guide/rules/global-stylesheet-rule.md
+ */
+import { preludeIdentifiers, selectorNames } from "./helpers.js";
+const SECTION_ORDER = ["imports", "custom-variant", "root", "theme", "utility", "base styles", "keyframes"];
+export const stylesheetOrderingRule = {
+    meta: {
+        schema: [],
+        type: "problem",
+        docs: {
+            description: "Require the global stylesheet sections in the documented order.",
+        },
+    },
+    create(context) {
+        return {
+            "StyleSheet:exit"(node) {
+                // Map each top-level child to its section name.
+                const sections = [];
+                let index = 0;
+                for (const child of node.children) {
+                    if (child.type === "Atrule" && child.name === "import") {
+                        sections.push({ name: "imports", at: index });
+                    }
+                    else if (child.type === "Atrule" && child.name === "custom-variant") {
+                        sections.push({ name: "custom-variant", at: index });
+                    }
+                    else if (child.type === "Atrule" && child.name === "theme") {
+                        sections.push({ name: "theme", at: index });
+                    }
+                    else if (child.type === "Atrule" && child.name === "utility") {
+                        sections.push({ name: "utility", at: index });
+                    }
+                    else if (child.type === "Atrule" && child.name === "keyframes") {
+                        sections.push({ name: "keyframes", at: index });
+                    }
+                    else if (child.type === "Atrule" && child.name === "layer") {
+                        if (preludeIdentifiers(child).includes("base")) {
+                            sections.push({ name: "base styles", at: index });
+                        }
+                    }
+                    else if (child.type === "Rule" && selectorNames(child).includes("root")) {
+                        sections.push({ name: "root", at: index });
+                    }
+                    index += 1;
+                }
+                // The first occurrence of each section must not appear after a later
+                // section has already started.
+                const firstAt = new Map();
+                for (const section of sections) {
+                    if (!firstAt.has(section.name))
+                        firstAt.set(section.name, section.at ?? 0);
+                }
+                let lastSeen = -1;
+                for (const name of SECTION_ORDER) {
+                    const at = firstAt.get(name);
+                    if (at === undefined)
+                        continue;
+                    if (at < lastSeen) {
+                        context.report({
+                            node,
+                            message: `Global stylesheet sections must be ordered: imports, @custom-variant, :root, @theme, custom utilities, base styles, keyframes. Found "${name}" before an earlier section.`,
+                        });
+                        return;
+                    }
+                    lastSeen = at;
+                }
+            },
+        };
+    },
+};

package/dist/eslint/pasika/rules/css/surface-utility.d.ts

@@ -0,0 +1,10 @@
+/**
+ * ESLint rule: pasika/surface-utility
+ *
+ * A repeated combination of canvas, ink, and related styles MUST become a
+ * *-surface custom Tailwind utility that owns the combination.
+ *
+ * @see docs/styling-guide/rules/theme-and-utility-definition-rule.md
+ */
+import type { CSSRuleDefinition } from "@eslint/css";
+export declare const surfaceUtilityRule: CSSRuleDefinition;

package/dist/eslint/pasika/rules/css/surface-utility.js

@@ -0,0 +1,41 @@
+/**
+ * ESLint rule: pasika/surface-utility
+ *
+ * A repeated combination of canvas, ink, and related styles MUST become a
+ * *-surface custom Tailwind utility that owns the combination.
+ *
+ * @see docs/styling-guide/rules/theme-and-utility-definition-rule.md
+ */
+import { atrulesNamed, preludeIdentifiers } from "./helpers.js";
+export const surfaceUtilityRule = {
+    meta: {
+        schema: [],
+        type: "problem",
+        docs: {
+            description: "Require repeated canvas+ink combinations to become a *-surface utility.",
+        },
+    },
+    create(context) {
+        return {
+            "StyleSheet:exit"(node) {
+                const combinations = new Map();
+                for (const apply of atrulesNamed(node, "apply")) {
+                    const classes = preludeIdentifiers(apply);
+                    if (!classes.some((name) => name.includes("canvas")) || !classes.some((name) => name.includes("ink"))) {
+                        continue;
+                    }
+                    const key = [...classes].sort().join(" ");
+                    combinations.set(key, (combinations.get(key) ?? 0) + 1);
+                }
+                for (const [combo, count] of combinations) {
+                    if (count < 2)
+                        continue;
+                    context.report({
+                        node,
+                        message: `Combination "${combo}" appears ${String(count)} times. Create a *-surface custom Tailwind utility for it.`,
+                    });
+                }
+            },
+        };
+    },
+};

package/dist/eslint/pasika/rules/css/theme-reset.d.ts

@@ -0,0 +1,9 @@
+/**
+ * ESLint rule: pasika/theme-reset
+ *
+ * The global stylesheet MUST reset Tailwind's default theme with `--*: initial`.
+ *
+ * @see docs/styling-guide/rules/global-stylesheet-rule.md
+ */
+import type { CSSRuleDefinition } from "@eslint/css";
+export declare const themeResetRule: CSSRuleDefinition;