nlptoolkit-universaldependencyparser 1.0.0

package/source/Parser/TransitionBasedParser/Oracle.ts

@@ -0,0 +1,123 @@
+import {Model} from "nlptoolkit-classification/dist/Model/Model";
+import {Decision} from "./Decision";
+import {State} from "./State";
+import {Candidate} from "./Candidate";
+import {UniversalDependencyRelation} from "nlptoolkit-dependencyparser/dist/Universal/UniversalDependencyRelation";
+import {UniversalDependencyType} from "nlptoolkit-dependencyparser/dist/Universal/UniversalDependencyType";
+
+export abstract class Oracle {
+
+    protected commandModel: Model
+    protected windowSize: number
+
+    /**
+     * Constructs an Oracle with the given model and window size.
+     * @param model the model used for making predictions
+     * @param windowSize the size of the window used in parsing
+     */
+    protected constructor(model: Model, windowSize: number) {
+        this.commandModel = model
+        this.windowSize = windowSize
+    }
+
+    /**
+     * Abstract method to be implemented by subclasses to make a parsing decision based on the current state.
+     * @param state the current parsing state
+     * @return a {@link Decision} object representing the action to be taken
+     */
+    abstract makeDecision(state: State): Decision
+
+    /**
+     * Abstract method to be implemented by subclasses to score potential decisions based on the current state and transition system.
+     * @param state the current parsing state
+     * @param transitionSystem the transition system being used (e.g., ARC_STANDARD or ARC_EAGER)
+     * @return a list of {@link Decision} objects, each with a score indicating its suitability
+     */
+    protected abstract scoreDecisions(state: State, transitionSystem: TransitionSystem): Array<Decision>
+
+    /**
+     * Finds the best valid parsing action for the ARC_EAGER transition system based on probabilities.
+     * Ensures the action is applicable given the current state.
+     * @param probabilities a map of actions to their associated probabilities
+     * @param state the current parsing state
+     * @return the best action as a string, or an empty string if no valid action is found
+     */
+    protected findBestValidEagerClassInfo(probabilities: Map<string, number>, state: State): string{
+        let bestValue = 0.0
+        let best = ""
+        for (let key in probabilities){
+            if (probabilities.get(key) > bestValue){
+                if (key == "SHIFT" || key == "RIGHTARC"){
+                    if (state.wordListSize() > 0){
+                        best = key
+                        bestValue = probabilities.get(key)
+                    }
+                } else {
+                    if (state.stackSize() > 1){
+                        if (!(key == "REDUCE" && state.getPeek().getRelation() == null)){
+                            best = key
+                            bestValue = probabilities.get(key)
+                        }
+                    }
+                }
+            }
+        }
+        return best
+    }
+
+    /**
+     * Finds the best valid parsing action for the ARC_STANDARD transition system based on probabilities.
+     * Ensures the action is applicable given the current state.
+     * @param probabilities a map of actions to their associated probabilities
+     * @param state the current parsing state
+     * @return the best action as a string, or an empty string if no valid action is found
+     */
+    protected findBestValidStandardClassInfo(probabilities: Map<string, number>, state: State): string{
+        let bestValue = 0.0
+        let best = ""
+        for (let key in probabilities){
+            if (probabilities.get(key) > bestValue){
+                if (key == "SHIFT"){
+                    if (state.wordListSize() > 0){
+                        best = key
+                        bestValue = probabilities.get(key)
+                    }
+                } else {
+                    if (state.stackSize() > 1){
+                        best = key
+                        bestValue = probabilities.get(key)
+                    }
+                }
+            }
+        }
+        return best
+    }
+
+    /**
+     * Converts a string representation of the best action into a {@link Candidate} object.
+     * @param best the best action represented as a string, possibly with a dependency type in parentheses
+     * @return a {@link Candidate} object representing the action, or null if the action is unknown
+     */
+    protected getDecisionCandidate(best: string): Candidate{
+        let command, type
+        if (best.includes("(")){
+            command = best.substring(0, best.indexOf('('))
+            let relation = best.substring(best.indexOf('(') + 1, best.indexOf(')'))
+            type = UniversalDependencyRelation.getDependencyTag(relation)
+        } else {
+            command = best
+            type = UniversalDependencyType.DEP
+        }
+        switch (command){
+            case "SHIFT":
+                return new Candidate(Command.SHIFT, type)
+            case "REDUCE":
+                return new Candidate(Command.REDUCE, type)
+            case "LEFTARC":
+                return new Candidate(Command.LEFTARC, type)
+            case "RIGHTARC":
+                return new Candidate(Command.RIGHTARC, type)
+        }
+        return null
+    }
+}

package/source/Parser/TransitionBasedParser/RandomOracle.ts

@@ -0,0 +1,37 @@
+import {Oracle} from "./Oracle";
+import {State} from "./State";
+import {Decision} from "./Decision";
+import {Model} from "nlptoolkit-classification/dist/Model/Model";
+import {UniversalDependencyType} from "nlptoolkit-dependencyparser/dist/Universal/UniversalDependencyType";
+import {UniversalDependencyRelation} from "nlptoolkit-dependencyparser/dist/Universal/UniversalDependencyRelation";
+
+export class RandomOracle extends Oracle{
+
+    constructor(model: Model, windowSize: number) {
+        super(model, windowSize)
+    }
+
+    /**
+     * Makes a random decision based on a uniform distribution over possible actions.
+     * @param state The current state of the parser.
+     * @return A Decision object representing the randomly chosen action.
+     */
+    public makeDecision(state: State): Decision {
+        let command = Math.floor(Math.random() * 3)
+        let relation = Math.floor(Math.random() * 58)
+        switch (command){
+            case 0:
+                return new Decision(Command.LEFTARC, UniversalDependencyRelation.universalDependencyTags[relation], 0)
+            case 1:
+                return new Decision(Command.RIGHTARC, UniversalDependencyRelation.universalDependencyTags[relation], 0)
+            case 2:
+                return new Decision(Command.SHIFT, UniversalDependencyType.DEP, 0)
+        }
+        return null
+    }
+
+    protected scoreDecisions(state: State, transitionSystem: TransitionSystem): Array<Decision> {
+        return null;
+    }
+
+}

package/source/Parser/TransitionBasedParser/RandomScoringOracle.ts

@@ -0,0 +1,10 @@
+import {ScoringOracle} from "./ScoringOracle";
+import {State} from "./State";
+
+export class RandomScoringOracle extends ScoringOracle{
+
+    score(state: State): number {
+        return Math.random()
+    }
+
+}

package/source/Parser/TransitionBasedParser/ScoringOracle.ts

@@ -0,0 +1,5 @@
+import {State} from "./State";
+
+export abstract class ScoringOracle {
+    abstract score(state: State): number
+}

package/source/Parser/TransitionBasedParser/SimpleInstanceGenerator.ts

@@ -0,0 +1,57 @@
+import {InstanceGenerator} from "./InstanceGenerator";
+import {State} from "./State";
+import {Instance} from "nlptoolkit-classification/dist/Instance/Instance";
+import {DiscreteIndexedAttribute} from "nlptoolkit-classification/dist/Attribute/DiscreteIndexedAttribute";
+import {
+    UniversalDependencyTreeBankFeatures
+} from "nlptoolkit-dependencyparser/dist/Universal/UniversalDependencyTreeBankFeatures";
+import {Attribute} from "nlptoolkit-classification/dist/Attribute/Attribute";
+
+export class SimpleInstanceGenerator extends InstanceGenerator{
+
+    constructor() {
+        super();
+    }
+
+    /**
+     * Generates an instance based on the state, window size, and command.
+     * @param state The current state of the parser, which includes the stack and word list.
+     * @param windowSize The size of the window used for feature extraction.
+     * @param command The command to be associated with the generated instance.
+     * @return The generated {@link Instance} object with attributes based on the state and command.
+     */
+    generate(state: State, windowSize: number, command: string): Instance {
+        let instance = new Instance(command)
+        let attributes = new Array<Attribute>()
+        for (let i = 0; i < windowSize; i++) {
+            let word = state.getStackWord(i);
+            if (word == null) {
+                attributes.push(new DiscreteIndexedAttribute("null", 0, 18))
+                this.addEmptyAttributes(attributes)
+            } else {
+                if (word.getName() == "root") {
+                    attributes.push(new DiscreteIndexedAttribute("root", 0, 18))
+                    this.addEmptyAttributes(attributes)
+                } else {
+                    attributes.push(new DiscreteIndexedAttribute(word.getUpos().toString(), UniversalDependencyTreeBankFeatures.posIndex(word.getUpos().toString()) + 1, 18))
+                    this.addFeatureAttributes(word, attributes)
+                }
+            }
+        }
+        for (let i = 0; i < windowSize; i++) {
+            let word = state.getWordListWord(i)
+            if (word != null) {
+                attributes.push(new DiscreteIndexedAttribute(word.getUpos().toString(), UniversalDependencyTreeBankFeatures.posIndex(word.getUpos().toString()) + 1, 18))
+                this.addFeatureAttributes(word, attributes)
+            } else {
+                attributes.push(new DiscreteIndexedAttribute("root", 0, 18))
+                this.addEmptyAttributes(attributes)
+            }
+        }
+        for (let attribute of attributes) {
+            instance.addAttribute(attribute)
+        }
+        return instance
+    }
+
+}

package/source/Parser/TransitionBasedParser/StackRelation.ts

@@ -0,0 +1,27 @@
+import {
+    UniversalDependencyTreeBankWord
+} from "nlptoolkit-dependencyparser/dist/Universal/UniversalDependencyTreeBankWord";
+import {UniversalDependencyRelation} from "nlptoolkit-dependencyparser/dist/Universal/UniversalDependencyRelation";
+
+export class StackRelation {
+
+    private readonly word: UniversalDependencyTreeBankWord
+    private readonly relation: UniversalDependencyRelation
+
+    constructor(word: UniversalDependencyTreeBankWord, relation: UniversalDependencyRelation) {
+        this.word = word
+        this.relation = relation
+    }
+
+    clone(): StackRelation{
+        return new StackRelation(this.word.clone(), this.relation)
+    }
+
+    getWord(): UniversalDependencyTreeBankWord{
+        return this.word
+    }
+
+    getRelation(): UniversalDependencyRelation{
+        return this.relation
+    }
+}

package/source/Parser/TransitionBasedParser/StackWord.ts

@@ -0,0 +1,38 @@
+import {
+    UniversalDependencyTreeBankWord
+} from "nlptoolkit-dependencyparser/dist/Universal/UniversalDependencyTreeBankWord";
+
+export class StackWord {
+
+    private word: UniversalDependencyTreeBankWord
+    private toWord: number
+
+    constructor1() {
+        this.word = new UniversalDependencyTreeBankWord()
+    }
+
+    constructor2(word: UniversalDependencyTreeBankWord, toWord: number){
+        this.word = word
+        this.toWord = toWord
+    }
+
+    clone(): StackWord{
+        return new StackWord(this.word.clone(), this.toWord)
+    }
+
+    constructor(word?: UniversalDependencyTreeBankWord, toWord?: number) {
+        if (word == undefined){
+            this.constructor1()
+        } else {
+            this.constructor2(word, toWord)
+        }
+    }
+
+    getWord(): UniversalDependencyTreeBankWord{
+        return this.word
+    }
+
+    getToWord(): number{
+        return this.toWord
+    }
+}

package/source/Parser/TransitionBasedParser/State.ts

@@ -0,0 +1,168 @@
+import {StackWord} from "./StackWord";
+import {StackRelation} from "./StackRelation";
+import {UniversalDependencyType} from "nlptoolkit-dependencyparser/dist/Universal/UniversalDependencyType";
+import {UniversalDependencyRelation} from "nlptoolkit-dependencyparser/dist/Universal/UniversalDependencyRelation";
+import {
+    UniversalDependencyTreeBankWord
+} from "nlptoolkit-dependencyparser/dist/Universal/UniversalDependencyTreeBankWord";
+
+export class State {
+
+    private stack: Array<StackWord>
+    private wordList: Array<StackWord>
+    private relations: Array<StackRelation>
+
+    constructor(stack: Array<StackWord>, wordList: Array<StackWord>, relations: Array<StackRelation>){
+        this.stack = stack
+        this.wordList = wordList
+        this.relations = relations
+    }
+
+    public applyShift(){
+        if (this.wordList.length > 0){
+            this.stack.push(this.wordList.splice(0, 1)[0])
+        }
+    }
+
+    public applyLeftArc(type: UniversalDependencyType){
+        if (this.stack.length > 1){
+            let beforeLast = this.stack[this.stack.length - 2].getWord()
+            let index = this.stack[this.stack.length - 1].getToWord()
+            beforeLast.setRelation(new UniversalDependencyRelation(index, type.toString().replace("_", ":")))
+            this.stack.splice(this.stack.length - 2, 1)
+            this.relations.push(new StackRelation(beforeLast, new UniversalDependencyRelation(index, type.toString().replace("_", ":"))))
+        }
+    }
+
+    public applyRightArc(type: UniversalDependencyType){
+        if (this.stack.length > 1){
+            let last = this.stack[this.stack.length - 1].getWord()
+            let index = this.stack[this.stack.length - 2].getToWord()
+            last.setRelation(new UniversalDependencyRelation(index, type.toString().replace("_", ":")))
+            this.stack.pop()
+            this.relations.push(new StackRelation(last, new UniversalDependencyRelation(index, type.toString().replace("_", ":"))))
+        }
+    }
+
+    public applyArcEagerLeftArc(type: UniversalDependencyType){
+        if (this.stack.length > 0 && this.wordList.length > 0){
+            let lastElementOfStack = this.stack[this.stack.length - 1].getWord()
+            let index = this.wordList[0].getToWord()
+            lastElementOfStack.setRelation(new UniversalDependencyRelation(index, type.toString().replace("_", ":")))
+            this.stack.pop()
+            this.relations.push(new StackRelation(lastElementOfStack, new UniversalDependencyRelation(index, type.toString().replace("_", ":"))))
+        }
+    }
+
+    public applyArcEagerRightArc(type: UniversalDependencyType){
+        if (this.stack.length > 0 && this.wordList.length > 0){
+            let firstElementOfWordList = this.wordList[0].getWord()
+            let index = this.stack[this.stack.length - 1].getToWord()
+            firstElementOfWordList.setRelation(new UniversalDependencyRelation(index, type.toString().replace("_", ":")))
+            this.applyShift()
+            this.relations.push(new StackRelation(firstElementOfWordList, new UniversalDependencyRelation(index, type.toString().replace("_", ":"))))
+        }
+    }
+
+    public applyReduce(){
+        if (this.stack.length > 0){
+            this.stack.pop()
+        }
+    }
+
+    public apply(command: Command, type: UniversalDependencyType, transitionSystem: TransitionSystem){
+        switch (transitionSystem){
+            case TransitionSystem.ARC_STANDARD:
+                switch (command) {
+                    case Command.LEFTARC:
+                        this.applyLeftArc(type)
+                        break
+                    case Command.RIGHTARC:
+                        this.applyRightArc(type)
+                        break
+                    case Command.SHIFT:
+                        this.applyShift()
+                        break
+                }
+                break
+            case TransitionSystem.ARC_EAGER:
+                switch (command){
+                    case Command.LEFTARC:
+                        this.applyArcEagerLeftArc(type)
+                        break
+                    case Command.RIGHTARC:
+                        this.applyArcEagerRightArc(type)
+                        break
+                    case Command.SHIFT:
+                        this.applyShift()
+                        break
+                    case Command.REDUCE:
+                        this.applyReduce()
+                        break
+                }
+        }
+    }
+
+    public relationSize(): number{
+        return this.relations.length
+    }
+
+    public wordListSize(): number{
+        return this.wordList.length
+    }
+
+    public stackSize(): number{
+        return this.stack.length
+    }
+
+    public getStackWord(index: number): UniversalDependencyTreeBankWord{
+        let size = this.stack.length - 1
+        if (size - index < 0){
+            return null
+        }
+        return this.stack[size - index].getWord()
+    }
+
+    public getPeek(): UniversalDependencyTreeBankWord{
+        if (this.stack.length > 0){
+            return this.stack[this.stack.length - 1].getWord()
+        }
+        return null
+    }
+
+    public getWordListWord(index: number): UniversalDependencyTreeBankWord{
+        if (index > this.wordList.length - 1){
+            return null
+        }
+        return this.wordList[index].getWord()
+    }
+
+    public getRelation(index: number): StackRelation{
+        if (index < this.relations.length){
+            return this.relations[index]
+        }
+        return null
+    }
+
+    public clone(): State{
+        let o = new State(new Array<StackWord>(), new Array<StackWord>(), new Array<StackRelation>())
+        for (let element of this.stack){
+            if (element.getWord().getName() != "root"){
+                o.stack.push(element.clone())
+            } else {
+                o.stack.push(new StackWord(new UniversalDependencyTreeBankWord(), element.getToWord()))
+            }
+        }
+        for (let word of this.wordList){
+            o.wordList.push(word.clone())
+        }
+        for (let relation of this.relations){
+            if (relation.getWord().getName() != "root"){
+                o.relations.push(relation.clone())
+            } else {
+                o.relations.push(new StackRelation(new UniversalDependencyTreeBankWord(), relation.getRelation()))
+            }
+        }
+        return o
+    }
+}

package/source/Parser/TransitionBasedParser/TransitionParser.ts

@@ -0,0 +1,187 @@
+import {
+    UniversalDependencyTreeBankSentence
+} from "nlptoolkit-dependencyparser/dist/Universal/UniversalDependencyTreeBankSentence";
+import {
+    UniversalDependencyTreeBankWord
+} from "nlptoolkit-dependencyparser/dist/Universal/UniversalDependencyTreeBankWord";
+import {
+    UniversalDependencyTreeBankCorpus
+} from "nlptoolkit-dependencyparser/dist/Universal/UniversalDependencyTreeBankCorpus";
+import {DataSet} from "nlptoolkit-classification/dist/DataSet/DataSet";
+import {Instance} from "nlptoolkit-classification/dist/Instance/Instance";
+import {Oracle} from "./Oracle";
+import {Agenda} from "./Agenda";
+import {State} from "./State";
+import {StackWord} from "./StackWord";
+import {StackRelation} from "./StackRelation";
+import {Candidate} from "./Candidate";
+import {UniversalDependencyType} from "nlptoolkit-dependencyparser/dist/Universal/UniversalDependencyType";
+import {UniversalDependencyRelation} from "nlptoolkit-dependencyparser/dist/Universal/UniversalDependencyRelation";
+import {ScoringOracle} from "./ScoringOracle";
+
+export abstract class TransitionParser {
+
+    /**
+     * Parses a single sentence and returns a list of instances that represent the parsing process.
+     * @param sentence the sentence to be parsed
+     * @param windowSize the size of the window used in parsing
+     * @return a list of {@link Instance} objects representing the parsing process
+     */
+    abstract simulateParse(sentence: UniversalDependencyTreeBankSentence, windowSize: number): Array<Instance>
+
+    /**
+     * Parses a single sentence using a specified oracle and returns the parsed sentence with dependencies.
+     * @param universalDependencyTreeBankSentence the sentence to be parsed
+     * @param oracle the oracle used for guiding the parsing process
+     * @return a {@link UniversalDependencyTreeBankSentence} with dependencies parsed
+     */
+    abstract dependencyParse(universalDependencyTreeBankSentence: UniversalDependencyTreeBankSentence, oracle: Oracle): UniversalDependencyTreeBankSentence
+
+    protected constructor() {
+    }
+
+    /**
+     * Creates a new {@link UniversalDependencyTreeBankSentence} with the same words as the input sentence,
+     * but with null heads, effectively cloning the sentence structure without dependencies.
+     * @param universalDependencyTreeBankSentence the sentence to be cloned
+     * @return a new {@link UniversalDependencyTreeBankSentence} with copied words but no dependencies
+     */
+    protected createResultSentence(universalDependencyTreeBankSentence: UniversalDependencyTreeBankSentence): UniversalDependencyTreeBankSentence{
+        let sentence = new UniversalDependencyTreeBankSentence()
+        for (let i = 0; i < universalDependencyTreeBankSentence.wordCount(); i++) {
+            let word = universalDependencyTreeBankSentence.getWord(i)
+            if (word instanceof UniversalDependencyTreeBankWord){
+                sentence.addWord(new UniversalDependencyTreeBankWord(word.getId(), word.getName(), word.getLemma(), word.getUpos(), word.getXpos(), word.getFeatures(), null, word.getDeps(), word.getMisc()))
+            }
+        }
+        return sentence;
+    }
+
+    /**
+     * Simulates parsing a corpus of sentences, returning a dataset of instances created by parsing each sentence.
+     * @param corpus the corpus to be parsed
+     * @param windowSize the size of the window used in parsing
+     * @return a {@link DataSet} containing instances from parsing each sentence in the corpus
+     */
+    public simulateParseOnCorpus(corpus: UniversalDependencyTreeBankCorpus, windowSize: number): DataSet{
+        let dataSet = new DataSet()
+        for (let i = 0; i < corpus.sentenceCount(); i++) {
+            let sentence = corpus.getSentence(i)
+            if (sentence instanceof UniversalDependencyTreeBankSentence){
+                dataSet.addInstanceList(this.simulateParse(sentence, windowSize))
+            }
+        }
+        return dataSet;
+    }
+
+    /**
+     * Checks if there are any states in the agenda that still have words to process or have more than one item in the stack.
+     * @param agenda the agenda containing the states
+     * @return true if there are states to process, false otherwise
+     */
+    private checkStates(agenda: Agenda): boolean{
+        for (let state of agenda.getKeySet()){
+            if (state.wordListSize() > 0 || state.stackSize() > 1){
+                return true
+            }
+        }
+        return false
+    }
+
+    /**
+     * Initializes the parsing state with a stack containing one empty {@link StackWord} and a word list containing all words in the sentence.
+     * @param sentence the sentence to initialize the state with
+     * @return a {@link State} representing the starting point for parsing
+     */
+    protected initialState(sentence: UniversalDependencyTreeBankSentence): State{
+        let wordList = new Array<StackWord>();
+        for (let i = 0; i < sentence.wordCount(); i++) {
+            let word = sentence.getWord(i)
+            if (word instanceof UniversalDependencyTreeBankWord){
+                wordList.push(new StackWord(word, i + 1))
+            }
+        }
+        let stack = new Array<StackWord>()
+        stack.push(new StackWord())
+        return new State(stack, wordList, new Array<StackRelation>())
+    }
+
+    /**
+     * Constructs possible parsing candidates based on the current state and transition system.
+     * @param transitionSystem the transition system used (ARC_STANDARD or ARC_EAGER)
+     * @param state the current parsing state
+     * @return a list of possible {@link Candidate} actions to be applied
+     */
+    private constructCandidates(transitionSystem: TransitionSystem, state: State): Array<Candidate>{
+        if (state.stackSize() == 1 && state.wordListSize() == 0) {
+            return new Array<Candidate>()
+        }
+        let subsets = new Array<Candidate>()
+        if (state.wordListSize() > 0) {
+            subsets.push(new Candidate(Command.SHIFT, UniversalDependencyType.DEP))
+        }
+        if (transitionSystem == TransitionSystem.ARC_EAGER && state.stackSize() > 0) {
+            subsets.push(new Candidate(Command.REDUCE, UniversalDependencyType.DEP))
+        }
+        for (let i = 0; i < UniversalDependencyRelation.universalDependencyTypes.length; i++) {
+            let type = UniversalDependencyRelation.getDependencyTag(UniversalDependencyRelation.universalDependencyTypes[i])
+            if (transitionSystem == TransitionSystem.ARC_STANDARD && state.stackSize() > 1) {
+                subsets.push(new Candidate(Command.LEFTARC, type))
+                subsets.push(new Candidate(Command.RIGHTARC, type))
+            } else if (transitionSystem == TransitionSystem.ARC_EAGER && state.stackSize() > 0 && state.wordListSize() > 0) {
+                subsets.push(new Candidate(Command.LEFTARC, type))
+                subsets.push(new Candidate(Command.RIGHTARC, type))
+            }
+        }
+        return subsets
+    }
+
+    /**
+     * Performs dependency parsing with beam search to find the best parse for a given sentence.
+     * @param oracle the scoring oracle used for guiding the search
+     * @param beamSize the size of the beam for beam search
+     * @param universalDependencyTreeBankSentence the sentence to be parsed
+     * @param transitionSystem the transition system used (ARC_STANDARD or ARC_EAGER)
+     * @return the best parsing state from the beam search
+     */
+    public dependencyParseWithBeamSearch(oracle: ScoringOracle,
+                                         beamSize: number,
+                                         universalDependencyTreeBankSentence: UniversalDependencyTreeBankSentence,
+                                         transitionSystem: TransitionSystem): State{
+        let sentence = this.createResultSentence(universalDependencyTreeBankSentence)
+        let initialState = this.initialState(sentence)
+        let agenda = new Agenda(beamSize)
+        agenda.updateAgenda(oracle, initialState.clone())
+        while (this.checkStates(agenda)) {
+            for (let state of agenda.getKeySet()) {
+                let subsets = this.constructCandidates(transitionSystem, state)
+                for (let subset of subsets) {
+                    let command = subset.getCommand()
+                    let type = subset.getUniversalDependencyType()
+                    let cloneState = state.clone()
+                    cloneState.apply(command, type, transitionSystem)
+                    agenda.updateAgenda(oracle, cloneState.clone())
+                }
+            }
+        }
+        return agenda.best()
+    }
+
+    /**
+     * Parses a corpus of sentences using the given oracle and returns a new corpus with the parsed sentences.
+     * @param universalDependencyTreeBankCorpus the corpus to be parsed
+     * @param oracle the oracle used for guiding the parsing process
+     * @return a {@link UniversalDependencyTreeBankCorpus} containing the parsed sentences
+     */
+    public dependencyParseCorpus(universalDependencyTreeBankCorpus: UniversalDependencyTreeBankCorpus,
+                                 oracle: Oracle){
+        let corpus = new UniversalDependencyTreeBankCorpus()
+        for (let i = 0; i < universalDependencyTreeBankCorpus.sentenceCount(); i++) {
+            let sentence = universalDependencyTreeBankCorpus.getSentence(i)
+            if (sentence instanceof UniversalDependencyTreeBankSentence){
+                corpus.addSentence(this.dependencyParse(sentence, oracle))
+            }
+        }
+        return corpus
+    }
+}

package/source/Parser/TransitionBasedParser/TransitionSystem.ts

@@ -0,0 +1,3 @@
+enum TransitionSystem {
+    ARC_STANDARD, ARC_EAGER
+}

package/source/tsconfig.json

@@ -0,0 +1,13 @@
+{
+    "compilerOptions": {
+        "outDir": "../dist",
+        "module": "umd",
+        "target": "es6",
+        "sourceMap": true,
+        "noImplicitAny": true,
+        "strictNullChecks": false,
+        "removeComments": false,
+        "moduleResolution": "node",
+        "declaration": true
+    }
+}