@ansh-ui/core 0.2.0

package/dist/random--4mSc5Lp.d.cts

@@ -0,0 +1,75 @@
+/**
+ * Seeded pseudo-random number generation.
+ *
+ * Determinism is a hard requirement in Ansh, not a nicety:
+ *
+ *  - **SSR safety.** The server and the client must produce the same first frame, or React
+ *    and Vue will both scream about hydration mismatches.
+ *  - **Visual regression testing.** A screenshot diff is meaningless if the particle field
+ *    is different on every run.
+ *  - **Authoring.** A designer who likes seed `4821` can pin it and get that composition back.
+ *
+ * So no effect ever calls `Math.random()`. They all take a `seed` and derive a {@link Rng}.
+ */
+interface Rng {
+    /** Uniform in `[0, 1)`. */
+    next(): number;
+    /** Uniform in `[min, max)`. */
+    range(min: number, max: number): number;
+    /** Integer in `[min, max]`, inclusive on both ends. */
+    int(min: number, max: number): number;
+    /** `true` with probability `p`. */
+    bool(p?: number): boolean;
+    /** Uniform angle in `[0, 2π)`. */
+    angle(): number;
+    /** Approximately standard-normal, mean 0 and standard deviation 1. */
+    gaussian(): number;
+    /** A uniformly distributed point inside the unit circle. */
+    insideCircle(): {
+        x: number;
+        y: number;
+    };
+    /** Uniformly pick an element. Throws on an empty array. */
+    pick<T>(items: readonly T[]): T;
+    /** A new shuffled copy (Fisher–Yates). The input is not mutated. */
+    shuffle<T>(items: readonly T[]): T[];
+    /** A fresh independent stream, deterministically derived from this one's current state. */
+    fork(): Rng;
+}
+/**
+ * Mulberry32: 32-bit state, period 2³², passes gjrand's basic suites and is roughly as fast
+ * as `Math.random()`. Chosen over xorshift because its avalanche is better for small seeds
+ * (`seed = 1` and `seed = 2` produce visibly unrelated streams, which matters when authors
+ * type small numbers).
+ */
+declare function createRng(seed?: number | string): Rng;
+/** FNV-1a. Lets authors seed with a memorable string (`seed="hero-aurora"`). */
+declare function hashString(input: string): number;
+/**
+ * Deterministically derive a child seed from a parent seed and an index.
+ *
+ * Used so that particle *n* of an effect gets a stable stream regardless of how many
+ * particles were created before it — which keeps a field visually stable when the count
+ * changes at runtime under adaptive quality.
+ */
+declare function deriveSeed(seed: number, index: number): number;
+/**
+ * Low-discrepancy 1D sequence. Fills `[0,1)` far more evenly than uniform random, which is
+ * what you want for scattering stars or fireflies — pure random leaves visible clumps and
+ * voids that read as a mistake.
+ */
+declare function goldenRatioSequence(index: number, offset?: number): number;
+/** 2D low-discrepancy sequence (R₂ / plastic constant). The 2D analogue of the above. */
+declare function r2Sequence(index: number): {
+    x: number;
+    y: number;
+};
+/**
+ * Weighted pick. `weights` need not be normalised; non-finite or negative entries are
+ * treated as zero. Falls back to the last item if floating point leaves a remainder.
+ */
+declare function weightedPick<T>(rng: Rng, items: readonly T[], weights: readonly number[]): T;
+/** Jitter a value by ±`amount` (absolute), clamped to an optional range. */
+declare function jitter(rng: Rng, value: number, amount: number, min?: number, max?: number): number;
+
+export { type Rng as R, createRng as c, deriveSeed as d, goldenRatioSequence as g, hashString as h, jitter as j, r2Sequence as r, weightedPick as w };

package/dist/random--4mSc5Lp.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Seeded pseudo-random number generation.
+ *
+ * Determinism is a hard requirement in Ansh, not a nicety:
+ *
+ *  - **SSR safety.** The server and the client must produce the same first frame, or React
+ *    and Vue will both scream about hydration mismatches.
+ *  - **Visual regression testing.** A screenshot diff is meaningless if the particle field
+ *    is different on every run.
+ *  - **Authoring.** A designer who likes seed `4821` can pin it and get that composition back.
+ *
+ * So no effect ever calls `Math.random()`. They all take a `seed` and derive a {@link Rng}.
+ */
+interface Rng {
+    /** Uniform in `[0, 1)`. */
+    next(): number;
+    /** Uniform in `[min, max)`. */
+    range(min: number, max: number): number;
+    /** Integer in `[min, max]`, inclusive on both ends. */
+    int(min: number, max: number): number;
+    /** `true` with probability `p`. */
+    bool(p?: number): boolean;
+    /** Uniform angle in `[0, 2π)`. */
+    angle(): number;
+    /** Approximately standard-normal, mean 0 and standard deviation 1. */
+    gaussian(): number;
+    /** A uniformly distributed point inside the unit circle. */
+    insideCircle(): {
+        x: number;
+        y: number;
+    };
+    /** Uniformly pick an element. Throws on an empty array. */
+    pick<T>(items: readonly T[]): T;
+    /** A new shuffled copy (Fisher–Yates). The input is not mutated. */
+    shuffle<T>(items: readonly T[]): T[];
+    /** A fresh independent stream, deterministically derived from this one's current state. */
+    fork(): Rng;
+}
+/**
+ * Mulberry32: 32-bit state, period 2³², passes gjrand's basic suites and is roughly as fast
+ * as `Math.random()`. Chosen over xorshift because its avalanche is better for small seeds
+ * (`seed = 1` and `seed = 2` produce visibly unrelated streams, which matters when authors
+ * type small numbers).
+ */
+declare function createRng(seed?: number | string): Rng;
+/** FNV-1a. Lets authors seed with a memorable string (`seed="hero-aurora"`). */
+declare function hashString(input: string): number;
+/**
+ * Deterministically derive a child seed from a parent seed and an index.
+ *
+ * Used so that particle *n* of an effect gets a stable stream regardless of how many
+ * particles were created before it — which keeps a field visually stable when the count
+ * changes at runtime under adaptive quality.
+ */
+declare function deriveSeed(seed: number, index: number): number;
+/**
+ * Low-discrepancy 1D sequence. Fills `[0,1)` far more evenly than uniform random, which is
+ * what you want for scattering stars or fireflies — pure random leaves visible clumps and
+ * voids that read as a mistake.
+ */
+declare function goldenRatioSequence(index: number, offset?: number): number;
+/** 2D low-discrepancy sequence (R₂ / plastic constant). The 2D analogue of the above. */
+declare function r2Sequence(index: number): {
+    x: number;
+    y: number;
+};
+/**
+ * Weighted pick. `weights` need not be normalised; non-finite or negative entries are
+ * treated as zero. Falls back to the last item if floating point leaves a remainder.
+ */
+declare function weightedPick<T>(rng: Rng, items: readonly T[], weights: readonly number[]): T;
+/** Jitter a value by ±`amount` (absolute), clamped to an optional range. */
+declare function jitter(rng: Rng, value: number, amount: number, min?: number, max?: number): number;
+
+export { type Rng as R, createRng as c, deriveSeed as d, goldenRatioSequence as g, hashString as h, jitter as j, r2Sequence as r, weightedPick as w };

package/dist/reduced-motion-D0LUgZle.d.cts

@@ -0,0 +1,120 @@
+/**
+ * Everything a frame callback receives.
+ *
+ * Passed as a single frozen-by-convention object rather than positional arguments so that new
+ * fields can be added without breaking every subscriber in the ecosystem.
+ */
+interface FrameState {
+    /** Scaled seconds since the ticker started, excluding paused time. */
+    time: number;
+    /** Scaled, clamped seconds since the previous frame. Use this for all motion. */
+    delta: number;
+    /** Unscaled, unclamped seconds since the previous frame. For profiling only. */
+    rawDelta: number;
+    /** Monotonically increasing frame index. */
+    frame: number;
+    /** Smoothed frames per second. */
+    fps: number;
+    /**
+     * Adaptive quality in `[0, 1]`. Multiply expensive work by this — particle counts, render
+     * resolution, octave counts — so the effect degrades gracefully instead of dropping frames.
+     */
+    quality: number;
+    /** Raw `performance.now()` timestamp for this frame. */
+    timestamp: number;
+}
+/**
+ * Scheduling phases, executed in this order every frame.
+ *
+ * The separation exists to make layout thrashing structurally impossible. If one component
+ * reads `getBoundingClientRect()` while another has already written a style, the browser must
+ * synchronously recompute layout — and with N components interleaving, that happens N times
+ * per frame. By collecting all reads before any write, it happens at most once.
+ *
+ * - `read`    — measure the DOM. Never mutate here.
+ * - `compute` — pure calculation: physics, interpolation, layout maths. Touch no DOM.
+ * - `write`   — mutate styles, draw to canvas. Never measure here.
+ * - `post`    — bookkeeping after the visual work: analytics, `onComplete` callbacks.
+ */
+type FramePhase = 'read' | 'compute' | 'write' | 'post';
+declare const FRAME_PHASES: readonly FramePhase[];
+type FrameCallback = (state: FrameState) => void;
+interface SubscribeOptions {
+    /** Which phase to run in. Default `'write'` — the common case for drawing effects. */
+    phase?: FramePhase;
+    /**
+     * Ordering within the phase. Lower runs first. Default `0`.
+     *
+     * Use this for genuine dependencies (a parallax container must position before its children
+     * measure), not as a general-purpose knob — over-ordered systems are hard to reason about.
+     */
+    priority?: number;
+    /** Label used in error messages and the dev inspector. */
+    name?: string;
+}
+/** Returned by `ticker.add()`. Idempotent — calling it twice is safe. */
+type Unsubscribe = () => void;
+
+/**
+ * Reduced-motion support.
+ *
+ * `prefers-reduced-motion` is not a niche preference. It is set by users with vestibular
+ * disorders, for whom large-scale parallax and continuous background motion cause genuine
+ * physical nausea. Honouring it is not a nice-to-have, and it must not be each component's
+ * job to remember — so the kernel owns it and every effect declares a strategy.
+ *
+ * The strategies exist because "disable all animation" is the wrong answer for most effects.
+ * A gradient that slowly shifts hue is not what makes people ill; a full-viewport parallax
+ * scroll is. So each effect states what it should do, and authors can override per instance.
+ */
+/**
+ * How an effect should behave when the user prefers reduced motion.
+ *
+ * - `static`  — render one frame and stop. The design still reads correctly, nothing moves.
+ *               The right default for backgrounds.
+ * - `slow`    — keep animating at a fraction of the speed. Suitable for gentle, small-amplitude
+ *               motion where stillness would lose meaning (a loading indicator).
+ * - `pause`   — don't render at all. For effects whose whole purpose is movement.
+ * - `none`    — ignore the preference. Only correct for motion that conveys required
+ *               information, e.g. a progress indicator with no other affordance.
+ */
+type ReducedMotionStrategy = 'static' | 'slow' | 'pause' | 'none';
+/** Application-level override, usually surfaced through a `<MotionConfig>` provider. */
+type ReducedMotionMode = 'auto' | 'always' | 'never';
+/**
+ * Does the user want reduced motion?
+ *
+ * Returns `false` during SSR. That is the correct default: rendering the static fallback on the
+ * server and the animated version on the client would be a hydration mismatch, whereas
+ * rendering the animated markup and then immediately stopping it on the client is seamless.
+ */
+declare function prefersReducedMotion(): boolean;
+/**
+ * Override the system preference application-wide.
+ *
+ * `'always'` is genuinely useful in production (an in-app "reduce motion" setting), and
+ * essential in tests and screenshot harnesses where you need the static frame deterministically.
+ */
+declare function setReducedMotionMode(mode: ReducedMotionMode): void;
+declare function getReducedMotionMode(): ReducedMotionMode;
+/** Subscribe to preference changes. Fires immediately with the current value. */
+declare function onReducedMotionChange(listener: (reduced: boolean) => void): Unsubscribe;
+interface MotionResolution {
+    /** Should the effect run its frame loop at all? */
+    animate: boolean;
+    /** Should it render a single frame before stopping? */
+    renderOnce: boolean;
+    /** Multiplier to apply to the effect's speed. */
+    timeScale: number;
+}
+/**
+ * Turn a strategy plus the current preference into concrete instructions.
+ *
+ * Centralising this means every effect behaves consistently, and that adding a new strategy
+ * later is a change in one file rather than eighty.
+ */
+declare function resolveMotion(strategy?: ReducedMotionStrategy, slowFactor?: number): MotionResolution;
+/** Reset module state. Test-only. */
+declare function resetReducedMotion(): void;
+
+export { type FrameCallback as F, type MotionResolution as M, type ReducedMotionStrategy as R, type SubscribeOptions as S, type Unsubscribe as U, type FrameState as a, type FramePhase as b, FRAME_PHASES as c, type ReducedMotionMode as d, resolveMotion as e, getReducedMotionMode as g, onReducedMotionChange as o, prefersReducedMotion as p, resetReducedMotion as r, setReducedMotionMode as s };

package/dist/reduced-motion-D0LUgZle.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Everything a frame callback receives.
+ *
+ * Passed as a single frozen-by-convention object rather than positional arguments so that new
+ * fields can be added without breaking every subscriber in the ecosystem.
+ */
+interface FrameState {
+    /** Scaled seconds since the ticker started, excluding paused time. */
+    time: number;
+    /** Scaled, clamped seconds since the previous frame. Use this for all motion. */
+    delta: number;
+    /** Unscaled, unclamped seconds since the previous frame. For profiling only. */
+    rawDelta: number;
+    /** Monotonically increasing frame index. */
+    frame: number;
+    /** Smoothed frames per second. */
+    fps: number;
+    /**
+     * Adaptive quality in `[0, 1]`. Multiply expensive work by this — particle counts, render
+     * resolution, octave counts — so the effect degrades gracefully instead of dropping frames.
+     */
+    quality: number;
+    /** Raw `performance.now()` timestamp for this frame. */
+    timestamp: number;
+}
+/**
+ * Scheduling phases, executed in this order every frame.
+ *
+ * The separation exists to make layout thrashing structurally impossible. If one component
+ * reads `getBoundingClientRect()` while another has already written a style, the browser must
+ * synchronously recompute layout — and with N components interleaving, that happens N times
+ * per frame. By collecting all reads before any write, it happens at most once.
+ *
+ * - `read`    — measure the DOM. Never mutate here.
+ * - `compute` — pure calculation: physics, interpolation, layout maths. Touch no DOM.
+ * - `write`   — mutate styles, draw to canvas. Never measure here.
+ * - `post`    — bookkeeping after the visual work: analytics, `onComplete` callbacks.
+ */
+type FramePhase = 'read' | 'compute' | 'write' | 'post';
+declare const FRAME_PHASES: readonly FramePhase[];
+type FrameCallback = (state: FrameState) => void;
+interface SubscribeOptions {
+    /** Which phase to run in. Default `'write'` — the common case for drawing effects. */
+    phase?: FramePhase;
+    /**
+     * Ordering within the phase. Lower runs first. Default `0`.
+     *
+     * Use this for genuine dependencies (a parallax container must position before its children
+     * measure), not as a general-purpose knob — over-ordered systems are hard to reason about.
+     */
+    priority?: number;
+    /** Label used in error messages and the dev inspector. */
+    name?: string;
+}
+/** Returned by `ticker.add()`. Idempotent — calling it twice is safe. */
+type Unsubscribe = () => void;
+
+/**
+ * Reduced-motion support.
+ *
+ * `prefers-reduced-motion` is not a niche preference. It is set by users with vestibular
+ * disorders, for whom large-scale parallax and continuous background motion cause genuine
+ * physical nausea. Honouring it is not a nice-to-have, and it must not be each component's
+ * job to remember — so the kernel owns it and every effect declares a strategy.
+ *
+ * The strategies exist because "disable all animation" is the wrong answer for most effects.
+ * A gradient that slowly shifts hue is not what makes people ill; a full-viewport parallax
+ * scroll is. So each effect states what it should do, and authors can override per instance.
+ */
+/**
+ * How an effect should behave when the user prefers reduced motion.
+ *
+ * - `static`  — render one frame and stop. The design still reads correctly, nothing moves.
+ *               The right default for backgrounds.
+ * - `slow`    — keep animating at a fraction of the speed. Suitable for gentle, small-amplitude
+ *               motion where stillness would lose meaning (a loading indicator).
+ * - `pause`   — don't render at all. For effects whose whole purpose is movement.
+ * - `none`    — ignore the preference. Only correct for motion that conveys required
+ *               information, e.g. a progress indicator with no other affordance.
+ */
+type ReducedMotionStrategy = 'static' | 'slow' | 'pause' | 'none';
+/** Application-level override, usually surfaced through a `<MotionConfig>` provider. */
+type ReducedMotionMode = 'auto' | 'always' | 'never';
+/**
+ * Does the user want reduced motion?
+ *
+ * Returns `false` during SSR. That is the correct default: rendering the static fallback on the
+ * server and the animated version on the client would be a hydration mismatch, whereas
+ * rendering the animated markup and then immediately stopping it on the client is seamless.
+ */
+declare function prefersReducedMotion(): boolean;
+/**
+ * Override the system preference application-wide.
+ *
+ * `'always'` is genuinely useful in production (an in-app "reduce motion" setting), and
+ * essential in tests and screenshot harnesses where you need the static frame deterministically.
+ */
+declare function setReducedMotionMode(mode: ReducedMotionMode): void;
+declare function getReducedMotionMode(): ReducedMotionMode;
+/** Subscribe to preference changes. Fires immediately with the current value. */
+declare function onReducedMotionChange(listener: (reduced: boolean) => void): Unsubscribe;
+interface MotionResolution {
+    /** Should the effect run its frame loop at all? */
+    animate: boolean;
+    /** Should it render a single frame before stopping? */
+    renderOnce: boolean;
+    /** Multiplier to apply to the effect's speed. */
+    timeScale: number;
+}
+/**
+ * Turn a strategy plus the current preference into concrete instructions.
+ *
+ * Centralising this means every effect behaves consistently, and that adding a new strategy
+ * later is a change in one file rather than eighty.
+ */
+declare function resolveMotion(strategy?: ReducedMotionStrategy, slowFactor?: number): MotionResolution;
+/** Reset module state. Test-only. */
+declare function resetReducedMotion(): void;
+
+export { type FrameCallback as F, type MotionResolution as M, type ReducedMotionStrategy as R, type SubscribeOptions as S, type Unsubscribe as U, type FrameState as a, type FramePhase as b, FRAME_PHASES as c, type ReducedMotionMode as d, resolveMotion as e, getReducedMotionMode as g, onReducedMotionChange as o, prefersReducedMotion as p, resetReducedMotion as r, setReducedMotionMode as s };

package/dist/types-B1FLLf3-.d.cts

@@ -0,0 +1,21 @@
+/**
+ * An easing function maps normalised progress to eased progress.
+ *
+ * Input is always in `[0, 1]`. Output is usually in `[0, 1]` but may overshoot — `back` and
+ * `elastic` curves deliberately exceed the range, which is what gives them their character.
+ * Implementations must be pure and must return exactly `0` at `t = 0` and `1` at `t = 1`.
+ */
+type EasingFn = (t: number) => number;
+/** Names of every easing shipped in the built-in library. */
+type EasingName = 'linear' | 'easeInSine' | 'easeOutSine' | 'easeInOutSine' | 'easeInQuad' | 'easeOutQuad' | 'easeInOutQuad' | 'easeInCubic' | 'easeOutCubic' | 'easeInOutCubic' | 'easeInQuart' | 'easeOutQuart' | 'easeInOutQuart' | 'easeInQuint' | 'easeOutQuint' | 'easeInOutQuint' | 'easeInExpo' | 'easeOutExpo' | 'easeInOutExpo' | 'easeInCirc' | 'easeOutCirc' | 'easeInOutCirc' | 'easeInBack' | 'easeOutBack' | 'easeInOutBack' | 'easeInElastic' | 'easeOutElastic' | 'easeInOutElastic' | 'easeInBounce' | 'easeOutBounce' | 'easeInOutBounce' | 'smoothstep' | 'smootherstep' | 'anticipate';
+/**
+ * Anywhere Ansh accepts an easing you may pass:
+ *
+ * - a built-in name — `'easeOutCubic'`
+ * - a name registered via `registerEasing()` — `'myBrandCurve'`
+ * - a raw function — `(t) => t * t`
+ * - CSS-style bézier coordinates — `[0.22, 1, 0.36, 1]`
+ */
+type EasingInput = EasingName | (string & {}) | EasingFn | readonly [number, number, number, number];
+
+export type { EasingInput as E, EasingFn as a, EasingName as b };

package/dist/types-B1FLLf3-.d.ts

@@ -0,0 +1,21 @@
+/**
+ * An easing function maps normalised progress to eased progress.
+ *
+ * Input is always in `[0, 1]`. Output is usually in `[0, 1]` but may overshoot — `back` and
+ * `elastic` curves deliberately exceed the range, which is what gives them their character.
+ * Implementations must be pure and must return exactly `0` at `t = 0` and `1` at `t = 1`.
+ */
+type EasingFn = (t: number) => number;
+/** Names of every easing shipped in the built-in library. */
+type EasingName = 'linear' | 'easeInSine' | 'easeOutSine' | 'easeInOutSine' | 'easeInQuad' | 'easeOutQuad' | 'easeInOutQuad' | 'easeInCubic' | 'easeOutCubic' | 'easeInOutCubic' | 'easeInQuart' | 'easeOutQuart' | 'easeInOutQuart' | 'easeInQuint' | 'easeOutQuint' | 'easeInOutQuint' | 'easeInExpo' | 'easeOutExpo' | 'easeInOutExpo' | 'easeInCirc' | 'easeOutCirc' | 'easeInOutCirc' | 'easeInBack' | 'easeOutBack' | 'easeInOutBack' | 'easeInElastic' | 'easeOutElastic' | 'easeInOutElastic' | 'easeInBounce' | 'easeOutBounce' | 'easeInOutBounce' | 'smoothstep' | 'smootherstep' | 'anticipate';
+/**
+ * Anywhere Ansh accepts an easing you may pass:
+ *
+ * - a built-in name — `'easeOutCubic'`
+ * - a name registered via `registerEasing()` — `'myBrandCurve'`
+ * - a raw function — `(t) => t * t`
+ * - CSS-style bézier coordinates — `[0.22, 1, 0.36, 1]`
+ */
+type EasingInput = EasingName | (string & {}) | EasingFn | readonly [number, number, number, number];
+
+export type { EasingInput as E, EasingFn as a, EasingName as b };

package/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "@ansh-ui/core",
+  "version": "0.2.0",
+  "description": "The Ansh animation engine — a zero-dependency, framework-agnostic kernel for high-performance motion.",
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": false,
+  "keywords": [
+    "animation",
+    "motion",
+    "spring",
+    "easing",
+    "noise",
+    "simplex",
+    "oklch",
+    "canvas",
+    "particles",
+    "timeline"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jithin003/ui-library.git",
+    "directory": "packages/core"
+  },
+  "homepage": "https://github.com/jithin003/ui-library",
+  "files": [
+    "dist"
+  ],
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./math": {
+      "types": "./dist/math.d.ts",
+      "import": "./dist/math.js",
+      "require": "./dist/math.cjs"
+    },
+    "./easing": {
+      "types": "./dist/easing.d.ts",
+      "import": "./dist/easing.js",
+      "require": "./dist/easing.cjs"
+    },
+    "./color": {
+      "types": "./dist/color.d.ts",
+      "import": "./dist/color.js",
+      "require": "./dist/color.cjs"
+    },
+    "./noise": {
+      "types": "./dist/noise.d.ts",
+      "import": "./dist/noise.js",
+      "require": "./dist/noise.cjs"
+    },
+    "./effects": {
+      "types": "./dist/effects.d.ts",
+      "import": "./dist/effects.js",
+      "require": "./dist/effects.cjs"
+    },
+    "./behaviours": {
+      "types": "./dist/behaviours.d.ts",
+      "import": "./dist/behaviours.js",
+      "require": "./dist/behaviours.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  }
+}