@brandtg/flapjack 0.1.0

package/dist/cli.js

@@ -0,0 +1,356 @@
+#!/usr/bin/env node
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import { Pool } from "pg";
+import { FeatureFlagModel } from "./model.js";
+import dotenv from "dotenv";
+dotenv.config();
+function createDatabase() {
+    const connectionString = process.env.DATABASE_URL;
+    if (!connectionString) {
+        throw new Error("DATABASE_URL is not set. Provide it in the environment or a .env file.");
+    }
+    return new Pool({ connectionString });
+}
+const cli = yargs(hideBin(process.argv))
+    .scriptName("flapjack")
+    .usage("$0 <command> [options]")
+    .help()
+    .alias("help", "h")
+    .version()
+    .alias("version", "v")
+    .demandCommand(1, "You need to specify a command")
+    .strict();
+// Common options for feature flag fields
+const flagOptions = {
+    name: {
+        type: "string",
+        describe: "Feature flag name",
+    },
+    everyone: {
+        type: "boolean",
+        describe: "Enable flag for everyone (overrides all other settings)",
+    },
+    percent: {
+        type: "number",
+        describe: "Percentage rollout (0-99.9)",
+    },
+    roles: {
+        type: "array",
+        describe: "List of roles that have this flag enabled",
+    },
+    groups: {
+        type: "array",
+        describe: "List of user groups that have this flag enabled",
+    },
+    users: {
+        type: "array",
+        describe: "List of specific user IDs that have this flag enabled",
+    },
+    note: {
+        type: "string",
+        describe: "Description of where this flag is used and what it does",
+    },
+};
+// Create command
+cli.command("create", "Create a new feature flag", (yargs) => {
+    return yargs
+        .options({
+        ...flagOptions,
+    })
+        .demandOption("name", "Feature flag name is required");
+}, async (argv) => {
+    const db = createDatabase();
+    const model = new FeatureFlagModel(db);
+    try {
+        const input = { name: argv.name };
+        if (argv.everyone !== undefined)
+            input.everyone = argv.everyone;
+        if (argv.percent !== undefined)
+            input.percent = argv.percent;
+        if (argv.roles !== undefined)
+            input.roles = argv.roles;
+        if (argv.groups !== undefined)
+            input.groups = argv.groups;
+        if (argv.users !== undefined)
+            input.users = argv.users;
+        if (argv.note !== undefined)
+            input.note = argv.note;
+        const flag = await model.create(input);
+        console.log(JSON.stringify(flag, null, 2));
+    }
+    catch (error) {
+        console.error("Error creating feature flag:", error);
+        process.exit(1);
+    }
+    finally {
+        await db.end();
+    }
+});
+// Get by ID command
+cli.command("get <id>", "Get a feature flag by ID", (yargs) => {
+    return yargs.positional("id", {
+        type: "number",
+        describe: "Feature flag ID",
+    });
+}, async (argv) => {
+    const db = createDatabase();
+    const model = new FeatureFlagModel(db);
+    try {
+        const flag = await model.getById(argv.id);
+        if (flag) {
+            console.log(JSON.stringify(flag, null, 2));
+        }
+        else {
+            console.log(`Feature flag with ID ${argv.id} not found`);
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        console.error("Error getting feature flag:", error);
+        process.exit(1);
+    }
+    finally {
+        await db.end();
+    }
+});
+// Get by name command
+cli.command("get-by-name <name>", "Get a feature flag by name", (yargs) => {
+    return yargs.positional("name", {
+        type: "string",
+        describe: "Feature flag name",
+    });
+}, async (argv) => {
+    const db = createDatabase();
+    const model = new FeatureFlagModel(db);
+    try {
+        const flag = await model.getByName(argv.name);
+        if (flag) {
+            console.log(JSON.stringify(flag, null, 2));
+        }
+        else {
+            console.log(`Feature flag with name "${argv.name}" not found`);
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        console.error("Error getting feature flag:", error);
+        process.exit(1);
+    }
+    finally {
+        await db.end();
+    }
+});
+// List command
+cli.command("list", "List all feature flags", () => { }, async () => {
+    const db = createDatabase();
+    const model = new FeatureFlagModel(db);
+    try {
+        const flags = await model.list();
+        console.log(JSON.stringify(flags, null, 2));
+    }
+    catch (error) {
+        console.error("Error listing feature flags:", error);
+        process.exit(1);
+    }
+    finally {
+        await db.end();
+    }
+});
+// Update command
+cli.command("update <id>", "Update a feature flag", (yargs) => {
+    return yargs
+        .positional("id", {
+        type: "number",
+        describe: "Feature flag ID",
+    })
+        .options({
+        ...flagOptions,
+        "clear-everyone": {
+            type: "boolean",
+            describe: "Unset the everyone override (set to null)",
+        },
+        "clear-percent": {
+            type: "boolean",
+            describe: "Unset percentage rollout",
+        },
+        "clear-roles": {
+            type: "boolean",
+            describe: "Clear roles list",
+        },
+        "clear-groups": {
+            type: "boolean",
+            describe: "Clear groups list",
+        },
+        "clear-users": {
+            type: "boolean",
+            describe: "Clear users list",
+        },
+        "clear-note": {
+            type: "boolean",
+            describe: "Clear the note",
+        },
+    });
+}, async (argv) => {
+    const db = createDatabase();
+    const model = new FeatureFlagModel(db);
+    try {
+        const changes = {};
+        if (argv.name !== undefined)
+            changes.name = argv.name;
+        // Everyone: clear flag takes precedence
+        if (argv.clearEveryone)
+            changes.everyone = null;
+        else if (argv.everyone !== undefined)
+            changes.everyone = argv.everyone;
+        // Percent: clear flag takes precedence
+        if (argv.clearPercent)
+            changes.percent = null;
+        else if (argv.percent !== undefined)
+            changes.percent = argv.percent;
+        // Roles: clear flag takes precedence
+        if (argv.clearRoles)
+            changes.roles = null;
+        else if (argv.roles !== undefined)
+            changes.roles = argv.roles;
+        // Groups: clear flag takes precedence
+        if (argv.clearGroups)
+            changes.groups = null;
+        else if (argv.groups !== undefined)
+            changes.groups = argv.groups;
+        // Users: clear flag takes precedence
+        if (argv.clearUsers)
+            changes.users = null;
+        else if (argv.users !== undefined)
+            changes.users = argv.users;
+        // Note: clear flag takes precedence
+        if (argv.clearNote)
+            changes.note = null;
+        else if (argv.note !== undefined)
+            changes.note = argv.note;
+        const flag = await model.update(argv.id, changes);
+        if (flag) {
+            console.log(JSON.stringify(flag, null, 2));
+        }
+        else {
+            console.log(`Feature flag with ID ${argv.id} not found`);
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        console.error("Error updating feature flag:", error);
+        process.exit(1);
+    }
+    finally {
+        await db.end();
+    }
+});
+// Delete command
+cli.command("delete <id>", "Delete a feature flag", (yargs) => {
+    return yargs.positional("id", {
+        type: "number",
+        describe: "Feature flag ID",
+    });
+}, async (argv) => {
+    const db = createDatabase();
+    const model = new FeatureFlagModel(db);
+    try {
+        const success = await model.delete(argv.id);
+        if (success) {
+            console.log(`Feature flag with ID ${argv.id} deleted successfully`);
+        }
+        else {
+            console.log(`Feature flag with ID ${argv.id} not found`);
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        console.error("Error deleting feature flag:", error);
+        process.exit(1);
+    }
+    finally {
+        await db.end();
+    }
+});
+// Check if active for user command
+cli.command("is-active <name>", "Check if a feature flag is active for a user", (yargs) => {
+    return yargs
+        .positional("name", {
+        type: "string",
+        describe: "Feature flag name",
+    })
+        .options({
+        user: {
+            type: "string",
+            describe: "User ID",
+        },
+        roles: {
+            type: "array",
+            describe: "User roles",
+        },
+        groups: {
+            type: "array",
+            describe: "User groups",
+        },
+    });
+}, async (argv) => {
+    const db = createDatabase();
+    const model = new FeatureFlagModel(db);
+    try {
+        const isActive = await model.isActiveForUser({
+            name: argv.name,
+            user: argv.user,
+            roles: argv.roles,
+            groups: argv.groups,
+        });
+        console.log(JSON.stringify({
+            name: argv.name,
+            isActive,
+            user: argv.user,
+            roles: argv.roles,
+            groups: argv.groups,
+        }, null, 2));
+    }
+    catch (error) {
+        console.error("Error checking feature flag:", error);
+        process.exit(1);
+    }
+    finally {
+        await db.end();
+    }
+});
+// Hash user ID command (utility)
+cli.command("hash-user <userId>", "Hash a user ID using the same algorithm as percentage rollout", (yargs) => {
+    return yargs.positional("userId", {
+        type: "string",
+        describe: "User ID to hash",
+    });
+}, async (argv) => {
+    const db = createDatabase();
+    const model = new FeatureFlagModel(db);
+    try {
+        const hash = await model.hashUserId(argv.userId);
+        const bucket = hash % 100;
+        console.log(JSON.stringify({
+            userId: argv.userId,
+            hash,
+            bucket,
+        }, null, 2));
+    }
+    catch (error) {
+        console.error("Error hashing user ID:", error);
+        process.exit(1);
+    }
+    finally {
+        await db.end();
+    }
+});
+async function main() {
+    await cli.parseAsync();
+}
+main()
+    .then(() => process.exit(0))
+    .catch((err) => {
+    console.error("Error:", err);
+    process.exit(1);
+});

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export type { FeatureFlag } from "./types.js";
+export { FeatureFlagModel } from "./model.js";
+export { runMigrations, type MigrationOptions } from "./migrate.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAC9C,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAC9C,OAAO,EAAE,aAAa,EAAE,KAAK,gBAAgB,EAAE,MAAM,cAAc,CAAC"}

package/dist/index.js

@@ -0,0 +1,2 @@
+export { FeatureFlagModel } from "./model.js";
+export { runMigrations } from "./migrate.js";

package/dist/migrate.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Configuration options for running Flapjack database migrations.
+ */
+export interface MigrationOptions {
+    /** PostgreSQL connection URL (e.g., "postgresql://user:pass@localhost/dbname") */
+    databaseUrl: string;
+    /** Name of the migrations tracking table (default: 'pgmigrations') */
+    migrationsTable?: string;
+    /** Schema name to create tables in (optional) */
+    schema?: string;
+}
+/**
+ * Run Flapjack database migrations.
+ *
+ * This function applies all pending migrations to create or update the
+ * flapjack_feature_flag table in your PostgreSQL database.
+ *
+ * @param options - Migration configuration options
+ * @param options.databaseUrl - PostgreSQL connection URL
+ * @param options.migrationsTable - Name of the migrations tracking table (default: 'pgmigrations')
+ * @param options.schema - Schema name to create tables in (optional)
+ * @returns Promise that resolves when migrations are complete
+ *
+ * @throws Will throw an error if the database connection fails or migrations cannot be applied
+ *
+ * @example
+ * ```typescript
+ * import { runMigrations } from "@brandtg/flapjack";
+ *
+ * // Basic usage
+ * await runMigrations({
+ *   databaseUrl: process.env.DATABASE_URL,
+ * });
+ *
+ * // With custom migrations table
+ * await runMigrations({
+ *   databaseUrl: process.env.DATABASE_URL,
+ *   migrationsTable: "my_migrations",
+ * });
+ *
+ * // With custom schema
+ * await runMigrations({
+ *   databaseUrl: process.env.DATABASE_URL,
+ *   schema: "feature_flags",
+ * });
+ * ```
+ */
+export declare function runMigrations(options: MigrationOptions): Promise<void>;
+//# sourceMappingURL=migrate.d.ts.map

package/dist/migrate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrate.d.ts","sourceRoot":"","sources":["../src/migrate.ts"],"names":[],"mappings":"AAOA;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,kFAAkF;IAClF,WAAW,EAAE,MAAM,CAAC;IACpB,sEAAsE;IACtE,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,iDAAiD;IACjD,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAsB,aAAa,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAgB5E"}

package/dist/migrate.js

@@ -0,0 +1,55 @@
+import { runner } from "node-pg-migrate";
+import path from "path";
+import { fileURLToPath } from "url";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+/**
+ * Run Flapjack database migrations.
+ *
+ * This function applies all pending migrations to create or update the
+ * flapjack_feature_flag table in your PostgreSQL database.
+ *
+ * @param options - Migration configuration options
+ * @param options.databaseUrl - PostgreSQL connection URL
+ * @param options.migrationsTable - Name of the migrations tracking table (default: 'pgmigrations')
+ * @param options.schema - Schema name to create tables in (optional)
+ * @returns Promise that resolves when migrations are complete
+ *
+ * @throws Will throw an error if the database connection fails or migrations cannot be applied
+ *
+ * @example
+ * ```typescript
+ * import { runMigrations } from "@brandtg/flapjack";
+ *
+ * // Basic usage
+ * await runMigrations({
+ *   databaseUrl: process.env.DATABASE_URL,
+ * });
+ *
+ * // With custom migrations table
+ * await runMigrations({
+ *   databaseUrl: process.env.DATABASE_URL,
+ *   migrationsTable: "my_migrations",
+ * });
+ *
+ * // With custom schema
+ * await runMigrations({
+ *   databaseUrl: process.env.DATABASE_URL,
+ *   schema: "feature_flags",
+ * });
+ * ```
+ */
+export async function runMigrations(options) {
+    const { databaseUrl, migrationsTable = "pgmigrations", schema } = options;
+    // Path to migrations directory (relative to dist in production)
+    const migrationsDir = path.resolve(__dirname, "../migrations");
+    const migrationConfig = {
+        databaseUrl,
+        dir: migrationsDir,
+        direction: "up",
+        migrationsTable,
+        ...(schema && { schema }),
+        verbose: false,
+    };
+    await runner(migrationConfig);
+}

package/dist/model.d.ts

@@ -0,0 +1,212 @@
+import type { FeatureFlag } from "./types.js";
+import type { QueryResult } from "pg";
+interface Queryable {
+    query: (text: string, params?: any[]) => Promise<QueryResult>;
+}
+type CreateInput = Omit<FeatureFlag, "id" | "created" | "modified">;
+type UpdateChanges = Partial<Omit<FeatureFlag, "id" | "created" | "modified">>;
+/**
+ * Model for managing feature flags stored in PostgreSQL.
+ *
+ * @example
+ * ```typescript
+ * import { Pool } from "pg";
+ * import { FeatureFlagModel } from "@brandtg/flapjack";
+ *
+ * const pool = new Pool({ connectionString: process.env.DATABASE_URL });
+ * const featureFlags = new FeatureFlagModel(pool);
+ * ```
+ */
+export declare class FeatureFlagModel {
+    private db;
+    /**
+     * Creates a new FeatureFlagModel instance.
+     *
+     * @param db - A PostgreSQL Pool or Client instance that implements the Queryable interface
+     *
+     * @example
+     * ```typescript
+     * const pool = new Pool({ connectionString: process.env.DATABASE_URL });
+     * const model = new FeatureFlagModel(pool);
+     * ```
+     */
+    constructor(db: Queryable);
+    /**
+     * Creates a new feature flag in the database.
+     *
+     * @param input - Feature flag configuration
+     * @param input.name - Unique name for the feature flag (required)
+     * @param input.everyone - Optional boolean to enable/disable for everyone (overrides all other settings)
+     * @param input.percent - Optional percentage rollout (0-99.9)
+     * @param input.roles - Optional list of roles that have this flag enabled
+     * @param input.groups - Optional list of user groups that have this flag enabled
+     * @param input.users - Optional list of specific user IDs that have this flag enabled
+     * @param input.note - Optional description of the flag's purpose
+     * @returns The created feature flag with generated id, created, and modified timestamps
+     *
+     * @throws Will throw an error if a flag with the same name already exists
+     *
+     * @example
+     * ```typescript
+     * const flag = await model.create({
+     *   name: "new_checkout_flow",
+     *   roles: ["admin"],
+     *   note: "New checkout redesign",
+     * });
+     * ```
+     */
+    create(input: CreateInput): Promise<FeatureFlag>;
+    /**
+     * Retrieves a feature flag by its ID.
+     *
+     * @param id - The unique identifier of the feature flag
+     * @returns The feature flag if found, null otherwise
+     *
+     * @example
+     * ```typescript
+     * const flag = await model.getById(123);
+     * if (flag) {
+     *   console.log(`Flag ${flag.name} is configured`);
+     * }
+     * ```
+     */
+    getById(id: number): Promise<FeatureFlag | null>;
+    /**
+     * Retrieves a feature flag by its name.
+     *
+     * @param name - The unique name of the feature flag
+     * @returns The feature flag if found, null otherwise
+     *
+     * @example
+     * ```typescript
+     * const flag = await model.getByName("new_checkout_flow");
+     * if (flag) {
+     *   console.log(`Flag is ${flag.everyone ? 'enabled' : 'disabled'} for everyone`);
+     * }
+     * ```
+     */
+    getByName(name: string): Promise<FeatureFlag | null>;
+    /**
+     * Retrieves all feature flags, ordered by ID.
+     *
+     * @returns Array of all feature flags in the database
+     *
+     * @example
+     * ```typescript
+     * const flags = await model.list();
+     * console.log(`Total flags: ${flags.length}`);
+     * flags.forEach(flag => {
+     *   console.log(`${flag.name}: ${flag.everyone ?? 'conditional'}`);
+     * });
+     * ```
+     */
+    list(): Promise<FeatureFlag[]>;
+    /**
+     * Updates an existing feature flag.
+     *
+     * @param id - The unique identifier of the feature flag to update
+     * @param changes - Object containing the fields to update
+     * @returns The updated feature flag if found, null otherwise
+     *
+     * @remarks
+     * The modified timestamp is automatically updated by a database trigger.
+     * Pass `null` for a field to clear it (e.g., `everyone: null` removes the override).
+     * If no changes are provided, returns the flag unchanged.
+     *
+     * @example
+     * ```typescript
+     * // Gradually increase rollout percentage
+     * await model.update(flagId, { percent: 25 });
+     *
+     * // Enable for everyone
+     * await model.update(flagId, { everyone: true });
+     *
+     * // Remove everyone override, reverting to other rules
+     * await model.update(flagId, { everyone: null });
+     * ```
+     */
+    update(id: number, changes: UpdateChanges): Promise<FeatureFlag | null>;
+    /**
+     * Deletes a feature flag from the database.
+     *
+     * @param id - The unique identifier of the feature flag to delete
+     * @returns true if the flag was deleted, false if not found
+     *
+     * @example
+     * ```typescript
+     * const deleted = await model.delete(flagId);
+     * if (deleted) {
+     *   console.log("Flag successfully removed");
+     * }
+     * ```
+     */
+    delete(id: number): Promise<boolean>;
+    /**
+     * Checks if a user belongs to any of the specified groups
+     */
+    private isActiveForGroups;
+    /**
+     * Computes the hash value for a user ID using MurmurHash3.
+     *
+     * @param userId - The user ID to hash
+     * @returns The hash value used for percentage bucketing
+     *
+     * @remarks
+     * This method is useful for debugging percentage rollouts.
+     * The hash value is consistent for the same user ID.
+     * The bucket is computed as `hash % 100`.
+     *
+     * @example
+     * ```typescript
+     * const hash = await model.hashUserId("user_123");
+     * const bucket = hash % 100;
+     * console.log(`User bucket: ${bucket}`);
+     * // If bucket is 42 and percent is 50, user is in the rollout
+     * ```
+     */
+    hashUserId(userId: string): Promise<number>;
+    /**
+     * Checks if a feature flag is active for a user based on configured rules.
+     *
+     * @param params - Parameters for flag evaluation
+     * @param params.name - The name of the feature flag to check
+     * @param params.user - Optional user ID
+     * @param params.roles - Optional list of roles the user has
+     * @param params.groups - Optional list of groups the user belongs to
+     * @returns true if the flag is active for the user, false otherwise
+     *
+     * @remarks
+     * Evaluation order (first match wins):
+     * 1. Everyone override (if set to true/false, returns immediately)
+     * 2. User ID is in the users list
+     * 3. User belongs to any group in the groups list
+     * 4. User has any role in the roles list
+     * 5. User falls within the percentage rollout (based on consistent hashing)
+     * 6. Default: returns false
+     *
+     * @example
+     * ```typescript
+     * // Check for admin user
+     * const isActive = await model.isActiveForUser({
+     *   name: "new_feature",
+     *   user: "user_123",
+     *   roles: ["admin"],
+     *   groups: ["beta_testers"],
+     * });
+     *
+     * if (isActive) {
+     *   // Show new feature
+     * } else {
+     *   // Show old feature
+     * }
+     * ```
+     */
+    isActiveForUser({ name, user, roles, groups, }: {
+        name: string;
+        user?: string;
+        roles?: string[];
+        groups?: string[];
+    }): Promise<boolean>;
+}
+export {};
+//# sourceMappingURL=model.d.ts.map

package/dist/model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../src/model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAC9C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,IAAI,CAAC;AAItC,UAAU,SAAS;IACjB,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,WAAW,CAAC,CAAC;CAC/D;AAiBD,KAAK,WAAW,GAAG,IAAI,CAAC,WAAW,EAAE,IAAI,GAAG,SAAS,GAAG,UAAU,CAAC,CAAC;AACpE,KAAK,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,WAAW,EAAE,IAAI,GAAG,SAAS,GAAG,UAAU,CAAC,CAAC,CAAC;AAyB/E;;;;;;;;;;;GAWG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,EAAE,CAAY;IAEtB;;;;;;;;;;OAUG;gBACS,EAAE,EAAE,SAAS;IAIzB;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACG,MAAM,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC;IAmCtD;;;;;;;;;;;;;OAaG;IACG,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC;IAOtD;;;;;;;;;;;;;OAaG;IACG,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC;IAO1D;;;;;;;;;;;;;OAaG;IACG,IAAI,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC;IAMpC;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACG,MAAM,CACV,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC;IA6C9B;;;;;;;;;;;;;OAaG;IACG,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAK1C;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAQzB;;;;;;;;;;;;;;;;;;OAkBG;IACG,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAIjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;IACG,eAAe,CAAC,EACpB,IAAI,EACJ,IAAI,EACJ,KAAK,EACL,MAAM,GACP,EAAE;QACD,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;QACjB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;KACnB,GAAG,OAAO,CAAC,OAAO,CAAC;CA4CrB"}