@paganaye/stylets 0.1.0

package/dist/CssExpr.js

@@ -0,0 +1,35 @@
+export class CssExpr {
+    unit;
+    type;
+    constructor(unit, type) {
+        this.unit = unit;
+        this.type = type;
+    }
+}
+class CssVar extends CssExpr {
+    varName;
+    constructor(varName, unit, type) {
+        super('%', 'unknown');
+        this.varName = varName;
+    }
+    toString() { return `var(--${this.varName})`; }
+}
+class CssCustomExpr extends CssExpr {
+    expr;
+    constructor(expr, unit, type) {
+        super(unit, type);
+        this.expr = expr;
+    }
+    toString() { return this.expr; }
+}
+class CssArg extends CssExpr {
+    argName;
+    constructor(argName, unit, type) {
+        super(unit, type);
+        this.argName = argName;
+    }
+    toString() { return this.argName; }
+}
+export function customCss(expr, unit = 'unknown', type = 'unknown') { return new CssCustomExpr(expr, unit, type); }
+export function arg(name, unit = 'unknown', type = 'unknown') { return new CssArg(name, unit, type); }
+export function v(name, unit = 'unknown', type = 'unknown') { return new CssVar(name, unit, type); }

package/dist/CssFilter.d.ts

@@ -0,0 +1,18 @@
+import { CssExpr } from "./CssExpr";
+import { Num } from "./CssNum";
+export declare class CssFilter extends CssExpr {
+    readonly options: FilterOptions | FilterOptions[];
+    constructor(options: FilterOptions | FilterOptions[]);
+    toString(): string;
+}
+export type FilterOptions = {
+    blur?: Num;
+    brightness?: Num;
+    contrast?: Num;
+    hueRotate?: Num;
+    saturate?: Num;
+    invert?: Num;
+    grayscale?: Num;
+    sepia?: Num;
+    opacity?: Num;
+};

package/dist/CssFilter.js

@@ -0,0 +1,40 @@
+import { CssExpr } from "./CssExpr";
+import { numToStr } from "./CssNum";
+export class CssFilter extends CssExpr {
+    options;
+    constructor(options) {
+        super('none', 'filter');
+        this.options = options;
+    }
+    toString() {
+        const serializeOne = (opt) => {
+            const result = [];
+            if (opt.blur !== undefined)
+                result.push(`blur(${numToStr(opt.blur)})`);
+            if (opt.brightness !== undefined)
+                result.push(`brightness(${numToStr(opt.brightness)})`);
+            if (opt.contrast !== undefined)
+                result.push(`contrast(${numToStr(opt.contrast)})`);
+            if (opt.hueRotate !== undefined)
+                result.push(`hue-rotate(${numToStr(opt.hueRotate)})`);
+            if (opt.saturate !== undefined)
+                result.push(`saturate(${numToStr(opt.saturate)})`);
+            if (opt.invert !== undefined)
+                result.push(`invert(${numToStr(opt.invert)})`);
+            if (opt.grayscale !== undefined)
+                result.push(`grayscale(${numToStr(opt.grayscale)})`);
+            if (opt.sepia !== undefined)
+                result.push(`sepia(${numToStr(opt.sepia)})`);
+            if (opt.opacity !== undefined)
+                result.push(`opacity(${numToStr(opt.opacity)})`);
+            return result.join(' ');
+        };
+        if (Array.isArray(this.options)) {
+            const parts = this.options.map(o => serializeOne(o));
+            return parts.join(' ');
+        }
+        else {
+            return serializeOne(this.options);
+        }
+    }
+}

package/dist/CssNum.d.ts

@@ -0,0 +1,30 @@
+import { CssExpr } from "./CssExpr";
+export type Num = number | string | CssExpr;
+export type ArgVariable = 'l' | 'c' | 'h';
+export type NumberType = 'length' | 'angle' | 'time' | 'frequency' | 'flex' | 'resolution';
+export type LengthUnit = 'px' | 'rem' | 'em' | 'vw' | 'vh' | '%';
+export type AngleUnit = 'deg' | 'rad';
+export type TimeUnit = 's' | 'ms';
+export type FrequencyUnit = 'hz' | 'khz';
+export type FlexUnit = 'fr';
+export type ResolutionUnit = 'dpi' | 'dpcm' | 'dppx';
+export type CssUnit = LengthUnit | AngleUnit | TimeUnit | FrequencyUnit | FlexUnit | ResolutionUnit | 'none' | 'unknown';
+export type CssType = NumberType | 'color' | 'shadow' | 'filter' | 'unknown';
+export declare function numToStr(num: Num): string;
+declare abstract class NumExpr extends CssExpr {
+    static arg: typeof numArg;
+    static mul: typeof mul;
+    static add: typeof add;
+    static clamp: typeof clamp;
+    static min: typeof min;
+    static max: typeof max;
+    static new: typeof num;
+}
+export declare function numArg(name: string, unit?: CssUnit, type?: CssType): CssExpr;
+export declare function mul(expr: NumExpr, factor: number | NumExpr): NumExpr;
+export declare function add(expr: NumExpr, addend: number | NumExpr): NumExpr;
+export declare function clamp(min: number | NumExpr, expr: NumExpr, max: number | NumExpr): NumExpr;
+export declare function min(...args: Array<number | NumExpr>): NumExpr;
+export declare function max(...args: Array<number | NumExpr>): NumExpr;
+export declare function num(value: number, unit?: CssUnit, type?: CssType): NumExpr;
+export {};

package/dist/CssNum.js

@@ -0,0 +1,106 @@
+import { CssExpr } from "./CssExpr";
+export function numToStr(num) {
+    if (typeof num === 'number')
+        return String(num);
+    return `${num.toString()}`;
+}
+// ==== Num ===== //
+class NumExpr extends CssExpr {
+    static arg = numArg;
+    static mul = mul;
+    static add = add;
+    static clamp = clamp;
+    static min = min;
+    static max = max;
+    static new = num;
+}
+class LitteralNumExpr extends NumExpr {
+    value;
+    unit;
+    constructor(value, unit, type) {
+        super(unit, type);
+        this.value = value;
+        this.unit = unit;
+    }
+    toString() { return `${this.value}${this.unit ?? ''}`; }
+}
+class CssNumArg extends NumExpr {
+    argName;
+    constructor(argName, unit, type) {
+        super(unit, type);
+        this.argName = argName;
+    }
+    toString() { return this.argName; }
+}
+class MulExpr extends NumExpr {
+    expr;
+    factor;
+    constructor(expr, factor) {
+        super('unknown', 'unknown');
+        this.expr = expr;
+        this.factor = factor;
+    }
+    toString() {
+        const f = numToStr(this.factor);
+        return `calc(${numToStr(this.expr)} * ${f})`;
+    }
+}
+class AddExpr extends NumExpr {
+    expr;
+    addend;
+    constructor(expr, addend) {
+        super('unknown', 'unknown');
+        this.expr = expr;
+        this.addend = addend;
+    }
+    toString() {
+        const a = numToStr(this.addend);
+        return `calc(${numToStr(this.expr)} + ${a})`;
+    }
+}
+class ClampExpr extends NumExpr {
+    min;
+    expr;
+    max;
+    constructor(min, expr, max) {
+        super('unknown', 'unknown');
+        this.min = min;
+        this.expr = expr;
+        this.max = max;
+    }
+    toString() {
+        const mn = numToStr(this.min);
+        const ex = numToStr(this.expr);
+        const mx = numToStr(this.max);
+        return `clamp(${mn}, ${ex}, ${mx})`;
+    }
+}
+class MinExpr extends NumExpr {
+    args;
+    constructor(args) {
+        super('unknown', 'unknown');
+        this.args = args;
+    }
+    toString() {
+        const parts = this.args.map(a => numToStr(a));
+        return `min(${parts.join(', ')})`;
+    }
+}
+class MaxExpr extends NumExpr {
+    args;
+    constructor(args) {
+        super('unknown', 'unknown');
+        this.args = args;
+    }
+    toString() {
+        const parts = this.args.map(a => numToStr(a));
+        return `max(${parts.join(', ')})`;
+    }
+}
+export function numArg(name, unit = 'none', type = 'length') { return new CssNumArg(name, unit, type); }
+export function mul(expr, factor) { return new MulExpr(expr, factor); }
+export function add(expr, addend) { return new AddExpr(expr, addend); }
+export function clamp(min, expr, max) { return new ClampExpr(min, expr, max); }
+export function min(...args) { return new MinExpr(args); }
+export function max(...args) { return new MaxExpr(args); }
+export function num(value, unit = 'unknown', type = 'unknown') { return new LitteralNumExpr(value, unit, type); }

package/dist/CssNum.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/CssNum.test.js

@@ -0,0 +1,30 @@
+import { describe, it } from 'vitest';
+// TODO: Update imports once CssNum is fully integrated
+// import { mul, add, clamp, min, max, num } from './CssNum';
+// import { l, h, c } from './CssColor';
+// import { v, customCss } from './CssExpr';
+describe('CssNumUtils', () => {
+    it.skip('numVar creates CSS var string', () => {
+        // expect(v('x').toString()).toBe('var(--x)');
+    });
+    it.skip('clamp/min/max produce expected strings', () => {
+        // expect(clamp(0, l, 1).toString()).toBe('clamp(0, l, 1)');
+        // expect(min(0, l, 2).toString()).toBe('min(0, l, 2)');
+        // expect(max(0, l, 2).toString()).toBe('max(0, l, 2)');
+        // expect(max(num(0, 'rem'), l, num(2, 'px')).toString()).toBe('max(0rem, l, 2px)');
+    });
+    it.skip('customCssExpr returns custom expression', () => {
+        // expect(customCss('calc(var(--a) + 1)').toString()).toBe('calc(var(--a) + 1)');
+    });
+    it.skip('num returns expected string', () => {
+        // expect(num(5, 'px').toString()).toBe('5px');
+    });
+    it.skip('min/max accept many args and nested expressions', () => {
+        // const nested = mul(l, 0.5);
+        // expect(clamp(0, nested, 100).toString()).toBe('clamp(0, calc(l * 0.5), 100)');
+        // expect(min(0, l, 2, mul(c, 3)).toString())
+        //     .toBe('min(0, l, 2, calc(c * 3))');
+        // expect(max(0, l, 2, add(c, 1)).toString())
+        //     .toBe('max(0, l, 2, calc(c + 1))');
+    });
+});

package/dist/CssReset.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/CssReset.js

@@ -0,0 +1,15 @@
+import { addStyles } from "./StyleWriter";
+addStyles("css-reset", (builder) => {
+    builder.addLines([`/* John W Comeau Modern CSS Reset */`,
+        `*, *::before, *::after { box-sizing: border-box; }`,
+        `*:not(dialog) { margin: 0; }`,
+        `@media (prefers-reduced-motion: no-preference) { html { interpolate-size: allow-keywords; } }`,
+        `body { line-height: 1.5; -webkit-font-smoothing: antialiased; -moz-osx-font-smoothing: grayscale; font-family: system-ui, -apple-system, 'Segoe UI', Roboto, 'Helvetica Neue', Arial; }`,
+        `img, picture, video, canvas, svg { display: block; max-width: 100%; }`,
+        `input, button, textarea, select { font: inherit; }`,
+        `p, h1, h2, h3, h4, h5, h6 { overflow-wrap: break-word; }`,
+        `p { text-wrap: pretty; }`,
+        `h1, h2, h3, h4, h5, h6 { text-wrap: balance; }`,
+        `#root, #__next { isolation: isolate; }`,
+    ]);
+});

package/dist/CssShadow.d.ts

@@ -0,0 +1,19 @@
+import { CssColor } from "./CssColor";
+import { CssExpr } from "./CssExpr";
+import { Num } from "./CssNum";
+export type BoxShadowOptions = {
+    offsetX: Num;
+    offsetY: Num;
+    blur?: Num;
+    spread?: Num;
+    color?: string | CssColor;
+    inset?: boolean;
+};
+export declare class CssShadow extends CssExpr {
+    readonly kind: 'box' | 'text';
+    opts: BoxShadowOptions | BoxShadowOptions[];
+    constructor(kind: 'box' | 'text', opts: BoxShadowOptions | BoxShadowOptions[]);
+    toString(): string;
+}
+export declare function textShadow(options: BoxShadowOptions | BoxShadowOptions[]): CssShadow;
+export declare function boxShadow(options: BoxShadowOptions | BoxShadowOptions[]): CssShadow;

package/dist/CssShadow.js

@@ -0,0 +1,42 @@
+import { CssExpr } from "./CssExpr";
+export class CssShadow extends CssExpr {
+    kind;
+    opts;
+    constructor(kind, opts) {
+        super('none', 'shadow');
+        this.kind = kind;
+        this.opts = opts;
+    }
+    toString() {
+        let serializeOne = (opt) => {
+            const { offsetX, offsetY, blur, spread, color, inset } = opt;
+            const parts = [];
+            // For text shadows, 'inset' and 'spread' are not valid
+            if (inset && this.kind === 'box')
+                parts.push('inset');
+            const sx = typeof offsetX === 'string' ? offsetX : offsetX.toString();
+            const sy = typeof offsetY === 'string' ? offsetY : offsetY.toString();
+            parts.push(sx, sy);
+            if (blur !== undefined)
+                parts.push(typeof blur === 'string' ? blur : blur.toString());
+            if (spread !== undefined && this.kind === 'box')
+                parts.push(typeof spread === 'string' ? spread : spread.toString());
+            if (color)
+                parts.push(typeof color === 'string' ? color : color.toString());
+            return parts.join(' ');
+        };
+        if (Array.isArray(this.opts)) {
+            const parts = this.opts.map(o => serializeOne(o));
+            return parts.join(', ');
+        }
+        else {
+            return serializeOne(this.opts);
+        }
+    }
+}
+export function textShadow(options) {
+    return new CssShadow('text', options);
+}
+export function boxShadow(options) {
+    return new CssShadow('box', options);
+}

package/dist/DefaultTheme.d.ts

@@ -0,0 +1,14 @@
+export declare const theme: import("./Theme").ThemeBuilder<{
+    colors: "primary";
+    sizes: never;
+    paddings: never;
+    margins: never;
+    borders: never;
+    backgrounds: never;
+    layouts: never;
+    typography: never;
+    shadows: never;
+    vars: never;
+    classes: never;
+    variants: Record<string, never>;
+}>;

package/dist/DefaultTheme.js

@@ -0,0 +1,6 @@
+import { createTheme } from "./Theme";
+export const theme = createTheme({
+    colors: {
+        primary: '#3498db',
+    }
+});

package/dist/EmptyTheme.d.ts

@@ -0,0 +1,14 @@
+export declare const emptyTheme: import("./Theme").ThemeBuilder<{
+    colors: never;
+    sizes: never;
+    paddings: never;
+    margins: never;
+    borders: never;
+    backgrounds: never;
+    layouts: never;
+    typography: never;
+    shadows: never;
+    vars: never;
+    classes: never;
+    variants: Record<string, never>;
+}>;

package/dist/EmptyTheme.js

@@ -0,0 +1,2 @@
+import { createTheme } from "./Theme";
+export const emptyTheme = createTheme({});

package/dist/HTML.d.ts

@@ -0,0 +1,9 @@
+import { CssProperties, ThemeClass } from "./types";
+import { theme } from "./DefaultTheme";
+export interface IDivProps {
+    class?: ThemeClass<typeof theme>;
+    style?: CssProperties;
+    gap?: number;
+}
+export declare function Div(props: IDivProps, children: any[]): string;
+export declare function P(props: IDivProps, children: any[]): string;

package/dist/HTML.jsx

@@ -0,0 +1,7 @@
+import { Elt } from "./props";
+export function Div(props, children) {
+    return Elt('div', props, children);
+}
+export function P(props, children) {
+    return Elt('p', props, children);
+}

package/dist/ScopeStyles.d.ts

@@ -0,0 +1,24 @@
+import { ThemeBuilder } from "./Theme";
+import { BaseStyles } from "./BaseStyles";
+import { IScopeStylesParts, MergeThemeArgs, ThemeArgs } from "./types";
+export declare class ScopeStylesBuilder<A extends ThemeArgs, V extends A['variants'] = A['variants']> extends BaseStyles<A> {
+    readonly class: string;
+    scopeStart: string;
+    scopeEnd: string | undefined;
+    parent: ThemeBuilder<any>;
+    constructor(parent: ThemeBuilder<any>, themeParts: IScopeStylesParts<A> & {
+        class: string;
+        scopeStart: string;
+        scopeEnd?: string;
+    });
+    add<P extends IScopeStylesParts<any>>(parts: P): ScopeStylesBuilder<MergeThemeArgs<A, P>, MergeThemeArgs<A, P>['variants']>;
+    add<P extends (theme: ThemeBuilder<A>) => IScopeStylesParts<any>>(parts: P): ScopeStylesBuilder<MergeThemeArgs<A, ReturnType<P>>, MergeThemeArgs<A, ReturnType<P>>['variants']>;
+    protected renderHeader(): void;
+    protected renderVariants(): void;
+    renderFooter(): void;
+    render(): ScopeStylesPublic<A, V>;
+}
+export type ScopeStylesPublic<A extends ThemeArgs, V extends A['variants'] = A['variants']> = {
+    class: string;
+    variants: V;
+};

package/dist/ScopeStyles.js

@@ -0,0 +1,67 @@
+import { BaseStyles } from "./BaseStyles";
+export class ScopeStylesBuilder extends BaseStyles {
+    class;
+    scopeStart;
+    scopeEnd;
+    parent;
+    constructor(parent, themeParts) {
+        // Merge all parent properties into scope
+        const mergedParts = {
+            ...themeParts,
+            name: `@scope ${themeParts.class}`,
+            colors: { ...parent.colors, ...themeParts.colors },
+            vars: { ...parent.vars, ...themeParts.vars },
+            paddings: { ...parent.paddings, ...themeParts.paddings },
+            margins: { ...parent.margins, ...themeParts.margins },
+            borders: { ...parent.borders, ...themeParts.borders },
+            backgrounds: { ...parent.backgrounds, ...themeParts.backgrounds },
+            typography: { ...parent.typography, ...themeParts.typography },
+            layouts: { ...parent.layouts, ...themeParts.layouts },
+            shadows: { ...parent.shadows, ...themeParts.shadows },
+            classes: { ...parent.classes, ...themeParts.classes },
+            variants: { ...parent.variants, ...themeParts.variants }
+        };
+        super(mergedParts);
+        this.parent = parent;
+        this.class = themeParts.class ?? '';
+        this.scopeStart = themeParts.scopeStart ?? `.${themeParts.class}`;
+        this.scopeEnd = themeParts.scopeEnd;
+    }
+    add(parts) {
+        if (typeof parts === 'function')
+            parts = parts(this);
+        super.add(parts);
+        return this;
+    }
+    renderHeader() {
+        super.renderHeader();
+        this.builder.addLine(`@scope (${this.scopeStart})${this.scopeEnd ? ` to (${this.scopeEnd})` : ''} {`);
+        this.builder.indentLevel += 1;
+    }
+    renderVariants() {
+        if (Object.keys(this._variants).length === 0)
+            return;
+        this.builder.addLine(`/* variants */`);
+        for (const [variantKey, variantValues] of Object.entries(this._variants)) {
+            for (const [variantName, styles] of Object.entries(variantValues)) {
+                const selector = `&[${variantKey}="${variantName}"]`;
+                this.builder.addRule(selector, styles);
+            }
+        }
+    }
+    renderFooter() {
+        this.renderVariants();
+        this.builder.indentLevel -= 1;
+        this.builder.addLine(`}`);
+        super.renderFooter();
+    }
+    render() {
+        super.render();
+        let result = this;
+        return result;
+    }
+}
+// only for the IDE never instantiated, kept internal
+class ScopeStyles extends BaseStyles {
+    class;
+}

package/dist/State.d.ts

@@ -0,0 +1,36 @@
+export type EqualityFunction<T> = (a: T, b: T) => boolean;
+export declare abstract class BaseState<T = any> {
+    protected _listeners: Array<(data: T) => void>;
+    protected _value: T;
+    protected valueEquals: EqualityFunction<T>;
+    constructor(initialValue: T, equalityFunction?: EqualityFunction<T>);
+    get value(): T;
+    protected internalSetValue(newValue: T): void;
+    subscribe(listener: (data: T) => void): void;
+    unsubscribe(listener: (data: T) => void): void;
+    protected emit(data: T): void;
+    dispose(): void;
+}
+export declare class State<T = any> extends BaseState<T> {
+    constructor(initialValue: T, equals?: EqualityFunction<T>);
+    setValue(newValue: T): void;
+}
+export declare function createState<T>(value: T, equals?: EqualityFunction<T>): State<T>;
+export declare function createState<T>(value?: T, equals?: EqualityFunction<T | undefined>): State<T | undefined>;
+export declare class Effect {
+    private compute;
+    readonly dependencies: Array<BaseState>;
+    readonly recomputeBound: () => Promise<void>;
+    constructor(watch: BaseState | Array<BaseState>, compute: () => void);
+    protected recomputeValue(): Promise<void>;
+    dispose(): void;
+}
+export declare function effect<T>(watch: BaseState | Array<BaseState>, compute: () => T | undefined): Effect;
+export declare class Computed<T = any> extends BaseState<T> {
+    private compute;
+    private readonly effect;
+    constructor(watch: BaseState | Array<BaseState>, compute: () => T, initialValue: T, isValidValue: boolean, equals?: EqualityFunction<T>);
+    dispose(): void;
+}
+export declare function computed<T>(watch: BaseState | Array<BaseState>, compute: () => T, initialValue: T, equals?: EqualityFunction<T>): Computed<T>;
+export declare function computed<T>(watch: BaseState | Array<BaseState>, compute: () => T | undefined, equals?: EqualityFunction<T | undefined>): Computed<T | undefined>;

package/dist/State.js

@@ -0,0 +1,107 @@
+export class BaseState {
+    _listeners = [];
+    _value;
+    valueEquals;
+    constructor(initialValue, equalityFunction) {
+        this._value = initialValue;
+        this.valueEquals = equalityFunction ?? ((a, b) => a === b);
+    }
+    get value() {
+        return this._value;
+    }
+    internalSetValue(newValue) {
+        let previousValue = this._value;
+        if (this.valueEquals(newValue, previousValue))
+            return;
+        this._value = newValue;
+        this.emit(newValue);
+    }
+    subscribe(listener) {
+        this._listeners.push(listener);
+        let currentValue = this._value;
+        listener(currentValue);
+    }
+    unsubscribe(listener) {
+        this._listeners = this._listeners.filter(l => l !== listener);
+    }
+    emit(data) {
+        for (const listener of this._listeners) {
+            listener(data);
+        }
+    }
+    dispose() {
+        this._listeners = [];
+    }
+}
+export class State extends BaseState {
+    constructor(initialValue, equals) {
+        super(initialValue, equals);
+    }
+    setValue(newValue) {
+        super.internalSetValue(newValue);
+    }
+}
+export function createState(value, equals) {
+    return new State(value, equals);
+}
+export class Effect {
+    compute;
+    dependencies;
+    recomputeBound = this.recomputeValue.bind(this);
+    constructor(watch, compute) {
+        this.compute = compute;
+        this.dependencies = Array.isArray(watch) ? watch : [watch];
+        for (let state of this.dependencies) {
+            state.subscribe(this.recomputeBound);
+        }
+    }
+    async recomputeValue() {
+        try {
+            this.compute();
+        }
+        catch (error) {
+            console.error("Error during effect computation:", error);
+        }
+    }
+    dispose() {
+        for (let state of this.dependencies) {
+            state.unsubscribe(this.recomputeBound);
+        }
+    }
+}
+export function effect(watch, compute) {
+    return new Effect(watch, compute);
+}
+export class Computed extends BaseState {
+    compute;
+    effect;
+    constructor(watch, compute, initialValue, isValidValue, equals) {
+        super(initialValue, equals);
+        this.compute = compute;
+        let recompute = () => {
+            const newValue = this.compute();
+            super.internalSetValue(newValue);
+        };
+        this.effect = new Effect(watch, recompute);
+        if (!isValidValue)
+            recompute();
+    }
+    dispose() {
+        this.effect.dispose();
+    }
+}
+export function computed(watch, compute, initialOrEquals, maybeEquals) {
+    if (typeof initialOrEquals === 'function' || initialOrEquals === undefined) {
+        const equals = initialOrEquals;
+        return new Computed(watch, compute, 
+        /*initialValue*/ undefined, 
+        /*isValidValue*/ false, equals);
+    }
+    else {
+        const initialValue = initialOrEquals;
+        const equals = maybeEquals;
+        return new Computed(watch, compute, 
+        /*initialValue*/ initialValue, 
+        /*isValidValue*/ true, equals);
+    }
+}

package/dist/State.test.d.ts

@@ -0,0 +1 @@
+export {};