gnim 1.2.3 → 1.2.5

package/dist/dbus.d.ts

@@ -7,8 +7,9 @@
 import Gio from "gi://Gio";
 import GLib from "gi://GLib";
 import GObject from "gi://GObject";
-import { type InferVariant } from "./variant.js";
 import { register } from "./gobject.js";
+export declare const Variant: typeof GLib.Variant;
+export type Variant<T extends string> = GLib.Variant<T>;
 declare const info: unique symbol;
 declare const internals: unique symbol;
 declare const remoteMethod: unique symbol;
@@ -62,10 +63,11 @@ type DBusType = string | {
     type: string;
     name: string;
 };
+type DeepInfer<T extends string> = ReturnType<GLib.Variant<T>["deepUnpack"]>;
 type InferVariantTypes<T extends Array<DBusType>> = {
-    [K in keyof T]: T[K] extends string ? InferVariant<T[K]> : T[K] extends {
+    [K in keyof T]: T[K] extends string ? DeepInfer<T[K]> : T[K] extends {
         type: infer S;
-    } ? S extends string ? InferVariant<S> : never : unknown;
+    } ? S extends string ? DeepInfer<S> : never : unknown;
 };
 /**
  * Registers a method.
@@ -103,21 +105,21 @@ export declare function methodAsync<const InArgs extends Array<DBusType>>(...inA
  * not emit the notify signal.
  * ```
  */
-export declare function property<T extends string>(type: T): (_: void, ctx: ClassFieldDecoratorContext<Service, InferVariant<T>>) => (this: Service, init: InferVariant<T>) => InferVariant<T>;
+export declare function property<T extends string>(type: T): (_: void, ctx: ClassFieldDecoratorContext<Service, DeepInfer<T>>) => (this: Service, init: DeepInfer<T>) => DeepInfer<T>;
 /**
  * Registers a read-only property. Can be used in conjuction with {@link setter} to define
  * read-write properties as accessors.
  *
  * Note that you will need to explicitly emit the notify signal.
  */
-export declare function getter<T extends string>(type: T): (getter: (this: Service) => InferVariant<T>, ctx: ClassGetterDecoratorContext<Service, InferVariant<T>>) => (this: Service) => InferVariant<T>;
+export declare function getter<T extends string>(type: T): (getter: (this: Service) => DeepInfer<T>, ctx: ClassGetterDecoratorContext<Service, DeepInfer<T>>) => (this: Service) => DeepInfer<T>;
 /**
  * Registers a write-only property. Can be used in conjuction with {@link getter} to define
  * read-write properties as accessors.
  *
  * Note that you will need to explicitly emit the notify signal.
  */
-export declare function setter<T extends string>(type: T): (setter: (this: Service, value: InferVariant<T>) => void, ctx: ClassSetterDecoratorContext<Service, InferVariant<T>>) => (this: Service, value: InferVariant<T>) => void;
+export declare function setter<T extends string>(type: T): (setter: (this: Service, value: DeepInfer<T>) => void, ctx: ClassSetterDecoratorContext<Service, DeepInfer<T>>) => (this: Service, value: DeepInfer<T>) => void;
 /**
  * Registers a signal which when invoked will emit the signal
  * on the local object and the exported object.
@@ -125,15 +127,4 @@ export declare function setter<T extends string>(type: T): (setter: (this: Servi
  * **Note**: its not possible to emit signals on remote objects through proxies.
  */
 export declare function signal<const Params extends Array<DBusType>>(...params: Params): (method: (this: Service, ...params: InferVariantTypes<Params>) => void, ctx: ClassMethodDecoratorContext<Service, typeof method>) => typeof method;
-declare class GLibVariant<T extends string = any> extends GLib.Variant<T> {
-    static new<T extends string>(signature: T, value: InferVariant<T>): GLib.Variant<T>;
-    constructor(signature: T, value: InferVariant<T>);
-    deepUnpack<V = InferVariant<T>>(): V;
-    deep_unpack<V = InferVariant<T>>(): V;
-}
-export declare namespace Variant {
-    type Infer<S extends string> = InferVariant<S>;
-}
-export declare const Variant: typeof GLibVariant;
-export type Variant<T extends string = any> = GLibVariant<T>;
 export {};

package/dist/dbus.js

@@ -22,6 +22,7 @@ import GObject from "gi://GObject";
 import { definePropertyGetter, kebabify, xml } from "./util.js";
 import { register, property as gproperty, signal as gsignal, getter as ggetter, setter as gsetter, } from "./gobject.js";
 const DEFAULT_TIMEOUT = 10000;
+export const Variant = GLib.Variant;
 const info = Symbol("dbus interface info");
 const internals = Symbol("dbus interface internals");
 const remoteMethod = Symbol("proxy remoteMethod");
@@ -549,28 +550,3 @@ export function signal(...params) {
         };
     };
 }
-// HACK: how do I augment it globally?
-class GLibVariant extends GLib.Variant {
-    static new(signature, value) {
-        return GLib.Variant.new(signature, value);
-    }
-    constructor(signature, value) {
-        super(signature, value);
-    }
-    deepUnpack() {
-        return super.deepUnpack();
-    }
-    deep_unpack() {
-        return super.deepUnpack();
-    }
-}
-export const Variant = GLib.Variant;
-// FIXME: should be augmented globally
-// declare module "gi://GLib?version=2.0" {
-//     export namespace GLib {
-//         export interface Variant<T extends string = string> {
-//             deepUnpack<V = InferVariantType<T>>(): V
-//             deep_unpack<V = InferVariantType<T>>(): V
-//         }
-//     }
-// }

package/dist/jsx/For.js

@@ -1,9 +1,10 @@
 import { Fragment } from "./Fragment.js";
 import { createState } from "./state.js";
 import { env } from "./env.js";
-import { onCleanup, Scope } from "./scope.js";
+import { getScope, onCleanup, Scope } from "./scope.js";
 // TODO: support Gio.ListModel
 export function For({ each, children: mkChild, cleanup, id = (item) => item, }) {
+    const currentScope = getScope();
     const map = new Map();
     const fragment = new Fragment();
     function remove({ item, child, index: [index], scope }) {
@@ -44,17 +45,17 @@ export function For({ each, children: mkChild, cleanup, id = (item) => item, })
             }
             else {
                 const [index, setIndex] = createState(i);
-                const scope = new Scope(Scope.current);
+                const scope = new Scope(currentScope);
                 const child = scope.run(() => mkChild(item, index));
                 map.set(key, { item, child, index: [index, setIndex], scope });
                 fragment.addChild(child);
             }
         });
     }
-    callback(each.get());
     const dispose = each.subscribe(() => {
         callback(each.get());
     });
+    callback(each.get());
     onCleanup(() => {
         dispose();
         for (const value of map.values()) {

package/dist/jsx/With.js

@@ -1,7 +1,8 @@
 import { Fragment } from "./Fragment.js";
 import { env } from "./env.js";
-import { onCleanup, Scope } from "./scope.js";
+import { getScope, onCleanup, Scope } from "./scope.js";
 export function With({ value, children: mkChild, cleanup, }) {
+    const currentScope = getScope();
     const fragment = new Fragment();
     let scope;
     function callback(v) {
@@ -16,7 +17,7 @@ export function With({ value, children: mkChild, cleanup, }) {
             if (scope)
                 scope.dispose();
         }
-        scope = new Scope(Scope.current);
+        scope = new Scope(currentScope);
         const ch = scope.run(() => mkChild(v));
         if (ch !== "" && ch !== false && ch !== null && ch !== undefined) {
             fragment.addChild(ch);

package/dist/jsx/scope.d.ts

@@ -1,11 +1,11 @@
 export declare class Scope {
-    static current: Scope | null;
+    static current?: Scope | null;
     parent?: Scope | null;
-    context?: any;
+    contexts: Map<Context<any>, unknown>;
     private cleanups;
     private mounts;
     private mounted;
-    constructor(parent: Scope | null);
+    constructor(parent?: Scope | null);
     onCleanup(callback: () => void): void;
     onMount(callback: () => void): void;
     run<T>(fn: () => T): T;

package/dist/jsx/scope.js

@@ -1,5 +1,6 @@
 export class Scope {
     constructor(parent) {
+        this.contexts = new Map();
         this.cleanups = new Set();
         this.mounts = new Set();
         this.mounted = false;
@@ -32,8 +33,8 @@ export class Scope {
     dispose() {
         this.cleanups.forEach((cb) => cb());
         this.cleanups.clear();
+        this.contexts.clear();
         delete this.parent;
-        delete this.context;
     }
 }
 /**
@@ -59,29 +60,29 @@ export class Scope {
  * ```
  */
 export function createContext(defaultValue) {
+    let ctx;
     function provide(value, fn) {
-        const scope = new Scope(Scope.current);
-        onCleanup(() => scope.dispose());
-        scope.context = value;
+        const scope = getScope();
+        scope.contexts.set(ctx, value);
         return scope.run(fn);
     }
     function use() {
         let scope = Scope.current;
         while (scope) {
-            const value = scope.context;
-            if (value)
+            const value = scope.contexts.get(ctx);
+            if (value !== undefined)
                 return value;
-            scope = scope.parent ?? null;
+            scope = scope.parent;
         }
         return defaultValue;
     }
     function context({ value, children }) {
         return provide(value, children);
     }
-    return Object.assign(context, {
+    return (ctx = Object.assign(context, {
         provide,
         use,
-    });
+    }));
 }
 /**
  * Gets the scope that owns the currently running code.

package/dist/jsx/state.d.ts

@@ -1,7 +1,7 @@
 import GObject from "gi://GObject";
 import Gio from "gi://Gio";
+import GLib from "gi://GLib";
 import { type Pascalify } from "../util.js";
-import { type InferVariantRec, type InferVariant } from "../variant.js";
 type SubscribeCallback = () => void;
 type DisposeFunction = () => void;
 type SubscribeFunction = (callback: SubscribeCallback) => DisposeFunction;
@@ -116,11 +116,13 @@ export declare function createConnection<T, O1 extends GObject.Object, S1 extend
  * @param producer The producer function which should return a cleanup function
  */
 export declare function createExternal<T>(init: T, producer: (set: Setter<T>) => DisposeFunction): Accessor<T>;
+type DeepInfer<T extends string> = ReturnType<GLib.Variant<T>["deepUnpack"]>;
+type RecursiveInfer<T extends string> = ReturnType<GLib.Variant<T>["recursiveUnpack"]>;
 /** @experimental */
 type Settings<T extends Record<string, string>> = {
-    [K in keyof T as Uncapitalize<Pascalify<K>>]: Accessor<InferVariantRec<T[K]>>;
+    [K in keyof T as Uncapitalize<Pascalify<K>>]: Accessor<RecursiveInfer<T[K]>>;
 } & {
-    [K in keyof T as `set${Pascalify<K>}`]: Setter<InferVariant<T[K]>>;
+    [K in keyof T as `set${Pascalify<K>}`]: Setter<DeepInfer<T[K]>>;
 };
 /**
  * @experimental

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "gnim",
-    "version": "1.2.3",
+    "version": "1.2.5",
     "type": "module",
     "author": "Aylur",
     "license": "MIT",

package/dist/variant.d.ts

@@ -1,77 +0,0 @@
-import type GLib from "gi://GLib";
-type Variant<S extends string = any> = GLib.Variant<S>;
-type CreateIndexType<Key extends string, Value> = Key extends `s` | `o` | `g` ? {
-    [key: string]: Value;
-} : Key extends `n` | `q` | `t` | `d` | `u` | `i` | `x` | `y` ? {
-    [key: number]: Value;
-} : never;
-type VariantTypeError<T extends string> = {
-    error: true;
-} & T;
-/**
- * Handles the {kv} of a{kv} where k is a basic type and v is any possible variant type string.
- */
-type $ParseDeepVariantDict<State extends string, Memo extends Record<string, any> = {}> = string extends State ? VariantTypeError<"$ParseDeepVariantDict: 'string' is not a supported type."> : State extends `}${infer State}` ? [Memo, State] : State extends `${infer Key}${''}${infer State}` ? $ParseDeepVariantValue<State> extends [infer Value, `${infer State}`] ? State extends `}${infer State}` ? [CreateIndexType<Key, Value>, State] : VariantTypeError<`$ParseDeepVariantDict encountered an invalid variant string: ${State} (1)`> : VariantTypeError<`$ParseDeepVariantValue returned unexpected value for: ${State}`> : VariantTypeError<`$ParseDeepVariantDict encountered an invalid variant string: ${State} (2)`>;
-/**
- * Handles parsing values within a tuple (e.g. (vvv)) where v is any possible variant type string.
- */
-type $ParseDeepVariantArray<State extends string, Memo extends any[] = []> = string extends State ? VariantTypeError<"$ParseDeepVariantArray: 'string' is not a supported type."> : State extends `)${infer State}` ? [Memo, State] : $ParseDeepVariantValue<State> extends [infer Value, `${infer State}`] ? State extends `${infer _NextValue})${infer _NextState}` ? $ParseDeepVariantArray<State, [...Memo, Value]> : State extends `)${infer State}` ? [[...Memo, Value], State] : VariantTypeError<`1: $ParseDeepVariantArray encountered an invalid variant string: ${State}`> : VariantTypeError<`2: $ParseDeepVariantValue returned unexpected value for: ${State}`>;
-/**
- * Handles parsing {kv} without an 'a' prefix (key-value pair) where k is a basic type
- * and v is any possible variant type string.
- */
-type $ParseDeepVariantKeyValue<State extends string, Memo extends any[] = []> = string extends State ? VariantTypeError<"$ParseDeepVariantKeyValue: 'string' is not a supported type."> : State extends `}${infer State}` ? [Memo, State] : State extends `${infer Key}${''}${infer State}` ? $ParseDeepVariantValue<State> extends [infer Value, `${infer State}`] ? State extends `}${infer State}` ? [[...Memo, $ParseVariant<Key>, Value], State] : VariantTypeError<`$ParseDeepVariantKeyValue encountered an invalid variant string: ${State} (1)`> : VariantTypeError<`$ParseDeepVariantKeyValue returned unexpected value for: ${State}`> : VariantTypeError<`$ParseDeepVariantKeyValue encountered an invalid variant string: ${State} (2)`>;
-/**
- * Handles parsing any variant 'value' or base unit.
- *
- * - ay - Array of bytes (Uint8Array)
- * - a* - Array of type *
- * - a{k*} - Dictionary
- * - {k*} - KeyValue
- * - (**) - tuple
- * - s | o | g - string types
- * - n | q | t | d | u | i | x | y - number types
- * - b - boolean type
- * - v - unknown Variant type
- * - h | ? - unknown types
- */
-type $ParseDeepVariantValue<State extends string> = string extends State ? unknown : State extends `${`s` | `o` | `g`}${infer State}` ? [string, State] : State extends `${`n` | `q` | `t` | `d` | `u` | `i` | `x` | `y`}${infer State}` ? [number, State] : State extends `b${infer State}` ? [boolean, State] : State extends `v${infer State}` ? [Variant, State] : State extends `${'h' | '?'}${infer State}` ? [unknown, State] : State extends `(${infer State}` ? $ParseDeepVariantArray<State> : State extends `a{${infer State}` ? $ParseDeepVariantDict<State> : State extends `{${infer State}` ? $ParseDeepVariantKeyValue<State> : State extends `ay${infer State}` ? [
-    Uint8Array,
-    State
-] : State extends `m${infer State}` ? $ParseDeepVariantValue<State> extends [infer Value, `${infer State}`] ? [Value | null, State] : VariantTypeError<`$ParseDeepVariantValue encountered an invalid variant string: ${State} (3)`> : State extends `a${infer State}` ? $ParseDeepVariantValue<State> extends [infer Value, `${infer State}`] ? [
-    Value[],
-    State
-] : VariantTypeError<`$ParseDeepVariantValue encountered an invalid variant string: ${State} (1)`> : VariantTypeError<`$ParseDeepVariantValue encountered an invalid variant string: ${State} (2)`>;
-type $ParseDeepVariant<T extends string> = $ParseDeepVariantValue<T> extends infer Result ? Result extends [infer Value, string] ? Value : Result extends VariantTypeError<any> ? Result : VariantTypeError<"$ParseDeepVariantValue returned unexpected Result"> : VariantTypeError<"$ParseDeepVariantValue returned uninferrable Result">;
-type $ParseRecursiveVariantDict<State extends string, Memo extends Record<string, any> = {}> = string extends State ? VariantTypeError<"$ParseRecursiveVariantDict: 'string' is not a supported type."> : State extends `}${infer State}` ? [Memo, State] : State extends `${infer Key}${''}${infer State}` ? $ParseRecursiveVariantValue<State> extends [infer Value, `${infer State}`] ? State extends `}${infer State}` ? [CreateIndexType<Key, Value>, State] : VariantTypeError<`$ParseRecursiveVariantDict encountered an invalid variant string: ${State} (1)`> : VariantTypeError<`$ParseRecursiveVariantValue returned unexpected value for: ${State}`> : VariantTypeError<`$ParseRecursiveVariantDict encountered an invalid variant string: ${State} (2)`>;
-type $ParseRecursiveVariantArray<State extends string, Memo extends any[] = []> = string extends State ? VariantTypeError<"$ParseRecursiveVariantArray: 'string' is not a supported type."> : State extends `)${infer State}` ? [Memo, State] : $ParseRecursiveVariantValue<State> extends [infer Value, `${infer State}`] ? State extends `${infer _NextValue})${infer _NextState}` ? $ParseRecursiveVariantArray<State, [...Memo, Value]> : State extends `)${infer State}` ? [[...Memo, Value], State] : VariantTypeError<`$ParseRecursiveVariantArray encountered an invalid variant string: ${State} (1)`> : VariantTypeError<`$ParseRecursiveVariantValue returned unexpected value for: ${State} (2)`>;
-type $ParseRecursiveVariantKeyValue<State extends string, Memo extends any[] = []> = string extends State ? VariantTypeError<"$ParseRecursiveVariantKeyValue: 'string' is not a supported type."> : State extends `}${infer State}` ? [Memo, State] : State extends `${infer Key}${''}${infer State}` ? $ParseRecursiveVariantValue<State> extends [infer Value, `${infer State}`] ? State extends `}${infer State}` ? [[...Memo, Key, Value], State] : VariantTypeError<`$ParseRecursiveVariantKeyValue encountered an invalid variant string: ${State} (1)`> : VariantTypeError<`$ParseRecursiveVariantKeyValue returned unexpected value for: ${State}`> : VariantTypeError<`$ParseRecursiveVariantKeyValue encountered an invalid variant string: ${State} (2)`>;
-type $ParseRecursiveVariantValue<State extends string> = string extends State ? unknown : State extends `${`s` | `o` | `g`}${infer State}` ? [string, State] : State extends `${`n` | `q` | `t` | `d` | `u` | `i` | `x` | `y`}${infer State}` ? [number, State] : State extends `b${infer State}` ? [boolean, State] : State extends `v${infer State}` ? [unknown, State] : State extends `${'h' | '?'}${infer State}` ? [unknown, State] : State extends `(${infer State}` ? $ParseRecursiveVariantArray<State> : State extends `a{${infer State}` ? $ParseRecursiveVariantDict<State> : State extends `{${infer State}` ? $ParseRecursiveVariantKeyValue<State> : State extends `ay${infer State}` ? [
-    Uint8Array,
-    State
-] : State extends `m${infer State}` ? $ParseRecursiveVariantValue<State> extends [infer Value, `${infer State}`] ? [Value | null, State] : VariantTypeError<`$ParseRecursiveVariantValue encountered an invalid variant string: ${State} (3)`> : State extends `a${infer State}` ? $ParseRecursiveVariantValue<State> extends [infer Value, `${infer State}`] ? [
-    Value[],
-    State
-] : VariantTypeError<`$ParseRecursiveVariantValue encountered an invalid variant string: ${State} (1)`> : VariantTypeError<`$ParseRecursiveVariantValue encountered an invalid variant string: ${State} (2)`>;
-type $ParseRecursiveVariant<T extends string> = $ParseRecursiveVariantValue<T> extends infer Result ? Result extends [infer Value, string] ? Value : Result extends VariantTypeError<any> ? Result : never : never;
-type $ParseVariantDict<State extends string, Memo extends Record<string, any> = {}> = string extends State ? VariantTypeError<"$ParseVariantDict: 'string' is not a supported type."> : State extends `}${infer State}` ? [Memo, State] : State extends `${infer Key}${''}${infer State}` ? $ParseVariantValue<State> extends [infer Value, `${infer State}`] ? State extends `}${infer State}` ? [CreateIndexType<Key, Variant<Value extends string ? Value : any>>, State] : VariantTypeError<`$ParseVariantDict encountered an invalid variant string: ${State} (1)`> : VariantTypeError<`$ParseVariantValue returned unexpected value for: ${State}`> : VariantTypeError<`$ParseVariantDict encountered an invalid variant string: ${State} (2)`>;
-type $ParseVariantArray<State extends string, Memo extends any[] = []> = string extends State ? VariantTypeError<"$ParseVariantArray: 'string' is not a supported type."> : State extends `)${infer State}` ? [Memo, State] : $ParseVariantValue<State> extends [infer Value, `${infer State}`] ? State extends `${infer _NextValue})${infer _NextState}` ? $ParseVariantArray<State, [...Memo, Variant<Value extends string ? Value : any>]> : State extends `)${infer State}` ? [[...Memo, Variant<Value extends string ? Value : any>], State] : VariantTypeError<`$ParseVariantArray encountered an invalid variant string: ${State} (1)`> : VariantTypeError<`$ParseVariantValue returned unexpected value for: ${State} (2)`>;
-type $ParseVariantKeyValue<State extends string, Memo extends any[] = []> = string extends State ? VariantTypeError<"$ParseVariantKeyValue: 'string' is not a supported type."> : State extends `}${infer State}` ? [Memo, State] : State extends `${infer Key}${''}${infer State}` ? $ParseVariantValue<State> extends [infer Value, `${infer State}`] ? State extends `}${infer State}` ? [[...Memo, Variant<Key>, Variant<Value extends string ? Value : any>], State] : VariantTypeError<`$ParseVariantKeyValue encountered an invalid variant string: ${State} (1)`> : VariantTypeError<`$ParseVariantKeyValue returned unexpected value for: ${State}`> : VariantTypeError<`$ParseVariantKeyValue encountered an invalid variant string: ${State} (2)`>;
-type $ParseShallowRootVariantValue<State extends string> = string extends State ? unknown : State extends `${`s` | `o` | `g`}${infer State}` ? [string, State] : State extends `${`n` | `q` | `t` | `d` | `u` | `i` | `x` | `y`}${infer State}` ? [number, State] : State extends `b${infer State}` ? [boolean, State] : State extends `v${infer State}` ? [Variant, State] : State extends `h${infer State}` ? [unknown, State] : State extends `?${infer State}` ? [unknown, State] : State extends `(${infer State}` ? $ParseVariantArray<State> : State extends `a{${infer State}` ? $ParseVariantDict<State> : State extends `{${infer State}` ? $ParseVariantKeyValue<State> : State extends `ay${infer State}` ? [
-    Uint8Array,
-    State
-] : State extends `m${infer State}` ? $ParseVariantValue<State> extends [infer Value, `${infer State}`] ? [Value | null, State] : VariantTypeError<`$ParseShallowRootVariantValue encountered an invalid variant string: ${State} (2)`> : State extends `a${infer State}` ? [
-    Variant<State>[],
-    State
-] : VariantTypeError<`$ParseShallowRootVariantValue encountered an invalid variant string: ${State} (1)`>;
-type $ParseVariantValue<State extends string> = string extends State ? unknown : State extends `s${infer State}` ? ['s', State] : State extends `o${infer State}` ? ['o', State] : State extends `g${infer State}` ? ['g', State] : State extends `n${infer State}` ? ["n", State] : State extends `q${infer State}` ? ["q", State] : State extends `t${infer State}` ? ["t", State] : State extends `d${infer State}` ? ["d", State] : State extends `u${infer State}` ? ["u", State] : State extends `i${infer State}` ? ["i", State] : State extends `x${infer State}` ? ["x", State] : State extends `y${infer State}` ? ["y", State] : State extends `b${infer State}` ? ['b', State] : State extends `v${infer State}` ? ['v', State] : State extends `h${infer State}` ? ['h', State] : State extends `?${infer State}` ? ['?', State] : State extends `(${infer State}` ? $ParseVariantArray<State> : State extends `a{${infer State}` ? $ParseVariantDict<State> : State extends `{${infer State}` ? $ParseVariantKeyValue<State> : State extends `ay${infer State}` ? [
-    Uint8Array,
-    State
-] : State extends `m${infer State}` ? $ParseVariantValue<State> extends [infer Value, `${infer State}`] ? [Value | null, State] : VariantTypeError<`$ParseVariantValue encountered an invalid variant string: ${State} (3)`> : State extends `a${infer State}` ? $ParseVariantValue<State> extends [infer Value, `${infer State}`] ? [
-    Value[],
-    State
-] : VariantTypeError<`$ParseVariantValue encountered an invalid variant string: ${State} (1)`> : VariantTypeError<`$ParseVariantValue encountered an invalid variant string: ${State} (2)`>;
-type $ParseVariant<T extends string> = $ParseShallowRootVariantValue<T> extends infer Result ? Result extends [infer Value, string] ? Value : Result extends VariantTypeError<any> ? Result : never : never;
-export type InferVariant<S extends string> = $ParseDeepVariant<S>;
-export type InferVariantRec<S extends string> = $ParseRecursiveVariant<S>;
-export {};

package/dist/variant.js

@@ -1,4 +0,0 @@
-// See: https://github.com/gjsify/ts-for-gir/issues/270
-//
-// Source: https://github.com/gjsify/ts-for-gir/blob/e1bfc49d233b4f13d4a3b342d5fc636532c4f352/packages/lib/src/generators/dts/glib.ts
-export {};