typewritingclass 0.2.2 → 0.2.3

package/dist/theme/index.d.cts

@@ -0,0 +1,18 @@
+export { c as colors } from '../colors-MvgcZKUW.cjs';
+export { t as typography } from '../typography-C8wipcCK.cjs';
+export { s as sizes } from '../sizes-CS9iz8YG.cjs';
+export { s as shadows } from '../shadows-CWViP1Zk.cjs';
+export { b as borders } from '../borders-pzt8w5Wv.cjs';
+export { ThemeConfig, ThemeResult, ThemeVars, createTheme } from './createTheme.cjs';
+export { i as injectTheme, s as setTheme } from '../inject-theme-CTzyfQH0.cjs';
+
+declare const spacingScale: Record<number, string>;
+declare function resolveSpacing(value: number | string): string;
+
+declare const spacing_resolveSpacing: typeof resolveSpacing;
+declare const spacing_spacingScale: typeof spacingScale;
+declare namespace spacing {
+  export { spacing_resolveSpacing as resolveSpacing, spacing_spacingScale as spacingScale };
+}
+
+export { spacing };

package/dist/theme/index.d.ts

@@ -0,0 +1,18 @@
+export { c as colors } from '../colors-MvgcZKUW.js';
+export { t as typography } from '../typography-C8wipcCK.js';
+export { s as sizes } from '../sizes-CS9iz8YG.js';
+export { s as shadows } from '../shadows-CWViP1Zk.js';
+export { b as borders } from '../borders-pzt8w5Wv.js';
+export { ThemeConfig, ThemeResult, ThemeVars, createTheme } from './createTheme.js';
+export { i as injectTheme, s as setTheme } from '../inject-theme-CTzyfQH0.js';
+
+declare const spacingScale: Record<number, string>;
+declare function resolveSpacing(value: number | string): string;
+
+declare const spacing_resolveSpacing: typeof resolveSpacing;
+declare const spacing_spacingScale: typeof spacingScale;
+declare namespace spacing {
+  export { spacing_resolveSpacing as resolveSpacing, spacing_spacingScale as spacingScale };
+}
+
+export { spacing };

package/dist/theme/index.js

@@ -0,0 +1,35 @@
+import {
+  injectTheme,
+  setTheme,
+  spacing_exports
+} from "../chunk-TAAEIXRF.js";
+import {
+  colors_exports
+} from "../chunk-XEHQXLQR.js";
+import {
+  typography_exports
+} from "../chunk-LARVCDO3.js";
+import {
+  sizes_exports
+} from "../chunk-U2LSMKZS.js";
+import {
+  shadows_exports
+} from "../chunk-IL3LVS32.js";
+import {
+  borders_exports
+} from "../chunk-YHDPOIUZ.js";
+import {
+  createTheme
+} from "../chunk-ATLK64TQ.js";
+import "../chunk-MLKGABMK.js";
+export {
+  borders_exports as borders,
+  colors_exports as colors,
+  createTheme,
+  injectTheme,
+  setTheme,
+  shadows_exports as shadows,
+  sizes_exports as sizes,
+  spacing_exports as spacing,
+  typography_exports as typography
+};

package/dist/theme/shadows.cjs

@@ -0,0 +1,21 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+var _chunk6CEDQ6GFcjs = require('../chunk-6CEDQ6GF.cjs');
+require('../chunk-75ZPJI57.cjs');
+
+
+
+
+
+
+
+
+
+exports.DEFAULT = _chunk6CEDQ6GFcjs.DEFAULT; exports._2xl = _chunk6CEDQ6GFcjs._2xl; exports.inner = _chunk6CEDQ6GFcjs.inner; exports.lg = _chunk6CEDQ6GFcjs.lg; exports.md = _chunk6CEDQ6GFcjs.md; exports.none = _chunk6CEDQ6GFcjs.none; exports.sm = _chunk6CEDQ6GFcjs.sm; exports.xl = _chunk6CEDQ6GFcjs.xl;

package/dist/theme/shadows.d.cts

@@ -0,0 +1 @@
+export { D as DEFAULT, _ as _2xl, i as inner, l as lg, m as md, n as none, a as sm, x as xl } from '../shadows-CWViP1Zk.cjs';

package/dist/theme/shadows.d.ts

@@ -0,0 +1 @@
+export { D as DEFAULT, _ as _2xl, i as inner, l as lg, m as md, n as none, a as sm, x as xl } from '../shadows-CWViP1Zk.js';

package/dist/theme/shadows.js

@@ -0,0 +1,21 @@
+import {
+  DEFAULT,
+  _2xl,
+  inner,
+  lg,
+  md,
+  none,
+  sm,
+  xl
+} from "../chunk-IL3LVS32.js";
+import "../chunk-MLKGABMK.js";
+export {
+  DEFAULT,
+  _2xl,
+  inner,
+  lg,
+  md,
+  none,
+  sm,
+  xl
+};

package/dist/theme/sizes.cjs

@@ -0,0 +1,21 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+var _chunkUUUE7HRNcjs = require('../chunk-UUUE7HRN.cjs');
+require('../chunk-75ZPJI57.cjs');
+
+
+
+
+
+
+
+
+
+exports.auto = _chunkUUUE7HRNcjs.auto; exports.fit = _chunkUUUE7HRNcjs.fit; exports.full = _chunkUUUE7HRNcjs.full; exports.max = _chunkUUUE7HRNcjs.max; exports.maxWidths = _chunkUUUE7HRNcjs.maxWidths; exports.min = _chunkUUUE7HRNcjs.min; exports.screen = _chunkUUUE7HRNcjs.screen; exports.screenH = _chunkUUUE7HRNcjs.screenH;

package/dist/theme/sizes.d.cts

@@ -0,0 +1 @@
+export { a as auto, f as fit, b as full, m as max, c as maxWidths, d as min, e as screen, g as screenH } from '../sizes-CS9iz8YG.cjs';

package/dist/theme/sizes.d.ts

@@ -0,0 +1 @@
+export { a as auto, f as fit, b as full, m as max, c as maxWidths, d as min, e as screen, g as screenH } from '../sizes-CS9iz8YG.js';

package/dist/theme/sizes.js

@@ -0,0 +1,21 @@
+import {
+  auto,
+  fit,
+  full,
+  max,
+  maxWidths,
+  min,
+  screen,
+  screenH
+} from "../chunk-U2LSMKZS.js";
+import "../chunk-MLKGABMK.js";
+export {
+  auto,
+  fit,
+  full,
+  max,
+  maxWidths,
+  min,
+  screen,
+  screenH
+};

package/dist/theme/typography.cjs

@@ -0,0 +1,55 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkUUVUSZJScjs = require('../chunk-UUVUSZJS.cjs');
+require('../chunk-75ZPJI57.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports._2xl = _chunkUUVUSZJScjs._2xl; exports._3xl = _chunkUUVUSZJScjs._3xl; exports._4xl = _chunkUUVUSZJScjs._4xl; exports._5xl = _chunkUUVUSZJScjs._5xl; exports._6xl = _chunkUUVUSZJScjs._6xl; exports._7xl = _chunkUUVUSZJScjs._7xl; exports._8xl = _chunkUUVUSZJScjs._8xl; exports._9xl = _chunkUUVUSZJScjs._9xl; exports.base = _chunkUUVUSZJScjs.base; exports.black_ = _chunkUUVUSZJScjs.black_; exports.bold = _chunkUUVUSZJScjs.bold; exports.extrabold = _chunkUUVUSZJScjs.extrabold; exports.extralight = _chunkUUVUSZJScjs.extralight; exports.fontFamilies = _chunkUUVUSZJScjs.fontFamilies; exports.letterSpacings = _chunkUUVUSZJScjs.letterSpacings; exports.lg = _chunkUUVUSZJScjs.lg; exports.light = _chunkUUVUSZJScjs.light; exports.lineHeights = _chunkUUVUSZJScjs.lineHeights; exports.medium = _chunkUUVUSZJScjs.medium; exports.normal = _chunkUUVUSZJScjs.normal; exports.semibold = _chunkUUVUSZJScjs.semibold; exports.sm = _chunkUUVUSZJScjs.sm; exports.thin = _chunkUUVUSZJScjs.thin; exports.xl = _chunkUUVUSZJScjs.xl; exports.xs = _chunkUUVUSZJScjs.xs;

package/dist/theme/typography.d.cts

@@ -0,0 +1 @@
+export { T as TextSize, _ as _2xl, a as _3xl, b as _4xl, c as _5xl, d as _6xl, e as _7xl, f as _8xl, g as _9xl, h as base, i as black_, j as bold, k as extrabold, l as extralight, m as fontFamilies, n as letterSpacings, o as lg, p as light, q as lineHeights, r as medium, s as normal, u as semibold, v as sm, w as thin, x as xl, y as xs } from '../typography-C8wipcCK.cjs';

package/dist/theme/typography.d.ts

@@ -0,0 +1 @@
+export { T as TextSize, _ as _2xl, a as _3xl, b as _4xl, c as _5xl, d as _6xl, e as _7xl, f as _8xl, g as _9xl, h as base, i as black_, j as bold, k as extrabold, l as extralight, m as fontFamilies, n as letterSpacings, o as lg, p as light, q as lineHeights, r as medium, s as normal, u as semibold, v as sm, w as thin, x as xl, y as xs } from '../typography-C8wipcCK.js';

package/dist/theme/typography.js

@@ -0,0 +1,55 @@
+import {
+  _2xl,
+  _3xl,
+  _4xl,
+  _5xl,
+  _6xl,
+  _7xl,
+  _8xl,
+  _9xl,
+  base,
+  black_,
+  bold,
+  extrabold,
+  extralight,
+  fontFamilies,
+  letterSpacings,
+  lg,
+  light,
+  lineHeights,
+  medium,
+  normal,
+  semibold,
+  sm,
+  thin,
+  xl,
+  xs
+} from "../chunk-LARVCDO3.js";
+import "../chunk-MLKGABMK.js";
+export {
+  _2xl,
+  _3xl,
+  _4xl,
+  _5xl,
+  _6xl,
+  _7xl,
+  _8xl,
+  _9xl,
+  base,
+  black_,
+  bold,
+  extrabold,
+  extralight,
+  fontFamilies,
+  letterSpacings,
+  lg,
+  light,
+  lineHeights,
+  medium,
+  normal,
+  semibold,
+  sm,
+  thin,
+  xl,
+  xs
+};

package/dist/types-FfRD4Hbd.d.cts

@@ -0,0 +1,346 @@
+/**
+ * A wrapper around a runtime-changeable CSS value.
+ *
+ * Instead of baking the value directly into the generated CSS, a
+ * `DynamicValue` is replaced with a CSS custom property reference
+ * (`var(--twc-dN)`). The actual value is applied at runtime through an
+ * inline `style` attribute, allowing it to change without regenerating
+ * the stylesheet.
+ *
+ * Create instances with the {@link dynamic} factory -- do not construct
+ * this interface manually.
+ *
+ * @typeParam T - The underlying value type, constrained to `string | number`.
+ *
+ * @example
+ * ```ts
+ * import { dynamic, bg, dcx } from 'typewritingclass'
+ *
+ * const color = dynamic('#e11d48')
+ * // color._tag    => 'DynamicValue'
+ * // color.__value => '#e11d48'
+ * // color.__id    => '--twc-d0'
+ *
+ * const { className, style } = dcx(bg(color))
+ * // Generated CSS uses var(--twc-d0) instead of the literal color.
+ * // style maps '--twc-d0' to '#e11d48' for the inline style attribute.
+ * ```
+ */
+interface DynamicValue<T extends string | number = string | number> {
+    /** Discriminant tag for runtime type checking. Always `'DynamicValue'`. */
+    _tag: 'DynamicValue';
+    /** The current runtime value (e.g. `'#e11d48'` or `16`). */
+    __value: T;
+    /** The generated CSS custom property name (e.g. `'--twc-d0'`). */
+    __id: string;
+}
+/**
+ * Wraps a value so it becomes a runtime-dynamic CSS custom property.
+ *
+ * The returned {@link DynamicValue} can be passed to any utility that
+ * accepts `DynamicValue` (e.g. `bg`, `p`, `textColor`, `rounded`). When
+ * composed via {@link dcx}, the value is not inlined into the CSS rule;
+ * instead a `var(--twc-dN)` reference is emitted, and the concrete value
+ * is placed in the `style` object so it can be changed at runtime without
+ * touching the stylesheet.
+ *
+ * Each call to `dynamic` allocates a new, globally unique custom property
+ * name (`--twc-d0`, `--twc-d1`, ...).
+ *
+ * @typeParam T - Inferred from the provided value; constrained to `string | number`.
+ * @param value - The initial CSS value (e.g. a color hex string, a pixel value, etc.).
+ * @returns A {@link DynamicValue} wrapping the given value with a unique CSS
+ *          custom property identifier.
+ *
+ * @example Dynamic background color in React
+ * ```ts
+ * import { dcx, bg, p, dynamic } from 'typewritingclass'
+ *
+ * function Banner({ color }: { color: string }) {
+ *   const { className, style } = dcx(p(4), bg(dynamic(color)))
+ *   return <div className={className} style={style} />
+ * }
+ * // CSS: ._xyz { background-color: var(--twc-d0); padding: 1rem; }
+ * // Inline style: --twc-d0: <whatever `color` is at render time>
+ * ```
+ *
+ * @example Dynamic spacing
+ * ```ts
+ * import { dcx, p, dynamic } from 'typewritingclass'
+ *
+ * const spacing = dynamic('2.5rem')
+ * const { className, style } = dcx(p(spacing))
+ * // className => "_a1b2c"
+ * // style     => { '--twc-d0': '2.5rem' }
+ * // CSS: ._a1b2c { padding: var(--twc-d0); }
+ * ```
+ */
+declare function dynamic<T extends string | number>(value: T): DynamicValue<T>;
+/**
+ * Type-guard that checks whether an unknown value is a {@link DynamicValue}.
+ *
+ * Useful inside utilities and the `css` tagged-template implementation to
+ * decide whether to emit a `var()` reference or inline the value directly.
+ *
+ * @param v - Any value to test.
+ * @returns `true` if `v` is a `DynamicValue`, narrowing its type accordingly.
+ *
+ * @example
+ * ```ts
+ * import { dynamic, isDynamic } from 'typewritingclass'
+ *
+ * const val = dynamic('#ff0000')
+ * isDynamic(val)       // => true
+ * isDynamic('#ff0000') // => false
+ * isDynamic(42)        // => false
+ * isDynamic(null)      // => false
+ * ```
+ */
+declare function isDynamic(v: unknown): v is DynamicValue;
+
+declare const __brand: unique symbol;
+/**
+ * Creates a nominal/branded type from a base type.
+ *
+ * Branded types look like their base type at runtime but are distinct at the
+ * type level, preventing accidental misuse (e.g. passing a color where a
+ * spacing value is expected).
+ *
+ * @example
+ * ```ts
+ * type Meters = Brand<number, 'meters'>
+ * type Seconds = Brand<number, 'seconds'>
+ *
+ * const d: Meters = 5 as Meters
+ * const t: Seconds = d // Type error — distinct brands!
+ * ```
+ */
+type Brand<T, B extends string> = T & {
+    readonly [__brand]: B;
+};
+/**
+ * A branded CSS color value — hex, `rgb()`, `hsl()`, CSS variable, etc.
+ *
+ * Theme color tokens (e.g. `blue[500]`) carry this brand. Raw color strings
+ * are also accepted alongside `CSSColor` since utility functions accept both.
+ */
+type CSSColor = Brand<string, 'css-color'>;
+/**
+ * A branded CSS length value — `rem`, `px`, `em`, `%`, `vh`, `vw`, etc.
+ *
+ * Theme spacing, size, and border-radius tokens carry this brand.
+ */
+type CSSLength = Brand<string, 'css-length'>;
+/**
+ * A branded CSS shadow value — `box-shadow` definition string.
+ *
+ * Theme shadow tokens (e.g. `lg` from `theme/shadows`) carry this brand.
+ */
+type CSSShadow = Brand<string, 'css-shadow'>;
+/**
+ * A branded CSS font-weight value — numeric string like `'400'` or `'700'`.
+ *
+ * Theme font weight tokens (e.g. `bold`, `semibold`) carry this brand.
+ */
+type CSSFontWeight = Brand<string, 'css-font-weight'>;
+/** Shorthand for any DynamicValue — used in utility input types. */
+type DynamicValueAny = DynamicValue;
+/**
+ * Input type for color utilities ({@link bg}, {@link textColor}, {@link borderColor}).
+ *
+ * Accepts theme color tokens (`CSSColor`), raw CSS color strings, or dynamic values.
+ */
+type ColorInput = CSSColor | string | DynamicValueAny;
+/**
+ * Input type for spacing utilities ({@link p}, {@link m}, {@link gap}).
+ *
+ * Accepts a theme scale number (`4` → `1rem`), a raw CSS length string
+ * (`'1.5rem'`), a theme length token, or a dynamic value.
+ */
+type SpacingInput = number | CSSLength | string | DynamicValueAny;
+/**
+ * Input type for size utilities ({@link w}, {@link h}, {@link minW}).
+ *
+ * Accepts a theme scale number, a raw CSS string (`'100%'`), a theme size
+ * token (`full`, `screen`), or a dynamic value.
+ */
+type SizeInput = number | CSSLength | string | DynamicValueAny;
+/**
+ * Input type for border-radius utilities ({@link rounded}).
+ *
+ * Accepts a theme radius token (`lg`), a raw CSS string, or a dynamic value.
+ */
+type RadiusInput = CSSLength | string | DynamicValueAny;
+/**
+ * Input type for shadow utilities ({@link shadow}).
+ *
+ * Accepts a theme shadow token (`lg`), a raw CSS string, or a dynamic value.
+ */
+type ShadowInput = CSSShadow | string | DynamicValueAny;
+/**
+ * A self-contained CSS rule produced by utility functions, the {@link css}
+ * helper, or modifier composition.
+ *
+ * `StyleRule` is the fundamental unit of the typewritingclass system. Every
+ * utility (`p`, `bg`, `rounded`, ...) returns a `StyleRule`, and composing
+ * functions like `cx` and `dcx` consume them to generate class names and
+ * register CSS in the global stylesheet.
+ *
+ * You rarely need to construct a `StyleRule` by hand -- use the provided
+ * utilities or the `css` tagged-template helper instead.
+ *
+ * @example Inspecting a rule returned by a utility
+ * ```ts
+ * import { p } from 'typewritingclass'
+ *
+ * const rule = p(4)
+ * // rule.declarations  => { padding: '1rem' }
+ * // rule.selectors      => []
+ * // rule.mediaQueries   => []
+ * ```
+ *
+ * @example A rule wrapped with a modifier
+ * ```ts
+ * import { p, hover } from 'typewritingclass'
+ *
+ * const rule = hover(p(4))
+ * // rule.selectors => [':hover']
+ * // CSS: .className:hover { padding: 1rem; }
+ * ```
+ */
+interface StyleRule {
+    /** Discriminant tag used for runtime type narrowing. Always `'StyleRule'`. */
+    _tag: 'StyleRule';
+    /**
+     * A map of CSS property-value pairs that this rule will emit.
+     *
+     * Keys are CSS property names (e.g. `'padding'`, `'background-color'`),
+     * and values are their corresponding CSS values (e.g. `'1rem'`, `'#3b82f6'`).
+     */
+    declarations: Record<string, string>;
+    /**
+     * Pseudo-class or pseudo-element selectors appended to the generated
+     * class name (e.g. `[':hover']`, `[':focus', ':active']`).
+     *
+     * An empty array means the rule applies unconditionally.
+     */
+    selectors: string[];
+    /**
+     * Media query strings that wrap the generated rule
+     * (e.g. `['(min-width: 768px)']`).
+     *
+     * An empty array means no `@media` wrapper is emitted.
+     */
+    mediaQueries: string[];
+    /**
+     * CSS custom property bindings for dynamic (runtime-changeable) values.
+     *
+     * When present, the generated CSS references `var(--twc-dN)` and these
+     * bindings must be applied as inline `style` on the element (via `dcx`).
+     * Keys are CSS custom property names (e.g. `'--twc-d0'`), values are
+     * the current runtime values (e.g. `'#ff0000'`).
+     */
+    dynamicBindings?: Record<string, string>;
+    /**
+     * `@supports` query strings that wrap the generated rule
+     * (e.g. `['(display: grid)']`).
+     *
+     * An empty array means no `@supports` wrapper is emitted.
+     */
+    supportsQueries: string[];
+    /**
+     * Optional selector template that wraps the generated class name in a
+     * more complex selector pattern. The `&` character is replaced with the
+     * generated `.className` at render time.
+     *
+     * Used for utilities like `spaceX`/`spaceY` (child combinator selectors),
+     * `group-*` / `peer-*` modifiers, and `rtl`/`ltr` direction modifiers.
+     *
+     * @example
+     * ```ts
+     * // spaceX uses: '& > :not([hidden]) ~ :not([hidden])'
+     * // group-hover uses: '.group:hover &'
+     * ```
+     */
+    selectorTemplate?: string;
+}
+/**
+ * A function that accepts a design-token value and returns a {@link StyleRule}.
+ *
+ * Every spacing, color, typography, and layout helper (`p`, `bg`, `text`, ...)
+ * satisfies this signature. The `value` parameter is intentionally `any` so
+ * that individual utilities can narrow it to their own accepted types
+ * (e.g. `number | string | DynamicValue`).
+ *
+ * @param value - The design-token or raw CSS value to apply.
+ * @returns A {@link StyleRule} containing the appropriate CSS declarations.
+ *
+ * @example
+ * ```ts
+ * import type { Utility } from 'typewritingclass'
+ * import { p } from 'typewritingclass'
+ *
+ * // `p` satisfies the Utility signature:
+ * const myUtility: Utility = p
+ * const rule = myUtility(4)
+ * // CSS: padding: 1rem;
+ * ```
+ */
+type Utility = (value: any) => StyleRule;
+/**
+ * A function that transforms a {@link StyleRule} by wrapping it with a
+ * pseudo-class selector or a media query.
+ *
+ * Modifiers are composable -- you can chain them via {@link when} to build
+ * multi-condition rules (e.g. "on hover, at medium breakpoint").
+ *
+ * @param rule - The source {@link StyleRule} to transform.
+ * @returns A new {@link StyleRule} with additional selectors or media queries.
+ *
+ * @example
+ * ```ts
+ * import type { Modifier } from 'typewritingclass'
+ * import { hover, md } from 'typewritingclass'
+ *
+ * // `hover` and `md` are both Modifiers:
+ * const hoverMod: Modifier = hover
+ * const mdMod: Modifier = md
+ * ```
+ */
+type Modifier = (rule: StyleRule) => StyleRule;
+/**
+ * The return value of {@link dcx}, containing both a class string and an
+ * inline `style` object for dynamic CSS custom-property bindings.
+ *
+ * Use this when your styles include runtime-changeable values created with
+ * {@link dynamic}. The `className` goes on the element's class attribute, and
+ * `style` must be spread onto the element's inline style so the CSS custom
+ * properties are set.
+ *
+ * @example
+ * ```ts
+ * import { dcx, bg, dynamic } from 'typewritingclass'
+ *
+ * const color = dynamic('#ff0000')
+ * const result = dcx(bg(color))
+ * // result.className => "_a1b2c"
+ * // result.style     => { '--twc-d0': '#ff0000' }
+ *
+ * // In JSX:
+ * // <div className={result.className} style={result.style} />
+ * // CSS: .\_a1b2c { background-color: var(--twc-d0); }
+ * ```
+ */
+interface DynamicResult {
+    /** A space-separated string of generated CSS class names, ready for `className` or `class`. */
+    className: string;
+    /**
+     * An object of CSS custom property assignments to apply as inline styles.
+     *
+     * Keys are custom property names (e.g. `'--twc-d0'`), values are the
+     * current runtime values (e.g. `'#ff0000'`, `'1.5rem'`).
+     */
+    style: Record<string, string>;
+}
+
+export { type Brand as B, type CSSColor as C, type DynamicResult as D, type Modifier as M, type RadiusInput as R, type StyleRule as S, type Utility as U, type DynamicValue as a, type CSSFontWeight as b, type CSSLength as c, type CSSShadow as d, type ColorInput as e, type ShadowInput as f, type SizeInput as g, type SpacingInput as h, dynamic as i, isDynamic as j };