@bromscandium/core 1.0.0

package/dist/reactive.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Proxy-based reactivity system for deep reactive state management.
+ * @module
+ */
+/**
+ * Internal flags used to identify reactive objects.
+ */
+export declare const ReactiveFlags: {
+    readonly IS_REACTIVE: "__b_isReactive";
+    readonly RAW: "__b_raw";
+};
+/**
+ * Creates a deeply reactive proxy of an object.
+ * Changes to the object or its nested properties will automatically trigger effects.
+ *
+ * @param target - The object to make reactive
+ * @returns A reactive proxy of the target object
+ *
+ * @example
+ * ```ts
+ * const state = reactive({ count: 0, nested: { value: 1 } });
+ * state.count++; // Triggers effects tracking 'count'
+ * state.nested.value++; // Triggers effects tracking nested 'value'
+ * ```
+ */
+export declare function reactive<T extends object>(target: T): T;
+/**
+ * Checks if a value is a reactive proxy created by `reactive()`.
+ *
+ * @param value - The value to check
+ * @returns True if the value is a reactive proxy
+ *
+ * @example
+ * ```ts
+ * const state = reactive({ count: 0 });
+ * isReactive(state); // true
+ * isReactive({ count: 0 }); // false
+ * ```
+ */
+export declare function isReactive(value: unknown): boolean;
+/**
+ * Returns the raw, non-reactive version of a reactive object.
+ * Useful when you need to read values without triggering dependency tracking.
+ *
+ * @param observed - The reactive object to unwrap
+ * @returns The original non-reactive object
+ *
+ * @example
+ * ```ts
+ * const state = reactive({ count: 0 });
+ * const raw = toRaw(state);
+ * raw === state; // false
+ * isReactive(raw); // false
+ * ```
+ */
+export declare function toRaw<T>(observed: T): T;
+/**
+ * Marks an object so it will never be converted to a reactive proxy.
+ * Useful for values that should not be made reactive, like third-party class instances.
+ *
+ * @param value - The object to mark as non-reactive
+ * @returns The same object, marked as raw
+ *
+ * @example
+ * ```ts
+ * const obj = markRaw({ count: 0 });
+ * const state = reactive({ data: obj });
+ * isReactive(state.data); // false - obj was marked raw
+ * ```
+ */
+export declare function markRaw<T extends object>(value: T): T;
+//# sourceMappingURL=reactive.d.ts.map

package/dist/reactive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reactive.d.ts","sourceRoot":"","sources":["../src/reactive.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAOH;;GAEG;AACH,eAAO,MAAM,aAAa;;;CAGhB,CAAC;AAEX;;;;;;;;;;;;;GAaG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,MAAM,EAAE,MAAM,EAAE,CAAC,GAAG,CAAC,CAqEvD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAElD;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,GAAG,CAAC,CAGvC;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,OAAO,CAAC,CAAC,SAAS,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAOrD"}

package/dist/reactive.js

@@ -0,0 +1,138 @@
+/**
+ * Proxy-based reactivity system for deep reactive state management.
+ * @module
+ */
+import { track, trigger } from './dep.js';
+const reactiveMap = new WeakMap();
+const rawMap = new WeakMap();
+/**
+ * Internal flags used to identify reactive objects.
+ */
+export const ReactiveFlags = {
+    IS_REACTIVE: '__b_isReactive',
+    RAW: '__b_raw',
+};
+/**
+ * Creates a deeply reactive proxy of an object.
+ * Changes to the object or its nested properties will automatically trigger effects.
+ *
+ * @param target - The object to make reactive
+ * @returns A reactive proxy of the target object
+ *
+ * @example
+ * ```ts
+ * const state = reactive({ count: 0, nested: { value: 1 } });
+ * state.count++; // Triggers effects tracking 'count'
+ * state.nested.value++; // Triggers effects tracking nested 'value'
+ * ```
+ */
+export function reactive(target) {
+    if (reactiveMap.has(target)) {
+        return reactiveMap.get(target);
+    }
+    if (target[ReactiveFlags.IS_REACTIVE]) {
+        return target;
+    }
+    const proxy = new Proxy(target, {
+        get(target, key, receiver) {
+            if (key === ReactiveFlags.IS_REACTIVE) {
+                return true;
+            }
+            if (key === ReactiveFlags.RAW) {
+                return target;
+            }
+            const result = Reflect.get(target, key, receiver);
+            track(target, key);
+            if (typeof result === 'object' && result !== null) {
+                return reactive(result);
+            }
+            return result;
+        },
+        set(target, key, value, receiver) {
+            const oldValue = Reflect.get(target, key, receiver);
+            const newValue = value?.[ReactiveFlags.RAW] || value;
+            const result = Reflect.set(target, key, newValue, receiver);
+            if (!Object.is(oldValue, newValue)) {
+                trigger(target, key);
+            }
+            return result;
+        },
+        deleteProperty(target, key) {
+            const hadKey = Reflect.has(target, key);
+            const result = Reflect.deleteProperty(target, key);
+            if (hadKey && result) {
+                trigger(target, key);
+            }
+            return result;
+        },
+        has(target, key) {
+            track(target, key);
+            return Reflect.has(target, key);
+        },
+        ownKeys(target) {
+            track(target, Symbol('iterate'));
+            return Reflect.ownKeys(target);
+        },
+    });
+    reactiveMap.set(target, proxy);
+    rawMap.set(proxy, target);
+    return proxy;
+}
+/**
+ * Checks if a value is a reactive proxy created by `reactive()`.
+ *
+ * @param value - The value to check
+ * @returns True if the value is a reactive proxy
+ *
+ * @example
+ * ```ts
+ * const state = reactive({ count: 0 });
+ * isReactive(state); // true
+ * isReactive({ count: 0 }); // false
+ * ```
+ */
+export function isReactive(value) {
+    return !!(value && value[ReactiveFlags.IS_REACTIVE]);
+}
+/**
+ * Returns the raw, non-reactive version of a reactive object.
+ * Useful when you need to read values without triggering dependency tracking.
+ *
+ * @param observed - The reactive object to unwrap
+ * @returns The original non-reactive object
+ *
+ * @example
+ * ```ts
+ * const state = reactive({ count: 0 });
+ * const raw = toRaw(state);
+ * raw === state; // false
+ * isReactive(raw); // false
+ * ```
+ */
+export function toRaw(observed) {
+    const raw = observed?.[ReactiveFlags.RAW];
+    return raw ? toRaw(raw) : observed;
+}
+/**
+ * Marks an object so it will never be converted to a reactive proxy.
+ * Useful for values that should not be made reactive, like third-party class instances.
+ *
+ * @param value - The object to mark as non-reactive
+ * @returns The same object, marked as raw
+ *
+ * @example
+ * ```ts
+ * const obj = markRaw({ count: 0 });
+ * const state = reactive({ data: obj });
+ * isReactive(state.data); // false - obj was marked raw
+ * ```
+ */
+export function markRaw(value) {
+    Object.defineProperty(value, ReactiveFlags.IS_REACTIVE, {
+        configurable: true,
+        enumerable: false,
+        value: false,
+    });
+    return value;
+}
+//# sourceMappingURL=reactive.js.map

package/dist/reactive.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reactive.js","sourceRoot":"","sources":["../src/reactive.ts"],"names":[],"mappings":"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"}

package/dist/ref.d.ts

@@ -0,0 +1,132 @@
+/**
+ * Ref implementation for wrapping primitive and object values in reactive containers.
+ * @module
+ */
+/** Internal flag used to identify ref objects */
+export declare const RefFlag = "__b_isRef";
+/**
+ * A reactive reference that wraps a value and tracks access to its `.value` property.
+ */
+export interface Ref<T = any> {
+    value: T;
+    readonly [RefFlag]: true;
+}
+/**
+ * A computed ref with a read-only value that is derived from other reactive state.
+ */
+export interface ComputedRef<T = any> extends Ref<T> {
+    readonly value: T;
+}
+/**
+ * Creates a reactive reference for a value.
+ * Object values are automatically made deeply reactive.
+ *
+ * @param value - The initial value for the ref
+ * @returns A reactive ref containing the value
+ *
+ * @example
+ * ```ts
+ * const count = ref(0);
+ * console.log(count.value); // 0
+ * count.value++; // Triggers effects
+ *
+ * const obj = ref({ nested: 1 });
+ * obj.value.nested++; // Also triggers effects (deep reactivity)
+ * ```
+ */
+export declare function ref<T>(value: T): Ref<T>;
+export declare function ref<T = any>(): Ref<T | undefined>;
+/**
+ * Checks if a value is a ref created by `ref()` or `computed()`.
+ *
+ * @param value - The value to check
+ * @returns True if the value is a ref
+ *
+ * @example
+ * ```ts
+ * isRef(ref(0)); // true
+ * isRef(0); // false
+ * isRef(computed(() => 1)); // true
+ * ```
+ */
+export declare function isRef<T>(value: Ref<T> | unknown): value is Ref<T>;
+/**
+ * Unwraps a ref to get its inner value. Returns the value directly if not a ref.
+ *
+ * @param ref - A ref or plain value to unwrap
+ * @returns The unwrapped value
+ *
+ * @example
+ * ```ts
+ * unref(ref(1)); // 1
+ * unref(1); // 1
+ * ```
+ */
+export declare function unref<T>(ref: T | Ref<T>): T;
+/**
+ * Creates a ref that syncs with a property of a reactive object.
+ * The ref stays connected to the source object.
+ *
+ * @param object - The source reactive object
+ * @param key - The property key to create a ref for
+ * @returns A ref linked to the specified property
+ *
+ * @example
+ * ```ts
+ * const state = reactive({ count: 0 });
+ * const countRef = toRef(state, 'count');
+ * countRef.value++; // Also updates state.count
+ * ```
+ */
+export declare function toRef<T extends object, K extends keyof T>(object: T, key: K): Ref<T[K]>;
+/**
+ * Converts all properties of a reactive object into refs.
+ * Each ref is linked to the corresponding property on the source object.
+ *
+ * @param object - The source reactive object
+ * @returns An object with the same keys, where each value is a ref
+ *
+ * @example
+ * ```ts
+ * const state = reactive({ count: 0, name: 'test' });
+ * const { count, name } = toRefs(state);
+ * count.value++; // Updates state.count
+ * ```
+ */
+export declare function toRefs<T extends object>(object: T): {
+    [K in keyof T]: Ref<T[K]>;
+};
+/**
+ * A shallow ref type (same interface as Ref but without deep reactivity).
+ */
+export type ShallowRef<T = any> = Ref<T>;
+/**
+ * Creates a ref that does not make its value deeply reactive.
+ * Only reassigning `.value` will trigger effects, not mutations to nested properties.
+ *
+ * @param value - The initial value for the shallow ref
+ * @returns A shallow ref containing the value
+ *
+ * @example
+ * ```ts
+ * const state = shallowRef({ nested: 0 });
+ * state.value.nested++; // Does NOT trigger effects
+ * state.value = { nested: 1 }; // Triggers effects
+ * ```
+ */
+export declare function shallowRef<T>(value: T): ShallowRef<T>;
+/**
+ * Manually triggers effects that depend on a ref.
+ * Useful after mutating the inner value of a shallow ref.
+ *
+ * @param ref - The ref to trigger
+ *
+ * @example
+ * ```ts
+ * const state = shallowRef({ count: 0 });
+ * state.value.count++; // No automatic trigger
+ * triggerRef(state); // Manually trigger effects
+ * ```
+ */
+export declare function triggerRef(ref: Ref): void;
+//# sourceMappingURL=ref.d.ts.map

package/dist/ref.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ref.d.ts","sourceRoot":"","sources":["../src/ref.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,iDAAiD;AACjD,eAAO,MAAM,OAAO,cAAc,CAAC;AAEnC;;GAEG;AACH,MAAM,WAAW,GAAG,CAAC,CAAC,GAAG,GAAG;IAC1B,KAAK,EAAE,CAAC,CAAC;IACT,QAAQ,CAAC,CAAC,OAAO,CAAC,EAAE,IAAI,CAAC;CAC1B;AAED;;GAEG;AACH,MAAM,WAAW,WAAW,CAAC,CAAC,GAAG,GAAG,CAAE,SAAQ,GAAG,CAAC,CAAC,CAAC;IAClD,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;CACnB;AA2CD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;AACzC,wBAAgB,GAAG,CAAC,CAAC,GAAG,GAAG,KAAK,GAAG,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC;AAQnD;;;;;;;;;;;;GAYG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,KAAK,EAAE,GAAG,CAAC,CAAC,CAAC,GAAG,OAAO,GAAG,KAAK,IAAI,GAAG,CAAC,CAAC,CAAC,CAEjE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAE3C;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,KAAK,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,CAAC,EACvD,MAAM,EAAE,CAAC,EACT,GAAG,EAAE,CAAC,GACL,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAeX;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,MAAM,CAAC,CAAC,SAAS,MAAM,EAAE,MAAM,EAAE,CAAC,GAAG;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CAAE,CAMjF;AAED;;GAEG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,GAAG,GAAG,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC;AAuBzC;;;;;;;;;;;;;GAaG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAErD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,GAAG,GAAG,IAAI,CAEzC"}

package/dist/ref.js

@@ -0,0 +1,181 @@
+/**
+ * Ref implementation for wrapping primitive and object values in reactive containers.
+ * @module
+ */
+var _a, _b;
+import { track, trigger, getActiveEffect } from './dep.js';
+import { reactive, toRaw } from './reactive.js';
+/** Internal flag used to identify ref objects */
+export const RefFlag = '__b_isRef';
+class RefImpl {
+    constructor(value) {
+        this[_a] = true;
+        this._rawValue = toRaw(value);
+        this._value = toReactive(value);
+    }
+    get value() {
+        trackRefValue(this);
+        return this._value;
+    }
+    set value(newValue) {
+        const rawNewValue = toRaw(newValue);
+        if (!Object.is(rawNewValue, this._rawValue)) {
+            this._rawValue = rawNewValue;
+            this._value = toReactive(newValue);
+            triggerRefValue(this);
+        }
+    }
+}
+_a = RefFlag;
+function toReactive(value) {
+    return typeof value === 'object' && value !== null
+        ? reactive(value)
+        : value;
+}
+function trackRefValue(ref) {
+    if (getActiveEffect()) {
+        track(ref, 'value');
+    }
+}
+function triggerRefValue(ref) {
+    trigger(ref, 'value');
+}
+export function ref(value) {
+    if (isRef(value)) {
+        return value;
+    }
+    return new RefImpl(value);
+}
+/**
+ * Checks if a value is a ref created by `ref()` or `computed()`.
+ *
+ * @param value - The value to check
+ * @returns True if the value is a ref
+ *
+ * @example
+ * ```ts
+ * isRef(ref(0)); // true
+ * isRef(0); // false
+ * isRef(computed(() => 1)); // true
+ * ```
+ */
+export function isRef(value) {
+    return !!(value && value[RefFlag] === true);
+}
+/**
+ * Unwraps a ref to get its inner value. Returns the value directly if not a ref.
+ *
+ * @param ref - A ref or plain value to unwrap
+ * @returns The unwrapped value
+ *
+ * @example
+ * ```ts
+ * unref(ref(1)); // 1
+ * unref(1); // 1
+ * ```
+ */
+export function unref(ref) {
+    return isRef(ref) ? ref.value : ref;
+}
+/**
+ * Creates a ref that syncs with a property of a reactive object.
+ * The ref stays connected to the source object.
+ *
+ * @param object - The source reactive object
+ * @param key - The property key to create a ref for
+ * @returns A ref linked to the specified property
+ *
+ * @example
+ * ```ts
+ * const state = reactive({ count: 0 });
+ * const countRef = toRef(state, 'count');
+ * countRef.value++; // Also updates state.count
+ * ```
+ */
+export function toRef(object, key) {
+    const val = object[key];
+    if (isRef(val)) {
+        return val;
+    }
+    return {
+        get value() {
+            return object[key];
+        },
+        set value(newValue) {
+            object[key] = newValue;
+        },
+        [RefFlag]: true,
+    };
+}
+/**
+ * Converts all properties of a reactive object into refs.
+ * Each ref is linked to the corresponding property on the source object.
+ *
+ * @param object - The source reactive object
+ * @returns An object with the same keys, where each value is a ref
+ *
+ * @example
+ * ```ts
+ * const state = reactive({ count: 0, name: 'test' });
+ * const { count, name } = toRefs(state);
+ * count.value++; // Updates state.count
+ * ```
+ */
+export function toRefs(object) {
+    const result = {};
+    for (const key in object) {
+        result[key] = toRef(object, key);
+    }
+    return result;
+}
+class ShallowRefImpl {
+    constructor(value) {
+        this[_b] = true;
+        this._value = value;
+    }
+    get value() {
+        trackRefValue(this);
+        return this._value;
+    }
+    set value(newValue) {
+        if (!Object.is(newValue, this._value)) {
+            this._value = newValue;
+            triggerRefValue(this);
+        }
+    }
+}
+_b = RefFlag;
+/**
+ * Creates a ref that does not make its value deeply reactive.
+ * Only reassigning `.value` will trigger effects, not mutations to nested properties.
+ *
+ * @param value - The initial value for the shallow ref
+ * @returns A shallow ref containing the value
+ *
+ * @example
+ * ```ts
+ * const state = shallowRef({ nested: 0 });
+ * state.value.nested++; // Does NOT trigger effects
+ * state.value = { nested: 1 }; // Triggers effects
+ * ```
+ */
+export function shallowRef(value) {
+    return new ShallowRefImpl(value);
+}
+/**
+ * Manually triggers effects that depend on a ref.
+ * Useful after mutating the inner value of a shallow ref.
+ *
+ * @param ref - The ref to trigger
+ *
+ * @example
+ * ```ts
+ * const state = shallowRef({ count: 0 });
+ * state.value.count++; // No automatic trigger
+ * triggerRef(state); // Manually trigger effects
+ * ```
+ */
+export function triggerRef(ref) {
+    triggerRefValue(ref);
+}
+//# sourceMappingURL=ref.js.map

package/dist/ref.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ref.js","sourceRoot":"","sources":["../src/ref.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@bromscandium/core",
+  "version": "1.0.0",
+  "description": "BromiumJS core reactivity system",
+  "author": "bromscandium",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bromscandium/bromiumjs.git",
+    "directory": "packages/core"
+  },
+  "homepage": "https://github.com/bromscandium/bromiumjs#readme",
+  "bugs": {
+    "url": "https://github.com/bromscandium/bromiumjs/issues"
+  },
+  "keywords": ["bromium", "bromiumjs", "reactivity", "proxy", "signals"],
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.3"
+  }
+}

package/src/dep.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Dependency tracking system for reactive state management.
+ * Uses WeakMap for automatic garbage collection of unused dependencies.
+ * @module
+ */
+/**
+ * An effect function that can be tracked and re-executed when dependencies change.
+ */
+export type EffectFn = (() => void) & {
+    deps: Set<Set<EffectFn>>;
+    options?: EffectOptions;
+};
+/**
+ * Configuration options for reactive effects.
+ */
+export interface EffectOptions {
+    /** If true, the effect will not run immediately upon creation */
+    lazy?: boolean;
+    /** Custom scheduler function to control when the effect runs */
+    scheduler?: (fn: EffectFn) => void;
+}
+/**
+ * Returns the currently executing effect, if any.
+ *
+ * @returns The active effect function or null if no effect is running
+ */
+export declare function getActiveEffect(): EffectFn | null;
+/**
+ * Sets the currently active effect.
+ *
+ * @param effect - The effect to set as active, or null to clear
+ */
+export declare function setActiveEffect(effect: EffectFn | null): void;
+/**
+ * Pushes an effect onto the effect stack and sets it as active.
+ * Used internally when running nested effects.
+ *
+ * @param effect - The effect to push onto the stack
+ */
+export declare function pushEffect(effect: EffectFn): void;
+/**
+ * Pops the current effect from the stack and restores the previous active effect.
+ * Used internally when a nested effect completes.
+ */
+export declare function popEffect(): void;
+/**
+ * Tracks a dependency between the currently active effect and a reactive property.
+ * Called automatically when a reactive property is accessed during effect execution.
+ *
+ * @param target - The reactive object being accessed
+ * @param key - The property key being accessed
+ *
+ * @example
+ * ```ts
+ * // Typically called internally by reactive proxies
+ * track(state, 'count');
+ * ```
+ */
+export declare function track(target: object, key: string | symbol): void;
+/**
+ * Triggers all effects that depend on a reactive property.
+ * Called automatically when a reactive property is modified.
+ *
+ * @param target - The reactive object being modified
+ * @param key - The property key being modified
+ *
+ * @example
+ * ```ts
+ * // Typically called internally by reactive proxies
+ * trigger(state, 'count');
+ * ```
+ */
+export declare function trigger(target: object, key: string | symbol): void;
+/**
+ * Removes an effect from all its dependency sets.
+ * Called before re-running an effect to ensure fresh dependency tracking.
+ *
+ * @param effect - The effect to clean up
+ */
+export declare function cleanup(effect: EffectFn): void;
+//# sourceMappingURL=dep.d.ts.map

package/src/dep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dep.d.ts","sourceRoot":"","sources":["dep.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG,CAAC,MAAM,IAAI,CAAC,GAAG;IACpC,IAAI,EAAE,GAAG,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC;IACzB,OAAO,CAAC,EAAE,aAAa,CAAC;CACzB,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,iEAAiE;IACjE,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,gEAAgE;IAChE,SAAS,CAAC,EAAE,CAAC,EAAE,EAAE,QAAQ,KAAK,IAAI,CAAC;CACpC;AAOD;;;;GAIG;AACH,wBAAgB,eAAe,IAAI,QAAQ,GAAG,IAAI,CAEjD;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,QAAQ,GAAG,IAAI,GAAG,IAAI,CAE7D;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,QAAQ,GAAG,IAAI,CAGjD;AAED;;;GAGG;AACH,wBAAgB,SAAS,IAAI,IAAI,CAGhC;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAiBhE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAsBlE;AAED;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,MAAM,EAAE,QAAQ,GAAG,IAAI,CAK9C"}