@ashstack/lint 0.1.0

package/dist/react-native/rules/reanimated/no-shared-value-dot-value.js

@@ -0,0 +1,112 @@
+import { isProducerCall } from "./shared.js";
+const MESSAGES = {
+    read: "Read this shared value with `.get()` so the React Compiler can track the read.",
+    write: "Write this shared value with `.set(...)` so the React Compiler can track the mutation.",
+    compound: "Write this shared value with `.set(v => ...)`, or `.set(x.get() ...)`, so the React Compiler can track the mutation.",
+};
+const COMPOUND_OPERATORS = new Map([
+    ["+=", "+"],
+    ["-=", "-"],
+    ["*=", "*"],
+    ["/=", "/"],
+]);
+/** The identifier a plain `x.value` reads from, or null when the node is not one. */
+const dotValueOwner = (node) => {
+    if (node?.type !== "MemberExpression" || node.optional || node.computed)
+        return null;
+    const { object, property } = node;
+    if (object.type !== "Identifier")
+        return null;
+    if (property.type !== "Identifier" || property.name !== "value")
+        return null;
+    return object.name;
+};
+/** A parent that makes `x.value` a write target no `.get()` rewrite can stand in for. */
+const WRITE_TARGET_PARENTS = new Set([
+    "UpdateExpression",
+    "ArrayPattern",
+    "ObjectPattern",
+    "RestElement",
+    "AssignmentPattern",
+]);
+export const noSharedValueDotValue = {
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Shared values are read with `.get()` and written with `.set(...)`, never through `.value`. React Compiler cannot track a `.value` access.",
+        },
+        hasSuggestions: true,
+    },
+    createOnce(context) {
+        const names = new Set();
+        const candidates = [];
+        return {
+            before() {
+                names.clear();
+                candidates.length = 0;
+            },
+            VariableDeclarator(node) {
+                if (node.id.type === "Identifier" && isProducerCall(node.init)) {
+                    names.add(node.id.name);
+                }
+            },
+            AssignmentExpression(node) {
+                const name = dotValueOwner(node.left);
+                if (name === null)
+                    return;
+                const operator = COMPOUND_OPERATORS.get(node.operator);
+                if (operator) {
+                    candidates.push({ kind: "compound", node, name, operator, right: node.right });
+                    return;
+                }
+                if (node.operator !== "=")
+                    return;
+                candidates.push({ kind: "write", node, name, right: node.right });
+            },
+            UpdateExpression(node) {
+                const name = dotValueOwner(node.argument);
+                if (name === null)
+                    return;
+                candidates.push({ kind: "update", node, name });
+            },
+            MemberExpression(node) {
+                const name = dotValueOwner(node);
+                if (name === null)
+                    return;
+                if (node.parent.type === "AssignmentExpression" && node.parent.left === node)
+                    return;
+                if (WRITE_TARGET_PARENTS.has(node.parent.type))
+                    return;
+                candidates.push({ kind: "read", node, name });
+            },
+            "Program:exit"() {
+                for (const candidate of candidates) {
+                    const { node, name } = candidate;
+                    if (!names.has(name))
+                        continue;
+                    if (candidate.kind === "update") {
+                        context.report({ node, message: MESSAGES.compound });
+                        continue;
+                    }
+                    if (candidate.kind === "read") {
+                        context.report({
+                            node,
+                            message: MESSAGES.read,
+                            suggest: [{ desc: `Rewrite as ${name}.get()`, fix: fixer => fixer.replaceText(node, `${name}.get()`) }],
+                        });
+                        continue;
+                    }
+                    const right = context.sourceCode.getText(candidate.right);
+                    const replacement = candidate.kind === "compound"
+                        ? `${name}.set(${name}.get() ${candidate.operator} (${right}))`
+                        : `${name}.set(${right})`;
+                    context.report({
+                        node,
+                        message: candidate.kind === "compound" ? MESSAGES.compound : MESSAGES.write,
+                        suggest: [{ desc: `Rewrite as ${name}.set(...)`, fix: fixer => fixer.replaceText(node, replacement) }],
+                    });
+                }
+            },
+        };
+    },
+};

package/dist/react-native/rules/reanimated/prefer-lazy-shared-value-initializer.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "../../../lib/types.js";
+export declare const preferLazySharedValueInitializer: Rule;

package/dist/react-native/rules/reanimated/prefer-lazy-shared-value-initializer.js

@@ -0,0 +1,24 @@
+import { gate, problem } from "../../../lib/ast.js";
+const EAGER_INITIALIZER = "Wrap this in a lazy initializer: `useSharedValue(() => compute())`, since the eager call runs on every React render.";
+export const preferLazySharedValueInitializer = problem("Pass a computed `useSharedValue` initial value as a function. An eager call runs on every render while only the first result is kept.", {
+    createOnce(context) {
+        return {
+            before() {
+                return gate(context, "useSharedValue");
+            },
+            CallExpression(node) {
+                const { callee } = node;
+                if (callee.type !== "Identifier" || callee.name !== "useSharedValue")
+                    return;
+                const argument = node.arguments[0];
+                if (!argument)
+                    return;
+                const eager = (argument.type === "CallExpression" && argument.callee.type === "Identifier") ||
+                    argument.type === "NewExpression";
+                if (!eager)
+                    return;
+                context.report({ node, message: EAGER_INITIALIZER });
+            },
+        };
+    },
+});

package/dist/react-native/rules/reanimated/schedule-on-rn-scope.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "../../../lib/types.js";
+export declare const scheduleOnRnScope: Rule;

package/dist/react-native/rules/reanimated/schedule-on-rn-scope.js

@@ -0,0 +1,21 @@
+import { calleeName, gate, isFunction, problem } from "../../../lib/ast.js";
+const INLINE_CALLBACK = "Pass a function declared in RN Runtime scope to `scheduleOnRN`; an inline callback has ambiguous runtime ownership and can be created on the wrong runtime.";
+export const scheduleOnRnScope = problem("`scheduleOnRN` takes a function declared in RN Runtime scope. An inline callback can end up created on the wrong runtime.", {
+    createOnce(context) {
+        return {
+            before() {
+                return gate(context, "scheduleOnRN");
+            },
+            CallExpression(node) {
+                if (calleeName(node) !== "scheduleOnRN")
+                    return;
+                const [callback] = node.arguments;
+                if (callback === undefined)
+                    return;
+                if (isFunction(callback) && callback.type !== "FunctionDeclaration") {
+                    context.report({ node: callback, message: INLINE_CALLBACK });
+                }
+            },
+        };
+    },
+});

package/dist/react-native/rules/reanimated/shared-value-usage.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "../../../lib/types.js";
+export declare const sharedValueUsage: Rule;

package/dist/react-native/rules/reanimated/shared-value-usage.js

@@ -0,0 +1,105 @@
+import { closestAncestor, crossesFunctionBefore, FUNCTION_TYPES, isMemberCall, problem, receiverName, subtreeHas, } from "../../../lib/ast.js";
+import { isProducerCall } from "./shared.js";
+const MESSAGES = {
+    renderRead: "Read this inside `useAnimatedStyle`/`useAnimatedProps`, or mirror non-visual state through an explicit callback. A `.get()` while JSX is evaluated is untracked, so the rendered value never updates.",
+    renderWrite: "Move this write into an event handler, an effect, or an animation callback — render must stay pure.",
+    destructure: "Keep the SharedValue object itself and read or write it with `.get()` / `.set(...)`; destructuring detaches the value from Reanimated reactivity.",
+    nestedProperty: "Assign a new value with `.set(...)`, or use `.modify()` for a large object; mutating a property returned by `.get()` bypasses shared-value reactivity.",
+    nestedCollection: "Assign a new collection with `.set(...)`, or mutate inside `.modify()`; mutating the collection returned by `.get()` bypasses shared-value reactivity.",
+};
+const MUTATING_METHODS = new Set([
+    "push",
+    "pop",
+    "shift",
+    "unshift",
+    "splice",
+    "sort",
+    "reverse",
+    "copyWithin",
+    "fill",
+    "set",
+    "add",
+    "delete",
+    "clear",
+]);
+const JSX_HOSTS = new Set(["JSXExpressionContainer", "JSXAttribute"]);
+/** True for `sv.get().push(...)` and friends — a mutation of the collection `get()` handed back. */
+const mutatesWhatGetReturned = (node) => {
+    if (node.type !== "CallExpression" || node.callee.type !== "MemberExpression")
+        return false;
+    const { object, property } = node.callee;
+    return property.type === "Identifier" && MUTATING_METHODS.has(property.name) && isMemberCall(object, "get");
+};
+/** True when the call is evaluated as JSX is built, rather than inside a callback JSX only passes along. */
+const runsWhileJsxEvaluates = (node) => {
+    const host = closestAncestor(node, JSX_HOSTS);
+    if (!host)
+        return false;
+    if (crossesFunctionBefore(node, host, FUNCTION_TYPES))
+        return false;
+    return !subtreeHas(host, current => FUNCTION_TYPES.has(current.type));
+};
+export const sharedValueUsage = problem("Destructuring a shared value or mutating what its `get()` returned detaches it from Reanimated reactivity. Reading or writing one while JSX evaluates also makes render impure.", {
+    createOnce(context) {
+        const names = new Set();
+        const candidates = [];
+        return {
+            before() {
+                names.clear();
+                candidates.length = 0;
+            },
+            VariableDeclarator(node) {
+                const { id, init } = node;
+                if (id.type === "Identifier" && isProducerCall(init)) {
+                    names.add(id.name);
+                    return;
+                }
+                if (id.type !== "ObjectPattern")
+                    return;
+                if (init?.type !== "CallExpression")
+                    return;
+                if (init.callee.type !== "Identifier" || init.callee.name !== "useSharedValue")
+                    return;
+                const destructuresValue = id.properties.some(property => {
+                    if (property.type !== "Property")
+                        return false;
+                    const { key } = property;
+                    return key.type === "Identifier" && key.name === "value";
+                });
+                if (destructuresValue)
+                    context.report({ node, message: MESSAGES.destructure });
+            },
+            AssignmentExpression(node) {
+                if (node.left.type !== "MemberExpression")
+                    return;
+                if (!isMemberCall(node.left.object, "get"))
+                    return;
+                const shared = receiverName(node.left.object);
+                if (!shared)
+                    return;
+                candidates.push({ node, shared, message: MESSAGES.nestedProperty });
+            },
+            CallExpression(node) {
+                if (mutatesWhatGetReturned(node)) {
+                    context.report({ node, message: MESSAGES.nestedCollection });
+                    return;
+                }
+                const isGet = isMemberCall(node, "get") && node.arguments.length === 0;
+                if (!isGet && !isMemberCall(node, "set"))
+                    return;
+                const shared = receiverName(node);
+                if (!shared)
+                    return;
+                if (!runsWhileJsxEvaluates(node))
+                    return;
+                candidates.push({ node, shared, message: isGet ? MESSAGES.renderRead : MESSAGES.renderWrite });
+            },
+            "Program:exit"() {
+                for (const { node, shared, message } of candidates) {
+                    if (names.has(shared))
+                        context.report({ node, message });
+                }
+            },
+        };
+    },
+});

package/dist/react-native/rules/reanimated/shared.d.ts

@@ -0,0 +1,5 @@
+import type { AstNode } from "../../../lib/types.js";
+/** `useSharedValue(...)` and friends, under a namespace or not — decides which locals hold a shared value. */
+export declare const isProducerCall: (node: AstNode | null | undefined) => boolean;
+/** The hooks whose callback is an animated updater. */
+export declare const ANIMATED_STYLE_HOOKS: Set<string>;

package/dist/react-native/rules/reanimated/shared.js

@@ -0,0 +1,13 @@
+import { calleeName } from "../../../lib/ast.js";
+/** Calls that hand back a SharedValue. */
+const PRODUCERS = new Set([
+    "useSharedValue",
+    "useDerivedValue",
+    "useScrollOffset",
+    "useScrollViewOffset",
+    "makeMutable",
+]);
+/** `useSharedValue(...)` and friends, under a namespace or not — decides which locals hold a shared value. */
+export const isProducerCall = (node) => node?.type === "CallExpression" && PRODUCERS.has(calleeName(node));
+/** The hooks whose callback is an animated updater. */
+export const ANIMATED_STYLE_HOOKS = new Set(["useAnimatedStyle", "useAnimatedProps"]);

package/dist/react-native/rules/skia/canvas-opaque.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "../../../lib/types.js";
+export declare const canvasOpaque: Rule;

package/dist/react-native/rules/skia/canvas-opaque.js

@@ -0,0 +1,49 @@
+import { attributeName, gate, importedSpecifiers, problem, tagPath } from "../../../lib/ast.js";
+const MESSAGE = "Add an explicit `opaque` prop to this `<Canvas>`: `opaque={Platform.OS === 'android'}` for a fullscreen animated canvas, or `opaque={false}` when it needs transparency, view transforms, or ordinary stacking.";
+export const canvasOpaque = problem("Require an explicit `opaque` prop on a Skia `<Canvas>`. A fullscreen animated canvas wants it on; anything that needs transparency or a view transform wants it off.", {
+    createOnce(context) {
+        const canvasLocals = new Set();
+        const namespaces = new Set();
+        const elements = [];
+        /** `<Canvas>` under its imported name, or `<Skia.Canvas>` under a namespace or default import. */
+        const namesACanvas = (name) => {
+            const path = tagPath(name);
+            const dot = path.lastIndexOf(".");
+            if (dot === -1)
+                return canvasLocals.has(path);
+            return namespaces.has(path.slice(0, dot)) && path.slice(dot + 1) === "Canvas";
+        };
+        return {
+            before() {
+                canvasLocals.clear();
+                namespaces.clear();
+                elements.length = 0;
+                return gate(context, "react-native-skia");
+            },
+            ImportDeclaration(node) {
+                for (const specifier of importedSpecifiers(node, "@shopify/react-native-skia")) {
+                    if (specifier.type === "ImportSpecifier") {
+                        const { imported, local } = specifier;
+                        if (imported.type === "Identifier" && imported.name === "Canvas")
+                            canvasLocals.add(local.name);
+                        continue;
+                    }
+                    if (specifier.type === "ImportNamespaceSpecifier" || specifier.type === "ImportDefaultSpecifier") {
+                        namespaces.add(specifier.local.name);
+                    }
+                }
+            },
+            JSXOpeningElement(node) {
+                if (!namesACanvas(node.name))
+                    return;
+                const hasOpaque = node.attributes.some(attribute => attribute.type === "JSXAttribute" && attributeName(attribute) === "opaque");
+                if (!hasOpaque)
+                    elements.push(node);
+            },
+            "Program:exit"() {
+                for (const element of elements)
+                    context.report({ node: element, message: MESSAGE });
+            },
+        };
+    },
+});

package/dist/react-native/rules/skia/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../../../index.js").ModuleManifest;
+export default _default;

package/dist/react-native/rules/skia/index.js

@@ -0,0 +1,21 @@
+import { defineModule } from "../../../lib/module.js";
+import { canvasOpaque } from "./canvas-opaque.js";
+export default defineModule({
+    meta: { name: "@ashstack/skia" },
+    url: import.meta.url,
+    packages: ["@shopify/react-native-skia"],
+    option: "skia",
+    docsWhen: "auto-enabled when `@shopify/react-native-skia` is a dependency",
+    rules: {
+        "canvas-opaque": canvasOpaque,
+    },
+    restrictedImports: {
+        paths: [
+            {
+                name: "@shopify/react-native-skia",
+                importNames: ["usePathValue", "usePathInterpolation"],
+                message: "Keep one stable `SkPath` buffer and mutate it inside `useDerivedValue`, with consumers reading the driving shared value. These legacy path-value hooks self-dirty Reanimated mappers and re-record idle canvases.",
+            },
+        ],
+    },
+});

package/dist/react-native/rules/turbo-image/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../../../index.js").ModuleManifest;
+export default _default;

package/dist/react-native/rules/turbo-image/index.js

@@ -0,0 +1,14 @@
+import { defineModule } from "../../../lib/module.js";
+import { requireCachePolicy } from "./require-cache-policy.js";
+import { requireResize } from "./require-resize.js";
+export default defineModule({
+    meta: { name: "@ashstack/turbo-image" },
+    url: import.meta.url,
+    packages: ["react-native-turbo-image"],
+    option: "turboImage",
+    docsWhen: "auto-enabled when `react-native-turbo-image` is a dependency",
+    rules: {
+        "require-resize": requireResize,
+        "require-cache-policy": requireCachePolicy,
+    },
+});

package/dist/react-native/rules/turbo-image/require-cache-policy.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "../../../lib/types.js";
+export declare const requireCachePolicy: Rule;

package/dist/react-native/rules/turbo-image/require-cache-policy.js

@@ -0,0 +1,21 @@
+import { attributeName, componentName, gate, problem } from "../../../lib/ast.js";
+const MESSAGE = 'Add `cachePolicy` to this TurboImage (normally `cachePolicy="dataCache"`), or it re-fetches over the network on every cold start.';
+export const requireCachePolicy = problem("Require `cachePolicy` on a TurboImage. Without one the image is re-fetched over the network on every cold start, so an already-scrolled feed costs its bandwidth again.", {
+    createOnce(context) {
+        return {
+            before() {
+                return gate(context, "TurboImage");
+            },
+            JSXOpeningElement(node) {
+                if (componentName(node.name) !== "TurboImage")
+                    return;
+                const { attributes } = node;
+                if (attributes.some(attribute => attribute.type === "JSXSpreadAttribute"))
+                    return;
+                if (attributes.some(attribute => attributeName(attribute) === "cachePolicy"))
+                    return;
+                context.report({ node: node.name, message: MESSAGE });
+            },
+        };
+    },
+});

package/dist/react-native/rules/turbo-image/require-resize.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "../../../lib/types.js";
+export declare const requireResize: Rule;

package/dist/react-native/rules/turbo-image/require-resize.js

@@ -0,0 +1,22 @@
+import { attributeName, componentName, gate, problem } from "../../../lib/ast.js";
+const MESSAGE = "Add `resize` to this TurboImage, set slightly BELOW the rendered width in points, so the native decoder downsamples before the bitmap reaches memory. Rounding down costs nothing visible; a value above the rendered width keeps the full-resolution decode (a 4000px photo in a 100pt avatar holds roughly 48MB of pixels).";
+export const requireResize = problem("Require `resize` on a TurboImage so the native decoder downsamples before the bitmap reaches memory. A full-resolution decode wastes tens of megabytes and stalls the first frame.", {
+    createOnce(context) {
+        return {
+            before() {
+                return gate(context, "TurboImage");
+            },
+            JSXOpeningElement(node) {
+                if (componentName(node.name) !== "TurboImage")
+                    return;
+                const { attributes } = node;
+                if (attributes.some(attribute => attribute.type === "JSXSpreadAttribute"))
+                    return;
+                const hasResize = attributes.some(attribute => attribute.type === "JSXAttribute" && attributeName(attribute) === "resize");
+                if (hasResize)
+                    return;
+                context.report({ node: node.name, message: MESSAGE });
+            },
+        };
+    },
+});

package/dist/react-native/rules/unistyles/animated-theme.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "../../../lib/types.js";
+export declare const animatedTheme: Rule;

package/dist/react-native/rules/unistyles/animated-theme.js

@@ -0,0 +1,37 @@
+import { calleeName, problem } from "../../../lib/ast.js";
+import { readsTheme } from "./shared.js";
+const WORKLET_HOOKS = new Set(["useAnimatedStyle", "useDerivedValue", "useAnimatedProps"]);
+const MESSAGE = "Use `useAnimatedTheme()` and read its shared value inside the Reanimated worklet so theme changes reach the UI thread.";
+export const animatedTheme = problem("A Reanimated worklet hook cannot see `useUnistyles()` theme changes on the UI thread. Read the shared value from `useAnimatedTheme()` there instead.", {
+    createOnce(context) {
+        let declaresTheme = false;
+        const candidates = [];
+        return {
+            before() {
+                declaresTheme = false;
+                candidates.length = 0;
+            },
+            VariableDeclarator(node) {
+                const { id, init } = node;
+                if (id.type === "ObjectPattern" &&
+                    calleeName(init) === "useUnistyles" &&
+                    id.properties.some(property => property.type === "Property" && property.key.type === "Identifier" && property.key.name === "theme")) {
+                    declaresTheme = true;
+                }
+            },
+            CallExpression(node) {
+                if (!WORKLET_HOOKS.has(calleeName(node)))
+                    return;
+                if (!readsTheme(node))
+                    return;
+                candidates.push(node);
+            },
+            "Program:exit"() {
+                if (!declaresTheme)
+                    return;
+                for (const node of candidates)
+                    context.report({ node, message: MESSAGE });
+            },
+        };
+    },
+});

package/dist/react-native/rules/unistyles/content-container.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "../../../lib/types.js";
+export declare const contentContainer: Rule;

package/dist/react-native/rules/unistyles/content-container.js

@@ -0,0 +1,73 @@
+import { calleeName, findInSubtree, gate, problem, subtreeHas, tagIdentifier } from "../../../lib/ast.js";
+import { isStyleSheetCreate, memberPath, propertyName, stylesObjectOf } from "./shared.js";
+const MESSAGES = {
+    contentContainerRuntime: "Wrap this component with `withUnistyles`, or pass `contentContainerStyle` a plain hook-fed style. On a raw component `contentContainerStyle` never subscribes to Unistyles updates.",
+    contentContainerTheme: "Wrap this component with `withUnistyles`, or pass `contentContainerStyle` a plain hook-fed style. On a raw component `contentContainerStyle` never subscribes to theme changes.",
+};
+export const contentContainer = problem("A raw component never subscribes its `contentContainerStyle` to theme or `rt` updates. Wrap the component with `withUnistyles` when the style depends on either.", {
+    createOnce(context) {
+        const sheetStyles = new Map();
+        const wrapped = new Set();
+        const attributes = [];
+        return {
+            before() {
+                sheetStyles.clear();
+                wrapped.clear();
+                attributes.length = 0;
+                return gate(context, "contentContainerStyle");
+            },
+            VariableDeclarator(node) {
+                const { id, init } = node;
+                if (id.type !== "Identifier")
+                    return;
+                if (calleeName(init) === "withUnistyles") {
+                    wrapped.add(id.name);
+                    return;
+                }
+                if (init?.type !== "CallExpression" || !isStyleSheetCreate(init))
+                    return;
+                const styles = stylesObjectOf(init.arguments[0]);
+                if (!styles)
+                    return;
+                const map = new Map();
+                for (const property of styles.properties) {
+                    if (property.type !== "Property")
+                        continue;
+                    map.set(propertyName(property), property.value);
+                }
+                sheetStyles.set(id.name, map);
+            },
+            JSXAttribute(node) {
+                if (node.name.type !== "JSXIdentifier" || node.name.name !== "contentContainerStyle")
+                    return;
+                attributes.push(node);
+            },
+            "Program:exit"() {
+                for (const attribute of attributes) {
+                    const reference = findInSubtree(attribute.value, current => current.type === "MemberExpression" &&
+                        current.object.type === "Identifier" &&
+                        sheetStyles.has(current.object.name));
+                    if (reference?.type !== "MemberExpression")
+                        continue;
+                    const owner = attribute.parent;
+                    if (owner.type === "JSXOpeningElement" && wrapped.has(tagIdentifier(owner.name)))
+                        continue;
+                    const { object, property } = reference;
+                    if (object.type !== "Identifier")
+                        continue;
+                    const definition = sheetStyles.get(object.name)?.get(property.type === "Identifier" ? property.name : "");
+                    if (!definition)
+                        continue;
+                    const usesRuntime = subtreeHas(definition, current => current.type === "MemberExpression" && memberPath(current).startsWith("rt."));
+                    if (usesRuntime) {
+                        context.report({ node: attribute, message: MESSAGES.contentContainerRuntime });
+                        continue;
+                    }
+                    const usesTheme = subtreeHas(definition, current => current.type === "MemberExpression" && memberPath(current).startsWith("theme."));
+                    if (usesTheme)
+                        context.report({ node: attribute, message: MESSAGES.contentContainerTheme });
+                }
+            },
+        };
+    },
+});

package/dist/react-native/rules/unistyles/in-sheet.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "../../../lib/types.js";
+export declare const inSheet: Rule;