@viewlint/rules 0.0.1

package/README.md

@@ -0,0 +1,5 @@
+# @viewlint/rules
+
+The default rules ViewLint has.
+
+For more info, see the [docs](https://viewlint.vercel.app/docs/rules-reference).

package/dist/index.d.ts

@@ -0,0 +1,41 @@
+import type { Plugin, RuleDefinition, RuleSchema } from "viewlint";
+declare const plugin: {
+    meta: {
+        name: string;
+        docs: {};
+    };
+    rules: Record<string, RuleDefinition<RuleSchema | undefined>>;
+    configs: {
+        recommended: {
+            rules: {
+                "rules/hit-target-obscured": "error";
+                "rules/clipped-content": "error";
+                "rules/container-overflow": "error";
+                "rules/overlapped-elements": "error";
+                "rules/text-overflow": "error";
+                "rules/text-contrast": "warn";
+                "rules/unexpected-scrollbar": "error";
+            };
+            plugins: Record<string, Plugin>;
+        };
+        all: {
+            rules: {
+                "rules/hit-target-obscured": "error";
+                "rules/clipped-content": "error";
+                "rules/container-overflow": "error";
+                "rules/corner-radius-coherence": "warn";
+                "rules/misalignment": "warn";
+                "rules/overlapped-elements": "error";
+                "rules/space-misuse": "warn";
+                "rules/text-overflow": "error";
+                "rules/text-contrast": "warn";
+                "rules/text-proximity": "warn";
+                "rules/text-ragged-lines": "warn";
+                "rules/unexpected-scrollbar": "error";
+            };
+            plugins: Record<string, Plugin>;
+        };
+    };
+};
+export default plugin;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAiClE,QAAA,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqCX,CAAA;AAKD,eAAe,MAAM,CAAA"}

package/dist/index.js

@@ -0,0 +1,69 @@
+import clippedContent from "./rules/clipped-content.js";
+import containerOverflow from "./rules/container-overflow.js";
+import cornerRadiusCoherence from "./rules/corner-radius-coherence.js";
+import hitTargetObscured from "./rules/hit-target-obscured.js";
+import misalignment from "./rules/misalignment.js";
+import overlappedElements from "./rules/overlapped-elements.js";
+import spaceMisuse from "./rules/space-misuse.js";
+import textContrast from "./rules/text-contrast.js";
+import textOverflow from "./rules/text-overflow.js";
+import textProximity from "./rules/text-proximity.js";
+import textRaggedLines from "./rules/text-ragged-lines.js";
+import unexpectedScrollbar from "./rules/unexpected-scrollbar.js";
+const rules = {
+    "hit-target-obscured": hitTargetObscured,
+    "clipped-content": clippedContent,
+    "container-overflow": containerOverflow,
+    "corner-radius-coherence": cornerRadiusCoherence,
+    misalignment: misalignment,
+    "overlapped-elements": overlappedElements,
+    "space-misuse": spaceMisuse,
+    "text-overflow": textOverflow,
+    "text-contrast": textContrast,
+    "text-proximity": textProximity,
+    "text-ragged-lines": textRaggedLines,
+    "unexpected-scrollbar": unexpectedScrollbar,
+};
+const recommendedPlugins = {};
+const allPlugins = {};
+const plugin = {
+    meta: {
+        name: "@viewlint/rules",
+        docs: {},
+    },
+    rules,
+    configs: {
+        recommended: {
+            rules: {
+                "rules/hit-target-obscured": "error",
+                "rules/clipped-content": "error",
+                "rules/container-overflow": "error",
+                "rules/overlapped-elements": "error",
+                "rules/text-overflow": "error",
+                "rules/text-contrast": "warn",
+                "rules/unexpected-scrollbar": "error",
+            },
+            plugins: recommendedPlugins,
+        },
+        all: {
+            rules: {
+                "rules/hit-target-obscured": "error",
+                "rules/clipped-content": "error",
+                "rules/container-overflow": "error",
+                "rules/corner-radius-coherence": "warn",
+                "rules/misalignment": "warn",
+                "rules/overlapped-elements": "error",
+                "rules/space-misuse": "warn",
+                "rules/text-overflow": "error",
+                "rules/text-contrast": "warn",
+                "rules/text-proximity": "warn",
+                "rules/text-ragged-lines": "warn",
+                "rules/unexpected-scrollbar": "error",
+            },
+            plugins: allPlugins,
+        },
+    },
+};
+recommendedPlugins.rules = plugin;
+allPlugins.rules = plugin;
+export default plugin;

package/dist/rules/clipped-content.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Detects elements with overflow:hidden or overflow:clip that are clipping content.
+ *
+ * Uses scrollWidth/scrollHeight as a signal for overflow, but compares against
+ * the element's (subpixel) padding box size derived from getBoundingClientRect
+ * to avoid false positives caused by integer rounding of clientWidth/clientHeight.
+ */
+declare const _default: import("viewlint").RuleDefinition<undefined>;
+export default _default;
+//# sourceMappingURL=clipped-content.d.ts.map

package/dist/rules/clipped-content.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clipped-content.d.ts","sourceRoot":"","sources":["../../src/rules/clipped-content.ts"],"names":[],"mappings":"AAGA;;;;;;GAMG;;AACH,wBAgQE"}

package/dist/rules/clipped-content.js

@@ -0,0 +1,222 @@
+import { defineRule } from "viewlint/plugin";
+import { getDomHelpersHandle } from "../utils/getDomHelpersHandle.js";
+/**
+ * Detects elements with overflow:hidden or overflow:clip that are clipping content.
+ *
+ * Uses scrollWidth/scrollHeight as a signal for overflow, but compares against
+ * the element's (subpixel) padding box size derived from getBoundingClientRect
+ * to avoid false positives caused by integer rounding of clientWidth/clientHeight.
+ */
+export default defineRule({
+    meta: {
+        severity: "error",
+        docs: {
+            description: "Detects content clipped by overflow:hidden or overflow:clip",
+            recommended: true,
+        },
+    },
+    async run(context) {
+        const domHelpers = await getDomHelpersHandle(context.page);
+        await context.evaluate(({ report, scope, args: { domHelpers } }) => {
+            const CLIP_THRESHOLD = 1;
+            const MIN_TEXT_CLIP_THRESHOLD = 3;
+            const NEGATIVE_MARGIN_TOLERANCE = 2;
+            const hasObviousMediaDescendant = (el) => {
+                return Boolean(el.querySelector("img, video, canvas, svg, picture"));
+            };
+            const hasPseudoContent = (el) => {
+                const before = window.getComputedStyle(el, "::before").content;
+                const after = window.getComputedStyle(el, "::after").content;
+                return ((before !== "none" && before !== "normal") ||
+                    (after !== "none" && after !== "normal"));
+            };
+            const matchesNegativeMarginClipping = (container, axis, clippedAmount) => {
+                if (container.children.length === 0)
+                    return false;
+                if (domHelpers.getDirectTextNodes(container, 1).length > 0)
+                    return false;
+                const children = Array.from(container.children).slice(0, 25);
+                for (const child of children) {
+                    if (!domHelpers.isHtmlElement(child))
+                        continue;
+                    if (!domHelpers.isVisible(child))
+                        continue;
+                    const style = window.getComputedStyle(child);
+                    const first = axis === "x"
+                        ? domHelpers.parsePx(style.marginLeft)
+                        : domHelpers.parsePx(style.marginTop);
+                    const second = axis === "x"
+                        ? domHelpers.parsePx(style.marginRight)
+                        : domHelpers.parsePx(style.marginBottom);
+                    if (first >= 0 && second >= 0)
+                        continue;
+                    const expected = Math.max(0, -first) + Math.max(0, -second);
+                    if (expected <= 0)
+                        continue;
+                    const closeEnough = Math.abs(clippedAmount - expected) <= NEGATIVE_MARGIN_TOLERANCE;
+                    const likelyFromNegativeMargins = clippedAmount <= expected + NEGATIVE_MARGIN_TOLERANCE;
+                    if (closeEnough || likelyFromNegativeMargins)
+                        return true;
+                }
+                return false;
+            };
+            const allElements = scope.queryAll("*");
+            for (const el of allElements) {
+                if (!domHelpers.isHtmlElement(el))
+                    continue;
+                if (!domHelpers.isVisible(el))
+                    continue;
+                if (!domHelpers.hasClientSize(el))
+                    continue;
+                const parent = el.parentElement;
+                if (parent &&
+                    domHelpers.isHtmlElement(parent) &&
+                    domHelpers.isIntentionallyClipped(parent)) {
+                    continue;
+                }
+                const style = window.getComputedStyle(el);
+                const overflowX = style.overflowX;
+                const overflowY = style.overflowY;
+                const clipsX = domHelpers.isClippingOverflowValue(overflowX);
+                const clipsY = domHelpers.isClippingOverflowValue(overflowY);
+                const clampsTextVertically = domHelpers.isLineClamped(el);
+                const clipsYForCheck = clipsY && !clampsTextVertically;
+                if (!clipsX && !clipsY)
+                    continue;
+                if (clipsX && domHelpers.hasTextOverflowEllipsis(el))
+                    continue;
+                const { scrollWidth, scrollHeight } = el;
+                const paddingBox = domHelpers.getPaddingBoxSize(el);
+                const clippedAmountX = scrollWidth - paddingBox.width;
+                const clippedAmountY = scrollHeight - paddingBox.height;
+                let clippedX = clipsX && clippedAmountX > CLIP_THRESHOLD;
+                let clippedY = clipsYForCheck && clippedAmountY > CLIP_THRESHOLD;
+                if (clippedY) {
+                    const hasVisibleText = el.innerText.trim().length > 0;
+                    const fontSizePx = domHelpers.getFontSize(el);
+                    const textClipThreshold = hasVisibleText
+                        ? Math.max(MIN_TEXT_CLIP_THRESHOLD, fontSizePx * 0.2)
+                        : CLIP_THRESHOLD;
+                    clippedY = clippedAmountY > textClipThreshold;
+                }
+                if (clippedY) {
+                    const isLikelyMinorCrop = paddingBox.height >= 48 &&
+                        domHelpers.isIntentionallyClipped(el) &&
+                        hasObviousMediaDescendant(el);
+                    if (isLikelyMinorCrop) {
+                        const allowable = Math.max(4, paddingBox.height * 0.02);
+                        if (clippedAmountY <= allowable) {
+                            clippedY = false;
+                        }
+                    }
+                }
+                if (clippedX || clippedY) {
+                    const hasVisibleText = el.innerText.trim().length > 0;
+                    const hasDirectText = domHelpers.getDirectTextNodes(el, 1).length > 0;
+                    const canVerifyByChildRects = !hasVisibleText &&
+                        !hasDirectText &&
+                        !hasPseudoContent(el) &&
+                        el.children.length > 0 &&
+                        el.children.length <= 5;
+                    if (canVerifyByChildRects) {
+                        const clipRect = domHelpers.getPaddingBoxRect(el);
+                        let fitsX = true;
+                        let fitsY = true;
+                        for (const child of el.children) {
+                            if (!domHelpers.isHtmlElement(child))
+                                continue;
+                            if (!domHelpers.isVisible(child))
+                                continue;
+                            const r = child.getBoundingClientRect();
+                            if (r.width === 0 || r.height === 0)
+                                continue;
+                            if (r.left < clipRect.left - CLIP_THRESHOLD)
+                                fitsX = false;
+                            if (r.right > clipRect.right + CLIP_THRESHOLD)
+                                fitsX = false;
+                            if (r.top < clipRect.top - CLIP_THRESHOLD)
+                                fitsY = false;
+                            if (r.bottom > clipRect.bottom + CLIP_THRESHOLD)
+                                fitsY = false;
+                            if (!fitsX && !fitsY)
+                                break;
+                        }
+                        if (clippedX && fitsX)
+                            clippedX = false;
+                        if (clippedY && fitsY)
+                            clippedY = false;
+                    }
+                }
+                if (clippedX &&
+                    matchesNegativeMarginClipping(el, "x", clippedAmountX)) {
+                    clippedX = false;
+                }
+                if (clippedY &&
+                    matchesNegativeMarginClipping(el, "y", clippedAmountY)) {
+                    clippedY = false;
+                }
+                // Common layout pattern: horizontal gutters achieved by clipping symmetric overflow.
+                if (clippedX) {
+                    let minLeft = Infinity;
+                    let maxRight = -Infinity;
+                    const clipRect = el.getBoundingClientRect();
+                    for (const child of el.children) {
+                        if (!domHelpers.isHtmlElement(child))
+                            continue;
+                        if (!domHelpers.isVisible(child))
+                            continue;
+                        const r = child.getBoundingClientRect();
+                        minLeft = Math.min(minLeft, r.left);
+                        maxRight = Math.max(maxRight, r.right);
+                    }
+                    if (minLeft !== Infinity && maxRight !== -Infinity) {
+                        const leftOverflow = Math.max(0, clipRect.left - minLeft);
+                        const rightOverflow = Math.max(0, maxRight - clipRect.right);
+                        const isSymmetric = leftOverflow > CLIP_THRESHOLD &&
+                            rightOverflow > CLIP_THRESHOLD &&
+                            Math.abs(leftOverflow - rightOverflow) <= 2;
+                        if (isSymmetric) {
+                            clippedX = false;
+                        }
+                    }
+                }
+                if (!clippedX && !clippedY)
+                    continue;
+                const containerRect = el.getBoundingClientRect();
+                let absoluteChildOverflow = false;
+                for (const child of el.children) {
+                    if (!domHelpers.isHtmlElement(child))
+                        continue;
+                    const childStyle = window.getComputedStyle(child);
+                    if (childStyle.position !== "absolute")
+                        continue;
+                    const childRect = child.getBoundingClientRect();
+                    const overflowsX = childRect.right - containerRect.right > CLIP_THRESHOLD ||
+                        containerRect.left - childRect.left > CLIP_THRESHOLD;
+                    const overflowsY = childRect.bottom - containerRect.bottom > CLIP_THRESHOLD ||
+                        containerRect.top - childRect.top > CLIP_THRESHOLD;
+                    if ((clippedX && overflowsX) || (clippedY && overflowsY)) {
+                        absoluteChildOverflow = true;
+                        break;
+                    }
+                }
+                if (absoluteChildOverflow)
+                    continue;
+                let message;
+                if (clippedX && clippedY) {
+                    message = `Content is clipped by ${Math.round(clippedAmountX)}px horizontally and ${Math.round(clippedAmountY)}px vertically`;
+                }
+                else if (clippedX) {
+                    message = `Content is clipped by ${Math.round(clippedAmountX)}px horizontally`;
+                }
+                else {
+                    message = `Content is clipped by ${Math.round(clippedAmountY)}px vertically`;
+                }
+                report({
+                    message,
+                    element: el,
+                });
+            }
+        }, { domHelpers });
+    },
+});

package/dist/rules/container-overflow.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Detects child elements that overflow their parent container bounds.
+ *
+ * Compares bounding boxes of parent and child to detect when content
+ * extends beyond the visible container area.
+ */
+declare const _default: import("viewlint").RuleDefinition<undefined>;
+export default _default;
+//# sourceMappingURL=container-overflow.d.ts.map

package/dist/rules/container-overflow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"container-overflow.d.ts","sourceRoot":"","sources":["../../src/rules/container-overflow.ts"],"names":[],"mappings":"AAIA;;;;;GAKG;;AACH,wBAkQE"}

package/dist/rules/container-overflow.js

@@ -0,0 +1,185 @@
+import { defineRule } from "viewlint/plugin";
+import { getDomHelpersHandle } from "../utils/getDomHelpersHandle.js";
+/**
+ * Detects child elements that overflow their parent container bounds.
+ *
+ * Compares bounding boxes of parent and child to detect when content
+ * extends beyond the visible container area.
+ */
+export default defineRule({
+    meta: {
+        severity: "error",
+        docs: {
+            description: "Detects child elements that overflow their parent container",
+            recommended: true,
+        },
+    },
+    async run(context) {
+        const domHelpers = await getDomHelpersHandle(context.page);
+        await context.evaluate(({ report, scope, args: { domHelpers } }) => {
+            void report;
+            // Small overflow for containers that clip
+            const OVERFLOW_THRESHOLD = 1;
+            // Larger threshold for visible overflow containers (likely intentional small overlaps)
+            const VISIBLE_OVERFLOW_THRESHOLD = 20;
+            const NEGATIVE_MARGIN_TOLERANCE = 2;
+            const hasVisibleOverflow = (el) => {
+                const style = window.getComputedStyle(el);
+                return (style.overflow === "visible" &&
+                    style.overflowX === "visible" &&
+                    style.overflowY === "visible");
+            };
+            const isSymmetricHorizontalOverflow = (overflow, threshold) => {
+                return (overflow.left > threshold &&
+                    overflow.right > threshold &&
+                    Math.abs(overflow.left - overflow.right) <= 2);
+            };
+            const looksLikeNegativeMarginClipping = (child, parent, overflow, threshold) => {
+                const parentStyle = window.getComputedStyle(parent);
+                const clipsX = domHelpers.isClippingOverflowValue(parentStyle.overflowX);
+                const clipsY = domHelpers.isClippingOverflowValue(parentStyle.overflowY);
+                if (!clipsX && !clipsY)
+                    return false;
+                const style = window.getComputedStyle(child);
+                const marginLeft = domHelpers.parsePx(style.marginLeft);
+                const marginRight = domHelpers.parsePx(style.marginRight);
+                const marginTop = domHelpers.parsePx(style.marginTop);
+                const marginBottom = domHelpers.parsePx(style.marginBottom);
+                const leftMatch = clipsX &&
+                    marginLeft < 0 &&
+                    overflow.left > threshold &&
+                    Math.abs(overflow.left - Math.abs(marginLeft)) <=
+                        NEGATIVE_MARGIN_TOLERANCE;
+                const rightMatch = clipsX &&
+                    marginRight < 0 &&
+                    overflow.right > threshold &&
+                    Math.abs(overflow.right - Math.abs(marginRight)) <=
+                        NEGATIVE_MARGIN_TOLERANCE;
+                const topMatch = clipsY &&
+                    marginTop < 0 &&
+                    overflow.top > threshold &&
+                    Math.abs(overflow.top - Math.abs(marginTop)) <=
+                        NEGATIVE_MARGIN_TOLERANCE;
+                const bottomMatch = clipsY &&
+                    marginBottom < 0 &&
+                    overflow.bottom > threshold &&
+                    Math.abs(overflow.bottom - Math.abs(marginBottom)) <=
+                        NEGATIVE_MARGIN_TOLERANCE;
+                const symmetricMatch = clipsX &&
+                    marginLeft < 0 &&
+                    marginRight < 0 &&
+                    isSymmetricHorizontalOverflow({ left: overflow.left, right: overflow.right }, threshold) &&
+                    Math.abs(Math.abs(marginLeft) - Math.abs(marginRight)) <=
+                        NEGATIVE_MARGIN_TOLERANCE;
+                return (leftMatch || rightMatch || topMatch || bottomMatch || symmetricMatch);
+            };
+            const isClippedByIntentionallyClippedAncestor = (el, childRect, overflow, threshold) => {
+                const needsX = overflow.left > threshold || overflow.right > threshold;
+                const needsY = overflow.top > threshold || overflow.bottom > threshold;
+                if (!needsX && !needsY)
+                    return false;
+                let current = el.parentElement;
+                while (current) {
+                    if (!domHelpers.isHtmlElement(current)) {
+                        current = current.parentElement;
+                        continue;
+                    }
+                    const style = window.getComputedStyle(current);
+                    const clipsX = domHelpers.isClippingOverflowValue(style.overflowX);
+                    const clipsY = domHelpers.isClippingOverflowValue(style.overflowY);
+                    const clipsInNeededAxis = (needsX && clipsX) || (needsY && clipsY);
+                    if (!clipsInNeededAxis) {
+                        current = current.parentElement;
+                        continue;
+                    }
+                    if (!domHelpers.isIntentionallyClipped(current)) {
+                        current = current.parentElement;
+                        continue;
+                    }
+                    const rect = current.getBoundingClientRect();
+                    const clippedInX = needsX &&
+                        clipsX &&
+                        (childRect.left < rect.left - threshold ||
+                            childRect.right > rect.right + threshold);
+                    const clippedInY = needsY &&
+                        clipsY &&
+                        (childRect.top < rect.top - threshold ||
+                            childRect.bottom > rect.bottom + threshold);
+                    if (clippedInX || clippedInY)
+                        return true;
+                    current = current.parentElement;
+                }
+                return false;
+            };
+            const allElements = scope.queryAll("*");
+            for (const el of allElements) {
+                if (!domHelpers.isHtmlElement(el))
+                    continue;
+                if (!domHelpers.isVisible(el))
+                    continue;
+                if (!domHelpers.hasElementRectSize(el))
+                    continue;
+                if (domHelpers.hasTextOverflowEllipsis(el))
+                    continue;
+                if (domHelpers.isOffscreenPositioned(el))
+                    continue;
+                const elementStyle = window.getComputedStyle(el);
+                if (elementStyle.position === "absolute" ||
+                    elementStyle.position === "fixed" ||
+                    elementStyle.position === "sticky") {
+                    continue;
+                }
+                const parent = el.parentElement;
+                if (!parent || !domHelpers.isHtmlElement(parent))
+                    continue;
+                if (!domHelpers.isVisible(parent))
+                    continue;
+                if (!domHelpers.hasElementRectSize(parent))
+                    continue;
+                // Skip body as parent - content overflowing body is normal for scrollable pages
+                if (parent.tagName === "BODY" || parent.tagName === "HTML")
+                    continue;
+                if (domHelpers.hasTextOverflowEllipsis(parent))
+                    continue;
+                if (domHelpers.isIntentionallyClipped(parent))
+                    continue;
+                const parentRect = parent.getBoundingClientRect();
+                const childRect = el.getBoundingClientRect();
+                const parentHasVisibleOverflow = hasVisibleOverflow(parent);
+                // For visible overflow containers, use higher threshold and only
+                // check if parent looks like a proper layout container
+                if (parentHasVisibleOverflow) {
+                    if (!domHelpers.isLayoutContainer(parent))
+                        continue;
+                    const overflow = domHelpers.getOverflow(parentRect, childRect, VISIBLE_OVERFLOW_THRESHOLD);
+                    if (!overflow)
+                        continue;
+                    if (isClippedByIntentionallyClippedAncestor(el, childRect, overflow, VISIBLE_OVERFLOW_THRESHOLD)) {
+                        continue;
+                    }
+                    report({
+                        message: `Element overflows its container by ${domHelpers.formatOverflow(overflow, VISIBLE_OVERFLOW_THRESHOLD)}`,
+                        element: el,
+                        relations: [{ description: "Container", element: parent }],
+                    });
+                }
+                else {
+                    const overflow = domHelpers.getOverflow(parentRect, childRect, OVERFLOW_THRESHOLD);
+                    if (!overflow)
+                        continue;
+                    if (looksLikeNegativeMarginClipping(el, parent, overflow, OVERFLOW_THRESHOLD)) {
+                        continue;
+                    }
+                    if (isClippedByIntentionallyClippedAncestor(el, childRect, overflow, OVERFLOW_THRESHOLD)) {
+                        continue;
+                    }
+                    report({
+                        message: `Element overflows its container by ${domHelpers.formatOverflow(overflow, OVERFLOW_THRESHOLD)}`,
+                        element: el,
+                        relations: [{ description: "Container", element: parent }],
+                    });
+                }
+            }
+        }, { domHelpers });
+    },
+});

package/dist/rules/corner-radius-coherence.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Detects child elements whose corner radius violates the corner radius law.
+ *
+ * The corner radius law states that for nested rounded corners to look visually
+ * coherent, the child's radius should equal `parent_radius - inset`, where inset
+ * is the distance between the parent's inner edge and the child's outer edge.
+ *
+ * Only reports when the inset is small enough relative to the parent's radius
+ * that the relationship matters visually (inset <= 0.5 * parent_radius).
+ */
+declare const _default: import("viewlint").RuleDefinition<undefined>;
+export default _default;
+//# sourceMappingURL=corner-radius-coherence.d.ts.map

package/dist/rules/corner-radius-coherence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"corner-radius-coherence.d.ts","sourceRoot":"","sources":["../../src/rules/corner-radius-coherence.ts"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;;AACH,wBAoNE"}