Laboratoire ICAR » Plateforme TXM

		TreeSearchSelector s = getSelectorForCorpus(corpus, TreeSearchPreferences.getInstance().getString(TreeSearchPreferences.DEFAULT_VISUALISATION));

				TreeSearchSelector s = getSelectorForCorpus(corpus, TreeSearchPreferences.getInstance().getString(TreeSearchPreferences.DEFAULT_VISUALISATION));

package org.txm.treesearch.preferences;

import org.eclipse.ui.IWorkbench;

import org.txm.rcp.IImageKeys;

import org.txm.rcp.preferences.TXMPreferencePage;

import org.txm.rcp.preferences.TXMPreferenceStore;

import org.txm.treesearch.rcp.Messages;

/**

 * Syntatic annotations preferences page

 * 

 * @author mdecorde

 *

 */

public class SyntacticAnnotationPreferencePage extends TXMPreferencePage {

	@Override

	public void createFieldEditors() {

		//this.addField(new StringFieldEditor(TreeSearchPreferences.DEFAULT_VISUALISATION, Messages.SyntacticVisualisation, this.getFieldEditorParent()));

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @see

	 * org.eclipse.ui.IWorkbenchPreferencePage#init(org.eclipse.ui.IWorkbench)

	 */

	@Override

	public void init(IWorkbench workbench) {

		this.setPreferenceStore(new TXMPreferenceStore(TreeSearchPreferences.getInstance().getPreferencesNodeQualifier()));

		this.setDescription(Messages.SyntacticAnnotation);

		this.setImageDescriptor(IImageKeys.getImageDescriptor(this.getClass(), "icons/functions/Tree.png")); //$NON-NLS-1$

	}

}

 * TreeSearch command preferences page

		this.addField(new StringFieldEditor(TreeSearchPreferences.DEFAULT_VISUALISATION, Messages.DefaultSyntacticVisualisation, this.getFieldEditorParent()));

DefaultSyntacticVisualisation=Default Syntactic annotation

SyntacticTree=Syntactic tree

SyntacticVisualisation=Syntactic representation

	public static String SyntacticTree;

	public static String DefaultSyntacticVisualisation;

	public static String SyntacticVisualisation;

import org.txm.rcp.messages.TXMUIMessages;

		GridLayout qlayout = new GridLayout(1, false);

		qlayout.horizontalSpacing = 0;

//		qlayout.verticalSpacing = 0;

		// first line

		GLComposite line1 = new GLComposite(queryPanel, SWT.NONE, "line1");

		line1.getLayout().numColumns = 13;

		line1.getLayout().horizontalSpacing = 5;

		line1.setLayoutData(new GridData(GridData.FILL, GridData.FILL, true, true));

		Label l = new Label(line1, SWT.NONE);

		l.setText(TXMUIMessages.query); //$NON-NLS-1$

		l.setLayoutData(new GridData(GridData.CENTER, GridData.CENTER, false, false));

		queryArea = new LargeQueryField(line1, SWT.BORDER | SWT.V_SCROLL | SWT.H_SCROLL, currentSelector.getQueryClass());

		queryAreaLayoutData.horizontalSpan = 12;

		// second line

		GLComposite line2 = new GLComposite(queryPanel, SWT.NONE, "line2");

		line2.getLayout().numColumns = 4;

		line2.getLayout().horizontalSpacing = 5;

		line2.setLayoutData(new GridData(GridData.FILL, GridData.FILL, true, true));

		Label l1 = new Label(line2, SWT.NONE);

		l1.setText("T "); //$NON-NLS-1$

		l1.setLayoutData(new GridData(SWT.CENTER, SWT.CENTER, false, false));

		TCombo = new Combo(line2, SWT.READ_ONLY);

		Label l2 = new Label(line2, SWT.NONE);

		l2.setText("NT "); //$NON-NLS-1$

		l2.setLayoutData(new GridData(SWT.CENTER, SWT.CENTER, false, false));

		NTCombo = new Combo(line2, SWT.READ_ONLY);

		// bottom toolbar

		navigationAreaComposite.getLayout().verticalSpacing = 5;

		navigationAreaComposite.getLayout().horizontalSpacing = 5;

		Label l3 = new Label(navigationAreaComposite, SWT.NONE);

		l3.setText("Match "); //$NON-NLS-1$

		gdata = new GridData(SWT.FILL, SWT.CENTER, false, false);

		l3.setLayoutData(gdata);

		gdata = new GridData(SWT.FILL, SWT.CENTER, false, false);

		gdata = new GridData(SWT.FILL, SWT.CENTER, false, false);

		new Label(navigationAreaComposite, SWT.NONE);

		Label l4 = new Label(navigationAreaComposite, SWT.NONE);

		l4.setText("Sub-Match "); //$NON-NLS-1$

		gdata = new GridData(SWT.FILL, SWT.CENTER, false, false);

		l4.setLayoutData(gdata);

		gdata = new GridData(SWT.FILL, SWT.CENTER, false, false);

		gdata = new GridData(SWT.FILL, SWT.CENTER, false, false);

page.name = Syntactic Tree

page.name2 = Syntactic Annotations

page.name = Arbre syntaxique

page.name2 = Annotations syntaxiques

            category="org.txm.rcp.preferences.UserPreferencePage"

      <page

            category="org.txm.rcp.preferences.AdvancePreferencePage"

            class="org.txm.treesearch.preferences.SyntacticAnnotationPreferencePage"

            id="org.txm.treesearch.preferences.SyntacticAnnotationPreferencePage"

            name="%page.name2">

      </page>

	public static final String DEFAULT_VISUALISATION = "default_representation";

		preferences.put(DEFAULT_VISUALISATION, "TIGER");

import org.eclipse.osgi.util.NLS;

	public String getComputingStartMessage() {

		return NLS.bind("Rendering {0} Syntactic Tree...", this.getSelector().getEngine());

	}

import org.txm.rcp.messages.TXMUIMessages;

import org.txm.utils.messages.Utf8NLS;

	private static final String BUNDLE_NAME = "org.txm.perl.rcp.messages"; //$NON-NLS-1$

		Utf8NLS.initializeMessages(BUNDLE_NAME, TXMUIMessages.class);

import org.txm.tigersearch.preferences.TigerSearchTreePreferences;

		boolean useSubMatches = TigerSearchTreePreferences.getInstance().getBoolean(TigerSearchTreePreferences.USESUBMATCHES);

package org.txm.tigersearch.rcp.preferences;

import org.eclipse.jface.preference.BooleanFieldEditor;

import org.eclipse.jface.preference.StringFieldEditor;

import org.eclipse.ui.IWorkbench;

import org.txm.rcp.IImageKeys;

import org.txm.rcp.preferences.TXMPreferencePage;

import org.txm.rcp.preferences.TXMPreferenceStore;

import org.txm.tigersearch.preferences.TigerSearchTreePreferences;

/**

 * TIGERSearch preferences page

 * 

 * @author mdecorde

 *

 */

public class TigerSearchTreePreferencePage extends TXMPreferencePage {

	@Override

	public void createFieldEditors() {

		this.addField(new StringFieldEditor(TigerSearchTreePreferences.TFEATURE, "Default T feature to show ", this.getFieldEditorParent()));

		this.addField(new StringFieldEditor(TigerSearchTreePreferences.NTFEATURE, "Default NT feature to show", this.getFieldEditorParent()));

		this.addField(new BooleanFieldEditor(TigerSearchTreePreferences.USESUBMATCHES, "Use sub matches", this.getFieldEditorParent()));

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @see

	 * org.eclipse.ui.IWorkbenchPreferencePage#init(org.eclipse.ui.IWorkbench)

	 */

	@Override

	public void init(IWorkbench workbench) {

		this.setPreferenceStore(new TXMPreferenceStore(TigerSearchTreePreferences.getInstance().getPreferencesNodeQualifier()));

		this.setImageDescriptor(IImageKeys.getImageDescriptor(this.getClass(), "icons/functions/TS.png"));

	}

}

            class="org.txm.tigersearch.rcp.preferences.TigerSearchTreePreferencePage"

            id="org.txm.tigersearch.rcp.preferences.TigerSearchTreePreferencePage"

            name="%page.name">

      </page>

      <page

            category="org.txm.treesearch.preferences.SyntacticAnnotationPreferencePage"

package org.txm.conllu.rcp.preferences;

import org.eclipse.jface.preference.BooleanFieldEditor;

import org.eclipse.jface.preference.StringFieldEditor;

import org.eclipse.ui.IWorkbench;

import org.txm.conllu.core.preferences.UDTreePreferences;

import org.txm.rcp.IImageKeys;

import org.txm.rcp.preferences.TXMPreferencePage;

import org.txm.rcp.preferences.TXMPreferenceStore;

/**

 * UD Tree preferences page

 * 

 * @author mdecorde

 *

 */

public class UDTreePreferencePage extends TXMPreferencePage {

	@Override

	public void createFieldEditors() {

		this.addField(new StringFieldEditor(UDTreePreferences.ENGINE, "Engine", this.getFieldEditorParent()));

		this.addField(new BooleanFieldEditor(UDTreePreferences.PRINTCONLLUSENTENCES, "Print CoNLL-U sentence when browsing the matches", this.getFieldEditorParent()));

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @see

	 * org.eclipse.ui.IWorkbenchPreferencePage#init(org.eclipse.ui.IWorkbench)

	 */

	@Override

	public void init(IWorkbench workbench) {

		this.setPreferenceStore(new TXMPreferenceStore(UDTreePreferences.getInstance().getPreferencesNodeQualifier()));

		this.setImageDescriptor(IImageKeys.getImageDescriptor(this.getClass(), "icons/functions/UD.png"));

	}

}

package org.txm.conllu.rcp.preferences;

import org.eclipse.jface.preference.BooleanFieldEditor;

import org.eclipse.jface.preference.StringFieldEditor;

import org.eclipse.ui.IWorkbench;

import org.txm.conllu.core.preferences.UDPreferences;

import org.txm.rcp.IImageKeys;

import org.txm.rcp.preferences.TXMPreferencePage;

import org.txm.rcp.preferences.TXMPreferenceStore;

/**

 * UD preferences page

 * 

 * @author mdecorde

 *

 */

public class CoNLLUPreferencePage extends TXMPreferencePage {

	@Override

	public void createFieldEditors() {

		this.addField(new BooleanFieldEditor(UDPreferences.IMPORT_USE_NEW_DOC_ID, "Use new odc id when importing CoNLL-U files", this.getFieldEditorParent()));

		this.addField(new BooleanFieldEditor(UDPreferences.KEEP_CONTRACTIONS, "Keep word contractions when importing CoNLL-U files", this.getFieldEditorParent()));

		this.addField(new StringFieldEditor(UDPreferences.UDPREFIX, "UD properties prefix", this.getFieldEditorParent()));

		this.addField(new StringFieldEditor(UDPreferences.IMPORT_HEAD_TO_PROJECT, "UD head properties to project (comma separated list)", this.getFieldEditorParent()));

		this.addField(new StringFieldEditor(UDPreferences.IMPORT_DEPS_TO_PROJECT, "UD deps properties to project (comma separated list)", this.getFieldEditorParent()));

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @see

	 * org.eclipse.ui.IWorkbenchPreferencePage#init(org.eclipse.ui.IWorkbench)

	 */

	@Override

	public void init(IWorkbench workbench) {

		this.setPreferenceStore(new TXMPreferenceStore(UDPreferences.getInstance().getPreferencesNodeQualifier()));

		this.setImageDescriptor(IImageKeys.getImageDescriptor(this.getClass(), "icons/functions/UD.png"));

	}

}

// -*- Mode: JavaScript; tab-width: 4; indent-tabs-mode: nil; -*-

// vim:set ft=javascript ts=4 sw=4 sts=4 cindent:

/*

CoNLL-U format library for JavaScript.

Home: http://github.com/spyysalo/conllu.js

Format: http://universaldependencies.github.io/docs/format.html

Author: Sampo Pyysalo

License: MIT (http://opensource.org/licenses/MIT)

*/

var ConllU = (function(window, undefined) {

    /*

     * ConllU.Document: represents CoNLL-U document

     */

    var Document = function() {

        this.reset();

    };

    Document.prototype.reset = function() {

        this.sentences = [];

        this.error = false;

        this.logger = function(s) { /* no-op */ };

        this.strict = null; // pick heuristically

    };

    Document.prototype.log = function(message) {

        this.logger(message);

    };

    Document.prototype.logError = function(message) {

        this.log('error: ' + message);

        this.error = true;

    };

    /* Parse CoNLL-U format, return Document.

     * (see http://universaldependencies.github.io/docs/format.html)

     *

     * CoNLL-U files contain three types of lines:

     * 1.  Word lines

     * 2.  Blank lines marking sentence boundaries

     * 3.  Comment lines starting with a hash ("#")        

     *

     * Each word line has the following format

     * 1.  ID: Word index, integer starting at 1 for each new sentence; 

     *     may be a range for tokens with multiple words; may be a decimal

     *     number for empty nodes.

     * 2.  FORM: Word form or punctuation symbol.

     * 3.  LEMMA: Lemma or stem of word form.

     * 4.  UPOSTAG: Universal part-of-speech tag.

     * 5.  XPOSTAG: Language-specific part-of-speech tag; underscore

     *     if not available.

     * 6.  FEATS: List of morphological features from the Universal 

     *     feature inventory or from a defined language-specific extension;

     *      underscore if not available.

     * 7.  HEAD: Head of the current token, which is either a value of ID

     *     or zero (0).

     * 8.  DEPREL: Universal Stanford dependency relation to the HEAD

     *     (root iff HEAD = 0) or a defined language-specific subtype

     *     of one.

     * 9.  DEPS: List of secondary dependencies (head-deprel pairs).

     * 10. MISC: Any other annotation.

     */

    Document.prototype.parse = function(input, logger, strict) {

        // discard previous state, if any

        this.reset();

        if (logger !== undefined) {

            this.logger = logger;

        }

        if (strict !== undefined) {

            this.strict = strict;

        }

        // TODO: handle other newline formats

        var lines = input.split('\n');

        if (this.strict === null) {

            this.strict = selectParsingMode(input, this.logger);

        }

        // select splitter to use for dividing the lines into fields.

        var splitter = selectFieldSplitter(input, this.logger, this.strict);

        var elements = [],            

            comments = [],

            beforeSentence = true;

        for (var idx=0; idx<lines.length; idx++) {

            var line = lines[idx], that = this;

            var logLineError = function(message) {

                that.logError('line '+(idx+1)+': '+message+' ("'+line+'")');

                that.error = true;

            }

            if (isComment(line)) {

                if (beforeSentence) {

                    comments.push(line);

                } else {

                    logLineError('comments must precede sentence, ignoring');

                }

                continue;

            }

            // non-comment, assume inside sentence until terminated by

            // blank line

            beforeSentence = false;

            var fields = splitter(line);

            if (fields.length === 0) {

                // empty line, terminates sentence

                if (elements.length !== 0) {

                    var sId = 'S' + (this.sentences.length+1);

                    var sentence = new Sentence(sId, elements, comments);

                    this.sentences.push(sentence);

                } else {

                    logLineError('empty sentence, ignoring');

                }

                // reset

                elements = [];

                comments = [];

                beforeSentence = true;

                continue;

            }

            if (fields.length !== 10) {

                logLineError('expected 10 fields, got '+fields.length);

                repairFields(fields, this.logger);

            }

            var element = new Element(fields, idx, line);

            var issues = element.validate();

            for (var j=0; j<issues.length; j++) {

                logLineError(issues[j]);

            }

            if (issues.length !== 0) {

                if (!element.repair(this.logger)) {

                    logLineError('repair failed, discarding line');

                    continue; // failed, ignore line

                }

            }

            elements.push(element);

        }

        // If elements is non-empty, last sentence ended without its

        // expected terminating empty line. Process, but warn if strict.

        if (elements.length !== 0) {

            if (this.strict) {

                this.logError('missing blank line after last sentence');

            }

            var sId = 'S' + (this.sentences.length+1);

            var sentence = new Sentence(sId, elements, comments);

            this.sentences.push(sentence);

            // reset

            elements = [];

            comments = [];

            beforeSentence = true;

        }

        // If comments is non-empty, there were comments after the

        // terminating empty line. Warn and discard.

        if (comments.length !== 0) {

            this.logError('comments may not occur after last sentence, '+

                          'ignoring');

        }

        return this;

    }

    Document.prototype.toBrat = function(logger, includeEmpty) {

        if (logger !== undefined) {

            this.logger = logger;

        }

        if (includeEmpty === undefined) {

            includeEmpty = false;    // hide empty nodes by default

        }

        // merge brat data over all sentences

        var mergedBratData = {},

            textOffset = 0;

        var categories = [

            'entities',

            'attributes',

            'relations',

            'comments',

            'styles',

            'sentlabels'

        ];

        for (var i=0; i<categories.length; i++) {

            mergedBratData[categories[i]] = [];

        }

        mergedBratData['text'] = '';

        for (var i=0; i<this.sentences.length; i++) {

            var sentence = this.sentences[i];

            var issues = sentence.validate();

            for (var j=0; j<issues.length; j++) {

                this.logError(issues[j]);

            }

            if (issues.length !== 0) {

                if (!sentence.repair(this.logger)) {

                    this.logError('repair failed, discarding sentence');

                    continue;

                }

            }

            sentence.setBaseOffset(textOffset !== 0 ? textOffset + 1 : 0);

            bratData = sentence.toBrat(includeEmpty);

            // merge

            if (mergedBratData['text'].length !== 0) {

                mergedBratData['text'] += '\n';

                textOffset += 1;

            }

            mergedBratData['text'] += bratData['text'];

            textOffset += bratData['text'].length;

            for (var j=0; j<categories.length; j++) {

                var c = categories[j];

                mergedBratData[c] = mergedBratData[c].concat(bratData[c]);

            }

        }

        // to avoid brat breakage on error, don't send empty text

        if (mergedBratData['text'].length === 0) {

            mergedBratData['text'] = '<EMPTY>';

        }

        mergedBratData['error'] = this.error;

        return mergedBratData;

    };

    /*

     * ConllU.Sentence: represents CoNLL-U sentence

     */

    var Sentence = function(sentenceId, elements, comments) {

        this.id = sentenceId;

        this.elements = elements;

        this.comments = comments;

        this.baseOffset = 0;

    };

    // set offset of first character in sentence (for standoff

    // generation)

    Sentence.prototype.setBaseOffset = function(baseOffset) {

        this.baseOffset = baseOffset;

    }

    Sentence.prototype.dependencies = function() {

        var dependencies = [];

        for (var i=0; i<this.elements.length; i++) {

            var element = this.elements[i];

            dependencies = dependencies.concat(element.dependencies());

        }

        return dependencies;

    };

    Sentence.prototype.words = function(includeEmpty) {

        return this.elements.filter(function(e) { 

            return (e.isWord() || (includeEmpty && e.isEmptyNode()));

        });

    };

    Sentence.prototype.multiwords = function() {

        return this.elements.filter(function(e) {

            return e.isMultiword();

        });

    };

    Sentence.prototype.tokens = function() {

        // extract token sequence by omitting word IDs that are

        // included in a multiword token range.

        var multiwords = this.multiwords();

        var inRange = {};

        for (var i=0; i<multiwords.length; i++) {

            var mw = multiwords[i];

            for (var j=mw.rangeFrom(); j<=mw.rangeTo(); j++) {

                inRange[j] = true;

            }

        }

        return this.elements.filter(function(e) {

            return e.isToken(inRange);

        });

    };

    // return words with possible modifications for visualization with

    // brat

    Sentence.prototype.bratWords = function(includeEmpty) {

        var words = this.words(includeEmpty);

        for (var i=0; i<words.length; i++) {

            if (isRtl(words[i].form)) {

                words[i] = deepCopy(words[i]);

                words[i].form = rtlFix(words[i].form);

            }

        }

        return words;

    };

    // return tokens with possible modifications for visualization

    // with brat

    Sentence.prototype.bratTokens = function() {

        var tokens = this.tokens();

        for (var i=0; i<tokens.length; i++) {

            tokens[i] = deepCopy(tokens[i]);

            tokens[i].form = rtlFix(tokens[i].form);

        }

        return tokens;

    };

    // return the text of the sentence for visualization with brat

    Sentence.prototype.bratText = function(includeEmpty) {

        var words = this.bratWords(includeEmpty);

        var tokens = this.bratTokens();

        var wordText = words.map(function(w) { return w.form }).join(' ');

        var tokenText = tokens.map(function(w) { return w.form }).join(' ');

        var combinedText = wordText;

        if (wordText != tokenText) {

            combinedText += '\n' + tokenText;

        }

        return combinedText;

    };

    // return the annotated text spans of the sentence for visualization

    // with brat.

    Sentence.prototype.bratSpans = function(includeEmpty) {

        var spans = [],

            offset = this.baseOffset;

        // create an annotation for each word

        var words = this.bratWords(includeEmpty);

        for (var i=0; i<words.length; i++) {

            var length = words[i].form.length;

            spans.push([this.id+'-T'+words[i].id, words[i].upostag,

                        [[offset, offset+length]]]);

            offset += length + 1;

        }

        return spans;

    }

    // return attributes of sentence annotations for visualization

    // with brat.

    Sentence.prototype.bratAttributes = function(includeEmpty) {

        var words = this.words(includeEmpty);

        // create attributes for word features

        var attributes = [],

            aidseq = 1;

        for (var i=0; i<words.length; i++) {

            var word = words[i],

                tid = this.id+'-T'+word.id;

            var nameVals = word.features();

            for (var j=0; j<nameVals.length; j++) {

                var name = nameVals[j][0], 

                    value = nameVals[j][1];

                attributes.push([this.id+'-A'+aidseq++, name, tid, value]);

            }

        }

        return attributes;

    };

    // return relations for sentence dependencies for visualization

    // with brat.

    Sentence.prototype.bratRelations = function(includeEmpty) {

        var dependencies = this.dependencies();

        var relations = [];

        for (var i=0; i<dependencies.length; i++) {

            var dep = dependencies[i];

            relations.push([this.id+'-R'+i, dep[2], 

                            [ [ 'arg1', this.id+'-T'+dep[1] ],

                              [ 'arg2', this.id+'-T'+dep[0] ] ] ]);

        }

        return relations;

    };

    // return comments (notes) on sentence annotations for

    // visualization with brat.

    Sentence.prototype.bratComments = function(includeEmpty) {

        var words = this.words(includeEmpty);

        // TODO: better visualization for LEMMA, XPOSTAG, and MISC.

        var comments = [];

        for (var i=0; i<words.length; i++) {

            var word = words[i],

                tid = this.id+'-T'+word.id,

                label = 'AnnotatorNotes';

            comments.push([tid, label, 'Lemma: ' + word.lemma]);

            if (word.xpostag !== '_') {

                comments.push([tid, label, 'Xpostag: ' + word.xpostag]);

            }

            if (word.misc !== '_') {

                comments.push([tid, label, 'Misc: ' + word.misc]);

            }

        }

        return comments;

    };

    // Return styles on sentence annotations for visualization with

    // brat. Note: this feature is an extension of both the CoNLL-U

    // comment format and the basic brat data format.

    Sentence.prototype.bratStyles = function(includeEmpty) {

        var styles = [],

            wildcards = [];

        for (var i=0; i<this.comments.length; i++) {

            var comment = this.comments[i];

            m = comment.match(/^(\#\s*visual-style\s+)(.*)/);

            if (!m) {

                continue;

            }

            var styleSpec = m[2];

            // Attempt to parse as a visual style specification. The

            // expected format is "REF<SPACE>STYLE", where REF

            // is either a single ID (for a span), a space-separated

            // ID1 ID2 TYPE triple (for a relation), or a special

            // wildcard value like "arcs", and STYLE is either

            // a colon-separated key-value pair or a color.

            m = styleSpec.match(/^([^\t]+)\s+(\S+)\s*$/);

            if (!m) {

                // TODO: avoid console.log

                console.log('warning: failed to parse: "'+comment+'"');

                continue;

            }

            var reference = m[1], style = m[2];

            // split style into key and value, adding a key to

            // color-only styles as needed for the reference type.

            var key, value;

            m = style.match(/^(\S+):(\S+)$/);

            if (m) {

                key = m[1];

                value = m[2];

            } else {

                value = style;

                if (reference === 'arcs' || reference.indexOf(' ') !== -1) {

                    key = 'color';

                } else {

                    key = 'bgColor';

                }

            }

            // store wildcards for separate later processing

            if (reference.match(/^(nodes|arcs)$/)) {

                wildcards.push([reference, key, value]);

                continue;

            }

            // adjust every ID in reference for brat

            if (reference.indexOf(' ') === -1) {

                reference = this.id + '-T' + reference;

            } else {

                reference = reference.split(' ');

                reference[0] = this.id + '-T' + reference[0];

                reference[1] = this.id + '-T' + reference[1];

            }

            styles.push([reference, key, value]);

        }

        // for expanding wildcards, first determine which words / arcs

        // styles have already been set, and then add the style to

        // everything that hasn't.

        var setStyle = {};

        for (var i=0; i<styles.length; i++) {

            setStyle[styles[i][0].concat([styles[i][1]])] = true;

        }

        for (var i=0; i<wildcards.length; i++) {

            var reference = wildcards[i][0],

                key = wildcards[i][1],

                value = wildcards[i][2];

            if (reference === 'nodes') {

                var words = this.words(includeEmpty);

                for (var j=0; j<words.length; j++) {

                    var r = this.id + '-T' + words[j].id;

                    if (!setStyle[r.concat([key])]) {

                        styles.push([r, key, value]);

                        setStyle[r.concat([key])] = true;

                    }

                }

            } else if (reference === 'arcs') {

                var deps = this.dependencies();

                for (var j=0; j<deps.length; j++) {

                    var r = [this.id + '-T' + deps[j][1],

                             this.id + '-T' + deps[j][0],

                             deps[j][2]];

                    if (!setStyle[r.concat([key])]) {

                        styles.push([r, key, value]);

                        setStyle[r.concat([key])] = true;

                    }

                }

            } else {

                console.log('internal error');

            }

        }

        return styles;

    };

    // Return label of sentence for visualization with brat, or null

    // if not defined. Note: this feature is an extension of both the

    // CoNLL-U comment format and the basic brat data format.

    Sentence.prototype.bratLabel = function() {

        var label = null;

        for (var i=0; i<this.comments.length; i++) {

            var comment = this.comments[i];

            m = comment.match(/^(\#\s*sentence-label\b)(.*)/);

            if (!m) {

                continue;

            }

            label = m[2].trim();

        }

        return label;

    };

    // Return representation of sentence in brat embedded format (see

    // http://brat.nlplab.org/embed.html).

    // If includeEmpty is truthy, include empty nodes in the representation.

    // Note: "styles" is an extension, not part of the basic format.

    Sentence.prototype.toBrat = function(includeEmpty) {

        var text = this.bratText(includeEmpty);

        var spans = this.bratSpans(includeEmpty);

        var attributes = this.bratAttributes(includeEmpty);

        var relations = this.bratRelations(includeEmpty);

        var comments = this.bratComments(includeEmpty);

        var styles = this.bratStyles(includeEmpty);

        var labels = [this.bratLabel()];

        return {

            'text': text,

            'entities': spans,

            'attributes': attributes,

            'relations': relations,

            'comments': comments,

            'styles': styles,

            'sentlabels': labels,

        };

    };

    Sentence.prototype.elementById = function() {

        var elementById = {};

        for (var i=0; i<this.elements.length; i++) {

            elementById[this.elements[i].id] = this.elements[i];

        }

        return elementById;

    };

    Sentence.prototype.addError = function(issue, element, issues) {

        issues.push('line '+(element.lineidx+1)+': '+issue+' ("'+element.line+'")');

    }

    // Check validity of the sentence. Return list of strings

    // representing issues found in validation (empty list if none).

    Sentence.prototype.validate = function() {

        var issues = [];

        this.validateUniqueIds(issues);

        this.validateWordSequence(issues);

        this.validateMultiwordSequence(issues);

        this.validateEmptyNodeSequence(issues);

        this.validateReferences(issues);

        return issues;

    };

    // Check for presence of ID duplicates

    Sentence.prototype.validateUniqueIds = function(issues) {

        issues = (issues !== undefined ? issues : []);

        var initialIssueCount = issues.length;

        var elementById = {};

        for (var i=0; i<this.elements.length; i++) {

            var element = this.elements[i];

            if (elementById[element.id] !== undefined) {

                this.addError('non-unique ID "'+element.id+'"',

                              element, issues);

            }

            elementById[element.id] = element;

        }

        return issues.length === initialIssueCount;

    };

    // Check validity of word ID sequence (should be 1,2,3,...)

    Sentence.prototype.validateWordSequence = function(issues) {

        issues = (issues !== undefined ? issues : []);

        var initialIssueCount = issues.length;

        var expectedId = 1;

        for (var i=0; i<this.elements.length; i++) {

            var element = this.elements[i];

            if (element.isMultiword() || element.isEmptyNode()) {

                continue; // only check simple word sequence here

            }

            if (parseInt(element.id, 10) !== expectedId) {

                this.addError('word IDs should be 1,2,3,..., ' +

                              'expected '+expectedId+', got '+element.id,

                              element, issues);

            }

            expectedId = parseInt(element.id, 10) + 1;

        }

        return issues.length === initialIssueCount;

    };

    // Check that multiword token ranges are valid

    Sentence.prototype.validateMultiwordSequence = function(issues) {

        issues = (issues !== undefined ? issues : []);

        var initialIssueCount = issues.length;

        var expectedId = 1;

        for (var i=0; i<this.elements.length; i++) {

            var element = this.elements[i];

            if (element.isMultiword() && element.rangeFrom() !== expectedId) {

                this.addError('multiword tokens must appear before '+

                              'first word in their range',

                              element, issues);

            } else {

                expectedId = parseInt(element.id, 10) + 1;

            }

        }

        return issues.length === initialIssueCount;

    };

    Sentence.prototype.validateEmptyNodeSequence = function(issues) {

        issues = (issues !== undefined ? issues : []);

        var initialIssueCount = issues.length;

        var previousWordId = '0';    // TODO check https://github.com/UniversalDependencies/docs/issues/382

        var nextEmptyNodeId = 1;

        for (var i=0; i<this.elements.length; i++) {

            var element = this.elements[i];

            if (element.isWord()) {

                previousWordId = element.id;

                nextEmptyNodeId = 1;

            } else if (element.isEmptyNode()) {

                var expectedId = previousWordId + '.' + nextEmptyNodeId;

                if (element.id !== expectedId) {

                    this.addError('empty node IDs should be *.1, *.2, ... ' +

                                  'expected '+expectedId+', got '+element.id,

                                  element, issues);

                }

                nextEmptyNodeId++;

            }

        }

        return issues.length === initialIssueCount;

    }

    // Check validity of ID references in HEAD and DEPS.

    Sentence.prototype.validateReferences = function(issues) {

        issues = (issues !== undefined ? issues : []);

        var initialIssueCount = issues.length;

        var elementById = this.elementById();

        for (var i=0; i<this.elements.length; i++) {

            var element = this.elements[i];

            // validate HEAD

            if (!element.validHeadReference(elementById)) {

                this.addError('HEAD is not valid ID: "'+element.head+'"',

                              element, issues);

            }

            // validate DEPS

            var elemDeps = element.dependencies(true);

            for (var j=0; j<elemDeps.length; j++) {

                var head = elemDeps[j][1];

                if (head !== '0' && elementById[head] === undefined) {

                    this.addError('invalid ID "'+head+'" in DEPS',

                                  element, issues);

                }

            }

        }

        return issues.length === initialIssueCount;

    };

    Sentence.prototype.repair = function(log) {

        log = (log !== undefined ? log : nullLogger);

        if (!this.validateUniqueIds()) {

            this.repairUniqueIds(log);

        }

        if (!this.validateWordSequence()) {

            this.repairWordSequence(log);

        }

        if (!this.validateMultiwordSequence()) {

            this.repairMultiwordSequence(log);

        }

        if (!this.validateEmptyNodeSequence()) {

            this.repairEmptyNodeSequence(log);

        }

        if (!this.validateReferences()) {

            this.repairReferences(log);

        }

        var issues = this.validate();

        return issues.length === 0;

    };

    Sentence.prototype.repairUniqueIds = function(log) {

        log = (log !== undefined ? log : nullLogger);

        var elementById = {},

            filtered = [];

        for (var i=0; i<this.elements.length; i++) {

            var element = this.elements[i];

            if (elementById[element.id] === undefined) {

                elementById[element.id] = element;

                filtered.push(element);

            } else {

                log('repair: remove element with duplicate ID "'+element.id+'"');

            }

        }

        this.elements = filtered;

        return true;

    };

    Sentence.prototype.repairWordSequence = function(log) {

        log('TODO: implement ConllU.Sentence.repairWordSequence()');

        return true;

    };

    Sentence.prototype.repairMultiwordSequence = function(log) {

        log('TODO: implement ConllU.Sentence.repairMultiwordSequence()');

        return true;

    };

    Sentence.prototype.repairEmptyNodeSequence = function(log) {

        log('TODO: implement ConllU.Sentence.repairEmptyNodeSequence()');

        return true;

    };

    Sentence.prototype.repairReferences = function(log) {

        log = (log !== undefined ? log : nullLogger);

        var elementById = this.elementById();

        for (var i=0; i<this.elements.length; i++) {

            var element = this.elements[i];

            // repair HEAD if not valid

            if (!element.validHeadReference(elementById)) {

                log('repair: blanking invalid HEAD');

                element.head = null;

            }

            // repair DEPS if not valid

            if (element.deps === '_') {

                continue;

            }

            var deparr = element.deps.split('|'),

                filtered = [];

            for (var j=0; j<deparr.length; j++) {

                var dep = deparr[j];

                var m = dep.match(dependencyRegex);

                if (m) {

                    var head = m[1], deprel = m[2];

                    if (head === '0' || elementById[head] !== undefined) {

                        filtered.push(dep);

                    } else {