calame 0.0.1

package/dist/constants.d.ts

@@ -0,0 +1,33 @@
+import type { LookupItem } from './types';
+/** @internal */
+export declare const DEFINITION_LOOKUP_TABLE: Record<string, LookupItem>;
+/** @internal */
+export declare const DATA_BUCKET_ATTR = "data-make-styles-bucket";
+/** @internal */
+export declare const DATA_PRIORITY_ATTR = "data-priority";
+/** @internal */
+export declare const HASH_PREFIX = "f";
+/** @internal */
+export declare const RESET_HASH_PREFIX = "r";
+/** @internal */
+export declare const SEQUENCE_HASH_LENGTH = 7;
+/** @internal */
+export declare const SEQUENCE_PREFIX = "___";
+/** @internal */
+export declare const SEQUENCE_SIZE: number;
+/** @internal */
+export declare const LOOKUP_DEFINITIONS_INDEX = 0;
+/** @internal */
+export declare const LOOKUP_DIR_INDEX = 1;
+/**
+ * CSS shorthands that are not supported — they must be expanded to longhands.
+ * @internal
+ */
+export declare const UNSUPPORTED_CSS_PROPERTIES: Record<string, 1>;
+/**
+ * Sentinel value that resets a CSS property (removes the generated class).
+ * Do not use directly — use the `RESET` export from the public API.
+ * @internal
+ */
+export declare const RESET: "unset";
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAgB,MAAM,SAAS,CAAC;AAiBxD,gBAAgB;AAChB,eAAO,MAAM,uBAAuB,4BAAgF,CAAC;AAIrH,gBAAgB;AAChB,eAAO,MAAM,gBAAgB,4BAA4B,CAAC;AAE1D,gBAAgB;AAChB,eAAO,MAAM,kBAAkB,kBAAkB,CAAC;AAElD,gBAAgB;AAChB,eAAO,MAAM,WAAW,MAAM,CAAC;AAE/B,gBAAgB;AAChB,eAAO,MAAM,iBAAiB,MAAM,CAAC;AAErC,gBAAgB;AAChB,eAAO,MAAM,oBAAoB,IAAI,CAAC;AAEtC,gBAAgB;AAChB,eAAO,MAAM,eAAe,QAAQ,CAAC;AAErC,gBAAgB;AAChB,eAAO,MAAM,aAAa,QAAgD,CAAC;AAG3E,gBAAgB;AAChB,eAAO,MAAM,wBAAwB,IAAI,CAAC;AAE1C,gBAAgB;AAChB,eAAO,MAAM,gBAAgB,IAAI,CAAC;AAElC;;;GAGG;AACH,eAAO,MAAM,0BAA0B,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAW/C,CAAC;AAEX;;;;GAIG;AACH,eAAO,MAAM,KAAK,EAA4D,OAAO,CAAC"}

package/dist/constants.js

@@ -0,0 +1,56 @@
+// ----
+// These constants are global and shared between Calame instances.
+// Any change should happen only in a MAJOR version.
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const __GLOBAL__ = typeof globalThis !== 'undefined' ? globalThis : window;
+const __NAMESPACE_PREFIX__ = '@calame/';
+function getGlobalVar(name, defaultValue) {
+    if (!__GLOBAL__[Symbol.for(__NAMESPACE_PREFIX__ + name)]) {
+        __GLOBAL__[Symbol.for(__NAMESPACE_PREFIX__ + name)] = defaultValue;
+    }
+    return __GLOBAL__[Symbol.for(__NAMESPACE_PREFIX__ + name)];
+}
+/** @internal */
+export const DEFINITION_LOOKUP_TABLE = getGlobalVar('DEFINITION_LOOKUP_TABLE', {});
+// ----
+/** @internal */
+export const DATA_BUCKET_ATTR = 'data-make-styles-bucket';
+/** @internal */
+export const DATA_PRIORITY_ATTR = 'data-priority';
+/** @internal */
+export const HASH_PREFIX = 'f';
+/** @internal */
+export const RESET_HASH_PREFIX = 'r';
+/** @internal */
+export const SEQUENCE_HASH_LENGTH = 7;
+/** @internal */
+export const SEQUENCE_PREFIX = '___';
+/** @internal */
+export const SEQUENCE_SIZE = SEQUENCE_PREFIX.length + SEQUENCE_HASH_LENGTH;
+// Indexes for values in LookupItem tuple
+/** @internal */
+export const LOOKUP_DEFINITIONS_INDEX = 0;
+/** @internal */
+export const LOOKUP_DIR_INDEX = 1;
+/**
+ * CSS shorthands that are not supported — they must be expanded to longhands.
+ * @internal
+ */
+export const UNSUPPORTED_CSS_PROPERTIES = {
+    all: 1,
+    borderColor: 1,
+    borderStyle: 1,
+    borderWidth: 1,
+    borderBlock: 1,
+    borderBlockEnd: 1,
+    borderBlockStart: 1,
+    borderInline: 1,
+    borderInlineEnd: 1,
+    borderInlineStart: 1,
+};
+/**
+ * Sentinel value that resets a CSS property (removes the generated class).
+ * Do not use directly — use the `RESET` export from the public API.
+ * @internal
+ */
+export const RESET = 'DO_NOT_USE_DIRECTLY: @calame/reset-value';

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export { makeStyles } from './makeStyles';
+export type { MakeStylesOptions } from './makeStyles';
+export { makeResetStyles } from './makeResetStyles';
+export type { MakeResetStylesOptions } from './makeResetStyles';
+export { makeStaticStyles } from './makeStaticStyles';
+export type { MakeStaticStylesOptions } from './makeStaticStyles';
+export { mergeClasses } from './mergeClasses';
+export { RESET } from './constants';
+export type { CalameRenderer, CalameInsertionFactory, CalameAnimation, CalameStylesCSSValue, CalameStylesCSSProperties, CalameStylesStrictCSSObject, CalameStylesCSSObjectCustom, CalameStyle, CalameResetStyle, CalameStaticStyle, CalameStaticStyles, StylesBySlots, StyleBucketName, CSSRulesByBucket, IsomorphicStyleSheet, } from './types';
+//# 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":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,YAAY,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAEtD,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,YAAY,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAEhE,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,YAAY,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AAElE,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAGpC,YAAY,EACR,cAAc,EACd,sBAAsB,EACtB,eAAe,EACf,oBAAoB,EACpB,yBAAyB,EACzB,2BAA2B,EAC3B,2BAA2B,EAC3B,WAAW,EACX,gBAAgB,EAChB,iBAAiB,EACjB,kBAAkB,EAClB,aAAa,EACb,eAAe,EACf,gBAAgB,EAChB,oBAAoB,GACvB,MAAM,SAAS,CAAC"}

package/dist/index.js

@@ -0,0 +1,6 @@
+// Public API
+export { makeStyles } from './makeStyles';
+export { makeResetStyles } from './makeResetStyles';
+export { makeStaticStyles } from './makeStaticStyles';
+export { mergeClasses } from './mergeClasses';
+export { RESET } from './constants';

package/dist/insertionFactory.d.ts

@@ -0,0 +1,3 @@
+import type { CalameInsertionFactory } from './types';
+export declare const insertionFactory: CalameInsertionFactory;
+//# sourceMappingURL=insertionFactory.d.ts.map

package/dist/insertionFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"insertionFactory.d.ts","sourceRoot":"","sources":["../src/insertionFactory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAoB,sBAAsB,EAAkB,MAAM,SAAS,CAAC;AAExF,eAAO,MAAM,gBAAgB,EAAE,sBAS9B,CAAC"}

package/dist/insertionFactory.js

@@ -0,0 +1,9 @@
+export const insertionFactory = () => {
+    const insertionCache = {};
+    return function insertStyles(renderer, cssRules) {
+        if (insertionCache[renderer.id] === undefined) {
+            renderer.insertCSSRules(cssRules);
+            insertionCache[renderer.id] = true;
+        }
+    };
+};

package/dist/makeResetStyles.d.ts

@@ -0,0 +1,7 @@
+import type { CalameInsertionFactory, CalameRenderer, CalameResetStyle } from './types';
+export interface MakeResetStylesOptions {
+    dir: 'ltr' | 'rtl';
+    renderer: CalameRenderer;
+}
+export declare function makeResetStyles(styles: CalameResetStyle, factory?: CalameInsertionFactory): (options: MakeResetStylesOptions) => string;
+//# sourceMappingURL=makeResetStyles.d.ts.map

package/dist/makeResetStyles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"makeResetStyles.d.ts","sourceRoot":"","sources":["../src/makeResetStyles.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAoB,sBAAsB,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAE1G,MAAM,WAAW,sBAAsB;IACnC,GAAG,EAAE,KAAK,GAAG,KAAK,CAAC;IACnB,QAAQ,EAAE,cAAc,CAAC;CAC5B;AAED,wBAAgB,eAAe,CAC3B,MAAM,EAAE,gBAAgB,EACxB,OAAO,GAAE,sBAAyC,aAQf,sBAAsB,KAAG,MAAM,CAarE"}

package/dist/makeResetStyles.js

@@ -0,0 +1,17 @@
+import { insertionFactory } from './insertionFactory';
+import { resolveResetStyleRules } from './runtime/resolveResetStyleRules';
+export function makeResetStyles(styles, factory = insertionFactory) {
+    const insertStyles = factory();
+    let ltrClassName = null;
+    let rtlClassName = null;
+    let cssRules = null;
+    function computeClassName(options) {
+        const { dir, renderer } = options;
+        if (ltrClassName === null) {
+            [ltrClassName, rtlClassName, cssRules] = resolveResetStyleRules(styles, renderer.classNameHashSalt);
+        }
+        insertStyles(renderer, Array.isArray(cssRules) ? { r: cssRules } : cssRules);
+        return dir === 'ltr' ? ltrClassName : (rtlClassName ?? ltrClassName);
+    }
+    return computeClassName;
+}

package/dist/makeStaticStyles.d.ts

@@ -0,0 +1,6 @@
+import type { CalameInsertionFactory, CalameRenderer, CalameStaticStyle } from './types';
+export interface MakeStaticStylesOptions {
+    renderer: CalameRenderer;
+}
+export declare function makeStaticStyles(styles: CalameStaticStyle | CalameStaticStyle[], factory?: CalameInsertionFactory): (options: MakeStaticStylesOptions) => void;
+//# sourceMappingURL=makeStaticStyles.d.ts.map

package/dist/makeStaticStyles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"makeStaticStyles.d.ts","sourceRoot":"","sources":["../src/makeStaticStyles.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,sBAAsB,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAEzF,MAAM,WAAW,uBAAuB;IACpC,QAAQ,EAAE,cAAc,CAAC;CAC5B;AAED,wBAAgB,gBAAgB,CAC5B,MAAM,EAAE,iBAAiB,GAAG,iBAAiB,EAAE,EAC/C,OAAO,GAAE,sBAAyC,aAKhB,uBAAuB,KAAG,IAAI,CAMnE"}

package/dist/makeStaticStyles.js

@@ -0,0 +1,11 @@
+import { insertionFactory } from './insertionFactory';
+import { resolveStaticStyleRules } from './runtime/resolveStaticStyleRules';
+export function makeStaticStyles(styles, factory = insertionFactory) {
+    const insertStyles = factory();
+    const stylesSet = Array.isArray(styles) ? styles : [styles];
+    function useStaticStyles(options) {
+        // Static rules are inserted into the default bucket
+        insertStyles(options.renderer, { d: resolveStaticStyleRules(stylesSet) });
+    }
+    return useStaticStyles;
+}

package/dist/makeStyles.d.ts

@@ -0,0 +1,7 @@
+import type { StylesBySlots, CalameInsertionFactory, CalameRenderer } from './types';
+export interface MakeStylesOptions {
+    dir: 'ltr' | 'rtl';
+    renderer: CalameRenderer;
+}
+export declare function makeStyles<Slots extends string | number>(stylesBySlots: StylesBySlots<Slots>, factory?: CalameInsertionFactory): (options: MakeStylesOptions) => Record<Slots, string>;
+//# sourceMappingURL=makeStyles.d.ts.map

package/dist/makeStyles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"makeStyles.d.ts","sourceRoot":"","sources":["../src/makeStyles.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAyC,aAAa,EAAE,sBAAsB,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE5H,MAAM,WAAW,iBAAiB;IAC9B,GAAG,EAAE,KAAK,GAAG,KAAK,CAAC;IACnB,QAAQ,EAAE,cAAc,CAAC;CAC5B;AAED,wBAAgB,UAAU,CAAC,KAAK,SAAS,MAAM,GAAG,MAAM,EACpD,aAAa,EAAE,aAAa,CAAC,KAAK,CAAC,EACnC,OAAO,GAAE,sBAAyC,aAUjB,iBAAiB,KAAG,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,CA2B7E"}

package/dist/makeStyles.js

@@ -0,0 +1,32 @@
+import { insertionFactory } from './insertionFactory';
+import { resolveStyleRulesForSlots } from './resolveStyleRulesForSlots';
+import { reduceToClassNameForSlots } from './runtime/reduceToClassNameForSlots';
+export function makeStyles(stylesBySlots, factory = insertionFactory) {
+    const insertStyles = factory();
+    let classesMapBySlot = null;
+    let cssRules = null;
+    let ltrClassNamesForSlots = null;
+    let rtlClassNamesForSlots = null;
+    function computeClasses(options) {
+        const { dir, renderer } = options;
+        if (classesMapBySlot === null) {
+            [classesMapBySlot, cssRules] = resolveStyleRulesForSlots(stylesBySlots, renderer.classNameHashSalt);
+        }
+        const isLTR = dir === 'ltr';
+        if (isLTR) {
+            if (ltrClassNamesForSlots === null) {
+                ltrClassNamesForSlots = reduceToClassNameForSlots(classesMapBySlot, dir);
+            }
+        }
+        else {
+            if (rtlClassNamesForSlots === null) {
+                rtlClassNamesForSlots = reduceToClassNameForSlots(classesMapBySlot, dir);
+            }
+        }
+        insertStyles(renderer, cssRules);
+        return isLTR
+            ? ltrClassNamesForSlots
+            : rtlClassNamesForSlots;
+    }
+    return computeClasses;
+}

package/dist/mergeClasses.d.ts

@@ -0,0 +1,3 @@
+export declare const mergeClassesCachedResults: Record<string, string>;
+export declare function mergeClasses(...classNames: (string | false | undefined)[]): string;
+//# sourceMappingURL=mergeClasses.d.ts.map

package/dist/mergeClasses.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mergeClasses.d.ts","sourceRoot":"","sources":["../src/mergeClasses.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,yBAAyB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAM,CAAC;AAEpE,wBAAgB,YAAY,CAAC,GAAG,UAAU,EAAE,CAAC,MAAM,GAAG,KAAK,GAAG,SAAS,CAAC,EAAE,GAAG,MAAM,CAAC"}

package/dist/mergeClasses.js

@@ -0,0 +1,63 @@
+import { DEFINITION_LOOKUP_TABLE, LOOKUP_DEFINITIONS_INDEX, LOOKUP_DIR_INDEX, SEQUENCE_PREFIX, SEQUENCE_SIZE, } from './constants';
+import { hashSequence } from './runtime/utils/hashSequence';
+import { reduceToClassName } from './runtime/reduceToClassNameForSlots';
+// Cache of previously resolved merged class sequences to avoid redundant work
+export const mergeClassesCachedResults = {};
+export function mergeClasses() {
+    // arguments are parsed manually to avoid the extra loop Babel/TS add for rest params
+    /* eslint-disable prefer-rest-params */
+    let dir = null;
+    let resultClassName = '';
+    // Key used to look up / store in the cache
+    let sequenceMatch = '';
+    for (let i = 0; i < arguments.length; i++) {
+        const className = arguments[i];
+        if (typeof className === 'string' && className !== '') {
+            const sequenceIndex = className.indexOf(SEQUENCE_PREFIX);
+            if (sequenceIndex === -1) {
+                // Plain class name (not from makeStyles) — pass through as-is
+                resultClassName += className + ' ';
+            }
+            else {
+                // Handles mixed strings like "ui-button ATOMIC_CLASSES"
+                if (sequenceIndex > 0) {
+                    resultClassName += className.slice(0, sequenceIndex);
+                }
+                sequenceMatch += className.substr(sequenceIndex, SEQUENCE_SIZE);
+            }
+        }
+    }
+    // No atomic classes — just trim the trailing space and return
+    if (sequenceMatch === '') {
+        return resultClassName.slice(0, -1);
+    }
+    // Return cached result if this exact combination was seen before
+    const cached = mergeClassesCachedResults[sequenceMatch];
+    if (cached !== undefined) {
+        return resultClassName + cached;
+    }
+    // Collect the CSSClassesMap for every atomic sequence, in order
+    const sequenceMappings = [];
+    for (let i = 0; i < arguments.length; i++) {
+        const className = arguments[i];
+        if (typeof className !== 'string' || className === '')
+            continue;
+        const sequenceIndex = className.indexOf(SEQUENCE_PREFIX);
+        if (sequenceIndex === -1)
+            continue;
+        const sequenceId = className.substr(sequenceIndex, SEQUENCE_SIZE);
+        const sequenceMapping = DEFINITION_LOOKUP_TABLE[sequenceId];
+        if (sequenceMapping) {
+            sequenceMappings.push(sequenceMapping[LOOKUP_DEFINITIONS_INDEX]);
+            dir = sequenceMapping[LOOKUP_DIR_INDEX];
+        }
+    }
+    // Merge all maps left-to-right so later slots win (last-write-wins per property hash)
+    const resultClassesMap = Object.assign({}, ...sequenceMappings);
+    const [atomicClasses, classesMapHash] = reduceToClassName(resultClassesMap, dir);
+    const newSequenceHash = hashSequence(classesMapHash, dir);
+    const newClassName = newSequenceHash + ' ' + atomicClasses;
+    mergeClassesCachedResults[sequenceMatch] = newClassName;
+    DEFINITION_LOOKUP_TABLE[newSequenceHash] = [resultClassesMap, dir];
+    return resultClassName + newClassName;
+}

package/dist/resolveStyleRulesForSlots.d.ts

@@ -0,0 +1,6 @@
+import type { CSSClassesMapBySlot, CSSRulesByBucket, StylesBySlots } from './types';
+/**
+ * Calls resolveStyleRules() for each slot. Also used by build-time transforms.
+ */
+export declare function resolveStyleRulesForSlots<Slots extends string | number>(stylesBySlots: StylesBySlots<Slots>, classNameHashSalt?: string): [CSSClassesMapBySlot<Slots>, CSSRulesByBucket];
+//# sourceMappingURL=resolveStyleRulesForSlots.d.ts.map

package/dist/resolveStyleRulesForSlots.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveStyleRulesForSlots.d.ts","sourceRoot":"","sources":["../src/resolveStyleRulesForSlots.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,gBAAgB,EAAmB,aAAa,EAAE,MAAM,SAAS,CAAC;AAErG;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,SAAS,MAAM,GAAG,MAAM,EACnE,aAAa,EAAE,aAAa,CAAC,KAAK,CAAC,EACnC,iBAAiB,GAAE,MAAW,GAC/B,CAAC,mBAAmB,CAAC,KAAK,CAAC,EAAE,gBAAgB,CAAC,CAgBhD"}

package/dist/resolveStyleRulesForSlots.js

@@ -0,0 +1,17 @@
+import { resolveStyleRules } from './runtime/resolveStyleRules';
+/**
+ * Calls resolveStyleRules() for each slot. Also used by build-time transforms.
+ */
+export function resolveStyleRulesForSlots(stylesBySlots, classNameHashSalt = '') {
+    const classesMapBySlot = {};
+    const cssRules = {};
+    // eslint-disable-next-line guard-for-in
+    for (const slotName in stylesBySlots) {
+        const [cssClassMap, cssRulesByBucket] = resolveStyleRules(stylesBySlots[slotName], classNameHashSalt);
+        classesMapBySlot[slotName] = cssClassMap;
+        Object.keys(cssRulesByBucket).forEach(bucketName => {
+            cssRules[bucketName] = (cssRules[bucketName] || []).concat(cssRulesByBucket[bucketName]);
+        });
+    }
+    return [classesMapBySlot, cssRules];
+}

package/dist/runtime/compileAtomicCSSRule.d.ts

@@ -0,0 +1,13 @@
+import type { AtRules } from './utils/types';
+export interface CompileAtomicCSSOptions {
+    className: string;
+    selectors: string[];
+    property: string;
+    value: number | string | Array<number | string>;
+    rtlClassName?: string;
+    rtlProperty?: string;
+    rtlValue?: number | string | Array<number | string>;
+}
+export declare function normalizePseudoSelector(pseudoSelector: string): string;
+export declare function compileAtomicCSSRule(options: CompileAtomicCSSOptions, atRules: AtRules): [string?, string?];
+//# sourceMappingURL=compileAtomicCSSRule.d.ts.map

package/dist/runtime/compileAtomicCSSRule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compileAtomicCSSRule.d.ts","sourceRoot":"","sources":["../../src/runtime/compileAtomicCSSRule.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAG7C,MAAM,WAAW,uBAAuB;IACpC,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC;IAChD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC;CACvD;AAID,wBAAgB,uBAAuB,CAAC,cAAc,EAAE,MAAM,GAAG,MAAM,CAEtE;AAcD,wBAAgB,oBAAoB,CAChC,OAAO,EAAE,uBAAuB,EAChC,OAAO,EAAE,OAAO,GACjB,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,CAAC,CA0BpB"}

package/dist/runtime/compileAtomicCSSRule.js

@@ -0,0 +1,41 @@
+import { hyphenateProperty } from './utils/hyphenateProperty';
+import { normalizeNestedProperty } from './utils/normalizeNestedProperty';
+import { compileCSSRules } from './compileCSSRules';
+const PSEUDO_SELECTOR_REGEX = /,( *[^ &])/g;
+export function normalizePseudoSelector(pseudoSelector) {
+    return '&' + normalizeNestedProperty(pseudoSelector.replace(PSEUDO_SELECTOR_REGEX, ',&$1'));
+}
+function createCSSRule(classNameSelector, cssDeclaration, pseudos) {
+    let cssRule = cssDeclaration;
+    if (pseudos.length > 0) {
+        cssRule = pseudos.reduceRight((acc, selector) => {
+            return `${normalizePseudoSelector(selector)} { ${acc} }`;
+        }, cssDeclaration);
+    }
+    return `${classNameSelector}{${cssRule}}`;
+}
+export function compileAtomicCSSRule(options, atRules) {
+    const { className, selectors, property, rtlClassName, rtlProperty, rtlValue, value } = options;
+    const { container, layer, media, supports } = atRules;
+    const classNameSelector = `.${className}`;
+    const cssDeclaration = Array.isArray(value)
+        ? `${value.map(v => `${hyphenateProperty(property)}: ${v}`).join(';')};`
+        : `${hyphenateProperty(property)}: ${value};`;
+    let cssRule = createCSSRule(classNameSelector, cssDeclaration, selectors);
+    if (rtlProperty && rtlClassName) {
+        const rtlClassNameSelector = `.${rtlClassName}`;
+        const rtlCSSDeclaration = Array.isArray(rtlValue)
+            ? `${rtlValue.map(v => `${hyphenateProperty(rtlProperty)}: ${v}`).join(';')};`
+            : `${hyphenateProperty(rtlProperty)}: ${rtlValue};`;
+        cssRule += createCSSRule(rtlClassNameSelector, rtlCSSDeclaration, selectors);
+    }
+    if (media)
+        cssRule = `@media ${media} { ${cssRule} }`;
+    if (layer)
+        cssRule = `@layer ${layer} { ${cssRule} }`;
+    if (supports)
+        cssRule = `@supports ${supports} { ${cssRule} }`;
+    if (container)
+        cssRule = `@container ${container} { ${cssRule} }`;
+    return compileCSSRules(cssRule, true);
+}

package/dist/runtime/compileCSSRules.d.ts

@@ -0,0 +1,2 @@
+export declare function compileCSSRules(cssRules: string, sortClassesInAtRules: boolean): string[];
+//# sourceMappingURL=compileCSSRules.d.ts.map

package/dist/runtime/compileCSSRules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compileCSSRules.d.ts","sourceRoot":"","sources":["../../src/runtime/compileCSSRules.ts"],"names":[],"mappings":"AASA,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,oBAAoB,EAAE,OAAO,GAAG,MAAM,EAAE,CAezF"}

package/dist/runtime/compileCSSRules.js

@@ -0,0 +1,17 @@
+import { compile, middleware, rulesheet, serialize, stringify } from 'stylis';
+import { globalPlugin } from './stylis/globalPlugin';
+import { prefixerPlugin } from './stylis/prefixerPlugin';
+import { sortClassesInAtRulesPlugin } from './stylis/sortClassesInAtRulesPlugin';
+// eslint-disable-next-line @typescript-eslint/no-empty-function
+function noop() { }
+export function compileCSSRules(cssRules, sortClassesInAtRules) {
+    const rules = [];
+    serialize(compile(cssRules), middleware([
+        globalPlugin,
+        sortClassesInAtRules ? sortClassesInAtRulesPlugin : noop,
+        prefixerPlugin,
+        stringify,
+        rulesheet(rule => rules.push(rule)),
+    ]));
+    return rules;
+}

package/dist/runtime/compileKeyframeCSS.d.ts

@@ -0,0 +1,4 @@
+import type { CalameAnimation } from '../types';
+export declare function compileKeyframeRule(keyframeObject: CalameAnimation): string;
+export declare function compileKeyframesCSS(keyframeName: string, keyframeCSS: string): string[];
+//# sourceMappingURL=compileKeyframeCSS.d.ts.map

package/dist/runtime/compileKeyframeCSS.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compileKeyframeCSS.d.ts","sourceRoot":"","sources":["../../src/runtime/compileKeyframeCSS.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAIhD,wBAAgB,mBAAmB,CAAC,cAAc,EAAE,eAAe,GAAG,MAAM,CAO3E;AAED,wBAAgB,mBAAmB,CAAC,YAAY,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,EAAE,CAcvF"}

package/dist/runtime/compileKeyframeCSS.js

@@ -0,0 +1,21 @@
+import { compile, middleware, serialize, rulesheet, stringify } from 'stylis';
+import { prefixerPlugin } from './stylis/prefixerPlugin';
+import { cssifyObject } from './utils/cssifyObject';
+export function compileKeyframeRule(keyframeObject) {
+    let css = '';
+    // eslint-disable-next-line guard-for-in
+    for (const percentage in keyframeObject) {
+        css += `${percentage}{${cssifyObject(keyframeObject[percentage])}}`;
+    }
+    return css;
+}
+export function compileKeyframesCSS(keyframeName, keyframeCSS) {
+    const cssRule = `@keyframes ${keyframeName} {${keyframeCSS}}`;
+    const rules = [];
+    serialize(compile(cssRule), middleware([
+        stringify,
+        prefixerPlugin,
+        rulesheet(rule => rules.push(rule)),
+    ]));
+    return rules;
+}

package/dist/runtime/compileResetCSSRules.d.ts

@@ -0,0 +1,2 @@
+export declare function compileResetCSSRules(cssRules: string): [string[], string[]];
+//# sourceMappingURL=compileResetCSSRules.d.ts.map

package/dist/runtime/compileResetCSSRules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compileResetCSSRules.d.ts","sourceRoot":"","sources":["../../src/runtime/compileResetCSSRules.ts"],"names":[],"mappings":"AAOA,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,EAAE,MAAM,EAAE,CAAC,CAqB3E"}

package/dist/runtime/compileResetCSSRules.js

@@ -0,0 +1,23 @@
+import { compile, middleware, serialize, stringify } from 'stylis';
+import { globalPlugin } from './stylis/globalPlugin';
+import { isAtRuleElement } from './stylis/isAtRuleElement';
+import { prefixerPlugin } from './stylis/prefixerPlugin';
+import { rulesheetPlugin } from './stylis/rulesheetPlugin';
+export function compileResetCSSRules(cssRules) {
+    const rules = [];
+    const atRules = [];
+    serialize(compile(cssRules), middleware([
+        globalPlugin,
+        prefixerPlugin,
+        stringify,
+        rulesheetPlugin((element, rule) => {
+            if (isAtRuleElement(element)) {
+                atRules.push(rule);
+            }
+            else {
+                rules.push(rule);
+            }
+        }),
+    ]));
+    return [rules, atRules];
+}

package/dist/runtime/compileStaticCSS.d.ts

@@ -0,0 +1,2 @@
+export declare function compileStaticCSS(selector: string, value: Record<string, unknown>): string;
+//# sourceMappingURL=compileStaticCSS.d.ts.map

package/dist/runtime/compileStaticCSS.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compileStaticCSS.d.ts","sourceRoot":"","sources":["../../src/runtime/compileStaticCSS.ts"],"names":[],"mappings":"AAGA,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAGzF"}

package/dist/runtime/compileStaticCSS.js

@@ -0,0 +1,6 @@
+import { cssifyObject } from './utils/cssifyObject';
+import { compileCSSRules } from './compileCSSRules';
+export function compileStaticCSS(selector, value) {
+    const cssRule = `${selector} {${cssifyObject(value)}}`;
+    return compileCSSRules(cssRule, false)[0];
+}

package/dist/runtime/getStyleBucketName.d.ts

@@ -0,0 +1,4 @@
+import type { StyleBucketName } from '../types';
+import type { AtRules } from './utils/types';
+export declare function getStyleBucketName(selectors: string[], atRules: AtRules): StyleBucketName;
+//# sourceMappingURL=getStyleBucketName.d.ts.map

package/dist/runtime/getStyleBucketName.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getStyleBucketName.d.ts","sourceRoot":"","sources":["../../src/runtime/getStyleBucketName.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAChD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAgB7C,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,OAAO,GAAG,eAAe,CAkBzF"}

package/dist/runtime/getStyleBucketName.js

@@ -0,0 +1,30 @@
+/**
+ * Maps a slice of the pseudo name to its bucket. Using a substring avoids
+ * collisions between e.g. `:focus-visible` and `:focus`.
+ */
+const pseudosMap = {
+    'us-w': 'w', // :focus-within
+    'us-v': 'i', // :focus-visible
+    nk: 'l', // :link
+    si: 'v', // :visited
+    cu: 'f', // :focus
+    ve: 'h', // :hover
+    ti: 'a', // :active
+};
+export function getStyleBucketName(selectors, atRules) {
+    if (atRules.media)
+        return 'm';
+    if (atRules.layer || atRules.supports)
+        return 't';
+    if (atRules.container)
+        return 'c';
+    if (selectors.length > 0) {
+        const normalizedPseudo = selectors[0].trim();
+        if (normalizedPseudo.charCodeAt(0) === 58 /* ":" */) {
+            return (pseudosMap[normalizedPseudo.slice(4, 8)] ||
+                pseudosMap[normalizedPseudo.slice(3, 5)] ||
+                'd');
+        }
+    }
+    return 'd';
+}

package/dist/runtime/reduceToClassNameForSlots.d.ts

@@ -0,0 +1,4 @@
+import type { CSSClassesMapBySlot, CSSClassesMap } from '../types';
+export declare function reduceToClassName(classMap: CSSClassesMap, dir: 'ltr' | 'rtl'): [string, string];
+export declare function reduceToClassNameForSlots<Slots extends string | number>(classesMapBySlot: CSSClassesMapBySlot<Slots>, dir: 'ltr' | 'rtl'): Record<Slots, string>;
+//# sourceMappingURL=reduceToClassNameForSlots.d.ts.map

package/dist/runtime/reduceToClassNameForSlots.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reduceToClassNameForSlots.d.ts","sourceRoot":"","sources":["../../src/runtime/reduceToClassNameForSlots.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,mBAAmB,EAAE,aAAa,EAAc,MAAM,UAAU,CAAC;AAE/E,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,aAAa,EAAE,GAAG,EAAE,KAAK,GAAG,KAAK,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAwB/F;AAED,wBAAgB,yBAAyB,CAAC,KAAK,SAAS,MAAM,GAAG,MAAM,EACnE,gBAAgB,EAAE,mBAAmB,CAAC,KAAK,CAAC,EAC5C,GAAG,EAAE,KAAK,GAAG,KAAK,GACnB,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,CAoBvB"}

package/dist/runtime/reduceToClassNameForSlots.js

@@ -0,0 +1,37 @@
+import { DEFINITION_LOOKUP_TABLE } from '../constants';
+import { hashSequence } from './utils/hashSequence';
+export function reduceToClassName(classMap, dir) {
+    let classString = '';
+    let hashString = '';
+    // eslint-disable-next-line guard-for-in
+    for (const propertyHash in classMap) {
+        const classNameMapping = classMap[propertyHash];
+        if (classNameMapping === 0) {
+            hashString += propertyHash + ' ';
+            continue;
+        }
+        const hasRTLClassName = Array.isArray(classNameMapping);
+        const className = dir === 'rtl'
+            ? (hasRTLClassName ? classNameMapping[1] : classNameMapping) + ' '
+            : (hasRTLClassName ? classNameMapping[0] : classNameMapping) + ' ';
+        classString += className;
+        hashString += className;
+    }
+    return [classString.slice(0, -1), hashString.slice(0, -1)];
+}
+export function reduceToClassNameForSlots(classesMapBySlot, dir) {
+    const classNamesForSlots = {};
+    // eslint-disable-next-line guard-for-in
+    for (const slotName in classesMapBySlot) {
+        const [slotClasses, slotClassesHash] = reduceToClassName(classesMapBySlot[slotName], dir);
+        if (slotClassesHash === '') {
+            classNamesForSlots[slotName] = '';
+            continue;
+        }
+        const sequenceHash = hashSequence(slotClassesHash, dir);
+        const resultSlotClasses = sequenceHash + (slotClasses === '' ? '' : ' ' + slotClasses);
+        DEFINITION_LOOKUP_TABLE[sequenceHash] = [classesMapBySlot[slotName], dir];
+        classNamesForSlots[slotName] = resultSlotClasses;
+    }
+    return classNamesForSlots;
+}

package/dist/runtime/resolveResetStyleRules.d.ts

@@ -0,0 +1,3 @@
+import type { CSSRulesByBucket, CalameResetStyle } from '../types';
+export declare function resolveResetStyleRules(styles: CalameResetStyle, classNameHashSalt?: string): [string, string | null, CSSRulesByBucket | string[]];
+//# sourceMappingURL=resolveResetStyleRules.d.ts.map

package/dist/runtime/resolveResetStyleRules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveResetStyleRules.d.ts","sourceRoot":"","sources":["../../src/runtime/resolveResetStyleRules.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAmB,MAAM,UAAU,CAAC;AAgHpF,wBAAgB,sBAAsB,CAClC,MAAM,EAAE,gBAAgB,EACxB,iBAAiB,GAAE,MAAW,GAC/B,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,EAAE,gBAAgB,GAAG,MAAM,EAAE,CAAC,CAsBtD"}