@glint/ember-tsc 1.5.0 → 1.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glint/ember-tsc",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "repository": "typed-ember/glint",
   "description": "A CLI for performing typechecking on Glimmer templates",
   "license": "MIT",
@@ -24,9 +24,12 @@
     "./types": "./types/-private/dsl/integration-declarations.d.ts",
     "./-private/dsl/globals": "./types/-private/dsl/globals.d.ts",
     "./-private/intrinsics/action": "./types/-private/intrinsics/action.d.ts",
+    "./-private/intrinsics/array-hash": "./types/-private/intrinsics/array-hash.d.ts",
+    "./-private/intrinsics/comparison": "./types/-private/intrinsics/comparison.d.ts",
     "./-private/intrinsics/concat": "./types/-private/intrinsics/concat.d.ts",
     "./-private/intrinsics/each": "./types/-private/intrinsics/each.d.ts",
     "./-private/intrinsics/each-in": "./types/-private/intrinsics/each-in.d.ts",
+    "./-private/intrinsics/element": "./types/-private/intrinsics/element.d.ts",
     "./-private/intrinsics/fn": "./types/-private/intrinsics/fn.d.ts",
     "./-private/intrinsics/get": "./types/-private/intrinsics/get.d.ts",
     "./-private/intrinsics/log": "./types/-private/intrinsics/log.d.ts",
@@ -34,6 +37,8 @@
     "./-private/intrinsics/mut": "./types/-private/intrinsics/mut.d.ts",
     "./-private/intrinsics/on": "./types/-private/intrinsics/on.d.ts",
     "./-private/intrinsics/outlet": "./types/-private/intrinsics/outlet.d.ts",
+    "./-private/intrinsics/truth-convert": "./types/-private/intrinsics/truth-convert.d.ts",
+    "./-private/intrinsics/truth-helpers": "./types/-private/intrinsics/truth-helpers.d.ts",
     "./-private/intrinsics/unbound": "./types/-private/intrinsics/unbound.d.ts",
     "./-private/intrinsics/unique-id": "./types/-private/intrinsics/unique-id.d.ts",
     "./*": {
@@ -53,8 +58,14 @@
     "glint-language-server": "bin/glint-language-server.js"
   },
   "peerDependencies": {
+    "ember-source": ">=7.1.0",
     "typescript": ">=5.6.0"
   },
+  "peerDependenciesMeta": {
+    "ember-source": {
+      "optional": true
+    }
+  },
   "dependencies": {
     "@glimmer/syntax": "^0.95.0",
     "@volar/kit": "~2.4.28",
@@ -86,8 +97,8 @@
     "execa": "^4.0.1",
     "strip-ansi": "^6.0.0",
     "typescript": "^5.9.3",
-    "@glint/type-test": "2.0.1",
-    "glint-monorepo-test-utils": "0.0.0"
+    "glint-monorepo-test-utils": "0.0.0",
+    "@glint/type-test": "2.0.1"
   },
   "publishConfig": {
     "access": "public"

package/src/environment-ember-template-imports/-private/environment/index.ts

@@ -16,6 +16,52 @@ export default function emberTemplateImportsEnvironment(
     ? options['additionalGlobals']
     : [];
 
+  const globalsForEmber = [
+    'action',
+    'component',
+    'debugger',
+    'each',
+    'each-in',
+    'has-block',
+    'has-block-params',
+    'helper',
+    'if',
+    'in-element',
+    'let',
+    'log',
+    'modifier',
+    'mount',
+    'mut',
+    'outlet',
+    'unbound',
+    'unless',
+    'with',
+    'yield',
+  ];
+
+  /*
+    Ember 7.1+ built-in keywords (RFCs 389, 470, 560, 561, 562, 997, 998, 999,
+    1000). Their template-side signatures live in `KeywordsForEmber71` in
+    `types/-private/dsl/globals.d.ts` and are gated on `ember-source >= 7.1.0`
+    via the `HasEmber71BuiltIns` probe.
+  */
+  const globalsForEmber71 = [
+    'and',
+    'array',
+    'element',
+    'eq',
+    'fn',
+    'gt',
+    'gte',
+    'hash',
+    'lt',
+    'lte',
+    'neq',
+    'not',
+    'on',
+    'or',
+  ];
+
   return {
     tags: {
       '@glint/ember-tsc/environment-ember-template-imports/-private/tag': {
@@ -41,26 +87,8 @@ export default function emberTemplateImportsEnvironment(
             },
           },
           globals: [
-            'action',
-            'component',
-            'debugger',
-            'each',
-            'each-in',
-            'has-block',
-            'has-block-params',
-            'helper',
-            'if',
-            'in-element',
-            'let',
-            'log',
-            'modifier',
-            'mount',
-            'mut',
-            'outlet',
-            'unbound',
-            'unless',
-            'with',
-            'yield',
+            ...globalsForEmber,
+            ...globalsForEmber71,
             ...Object.keys(additionalGlobalSpecialForms),
             ...additionalGlobals,
           ],

package/types/-private/dsl/globals.d.ts

@@ -3,19 +3,59 @@ import Globals from '../../globals';
 import * as VM from '@glint/template/-private/keywords';
 
 import { ActionKeyword } from '../intrinsics/action';
+import { ArrayHelper, HashHelper } from '../intrinsics/array-hash';
+import {
+  EqHelper,
+  GtHelper,
+  GteHelper,
+  LtHelper,
+  LteHelper,
+  NeqHelper,
+} from '../intrinsics/comparison';
 import { EachKeyword } from '../intrinsics/each';
 import { EachInKeyword } from '../intrinsics/each-in';
+import { ElementHelper } from '../intrinsics/element';
+import { FnHelper } from '../intrinsics/fn';
 import { LogHelper } from '../intrinsics/log';
 import { MountKeyword } from '../intrinsics/mount';
 import { MutKeyword } from '../intrinsics/mut';
+import { OnModifier } from '../intrinsics/on';
 import { OutletKeyword } from '../intrinsics/outlet';
+import { AndHelper, NotHelper, OrHelper } from '../intrinsics/truth-helpers';
 import { UnboundKeyword } from '../intrinsics/unbound';
 import { UniqueIdHelper } from '../intrinsics/unique-id';
 
+// ---- ember-source 7.1 detection -------------------------------------------
+//
+// The keywords introduced by RFCs 562, 470, 997, 998, 999, 1000, 560, 561 and
+// 389 are only available at runtime when consumers are on ember-source >= 7.1.
+// We probe for the `eq` value re-export added by RFC 561 to decide whether to
+// expose the new keyword types. On older versions the probe collapses to the
+// empty type, so referencing e.g. `{{eq}}` falls back to whatever the user
+// has imported (or surfaces as an "unknown identifier" diagnostic), keeping
+// behaviour identical to today.
+//
+// We probe a value export (`eq`) rather than the matching `EqHelper`
+// interface because `typeof import(...)` only surfaces the module's value
+// exports; type-only exports never appear as keys, so an interface probe
+// would always collapse to `false`.
+//
+// `@ember/helper` is an optional peer dependency at the type level: the
+// `@ts-ignore` ensures Glint still type-checks in environments that haven't
+// installed it.
+//
+// @ts-ignore — `@ember/helper` is an optional peer dependency
+type EmberHelperExports = typeof import('@ember/helper');
+
+type HasEmber71BuiltIns = [EmberHelperExports] extends [{ eq: unknown }] ? true : false;
+
+/** Resolves to `T` only when ember-source >= 7.1 ships the new keyword set. */
+type Ember71Only<T> = HasEmber71BuiltIns extends true ? T : never;
+
 // The keyword vs global breakdown here is loosely matched with
 // the listing in http://emberjs.github.io/rfcs/0496-handlebars-strict-mode.html
 
-interface Keywords {
+interface KeywordsForEmber {
   /**
     The {{action}} helper provides a way to pass triggers for behavior (usually just a function)
     between components, and into components from controllers.
@@ -201,4 +241,279 @@ interface Keywords {
   yield: void;
 }
 
+/**
+ * Built-in template keywords introduced by ember-source 7.1
+ * (RFCs 389, 470, 560, 561, 562, 997, 998, 999, 1000). Each entry is gated by
+ * `Ember71Only<T>` so the keyword resolves to `never` (and is therefore
+ * effectively absent) when the consumer is on ember-source < 7.1. See the
+ * `HasEmber71BuiltIns` probe at the top of this file.
+ */
+interface KeywordsForEmber71 {
+  /**
+   * The `{{and}}` helper evaluates arguments left to right, returning the first
+   * falsy value (using Handlebars truthiness) or the right-most value if all
+   * are truthy. Requires at least two arguments.
+   *
+   * ```gjs
+   * <template>
+   *   {{if (and @isAdmin @isLoggedIn) "Welcome, admin!" "Access denied"}}
+   * </template>
+   * ```
+   *
+   * In strict-mode (`.gjs`/`.gts`) templates, `and` is available as a keyword
+   * and does not need to be imported from `@ember/helper`.
+   *
+   * @see https://api.emberjs.com/ember/release/functions/@ember%2Fhelper/and
+   */
+  and: Ember71Only<AndHelper>;
+
+  /**
+   * Using the `{{array}}` helper, you can pass arrays directly from the
+   * template as an argument to your components.
+   *
+   * ```gjs
+   * <template>
+   *   <ul>
+   *     {{#each (array "Tom Dale" "Yehuda Katz" @anotherPerson) as |person|}}
+   *       <li>{{person}}</li>
+   *     {{/each}}
+   *   </ul>
+   * </template>
+   * ```
+   *
+   * In strict-mode (`.gjs`/`.gts`) templates, `array` is available as a
+   * keyword and does not need to be imported from `@ember/helper`.
+   *
+   * @see https://api.emberjs.com/ember/release/functions/@ember%2Fhelper/array
+   */
+  array: Ember71Only<ArrayHelper>;
+
+  /**
+   * The `{{element}}` helper lets you dynamically set the tag name of an
+   * element.
+   *
+   * ```gjs
+   * <template>
+   *   {{#let (element @tagName) as |Tag|}}
+   *     <Tag class="my-element">Hello</Tag>
+   *   {{/let}}
+   * </template>
+   * ```
+   *
+   * When `@tagName` is `"h1"`, this renders `<h1 class="my-element">Hello</h1>`.
+   * When `@tagName` is an empty string, the block content is rendered without
+   * a wrapping element. When `@tagName` is `null` or `undefined`, nothing is
+   * rendered.
+   *
+   * In strict-mode (`.gjs`/`.gts`) templates, `element` is available as a
+   * keyword and does not need to be imported from `@ember/helper`.
+   *
+   * @see https://api.emberjs.com/ember/release/functions/@ember%2Fhelper/element
+   */
+  element: Ember71Only<ElementHelper>;
+
+  /**
+   * The `{{eq}}` helper returns `true` if its two arguments are strictly equal
+   * (`===`). Takes exactly two arguments.
+   *
+   * ```gjs
+   * <template>
+   *   {{if (eq @status "active") "Active" "Inactive"}}
+   * </template>
+   * ```
+   *
+   * In strict-mode (`.gjs`/`.gts`) templates, `eq` is available as a keyword
+   * and does not need to be imported from `@ember/helper`.
+   *
+   * @see https://api.emberjs.com/ember/release/functions/@ember%2Fhelper/eq
+   */
+  eq: Ember71Only<EqHelper>;
+
+  /**
+   * `{{fn}}` is a helper that receives a function and some arguments, and
+   * returns a new function that combines them. This allows you to pass
+   * parameters along to functions in your templates:
+   *
+   * ```gjs
+   * function showAlert(message) {
+   *   alert(`The message is: '${message}'`);
+   * }
+   *
+   * <template>
+   *   <button type="button" {{on "click" (fn showAlert "Hello!")}}>
+   *     Click me!
+   *   </button>
+   * </template>
+   * ```
+   *
+   * In strict-mode (`.gjs`/`.gts`) templates, `fn` is available as a keyword
+   * and does not need to be imported from `@ember/helper`.
+   *
+   * @see https://api.emberjs.com/ember/release/functions/@ember%2Fhelper/fn
+   */
+  fn: Ember71Only<FnHelper>;
+
+  /**
+   * The `{{gt}}` helper returns `true` if the first argument is greater than
+   * the second argument.
+   *
+   * ```gjs
+   * <template>
+   *   {{if (gt @score 100) "High score!" "Keep trying"}}
+   * </template>
+   * ```
+   *
+   * In strict-mode (`.gjs`/`.gts`) templates, `gt` is available as a keyword
+   * and does not need to be imported from `@ember/helper`.
+   *
+   * @see https://api.emberjs.com/ember/release/functions/@ember%2Fhelper/gt
+   */
+  gt: Ember71Only<GtHelper>;
+
+  /**
+   * The `{{gte}}` helper returns `true` if the first argument is greater than
+   * or equal to the second argument.
+   *
+   * ```gjs
+   * <template>
+   *   {{if (gte @age 18) "Adult" "Minor"}}
+   * </template>
+   * ```
+   *
+   * In strict-mode (`.gjs`/`.gts`) templates, `gte` is available as a keyword
+   * and does not need to be imported from `@ember/helper`.
+   *
+   * @see https://api.emberjs.com/ember/release/functions/@ember%2Fhelper/gte
+   */
+  gte: Ember71Only<GteHelper>;
+
+  /**
+   * Using the `{{hash}}` helper, you can pass objects directly from the
+   * template as an argument to your components.
+   *
+   * ```gjs
+   * <template>
+   *   {{#each-in (hash givenName="Jen" familyName="Weber") as |key value|}}
+   *     <p>{{key}}: {{value}}</p>
+   *   {{/each-in}}
+   * </template>
+   * ```
+   *
+   * In strict-mode (`.gjs`/`.gts`) templates, `hash` is available as a
+   * keyword and does not need to be imported from `@ember/helper`.
+   *
+   * @see https://api.emberjs.com/ember/release/functions/@ember%2Fhelper/hash
+   */
+  hash: Ember71Only<HashHelper>;
+
+  /**
+   * The `{{lt}}` helper returns `true` if the first argument is less than the
+   * second argument.
+   *
+   * ```gjs
+   * <template>
+   *   {{if (lt @temperature 0) "Freezing" "Above zero"}}
+   * </template>
+   * ```
+   *
+   * In strict-mode (`.gjs`/`.gts`) templates, `lt` is available as a keyword
+   * and does not need to be imported from `@ember/helper`.
+   *
+   * @see https://api.emberjs.com/ember/release/functions/@ember%2Fhelper/lt
+   */
+  lt: Ember71Only<LtHelper>;
+
+  /**
+   * The `{{lte}}` helper returns `true` if the first argument is less than or
+   * equal to the second argument.
+   *
+   * ```gjs
+   * <template>
+   *   {{if (lte @count 0) "Empty" "Has items"}}
+   * </template>
+   * ```
+   *
+   * In strict-mode (`.gjs`/`.gts`) templates, `lte` is available as a keyword
+   * and does not need to be imported from `@ember/helper`.
+   *
+   * @see https://api.emberjs.com/ember/release/functions/@ember%2Fhelper/lte
+   */
+  lte: Ember71Only<LteHelper>;
+
+  /**
+   * The `{{neq}}` helper returns `true` if its two arguments are strictly not
+   * equal (`!==`). Takes exactly two arguments.
+   *
+   * ```gjs
+   * <template>
+   *   {{if (neq @status "active") "Not active" "Active"}}
+   * </template>
+   * ```
+   *
+   * In strict-mode (`.gjs`/`.gts`) templates, `neq` is available as a keyword
+   * and does not need to be imported from `@ember/helper`.
+   *
+   * @see https://api.emberjs.com/ember/release/functions/@ember%2Fhelper/neq
+   */
+  neq: Ember71Only<NeqHelper>;
+
+  /**
+   * The `{{not}}` helper returns the logical negation of its argument using
+   * Handlebars truthiness. Takes exactly one argument.
+   *
+   * ```gjs
+   * <template>
+   *   {{if (not @isDisabled) "Enabled" "Disabled"}}
+   * </template>
+   * ```
+   *
+   * In strict-mode (`.gjs`/`.gts`) templates, `not` is available as a keyword
+   * and does not need to be imported from `@ember/helper`.
+   *
+   * @see https://api.emberjs.com/ember/release/functions/@ember%2Fhelper/not
+   */
+  not: Ember71Only<NotHelper>;
+
+  /**
+   * The `{{on}}` element modifier attaches an event listener to an element.
+   *
+   * ```gjs
+   * <template>
+   *   <button type="button" {{on "click" this.handleClick}}>
+   *     Click me!
+   *   </button>
+   * </template>
+   * ```
+   *
+   * It accepts the same options as `addEventListener` via named arguments
+   * (`capture`, `once`, `passive`).
+   *
+   * In strict-mode (`.gjs`/`.gts`) templates, `on` is available as a keyword
+   * and does not need to be imported from `@ember/modifier`.
+   *
+   * @see https://api.emberjs.com/ember/release/functions/@ember%2Fmodifier/on
+   */
+  on: Ember71Only<OnModifier>;
+
+  /**
+   * The `{{or}}` helper evaluates arguments left to right, returning the first
+   * truthy value (using Handlebars truthiness) or the right-most value if all
+   * are falsy. Requires at least two arguments.
+   *
+   * ```gjs
+   * <template>
+   *   {{if (or @hasAccess @isAdmin) "Welcome!" "No access"}}
+   * </template>
+   * ```
+   *
+   * In strict-mode (`.gjs`/`.gts`) templates, `or` is available as a keyword
+   * and does not need to be imported from `@ember/helper`.
+   *
+   * @see https://api.emberjs.com/ember/release/functions/@ember%2Fhelper/or
+   */
+  or: Ember71Only<OrHelper>;
+}
+
+interface Keywords extends KeywordsForEmber, KeywordsForEmber71 {}
+
 export const Globals: Keywords & Globals;

package/types/-private/intrinsics/array-hash.d.ts

@@ -0,0 +1,17 @@
+import { DirectInvokable } from '@glint/template/-private/integration';
+
+/**
+ * `(array a b ...)` — packs the positional arguments into a typed tuple.
+ * Built-in keyword in ember-source >= 7.1 (RFC 1000).
+ */
+export type ArrayHelper = DirectInvokable<{
+  <T extends unknown[]>(...args: T): T;
+}>;
+
+/**
+ * `(hash key=value ...)` — packs the named arguments into a typed object.
+ * Built-in keyword in ember-source >= 7.1 (RFC 999).
+ */
+export type HashHelper = DirectInvokable<{
+  <T extends Record<string, unknown>>(args: T): T;
+}>;

package/types/-private/intrinsics/comparison.d.ts

@@ -0,0 +1,36 @@
+import { DirectInvokable } from '@glint/template/-private/integration';
+
+/**
+ * `(eq a b)` — strict equality of two values. Built-in keyword in
+ * ember-source >= 7.1 (RFC 561). The result is narrowed when both sides are
+ * literal types so templates such as `{{#if (eq this.kind "primary")}}` get
+ * accurate type information.
+ */
+export type EqHelper = DirectInvokable<{
+  <A, B>(a: A, b: B): [A] extends [B] ? ([B] extends [A] ? true : boolean) : boolean;
+}>;
+
+/** `(neq a b)` — strict inequality. Built-in keyword in ember-source >= 7.1. */
+export type NeqHelper = DirectInvokable<{
+  <A, B>(a: A, b: B): [A] extends [B] ? ([B] extends [A] ? false : boolean) : boolean;
+}>;
+
+/** `(lt a b)` — numeric less-than. Built-in keyword in ember-source >= 7.1. */
+export type LtHelper = DirectInvokable<{
+  (a: number, b: number): boolean;
+}>;
+
+/** `(lte a b)` — numeric less-than-or-equal. Built-in keyword in ember-source >= 7.1. */
+export type LteHelper = DirectInvokable<{
+  (a: number, b: number): boolean;
+}>;
+
+/** `(gt a b)` — numeric greater-than. Built-in keyword in ember-source >= 7.1. */
+export type GtHelper = DirectInvokable<{
+  (a: number, b: number): boolean;
+}>;
+
+/** `(gte a b)` — numeric greater-than-or-equal. Built-in keyword in ember-source >= 7.1. */
+export type GteHelper = DirectInvokable<{
+  (a: number, b: number): boolean;
+}>;

package/types/-private/intrinsics/element.d.ts

@@ -0,0 +1,14 @@
+import { ComponentLike } from '@glint/template';
+import { DirectInvokable } from '@glint/template/-private/integration';
+
+/**
+ * `(element "tag-name")` — yields a component bound to a dynamic HTML tag
+ * name. Built-in keyword in ember-source >= 7.1 (RFC 389).
+ */
+export type ElementHelper = DirectInvokable<{
+  (tagName: string): ComponentLike<{
+    Element: Element;
+    Args: Record<string, unknown>;
+    Blocks: { default: [] };
+  }>;
+}>;

package/types/-private/intrinsics/truth-convert.d.ts

@@ -0,0 +1,86 @@
+// Adapted from `ember-truth-helpers` to give Glint exact return-type inference
+// for the `(and ...)` and `(or ...)` built-in keywords introduced in
+// ember-source 7.1 (RFC 560). The runtime semantics in Ember intentionally
+// match `ember-truth-helpers`, so the type-level rules here mirror that
+// package's published types.
+//
+// See: https://github.com/jmurphyau/ember-truth-helpers/blob/master/src/utils/truth-convert.ts
+
+export type Falsy = { isTruthy: false } | undefined | null | false | 0 | 0n | '' | never[];
+
+export type MaybeTruthy =
+  | { isTruthy: boolean }
+  | undefined
+  | null
+  | boolean
+  | number
+  | bigint
+  | string
+  | unknown[]
+  | object;
+
+export type TruthConvert<T> = T extends { isTruthy: true }
+  ? true
+  : T extends { isTruthy: false }
+    ? false
+    : T extends { isTruthy: boolean }
+      ? boolean
+      : T extends undefined | null
+        ? false
+        : T extends boolean
+          ? T
+          : T extends number
+            ? T extends 0
+              ? false
+              : number extends T
+                ? boolean
+                : true
+            : T extends bigint
+              ? T extends 0n
+                ? false
+                : bigint extends T
+                  ? boolean
+                  : true
+              : T extends string
+                ? T extends ''
+                  ? false
+                  : string extends T
+                    ? boolean
+                    : true
+                : T extends never[]
+                  ? false
+                  : T extends ArrayLike<unknown>
+                    ? boolean
+                    : T extends object
+                      ? true
+                      : boolean;
+
+/**
+ * Walks the positional argument tuple and returns the type of the first
+ * element whose `TruthConvert` resolves to `false`, falling back to the last
+ * element. Mirrors the runtime short-circuit behaviour of `(and ...)`.
+ */
+export type FirstFalsy<T> = T extends [infer Item]
+  ? Item
+  : T extends [infer Head, ...infer Tail]
+    ? TruthConvert<Head> extends false
+      ? Head
+      : TruthConvert<Head> extends true
+        ? FirstFalsy<Tail>
+        : Head | FirstFalsy<Tail>
+    : undefined;
+
+/**
+ * Walks the positional argument tuple and returns the type of the first
+ * element whose `TruthConvert` resolves to `true`, falling back to the last
+ * element. Mirrors the runtime short-circuit behaviour of `(or ...)`.
+ */
+export type FirstTruthy<T> = T extends [infer Item]
+  ? Item
+  : T extends [infer Head, ...infer Tail]
+    ? TruthConvert<Head> extends true
+      ? Head
+      : TruthConvert<Head> extends false
+        ? FirstTruthy<Tail>
+        : Exclude<Head, Falsy> | FirstTruthy<Tail>
+    : undefined;

package/types/-private/intrinsics/truth-helpers.d.ts

@@ -0,0 +1,32 @@
+import { DirectInvokable } from '@glint/template/-private/integration';
+
+import type { FirstFalsy, FirstTruthy, MaybeTruthy, TruthConvert } from './truth-convert';
+
+/**
+ * `(and a b ...)` — short-circuit logical AND. Returns the first falsy
+ * positional argument or the last argument. Available as a built-in keyword
+ * in ember-source >= 7.1 (RFC 560).
+ */
+export type AndHelper = DirectInvokable<{
+  <T extends MaybeTruthy[]>(...args: T): FirstFalsy<T>;
+}>;
+
+/**
+ * `(or a b ...)` — short-circuit logical OR. Returns the first truthy
+ * positional argument or the last argument. Available as a built-in keyword
+ * in ember-source >= 7.1 (RFC 560).
+ */
+export type OrHelper = DirectInvokable<{
+  <T extends MaybeTruthy[]>(...args: T): FirstTruthy<T>;
+}>;
+
+/**
+ * `(not value)` — boolean negation using truthy semantics matching the rest
+ * of Ember's template-side helpers. Built-in keyword in ember-source >= 7.1
+ * (RFC 560).
+ */
+export type NotHelper = DirectInvokable<{
+  <T>(
+    value: T,
+  ): TruthConvert<T> extends true ? false : TruthConvert<T> extends false ? true : boolean;
+}>;

package/lib/cli/run-volar-tsc.d.ts

@@ -1,2 +0,0 @@
-export declare function run(): void;
-//# sourceMappingURL=run-volar-tsc.d.ts.map

package/lib/cli/run-volar-tsc.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"run-volar-tsc.d.ts","sourceRoot":"","sources":["../../src/cli/run-volar-tsc.ts"],"names":[],"mappings":"AAOA,wBAAgB,GAAG,IAAI,IAAI,CA6B1B"}