declare type AllowedRegexAttrValueFlag = 'i' | 'm' | 's' | 'u';

declare type AttrValueIsUnsafeToIntersect = typeof _AttrValueIsUnsafeToIntersect;

declare const _AttrValueIsUnsafeToIntersect: unique symbol;

declare type CarefullyIntersectNodes<L extends any | null, R extends any | null> = L extends null ? R : R extends null ? L : Extract<L, R>;

declare type Cartesian<Dnfs> = Dnfs extends [infer First, ...infer Rest] ? First extends {
    args: any[];
} ? CartesianSemiInner<First['args'], Cartesian<Rest>> : never : [[]];

declare type CartesianInner<F extends any[], Args, Acc extends any[] = []> = Args extends [infer First, ...infer Rest] ? First extends any[] ? CartesianInner<F, Rest, [...Acc, [...F, ...First]]> : never : Acc;

declare type CartesianSemiInner<FArgs, Head, Acc extends any[] = []> = FArgs extends [
infer First,
...infer Rest
] ? First extends {
    args: any[];
} ? CartesianSemiInner<Rest, Head, [
...Acc,
...CartesianInner<First['args'], Head>
]> : never : Acc;

declare type CheckMetaField<T, If = null, Else = T> = T extends `${string}.${string}` ? If : Else;

declare type CollapseChildRelations<Left, Right, AST extends {
    type: any;
}, Acc extends unknown[] = []> = Right extends [infer First, ...infer Rest] ? First extends {
    args: any[];
} ? CollapseChildRelations<Left, Rest, AST, [
...Acc,
MatchSplittedConjunction<Left, SplitConjunction<First['args']>, AST>
]> : never : Acc[number];

declare type CollapseNegativesFromConjunction<Left, Negatives, AST extends {
    type: any;
}, Acc = AST> = Negatives extends [infer First, ...infer Rest] ? First extends MetaAcc ? CollapseNegativesFromConjunction<Left, Rest, AST, Exclude<Acc, Extract<Left extends LeftIsAny ? AST : PrecollapseCollectChildBoundaries<Left, {
    field: First['field'];
}, AST>, Exclude<TryToNarrowByExtracting<First['identifier'] extends null ? AST : PickNode<First['identifier'], AST>, First['extract']>, First['exclude']>>>> : never : Acc;

declare type CollapsePositivesFromConjunction<Left, Positives, AST extends {
    type: any;
}, Acc = Left extends LeftIsAny ? AST : PrecollapseCollectChildBoundaries<Left, {
    field: null;
}, AST>> = Positives extends [infer First, ...infer Rest] ? First extends MetaAcc ? CollapsePositivesFromConjunction<Left, Rest, AST, Extract<Acc, Extract<Extract<Left extends LeftIsAny ? First['field'] extends null ? AST : PrecollapseCollectChildBoundaries<AST, {
    field: First['field'];
}, AST> : PrecollapseCollectChildBoundaries<Left, {
    field: First['field'];
}, AST>, unknown extends First['extract'] ? Exclude<TryToNarrowByExtracting<First['identifier'] extends null ? AST : PickNode<First['identifier'], AST>, First['extract']>, First['exclude']> : Exclude<Exclude<TryToNarrowByExtracting<First['identifier'] extends null ? AST : PickNode<First['identifier'], AST>, PreprocessExtract<First['extract']>['extract']>, First['exclude']>, PreprocessExtract<First['extract']>['exclude']>>, First['inferredNodes'] extends null ? any : First['inferredNodes']>>> : never : Acc;

declare type ConjunctionDnf<T extends {
    type: 'and';
    args: any[];
}> = unknown & {
    type: 'or';
    args: WrapCartesian<Cartesian<DnfArgs<T['args'], false>>>;
};

declare type DisjunctionDnf<T extends {
    type: 'or';
    args: any[];
}> = IsDisjunctionDnf<T, 0> extends true ? T : {
    type: 'or';
    args: DnfArgs<T['args'], true>;
};

declare type Dnf<T> = T extends MetaAcc ? {
    type: 'or';
    args: [
        {
        type: 'and';
        args: [T];
    }
    ];
} : T extends {
    type: 'or';
    args: any[];
} ? DisjunctionDnf<T> : T extends {
    type: 'and';
    args: any[];
} ? ConjunctionDnf<T> : T extends {
    type: 'not';
    arg: any;
} ? NotDnf<T> : never;

declare type DnfArgs<Args, Flat extends boolean, Acc extends any[] = []> = Args extends [infer First, ...infer Rest] ? DnfArgs<Rest, Flat, Dnf<First> extends infer Res ? Res extends {
    args: any[];
} ? Flat extends true ? Res extends [...any[]] ? [...Acc, ...FlatWithArgs<Res>] : [...Acc, ...Res['args']] : [...Acc, Res] : never : never> : Acc;

declare enum EndOfSelectorsList {
    None = 0,
    ClosingParen = 1
}

declare type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false;

declare type EveryArgIsDnf<Args, Depth> = Args extends [infer First, ...infer Rest] ? First extends MetaAcc ? IsVariableDnf<Depth> : First extends {
    type: 'and';
    args: any[];
} ? IsConjunctionDnf<First, Depth> extends true ? EveryArgIsDnf<Rest, Depth> : false : First extends {
    type: 'or';
    args: any[];
} ? IsDisjunctionDnf<First, Depth> extends true ? EveryArgIsDnf<Rest, Depth> : false : First extends {
    type: 'not';
    arg: any;
} ? IsNotDnf<First, Depth> extends true ? EveryArgIsDnf<Rest, Depth> : false : never : true;

declare type ExtractChildDeps<T, AST extends {
    type: any;
}> = NonNullable<{
    [K in keyof T]: K extends 'parent' ? never : FilterNodes<T[K], AST>;
}[keyof T]>;

declare type FilterNodes<T, AST extends {
    type: any;
}> = NonNullable<T> extends infer NonNullableT ? NonNullableT extends {
    type: AST['type'];
} ? NonNullableT : NonNullableT extends [...infer Elements] ? NonNullable<Elements[number]> extends {
    type: AST['type'];
} ? NonNullable<Elements[number]> : never : never : never;

declare type FilterTuple<T extends any[], Acc extends any[] = []> = T extends [
infer First,
...infer Rest
] ? First extends false ? FilterTuple<Rest, Acc> : FilterTuple<Rest, [...Acc, First]> : Acc;

declare type FlatWithArgs<T, Acc extends any[] = []> = T extends [
infer First,
...infer Rest
] ? First extends {
    args: any[];
} ? FlatWithArgs<Rest, [...Acc, First['args']]> : never : never;

declare type GenParseAttrRes<RawAttrName, Op extends string, ParseRes> = ParseRes extends string ? `parseAttrErr-${ParseRes}` : ParseRes extends {
    res: infer ParseResRes;
    rest: infer ParseResRest;
} ? ParseAttrName<RawAttrName> extends infer AttrNameParseRes ? AttrNameParseRes extends string ? `genParseAttrResErr-${AttrNameParseRes}` : Simplify<AttrNameParseRes & {
    operator: Op;
    value: ParseResRes;
    rest: ParseResRest;
}> : never : never;

declare type IdentifierNameRestrictedSymbols = ' ' | '[' | ']' | ',' | '(' | ')' | ':' | '#' | '!' | '=' | '>' | '<' | '~' | '+' | '.';

declare type IdentifierNameRestrictedSymbolsWithDot = Exclude<IdentifierNameRestrictedSymbols, '.'>;

declare type IfString<T, U> = T extends string ? U : T;

declare type IntersectAndSimplify<L, R> = unknown extends L ? R : unknown extends R ? L : Simplify<L & R>;

declare type IsConjunctionDnf<T extends {
    type: 'and';
    args: any[];
}, Depth> = Depth extends 1 ? EveryArgIsDnf<T['args'], 2> : false;

declare type IsDisjunctionDnf<T extends {
    type: 'or';
    args: any[];
}, Depth> = Depth extends 0 ? EveryArgIsDnf<T['args'], 1> : false;

declare type IsNotDnf<T extends {
    type: 'not';
    arg: any;
}, Depth> = Depth extends 2 ? EveryArgIsDnf<[T['arg']], 3> : false;

declare type IsVariableDnf<Depth> = Depth extends 0 ? false : Depth extends 1 ? false : true;

declare type LeftIsAny = typeof _LeftIsAny;

declare const _LeftIsAny: unique symbol;

export declare type Match<SelectorAST, AST extends {
    type: string;
}> = MatchIt<SelectorAST, AST>;

declare type MatchIt<T, AST extends {
    type: any;
}> = CollapseChildRelations<LeftIsAny, Dnf<PreprocessSelector<T, WildcardMeta, AST>> extends infer Res ? Res extends {
    args: any[];
} ? Res['args'] : never : never, AST>;

declare type MatchSplittedConjunction<Left, Splitted extends {
    and: any;
    not: any;
}, AST extends {
    type: any;
}> = Extract<CollapsePositivesFromConjunction<Left, Splitted['and'], AST>, CollapseNegativesFromConjunction<Left, Splitted['not'], AST>>;

declare type MergeTwoMetaFields<L extends string | null, R extends string | null> = L extends null ? CheckMetaField<R> : R extends null ? CheckMetaField<L> : CheckMetaField<L, CheckMetaField<R>, CheckMetaField<R, L, Equal<L, R> extends true ? L : NeverError<`different fields: ${L}, ${R}`>>>;

declare type MergeTwoMetaIdentifiers<L extends string | null, R extends string | null> = L extends null ? R : R extends null ? L : Equal<L, R> extends true ? L : NeverError<`different identifiers: ${L}, ${R}`>;

declare type MergeTwoMetas<L extends MetaAcc, R extends MetaAcc> = MergeTwoMetaIdentifiers<L['identifier'], R['identifier']> extends infer MergedIdentifiers ? MergedIdentifiers extends NeverError ? NeverError<MergedIdentifiers> : MergeTwoMetaFields<L['field'], R['field']> extends infer MergedFields ? MergedFields extends NeverError ? NeverError<MergedFields> : {
    identifier: MergedIdentifiers;
    field: MergedFields;
    extract: IntersectAndSimplify<L['extract'], R['extract']>;
    exclude: L['exclude'] | R['exclude'];
    inferredNodes: CarefullyIntersectNodes<L['inferredNodes'], R['inferredNodes']>;
} : NeverError : NeverError;

declare interface MetaAcc {
    identifier: string | null;
    field: string | null;
    extract: any;
    exclude: any;
    inferredNodes: any | null;
}

declare type NegatedArgs<Args, Acc extends any[] = []> = Args extends [
infer First,
...infer Rest
] ? NegatedArgs<Rest, [...Acc, {
    type: 'not';
    arg: First;
}]> : Acc;

declare type NegatedDnf<T> = T extends {
    type: 'or';
    args: any[];
} ? Dnf<{
    type: 'and';
    args: NegatedArgs<T['args']>;
}> : T extends {
    type: 'and';
    args: any[];
} ? Dnf<{
    type: 'or';
    args: NegatedArgs<T['args']>;
}> : T extends {
    type: 'not';
    arg: any;
} ? Dnf<T['arg']> : never;

declare type NeverError<Message = unknown> = [typeof NeverErrorSymbol, Message];

declare const NeverErrorSymbol: unique symbol;

declare type NotDnf<T extends {
    type: 'not';
    arg: any;
}> = IsNotDnf<T, 2> extends true ? {
    type: 'or';
    args: [
        {
        type: 'and';
        args: [T];
    }
    ];
} : NegatedDnf<T['arg']>;

export declare type Parse<Selector extends string> = ParseIt<Selector>;

declare type ParseAtom<T extends string> = ParseWildcard<T> extends infer WildcardParseRes ? WildcardParseRes extends string ? ParseIdentifier<T> extends infer IdentifierParseRes ? IdentifierParseRes extends string ? ParseAttr<T> extends infer AttrParseRes ? AttrParseRes extends string ? ParseField<T> extends infer FieldParseRes ? FieldParseRes extends string ? ParseNegation<T> extends infer NegationParseRes ? NegationParseRes extends string ? ParseMatches<T> extends infer MatchesParseRes ? MatchesParseRes extends string ? ParseHas<T> extends infer HasParseRes ? HasParseRes extends string ? ParseClass<T> extends infer ClassParseRes ? ClassParseRes extends string ? 'super next Stub (unimplemented)' : ClassParseRes : never : HasParseRes : never : MatchesParseRes : never : NegationParseRes : never : FieldParseRes : never : AttrParseRes : never : IdentifierParseRes : never : WildcardParseRes : never;

declare type ParseAttr<T extends string> = T extends `[${infer Rest}` ? SplitToClosingSquareBracketOrEqualSignOrAngleBracket<Rest> extends infer SplitRes ? SplitRes extends string ? `attrParseErr-split-${SplitRes}` : SplitRes extends [infer AttrName, infer AfterAttrName] ? AttrName extends string ? AfterAttrName extends string ? ParseAttrImpl<AttrName, AfterAttrName> : never : never : never : never : 'attrParseErr-cantFindOpeningSquareBracket';

declare type ParseAttrImpl<AttrName extends string, _AfterAttrName extends string> = _AfterAttrName extends `=${infer AfterAttrName}` ? TrimSpacesLeft<AfterAttrName> extends infer TrimmedAfterAttrName ? TrimmedAfterAttrName extends string ? AttrName extends `${infer RawAttrName}<` ? GenParseAttrRes<RawAttrName, '<=', ParseAttrValueForOps<TrimmedAfterAttrName>> : AttrName extends `${infer RawAttrName}>` ? GenParseAttrRes<RawAttrName, '>=', ParseAttrValueForOps<TrimmedAfterAttrName>> : AttrName extends `${infer RawAttrName}!` ? IfString<GenParseAttrRes<RawAttrName, '!=', ParseAttrValueForOps<TrimmedAfterAttrName>>, GenParseAttrRes<RawAttrName, '!=', ParseAttrValueForEqOps<TrimmedAfterAttrName>>> : IfString<GenParseAttrRes<AttrName, '=', ParseAttrValueForOps<TrimmedAfterAttrName>>, GenParseAttrRes<AttrName, '=', ParseAttrValueForEqOps<TrimmedAfterAttrName>>> : never : never : _AfterAttrName extends `<${infer AfterAttrName}` ? TrimSpacesLeft<AfterAttrName> extends infer TrimmedAfterAttrName ? TrimmedAfterAttrName extends string ? GenParseAttrRes<AttrName, '<', ParseAttrValueForOps<TrimmedAfterAttrName>> : never : never : _AfterAttrName extends `>${infer AfterAttrName}` ? TrimSpacesLeft<AfterAttrName> extends infer TrimmedAfterAttrName ? TrimmedAfterAttrName extends string ? GenParseAttrRes<AttrName, '>', ParseAttrValueForOps<TrimmedAfterAttrName>> : never : never : _AfterAttrName extends `]${infer Rest}` ? ParseAttrName<AttrName> extends infer AttrNameParseRes ? AttrNameParseRes extends string ? `attrParseErr-${AttrNameParseRes}` : Simplify<AttrNameParseRes & {
    rest: Rest;
}> : never : 'attrParseErr-wrongAttr';

declare type ParseAttrName<RawAttrName> = RawAttrName extends string ? ParseIdentifierName<TrimSpaces<RawAttrName>, IdentifierNameRestrictedSymbolsWithDot> extends infer AttrNameParseRes ? AttrNameParseRes extends string ? `genParseAttrResErr-${AttrNameParseRes}` : AttrNameParseRes extends {
    value: infer AttrNameParseResValue;
    rest: infer AttrNameParseResRest;
} ? AttrNameParseResRest extends '' ? {
    type: 'attribute';
    name: AttrNameParseResValue;
} : 'genParseAttrResErr-wrongAttrName' : never : never : never;

declare type ParseAttrValueForEqOps<AttrValue extends string> = PostProcessAttrValueWithRest<ParseRegexAttrValue<AttrValue>, AttrValue extends `${infer FullAttrValue}]${infer Rest}` ? TrimSpaces<FullAttrValue> extends infer TrimmedFullAttrValue ? TrimmedFullAttrValue extends string ? ParseTypeAttrValue<TrimmedFullAttrValue> extends infer TypeParseRes ? TypeParseRes extends string ? 'parseAttrValueForEqOpsErr-doesntMatch' : {
    res: TypeParseRes;
    rest: Rest;
} : never : never : never : 'parseAttrValueForOpsErr-unterminatedAttrSquareBracket'>;

declare type ParseAttrValueForOps<AttrValue extends string> = PostProcessAttrValueWithRest<ParseStringAttrValue<AttrValue>, AttrValue extends `${infer FullAttrValue}]${infer Rest}` ? TrimSpaces<FullAttrValue> extends infer TrimmedFullAttrValue ? TrimmedFullAttrValue extends string ? ParseNumberAttrValue<TrimmedFullAttrValue> extends infer NumberParseRes ? NumberParseRes extends string ? ParsePathAttrValue<TrimmedFullAttrValue> extends infer PathParseRes ? PathParseRes extends string ? 'parseAttrValueForOpsErr-doesntMatch' : {
    res: PathParseRes;
    rest: Rest;
} : never : {
    res: NumberParseRes;
    rest: Rest;
} : never : never : never : 'parseAttrValueForOpsErr-unterminatedAttrSquareBracket'>;

declare type ParseBinaryOp<T extends string> = TrimSpacesLeft<T> extends infer Op ? Op extends `>${infer Rest}` ? {
    op: 'child';
    rest: Rest;
} : Op extends `~${infer Rest}` ? {
    op: 'sibling';
    rest: Rest;
} : Op extends `+${infer Rest}` ? {
    op: 'adjacent';
    rest: Rest;
} : T extends ` ${infer Rest}` ? {
    op: 'descendant';
    rest: Rest;
} : 'unknownBinaryOp' : never;

declare type ParseClass<T extends string> = T extends `:${infer Class}` ? ParseIdentifierName<Class, IdentifierNameRestrictedSymbols> extends infer IdentifierNameParseRes ? IdentifierNameParseRes extends 'identifierNameEmpty' ? 'classErr-identifierNameNope' : IdentifierNameParseRes extends {
    value: infer IdentifierNameParseResValue;
    rest: infer IdentifierNameParseResRest;
} ? {
    type: 'class';
    name: IdentifierNameParseResValue;
    rest: IdentifierNameParseResRest;
} : never : 'field stub' : 'not class';

declare type ParseField<T extends string> = T extends `.${infer Rest}` ? ParseIdentifierName<Rest, IdentifierNameRestrictedSymbolsWithDot> extends infer IdentifierNameParseRes ? IdentifierNameParseRes extends 'identifierNameEmpty' ? 'fieldErr-identifierNameNope' : IdentifierNameParseRes extends {
    value: infer IdentifierNameParseResValue;
    rest: infer IdentifierNameParseResRest;
} ? {
    type: 'field';
    name: IdentifierNameParseResValue;
    rest: IdentifierNameParseResRest;
} : never : 'field stub' : 'field not starts with dot';

declare type ParseHas<T extends string> = ParsePseudoClass<T, 'has'>;

declare type ParseIdentifier<T extends string, RestrictedChars extends string = IdentifierNameRestrictedSymbols> = T extends `#${infer Rest}` ? ParseIdentifierInternal<Rest, RestrictedChars> : ParseIdentifierInternal<T, RestrictedChars>;

declare type ParseIdentifierInternal<T extends string, RestrictedChars extends string> = ParseIdentifierName<T, RestrictedChars> extends infer ParseRes ? ParseRes extends {
    value: infer V;
    rest: infer R;
} ? {
    type: 'identifier';
    value: V;
    rest: R;
} : ParseRes extends 'identifierNameEmpty' ? 'identifierEmpty' : 'identifier-unhandled' : never;

declare type ParseIdentifierName<T extends string, RestrictedChars extends string, Acc extends string = ''> = T extends '' ? Acc extends '' ? 'identifierNameEmpty' : {
    value: Acc;
    rest: T;
} : T extends `${infer First}${infer Rest}` ? First extends RestrictedChars ? Acc extends '' ? 'identifierNameEmpty' : {
    value: Acc;
    rest: T;
} : ParseIdentifierName<Rest, RestrictedChars, `${Acc}${First}`> : never;

declare type ParseIt<T extends string> = ParseSelectors<TrimSpaces<T>> extends infer SelectorsParseRes ? SelectorsParseRes extends string ? SelectorsParseRes : SelectorsParseRes extends {
    selectors: infer Selectors;
} ? Selectors extends [infer First, ...infer Rest] ? Rest[0] extends undefined ? First : {
    type: 'matches';
    selectors: [First, ...Rest];
} : never : never : never;

declare type ParseMatches<T extends string> = ParsePseudoClass<T, 'matches'>;

declare type ParseNegation<T extends string> = ParsePseudoClass<T, 'not'>;

declare type ParseNumberAttrValue<T extends string> = T extends `${infer N extends number}` ? {
    type: 'literal';
    value: N;
} : 'arrValueNumberErr';

declare type ParsePathAttrValue<T extends string> = ParseIdentifierName<T, IdentifierNameRestrictedSymbols> extends infer Res ? Res extends string ? `pathParseErr-${Res}` : Res extends {
    value: infer ResValue;
    rest: infer ResRest;
} ? ResRest extends '' ? {
    type: 'literal';
    value: ResValue;
} : `pathParseErr-hasSomeRest` : never : never;

declare type ParsePseudoClass<T extends string, PseudoClassName extends string> = T extends `:${PseudoClassName}(${infer Rest}` ? {
    type: PseudoClassName;
} & ParseSelectors<TrimSpaces<Rest>, [
], EndOfSelectorsList.ClosingParen> extends infer SelectorsParseRes ? SelectorsParseRes : never : `is not ${PseudoClassName} pseudo class`;

declare type ParseRegexAttrValue<T extends string> = ParseRegexAttrValueImpl<T> extends infer Res ? Res extends string ? Res : Res extends {
    res: infer ResRes;
    rest: infer Rest;
} ? {
    type: 'regexp';
    value: ResRes;
    rest: Rest;
} : never : never;

declare type ParseRegexAttrValueFlags<T extends string> = T extends '' ? 'regexEmptyFlags' : T extends `${infer First}${infer Rest}` ? First extends AllowedRegexAttrValueFlag ? Rest extends '' ? {
    acc: First;
    res: First;
    rest: '';
} : ParseRegexAttrValueFlags<Rest> extends infer NestedRes ? NestedRes extends string ? NestedRes : NestedRes extends {
    acc: infer NestedResAcc;
    res: infer NestedResRes;
    rest: infer NestedResRest;
} ? First extends NestedResAcc ? `regexDuplicatedFlag-${First}` : NestedResRes extends string ? {
    acc: First | NestedResAcc;
    res: `${First}${NestedResRes}`;
    rest: NestedResRest;
} : never : never : never : {
    acc: never;
    res: '';
    rest: T;
} : never;

declare type ParseRegexAttrValueImpl<T extends string> = T extends `/${infer Inner}/${infer Rest}` ? ParseRegexAttrValueFlags<Rest> extends infer ParsedFlags ? ParsedFlags extends string ? ParsedFlags extends 'regexEmptyFlags' ? {
    res: `/${Inner}/`;
    rest: Rest;
} : `regexErrInFlags-${ParsedFlags}` : ParsedFlags extends {
    res: infer ParsedFlagsRes;
    rest: infer ParsedFlagsRest;
} ? ParsedFlagsRes extends string ? {
    res: `/${Inner}/${ParsedFlagsRes}`;
    rest: ParsedFlagsRest;
} : never : never : never : 'regexParseErr-doesntMatch';

declare type ParseSelector<T extends string> = ParseSequence<T> extends infer SeqParseRes ? SeqParseRes extends string ? `sequenceErr-SeqParseFailed-${SeqParseRes}` : SeqParseRes extends {
    rest: infer Rest;
} ? Rest extends string ? Rest extends '' ? SimplifySeq<SeqParseRes> : ParseSelectorRequrser<Rest, SimplifySeq<SeqParseRes>> : never : never : never;

declare type ParseSelectorRequrser<T extends string, Acc> = ParseBinaryOp<T> extends infer BinaryOpParseRes ? BinaryOpParseRes extends string ? {
    error: `recursersequenceErr-atomParseFailed-${BinaryOpParseRes}`;
    acc: Acc;
    rest: T;
} : BinaryOpParseRes extends {
    op: infer Op;
    rest: infer BinaryOpParseResRest;
} ? BinaryOpParseResRest extends string ? ParseSequence<TrimSpaces<BinaryOpParseResRest>> extends infer SeqParseRes ? SeqParseRes extends string | never ? {
    error: `recursersequenceErr-SeqParseFailed-${SeqParseRes}`;
    acc: Acc;
    rest: T;
} : SeqParseRes extends {
    selectors: infer Selectors;
    rest: infer Rest;
} ? Selectors extends [infer _, ...infer __] ? Rest extends '' ? {
    type: Op;
    left: Acc;
    right: SimplifySeq<SeqParseRes>;
} : Rest extends string ? ParseSelectorRequrser<Rest, {
    type: Op;
    left: Acc;
    right: SimplifySeq<SeqParseRes>;
}> : never : {
    error: `recursersequenceErr-SeqParseFailed-${'todo'}`;
    acc: Acc;
    rest: BinaryOpParseResRest;
} : 'here Stub' : never : never : never : never;

declare type ParseSelectors<T extends string, Acc extends unknown[] = [], Eosl extends EndOfSelectorsList = EndOfSelectorsList.None> = ParseSelector<T> extends infer SelectorParseRes ? SelectorParseRes extends {
    error: unknown;
    acc: infer SelectorAcc;
    rest: infer Rest;
} ? Rest extends string ? _ParseSelectorsTrimCommaAtStart<Rest> extends infer RestWithoutComma ? RestWithoutComma extends string ? Eosl extends EndOfSelectorsList.None ? `${Rest}-nanoStub-${RestWithoutComma}` : Eosl extends EndOfSelectorsList.ClosingParen ? TrimSpacesLeft<Rest> extends infer R ? R extends `)${infer RestRest}` ? {
    selectors: [...Acc, SelectorAcc];
    rest: RestRest;
} : `commaErr-${T}` : never : never : RestWithoutComma extends {
    res: infer RestWithoutCommaRes;
} ? RestWithoutCommaRes extends string ? ParseSelectors<RestWithoutCommaRes, [
...Acc,
SelectorAcc
], Eosl> : never : never : never : never : SelectorParseRes extends {
    rest: infer Rest;
} ? {
    selectors: [...Acc, Simplify<Omit<SelectorParseRes, 'rest'>>];
    rest: Rest;
} : {
    selectors: [...Acc, Simplify<Omit<SelectorParseRes, 'rest'>>];
    rest: '';
} : never;

declare type _ParseSelectorsTrimCommaAtStart<T extends string> = TrimSpacesLeft<T> extends infer R ? R extends `,${infer Rest}` ? {
    res: TrimSpacesLeft<Rest>;
} : `commaErr-${T}` : never;

declare type ParseSequence<T extends string, Acc extends unknown[] = []> = ParseAtom<T> extends infer AtomParseRes ? AtomParseRes extends string ? {
    selectors: Acc;
    rest: T;
} : AtomParseRes extends {
    rest: infer Rest;
} ? Rest extends string ? ParseSequence<Rest, [...Acc, Simplify<Omit<AtomParseRes, 'rest'>>]> : never : never : never;

declare type ParseStringAttrValue<T extends string> = T extends `"${infer Rest}` ? ParseStringAttrValueImpl<Rest, '"'> : T extends `'${infer Rest}` ? ParseStringAttrValueImpl<Rest, "'"> : 'stringParseErr-itDoesntStartWithQuotes';

declare type ParseStringAttrValueImpl<T extends string, Q extends '"' | "'"> = ParseStringAttrValueRecurser<T, Q> extends infer Res ? Res extends string ? `stringParseErr-${Res}` : Res extends {
    res: infer ResRes;
    rest: infer ResRest;
} ? ResRes extends string ? {
    type: 'literal';
    value: Replace<ResRes, `\\${Q}`, Q>;
    rest: ResRest;
} : never : never : never;

declare type ParseStringAttrValueRecurser<T extends string, Q extends '"' | "'"> = T extends `${infer BeforeQuote}${Q}${infer Rest}` ? BeforeQuote extends `${string}\\` ? ParseStringAttrValueRecurser<Rest, Q> extends infer Res ? Res extends string ? 'unterminatedString' : Res extends {
    res: infer ResRes;
    rest: infer ResRest;
} ? ResRes extends string ? {
    res: `${BeforeQuote}${Q}${ResRes}`;
    rest: ResRest;
} : never : never : never : {
    res: BeforeQuote;
    rest: Rest;
} : 'no';

declare type ParseTypeAttrValue<T extends string> = T extends `type(${infer Inner})${infer Rest}` ? Rest extends '' ? TrimSpaces<Inner> extends infer TrimmedInner ? TrimmedInner extends '' ? 'typeParseErr-emptyType' : {
    type: 'type';
    value: TrimmedInner;
} : never : 'attrValueTypeErr-somethingAfterClosingParen' : 'attrValueTypeErr-doesntMatch';

declare type ParseWildcard<T extends string> = T extends `*${infer Rest}` ? {
    type: 'wildcard';
    value: '*';
    rest: Rest;
} : 'wildcardnope';

declare type PartitionBy<Tuple extends [string, string][], CompareTo extends string, LeftAcc extends [string, string][] = [], RightAcc extends [string, string][] = []> = Tuple extends [infer First, ...infer Rest] ? Rest extends [string, string][] ? First extends [infer PairFirst, infer PairLast] ? PairFirst extends string ? PairLast extends string ? PairFirst extends `${CompareTo}${string}` ? PartitionBy<Rest, CompareTo, LeftAcc, [
...RightAcc,
[PairFirst, PairLast]
]> : PartitionBy<Rest, CompareTo, [
...LeftAcc,
[PairFirst, PairLast]
], RightAcc> : never : never : never : never : [LeftAcc, RightAcc];

declare type PatchMeta<T extends MetaAcc, Field extends keyof MetaAcc, Value> = MergeTwoMetas<T, {
    [K in Field]: Value;
} & Omit<WildcardMeta, Field> extends infer Res ? Res extends MetaAcc ? Res : never : never>;

declare type PickNode<T, AST> = [T] extends [any] ? Extract<AST, {
    type: T;
}> : never;

declare type PostProcessAttrValueWithRest<V, Next> = V extends infer ParseRes ? ParseRes extends string ? Next : ParseRes extends {
    rest: infer Rest;
} ? Rest extends string ? TrimSpacesLeft<Rest> extends `]${infer RestRest}` ? {
    res: Simplify<Omit<ParseRes, 'rest'>>;
    rest: RestRest;
} : 'attrParseErr-unterminatedAttrSquareBracket' : never : never : never;

declare type PrecollapseCollectChildBoundaries<Boundary, Ctx extends {
    field: any | null;
}, AST extends {
    type: any;
}> = Ctx['field'] extends null ? ExtractChildDeps<Boundary, AST> : FilterNodes<Extract<Boundary, {
    [K in Ctx['field']]: any;
}>[Ctx['field']], AST>;

declare type PrepreprocessCompoundSelector<Selectors extends any[], SelectorAcc extends MetaAcc, AST extends {
    type: any;
}, Acc extends {
    selectors: any[];
    matches: any[];
    nots: any[];
} = {
    selectors: [];
    matches: [];
    nots: [];
}> = Selectors extends [infer Selector, ...infer Rest] ? Selector extends {
    type: 'matches';
} ? PrepreprocessCompoundSelector<Rest, SelectorAcc, AST, {
    matches: [...Acc['matches'], Selector];
} & Omit<Acc, 'matches'>> : Selector extends {
    type: 'not';
} ? PrepreprocessCompoundSelector<Rest, SelectorAcc, AST, {
    nots: [...Acc['nots'], Selector];
} & Omit<Acc, 'nots'>> : PrepreprocessCompoundSelector<Rest, SelectorAcc, AST, {
    selectors: [...Acc['selectors'], Selector];
} & Omit<Acc, 'selectors'>> : PreprocessCompoundSelector<[
...(Acc['matches'] extends [infer _, ...infer __] ? [
    {
    type: 'matches';
    selectors: [{
        type: 'compound';
        selectors: Acc['selectors'];
    }];
}
] : Acc['nots'] extends [infer _, ...infer __] ? [
    {
    type: 'matches';
    selectors: [{
        type: 'compound';
        selectors: Acc['selectors'];
    }];
}
] : Acc['selectors']),
...Acc['matches'],
...Acc['nots']
], SelectorAcc, AST>;

declare type PreprocessCompoundSelector<Selectors extends any[], SelectorAcc extends MetaAcc, AST extends {
    type: any;
}, Acc extends any[] | null = null> = Selectors extends [infer Selector, ...infer Rest] ? Selector extends {
    type: 'wildcard';
} | {
    type: 'class';
} | {
    type: 'has';
} ? PreprocessCompoundSelector<Rest, SelectorAcc, AST, Acc> : Selector extends {
    type: 'identifier';
    value: any;
} ? PatchMeta<SelectorAcc, 'identifier', Selector['value']> extends infer PatchRes ? PatchRes extends MetaAcc ? PreprocessCompoundSelector<Rest, PatchRes, AST, Acc> : NeverError<PatchRes> : never : Selector extends {
    type: 'attribute';
    name: any;
} ? Selector['name'] extends `${string}.${string}` ? PreprocessCompoundSelector<Rest, SelectorAcc, AST, Acc> : Selector extends {
    operator: any;
    value: any;
} ? Selector['value'] extends {
    type: 'literal';
    value: any;
} ? Selector['operator'] extends '=' ? TryToParseAttrValue<Selector['value']['value']> extends infer AttrValue ? AttrValue extends AttrValueIsUnsafeToIntersect ? PreprocessCompoundSelector<Rest, SelectorAcc, AST, Acc> : PatchMeta<SelectorAcc, 'extract', {
    [K in Selector['name']]: AttrValue;
}> extends infer PatchRes ? PatchRes extends MetaAcc ? PreprocessCompoundSelector<Rest, PatchRes, AST, Acc> : NeverError<PatchRes> : never : never : Selector['operator'] extends '!=' ? TryToParseAttrValue<Selector['value']['value']> extends infer AttrValue ? AttrValue extends AttrValueIsUnsafeToIntersect ? PreprocessCompoundSelector<Rest, SelectorAcc, AST, Acc> : PatchMeta<SelectorAcc, 'exclude', {
    [K in Selector['name']]: AttrValue;
}> extends infer PatchRes ? PatchRes extends MetaAcc ? PreprocessCompoundSelector<Rest, PatchRes, AST, Acc> : NeverError<PatchRes> : never : never : PreprocessCompoundSelector<Rest, SelectorAcc, AST, Acc> : PreprocessCompoundSelector<Rest, SelectorAcc, AST, Acc> : PatchMeta<SelectorAcc, 'extract', {
    [K in Selector['name']]: string | number | boolean | symbol | object;
}> extends infer PatchRes ? PatchRes extends MetaAcc ? PreprocessCompoundSelector<Rest, PatchRes, AST, Acc> : NeverError<PatchRes> : never : Selector extends {
    type: 'field';
    name: any;
} ? PatchMeta<SelectorAcc, 'field', Selector['name']> extends infer PatchRes ? PatchRes extends MetaAcc ? PreprocessCompoundSelector<Rest, PatchRes, AST, Acc> : NeverError<PatchRes> : never : PreprocessCompoundSelector<Rest, SelectorAcc, AST, [
...(Acc extends any[] ? Acc : []),
PreprocessSelector<Selector, SelectorAcc, AST>
]> : Acc extends any[] ? Acc : [SelectorAcc];

declare type PreprocessExtract<T> = {
    extract: {
        [K in keyof T]: T[K] extends boolean ? boolean : T[K];
    };
    exclude: {
        [K in keyof T]: T[K] extends boolean ? T[K] extends true ? false : true : never;
    };
};

declare type PreprocessSelector<T, SelectorAcc extends MetaAcc, AST extends {
    type: any;
}> = T extends {
    type: 'sibling';
} | {
    type: 'adjacent';
} | {
    type: 'descendant';
} ? T extends {
    right: any;
} ? PreprocessSelector<T['right'], SelectorAcc, AST> : never : T extends {
    type: 'wildcard';
} | {
    type: 'identifier';
} | {
    type: 'attribute';
} | {
    type: 'field';
} | {
    type: 'class';
} | {
    type: 'has';
} ? PreprocessSelector<{
    type: 'compound';
    selectors: [T];
}, SelectorAcc, AST> : T extends {
    type: 'compound';
    selectors: any;
} ? {
    type: 'and';
    args: PrepreprocessCompoundSelector<T['selectors'], SelectorAcc, AST>;
} : T extends {
    type: 'child';
    left: any;
    right: any;
} ? CollapseChildRelations<MatchIt<T['left'], AST>, Dnf<PreprocessSelector<T['right'], WildcardMeta, AST>> extends infer Res ? Res extends {
    args: any[];
} ? Res['args'] : never : never, AST> extends infer InferredNodes ? [InferredNodes] extends [never] ? never : {
    identifier: null;
    field: null;
    extract: unknown;
    exclude: never;
    inferredNodes: InferredNodes;
} : never : T extends {
    type: 'matches';
    selectors: any;
} ? PreprocessSelectorsList<T['selectors'], SelectorAcc, AST> : T extends {
    type: 'not';
    selectors: any;
} ? {
    type: 'and';
    args: [
        {
        type: 'not';
        arg: {
            type: 'not';
            arg: SelectorAcc;
        };
    },
        {
        type: 'not';
        arg: PreprocessSelectorsList<T['selectors'], SelectorAcc, AST>;
    }
    ];
} : NeverError<'not impleeemented'>;

declare type PreprocessSelectorsList<Selectors extends any[], SelectorAcc extends MetaAcc, AST extends {
    type: any;
}, Acc extends any[] = []> = Selectors extends [infer Selector, ...infer Rest] ? PreprocessSelectorsList<Rest, SelectorAcc, AST, [
...Acc,
PreprocessSelector<Selector, SelectorAcc, AST>
]> : {
    type: 'or';
    args: Acc;
};

export declare type Query<Selector extends string, AST extends {
    type: string;
}> = Match<Parse<Selector>, AST>;

declare type Replace<T extends string, From extends string, To extends string> = T extends `${infer Before}${From}${infer After}` ? Replace<`${Before}${To}${After}`, From, To> : T;

declare type Simplify<T> = {
    [K in keyof T]: T[K];
} & {};

declare type SimplifySeq<S> = S extends {
    selectors: infer Selectors;
} ? Selectors extends [infer First, ...infer Rest] ? Rest[0] extends undefined ? First : {
    type: 'compound';
    selectors: [First, ...Rest];
} : never : never;

declare type SortPairsByShortestTemplateLiteral<Pairs extends [string, string][]> = Pairs extends [infer Head, ...infer Tail] ? Tail extends [string, string][] ? Head extends [infer HeadFirst, infer _] ? HeadFirst extends string ? PartitionBy<Tail, HeadFirst> extends [infer Left, infer Right] ? Left extends [string, string][] ? Right extends [string, string][] ? [
...SortPairsByShortestTemplateLiteral<Left>,
Head,
...SortPairsByShortestTemplateLiteral<Right>
] : never : never : never : never : never : never : [];

declare type SplitConjunction<T, Acc extends {
    and: MetaAcc[];
    not: MetaAcc[];
} = {
    and: [];
    not: [];
}> = T extends [infer First, ...infer Rest] ? First extends {
    type: 'not';
    arg: MetaAcc;
} ? SplitConjunction<Rest, {
    not: [...Acc['not'], First['arg']];
} & Omit<Acc, 'not'>> : First extends MetaAcc ? SplitConjunction<Rest, {
    and: [...Acc['and'], First];
} & Omit<Acc, 'and'>> : never : Simplify<Acc>;

declare type SplitToClosingSquareBracketOrEqualSignOrAngleBracket<T extends string> = SortPairsByShortestTemplateLiteral<FilterTuple<[
TryToSplitByAngleBracket<T, '>'>,
TryToSplitByAngleBracket<T, '<'>,
TryToSplitBy<T, '='>,
TryToSplitBy<T, ']'>
]>> extends [infer First, ...infer _] ? First : 'cant find splitter';

declare type Trim<T extends string, R extends string> = T extends `${R}${infer Rest}${R}` ? Trim<Rest, R> : T extends `${R}${infer Rest}` ? TrimLeft<Rest, R> : T extends `${infer Rest}${R}` ? TrimRight<Rest, R> : T;

declare type TrimLeft<T extends string, R extends string> = T extends `${R}${infer Rest}` ? TrimLeft<Rest, R> : T;

declare type TrimRight<T extends string, R extends string> = T extends `${infer Rest}${R}` ? TrimRight<Rest, R> : T;

declare type TrimSpaces<T extends string> = Trim<T, ' '>;

declare type TrimSpacesLeft<T extends string> = TrimLeft<T, ' '>;

declare type TryToNarrowByExtracting<T, U> = Extract<T, U> extends never ? Extract<T, {
    [K in keyof U]: any;
}> : Extract<T, U>;

declare type TryToParseAttrValue<T> = T extends 'true' ? true : T extends 'false' ? false : T extends 'null' ? null : T extends 'undefined' ? undefined : AttrValueIsUnsafeToIntersect;

declare type TryToSplitBy<T, S extends string> = T extends `${infer Before}${S}${infer After}` ? [Before, `${S}${After}`] : false;

declare type TryToSplitByAngleBracket<T, S extends '>' | '<'> = T extends `${infer Before}${S}${infer After}` ? After extends `=${string}` ? [`${Before}${S}`, After] : [Before, `${S}${After}`] : false;

declare type WildcardMeta = {
    identifier: null;
    field: null;
    extract: unknown;
    exclude: never;
    inferredNodes: null;
};

declare type WrapCartesian<C, Acc extends any[] = []> = C extends [
infer First,
...infer Rest
] ? WrapCartesian<Rest, [
...Acc,
    {
    type: 'and';
    args: First;
}
]> : Acc;

export { }