Brunobkr/llama.cpp_AlgMor24_github

1import { U as UserConfig, P as Plugin } from './types-B254mqw1.mjs';2import { V as Variant, C as Candidate } from './resolve-config-QUZ9b-Gn.mjs';3import './colors.mjs';4 5declare const enum ThemeOptions {6    NONE = 0,7    INLINE = 1,8    REFERENCE = 2,9    DEFAULT = 4,10    STATIC = 8,11    USED = 1612}13declare class Theme {14    #private;15    private values;16    private keyframes;17    prefix: string | null;18    constructor(values?: Map<string, {19        value: string;20        options: ThemeOptions;21        src: Declaration["src"];22    }>, keyframes?: Set<AtRule>);23    get size(): number;24    add(key: string, value: string, options?: ThemeOptions, src?: Declaration['src']): void;25    keysInNamespaces(themeKeys: Iterable<ThemeKey>): string[];26    get(themeKeys: ThemeKey[]): string | null;27    hasDefault(key: string): boolean;28    getOptions(key: string): ThemeOptions;29    entries(): IterableIterator<[string, {30        value: string;31        options: ThemeOptions;32        src: Declaration["src"];33    }]> | [string, {34        value: string;35        options: ThemeOptions;36        src: Declaration["src"];37    }][];38    prefixKey(key: string): string;39    clearNamespace(namespace: string, clearOptions: ThemeOptions): void;40    markUsedVariable(themeKey: string): boolean;41    resolve(candidateValue: string | null, themeKeys: ThemeKey[], options?: ThemeOptions): string | null;42    resolveValue(candidateValue: string | null, themeKeys: ThemeKey[]): string | null;43    resolveWith(candidateValue: string, themeKeys: ThemeKey[], nestedKeys?: `--${string}`[]): [string, Record<string, string>] | null;44    namespace(namespace: string): Map<string | null, string>;45    addKeyframes(value: AtRule): void;46    getKeyframes(): AtRule[];47}48type ThemeKey = `--${string}`;49 50type VariantFn<T extends Variant['kind']> = (rule: Rule, variant: Extract<Variant, {51    kind: T;52}>) => null | void;53type CompareFn = (a: Variant, z: Variant) => number;54declare const enum Compounds {55    Never = 0,56    AtRules = 1,57    StyleRules = 258}59declare class Variants {60    compareFns: Map<number, CompareFn>;61    variants: Map<string, {62        kind: Variant["kind"];63        order: number;64        applyFn: VariantFn<any>;65        compoundsWith: Compounds;66        compounds: Compounds;67    }>;68    private completions;69    /**70     * Registering a group of variants should result in the same sort number for71     * all the variants. This is to ensure that the variants are applied in the72     * correct order.73     */74    private groupOrder;75    /**76     * Keep track of the last sort order instead of using the size of the map to77     * avoid unnecessarily skipping order numbers.78     */79    private lastOrder;80    static(name: string, applyFn: VariantFn<'static'>, { compounds, order }?: {81        compounds?: Compounds;82        order?: number;83    }): void;84    fromAst(name: string, ast: AstNode[]): void;85    functional(name: string, applyFn: VariantFn<'functional'>, { compounds, order }?: {86        compounds?: Compounds;87        order?: number;88    }): void;89    compound(name: string, compoundsWith: Compounds, applyFn: VariantFn<'compound'>, { compounds, order }?: {90        compounds?: Compounds;91        order?: number;92    }): void;93    group(fn: () => void, compareFn?: CompareFn): void;94    has(name: string): boolean;95    get(name: string): {96        kind: Variant["kind"];97        order: number;98        applyFn: VariantFn<any>;99        compoundsWith: Compounds;100        compounds: Compounds;101    } | undefined;102    kind(name: string): "static" | "arbitrary" | "functional" | "compound";103    compoundsWith(parent: string, child: string | Variant): boolean;104    suggest(name: string, suggestions: () => string[]): void;105    getCompletions(name: string): string[];106    compare(a: Variant | null, z: Variant | null): number;107    keys(): IterableIterator<string>;108    entries(): IterableIterator<[string, {109        kind: Variant["kind"];110        order: number;111        applyFn: VariantFn<any>;112        compoundsWith: Compounds;113        compounds: Compounds;114    }]>;115    private set;116    private nextOrder;117}118 119declare function compileAstNodes(candidate: Candidate, designSystem: DesignSystem): {120    node: AstNode;121    propertySort: {122        order: number[];123        count: number;124    };125}[];126 127interface ClassMetadata {128    modifiers: string[];129}130type ClassEntry = [string, ClassMetadata];131interface SelectorOptions {132    modifier?: string;133    value?: string;134}135interface VariantEntry {136    name: string;137    isArbitrary: boolean;138    values: string[];139    hasDash: boolean;140    selectors: (options: SelectorOptions) => string[];141}142 143type CompileFn<T extends Candidate['kind']> = (value: Extract<Candidate, {144    kind: T;145}>) => AstNode[] | undefined | null;146interface SuggestionGroup {147    supportsNegative?: boolean;148    values: (string | null)[];149    modifiers: string[];150}151type UtilityOptions = {152    types: string[];153};154type Utility = {155    kind: 'static' | 'functional';156    compileFn: CompileFn<any>;157    options?: UtilityOptions;158};159declare class Utilities {160    private utilities;161    private completions;162    static(name: string, compileFn: CompileFn<'static'>): void;163    functional(name: string, compileFn: CompileFn<'functional'>, options?: UtilityOptions): void;164    has(name: string, kind: 'static' | 'functional'): boolean;165    get(name: string): Utility[];166    getCompletions(name: string): SuggestionGroup[];167    suggest(name: string, groups: () => SuggestionGroup[]): void;168    keys(kind: 'static' | 'functional'): string[];169}170 171type DesignSystem = {172    theme: Theme;173    utilities: Utilities;174    variants: Variants;175    invalidCandidates: Set<string>;176    important: boolean;177    getClassOrder(classes: string[]): [string, bigint | null][];178    getClassList(): ClassEntry[];179    getVariants(): VariantEntry[];180    parseCandidate(candidate: string): Readonly<Candidate>[];181    parseVariant(variant: string): Readonly<Variant> | null;182    compileAstNodes(candidate: Candidate): ReturnType<typeof compileAstNodes>;183    printCandidate(candidate: Candidate): string;184    printVariant(variant: Variant): string;185    getVariantOrder(): Map<Variant, number>;186    resolveThemeValue(path: string, forceInline?: boolean): string | undefined;187    trackUsedVariables(raw: string): void;188    candidatesToCss(classes: string[]): (string | null)[];189};190 191/**192 * The source code for one or more nodes in the AST193 *194 * This generally corresponds to a stylesheet195 */196interface Source {197    /**198     * The path to the file that contains the referenced source code199     *200     * If this references the *output* source code, this is `null`.201     */202    file: string | null;203    /**204     * The referenced source code205     */206    code: string;207}208/**209 * The file and offsets within it that this node covers210 *211 * This can represent either:212 * - A location in the original CSS which caused this node to be created213 * - A location in the output CSS where this node resides214 */215type SourceLocation = [source: Source, start: number, end: number];216 217type StyleRule = {218    kind: 'rule';219    selector: string;220    nodes: AstNode[];221    src?: SourceLocation;222    dst?: SourceLocation;223};224type AtRule = {225    kind: 'at-rule';226    name: string;227    params: string;228    nodes: AstNode[];229    src?: SourceLocation;230    dst?: SourceLocation;231};232type Declaration = {233    kind: 'declaration';234    property: string;235    value: string | undefined;236    important: boolean;237    src?: SourceLocation;238    dst?: SourceLocation;239};240type Comment = {241    kind: 'comment';242    value: string;243    src?: SourceLocation;244    dst?: SourceLocation;245};246type Context = {247    kind: 'context';248    context: Record<string, string | boolean>;249    nodes: AstNode[];250    src?: undefined;251    dst?: undefined;252};253type AtRoot = {254    kind: 'at-root';255    nodes: AstNode[];256    src?: undefined;257    dst?: undefined;258};259type Rule = StyleRule | AtRule;260type AstNode = StyleRule | AtRule | Declaration | Comment | Context | AtRoot;261 262/**263 * Line offset tables are the key to generating our source maps. They allow us264 * to store indexes with our AST nodes and later convert them into positions as265 * when given the source that the indexes refer to.266 */267/**268 * A position in source code269 *270 * https://tc39.es/ecma426/#sec-position-record-type271 */272interface Position {273    /** The line number, one-based */274    line: number;275    /** The column/character number, one-based */276    column: number;277}278 279interface OriginalPosition extends Position {280    source: DecodedSource;281}282/**283 * A "decoded" sourcemap284 *285 * @see https://tc39.es/ecma426/#decoded-source-map-record286 */287interface DecodedSourceMap {288    file: string | null;289    sources: DecodedSource[];290    mappings: DecodedMapping[];291}292/**293 * A "decoded" source294 *295 * @see https://tc39.es/ecma426/#decoded-source-record296 */297interface DecodedSource {298    url: string | null;299    content: string | null;300    ignore: boolean;301}302/**303 * A "decoded" mapping304 *305 * @see https://tc39.es/ecma426/#decoded-mapping-record306 */307interface DecodedMapping {308    originalPosition: OriginalPosition | null;309    generatedPosition: Position;310    name: string | null;311}312 313type Config = UserConfig;314declare const enum Polyfills {315    None = 0,316    AtProperty = 1,317    ColorMix = 2,318    All = 3319}320type CompileOptions = {321    base?: string;322    from?: string;323    polyfills?: Polyfills;324    loadModule?: (id: string, base: string, resourceHint: 'plugin' | 'config') => Promise<{325        path: string;326        base: string;327        module: Plugin | Config;328    }>;329    loadStylesheet?: (id: string, base: string) => Promise<{330        path: string;331        base: string;332        content: string;333    }>;334};335type Root = null | 'none' | {336    base: string;337    pattern: string;338};339declare const enum Features {340    None = 0,341    AtApply = 1,342    AtImport = 2,343    JsPluginCompat = 4,344    ThemeFunction = 8,345    Utilities = 16,346    Variants = 32347}348declare function compileAst(input: AstNode[], opts?: CompileOptions): Promise<{349    sources: {350        base: string;351        pattern: string;352        negated: boolean;353    }[];354    root: Root;355    features: Features;356    build(candidates: string[]): AstNode[];357}>;358 359declare function compile(css: string, opts?: CompileOptions): Promise<{360    sources: {361        base: string;362        pattern: string;363        negated: boolean;364    }[];365    root: Root;366    features: Features;367    build(candidates: string[]): string;368    buildSourceMap(): DecodedSourceMap;369}>;370declare function __unstable__loadDesignSystem(css: string, opts?: CompileOptions): Promise<DesignSystem>;371declare function postcssPluginWarning(): void;372 373export { type Config, type DecodedSourceMap, Features, Polyfills, __unstable__loadDesignSystem, compile, compileAst, postcssPluginWarning as default };374