fuzzy-rater/build/DFA/convertNFATemplateToDFATemplate.d.ts

Tooling for fuzzily rating text according to some query

import { INormalizedNFANode } from "../NFA/_types/INormalizedNFANode";
import { INormalizedNFATemplate } from "../NFA/_types/INormalizedNFATemplate";
import { IDFANFATemplate } from "./_types/NFAconversion/IDFANFATemplate";
import { IDFANFATransition } from "./_types/NFAconversion/IDFANFATransition";
/**
 * Converts the nfa input to a dfa input
 * @param nodes The nodes for a nfa automaton
 * @returns The dfa equivalent automaton template
 */
export declare function convertNFATemplateToDFATemplate<N, T>(nodes: INormalizedNFATemplate<N, T>): IDFANFATemplate<N, T>;
/**
 * Creates a transition, given a character and the node sets to transition from
 * @param template All the nfa input nodes
 * @param nodes The current state
 * @param char The character to transition on
 * @returns The transition for this character
 */
export declare function getCharacterTransition<N, T>(template: Map<string, INormalizedNFANode<N, T>>, nodes: INormalizedNFANode<N, T>[], char: string): {
    transition: IDFANFATransition<T>;
    to: INormalizedNFANode<N, T>[];
};
/**
 * Retrieves the transition for all characters for which no specific transition exists
 * @param template All the nfa input nodes
 * @param nodes The current state
 * @returns The transition for the remaining characters
 */
export declare function getRemainingTransition<N, T>(template: Map<string, INormalizedNFANode<N, T>>, nodes: INormalizedNFANode<N, T>[]): {
    transition: IDFANFATransition<T>;
    to: INormalizedNFANode<N, T>[];
};
/**
 * Retrieves the transition characters found in the given set of nodes
 * @param nodes The nodes in which to look for transition characters
 * @returns The transition character set
 */
export declare function getAvailableTransitionCharacter<N, T>(nodes: INormalizedNFANode<N, T>[]): string[];
/**
 * Checks what nodes are reachable with the given set, by using empty transitions
 * @param template All the nfa input nodes
 * @param nodes The nodes to get the closure of, (may include duplicates, which will be removed)
 * @returns The reach of these nodes
 */
export declare function getReachableNodes<N, T>(template: Map<string, INormalizedNFANode<N, T>>, nodes: INormalizedNFANode<N, T>[]): INormalizedNFANode<N, T>[];
/**
 * Creates an ID to uniquely define a set of nodes, no matter what the order is
 * @param nodes The nodes to create the ID for
 * @returns The created ID
 */
export declare function createID<N, T>(nodes: (INormalizedNFANode<N, T> | string)[]): string;
/**
 * Retrieves nodes given the list of IDs
 * @param map The map of items that the nodes are in
 * @param IDs The IDs of the nodes to retrieve
 * @returns The nodes
 */
export declare function getNodesFromIDs<T>(map: Map<string, T>, IDs: string[]): T[];
//# sourceMappingURL=convertNFATemplateToDFATemplate.d.ts.map