WebSVN – corrade-http-templates – Blame – Rev 15 – /inventoryBrowser/js/jstree/jstree.js

 * jslint: loopfunc: true, browser: true, ass: true, bitwise: true, continue: true, nomen: true, plusplus: true, regexp: true, unparam: true, todo: true, white: true

27

*/

28

/*jshint -W083 */

29

30

// prevent another load? maybe there is a better way?

if($.jstree) {

return;

}

/**

* ### jsTree core functionality

37

*/

38

39

// internal variables

40

var instance_counter = 0,

ccp_node = false,

ccp_mode = false,

ccp_inst = false,

themes_loaded = [],

45

src = $('script:last').attr('src'),

46

document = window.document, // local variable is always faster to access then a global

47

_node = document.createElement('LI'), _temp1, _temp2;

48

49

_node.setAttribute('role', 'treeitem');

50

_temp1 = document.createElement('I');

51

_temp1.className = 'jstree-icon jstree-ocl';

52

_temp1.setAttribute('role', 'presentation');

53

_node.appendChild(_temp1);

54

_temp1 = document.createElement('A');

55

_temp1.className = 'jstree-anchor';

56

_temp1.setAttribute('href','#');

57

_temp1.setAttribute('tabindex','-1');

58

_temp2 = document.createElement('I');

59

_temp2.className = 'jstree-icon jstree-themeicon';

60

_temp2.setAttribute('role', 'presentation');

61

_temp1.appendChild(_temp2);

62

_node.appendChild(_temp1);

63

_temp1 = _temp2 = null;

/**

	 * holds all jstree related functions and variables, including the actual class and methods to create, access and manipulate instances.

* @name $.jstree

*/

$.jstree = {

/**

* specifies the jstree version in use

73

* @name $.jstree.version

*/

version : '3.3.2',

/**

* holds all the default options used when creating new instances

78

* @name $.jstree.defaults

*/

defaults : {

/**

			 * configure which plugins will be active on an instance. Should be an array of strings, where each element is a plugin name. The default is `[]`

83

* @name $.jstree.defaults.plugins

*/

plugins : []

},

/**

* stores all loaded jstree plugins (used internally)

89

* @name $.jstree.plugins

90

*/

91

plugins : {},

92

path : src && src.indexOf('/') !== -1 ? src.replace(/\/[^\/]+$/,'') : '',

93

idregex : /[\\:&!^|()\[\]<>@*'+~#";.,=\- \/${}%?`]/g,

<> root : '#'

<> };

<> /**

<> * creates a jstree instance

98

<> * @name $.jstree.create(el [, options])

99

<> * @param {DOMElement|jQuery|String} el the element to create the instance on, can be jQuery extended or a selector

100

<> * @param {Object} options options for this instance (extends `$.jstree.defaults`)

101

<> * @return {jsTree} the new instance

102

<> */

103

<> $.jstree.create = function (el, options) {

104

<> var tmp = new $.jstree.core(++instance_counter),

105

<> opt = options;

106

<> options = $.extend(true, {}, $.jstree.defaults, options);

107

<> if(opt && opt.plugins) {

108

<> options.plugins = opt.plugins;

109

<> }

110

<> $.each(options.plugins, function (i, k) {

111

<> if(i !== 'core') {

112

<> tmp = tmp.plugin(k, options[k]);

113

<> }

114

<> });

115

<> $(el).data('jstree', tmp);

116

<> tmp.init(el, options);

<> return tmp;

<> };

<> /**

<> * remove all traces of jstree from the DOM and destroy all instances

121

<> * @name $.jstree.destroy()

122

<> */

123

<> $.jstree.destroy = function () {

124

<> $('.jstree:jstree').jstree('destroy');

125

<> $(document).off('.jstree');

126

<> };

127

<> /**

128

<> * the jstree class constructor, used only internally

129

<> * @private

130

<> * @name $.jstree.core(id)

131

<> * @param {Number} id this instance's index

132

<> */

133

<> $.jstree.core = function (id) {

134

<> this._id = id;

135

<> this._cnt = 0;

136

<> this._wrk = null;

<> this._data = {

<> core : {

<> themes : {

<> name : false,

<> dots : false,

<> icons : false

<> },

<> selected : [],

<> last_error : {},

146

<> working : false,

147

<> worker_queue : [],

<> focused : null

<> }

<> };

<> };

<> /**

<> * get a reference to an existing instance

<> *

<> * __Examples__

<> *

<> * // provided a container with an ID of "tree", and a nested node with an ID of "branch"

158

<> * // all of there will return the same instance

159

<> * $.jstree.reference('tree');

160

<> * $.jstree.reference('#tree');

161

<> * $.jstree.reference($('#tree'));

162

<> * $.jstree.reference(document.getElementByID('tree'));

163

<> * $.jstree.reference('branch');

164

<> * $.jstree.reference('#branch');

165

<> * $.jstree.reference($('#branch'));

166

<> * $.jstree.reference(document.getElementByID('branch'));

167

<> *

168

<> * @name $.jstree.reference(needle)

169

<> * @param {DOMElement|jQuery|String} needle

170

<> * @return {jsTree|null} the instance or `null` if not found

171

<> */

172

<> $.jstree.reference = function (needle) {

173

<> var tmp = null,

174

<> obj = null;

175

<> if(needle && needle.id && (!needle.tagName || !needle.nodeType)) { needle = needle.id; }

176

177

<> if(!obj || !obj.length) {

178

<> try { obj = $(needle); } catch (ignore) { }

179

<> }

180

<> if(!obj || !obj.length) {

181

<> try { obj = $('#' + needle.replace($.jstree.idregex,'\\$&')); } catch (ignore) { }

182

<> }

183

<> if(obj && obj.length && (obj = obj.closest('.jstree')).length && (obj = obj.data('jstree'))) {

<> tmp = obj;

<> }

<> else {

<> $('.jstree').each(function () {

188

<> var inst = $(this).data('jstree');

189

<> if(inst && inst._model.data[needle]) {

<> tmp = inst;

<> return false;

<> }

<> });

<> }

<> return tmp;

<> };

<> /**

<> * Create an instance, get an instance or invoke a command on a instance.

199

<> *

200

<>	 * If there is no instance associated with the current node a new one is created and `arg` is used to extend `$.jstree.defaults` for this new instance. There would be no return value (chaining is not broken).

201

<> *

202

<>	 * If there is an existing instance and `arg` is a string the command specified by `arg` is executed on the instance, with any additional arguments passed to the function. If the function returns a value it will be returned (chaining could break depending on function).

203

<> *

204

<>	 * If there is an existing instance and `arg` is not a string the instance itself is returned (similar to `$.jstree.reference`).

205

<> *

206

<> * In any other case - nothing is returned and chaining is not broken.

<> *

<> * __Examples__

<> *

<> * $('#tree1').jstree(); // creates an instance

211

<> * $('#tree2').jstree({ plugins : [] }); // create an instance with some options

212

<>	 *	$('#tree1').jstree('open_node', '#branch_1'); // call a method on an existing instance, passing additional arguments

213

<> * $('#tree2').jstree(); // get an existing instance (or create an instance)

214

<> * $('#tree2').jstree(true); // get an existing instance (will not create new instance)

215

<> * $('#branch_1').jstree().select_node('#branch_1'); // get an instance (using a nested element and call a method)

216

<> *

217

<> * @name $().jstree([arg])

218

<> * @param {String|Object} arg

219

<> * @return {Mixed}

220

<> */

221

<> $.fn.jstree = function (arg) {

222

<> // check for string argument

223

<> var is_method = (typeof arg === 'string'),

224

<> args = Array.prototype.slice.call(arguments, 1),

225

<> result = null;

226

<> if(arg === true && !this.length) { return false; }

227

<> this.each(function () {

228

<> // get the instance (if there is one) and method (if it exists)

229

<> var instance = $.jstree.reference(this),

230

<> method = is_method && instance ? instance[arg] : null;

231

<> // if calling a method, and method is available - execute on the instance

232

<> result = is_method && method ?

233

<> method.apply(instance, args) :

234

<> null;

235

<> // if there is no instance and no method is being called - create one

236

<> if(!instance && !is_method && (arg === undefined || $.isPlainObject(arg))) {

237

<> $.jstree.create(this, arg);

238

<> }

239

<> // if there is an instance and no method is called - return the instance

240

<> if( (instance && !is_method) || arg === true ) {

241

<> result = instance || false;

242

<> }

243

<> // if there was a method call which returned a result - break and return the value

244

<> if(result !== null && result !== undefined) {

<> return false;

<> }

<> });

<> // if there was a method call with a valid return value - return that, otherwise continue the chain

249

<> return result !== null && result !== undefined ?

<> result : this;

<> };

<> /**

<> * used to find elements containing an instance

<> *

<> * __Examples__

<> *

<> * $('div:jstree').each(function () {

258

<> * $(this).jstree('destroy');

259

<> * });

260

<> *

261

<> * @name $(':jstree')

262

<> * @return {jQuery}

263

<> */

264

<> $.expr.pseudos.jstree = $.expr.createPseudo(function(search) {

265

<> return function(a) {

266

<> return $(a).hasClass('jstree') &&

267

<> $(a).data('jstree') !== undefined;

<> };

<> });

<> /**

<> * stores all defaults for the core

273

<> * @name $.jstree.defaults.core

274

<> */

275

<> $.jstree.defaults.core = {

276

<> /**

277

<> * data configuration

278

<> *

279

<>		 * If left as `false` the HTML inside the jstree container element is used to populate the tree (that should be an unordered list with list items).

280

<> *

281

<> * You can also pass in a HTML string or a JSON array here.

282

<> *

283

<>		 * It is possible to pass in a standard jQuery-like AJAX config and jstree will automatically determine if the response is JSON or HTML and use that to populate the tree.

284

<>		 * In addition to the standard jQuery ajax options here you can suppy functions for `data` and `url`, the functions will be run in the current instance's scope and a param will be passed indicating which node is being loaded, the return value of those functions will be used.

285

<> *

286

<>		 * The last option is to specify a function, that function will receive the node being loaded as argument and a second param which is a function which should be called with the result.

<> *

<> * __Examples__

<> *

<> * // AJAX

<> * $('#tree').jstree({

292

<> * 'core' : {

293

<> * 'data' : {

294

<> * 'url' : '/get/children/',

295

<> * 'data' : function (node) {

296

<> * return { 'id' : node.id };

<> * }

<> * }

<> * });

<> *

<> * // direct data

302

<> * $('#tree').jstree({

303

<> * 'core' : {

304

<> * 'data' : [

305

<> * 'Simple root node',

306

<> * {

307

<> * 'id' : 'node_2',

308

<> * 'text' : 'Root node with options',

309

<> * 'state' : { 'opened' : true, 'selected' : true },

310

<> * 'children' : [ { 'text' : 'Child 1' }, 'Child 2']

<> * }

<> * ]

<> * }

<> * });

<> *

<> * // function

<> * $('#tree').jstree({

318

<> * 'core' : {

319

<> * 'data' : function (obj, callback) {

320

<> * callback.call(this, ['Root 1', 'Root 2']);

<> * }

<> * });

<> *

<> * @name $.jstree.defaults.core.data

<> */

<> data : false,

<> /**

<> * configure the various strings used throughout the tree

329

<> *

330

<> * You can use an object where the key is the string you need to replace and the value is your replacement.

331

<>		 * Another option is to specify a function which will be called with an argument of the needed string and should return the replacement.

332

<> * If left as `false` no replacement is made.

<> *

<> * __Examples__

<> *

<> * $('#tree').jstree({

337

<> * 'core' : {

338

<> * 'strings' : {

339

<> * 'Loading ...' : 'Please wait ...'

<> * }

<> * }

<> * });

<> *

<> * @name $.jstree.defaults.core.strings

345

<> */

346

<> strings : false,

347

<> /**

348

<> * determines what happens when a user tries to modify the structure of the tree

349

<> * If left as `false` all operations like create, rename, delete, move or copy are prevented.

350

<> * You can set this to `true` to allow all interactions or use a function to have better control.

<> *

<> * __Examples__

<> *

<> * $('#tree').jstree({

355

<> * 'core' : {

356

<> * 'check_callback' : function (operation, node, node_parent, node_position, more) {

357

<> * // operation can be 'create_node', 'rename_node', 'delete_node', 'move_node' or 'copy_node'

358

<> * // in case of 'rename_node' node_position is filled with the new node name

359

<> * return operation === 'rename_node' ? true : false;

<> * }

<> * }

<> * });

<> *

<> * @name $.jstree.defaults.core.check_callback

365

<> */

366

<> check_callback : false,

367

<> /**

368

<>		 * a callback called with a single object parameter in the instance's scope when something goes wrong (operation prevented, ajax failed, etc)

369

<> * @name $.jstree.defaults.core.error

<> */

<> error : $.noop,

<> /**

<>		 * the open / close animation duration in milliseconds - set this to `false` to disable the animation (default is `200`)

374

<> * @name $.jstree.defaults.core.animation

375

<> */

376

<> animation : 200,

377

<> /**

378

<> * a boolean indicating if multiple nodes can be selected

379

<> * @name $.jstree.defaults.core.multiple

380

<> */

381

<> multiple : true,

382

<> /**

383

<> * theme configuration object

384

<> * @name $.jstree.defaults.core.themes

<> */

<> themes : {

<> /**

<> * the name of the theme to use (if left as `false` the default theme is used)

389

<> * @name $.jstree.defaults.core.themes.name

<> */

<> name : false,

<> /**

<>			 * the URL of the theme's CSS file, leave this as `false` if you have manually included the theme CSS (recommended). You can set this to `true` too which will try to autoload the theme.

394

<> * @name $.jstree.defaults.core.themes.url

<> */

<> url : false,

<> /**

<> * the location of all jstree themes - only used if `url` is set to `true`

399

<> * @name $.jstree.defaults.core.themes.dir

<> */

<> dir : false,

<> /**

<> * a boolean indicating if connecting dots are shown

404

<> * @name $.jstree.defaults.core.themes.dots

<> */

<> dots : true,

<> /**

<> * a boolean indicating if node icons are shown

409

<> * @name $.jstree.defaults.core.themes.icons

<> */

<> icons : true,

<> /**

<> * a boolean indicating if the tree background is striped

414

<> * @name $.jstree.defaults.core.themes.stripes

415

<> */

416

<> stripes : false,

417

<> /**

418

<> * a string (or boolean `false`) specifying the theme variant to use (if the theme supports variants)

419

<> * @name $.jstree.defaults.core.themes.variant

420

<> */

421

<> variant : false,

422

<> /**

423

<>			 * a boolean specifying if a reponsive version of the theme should kick in on smaller screens (if the theme supports it). Defaults to `false`.

424

<> * @name $.jstree.defaults.core.themes.responsive

425

<> */

426

<> responsive : false

427

<> },

428

<> /**

429

<>		 * if left as `true` all parents of all selected nodes will be opened once the tree loads (so that all selected nodes are visible to the user)

430

<> * @name $.jstree.defaults.core.expand_selected_onload

431

<> */

432

<> expand_selected_onload : true,

433

<> /**

434

<>		 * if left as `true` web workers will be used to parse incoming JSON data where possible, so that the UI will not be blocked by large requests. Workers are however about 30% slower. Defaults to `true`

435

<> * @name $.jstree.defaults.core.worker

<> */

<> worker : true,

<> /**

<> * Force node text to plain text (and escape HTML). Defaults to `false`

440

<> * @name $.jstree.defaults.core.force_text

441

<> */

442

<> force_text : false,

443

<> /**

444

<> * Should the node should be toggled if the text is double clicked . Defaults to `true`

445

<> * @name $.jstree.defaults.core.dblclick_toggle

446

<> */

447

<> dblclick_toggle : true

448

<> };

449

<> $.jstree.core.prototype = {

450

<> /**

451

<> * used to decorate an instance with a plugin. Used internally.

452

<> * @private

453

<> * @name plugin(deco [, opts])

454

<> * @param {String} deco the plugin to decorate with

455

<> * @param {Object} opts options for the plugin

456

<> * @return {jsTree}

457

<> */

458

<> plugin : function (deco, opts) {

459

<> var Child = $.jstree.plugins[deco];

460

<> if(Child) {

461

<> this._data[deco] = {};

462

<> Child.prototype = this;

463

<> return new Child(opts, this);

<> }

<> return this;

<> },

<> /**

<> * initialize the instance. Used internally.

469

<> * @private

470

<> * @name init(el, optons)

471

<> * @param {DOMElement|jQuery|String} el the element we are transforming

472

<> * @param {Object} options options for this instance

473

<> * @trigger init.jstree, loading.jstree, loaded.jstree, ready.jstree, changed.jstree

474

<> */

475

<> init : function (el, options) {

<> this._model = {

<> data : {},

<> changed : [],

<> force_full_redraw : false,

480

<> redraw_timeout : false,

481

<> default_state : {

482

<> loaded : true,

483

<> opened : false,

484

<> selected : false,

485

<> disabled : false

486

<> }

487

<> };

488

<> this._model.data[$.jstree.root] = {

489

<> id : $.jstree.root,

<> parent : null,

<> parents : [],

<> children : [],

<> children_d : [],

494

<> state : { loaded : false }

495

<> };

496

497

<> this.element = $(el).addClass('jstree jstree-' + this._id);

498

<> this.settings = options;

499

500

<> this._data.core.ready = false;

501

<> this._data.core.loaded = false;

502

<> this._data.core.rtl = (this.element.css("direction") === "rtl");

503

<> this.element[this._data.core.rtl ? 'addClass' : 'removeClass']("jstree-rtl");

504

<> this.element.attr('role','tree');

505

<> if(this.settings.core.multiple) {

506

<> this.element.attr('aria-multiselectable', true);

507

<> }

508

<> if(!this.element.attr('tabindex')) {

509

<> this.element.attr('tabindex','0');

<> }

<> this.bind();

<> /**

<> * triggered after all events are bound

515

<> * @event

516

<> * @name init.jstree

517

<> */

518

<> this.trigger("init");

519

520

<> this._data.core.original_container_html = this.element.find(" > ul > li").clone(true);

521

<> this._data.core.original_container_html

522

<> .find("li").addBack()

523

<> .contents().filter(function() {

524

<> return this.nodeType === 3 && (!this.nodeValue || /^\s+$/.test(this.nodeValue));

525

<> })

526

<> .remove();

527

<>			this.element.html("<"+"ul class='jstree-container-ul jstree-children' role='group'><"+"li id='j"+this._id+"_loading' class='jstree-initial-node jstree-loading jstree-leaf jstree-last' role='tree-item'><i class='jstree-icon jstree-ocl'></i><"+"a class='jstree-anchor' href='#'><i class='jstree-icon jstree-themeicon-hidden'></i>" + this.get_string("Loading ...") + "</a></li></ul>");

528

<> this.element.attr('aria-activedescendant','j' + this._id + '_loading');

529

<> this._data.core.li_height = this.get_container_ul().children("li").first().height() || 24;

530

<> /**

531

<> * triggered after the loading text is shown and before loading starts

532

<> * @event

533

<> * @name loading.jstree

534

<> */

535

<> this.trigger("loading");

536

<> this.load_node($.jstree.root);

537

<> },

538

<> /**

539

<> * destroy an instance

540

<> * @name destroy()

541

<>		 * @param  {Boolean} keep_html if not set to `true` the container will be emptied, otherwise the current DOM elements will be kept intact

542

<> */

543

<> destroy : function (keep_html) {

544

<> if(this._wrk) {

545

<> try {

546

<> window.URL.revokeObjectURL(this._wrk);

547

<> this._wrk = null;

548

<> }

549

<> catch (ignore) { }

550

<> }

551

<> if(!keep_html) { this.element.empty(); }

552

<> this.teardown();

553

<> },

554

<> /**

555

<> * part of the destroying of an instance. Used internally.

556

<> * @private

557

<> * @name teardown()

558

<> */

559

<> teardown : function () {

560

<> this.unbind();

561

<> this.element

562

<> .removeClass('jstree')

563

<> .removeData('jstree')

564

<> .find("[class^='jstree']")

565

<> .addBack()

566

<> .attr("class", function () { return this.className.replace(/jstree[^ ]*|$/ig,''); });

567

<> this.element = null;

568

<> },

569

<> /**

570

<> * bind all events. Used internally.

<> * @private

<> * @name bind()

<> */

<> bind : function () {

<> var word = '',

<> tout = null,

<> was_click = 0;

<> this.element

<> .on("dblclick.jstree", function (e) {

580

<> if(e.target.tagName && e.target.tagName.toLowerCase() === "input") { return true; }

581

<> if(document.selection && document.selection.empty) {

582

<> document.selection.empty();

583

<> }

584

<> else {

585

<> if(window.getSelection) {

586

<> var sel = window.getSelection();

587

<> try {

588

<> sel.removeAllRanges();

589

<> sel.collapse();

590

<> } catch (ignore) { }

<> }

<> }

<> })

<> .on("mousedown.jstree", $.proxy(function (e) {

595

<> if(e.target === this.element[0]) {

596

<> e.preventDefault(); // prevent losing focus when clicking scroll arrows (FF, Chrome)

597

<> was_click = +(new Date()); // ie does not allow to prevent losing focus

598

<> }

599

<> }, this))

600

<> .on("mousedown.jstree", ".jstree-ocl", function (e) {

601

<> e.preventDefault(); // prevent any node inside from losing focus when clicking the open/close icon

602

<> })

603

<> .on("click.jstree", ".jstree-ocl", $.proxy(function (e) {

604

<> this.toggle_node(e.target);

605

<> }, this))

606

<> .on("dblclick.jstree", ".jstree-anchor", $.proxy(function (e) {

607

<> if(e.target.tagName && e.target.tagName.toLowerCase() === "input") { return true; }

608

<> if(this.settings.core.dblclick_toggle) {

609

<> this.toggle_node(e.target);

610

<> }

611

<> }, this))

612

<> .on("click.jstree", ".jstree-anchor", $.proxy(function (e) {

613

<> e.preventDefault();

614

<> if(e.currentTarget !== document.activeElement) { $(e.currentTarget).focus(); }

615

<> this.activate_node(e.currentTarget, e);

616

<> }, this))

617

<> .on('keydown.jstree', '.jstree-anchor', $.proxy(function (e) {

618

<> if(e.target.tagName && e.target.tagName.toLowerCase() === "input") { return true; }

619

<> if(e.which !== 32 && e.which !== 13 && (e.shiftKey || e.ctrlKey || e.altKey || e.metaKey)) { return true; }

620

<> var o = null;

621

<> if(this._data.core.rtl) {

622

<> if(e.which === 37) { e.which = 39; }

623

<> else if(e.which === 39) { e.which = 37; }

624

<> }

625

<> switch(e.which) {

626

<> case 32: // aria defines space only with Ctrl

627

<> if(e.ctrlKey) {

628

<> e.type = "click";

629

<> $(e.currentTarget).trigger(e);

630

<> }

631

<> break;

632

<> case 13: // enter

633

<> e.type = "click";

634

<> $(e.currentTarget).trigger(e);

635

<> break;

636

<> case 37: // left

637

<> e.preventDefault();

638

<> if(this.is_open(e.currentTarget)) {

639

<> this.close_node(e.currentTarget);

640

<> }

641

<> else {

642

<> o = this.get_parent(e.currentTarget);

643

<> if(o && o.id !== $.jstree.root) { this.get_node(o, true).children('.jstree-anchor').focus(); }

<> }

<> break;

<> case 38: // up

<> e.preventDefault();

648

<> o = this.get_prev_dom(e.currentTarget);

649

<> if(o && o.length) { o.children('.jstree-anchor').focus(); }

650

<> break;

651

<> case 39: // right

652

<> e.preventDefault();

653

<> if(this.is_closed(e.currentTarget)) {

654

<> this.open_node(e.currentTarget, function (o) { this.get_node(o, true).children('.jstree-anchor').focus(); });

655

<> }

656

<> else if (this.is_open(e.currentTarget)) {

657

<> o = this.get_node(e.currentTarget, true).children('.jstree-children')[0];

658

<> if(o) { $(this._firstChild(o)).children('.jstree-anchor').focus(); }

659

<> }

660

<> break;

661

<> case 40: // down

662

<> e.preventDefault();

663

<> o = this.get_next_dom(e.currentTarget);

664

<> if(o && o.length) { o.children('.jstree-anchor').focus(); }

665

<> break;

666

<> case 106: // aria defines * on numpad as open_all - not very common

667

<> this.open_all();

668

<> break;

669

<> case 36: // home

670

<> e.preventDefault();

671

<> o = this._firstChild(this.get_container_ul()[0]);

672

<> if(o) { $(o).children('.jstree-anchor').filter(':visible').focus(); }

673

<> break;

674

<> case 35: // end

675

<> e.preventDefault();

676

<> this.element.find('.jstree-anchor').filter(':visible').last().focus();

677

<> break;

678

<> case 113: // f2 - safe to include - if check_callback is false it will fail

679

<> e.preventDefault();

680

<> this.edit(e.currentTarget);

<> break;

<> default:

<> break;

<> /*!

<> // delete

<> case 46:

<> e.preventDefault();

688

<> o = this.get_node(e.currentTarget);

689

<> if(o && o.id && o.id !== $.jstree.root) {

690

<> o = this.is_selected(o) ? this.get_selected() : o;

691

<> this.delete_node(o);

<> }

<> break;

<> */

<> }

<> }, this))

<> .on("load_node.jstree", $.proxy(function (e, data) {

699

<> if(data.status) {

700

<> if(data.node.id === $.jstree.root && !this._data.core.loaded) {

701

<> this._data.core.loaded = true;

702

<> if(this._firstChild(this.get_container_ul()[0])) {

703

<> this.element.attr('aria-activedescendant',this._firstChild(this.get_container_ul()[0]).id);

704

<> }

705

<> /**

706

<> * triggered after the root node is loaded for the first time

707

<> * @event

708

<> * @name loaded.jstree

709

<> */

710

<> this.trigger("loaded");

711

<> }

712

<> if(!this._data.core.ready) {

713

<> setTimeout($.proxy(function() {

714

<> if(this.element && !this.get_container_ul().find('.jstree-loading').length) {

715

<> this._data.core.ready = true;

716

<> if(this._data.core.selected.length) {

717

<> if(this.settings.core.expand_selected_onload) {

718

<> var tmp = [], i, j;

719

<> for(i = 0, j = this._data.core.selected.length; i < j; i++) {

720

<> tmp = tmp.concat(this._model.data[this._data.core.selected[i]].parents);

721

<> }

722

<> tmp = $.vakata.array_unique(tmp);

723

<> for(i = 0, j = tmp.length; i < j; i++) {

724

<> this.open_node(tmp[i], false, 0);

725

<> }

726

<> }

727

<> this.trigger('changed', { 'action' : 'ready', 'selected' : this._data.core.selected });

728

<> }

729

<> /**

730

<> * triggered after all nodes are finished loading

731

<> * @event

732

<> * @name ready.jstree

733

<> */

734

<> this.trigger("ready");

<> }

<> }, this), 0);

<> }

<> }

<> }, this))

<> // quick searching when the tree is focused

741

<> .on('keypress.jstree', $.proxy(function (e) {

742

<> if(e.target.tagName && e.target.tagName.toLowerCase() === "input") { return true; }

743

<> if(tout) { clearTimeout(tout); }

744

<> tout = setTimeout(function () {

<> word = '';

<> }, 500);

<> var chr = String.fromCharCode(e.which).toLowerCase(),

749

<> col = this.element.find('.jstree-anchor').filter(':visible'),

750

<> ind = col.index(document.activeElement) || 0,

<> end = false;

<> word += chr;

<> // match for whole word from current node down (including the current node)

755

<> if(word.length > 1) {

756

<> col.slice(ind).each($.proxy(function (i, v) {

757

<> if($(v).text().toLowerCase().indexOf(word) === 0) {

<> $(v).focus();

<> end = true;

<> return false;

<> }

<> }, this));

<> if(end) { return; }

764

765

<> // match for whole word from the beginning of the tree

766

<> col.slice(0, ind).each($.proxy(function (i, v) {

767

<> if($(v).text().toLowerCase().indexOf(word) === 0) {

<> $(v).focus();

<> end = true;

<> return false;

<> }

<> }, this));

<> if(end) { return; }

774

<> }

775

<> // list nodes that start with that letter (only if word consists of a single char)

776

<> if(new RegExp('^' + chr.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&') + '+$').test(word)) {

777

<> // search for the next node starting with that letter

778

<> col.slice(ind + 1).each($.proxy(function (i, v) {

779

<> if($(v).text().toLowerCase().charAt(0) === chr) {

<> $(v).focus();

<> end = true;

<> return false;

<> }

<> }, this));

<> if(end) { return; }

786

787

<> // search from the beginning

788

<> col.slice(0, ind + 1).each($.proxy(function (i, v) {

789

<> if($(v).text().toLowerCase().charAt(0) === chr) {

<> $(v).focus();

<> end = true;

<> return false;

<> }

<> }, this));

<> if(end) { return; }

796

<> }

797

<> }, this))

798

<> // THEME RELATED

799

<> .on("init.jstree", $.proxy(function () {

800

<> var s = this.settings.core.themes;

801

<> this._data.core.themes.dots = s.dots;

802

<> this._data.core.themes.stripes = s.stripes;

803

<> this._data.core.themes.icons = s.icons;

804

<> this.set_theme(s.name || "default", s.url);

805

<> this.set_theme_variant(s.variant);

806

<> }, this))

807

<> .on("loading.jstree", $.proxy(function () {

808

<> this[ this._data.core.themes.dots ? "show_dots" : "hide_dots" ]();

809

<> this[ this._data.core.themes.icons ? "show_icons" : "hide_icons" ]();

810

<> this[ this._data.core.themes.stripes ? "show_stripes" : "hide_stripes" ]();

811

<> }, this))

812

<> .on('blur.jstree', '.jstree-anchor', $.proxy(function (e) {

813

<> this._data.core.focused = null;

814

<> $(e.currentTarget).filter('.jstree-hovered').mouseleave();

815

<> this.element.attr('tabindex', '0');

816

<> }, this))

817

<> .on('focus.jstree', '.jstree-anchor', $.proxy(function (e) {

818

<> var tmp = this.get_node(e.currentTarget);

819

<> if(tmp && tmp.id) {

820

<> this._data.core.focused = tmp.id;

821

<> }

822

<> this.element.find('.jstree-hovered').not(e.currentTarget).mouseleave();

823

<> $(e.currentTarget).mouseenter();

824

<> this.element.attr('tabindex', '-1');

825

<> }, this))

826

<> .on('focus.jstree', $.proxy(function () {

827

<> if(+(new Date()) - was_click > 500 && !this._data.core.focused) {

828

<> was_click = 0;

829

<> var act = this.get_node(this.element.attr('aria-activedescendant'), true);

830

<> if(act) {

831

<> act.find('> .jstree-anchor').focus();

<> }

<> }

<> }, this))

<> .on('mouseenter.jstree', '.jstree-anchor', $.proxy(function (e) {

836

<> this.hover_node(e.currentTarget);

837

<> }, this))

838

<> .on('mouseleave.jstree', '.jstree-anchor', $.proxy(function (e) {

839

<> this.dehover_node(e.currentTarget);

<> }, this));

<> },

<> /**

<> * part of the destroying of an instance. Used internally.

844

<> * @private

845

<> * @name unbind()

846

<> */

847

<> unbind : function () {

848

<> this.element.off('.jstree');

849

<> $(document).off('.jstree-' + this._id);

850

<> },

851

<> /**

852

<> * trigger an event. Used internally.

853

<> * @private

854

<> * @name trigger(ev [, data])

855

<> * @param {String} ev the name of the event to trigger

856

<> * @param {Object} data additional data to pass with the event

857

<> */

858

<> trigger : function (ev, data) {

<> if(!data) {

<> data = {};

<> }

<> data.instance = this;

863

<> this.element.triggerHandler(ev.replace('.jstree','') + '.jstree', data);

864

<> },

865

<> /**

866

<> * returns the jQuery extended instance container

867

<> * @name get_container()

868

<> * @return {jQuery}

869

<> */

870

<> get_container : function () {

871

<> return this.element;

872

<> },

873

<> /**

874

<> * returns the jQuery extended main UL node inside the instance container. Used internally.

875

<> * @private

876

<> * @name get_container_ul()

877

<> * @return {jQuery}

878

<> */

879

<> get_container_ul : function () {

880

<> return this.element.children(".jstree-children").first();

881

<> },

882

<> /**

883

<> * gets string replacements (localization). Used internally.

884

<> * @private

885

<> * @name get_string(key)

886

<> * @param {String} key

887

<> * @return {String}

888

<> */

889

<> get_string : function (key) {

890

<> var a = this.settings.core.strings;

891

<> if($.isFunction(a)) { return a.call(this, key); }

892

<> if(a && a[key]) { return a[key]; }

<> return key;

<> },

<> /**

<> * gets the first child of a DOM node. Used internally.

897

<> * @private

898

<> * @name _firstChild(dom)

899

<> * @param {DOMElement} dom

900

<> * @return {DOMElement}

901

<> */

902

<> _firstChild : function (dom) {

903

<> dom = dom ? dom.firstChild : null;

904

<> while(dom !== null && dom.nodeType !== 1) {

905

<> dom = dom.nextSibling;

<> }

<> return dom;

<> },

<> /**

<> * gets the next sibling of a DOM node. Used internally.

911

<> * @private

912

<> * @name _nextSibling(dom)

913

<> * @param {DOMElement} dom

914

<> * @return {DOMElement}

915

<> */

916

<> _nextSibling : function (dom) {

917

<> dom = dom ? dom.nextSibling : null;

918

<> while(dom !== null && dom.nodeType !== 1) {

919

<> dom = dom.nextSibling;

<> }

<> return dom;

<> },

<> /**

<> * gets the previous sibling of a DOM node. Used internally.

925

<> * @private

926

<> * @name _previousSibling(dom)

927

<> * @param {DOMElement} dom

928

<> * @return {DOMElement}

929

<> */

930

<> _previousSibling : function (dom) {

931

<> dom = dom ? dom.previousSibling : null;

932

<> while(dom !== null && dom.nodeType !== 1) {

933

<> dom = dom.previousSibling;

<> }

<> return dom;

<> },

<> /**

<>		 * get the JSON representation of a node (or the actual jQuery extended DOM node) by using any input (child DOM element, ID string, selector, etc)

939

<> * @name get_node(obj [, as_dom])

940

<> * @param {mixed} obj

941

<> * @param {Boolean} as_dom

942

<> * @return {Object|jQuery}

943

<> */

944

<> get_node : function (obj, as_dom) {

945

<> if(obj && obj.id) {

<> obj = obj.id;

<> }

<> var dom;

<> try {

<> if(this._model.data[obj]) {

951

<> obj = this._model.data[obj];

952

<> }

953

<> else if(typeof obj === "string" && this._model.data[obj.replace(/^#/, '')]) {

954

<> obj = this._model.data[obj.replace(/^#/, '')];

955

<> }

956

<>				else if(typeof obj === "string" && (dom = $('#' + obj.replace($.jstree.idregex,'\\$&'), this.element)).length && this._model.data[dom.closest('.jstree-node').attr('id')]) {

957

<> obj = this._model.data[dom.closest('.jstree-node').attr('id')];

958

<> }

959

<> else if((dom = $(obj, this.element)).length && this._model.data[dom.closest('.jstree-node').attr('id')]) {

960

<> obj = this._model.data[dom.closest('.jstree-node').attr('id')];

961

<> }

962

<> else if((dom = $(obj, this.element)).length && dom.hasClass('jstree')) {

963

<> obj = this._model.data[$.jstree.root];

<> }

<> else {

<> return false;

<> }

<> if(as_dom) {

<> obj = obj.id === $.jstree.root ? this.element : $('#' + obj.id.replace($.jstree.idregex,'\\$&'), this.element);

971

<> }

972

<> return obj;

973

<> } catch (ex) { return false; }

974

<> },

975

<> /**

976

<>		 * get the path to a node, either consisting of node texts, or of node IDs, optionally glued together (otherwise an array)

977

<> * @name get_path(obj [, glue, ids])

978

<> * @param {mixed} obj the node

979

<>		 * @param  {String} glue if you want the path as a string - pass the glue here (for example '/'), if a falsy value is supplied here, an array is returned

980

<> * @param {Boolean} ids if set to true build the path using ID, otherwise node text is used

981

<> * @return {mixed}

982

<> */

983

<> get_path : function (obj, glue, ids) {

984

<> obj = obj.parents ? obj : this.get_node(obj);

985

<> if(!obj || obj.id === $.jstree.root || !obj.parents) {

986

<> return false;

987

<> }

988

<> var i, j, p = [];

989

<> p.push(ids ? obj.id : obj.text);

990

<> for(i = 0, j = obj.parents.length; i < j; i++) {

991

<> p.push(ids ? obj.parents[i] : this.get_text(obj.parents[i]));

992

<> }

993

<> p = p.reverse().slice(1);

994

<> return glue ? p.join(glue) : p;

995

<> },

996

<> /**

997

<>		 * get the next visible node that is below the `obj` node. If `strict` is set to `true` only sibling nodes are returned.

998

<> * @name get_next_dom(obj [, strict])

999

<> * @param {mixed} obj

1000

<> * @param {Boolean} strict

1001

<> * @return {jQuery}

1002

<> */

1003

<> get_next_dom : function (obj, strict) {

1004

<> var tmp;

1005

<> obj = this.get_node(obj, true);

1006

<> if(obj[0] === this.element[0]) {

1007

<> tmp = this._firstChild(this.get_container_ul()[0]);

1008

<> while (tmp && tmp.offsetHeight === 0) {

1009

<> tmp = this._nextSibling(tmp);

1010

<> }

1011

<> return tmp ? $(tmp) : false;

1012

<> }

1013

<> if(!obj || !obj.length) {

<> return false;

<> }

<> if(strict) {

<> tmp = obj[0];

<> do {

<> tmp = this._nextSibling(tmp);

1020

<> } while (tmp && tmp.offsetHeight === 0);

1021

<> return tmp ? $(tmp) : false;

1022

<> }

1023

<> if(obj.hasClass("jstree-open")) {

1024

<> tmp = this._firstChild(obj.children('.jstree-children')[0]);

1025

<> while (tmp && tmp.offsetHeight === 0) {

1026

<> tmp = this._nextSibling(tmp);

1027

<> }

1028

<> if(tmp !== null) {

<> return $(tmp);

<> }

<> }

<> tmp = obj[0];

<> do {

<> tmp = this._nextSibling(tmp);

1035

<> } while (tmp && tmp.offsetHeight === 0);

1036

<> if(tmp !== null) {

1037

<> return $(tmp);

1038

<> }

1039

<> return obj.parentsUntil(".jstree",".jstree-node").nextAll(".jstree-node:visible").first();

1040

<> },

1041

<> /**

1042

<>		 * get the previous visible node that is above the `obj` node. If `strict` is set to `true` only sibling nodes are returned.

1043

<> * @name get_prev_dom(obj [, strict])

1044

<> * @param {mixed} obj

1045

<> * @param {Boolean} strict

1046

<> * @return {jQuery}

1047

<> */

1048

<> get_prev_dom : function (obj, strict) {

1049

<> var tmp;

1050

<> obj = this.get_node(obj, true);

1051

<> if(obj[0] === this.element[0]) {

1052

<> tmp = this.get_container_ul()[0].lastChild;

1053

<> while (tmp && tmp.offsetHeight === 0) {

1054

<> tmp = this._previousSibling(tmp);

1055

<> }

1056

<> return tmp ? $(tmp) : false;

1057

<> }

1058

<> if(!obj || !obj.length) {

<> return false;

<> }

<> if(strict) {

<> tmp = obj[0];

<> do {

<> tmp = this._previousSibling(tmp);

1065

<> } while (tmp && tmp.offsetHeight === 0);

1066

<> return tmp ? $(tmp) : false;

<> }

<> tmp = obj[0];

<> do {

<> tmp = this._previousSibling(tmp);

1071

<> } while (tmp && tmp.offsetHeight === 0);

1072

<> if(tmp !== null) {

1073

<> obj = $(tmp);

1074

<> while(obj.hasClass("jstree-open")) {

1075

<> obj = obj.children(".jstree-children").first().children(".jstree-node:visible:last");

<> }

<> return obj;

<> }

<> tmp = obj[0].parentNode.parentNode;

1080

<> return tmp && tmp.className && tmp.className.indexOf('jstree-node') !== -1 ? $(tmp) : false;

1081

<> },

1082

<> /**

1083

<> * get the parent ID of a node

1084

<> * @name get_parent(obj)

1085

<> * @param {mixed} obj

1086

<> * @return {String}

1087

<> */

1088

<> get_parent : function (obj) {

1089

<> obj = this.get_node(obj);

1090

<> if(!obj || obj.id === $.jstree.root) {

1091

<> return false;

1092

<> }

1093

<> return obj.parent;

1094

<> },

1095

<> /**

1096

<> * get a jQuery collection of all the children of a node (node must be rendered)

1097

<> * @name get_children_dom(obj)

1098

<> * @param {mixed} obj

1099

<> * @return {jQuery}

1100

<> */

1101

<> get_children_dom : function (obj) {

1102

<> obj = this.get_node(obj, true);

1103

<> if(obj[0] === this.element[0]) {

1104

<> return this.get_container_ul().children(".jstree-node");

1105

<> }

1106

<> if(!obj || !obj.length) {

1107

<> return false;

1108

<> }

1109

<> return obj.children(".jstree-children").children(".jstree-node");

1110

<> },

1111

<> /**

1112

<> * checks if a node has children

1113

<> * @name is_parent(obj)

1114

<> * @param {mixed} obj

1115

<> * @return {Boolean}

1116

<> */

1117

<> is_parent : function (obj) {

1118

<> obj = this.get_node(obj);

1119

<> return obj && (obj.state.loaded === false || obj.children.length > 0);

1120

<> },

1121

<> /**

1122

<> * checks if a node is loaded (its children are available)

1123

<> * @name is_loaded(obj)

1124

<> * @param {mixed} obj

1125

<> * @return {Boolean}

1126

<> */

1127

<> is_loaded : function (obj) {

1128

<> obj = this.get_node(obj);

1129

<> return obj && obj.state.loaded;

1130

<> },

1131

<> /**

1132

<> * check if a node is currently loading (fetching children)

1133

<> * @name is_loading(obj)

1134

<> * @param {mixed} obj

1135

<> * @return {Boolean}

1136

<> */

1137

<> is_loading : function (obj) {

1138

<> obj = this.get_node(obj);

1139

<> return obj && obj.state && obj.state.loading;

1140

<> },

1141

<> /**

1142

<> * check if a node is opened

1143

<> * @name is_open(obj)

1144

<> * @param {mixed} obj

1145

<> * @return {Boolean}

1146

<> */

1147

<> is_open : function (obj) {

1148

<> obj = this.get_node(obj);

1149

<> return obj && obj.state.opened;

1150

<> },

1151

<> /**

1152

<> * check if a node is in a closed state

1153

<> * @name is_closed(obj)

1154

<> * @param {mixed} obj

1155

<> * @return {Boolean}

1156

<> */

1157

<> is_closed : function (obj) {

1158

<> obj = this.get_node(obj);

1159

<> return obj && this.is_parent(obj) && !obj.state.opened;

1160

<> },

1161

<> /**

1162

<> * check if a node has no children

1163

<> * @name is_leaf(obj)

1164

<> * @param {mixed} obj

1165

<> * @return {Boolean}

1166

<> */

1167

<> is_leaf : function (obj) {

1168

<> return !this.is_parent(obj);

1169

<> },

1170

<> /**

1171

<>		 * loads a node (fetches its children using the `core.data` setting). Multiple nodes can be passed to by using an array.

1172

<> * @name load_node(obj [, callback])

1173

<> * @param {mixed} obj

1174

<>		 * @param  {function} callback a function to be executed once loading is complete, the function is executed in the instance's scope and receives two arguments - the node and a boolean status

1175

<> * @return {Boolean}

1176

<> * @trigger load_node.jstree

1177

<> */

1178

<> load_node : function (obj, callback) {

1179

<> var k, l, i, j, c;

1180

<> if($.isArray(obj)) {

1181

<> this._load_nodes(obj.slice(), callback);

1182

<> return true;

1183

<> }

1184

<> obj = this.get_node(obj);

1185

<> if(!obj) {

1186

<> if(callback) { callback.call(this, obj, false); }

1187

<> return false;

1188

<> }

1189

<>			// if(obj.state.loading) { } // the node is already loading - just wait for it to load and invoke callback? but if called implicitly it should be loaded again?

1190

<> if(obj.state.loaded) {

1191

<> obj.state.loaded = false;

1192

<> for(i = 0, j = obj.parents.length; i < j; i++) {

1193

<>					this._model.data[obj.parents[i]].children_d = $.vakata.array_filter(this._model.data[obj.parents[i]].children_d, function (v) {

1194

<> return $.inArray(v, obj.children_d) === -1;

1195

<> });

1196

<> }

1197

<> for(k = 0, l = obj.children_d.length; k < l; k++) {

1198

<> if(this._model.data[obj.children_d[k]].state.selected) {

1199

<> c = true;

1200

<> }

1201

<> delete this._model.data[obj.children_d[k]];

1202

<> }

1203

<> if (c) {

1204

<> this._data.core.selected = $.vakata.array_filter(this._data.core.selected, function (v) {

1205

<> return $.inArray(v, obj.children_d) === -1;

1206

<> });

1207

<> }

1208

<> obj.children = [];

1209

<> obj.children_d = [];

1210

<> if(c) {

1211

<> this.trigger('changed', { 'action' : 'load_node', 'node' : obj, 'selected' : this._data.core.selected });

1212

<> }

1213

<> }

1214

<> obj.state.failed = false;

1215

<> obj.state.loading = true;

1216

<> this.get_node(obj, true).addClass("jstree-loading").attr('aria-busy',true);

1217

<> this._load_node(obj, $.proxy(function (status) {

1218

<> obj = this._model.data[obj.id];

1219

<> obj.state.loading = false;

1220

<> obj.state.loaded = status;

1221

<> obj.state.failed = !obj.state.loaded;

1222

<> var dom = this.get_node(obj, true), i = 0, j = 0, m = this._model.data, has_children = false;

1223

<> for(i = 0, j = obj.children.length; i < j; i++) {

1224

<> if(m[obj.children[i]] && !m[obj.children[i]].state.hidden) {

1225

<> has_children = true;

<> break;

<> }

<> }

<> if(obj.state.loaded && dom && dom.length) {

1230

<> dom.removeClass('jstree-closed jstree-open jstree-leaf');

1231

<> if (!has_children) {

1232

<> dom.addClass('jstree-leaf');

1233

<> }

1234

<> else {

1235

<> if (obj.id !== '#') {

1236

<> dom.addClass(obj.state.opened ? 'jstree-open' : 'jstree-closed');

<> }

<> }

<> }

<> dom.removeClass("jstree-loading").attr('aria-busy',false);

1241

<> /**

1242

<> * triggered after a node is loaded

1243

<> * @event

1244

<> * @name load_node.jstree

1245

<> * @param {Object} node the node that was loading

1246

<> * @param {Boolean} status was the node loaded successfully

1247

<> */

1248

<> this.trigger('load_node', { "node" : obj, "status" : status });

1249

<> if(callback) {

1250

<> callback.call(this, obj, status);

<> }

<> }, this));

<> return true;

<> },

<> /**

<>		 * load an array of nodes (will also load unavailable nodes as soon as the appear in the structure). Used internally.

1257

<> * @private

1258

<> * @name _load_nodes(nodes [, callback])

1259

<> * @param {array} nodes

1260

<>		 * @param  {function} callback a function to be executed once loading is complete, the function is executed in the instance's scope and receives one argument - the array passed to _load_nodes

1261

<> */

1262

<> _load_nodes : function (nodes, callback, is_callback, force_reload) {

1263

<> var r = true,

1264

<> c = function () { this._load_nodes(nodes, callback, true); },

1265

<> m = this._model.data, i, j, tmp = [];

1266

<> for(i = 0, j = nodes.length; i < j; i++) {

1267

<>				if(m[nodes[i]] && ( (!m[nodes[i]].state.loaded && !m[nodes[i]].state.failed) || (!is_callback && force_reload) )) {

1268

<> if(!this.is_loading(nodes[i])) {

1269

<> this.load_node(nodes[i], c);

<> }

<> r = false;

<> }

<> }

<> if(r) {

<> for(i = 0, j = nodes.length; i < j; i++) {

1276

<> if(m[nodes[i]] && m[nodes[i]].state.loaded) {

1277

<> tmp.push(nodes[i]);

1278

<> }

1279

<> }

1280

<> if(callback && !callback.done) {

1281

<> callback.call(this, tmp);

1282

<> callback.done = true;

<> }

<> }

<> },

<> /**

<> * loads all unloaded nodes

1288

<> * @name load_all([obj, callback])

1289

<> * @param {mixed} obj the node to load recursively, omit to load all nodes in the tree

1290

<> * @param {function} callback a function to be executed once loading all the nodes is complete,

1291

<> * @trigger load_all.jstree

1292

<> */

1293

<> load_all : function (obj, callback) {

1294

<> if(!obj) { obj = $.jstree.root; }

1295

<> obj = this.get_node(obj);

1296

<> if(!obj) { return false; }

1297

<> var to_load = [],

1298

<> m = this._model.data,

1299

<> c = m[obj.id].children_d,

1300

<> i, j;

1301

<> if(obj.state && !obj.state.loaded) {

1302

<> to_load.push(obj.id);

1303

<> }

1304

<> for(i = 0, j = c.length; i < j; i++) {

1305

<> if(m[c[i]] && m[c[i]].state && !m[c[i]].state.loaded) {

1306

<> to_load.push(c[i]);

1307

<> }

1308

<> }

1309

<> if(to_load.length) {

1310

<> this._load_nodes(to_load, function () {

1311

<> this.load_all(obj, callback);

<> });

<> }

<> else {

<> /**

<> * triggered after a load_all call completes

1317

<> * @event

1318

<> * @name load_all.jstree

1319

<> * @param {Object} node the recursively loaded node

1320

<> */

1321

<> if(callback) { callback.call(this, obj); }

1322

<> this.trigger('load_all', { "node" : obj });

<> }

<> },

<> /**

<> * handles the actual loading of a node. Used only internally.

1327

<> * @private

1328

<> * @name _load_node(obj [, callback])

1329

<> * @param {mixed} obj

1330

<>		 * @param  {function} callback a function to be executed once loading is complete, the function is executed in the instance's scope and receives one argument - a boolean status

1331

<> * @return {Boolean}

1332

<> */

1333

<> _load_node : function (obj, callback) {

1334

<> var s = this.settings.core.data, t;

1335

<> var notTextOrCommentNode = function notTextOrCommentNode () {

1336

<> return this.nodeType !== 3 && this.nodeType !== 8;

1337

<> };

1338

<> // use original HTML

1339

<> if(!s) {

1340

<> if(obj.id === $.jstree.root) {

1341

<> return this._append_html_data(obj, this._data.core.original_container_html.clone(true), function (status) {

1342

<> callback.call(this, status);

<> });

<> }

<> else {

<> return callback.call(this, false);

1347

<> }

1348

<>				// return callback.call(this, obj.id === $.jstree.root ? this._append_html_data(obj, this._data.core.original_container_html.clone(true)) : false);

1349

<> }

1350

<> if($.isFunction(s)) {

1351

<> return s.call(this, obj, $.proxy(function (d) {

1352

<> if(d === false) {

1353

<> callback.call(this, false);

1354

<> }

1355

<> else {

1356

<>						this[typeof d === 'string' ? '_append_html_data' : '_append_json_data'](obj, typeof d === 'string' ? $($.parseHTML(d)).filter(notTextOrCommentNode) : d, function (status) {

1357

<> callback.call(this, status);

1358

<> });

1359

<> }

1360

<>					// return d === false ? callback.call(this, false) : callback.call(this, this[typeof d === 'string' ? '_append_html_data' : '_append_json_data'](obj, typeof d === 'string' ? $(d) : d));

1361

<> }, this));

1362

<> }

1363

<> if(typeof s === 'object') {

1364

<> if(s.url) {

1365

<> s = $.extend(true, {}, s);

1366

<> if($.isFunction(s.url)) {

1367

<> s.url = s.url.call(this, obj);

1368

<> }

1369

<> if($.isFunction(s.data)) {

1370

<> s.data = s.data.call(this, obj);

1371

<> }

1372

<> return $.ajax(s)

1373

<> .done($.proxy(function (d,t,x) {

1374

<> var type = x.getResponseHeader('Content-Type');

1375

<> if((type && type.indexOf('json') !== -1) || typeof d === "object") {

1376

<> return this._append_json_data(obj, d, function (status) { callback.call(this, status); });

1377

<> //return callback.call(this, this._append_json_data(obj, d));

1378

<> }

1379

<> if((type && type.indexOf('html') !== -1) || typeof d === "string") {

1380

<>									return this._append_html_data(obj, $($.parseHTML(d)).filter(notTextOrCommentNode), function (status) { callback.call(this, status); });

1381

<> // return callback.call(this, this._append_html_data(obj, $(d)));

1382

<> }

1383

<>								this._data.core.last_error = { 'error' : 'ajax', 'plugin' : 'core', 'id' : 'core_04', 'reason' : 'Could not load node', 'data' : JSON.stringify({ 'id' : obj.id, 'xhr' : x }) };

1384

<> this.settings.core.error.call(this, this._data.core.last_error);

1385

<> return callback.call(this, false);

1386

<> }, this))

1387

<> .fail($.proxy(function (f) {

1388

<> callback.call(this, false);

1389

<>								this._data.core.last_error = { 'error' : 'ajax', 'plugin' : 'core', 'id' : 'core_04', 'reason' : 'Could not load node', 'data' : JSON.stringify({ 'id' : obj.id, 'xhr' : f }) };

1390

<> this.settings.core.error.call(this, this._data.core.last_error);

1391

<> }, this));

1392

<> }

1393

<> t = ($.isArray(s) || $.isPlainObject(s)) ? JSON.parse(JSON.stringify(s)) : s;

1394

<> if(obj.id === $.jstree.root) {

1395

<> return this._append_json_data(obj, t, function (status) {

1396

<> callback.call(this, status);

<> });

<> }

<> else {

<>					this._data.core.last_error = { 'error' : 'nodata', 'plugin' : 'core', 'id' : 'core_05', 'reason' : 'Could not load node', 'data' : JSON.stringify({ 'id' : obj.id }) };

1401

<> this.settings.core.error.call(this, this._data.core.last_error);

1402

<> return callback.call(this, false);

1403

<> }

1404

<> //return callback.call(this, (obj.id === $.jstree.root ? this._append_json_data(obj, t) : false) );

1405

<> }

1406

<> if(typeof s === 'string') {

1407

<> if(obj.id === $.jstree.root) {

1408

<> return this._append_html_data(obj, $($.parseHTML(s)).filter(notTextOrCommentNode), function (status) {

1409

<> callback.call(this, status);

<> });

<> }

<> else {

<>					this._data.core.last_error = { 'error' : 'nodata', 'plugin' : 'core', 'id' : 'core_06', 'reason' : 'Could not load node', 'data' : JSON.stringify({ 'id' : obj.id }) };

1414

<> this.settings.core.error.call(this, this._data.core.last_error);

1415

<> return callback.call(this, false);

1416

<> }

1417

<> //return callback.call(this, (obj.id === $.jstree.root ? this._append_html_data(obj, $(s)) : false) );

1418

<> }

1419

<> return callback.call(this, false);

1420

<> },

1421

<> /**

1422

<> * adds a node to the list of nodes to redraw. Used only internally.

1423

<> * @private

1424

<> * @name _node_changed(obj [, callback])

1425

<> * @param {mixed} obj

1426

<> */

1427

<> _node_changed : function (obj) {

1428

<> obj = this.get_node(obj);

1429

<> if(obj) {

1430

<> this._model.changed.push(obj.id);

<> }

<> },

<> /**

<> * appends HTML content to the tree. Used internally.

1435

<> * @private

1436

<> * @name _append_html_data(obj, data)

1437

<> * @param {mixed} obj the node to append to

1438

<> * @param {String} data the HTML string to parse and append

1439

<> * @trigger model.jstree, changed.jstree

1440

<> */

1441

<> _append_html_data : function (dom, data, cb) {

1442

<> dom = this.get_node(dom);

1443

<> dom.children = [];

1444

<> dom.children_d = [];

1445

<> var dat = data.is('ul') ? data.children() : data,

<> par = dom.id,

<> chd = [],

<> dpc = [],

<> m = this._model.data,

1450

<> p = m[par],

1451

<> s = this._data.core.selected.length,

1452

<> tmp, i, j;

1453

<> dat.each($.proxy(function (i, v) {

1454

<> tmp = this._parse_model_from_html($(v), par, p.parents.concat());

<> if(tmp) {

<> chd.push(tmp);

<> dpc.push(tmp);

<> if(m[tmp].children_d.length) {

1459

<> dpc = dpc.concat(m[tmp].children_d);

<> }

<> }

<> }, this));

<> p.children = chd;

1464

<> p.children_d = dpc;

1465

<> for(i = 0, j = p.parents.length; i < j; i++) {

1466

<> m[p.parents[i]].children_d = m[p.parents[i]].children_d.concat(dpc);

1467

<> }

1468

<> /**

1469

<> * triggered when new data is inserted to the tree model

1470

<> * @event

1471

<> * @name model.jstree

1472

<> * @param {Array} nodes an array of node IDs

1473

<> * @param {String} parent the parent ID of the nodes

1474

<> */

1475

<> this.trigger('model', { "nodes" : dpc, 'parent' : par });

1476

<> if(par !== $.jstree.root) {

1477

<> this._node_changed(par);

<> this.redraw();

<> }

<> else {

<> this.get_container_ul().children('.jstree-initial-node').remove();

1482

<> this.redraw(true);

1483

<> }

1484

<> if(this._data.core.selected.length !== s) {

1485

<> this.trigger('changed', { 'action' : 'model', 'selected' : this._data.core.selected });

1486

<> }

1487

<> cb.call(this, true);

1488

<> },

1489

<> /**

1490

<> * appends JSON content to the tree. Used internally.

1491

<> * @private

1492

<> * @name _append_json_data(obj, data)

1493

<> * @param {mixed} obj the node to append to

1494

<> * @param {String} data the JSON object to parse and append

1495

<> * @param {Boolean} force_processing internal param - do not set

1496

<> * @trigger model.jstree, changed.jstree

1497

<> */

1498

<> _append_json_data : function (dom, data, cb, force_processing) {

1499

<> if(this.element === null) { return; }

1500

<> dom = this.get_node(dom);

1501

<> dom.children = [];

1502

<> dom.children_d = [];

<> // *%$@!!!

<> if(data.d) {

<> data = data.d;

<> if(typeof data === "string") {

1507

<> data = JSON.parse(data);

1508

<> }

1509

<> }

1510

<> if(!$.isArray(data)) { data = [data]; }

1511

<> var w = null,

1512

<> args = {

1513

<> 'df' : this._model.default_state,

1514

<> 'dat' : data,

1515

<> 'par' : dom.id,

1516

<> 'm' : this._model.data,

1517

<> 't_id' : this._id,

1518

<> 't_cnt' : this._cnt,

1519

<> 'sel' : this._data.core.selected

1520

<> },

1521

<> func = function (data, undefined) {

1522

<> if(data.data) { data = data.data; }

1523

<> var dat = data.dat,

<> par = data.par,

<> chd = [],

<> dpc = [],

<> add = [],

<> df = data.df,

<> t_id = data.t_id,

1530

<> t_cnt = data.t_cnt,

<> m = data.m,

<> p = m[par],

<> sel = data.sel,

<> tmp, i, j, rslt,

1535

<> parse_flat = function (d, p, ps) {

1536

<> if(!ps) { ps = []; }

1537

<> else { ps = ps.concat(); }

1538

<> if(p) { ps.unshift(p); }

1539

<> var tid = d.id.toString(),

<> i, j, c, e,

<> tmp = {

<> id : tid,

<> text : d.text || '',

1544

<> icon : d.icon !== undefined ? d.icon : true,

1545

<> parent : p,

1546

<> parents : ps,

1547

<> children : d.children || [],

1548

<> children_d : d.children_d || [],

1549

<> data : d.data,

1550

<> state : { },

1551

<> li_attr : { id : false },

1552

<> a_attr : { href : '#' },

1553

<> original : false

1554

<> };

1555

<> for(i in df) {

1556

<> if(df.hasOwnProperty(i)) {

1557

<> tmp.state[i] = df[i];

1558

<> }

1559

<> }

1560

<> if(d && d.data && d.data.jstree && d.data.jstree.icon) {

1561

<> tmp.icon = d.data.jstree.icon;

1562

<> }

1563

<> if(tmp.icon === undefined || tmp.icon === null || tmp.icon === "") {

1564

<> tmp.icon = true;

1565

<> }

1566

<> if(d && d.data) {

1567

<> tmp.data = d.data;

1568

<> if(d.data.jstree) {

1569

<> for(i in d.data.jstree) {

1570

<> if(d.data.jstree.hasOwnProperty(i)) {

1571

<> tmp.state[i] = d.data.jstree[i];

<> }

<> }

<> }

<> }

<> if(d && typeof d.state === 'object') {

1577

<> for (i in d.state) {

1578

<> if(d.state.hasOwnProperty(i)) {

1579

<> tmp.state[i] = d.state[i];

<> }

<> }

<> }

<> if(d && typeof d.li_attr === 'object') {

1584

<> for (i in d.li_attr) {

1585

<> if(d.li_attr.hasOwnProperty(i)) {

1586

<> tmp.li_attr[i] = d.li_attr[i];

<> }

<> }

<> }

<> if(!tmp.li_attr.id) {

1591

<> tmp.li_attr.id = tid;

1592

<> }

1593

<> if(d && typeof d.a_attr === 'object') {

1594

<> for (i in d.a_attr) {

1595

<> if(d.a_attr.hasOwnProperty(i)) {

1596

<> tmp.a_attr[i] = d.a_attr[i];

<> }

<> }

<> }

<> if(d && d.children && d.children === true) {

1601

<> tmp.state.loaded = false;

1602

<> tmp.children = [];

1603

<> tmp.children_d = [];

1604

<> }

1605

<> m[tmp.id] = tmp;

1606

<> for(i = 0, j = tmp.children.length; i < j; i++) {

1607

<> c = parse_flat(m[tmp.children[i]], tmp.id, ps);

1608

<> e = m[c];

1609

<> tmp.children_d.push(c);

1610

<> if(e.children_d.length) {

1611

<> tmp.children_d = tmp.children_d.concat(e.children_d);

<> }

<> }

<> delete d.data;

<> delete d.children;

1616

<> m[tmp.id].original = d;

1617

<> if(tmp.state.selected) {

1618

<> add.push(tmp.id);

<> }

<> return tmp.id;

<> },

<> parse_nest = function (d, p, ps) {

1623

<> if(!ps) { ps = []; }

1624

<> else { ps = ps.concat(); }

1625

<> if(p) { ps.unshift(p); }

1626

<> var tid = false, i, j, c, e, tmp;

1627

<> do {

1628

<> tid = 'j' + t_id + '_' + (++t_cnt);

1629

<> } while(m[tid]);

<> tmp = {

<> id : false,

<> text : typeof d === 'string' ? d : '',

1634

<> icon : typeof d === 'object' && d.icon !== undefined ? d.icon : true,

<> parent : p,

<> parents : ps,

<> children : [],

<> children_d : [],

1639

<> data : null,

1640

<> state : { },

1641

<> li_attr : { id : false },

1642

<> a_attr : { href : '#' },

1643

<> original : false

1644

<> };

1645

<> for(i in df) {

1646

<> if(df.hasOwnProperty(i)) {

1647

<> tmp.state[i] = df[i];

1648

<> }

1649

<> }

1650

<> if(d && d.id) { tmp.id = d.id.toString(); }

1651

<> if(d && d.text) { tmp.text = d.text; }

1652

<> if(d && d.data && d.data.jstree && d.data.jstree.icon) {

1653

<> tmp.icon = d.data.jstree.icon;

1654

<> }

1655

<> if(tmp.icon === undefined || tmp.icon === null || tmp.icon === "") {

1656

<> tmp.icon = true;

1657

<> }

1658

<> if(d && d.data) {

1659

<> tmp.data = d.data;

1660

<> if(d.data.jstree) {

1661

<> for(i in d.data.jstree) {

1662

<> if(d.data.jstree.hasOwnProperty(i)) {

1663

<> tmp.state[i] = d.data.jstree[i];

<> }

<> }

<> }

<> }

<> if(d && typeof d.state === 'object') {

1669

<> for (i in d.state) {

1670

<> if(d.state.hasOwnProperty(i)) {

1671

<> tmp.state[i] = d.state[i];

<> }

<> }

<> }

<> if(d && typeof d.li_attr === 'object') {

1676

<> for (i in d.li_attr) {

1677

<> if(d.li_attr.hasOwnProperty(i)) {

1678

<> tmp.li_attr[i] = d.li_attr[i];

<> }

<> }

<> }

<> if(tmp.li_attr.id && !tmp.id) {

1683

<> tmp.id = tmp.li_attr.id.toString();

<> }

<> if(!tmp.id) {

<> tmp.id = tid;

<> }

<> if(!tmp.li_attr.id) {

1689

<> tmp.li_attr.id = tmp.id;

1690

<> }

1691

<> if(d && typeof d.a_attr === 'object') {

1692

<> for (i in d.a_attr) {

1693

<> if(d.a_attr.hasOwnProperty(i)) {

1694

<> tmp.a_attr[i] = d.a_attr[i];

<> }

<> }

<> }

<> if(d && d.children && d.children.length) {

1699

<> for(i = 0, j = d.children.length; i < j; i++) {

1700

<> c = parse_nest(d.children[i], tmp.id, ps);

1701

<> e = m[c];

1702

<> tmp.children.push(c);

1703

<> if(e.children_d.length) {

1704

<> tmp.children_d = tmp.children_d.concat(e.children_d);

1705

<> }

1706

<> }

1707

<> tmp.children_d = tmp.children_d.concat(tmp.children);

1708

<> }

1709

<> if(d && d.children && d.children === true) {

1710

<> tmp.state.loaded = false;

1711

<> tmp.children = [];

1712

<> tmp.children_d = [];

1713

<> }

1714

<> delete d.data;

1715

<> delete d.children;

1716

<> tmp.original = d;

1717

<> m[tmp.id] = tmp;

1718

<> if(tmp.state.selected) {

1719

<> add.push(tmp.id);

<> }

<> return tmp.id;

<> };

<> if(dat.length && dat[0].id !== undefined && dat[0].parent !== undefined) {

1725

<> // Flat JSON support (for easy import from DB):

1726

<> // 1) convert to object (foreach)

1727

<> for(i = 0, j = dat.length; i < j; i++) {

1728

<> if(!dat[i].children) {

1729

<> dat[i].children = [];

1730

<> }

1731

<> m[dat[i].id.toString()] = dat[i];

1732

<> }

1733

<> // 2) populate children (foreach)

1734

<> for(i = 0, j = dat.length; i < j; i++) {

1735

<> m[dat[i].parent.toString()].children.push(dat[i].id.toString());

1736

<> // populate parent.children_d

1737

<> p.children_d.push(dat[i].id.toString());

1738

<> }

1739

<> // 3) normalize && populate parents and children_d with recursion

1740

<> for(i = 0, j = p.children.length; i < j; i++) {

1741

<> tmp = parse_flat(m[p.children[i]], par, p.parents.concat());

1742

<> dpc.push(tmp);

1743

<> if(m[tmp].children_d.length) {

1744

<> dpc = dpc.concat(m[tmp].children_d);

1745

<> }

1746

<> }

1747

<> for(i = 0, j = p.parents.length; i < j; i++) {

1748

<> m[p.parents[i]].children_d = m[p.parents[i]].children_d.concat(dpc);

1749

<> }

1750

<>						// ?) three_state selection - p.state.selected && t - (if three_state foreach(dat => ch) -> foreach(parents) if(parent.selected) child.selected = true;

<> rslt = {

<> 'cnt' : t_cnt,

<> 'mod' : m,

<> 'sel' : sel,

<> 'par' : par,

<> 'dpc' : dpc,

<> 'add' : add

<> };

<> }

<> else {

<> for(i = 0, j = dat.length; i < j; i++) {

1762

<> tmp = parse_nest(dat[i], par, p.parents.concat());

<> if(tmp) {

<> chd.push(tmp);

<> dpc.push(tmp);

<> if(m[tmp].children_d.length) {

1767

<> dpc = dpc.concat(m[tmp].children_d);

<> }

<> }

<> }

<> p.children = chd;

1772

<> p.children_d = dpc;

1773

<> for(i = 0, j = p.parents.length; i < j; i++) {

1774

<> m[p.parents[i]].children_d = m[p.parents[i]].children_d.concat(dpc);

<> }

<> rslt = {

<> 'cnt' : t_cnt,

<> 'mod' : m,

<> 'sel' : sel,

<> 'par' : par,

<> 'dpc' : dpc,

<> 'add' : add

<> };

<> }

<> if(typeof window === 'undefined' || typeof window.document === 'undefined') {

1786

<> postMessage(rslt);

<> }

<> else {

<> return rslt;

<> }

<> },

<> rslt = function (rslt, worker) {

1793

<> if(this.element === null) { return; }

1794

<> this._cnt = rslt.cnt;

1795

<> var i, m = this._model.data;

1796

<> for (i in m) {

1797

<> if (m.hasOwnProperty(i) && m[i].state && m[i].state.loading && rslt.mod[i]) {

1798

<> rslt.mod[i].state.loading = true;

1799

<> }

1800

<> }

1801

<> this._model.data = rslt.mod; // breaks the reference in load_node - careful

1802

1803

<> if(worker) {

1804

<> var j, a = rslt.add, r = rslt.sel, s = this._data.core.selected.slice();

1805

<> m = this._model.data;

1806

<> // if selection was changed while calculating in worker

1807

<> if(r.length !== s.length || $.vakata.array_unique(r.concat(s)).length !== r.length) {

1808

<> // deselect nodes that are no longer selected

1809

<> for(i = 0, j = r.length; i < j; i++) {

1810

<> if($.inArray(r[i], a) === -1 && $.inArray(r[i], s) === -1) {

1811

<> m[r[i]].state.selected = false;

1812

<> }

1813

<> }

1814

<> // select nodes that were selected in the mean time

1815

<> for(i = 0, j = s.length; i < j; i++) {

1816

<> if($.inArray(s[i], r) === -1) {

1817

<> m[s[i]].state.selected = true;

<> }

<> }

<> }

<> }

<> if(rslt.add.length) {

1823

<> this._data.core.selected = this._data.core.selected.concat(rslt.add);

1824

<> }

1825

1826

<> this.trigger('model', { "nodes" : rslt.dpc, 'parent' : rslt.par });

1827

1828

<> if(rslt.par !== $.jstree.root) {

1829

<> this._node_changed(rslt.par);

<> this.redraw();

<> }

<> else {

<> // this.get_container_ul().children('.jstree-initial-node').remove();

1834

<> this.redraw(true);

1835

<> }

1836

<> if(rslt.add.length) {

1837

<> this.trigger('changed', { 'action' : 'model', 'selected' : this._data.core.selected });

1838

<> }

1839

<> cb.call(this, true);

1840

<> };

1841

<> if(this.settings.core.worker && window.Blob && window.URL && window.Worker) {

1842

<> try {

1843

<> if(this._wrk === null) {

1844

<> this._wrk = window.URL.createObjectURL(

1845

<> new window.Blob(

1846

<> ['self.onmessage = ' + func.toString()],

1847

<> {type:"text/javascript"}

<> )

<> );

<> }

<> if(!this._data.core.working || force_processing) {

1852

<> this._data.core.working = true;

1853

<> w = new window.Worker(this._wrk);

1854

<> w.onmessage = $.proxy(function (e) {

1855

<> rslt.call(this, e.data, true);

1856

<> try { w.terminate(); w = null; } catch(ignore) { }

1857

<> if(this._data.core.worker_queue.length) {

1858

<> this._append_json_data.apply(this, this._data.core.worker_queue.shift());

1859

<> }

1860

<> else {

1861

<> this._data.core.working = false;

<> }

<> }, this);

<> if(!args.par) {

<> if(this._data.core.worker_queue.length) {

1866

<> this._append_json_data.apply(this, this._data.core.worker_queue.shift());

1867

<> }

1868

<> else {

1869

<> this._data.core.working = false;

<> }

<> }

<> else {

<> w.postMessage(args);

<> }

<> }

<> else {

<> this._data.core.worker_queue.push([dom, data, cb, true]);

<> }

<> }

<> catch(e) {

<> rslt.call(this, func(args), false);

1882

<> if(this._data.core.worker_queue.length) {

1883

<> this._append_json_data.apply(this, this._data.core.worker_queue.shift());

1884

<> }

1885

<> else {

1886

<> this._data.core.working = false;

<> }

<> }

<> }

<> else {

<> rslt.call(this, func(args), false);

<> }

<> },

<> /**

<> * parses a node from a jQuery object and appends them to the in memory tree model. Used internally.

1896

<> * @private

1897

<> * @name _parse_model_from_html(d [, p, ps])

1898

<> * @param {jQuery} d the jQuery object to parse

1899

<> * @param {String} p the parent ID

1900

<> * @param {Array} ps list of all parents

1901

<> * @return {String} the ID of the object added to the model

1902

<> */

1903

<> _parse_model_from_html : function (d, p, ps) {

1904

<> if(!ps) { ps = []; }

1905

<> else { ps = [].concat(ps); }

1906

<> if(p) { ps.unshift(p); }

1907

<> var c, e, m = this._model.data,

<> data = {

<> id : false,

<> text : false,

<> icon : true,

<> parent : p,

<> parents : ps,

<> children : [],

<> children_d : [],

1916

<> data : null,

1917

<> state : { },

1918

<> li_attr : { id : false },

1919

<> a_attr : { href : '#' },

1920

<> original : false

1921

<> }, i, tmp, tid;

1922

<> for(i in this._model.default_state) {

1923

<> if(this._model.default_state.hasOwnProperty(i)) {

1924

<> data.state[i] = this._model.default_state[i];

1925

<> }

1926

<> }

1927

<> tmp = $.vakata.attributes(d, true);

1928

<> $.each(tmp, function (i, v) {

1929

<> v = $.trim(v);

1930

<> if(!v.length) { return true; }

1931

<> data.li_attr[i] = v;

1932

<> if(i === 'id') {

1933

<> data.id = v.toString();

1934

<> }

1935

<> });

1936

<> tmp = d.children('a').first();

1937

<> if(tmp.length) {

1938

<> tmp = $.vakata.attributes(tmp, true);

1939

<> $.each(tmp, function (i, v) {

1940

<> v = $.trim(v);

1941

<> if(v.length) {

1942

<> data.a_attr[i] = v;

<> }

<> });

<> }

<> tmp = d.children("a").first().length ? d.children("a").first().clone() : d.clone();

1947

<> tmp.children("ins, i, ul").remove();

1948

<> tmp = tmp.html();

1949

<> tmp = $('<div />').html(tmp);

1950

<> data.text = this.settings.core.force_text ? tmp.text() : tmp.html();

1951

<> tmp = d.data();

1952

<> data.data = tmp ? $.extend(true, {}, tmp) : null;

1953

<> data.state.opened = d.hasClass('jstree-open');

1954

<> data.state.selected = d.children('a').hasClass('jstree-clicked');

1955

<> data.state.disabled = d.children('a').hasClass('jstree-disabled');

1956

<> if(data.data && data.data.jstree) {

1957

<> for(i in data.data.jstree) {

1958

<> if(data.data.jstree.hasOwnProperty(i)) {

1959

<> data.state[i] = data.data.jstree[i];

<> }

<> }

<> }

<> tmp = d.children("a").children(".jstree-themeicon");

1964

<> if(tmp.length) {

1965

<> data.icon = tmp.hasClass('jstree-themeicon-hidden') ? false : tmp.attr('rel');

1966

<> }

1967

<> if(data.state.icon !== undefined) {

1968

<> data.icon = data.state.icon;

1969

<> }

1970

<> if(data.icon === undefined || data.icon === null || data.icon === "") {

1971

<> data.icon = true;

1972

<> }

1973

<> tmp = d.children("ul").children("li");

1974

<> do {

1975

<> tid = 'j' + this._id + '_' + (++this._cnt);

1976

<> } while(m[tid]);

1977

<> data.id = data.li_attr.id ? data.li_attr.id.toString() : tid;

1978

<> if(tmp.length) {

1979

<> tmp.each($.proxy(function (i, v) {

1980

<> c = this._parse_model_from_html($(v), data.id, ps);

1981

<> e = this._model.data[c];

1982

<> data.children.push(c);

1983

<> if(e.children_d.length) {

1984

<> data.children_d = data.children_d.concat(e.children_d);

1985

<> }

1986

<> }, this));

1987

<> data.children_d = data.children_d.concat(data.children);

1988

<> }

1989

<> else {

1990

<> if(d.hasClass('jstree-closed')) {

1991

<> data.state.loaded = false;

1992

<> }

1993

<> }

1994

<> if(data.li_attr['class']) {

1995

<> data.li_attr['class'] = data.li_attr['class'].replace('jstree-closed','').replace('jstree-open','');

1996

<> }

1997

<> if(data.a_attr['class']) {

1998

<> data.a_attr['class'] = data.a_attr['class'].replace('jstree-clicked','').replace('jstree-disabled','');

1999

<> }

2000

<> m[data.id] = data;

2001

<> if(data.state.selected) {

2002

<> this._data.core.selected.push(data.id);

<> }

<> return data.id;

<> },

<> /**

<>		 * parses a node from a JSON object (used when dealing with flat data, which has no nesting of children, but has id and parent properties) and appends it to the in memory tree model. Used internally.

2008

<> * @private

2009

<> * @name _parse_model_from_flat_json(d [, p, ps])

2010

<> * @param {Object} d the JSON object to parse

2011

<> * @param {String} p the parent ID

2012

<> * @param {Array} ps list of all parents

2013

<> * @return {String} the ID of the object added to the model

2014

<> */

2015

<> _parse_model_from_flat_json : function (d, p, ps) {

2016

<> if(!ps) { ps = []; }

2017

<> else { ps = ps.concat(); }

2018

<> if(p) { ps.unshift(p); }

2019

<> var tid = d.id.toString(),

2020

<> m = this._model.data,

2021

<> df = this._model.default_state,

<> i, j, c, e,

<> tmp = {

<> id : tid,

<> text : d.text || '',

2026

<> icon : d.icon !== undefined ? d.icon : true,

2027

<> parent : p,

2028

<> parents : ps,

2029

<> children : d.children || [],

2030

<> children_d : d.children_d || [],

2031

<> data : d.data,

2032

<> state : { },

2033

<> li_attr : { id : false },

2034

<> a_attr : { href : '#' },

2035

<> original : false

2036

<> };

2037

<> for(i in df) {

2038

<> if(df.hasOwnProperty(i)) {

2039

<> tmp.state[i] = df[i];

2040

<> }

2041

<> }

2042

<> if(d && d.data && d.data.jstree && d.data.jstree.icon) {

2043

<> tmp.icon = d.data.jstree.icon;

2044

<> }

2045

<> if(tmp.icon === undefined || tmp.icon === null || tmp.icon === "") {

2046

<> tmp.icon = true;

2047

<> }

2048

<> if(d && d.data) {

2049

<> tmp.data = d.data;

2050

<> if(d.data.jstree) {

2051

<> for(i in d.data.jstree) {

2052

<> if(d.data.jstree.hasOwnProperty(i)) {

2053

<> tmp.state[i] = d.data.jstree[i];

<> }

<> }

<> }

<> }

<> if(d && typeof d.state === 'object') {

2059

<> for (i in d.state) {

2060

<> if(d.state.hasOwnProperty(i)) {

2061

<> tmp.state[i] = d.state[i];

<> }

<> }

<> }

<> if(d && typeof d.li_attr === 'object') {

2066

<> for (i in d.li_attr) {

2067

<> if(d.li_attr.hasOwnProperty(i)) {

2068

<> tmp.li_attr[i] = d.li_attr[i];

<> }

<> }

<> }

<> if(!tmp.li_attr.id) {

2073

<> tmp.li_attr.id = tid;

2074

<> }

2075

<> if(d && typeof d.a_attr === 'object') {

2076

<> for (i in d.a_attr) {

2077

<> if(d.a_attr.hasOwnProperty(i)) {

2078

<> tmp.a_attr[i] = d.a_attr[i];

<> }

<> }

<> }

<> if(d && d.children && d.children === true) {

2083

<> tmp.state.loaded = false;

2084

<> tmp.children = [];

2085

<> tmp.children_d = [];

2086

<> }

2087

<> m[tmp.id] = tmp;

2088

<> for(i = 0, j = tmp.children.length; i < j; i++) {

2089

<> c = this._parse_model_from_flat_json(m[tmp.children[i]], tmp.id, ps);

2090

<> e = m[c];

2091

<> tmp.children_d.push(c);

2092

<> if(e.children_d.length) {

2093

<> tmp.children_d = tmp.children_d.concat(e.children_d);

<> }

<> }

<> delete d.data;

<> delete d.children;

2098

<> m[tmp.id].original = d;

2099

<> if(tmp.state.selected) {

2100

<> this._data.core.selected.push(tmp.id);

<> }

<> return tmp.id;

<> },

<> /**

<> * parses a node from a JSON object and appends it to the in memory tree model. Used internally.

2106

<> * @private

2107

<> * @name _parse_model_from_json(d [, p, ps])

2108

<> * @param {Object} d the JSON object to parse

2109

<> * @param {String} p the parent ID

2110

<> * @param {Array} ps list of all parents

2111

<> * @return {String} the ID of the object added to the model

2112

<> */

2113

<> _parse_model_from_json : function (d, p, ps) {

2114

<> if(!ps) { ps = []; }

2115

<> else { ps = ps.concat(); }

2116

<> if(p) { ps.unshift(p); }

2117

<> var tid = false, i, j, c, e, m = this._model.data, df = this._model.default_state, tmp;

2118

<> do {

2119

<> tid = 'j' + this._id + '_' + (++this._cnt);

2120

<> } while(m[tid]);

<> tmp = {

<> id : false,

<> text : typeof d === 'string' ? d : '',

2125

<> icon : typeof d === 'object' && d.icon !== undefined ? d.icon : true,

<> parent : p,

<> parents : ps,

<> children : [],

<> children_d : [],

2130

<> data : null,

2131

<> state : { },

2132

<> li_attr : { id : false },

2133

<> a_attr : { href : '#' },

2134

<> original : false

2135

<> };

2136

<> for(i in df) {

2137

<> if(df.hasOwnProperty(i)) {

2138

<> tmp.state[i] = df[i];

2139

<> }

2140

<> }

2141

<> if(d && d.id) { tmp.id = d.id.toString(); }

2142

<> if(d && d.text) { tmp.text = d.text; }

2143

<> if(d && d.data && d.data.jstree && d.data.jstree.icon) {

2144

<> tmp.icon = d.data.jstree.icon;

2145

<> }

2146

<> if(tmp.icon === undefined || tmp.icon === null || tmp.icon === "") {

2147

<> tmp.icon = true;

2148

<> }

2149

<> if(d && d.data) {

2150

<> tmp.data = d.data;

2151

<> if(d.data.jstree) {

2152

<> for(i in d.data.jstree) {

2153

<> if(d.data.jstree.hasOwnProperty(i)) {

2154

<> tmp.state[i] = d.data.jstree[i];

<> }

<> }

<> }

<> }

<> if(d && typeof d.state === 'object') {

2160

<> for (i in d.state) {

2161

<> if(d.state.hasOwnProperty(i)) {

2162

<> tmp.state[i] = d.state[i];

<> }

<> }

<> }

<> if(d && typeof d.li_attr === 'object') {

2167

<> for (i in d.li_attr) {

2168

<> if(d.li_attr.hasOwnProperty(i)) {

2169

<> tmp.li_attr[i] = d.li_attr[i];

<> }

<> }

<> }

<> if(tmp.li_attr.id && !tmp.id) {

2174

<> tmp.id = tmp.li_attr.id.toString();

<> }

<> if(!tmp.id) {

<> tmp.id = tid;

<> }

<> if(!tmp.li_attr.id) {

2180

<> tmp.li_attr.id = tmp.id;

2181

<> }

2182

<> if(d && typeof d.a_attr === 'object') {

2183

<> for (i in d.a_attr) {

2184

<> if(d.a_attr.hasOwnProperty(i)) {

2185

<> tmp.a_attr[i] = d.a_attr[i];

<> }

<> }

<> }

<> if(d && d.children && d.children.length) {

2190

<> for(i = 0, j = d.children.length; i < j; i++) {

2191

<> c = this._parse_model_from_json(d.children[i], tmp.id, ps);

2192

<> e = m[c];

2193

<> tmp.children.push(c);

2194

<> if(e.children_d.length) {

2195

<> tmp.children_d = tmp.children_d.concat(e.children_d);

2196

<> }

2197

<> }

2198

<> tmp.children_d = tmp.children_d.concat(tmp.children);

2199

<> }

2200

<> if(d && d.children && d.children === true) {

2201

<> tmp.state.loaded = false;

2202

<> tmp.children = [];

2203

<> tmp.children_d = [];

2204

<> }

2205

<> delete d.data;

2206

<> delete d.children;

2207

<> tmp.original = d;

2208

<> m[tmp.id] = tmp;

2209

<> if(tmp.state.selected) {

2210

<> this._data.core.selected.push(tmp.id);

<> }

<> return tmp.id;

<> },

<> /**

<> * redraws all nodes that need to be redrawn. Used internally.

2216

<> * @private

2217

<> * @name _redraw()

2218

<> * @trigger redraw.jstree

2219

<> */

2220

<> _redraw : function () {

2221

<>			var nodes = this._model.force_full_redraw ? this._model.data[$.jstree.root].children.concat([]) : this._model.changed.concat([]),

2222

<> f = document.createElement('UL'), tmp, i, j, fe = this._data.core.focused;

2223

<> for(i = 0, j = nodes.length; i < j; i++) {

2224

<> tmp = this.redraw_node(nodes[i], true, this._model.force_full_redraw);

2225

<> if(tmp && this._model.force_full_redraw) {

2226

<> f.appendChild(tmp);

2227

<> }

2228

<> }

2229

<> if(this._model.force_full_redraw) {

2230

<> f.className = this.get_container_ul()[0].className;

2231

<> f.setAttribute('role','group');

2232

<> this.element.empty().append(f);

2233

<> //this.get_container_ul()[0].appendChild(f);

2234

<> }

2235

<> if(fe !== null) {

2236

<> tmp = this.get_node(fe, true);

2237

<> if(tmp && tmp.length && tmp.children('.jstree-anchor')[0] !== document.activeElement) {

2238

<> tmp.children('.jstree-anchor').focus();

2239

<> }

2240

<> else {

2241

<> this._data.core.focused = null;

2242

<> }

2243

<> }

2244

<> this._model.force_full_redraw = false;

2245

<> this._model.changed = [];

2246

<> /**

2247

<> * triggered after nodes are redrawn

2248

<> * @event

2249

<> * @name redraw.jstree

2250

<> * @param {array} nodes the redrawn nodes

2251

<> */

2252

<> this.trigger('redraw', { "nodes" : nodes });

2253

<> },

2254

<> /**

2255

<> * redraws all nodes that need to be redrawn or optionally - the whole tree

2256

<> * @name redraw([full])

2257

<> * @param {Boolean} full if set to `true` all nodes are redrawn.

2258

<> */

2259

<> redraw : function (full) {

2260

<> if(full) {

2261

<> this._model.force_full_redraw = true;

2262

<> }

2263

<> //if(this._model.redraw_timeout) {

2264

<> // clearTimeout(this._model.redraw_timeout);

2265

<> //}

2266

<> //this._model.redraw_timeout = setTimeout($.proxy(this._redraw, this),0);

<> this._redraw();

<> },

<> /**

<> * redraws a single node's children. Used internally.

2271

<> * @private

2272

<> * @name draw_children(node)

2273

<> * @param {mixed} node the node whose children will be redrawn

2274

<> */

2275

<> draw_children : function (node) {

2276

<> var obj = this.get_node(node),

<> i = false,

<> j = false,

<> k = false,

<> d = document;

<> if(!obj) { return false; }

2282

<> if(obj.id === $.jstree.root) { return this.redraw(true); }

2283

<> node = this.get_node(node, true);

2284

<> if(!node || !node.length) { return false; } // TODO: quick toggle

2285

2286

<> node.children('.jstree-children').remove();

2287

<> node = node[0];

2288

<> if(obj.children.length && obj.state.loaded) {

2289

<> k = d.createElement('UL');

2290

<> k.setAttribute('role', 'group');

2291

<> k.className = 'jstree-children';

2292

<> for(i = 0, j = obj.children.length; i < j; i++) {

2293

<> k.appendChild(this.redraw_node(obj.children[i], true, true));

2294

<> }

2295

<> node.appendChild(k);

<> }

<> },

<> /**

<> * redraws a single node. Used internally.

2300

<> * @private

2301

<> * @name redraw_node(node, deep, is_callback, force_render)

2302

<> * @param {mixed} node the node to redraw

2303

<> * @param {Boolean} deep should child nodes be redrawn too

2304

<> * @param {Boolean} is_callback is this a recursion call

2305

<> * @param {Boolean} force_render should children of closed parents be drawn anyway

2306

<> */

2307

<> redraw_node : function (node, deep, is_callback, force_render) {

2308

<> var obj = this.get_node(node),

<> par = false,

<> ind = false,

<> old = false,

<> i = false,

<> j = false,

<> k = false,

<> c = '',

<> d = document,

<> m = this._model.data,

<> f = false,

<> s = false,

<> tmp = null,

<> t = 0,

<> l = 0,

<> has_children = false,

2324

<> last_sibling = false;

2325

<> if(!obj) { return false; }

2326

<> if(obj.id === $.jstree.root) { return this.redraw(true); }

2327

<> deep = deep || obj.children.length === 0;

2328

<>			node = !document.querySelector ? document.getElementById(obj.id) : this.element[0].querySelector('#' + ("0123456789".indexOf(obj.id[0]) !== -1 ? '\\3' + obj.id[0] + ' ' + obj.id.substr(1).replace($.jstree.idregex,'\\$&') : obj.id.replace($.jstree.idregex,'\\$&')) ); //, this.element);

2329

<> if(!node) {

2330

<> deep = true;

2331

<> //node = d.createElement('LI');

2332

<> if(!is_callback) {

2333

<>					par = obj.parent !== $.jstree.root ? $('#' + obj.parent.replace($.jstree.idregex,'\\$&'), this.element)[0] : null;

2334

<> if(par !== null && (!par || !m[obj.parent].state.opened)) {

2335

<> return false;

2336

<> }

2337

<> ind = $.inArray(obj.id, par === null ? m[$.jstree.root].children : m[obj.parent].children);

<> }

<> }

<> else {

<> node = $(node);

<> if(!is_callback) {

2343

<> par = node.parent().parent()[0];

2344

<> if(par === this.element[0]) {

2345

<> par = null;

2346

<> }

2347

<> ind = node.index();

2348

<> }

2349

<> // m[obj.id].data = node.data(); // use only node's data, no need to touch jquery storage

2350

<> if(!deep && obj.children.length && !node.children('.jstree-children').length) {

<> deep = true;

<> }

<> if(!deep) {

<> old = node.children('.jstree-children')[0];

2355

<> }

2356

<> f = node.children('.jstree-anchor')[0] === document.activeElement;

2357

<> node.remove();

2358

<> //node = d.createElement('LI');

2359

<> //node = node[0];

2360

<> }

2361

<> node = _node.cloneNode(true);

2362

<> // node is DOM, deep is boolean

2363

2364

<> c = 'jstree-node ';

2365

<> for(i in obj.li_attr) {

2366

<> if(obj.li_attr.hasOwnProperty(i)) {

2367

<> if(i === 'id') { continue; }

2368

<> if(i !== 'class') {

2369

<> node.setAttribute(i, obj.li_attr[i]);

2370

<> }

2371

<> else {

2372

<> c += obj.li_attr[i];

<> }

<> }

<> }

<> if(!obj.a_attr.id) {

2377

<> obj.a_attr.id = obj.id + '_anchor';

2378

<> }

2379

<> node.setAttribute('aria-selected', !!obj.state.selected);

2380

<> node.setAttribute('aria-level', obj.parents.length);

2381

<> node.setAttribute('aria-labelledby', obj.a_attr.id);

2382

<> if(obj.state.disabled) {

2383

<> node.setAttribute('aria-disabled', true);

2384

<> }

2385

2386

<> for(i = 0, j = obj.children.length; i < j; i++) {

2387

<> if(!m[obj.children[i]].state.hidden) {

2388

<> has_children = true;

<> break;

<> }

<> }

<> if(obj.parent !== null && m[obj.parent] && !obj.state.hidden) {

2393

<> i = $.inArray(obj.id, m[obj.parent].children);

2394

<> last_sibling = obj.id;

2395

<> if(i !== -1) {

2396

<> i++;

2397

<> for(j = m[obj.parent].children.length; i < j; i++) {

2398

<> if(!m[m[obj.parent].children[i]].state.hidden) {

2399

<> last_sibling = m[obj.parent].children[i];

2400

<> }

2401

<> if(last_sibling !== obj.id) {

<> break;

<> }

<> }

<> }

<> }

<> if(obj.state.hidden) {

2409

<> c += ' jstree-hidden';

2410

<> }

2411

<> if(obj.state.loaded && !has_children) {

2412

<> c += ' jstree-leaf';

2413

<> }

2414

<> else {

2415

<> c += obj.state.opened && obj.state.loaded ? ' jstree-open' : ' jstree-closed';

2416

<> node.setAttribute('aria-expanded', (obj.state.opened && obj.state.loaded) );

2417

<> }

2418

<> if(last_sibling === obj.id) {

2419

<> c += ' jstree-last';

2420

<> }

2421

<> node.id = obj.id;

2422

<> node.className = c;

2423

<> c = ( obj.state.selected ? ' jstree-clicked' : '') + ( obj.state.disabled ? ' jstree-disabled' : '');

2424

<> for(j in obj.a_attr) {

2425

<> if(obj.a_attr.hasOwnProperty(j)) {

2426

<> if(j === 'href' && obj.a_attr[j] === '#') { continue; }

2427

<> if(j !== 'class') {

2428

<> node.childNodes[1].setAttribute(j, obj.a_attr[j]);

2429

<> }

2430

<> else {

2431

<> c += ' ' + obj.a_attr[j];

<> }

<> }

<> }

<> if(c.length) {

<> node.childNodes[1].className = 'jstree-anchor ' + c;

2437

<> }

2438

<> if((obj.icon && obj.icon !== true) || obj.icon === false) {

2439

<> if(obj.icon === false) {

2440

<> node.childNodes[1].childNodes[0].className += ' jstree-themeicon-hidden';

2441

<> }

2442

<> else if(obj.icon.indexOf('/') === -1 && obj.icon.indexOf('.') === -1) {

2443

<> node.childNodes[1].childNodes[0].className += ' ' + obj.icon + ' jstree-themeicon-custom';

2444

<> }

2445

<> else {

2446

<> node.childNodes[1].childNodes[0].style.backgroundImage = 'url("'+obj.icon+'")';

2447

<> node.childNodes[1].childNodes[0].style.backgroundPosition = 'center center';

2448

<> node.childNodes[1].childNodes[0].style.backgroundSize = 'auto';

2449

<> node.childNodes[1].childNodes[0].className += ' jstree-themeicon-custom';

<> }

<> }

<> if(this.settings.core.force_text) {

2454

<> node.childNodes[1].appendChild(d.createTextNode(obj.text));

2455

<> }

2456

<> else {

2457

<> node.childNodes[1].innerHTML += obj.text;

<> }

<> if(deep && obj.children.length && (obj.state.opened || force_render) && obj.state.loaded) {

2462

<> k = d.createElement('UL');

2463

<> k.setAttribute('role', 'group');

2464

<> k.className = 'jstree-children';

2465

<> for(i = 0, j = obj.children.length; i < j; i++) {

2466

<> k.appendChild(this.redraw_node(obj.children[i], deep, true));

2467

<> }

2468

<> node.appendChild(k);

2469

<> }

2470

<> if(old) {

2471

<> node.appendChild(old);

2472

<> }

2473

<> if(!is_callback) {

2474

<> // append back using par / ind

2475

<> if(!par) {

2476

<> par = this.element[0];

2477

<> }

2478

<> for(i = 0, j = par.childNodes.length; i < j; i++) {

2479

<>					if(par.childNodes[i] && par.childNodes[i].className && par.childNodes[i].className.indexOf('jstree-children') !== -1) {

2480

<> tmp = par.childNodes[i];

<> break;

<> }

<> }

<> if(!tmp) {

<> tmp = d.createElement('UL');

2486

<> tmp.setAttribute('role', 'group');

2487

<> tmp.className = 'jstree-children';

2488

<> par.appendChild(tmp);

<> }

<> par = tmp;

<> if(ind < par.childNodes.length) {

2493

<> par.insertBefore(node, par.childNodes[ind]);

2494

<> }

2495

<> else {

2496

<> par.appendChild(node);

2497

<> }

2498

<> if(f) {

2499

<> t = this.element[0].scrollTop;

2500

<> l = this.element[0].scrollLeft;

2501

<> node.childNodes[1].focus();

2502

<> this.element[0].scrollTop = t;

2503

<> this.element[0].scrollLeft = l;

2504

<> }

2505

<> }

2506

<> if(obj.state.opened && !obj.state.loaded) {

2507

<> obj.state.opened = false;

2508

<> setTimeout($.proxy(function () {

2509

<> this.open_node(obj.id, false, 0);

<> }, this), 0);

<> }

<> return node;

<> },

<> /**

<> * opens a node, revaling its children. If the node is not loaded it will be loaded and opened once ready.

2516

<> * @name open_node(obj [, callback, animation])

2517

<> * @param {mixed} obj the node to open

2518

<> * @param {Function} callback a function to execute once the node is opened

2519

<>		 * @param {Number} animation the animation duration in milliseconds when opening the node (overrides the `core.animation` setting). Use `false` for no animation.

2520

<> * @trigger open_node.jstree, after_open.jstree, before_open.jstree

2521

<> */

2522

<> open_node : function (obj, callback, animation) {

2523

<> var t1, t2, d, t;

2524

<> if($.isArray(obj)) {

2525

<> obj = obj.slice();

2526

<> for(t1 = 0, t2 = obj.length; t1 < t2; t1++) {

2527

<> this.open_node(obj[t1], callback, animation);

<> }

<> return true;

<> }

<> obj = this.get_node(obj);

2532

<> if(!obj || obj.id === $.jstree.root) {

2533

<> return false;

2534

<> }

2535

<> animation = animation === undefined ? this.settings.core.animation : animation;

2536

<> if(!this.is_closed(obj)) {

2537

<> if(callback) {

2538

<> callback.call(this, obj, false);

<> }

<> return false;

<> }

<> if(!this.is_loaded(obj)) {

2543

<> if(this.is_loading(obj)) {

2544

<> return setTimeout($.proxy(function () {

2545

<> this.open_node(obj, callback, animation);

2546

<> }, this), 500);

2547

<> }

2548

<> this.load_node(obj, function (o, ok) {

2549

<> return ok ? this.open_node(o, callback, animation) : (callback ? callback.call(this, o, false) : false);

<> });

<> }

<> else {

<> d = this.get_node(obj, true);

2554

<> t = this;

2555

<> if(d.length) {

2556

<> if(animation && d.children(".jstree-children").length) {

2557

<> d.children(".jstree-children").stop(true, true);

2558

<> }

2559

<> if(obj.children.length && !this._firstChild(d.children('.jstree-children')[0])) {

2560

<> this.draw_children(obj);

2561

<> //d = this.get_node(obj, true);

2562

<> }

2563

<> if(!animation) {

2564

<> this.trigger('before_open', { "node" : obj });

2565

<> d[0].className = d[0].className.replace('jstree-closed', 'jstree-open');

2566

<> d[0].setAttribute("aria-expanded", true);

2567

<> }

2568

<> else {

2569

<> this.trigger('before_open', { "node" : obj });

2570

<> d

2571

<> .children(".jstree-children").css("display","none").end()

2572

<> .removeClass("jstree-closed").addClass("jstree-open").attr("aria-expanded", true)

2573

<> .children(".jstree-children").stop(true, true)

2574

<> .slideDown(animation, function () {

2575

<> this.style.display = "";

2576

<> if (t.element) {

2577

<> t.trigger("after_open", { "node" : obj });

<> }

<> });

<> }

<> }

<> obj.state.opened = true;

2583

<> if(callback) {

2584

<> callback.call(this, obj, true);

<> }

<> if(!d.length) {

<> /**

<>					 * triggered when a node is about to be opened (if the node is supposed to be in the DOM, it will be, but it won't be visible yet)

2589

<> * @event

2590

<> * @name before_open.jstree

2591

<> * @param {Object} node the opened node

2592

<> */

2593

<> this.trigger('before_open', { "node" : obj });

2594

<> }

2595

<> /**

2596

<> * triggered when a node is opened (if there is an animation it will not be completed yet)

2597

<> * @event

2598

<> * @name open_node.jstree

2599

<> * @param {Object} node the opened node

2600

<> */

2601

<> this.trigger('open_node', { "node" : obj });

2602

<> if(!animation || !d.length) {

2603

<> /**

2604

<> * triggered when a node is opened and the animation is complete

2605

<> * @event

2606

<> * @name after_open.jstree

2607

<> * @param {Object} node the opened node

2608

<> */

2609

<> this.trigger("after_open", { "node" : obj });

<> }

<> return true;

<> }

<> },

<> /**

<> * opens every parent of a node (node should be loaded)

2616

<> * @name _open_to(obj)

2617

<> * @param {mixed} obj the node to reveal

2618

<> * @private

2619

<> */

2620

<> _open_to : function (obj) {

2621

<> obj = this.get_node(obj);

2622

<> if(!obj || obj.id === $.jstree.root) {

2623

<> return false;

2624

<> }

2625

<> var i, j, p = obj.parents;

2626

<> for(i = 0, j = p.length; i < j; i+=1) {

2627

<> if(i !== $.jstree.root) {

2628

<> this.open_node(p[i], false, 0);

2629

<> }

2630

<> }

2631

<> return $('#' + obj.id.replace($.jstree.idregex,'\\$&'), this.element);

2632

<> },

2633

<> /**

2634

<> * closes a node, hiding its children

2635

<> * @name close_node(obj [, animation])

2636

<> * @param {mixed} obj the node to close

2637

<>		 * @param {Number} animation the animation duration in milliseconds when closing the node (overrides the `core.animation` setting). Use `false` for no animation.

2638

<> * @trigger close_node.jstree, after_close.jstree

2639

<> */

2640

<> close_node : function (obj, animation) {

2641

<> var t1, t2, t, d;

2642

<> if($.isArray(obj)) {

2643

<> obj = obj.slice();

2644

<> for(t1 = 0, t2 = obj.length; t1 < t2; t1++) {

2645

<> this.close_node(obj[t1], animation);

<> }

<> return true;

<> }

<> obj = this.get_node(obj);

2650

<> if(!obj || obj.id === $.jstree.root) {

2651

<> return false;

2652

<> }

2653

<> if(this.is_closed(obj)) {

2654

<> return false;

2655

<> }

2656

<> animation = animation === undefined ? this.settings.core.animation : animation;

2657

<> t = this;

2658

<> d = this.get_node(obj, true);

2659

2660

<> obj.state.opened = false;

2661

<> /**

2662

<> * triggered when a node is closed (if there is an animation it will not be complete yet)

2663

<> * @event

2664

<> * @name close_node.jstree

2665

<> * @param {Object} node the closed node

2666

<> */

2667

<> this.trigger('close_node',{ "node" : obj });

2668

<> if(!d.length) {

2669

<> /**

2670

<> * triggered when a node is closed and the animation is complete

2671

<> * @event

2672

<> * @name after_close.jstree

2673

<> * @param {Object} node the closed node

2674

<> */

2675

<> this.trigger("after_close", { "node" : obj });

2676

<> }

2677

<> else {

2678

<> if(!animation) {

2679

<> d[0].className = d[0].className.replace('jstree-open', 'jstree-closed');

2680

<> d.attr("aria-expanded", false).children('.jstree-children').remove();

2681

<> this.trigger("after_close", { "node" : obj });

<> }

<> else {

<> d

<> .children(".jstree-children").attr("style","display:block !important").end()

2686

<> .removeClass("jstree-open").addClass("jstree-closed").attr("aria-expanded", false)

2687

<> .children(".jstree-children").stop(true, true).slideUp(animation, function () {

2688

<> this.style.display = "";

2689

<> d.children('.jstree-children').remove();

2690

<> if (t.element) {

2691

<> t.trigger("after_close", { "node" : obj });

<> }

<> });

<> }

<> }

<> },

<> /**

<> * toggles a node - closing it if it is open, opening it if it is closed

2699

<> * @name toggle_node(obj)

2700

<> * @param {mixed} obj the node to toggle

2701

<> */

2702

<> toggle_node : function (obj) {

2703

<> var t1, t2;

2704

<> if($.isArray(obj)) {

2705

<> obj = obj.slice();

2706

<> for(t1 = 0, t2 = obj.length; t1 < t2; t1++) {

2707

<> this.toggle_node(obj[t1]);

<> }

<> return true;

<> }

<> if(this.is_closed(obj)) {

2712

<> return this.open_node(obj);

2713

<> }

2714

<> if(this.is_open(obj)) {

2715

<> return this.close_node(obj);

<> }

<> },

<> /**

<>		 * opens all nodes within a node (or the tree), revaling their children. If the node is not loaded it will be loaded and opened once ready.

2720

<> * @name open_all([obj, animation, original_obj])

2721

<> * @param {mixed} obj the node to open recursively, omit to open all nodes in the tree

2722

<>		 * @param {Number} animation the animation duration in milliseconds when opening the nodes, the default is no animation

2723

<> * @param {jQuery} reference to the node that started the process (internal use)

2724

<> * @trigger open_all.jstree

2725

<> */

2726

<> open_all : function (obj, animation, original_obj) {

2727

<> if(!obj) { obj = $.jstree.root; }

2728

<> obj = this.get_node(obj);

2729

<> if(!obj) { return false; }

2730

<> var dom = obj.id === $.jstree.root ? this.get_container_ul() : this.get_node(obj, true), i, j, _this;

2731

<> if(!dom.length) {

2732

<> for(i = 0, j = obj.children_d.length; i < j; i++) {

2733

<> if(this.is_closed(this._model.data[obj.children_d[i]])) {

2734

<> this._model.data[obj.children_d[i]].state.opened = true;

2735

<> }

2736

<> }

2737

<> return this.trigger('open_all', { "node" : obj });

2738

<> }

2739

<> original_obj = original_obj || dom;

2740

<> _this = this;

2741

<> dom = this.is_closed(obj) ? dom.find('.jstree-closed').addBack() : dom.find('.jstree-closed');

2742

<> dom.each(function () {

2743

<> _this.open_node(

2744

<> this,

2745

<> function(node, status) { if(status && this.is_parent(node)) { this.open_all(node, animation, original_obj); } },

<> animation || 0

<> );

<> });

<> if(original_obj.find('.jstree-closed').length === 0) {

2750

<> /**

2751

<> * triggered when an `open_all` call completes

2752

<> * @event

2753

<> * @name open_all.jstree

2754

<> * @param {Object} node the opened node

2755

<> */

2756

<> this.trigger('open_all', { "node" : this.get_node(original_obj) });

<> }

<> },

<> /**

<> * closes all nodes within a node (or the tree), revaling their children

2761

<> * @name close_all([obj, animation])

2762

<> * @param {mixed} obj the node to close recursively, omit to close all nodes in the tree

2763

<>		 * @param {Number} animation the animation duration in milliseconds when closing the nodes, the default is no animation

2764

<> * @trigger close_all.jstree

2765

<> */

2766

<> close_all : function (obj, animation) {

2767

<> if(!obj) { obj = $.jstree.root; }

2768

<> obj = this.get_node(obj);

2769

<> if(!obj) { return false; }

2770

<> var dom = obj.id === $.jstree.root ? this.get_container_ul() : this.get_node(obj, true),

2771

<> _this = this, i, j;

2772

<> if(dom.length) {

2773

<> dom = this.is_open(obj) ? dom.find('.jstree-open').addBack() : dom.find('.jstree-open');

2774

<> $(dom.get().reverse()).each(function () { _this.close_node(this, animation || 0); });

2775

<> }

2776

<> for(i = 0, j = obj.children_d.length; i < j; i++) {

2777

<> this._model.data[obj.children_d[i]].state.opened = false;

2778

<> }

2779

<> /**

2780

<> * triggered when an `close_all` call completes

2781

<> * @event

2782

<> * @name close_all.jstree

2783

<> * @param {Object} node the closed node

2784

<> */

2785

<> this.trigger('close_all', { "node" : obj });

2786

<> },

2787

<> /**

2788

<> * checks if a node is disabled (not selectable)

2789

<> * @name is_disabled(obj)

2790

<> * @param {mixed} obj

2791

<> * @return {Boolean}

2792

<> */

2793

<> is_disabled : function (obj) {

2794

<> obj = this.get_node(obj);

2795

<> return obj && obj.state && obj.state.disabled;

2796

<> },

2797

<> /**

2798

<> * enables a node - so that it can be selected

2799

<> * @name enable_node(obj)

2800

<> * @param {mixed} obj the node to enable

2801

<> * @trigger enable_node.jstree

2802

<> */

2803

<> enable_node : function (obj) {

2804

<> var t1, t2;

2805

<> if($.isArray(obj)) {

2806

<> obj = obj.slice();

2807

<> for(t1 = 0, t2 = obj.length; t1 < t2; t1++) {

2808

<> this.enable_node(obj[t1]);

<> }

<> return true;

<> }

<> obj = this.get_node(obj);

2813

<> if(!obj || obj.id === $.jstree.root) {

2814

<> return false;

2815

<> }

2816

<> obj.state.disabled = false;

2817

<> this.get_node(obj,true).children('.jstree-anchor').removeClass('jstree-disabled').attr('aria-disabled', false);

2818

<> /**

2819

<> * triggered when an node is enabled

2820

<> * @event

2821

<> * @name enable_node.jstree

2822

<> * @param {Object} node the enabled node

2823

<> */

2824

<> this.trigger('enable_node', { 'node' : obj });

2825

<> },

2826

<> /**

2827

<> * disables a node - so that it can not be selected

2828

<> * @name disable_node(obj)

2829

<> * @param {mixed} obj the node to disable

2830

<> * @trigger disable_node.jstree

2831

<> */

2832

<> disable_node : function (obj) {

2833

<> var t1, t2;

2834

<> if($.isArray(obj)) {

2835

<> obj = obj.slice();

2836

<> for(t1 = 0, t2 = obj.length; t1 < t2; t1++) {

2837

<> this.disable_node(obj[t1]);

<> }

<> return true;

<> }

<> obj = this.get_node(obj);

2842

<> if(!obj || obj.id === $.jstree.root) {

2843

<> return false;

2844

<> }

2845

<> obj.state.disabled = true;

2846

<> this.get_node(obj,true).children('.jstree-anchor').addClass('jstree-disabled').attr('aria-disabled', true);

2847

<> /**

2848

<> * triggered when an node is disabled

2849

<> * @event

2850

<> * @name disable_node.jstree

2851

<> * @param {Object} node the disabled node

2852

<> */

2853

<> this.trigger('disable_node', { 'node' : obj });

2854

<> },

2855

<> /**

2856

<> * determines if a node is hidden

2857

<> * @name is_hidden(obj)

2858

<> * @param {mixed} obj the node

2859

<> */

2860

<> is_hidden : function (obj) {

2861

<> obj = this.get_node(obj);

2862

<> return obj.state.hidden === true;

2863

<> },

2864

<> /**

2865

<> * hides a node - it is still in the structure but will not be visible

2866

<> * @name hide_node(obj)

2867

<> * @param {mixed} obj the node to hide

2868

<> * @param {Boolean} redraw internal parameter controlling if redraw is called

2869

<> * @trigger hide_node.jstree

2870

<> */

2871

<> hide_node : function (obj, skip_redraw) {

2872

<> var t1, t2;

2873

<> if($.isArray(obj)) {

2874

<> obj = obj.slice();

2875

<> for(t1 = 0, t2 = obj.length; t1 < t2; t1++) {

2876

<> this.hide_node(obj[t1], true);

2877

<> }

2878

<> if (!skip_redraw) {

<> this.redraw();

<> }

<> return true;

<> }

<> obj = this.get_node(obj);

2884

<> if(!obj || obj.id === $.jstree.root) {

2885

<> return false;

2886

<> }

2887

<> if(!obj.state.hidden) {

2888

<> obj.state.hidden = true;

2889

<> this._node_changed(obj.parent);

2890

<> if(!skip_redraw) {

<> this.redraw();

<> }

<> /**

<> * triggered when an node is hidden

2895

<> * @event

2896

<> * @name hide_node.jstree

2897

<> * @param {Object} node the hidden node

2898

<> */

2899

<> this.trigger('hide_node', { 'node' : obj });

<> }

<> },

<> /**

<> * shows a node

<> * @name show_node(obj)

2905

<> * @param {mixed} obj the node to show

2906

<> * @param {Boolean} skip_redraw internal parameter controlling if redraw is called

2907

<> * @trigger show_node.jstree

2908

<> */

2909

<> show_node : function (obj, skip_redraw) {

2910

<> var t1, t2;

2911

<> if($.isArray(obj)) {

2912

<> obj = obj.slice();

2913

<> for(t1 = 0, t2 = obj.length; t1 < t2; t1++) {

2914

<> this.show_node(obj[t1], true);

2915

<> }

2916

<> if (!skip_redraw) {

<> this.redraw();

<> }

<> return true;

<> }

<> obj = this.get_node(obj);

2922

<> if(!obj || obj.id === $.jstree.root) {

2923

<> return false;

2924

<> }

2925

<> if(obj.state.hidden) {

2926

<> obj.state.hidden = false;

2927

<> this._node_changed(obj.parent);

2928

<> if(!skip_redraw) {

<> this.redraw();

<> }

<> /**

<> * triggered when an node is shown

2933

<> * @event

2934

<> * @name show_node.jstree

2935

<> * @param {Object} node the shown node

2936

<> */

2937

<> this.trigger('show_node', { 'node' : obj });

<> }

<> },

<> /**

<> * hides all nodes

2942

<> * @name hide_all()

2943

<> * @trigger hide_all.jstree

2944

<> */

2945

<> hide_all : function (skip_redraw) {

2946

<> var i, m = this._model.data, ids = [];

2947

<> for(i in m) {

2948

<> if(m.hasOwnProperty(i) && i !== $.jstree.root && !m[i].state.hidden) {

2949

<> m[i].state.hidden = true;

<> ids.push(i);

<> }

<> }

<> this._model.force_full_redraw = true;

2954

<> if(!skip_redraw) {

<> this.redraw();

<> }

<> /**

<> * triggered when all nodes are hidden

2959

<> * @event

2960

<> * @name hide_all.jstree

2961

<> * @param {Array} nodes the IDs of all hidden nodes

2962

<> */

2963

<> this.trigger('hide_all', { 'nodes' : ids });

<> return ids;

<> },

<> /**

<> * shows all nodes

2968

<> * @name show_all()

2969

<> * @trigger show_all.jstree

2970

<> */

2971

<> show_all : function (skip_redraw) {

2972

<> var i, m = this._model.data, ids = [];

2973

<> for(i in m) {

2974

<> if(m.hasOwnProperty(i) && i !== $.jstree.root && m[i].state.hidden) {

2975

<> m[i].state.hidden = false;

<> ids.push(i);

<> }

<> }

<> this._model.force_full_redraw = true;

2980

<> if(!skip_redraw) {

<> this.redraw();

<> }

<> /**

<> * triggered when all nodes are shown

2985

<> * @event

2986

<> * @name show_all.jstree

2987

<> * @param {Array} nodes the IDs of all shown nodes

2988

<> */

2989

<> this.trigger('show_all', { 'nodes' : ids });

<> return ids;

<> },

<> /**

<> * called when a node is selected by the user. Used internally.

2994

<> * @private

2995

<> * @name activate_node(obj, e)

2996

<> * @param {mixed} obj the node

2997

<> * @param {Object} e the related event

2998

<> * @trigger activate_node.jstree, changed.jstree

2999

<> */

3000

<> activate_node : function (obj, e) {

3001

<> if(this.is_disabled(obj)) {

3002

<> return false;

3003

<> }

3004

<> if(!e || typeof e !== 'object') {

<> e = {};

<> }

<>			// ensure last_clicked is still in the DOM, make it fresh (maybe it was moved?) and make sure it is still selected, if not - make last_clicked the last selected node

3009

<>			this._data.core.last_clicked = this._data.core.last_clicked && this._data.core.last_clicked.id !== undefined ? this.get_node(this._data.core.last_clicked.id) : null;

3010

<>			if(this._data.core.last_clicked && !this._data.core.last_clicked.state.selected) { this._data.core.last_clicked = null; }

3011

<>			if(!this._data.core.last_clicked && this._data.core.selected.length) { this._data.core.last_clicked = this.get_node(this._data.core.selected[this._data.core.selected.length - 1]); }

3012

3013

<>			if(!this.settings.core.multiple || (!e.metaKey && !e.ctrlKey && !e.shiftKey) || (e.shiftKey && (!this._data.core.last_clicked || !this.get_parent(obj) || this.get_parent(obj) !== this._data.core.last_clicked.parent ) )) {

3014

<> if(!this.settings.core.multiple && (e.metaKey || e.ctrlKey || e.shiftKey) && this.is_selected(obj)) {

3015

<> this.deselect_node(obj, false, e);

3016

<> }

3017

<> else {

3018

<> this.deselect_all(true);

3019

<> this.select_node(obj, false, false, e);

3020

<> this._data.core.last_clicked = this.get_node(obj);

<> }

<> }

<> else {

<> if(e.shiftKey) {

3025

<> var o = this.get_node(obj).id,

3026

<> l = this._data.core.last_clicked.id,

3027

<> p = this.get_node(this._data.core.last_clicked.parent).children,

3028

<> c = false,

3029

<> i, j;

3030

<> for(i = 0, j = p.length; i < j; i += 1) {

3031

<> // separate IFs work whem o and l are the same

3032

<> if(p[i] === o) {

3033

<> c = !c;

3034

<> }

3035

<> if(p[i] === l) {

3036

<> c = !c;

3037

<> }

3038

<> if(!this.is_disabled(p[i]) && (c || p[i] === o || p[i] === l)) {

3039

<> if (!this.is_hidden(p[i])) {

3040

<> this.select_node(p[i], true, false, e);

<> }

<> }

<> else {

<> this.deselect_node(p[i], true, e);

3045

<> }

3046

<> }

3047

<>					this.trigger('changed', { 'action' : 'select_node', 'node' : this.get_node(obj), 'selected' : this._data.core.selected, 'event' : e });

3048

<> }

3049

<> else {

3050

<> if(!this.is_selected(obj)) {

3051

<> this.select_node(obj, false, false, e);

3052

<> }

3053

<> else {

3054

<> this.deselect_node(obj, false, e);

<> }

<> }

<> }

<> /**

<> * triggered when an node is clicked or intercated with by the user

3060

<> * @event

3061

<> * @name activate_node.jstree

3062

<> * @param {Object} node

3063

<> * @param {Object} event the ooriginal event (if any) which triggered the call (may be an empty object)

3064

<> */

3065

<> this.trigger('activate_node', { 'node' : this.get_node(obj), 'event' : e });

3066

<> },

3067

<> /**

3068

<> * applies the hover state on a node, called when a node is hovered by the user. Used internally.

3069

<> * @private

3070

<> * @name hover_node(obj)

3071

<> * @param {mixed} obj

3072

<> * @trigger hover_node.jstree

3073

<> */

3074

<> hover_node : function (obj) {

3075

<> obj = this.get_node(obj, true);

3076

<> if(!obj || !obj.length || obj.children('.jstree-hovered').length) {

3077

<> return false;

3078

<> }

3079

<> var o = this.element.find('.jstree-hovered'), t = this.element;

3080

<> if(o && o.length) { this.dehover_node(o); }

3081

3082

<> obj.children('.jstree-anchor').addClass('jstree-hovered');

3083

<> /**

3084

<> * triggered when an node is hovered

3085

<> * @event

3086

<> * @name hover_node.jstree

3087

<> * @param {Object} node

3088

<> */

3089

<> this.trigger('hover_node', { 'node' : this.get_node(obj) });

3090

<> setTimeout(function () { t.attr('aria-activedescendant', obj[0].id); }, 0);

3091

<> },

3092

<> /**

3093

<> * removes the hover state from a nodecalled when a node is no longer hovered by the user. Used internally.

3094

<> * @private

3095

<> * @name dehover_node(obj)

3096

<> * @param {mixed} obj

3097

<> * @trigger dehover_node.jstree

3098

<> */

3099

<> dehover_node : function (obj) {

3100

<> obj = this.get_node(obj, true);

3101

<> if(!obj || !obj.length || !obj.children('.jstree-hovered').length) {

3102

<> return false;

3103

<> }

3104

<> obj.children('.jstree-anchor').removeClass('jstree-hovered');

3105

<> /**

3106

<> * triggered when an node is no longer hovered

3107

<> * @event

3108

<> * @name dehover_node.jstree

3109

<> * @param {Object} node

3110

<> */

3111

<> this.trigger('dehover_node', { 'node' : this.get_node(obj) });

<> },

<> /**

<> * select a node

<> * @name select_node(obj [, supress_event, prevent_open])

3116

<> * @param {mixed} obj an array can be used to select multiple nodes

3117

<> * @param {Boolean} supress_event if set to `true` the `changed.jstree` event won't be triggered

3118

<> * @param {Boolean} prevent_open if set to `true` parents of the selected node won't be opened

3119

<> * @trigger select_node.jstree, changed.jstree

3120

<> */

3121

<> select_node : function (obj, supress_event, prevent_open, e) {

3122

<> var dom, t1, t2, th;

3123

<> if($.isArray(obj)) {

3124

<> obj = obj.slice();

3125

<> for(t1 = 0, t2 = obj.length; t1 < t2; t1++) {

3126

<> this.select_node(obj[t1], supress_event, prevent_open, e);

<> }

<> return true;

<> }

<> obj = this.get_node(obj);

3131

<> if(!obj || obj.id === $.jstree.root) {

3132

<> return false;

3133

<> }

3134

<> dom = this.get_node(obj, true);

3135

<> if(!obj.state.selected) {

3136

<> obj.state.selected = true;

3137

<> this._data.core.selected.push(obj.id);

3138

<> if(!prevent_open) {

3139

<> dom = this._open_to(obj);

3140

<> }

3141

<> if(dom && dom.length) {

3142

<> dom.attr('aria-selected', true).children('.jstree-anchor').addClass('jstree-clicked');

3143

<> }

3144

<> /**

3145

<> * triggered when an node is selected

3146

<> * @event

3147

<> * @name select_node.jstree

3148

<> * @param {Object} node

3149

<> * @param {Array} selected the current selection

3150

<> * @param {Object} event the event (if any) that triggered this select_node

3151

<> */

3152

<> this.trigger('select_node', { 'node' : obj, 'selected' : this._data.core.selected, 'event' : e });

3153

<> if(!supress_event) {

3154

<> /**

3155

<> * triggered when selection changes

3156

<> * @event

3157

<> * @name changed.jstree

3158

<> * @param {Object} node

3159

<> * @param {Object} action the action that caused the selection to change

3160

<> * @param {Array} selected the current selection

3161

<> * @param {Object} event the event (if any) that triggered this changed event

3162

<> */

3163

<>					this.trigger('changed', { 'action' : 'select_node', 'node' : obj, 'selected' : this._data.core.selected, 'event' : e });

<> }

<> }

<> },

<> /**

<> * deselect a node

3169

<> * @name deselect_node(obj [, supress_event])

3170

<> * @param {mixed} obj an array can be used to deselect multiple nodes

3171

<> * @param {Boolean} supress_event if set to `true` the `changed.jstree` event won't be triggered

3172

<> * @trigger deselect_node.jstree, changed.jstree

3173

<> */

3174

<> deselect_node : function (obj, supress_event, e) {

3175

<> var t1, t2, dom;

3176

<> if($.isArray(obj)) {

3177

<> obj = obj.slice();

3178

<> for(t1 = 0, t2 = obj.length; t1 < t2; t1++) {

3179

<> this.deselect_node(obj[t1], supress_event, e);

<> }

<> return true;

<> }

<> obj = this.get_node(obj);

3184

<> if(!obj || obj.id === $.jstree.root) {

3185

<> return false;

3186

<> }

3187

<> dom = this.get_node(obj, true);

3188

<> if(obj.state.selected) {

3189

<> obj.state.selected = false;

3190

<> this._data.core.selected = $.vakata.array_remove_item(this._data.core.selected, obj.id);

3191

<> if(dom.length) {

3192

<> dom.attr('aria-selected', false).children('.jstree-anchor').removeClass('jstree-clicked');

3193

<> }

3194

<> /**

3195

<> * triggered when an node is deselected

3196

<> * @event

3197

<> * @name deselect_node.jstree

3198

<> * @param {Object} node

3199

<> * @param {Array} selected the current selection

3200

<> * @param {Object} event the event (if any) that triggered this deselect_node

3201

<> */

3202

<> this.trigger('deselect_node', { 'node' : obj, 'selected' : this._data.core.selected, 'event' : e });

3203

<> if(!supress_event) {

3204

<>					this.trigger('changed', { 'action' : 'deselect_node', 'node' : obj, 'selected' : this._data.core.selected, 'event' : e });

<> }

<> }

<> },

<> /**

<> * select all nodes in the tree

3210

<> * @name select_all([supress_event])

3211

<> * @param {Boolean} supress_event if set to `true` the `changed.jstree` event won't be triggered

3212

<> * @trigger select_all.jstree, changed.jstree

3213

<> */

3214

<> select_all : function (supress_event) {

3215

<> var tmp = this._data.core.selected.concat([]), i, j;

3216

<> this._data.core.selected = this._model.data[$.jstree.root].children_d.concat();

3217

<> for(i = 0, j = this._data.core.selected.length; i < j; i++) {

3218

<> if(this._model.data[this._data.core.selected[i]]) {

3219

<> this._model.data[this._data.core.selected[i]].state.selected = true;

3220

<> }

3221

<> }

3222

<> this.redraw(true);

3223

<> /**

3224

<> * triggered when all nodes are selected

3225

<> * @event

3226

<> * @name select_all.jstree

3227

<> * @param {Array} selected the current selection

3228

<> */

3229

<> this.trigger('select_all', { 'selected' : this._data.core.selected });

3230

<> if(!supress_event) {

3231

<>				this.trigger('changed', { 'action' : 'select_all', 'selected' : this._data.core.selected, 'old_selection' : tmp });

<> }

<> },

<> /**

<> * deselect all selected nodes

3236

<> * @name deselect_all([supress_event])

3237

<> * @param {Boolean} supress_event if set to `true` the `changed.jstree` event won't be triggered

3238

<> * @trigger deselect_all.jstree, changed.jstree

3239

<> */

3240

<> deselect_all : function (supress_event) {

3241

<> var tmp = this._data.core.selected.concat([]), i, j;

3242

<> for(i = 0, j = this._data.core.selected.length; i < j; i++) {

3243

<> if(this._model.data[this._data.core.selected[i]]) {

3244

<> this._model.data[this._data.core.selected[i]].state.selected = false;

3245

<> }

3246

<> }

3247

<> this._data.core.selected = [];

3248

<> this.element.find('.jstree-clicked').removeClass('jstree-clicked').parent().attr('aria-selected', false);

3249

<> /**

3250

<> * triggered when all nodes are deselected

3251

<> * @event

3252

<> * @name deselect_all.jstree

3253

<> * @param {Object} node the previous selection

3254

<> * @param {Array} selected the current selection

3255

<> */

3256

<> this.trigger('deselect_all', { 'selected' : this._data.core.selected, 'node' : tmp });

3257

<> if(!supress_event) {

3258

<>				this.trigger('changed', { 'action' : 'deselect_all', 'selected' : this._data.core.selected, 'old_selection' : tmp });

<> }

<> },

<> /**

<> * checks if a node is selected

3263

<> * @name is_selected(obj)

3264

<> * @param {mixed} obj

3265

<> * @return {Boolean}

3266

<> */

3267

<> is_selected : function (obj) {

3268

<> obj = this.get_node(obj);

3269

<> if(!obj || obj.id === $.jstree.root) {

3270

<> return false;

3271

<> }

3272

<> return obj.state.selected;

3273

<> },

3274

<> /**

3275

<> * get an array of all selected nodes

3276

<> * @name get_selected([full])

3277

<>		 * @param  {mixed}  full if set to `true` the returned array will consist of the full node objects, otherwise - only IDs will be returned

3278

<> * @return {Array}

3279

<> */

3280

<> get_selected : function (full) {

3281

<>			return full ? $.map(this._data.core.selected, $.proxy(function (i) { return this.get_node(i); }, this)) : this._data.core.selected.slice();

3282

<> },

3283

<> /**

3284

<> * get an array of all top level selected nodes (ignoring children of selected nodes)

3285

<> * @name get_top_selected([full])

3286

<>		 * @param  {mixed}  full if set to `true` the returned array will consist of the full node objects, otherwise - only IDs will be returned

3287

<> * @return {Array}

3288

<> */

3289

<> get_top_selected : function (full) {

3290

<> var tmp = this.get_selected(true),

3291

<> obj = {}, i, j, k, l;

3292

<> for(i = 0, j = tmp.length; i < j; i++) {

3293

<> obj[tmp[i].id] = tmp[i];

3294

<> }

3295

<> for(i = 0, j = tmp.length; i < j; i++) {

3296

<> for(k = 0, l = tmp[i].children_d.length; k < l; k++) {

3297

<> if(obj[tmp[i].children_d[k]]) {

3298

<> delete obj[tmp[i].children_d[k]];

<> }

<> }

<> }

<> tmp = [];

<> for(i in obj) {

<> if(obj.hasOwnProperty(i)) {

<> tmp.push(i);

<> }

<> }

<> return full ? $.map(tmp, $.proxy(function (i) { return this.get_node(i); }, this)) : tmp;

3309

<> },

3310

<> /**

3311

<> * get an array of all bottom level selected nodes (ignoring selected parents)

3312

<> * @name get_bottom_selected([full])

3313

<>		 * @param  {mixed}  full if set to `true` the returned array will consist of the full node objects, otherwise - only IDs will be returned

3314

<> * @return {Array}

3315

<> */

3316

<> get_bottom_selected : function (full) {

3317

<> var tmp = this.get_selected(true),

3318

<> obj = [], i, j;

3319

<> for(i = 0, j = tmp.length; i < j; i++) {

3320

<> if(!tmp[i].children.length) {

3321

<> obj.push(tmp[i].id);

3322

<> }

3323

<> }

3324

<> return full ? $.map(obj, $.proxy(function (i) { return this.get_node(i); }, this)) : obj;

3325

<> },

3326

<> /**

3327

<> * gets the current state of the tree so that it can be restored later with `set_state(state)`. Used internally.

3328

<> * @name get_state()

3329

<> * @private

3330

<> * @return {Object}

3331

<> */

3332

<> get_state : function () {

<> var state = {

<> 'core' : {

<> 'open' : [],

<> 'scroll' : {

<> 'left' : this.element.scrollLeft(),

3338

<> 'top' : this.element.scrollTop()

<> },

<> /*!

<> 'themes' : {

<> 'name' : this.get_theme(),

3343

<> 'icons' : this._data.core.themes.icons,

3344

<> 'dots' : this._data.core.themes.dots

<> },

<> */

<> 'selected' : []

<> }

<> }, i;

<> for(i in this._model.data) {

3351

<> if(this._model.data.hasOwnProperty(i)) {

3352

<> if(i !== $.jstree.root) {

3353

<> if(this._model.data[i].state.opened) {

3354

<> state.core.open.push(i);

3355

<> }

3356

<> if(this._model.data[i].state.selected) {

3357

<> state.core.selected.push(i);

<> }

<> }

<> }

<> }

<> return state;

<> },

<> /**

<> * sets the state of the tree. Used internally.

3366

<> * @name set_state(state [, callback])

3367

<> * @private

3368

<>		 * @param {Object} state the state to restore. Keep in mind this object is passed by reference and jstree will modify it.

3369

<> * @param {Function} callback an optional function to execute once the state is restored.

3370

<> * @trigger set_state.jstree

3371

<> */

3372

<> set_state : function (state, callback) {

3373

<> if(state) {

3374

<> if(state.core) {

3375

<> var res, n, t, _this, i;

3376

<> if(state.core.open) {

3377

<> if(!$.isArray(state.core.open) || !state.core.open.length) {

3378

<> delete state.core.open;

3379

<> this.set_state(state, callback);

3380

<> }

3381

<> else {

3382

<> this._load_nodes(state.core.open, function (nodes) {

3383

<> this.open_node(nodes, false, 0);

3384

<> delete state.core.open;

3385

<> this.set_state(state, callback);

<> });

<> }

<> return false;

<> }

<> if(state.core.scroll) {

3391

<> if(state.core.scroll && state.core.scroll.left !== undefined) {

3392

<> this.element.scrollLeft(state.core.scroll.left);

3393

<> }

3394

<> if(state.core.scroll && state.core.scroll.top !== undefined) {

3395

<> this.element.scrollTop(state.core.scroll.top);

3396

<> }

3397

<> delete state.core.scroll;

3398

<> this.set_state(state, callback);

3399

<> return false;

3400

<> }

3401

<> if(state.core.selected) {

3402

<> _this = this;

3403

<> this.deselect_all();

3404

<> $.each(state.core.selected, function (i, v) {

3405

<> _this.select_node(v, false, true);

3406

<> });

3407

<> delete state.core.selected;

3408

<> this.set_state(state, callback);

3409

<> return false;

3410

<> }

3411

<> for(i in state) {

3412

<> if(state.hasOwnProperty(i) && i !== "core" && $.inArray(i, this.settings.plugins) === -1) {

3413

<> delete state[i];

3414

<> }

3415

<> }

3416

<> if($.isEmptyObject(state.core)) {

3417

<> delete state.core;

3418

<> this.set_state(state, callback);

<> return false;

<> }

<> }

<> if($.isEmptyObject(state)) {

3423

<> state = null;

3424

<> if(callback) { callback.call(this); }

3425

<> /**

3426

<> * triggered when a `set_state` call completes

3427

<> * @event

3428

<> * @name set_state.jstree

3429

<> */

3430

<> this.trigger('set_state');

<> return false;

<> }

<> return true;

<> }

<> return false;

<> },

<> /**

<> * refreshes the tree - all nodes are reloaded with calls to `load_node`.

3439

<> * @name refresh()

3440

<> * @param {Boolean} skip_loading an option to skip showing the loading indicator

3441

<>		 * @param {Mixed} forget_state if set to `true` state will not be reapplied, if set to a function (receiving the current state as argument) the result of that function will be used as state

3442

<> * @trigger refresh.jstree

3443

<> */

3444

<> refresh : function (skip_loading, forget_state) {

3445

<> this._data.core.state = forget_state === true ? {} : this.get_state();

3446

<>			if(forget_state && $.isFunction(forget_state)) { this._data.core.state = forget_state.call(this, this._data.core.state); }

3447

<> this._cnt = 0;

3448

<> this._model.data = {};

3449

<> this._model.data[$.jstree.root] = {

3450

<> id : $.jstree.root,

<> parent : null,

<> parents : [],

<> children : [],

<> children_d : [],

3455

<> state : { loaded : false }

3456

<> };

3457

<> this._data.core.selected = [];

3458

<> this._data.core.last_clicked = null;

3459

<> this._data.core.focused = null;

3460

3461

<> var c = this.get_container_ul()[0].className;

3462

<> if(!skip_loading) {

3463

<>				this.element.html("<"+"ul class='"+c+"' role='group'><"+"li class='jstree-initial-node jstree-loading jstree-leaf jstree-last' role='treeitem' id='j"+this._id+"_loading'><i class='jstree-icon jstree-ocl'></i><"+"a class='jstree-anchor' href='#'><i class='jstree-icon jstree-themeicon-hidden'></i>" + this.get_string("Loading ...") + "</a></li></ul>");

3464

<> this.element.attr('aria-activedescendant','j'+this._id+'_loading');

3465

<> }

3466

<> this.load_node($.jstree.root, function (o, s) {

3467

<> if(s) {

3468

<> this.get_container_ul()[0].className = c;

3469

<> if(this._firstChild(this.get_container_ul()[0])) {

3470

<> this.element.attr('aria-activedescendant',this._firstChild(this.get_container_ul()[0]).id);

3471

<> }

3472

<> this.set_state($.extend(true, {}, this._data.core.state), function () {

3473

<> /**

3474

<> * triggered when a `refresh` call completes

3475

<> * @event

3476

<> * @name refresh.jstree

3477

<> */

3478

<> this.trigger('refresh');

3479

<> });

3480

<> }

3481

<> this._data.core.state = null;

<> });

<> },

<> /**

<>		 * refreshes a node in the tree (reload its children) all opened nodes inside that node are reloaded with calls to `load_node`.

3486

<> * @name refresh_node(obj)

3487

<> * @param {mixed} obj the node

3488

<> * @trigger refresh_node.jstree

3489

<> */

3490

<> refresh_node : function (obj) {

3491

<> obj = this.get_node(obj);

3492

<> if(!obj || obj.id === $.jstree.root) { return false; }

3493

<> var opened = [], to_load = [], s = this._data.core.selected.concat([]);

3494

<> to_load.push(obj.id);

3495

<> if(obj.state.opened === true) { opened.push(obj.id); }

3496

<> this.get_node(obj, true).find('.jstree-open').each(function() { to_load.push(this.id); opened.push(this.id); });

3497

<> this._load_nodes(to_load, $.proxy(function (nodes) {

3498

<> this.open_node(opened, false, 0);

3499

<> this.select_node(s);

3500

<> /**

3501

<> * triggered when a node is refreshed

3502

<> * @event

3503

<> * @name refresh_node.jstree

3504

<> * @param {Object} node - the refreshed node

3505

<> * @param {Array} nodes - an array of the IDs of the nodes that were reloaded

3506

<> */

3507

<> this.trigger('refresh_node', { 'node' : obj, 'nodes' : nodes });

3508

<> }, this), false, true);

3509

<> },

3510

<> /**

3511

<> * set (change) the ID of a node

3512

<> * @name set_id(obj, id)

3513

<> * @param {mixed} obj the node

3514

<> * @param {String} id the new ID

3515

<> * @return {Boolean}

3516

<> * @trigger set_id.jstree

3517

<> */

3518

<> set_id : function (obj, id) {

3519

<> obj = this.get_node(obj);

3520

<> if(!obj || obj.id === $.jstree.root) { return false; }

3521

<> var i, j, m = this._model.data, old = obj.id;

3522

<> id = id.toString();

3523

<> // update parents (replace current ID with new one in children and children_d)

3524

<> m[obj.parent].children[$.inArray(obj.id, m[obj.parent].children)] = id;

3525

<> for(i = 0, j = obj.parents.length; i < j; i++) {

3526

<> m[obj.parents[i]].children_d[$.inArray(obj.id, m[obj.parents[i]].children_d)] = id;

3527

<> }

3528

<> // update children (replace current ID with new one in parent and parents)

3529

<> for(i = 0, j = obj.children.length; i < j; i++) {

3530

<> m[obj.children[i]].parent = id;

3531

<> }

3532

<> for(i = 0, j = obj.children_d.length; i < j; i++) {

3533

<> m[obj.children_d[i]].parents[$.inArray(obj.id, m[obj.children_d[i]].parents)] = id;

3534

<> }

3535

<> i = $.inArray(obj.id, this._data.core.selected);

3536

<> if(i !== -1) { this._data.core.selected[i] = id; }

3537

<> // update model and obj itself (obj.id, this._model.data[KEY])

3538

<> i = this.get_node(obj.id, true);

3539

<> if(i) {

3540

<>				i.attr('id', id); //.children('.jstree-anchor').attr('id', id + '_anchor').end().attr('aria-labelledby', id + '_anchor');

3541

<> if(this.element.attr('aria-activedescendant') === obj.id) {

3542

<> this.element.attr('aria-activedescendant', id);

3543

<> }

3544

<> }

3545

<> delete m[obj.id];

3546

<> obj.id = id;

3547

<> obj.li_attr.id = id;

3548

<> m[id] = obj;

3549

<> /**

3550

<> * triggered when a node id value is changed

3551

<> * @event

3552

<> * @name set_id.jstree

3553

<> * @param {Object} node

3554

<> * @param {String} old the old id

3555

<> */

3556

<> this.trigger('set_id',{ "node" : obj, "new" : obj.id, "old" : old });

<> return true;

<> },

<> /**

<> * get the text value of a node

3561

<> * @name get_text(obj)

3562

<> * @param {mixed} obj the node

3563

<> * @return {String}

3564

<> */

3565

<> get_text : function (obj) {

3566

<> obj = this.get_node(obj);

3567

<> return (!obj || obj.id === $.jstree.root) ? false : obj.text;

3568

<> },

3569

<> /**

3570

<> * set the text value of a node. Used internally, please use `rename_node(obj, val)`.

3571

<> * @private

3572

<> * @name set_text(obj, val)

3573

<> * @param {mixed} obj the node, you can pass an array to set the text on multiple nodes

3574

<> * @param {String} val the new text value

3575

<> * @return {Boolean}

3576

<> * @trigger set_text.jstree

3577

<> */

3578

<> set_text : function (obj, val) {

3579

<> var t1, t2;

3580

<> if($.isArray(obj)) {

3581

<> obj = obj.slice();

3582

<> for(t1 = 0, t2 = obj.length; t1 < t2; t1++) {

3583

<> this.set_text(obj[t1], val);

<> }

<> return true;

<> }

<> obj = this.get_node(obj);

3588

<> if(!obj || obj.id === $.jstree.root) { return false; }

3589

<> obj.text = val;

3590

<> if(this.get_node(obj, true).length) {

3591

<> this.redraw_node(obj.id);

3592

<> }

3593

<> /**

3594

<> * triggered when a node text value is changed

3595

<> * @event

3596

<> * @name set_text.jstree

3597

<> * @param {Object} obj

3598

<> * @param {String} text the new value

3599

<> */

3600

<> this.trigger('set_text',{ "obj" : obj, "text" : val });

<> return true;

<> },

<> /**

<> * gets a JSON representation of a node (or the whole tree)

3605

<> * @name get_json([obj, options])

3606

<> * @param {mixed} obj

3607

<> * @param {Object} options

3608

<> * @param {Boolean} options.no_state do not return state information

3609

<> * @param {Boolean} options.no_id do not return ID

3610

<> * @param {Boolean} options.no_children do not include children

3611

<> * @param {Boolean} options.no_data do not include node data

3612

<> * @param {Boolean} options.no_li_attr do not include LI attributes

3613

<> * @param {Boolean} options.no_a_attr do not include A attributes

3614

<> * @param {Boolean} options.flat return flat JSON instead of nested

3615

<> * @return {Object}

3616

<> */

3617

<> get_json : function (obj, options, flat) {

3618

<> obj = this.get_node(obj || $.jstree.root);

3619

<> if(!obj) { return false; }

3620

<> if(options && options.flat && !flat) { flat = []; }

3621

<> var tmp = {

3622

<> 'id' : obj.id,

3623

<> 'text' : obj.text,

3624

<> 'icon' : this.get_icon(obj),

3625

<> 'li_attr' : $.extend(true, {}, obj.li_attr),

3626

<> 'a_attr' : $.extend(true, {}, obj.a_attr),

3627

<> 'state' : {},

3628

<> 'data' : options && options.no_data ? false : $.extend(true, {}, obj.data)

3629

<> //( this.get_node(obj, true).length ? this.get_node(obj, true).data() : obj.data ),

3630

<> }, i, j;

3631

<> if(options && options.flat) {

3632

<> tmp.parent = obj.parent;

3633

<> }

3634

<> else {

3635

<> tmp.children = [];

3636

<> }

3637

<> if(!options || !options.no_state) {

3638

<> for(i in obj.state) {

3639

<> if(obj.state.hasOwnProperty(i)) {

3640

<> tmp.state[i] = obj.state[i];

<> }

<> }

<> } else {

<> delete tmp.state;

3645

<> }

3646

<> if(options && options.no_li_attr) {

3647

<> delete tmp.li_attr;

3648

<> }

3649

<> if(options && options.no_a_attr) {

3650

<> delete tmp.a_attr;

3651

<> }

3652

<> if(options && options.no_id) {

3653

<> delete tmp.id;

3654

<> if(tmp.li_attr && tmp.li_attr.id) {

3655

<> delete tmp.li_attr.id;

3656

<> }

3657

<> if(tmp.a_attr && tmp.a_attr.id) {

3658

<> delete tmp.a_attr.id;

3659

<> }

3660

<> }

3661

<> if(options && options.flat && obj.id !== $.jstree.root) {

3662

<> flat.push(tmp);

3663

<> }

3664

<> if(!options || !options.no_children) {

3665

<> for(i = 0, j = obj.children.length; i < j; i++) {

3666

<> if(options && options.flat) {

3667

<> this.get_json(obj.children[i], options, flat);

3668

<> }

3669

<> else {

3670

<> tmp.children.push(this.get_json(obj.children[i], options));

<> }

<> }

<> }

<> return options && options.flat ? flat : (obj.id === $.jstree.root ? tmp.children : tmp);

3675

<> },

3676

<> /**

3677

<> * create a new node (do not confuse with load_node)

3678

<> * @name create_node([par, node, pos, callback, is_loaded])

3679

<> * @param {mixed} par the parent node (to create a root node use either "#" (string) or `null`)

3680

<> * @param {mixed} node the data for the new node (a valid JSON object, or a simple string with the name)

3681

<>		 * @param  {mixed}   pos       the index at which to insert the node, "first" and "last" are also supported, default is "last"

3682

<> * @param {Function} callback a function to be called once the node is created

3683

<> * @param {Boolean} is_loaded internal argument indicating if the parent node was succesfully loaded

3684

<> * @return {String} the ID of the newly create node

3685

<> * @trigger model.jstree, create_node.jstree

3686

<> */

3687

<> create_node : function (par, node, pos, callback, is_loaded) {

3688

<> if(par === null) { par = $.jstree.root; }

3689

<> par = this.get_node(par);

3690

<> if(!par) { return false; }

3691

<> pos = pos === undefined ? "last" : pos;

3692

<> if(!pos.toString().match(/^(before|after)$/) && !is_loaded && !this.is_loaded(par)) {

3693

<> return this.load_node(par, function () { this.create_node(par, node, pos, callback, true); });

3694

<> }

3695

<> if(!node) { node = { "text" : this.get_string('New node') }; }

3696

<> if(typeof node === "string") { node = { "text" : node }; }

3697

<> if(node.text === undefined) { node.text = this.get_string('New node'); }

3698

<> var tmp, dpc, i, j;

3699

3700

<> if(par.id === $.jstree.root) {

3701

<> if(pos === "before") { pos = "first"; }

3702

<> if(pos === "after") { pos = "last"; }

<> }

<> switch(pos) {

<> case "before":

<> tmp = this.get_node(par.parent);

3707

<> pos = $.inArray(par.id, tmp.children);

<> par = tmp;

<> break;

<> case "after" :

<> tmp = this.get_node(par.parent);

3712

<> pos = $.inArray(par.id, tmp.children) + 1;

<> par = tmp;

<> break;

<> case "inside":

<> case "first":

<> pos = 0;

<> break;

<> case "last":

<> pos = par.children.length;

3721

<> break;

3722

<> default:

3723

<> if(!pos) { pos = 0; }

3724

<> break;

3725

<> }

3726

<> if(pos > par.children.length) { pos = par.children.length; }

3727

<> if(!node.id) { node.id = true; }

3728

<> if(!this.check("create_node", node, par, pos)) {

3729

<> this.settings.core.error.call(this, this._data.core.last_error);

3730

<> return false;

3731

<> }

3732

<> if(node.id === true) { delete node.id; }

3733

<> node = this._parse_model_from_json(node, par.id, par.parents.concat());

3734

<> if(!node) { return false; }

3735

<> tmp = this.get_node(node);

3736

<> dpc = [];

3737

<> dpc.push(node);

3738

<> dpc = dpc.concat(tmp.children_d);

3739

<> this.trigger('model', { "nodes" : dpc, "parent" : par.id });

3740

3741

<> par.children_d = par.children_d.concat(dpc);

3742

<> for(i = 0, j = par.parents.length; i < j; i++) {

3743

<> this._model.data[par.parents[i]].children_d = this._model.data[par.parents[i]].children_d.concat(dpc);

<> }

<> node = tmp;

<> tmp = [];

<> for(i = 0, j = par.children.length; i < j; i++) {

3748

<> tmp[i >= pos ? i+1 : i] = par.children[i];

3749

<> }

3750

<> tmp[pos] = node.id;

3751

<> par.children = tmp;

3752

3753

<> this.redraw_node(par, true);

3754

<> if(callback) { callback.call(this, this.get_node(node)); }

3755

<> /**

3756

<> * triggered when a node is created

3757

<> * @event

3758

<> * @name create_node.jstree

3759

<> * @param {Object} node

3760

<> * @param {String} parent the parent's ID

3761

<> * @param {Number} position the position of the new node among the parent's children

3762

<> */

3763

<> this.trigger('create_node', { "node" : this.get_node(node), "parent" : par.id, "position" : pos });

<> return node.id;

<> },

<> /**

<> * set the text value of a node

3768

<> * @name rename_node(obj, val)

3769

<> * @param {mixed} obj the node, you can pass an array to rename multiple nodes to the same name

3770

<> * @param {String} val the new text value

3771

<> * @return {Boolean}

3772

<> * @trigger rename_node.jstree

3773

<> */

3774

<> rename_node : function (obj, val) {

3775

<> var t1, t2, old;

3776

<> if($.isArray(obj)) {

3777

<> obj = obj.slice();

3778

<> for(t1 = 0, t2 = obj.length; t1 < t2; t1++) {

3779

<> this.rename_node(obj[t1], val);

<> }

<> return true;

<> }

<> obj = this.get_node(obj);

3784

<> if(!obj || obj.id === $.jstree.root) { return false; }

3785

<> old = obj.text;

3786

<> if(!this.check("rename_node", obj, this.get_parent(obj), val)) {

3787

<> this.settings.core.error.call(this, this._data.core.last_error);

3788

<> return false;

3789

<> }

3790

<> this.set_text(obj, val); // .apply(this, Array.prototype.slice.call(arguments))

3791

<> /**

3792

<> * triggered when a node is renamed

3793

<> * @event

3794

<> * @name rename_node.jstree

3795

<> * @param {Object} node

3796

<> * @param {String} text the new value

3797

<> * @param {String} old the old value

3798

<> */

3799

<> this.trigger('rename_node', { "node" : obj, "text" : val, "old" : old });

<> return true;

<> },

<> /**

<> * remove a node

<> * @name delete_node(obj)

3805

<> * @param {mixed} obj the node, you can pass an array to delete multiple nodes

3806

<> * @return {Boolean}

3807

<> * @trigger delete_node.jstree, changed.jstree

3808

<> */

3809

<> delete_node : function (obj) {

3810

<> var t1, t2, par, pos, tmp, i, j, k, l, c, top, lft;

3811

<> if($.isArray(obj)) {

3812

<> obj = obj.slice();

3813

<> for(t1 = 0, t2 = obj.length; t1 < t2; t1++) {

3814

<> this.delete_node(obj[t1]);

<> }

<> return true;

<> }

<> obj = this.get_node(obj);

3819

<> if(!obj || obj.id === $.jstree.root) { return false; }

3820

<> par = this.get_node(obj.parent);

3821

<> pos = $.inArray(obj.id, par.children);

3822

<> c = false;

3823

<> if(!this.check("delete_node", obj, par, pos)) {

3824

<> this.settings.core.error.call(this, this._data.core.last_error);

3825

<> return false;

3826

<> }

3827

<> if(pos !== -1) {

3828

<> par.children = $.vakata.array_remove(par.children, pos);

3829

<> }

3830

<> tmp = obj.children_d.concat([]);

3831

<> tmp.push(obj.id);

3832

<> for(i = 0, j = obj.parents.length; i < j; i++) {

3833

<>				this._model.data[obj.parents[i]].children_d = $.vakata.array_filter(this._model.data[obj.parents[i]].children_d, function (v) {

3834

<> return $.inArray(v, tmp) === -1;

3835

<> });

3836

<> }

3837

<> for(k = 0, l = tmp.length; k < l; k++) {

3838

<> if(this._model.data[tmp[k]].state.selected) {

<> c = true;

<> break;

<> }

<> }

<> if (c) {

<> this._data.core.selected = $.vakata.array_filter(this._data.core.selected, function (v) {

3845

<> return $.inArray(v, tmp) === -1;

<> });

<> }

<> /**

<> * triggered when a node is deleted

3850

<> * @event

3851

<> * @name delete_node.jstree

3852

<> * @param {Object} node

3853

<> * @param {String} parent the parent's ID

3854

<> */

3855

<> this.trigger('delete_node', { "node" : obj, "parent" : par.id });

3856

<> if(c) {

3857

<>				this.trigger('changed', { 'action' : 'delete_node', 'node' : obj, 'selected' : this._data.core.selected, 'parent' : par.id });

3858

<> }

3859

<> for(k = 0, l = tmp.length; k < l; k++) {

3860

<> delete this._model.data[tmp[k]];

3861

<> }

3862

<> if($.inArray(this._data.core.focused, tmp) !== -1) {

3863

<> this._data.core.focused = null;

3864

<> top = this.element[0].scrollTop;

3865

<> lft = this.element[0].scrollLeft;

3866

<> if(par.id === $.jstree.root) {

3867

<> if (this._model.data[$.jstree.root].children[0]) {

3868

<> this.get_node(this._model.data[$.jstree.root].children[0], true).children('.jstree-anchor').focus();

<> }

<> }

<> else {

<> this.get_node(par, true).children('.jstree-anchor').focus();

3873

<> }

3874

<> this.element[0].scrollTop = top;

3875

<> this.element[0].scrollLeft = lft;

3876

<> }

3877

<> this.redraw_node(par, true);

<> return true;

<> },

<> /**

<> * check if an operation is premitted on the tree. Used internally.

3882

<> * @private

3883

<> * @name check(chk, obj, par, pos)

3884

<>		 * @param  {String} chk the operation to check, can be "create_node", "rename_node", "delete_node", "copy_node" or "move_node"

3885

<> * @param {mixed} obj the node

3886

<> * @param {mixed} par the parent

3887

<> * @param {mixed} pos the position to insert at, or if "rename_node" - the new name

3888

<>		 * @param  {mixed} more some various additional information, for example if a "move_node" operations is triggered by DND this will be the hovered node

3889

<> * @return {Boolean}

3890

<> */

3891

<> check : function (chk, obj, par, pos, more) {

3892

<> obj = obj && obj.id ? obj : this.get_node(obj);

3893

<> par = par && par.id ? par : this.get_node(par);

3894

<> var tmp = chk.match(/^move_node|copy_node|create_node$/i) ? par : obj,

3895

<> chc = this.settings.core.check_callback;

3896

<> if(chk === "move_node" || chk === "copy_node") {

3897

<>				if((!more || !more.is_multi) && (obj.id === par.id || (chk === "move_node" && $.inArray(obj.id, par.children) === pos) || $.inArray(par.id, obj.children_d) !== -1)) {

3898

<>					this._data.core.last_error = { 'error' : 'check', 'plugin' : 'core', 'id' : 'core_01', 'reason' : 'Moving parent inside child', 'data' : JSON.stringify({ 'chk' : chk, 'pos' : pos, 'obj' : obj && obj.id ? obj.id : false, 'par' : par && par.id ? par.id : false }) };

<> return false;

<> }

<> }

<> if(tmp && tmp.data) { tmp = tmp.data; }

3903

<> if(tmp && tmp.functions && (tmp.functions[chk] === false || tmp.functions[chk] === true)) {

3904

<> if(tmp.functions[chk] === false) {

3905

<>					this._data.core.last_error = { 'error' : 'check', 'plugin' : 'core', 'id' : 'core_02', 'reason' : 'Node data prevents function: ' + chk, 'data' : JSON.stringify({ 'chk' : chk, 'pos' : pos, 'obj' : obj && obj.id ? obj.id : false, 'par' : par && par.id ? par.id : false }) };

3906

<> }

3907

<> return tmp.functions[chk];

3908

<> }

3909

<>			if(chc === false || ($.isFunction(chc) && chc.call(this, chk, obj, par, pos, more) === false) || (chc && chc[chk] === false)) {

3910

<>				this._data.core.last_error = { 'error' : 'check', 'plugin' : 'core', 'id' : 'core_03', 'reason' : 'User config for core.check_callback prevents function: ' + chk, 'data' : JSON.stringify({ 'chk' : chk, 'pos' : pos, 'obj' : obj && obj.id ? obj.id : false, 'par' : par && par.id ? par.id : false }) };

<> return false;

<> }

<> return true;

<> },

<> /**

<> * get the last error

3917

<> * @name last_error()

3918

<> * @return {Object}

3919

<> */

3920

<> last_error : function () {

3921

<> return this._data.core.last_error;

3922

<> },

3923

<> /**

3924

<> * move a node to a new parent

3925

<> * @name move_node(obj, par [, pos, callback, is_loaded])

3926

<> * @param {mixed} obj the node to move, pass an array to move multiple nodes

3927

<> * @param {mixed} par the new parent

3928

<>		 * @param  {mixed} pos the position to insert at (besides integer values, "first" and "last" are supported, as well as "before" and "after"), defaults to integer `0`

3929

<>		 * @param  {function} callback a function to call once the move is completed, receives 3 arguments - the node, the new parent and the position

3930

<> * @param {Boolean} is_loaded internal parameter indicating if the parent node has been loaded

3931

<> * @param {Boolean} skip_redraw internal parameter indicating if the tree should be redrawn

3932

<> * @param {Boolean} instance internal parameter indicating if the node comes from another instance

3933

<> * @trigger move_node.jstree

3934

<> */

3935

<> move_node : function (obj, par, pos, callback, is_loaded, skip_redraw, origin) {

3936

<> var t1, t2, old_par, old_pos, new_par, old_ins, is_multi, dpc, tmp, i, j, k, l, p;

3937

3938

<> par = this.get_node(par);

3939

<> pos = pos === undefined ? 0 : pos;

3940

<> if(!par) { return false; }

3941

<> if(!pos.toString().match(/^(before|after)$/) && !is_loaded && !this.is_loaded(par)) {

3942

<> return this.load_node(par, function () { this.move_node(obj, par, pos, callback, true, false, origin); });

3943

<> }

3944

3945

<> if($.isArray(obj)) {

3946

<> if(obj.length === 1) {

<> obj = obj[0];

<> }

<> else {

<> //obj = obj.slice();

3951

<> for(t1 = 0, t2 = obj.length; t1 < t2; t1++) {

3952

<> if((tmp = this.move_node(obj[t1], par, pos, callback, is_loaded, false, origin))) {

<> par = tmp;

<> pos = "after";

<> }

<> }

<> this.redraw();

<> return true;

<> }

<> }

<> obj = obj && obj.id ? obj : this.get_node(obj);

3962

3963

<> if(!obj || obj.id === $.jstree.root) { return false; }

3964

3965

<> old_par = (obj.parent || $.jstree.root).toString();

3966

<>			new_par = (!pos.toString().match(/^(before|after)$/) || par.id === $.jstree.root) ? par : this.get_node(par.parent);

3967

<> old_ins = origin ? origin : (this._model.data[obj.id] ? this : $.jstree.reference(obj.id));

3968

<> is_multi = !old_ins || !old_ins._id || (this._id !== old_ins._id);

3969

<>			old_pos = old_ins && old_ins._id && old_par && old_ins._model.data[old_par] && old_ins._model.data[old_par].children ? $.inArray(obj.id, old_ins._model.data[old_par].children) : -1;

3970

<> if(old_ins && old_ins._id) {

3971

<> obj = old_ins._model.data[obj.id];

<> }

<> if(is_multi) {

<> if((tmp = this.copy_node(obj, par, pos, callback, is_loaded, false, origin))) {

3976

<> if(old_ins) { old_ins.delete_node(obj); }

<> return tmp;

<> }

<> return false;

<> }

<> //var m = this._model.data;

3982

<> if(par.id === $.jstree.root) {

3983

<> if(pos === "before") { pos = "first"; }

3984

<> if(pos === "after") { pos = "last"; }

<> }

<> switch(pos) {

<> case "before":

<> pos = $.inArray(par.id, new_par.children);

3989

<> break;

3990

<> case "after" :

3991

<> pos = $.inArray(par.id, new_par.children) + 1;

<> break;

<> case "inside":

<> case "first":

<> pos = 0;

<> break;

<> case "last":

<> pos = new_par.children.length;

3999

<> break;

4000

<> default:

4001

<> if(!pos) { pos = 0; }

4002

<> break;

4003

<> }

4004

<> if(pos > new_par.children.length) { pos = new_par.children.length; }

4005

<>			if(!this.check("move_node", obj, new_par, pos, { 'core' : true, 'origin' : origin, 'is_multi' : (old_ins && old_ins._id && old_ins._id !== this._id), 'is_foreign' : (!old_ins || !old_ins._id) })) {

4006

<> this.settings.core.error.call(this, this._data.core.last_error);

4007

<> return false;

4008

<> }

4009

<> if(obj.parent === new_par.id) {

4010

<> dpc = new_par.children.concat();

4011

<> tmp = $.inArray(obj.id, dpc);

4012

<> if(tmp !== -1) {

4013

<> dpc = $.vakata.array_remove(dpc, tmp);

4014

<> if(pos > tmp) { pos--; }

4015

<> }

4016

<> tmp = [];

4017

<> for(i = 0, j = dpc.length; i < j; i++) {

4018

<> tmp[i >= pos ? i+1 : i] = dpc[i];

4019

<> }

4020

<> tmp[pos] = obj.id;

4021

<> new_par.children = tmp;

4022

<> this._node_changed(new_par.id);

4023

<> this.redraw(new_par.id === $.jstree.root);

4024

<> }

4025

<> else {

4026

<> // clean old parent and up

4027

<> tmp = obj.children_d.concat();

4028

<> tmp.push(obj.id);

4029

<> for(i = 0, j = obj.parents.length; i < j; i++) {

4030

<> dpc = [];

4031

<> p = old_ins._model.data[obj.parents[i]].children_d;

4032

<> for(k = 0, l = p.length; k < l; k++) {

4033

<> if($.inArray(p[k], tmp) === -1) {

<> dpc.push(p[k]);

<> }

<> }

<> old_ins._model.data[obj.parents[i]].children_d = dpc;

4038

<> }

4039

<> old_ins._model.data[old_par].children = $.vakata.array_remove_item(old_ins._model.data[old_par].children, obj.id);

4040

4041

<> // insert into new parent and up

4042

<> for(i = 0, j = new_par.parents.length; i < j; i++) {

4043

<> this._model.data[new_par.parents[i]].children_d = this._model.data[new_par.parents[i]].children_d.concat(tmp);

4044

<> }

4045

<> dpc = [];

4046

<> for(i = 0, j = new_par.children.length; i < j; i++) {

4047

<> dpc[i >= pos ? i+1 : i] = new_par.children[i];

4048

<> }

4049

<> dpc[pos] = obj.id;

4050

<> new_par.children = dpc;

4051

<> new_par.children_d.push(obj.id);

4052

<> new_par.children_d = new_par.children_d.concat(obj.children_d);

4053

4054

<> // update object

4055

<> obj.parent = new_par.id;

4056

<> tmp = new_par.parents.concat();

4057

<> tmp.unshift(new_par.id);

4058

<> p = obj.parents.length;

4059

<> obj.parents = tmp;

4060

4061

<> // update object children

4062

<> tmp = tmp.concat();

4063

<> for(i = 0, j = obj.children_d.length; i < j; i++) {

4064

<> this._model.data[obj.children_d[i]].parents = this._model.data[obj.children_d[i]].parents.slice(0,p*-1);

4065

<> Array.prototype.push.apply(this._model.data[obj.children_d[i]].parents, tmp);

4066

<> }

4067

4068

<> if(old_par === $.jstree.root || new_par.id === $.jstree.root) {

4069

<> this._model.force_full_redraw = true;

4070

<> }

4071

<> if(!this._model.force_full_redraw) {

4072

<> this._node_changed(old_par);

4073

<> this._node_changed(new_par.id);

4074

<> }

4075

<> if(!skip_redraw) {

<> this.redraw();

<> }

<> }

<> if(callback) { callback.call(this, obj, new_par, pos); }

4080

<> /**

4081

<> * triggered when a node is moved

4082

<> * @event

4083

<> * @name move_node.jstree

4084

<> * @param {Object} node

4085

<> * @param {String} parent the parent's ID

4086

<> * @param {Number} position the position of the node among the parent's children

4087

<> * @param {String} old_parent the old parent of the node

4088

<> * @param {Number} old_position the old position of the node

4089

<> * @param {Boolean} is_multi do the node and new parent belong to different instances

4090

<> * @param {jsTree} old_instance the instance the node came from

4091

<> * @param {jsTree} new_instance the instance of the new parent

4092

<> */

4093

<>			this.trigger('move_node', { "node" : obj, "parent" : new_par.id, "position" : pos, "old_parent" : old_par, "old_position" : old_pos, 'is_multi' : (old_ins && old_ins._id && old_ins._id !== this._id), 'is_foreign' : (!old_ins || !old_ins._id), 'old_instance' : old_ins, 'new_instance' : this });

<> return obj.id;

<> },

<> /**

<> * copy a node to a new parent

4098

<> * @name copy_node(obj, par [, pos, callback, is_loaded])

4099

<> * @param {mixed} obj the node to copy, pass an array to copy multiple nodes

4100

<> * @param {mixed} par the new parent

4101

<>		 * @param  {mixed} pos the position to insert at (besides integer values, "first" and "last" are supported, as well as "before" and "after"), defaults to integer `0`

4102

<>		 * @param  {function} callback a function to call once the move is completed, receives 3 arguments - the node, the new parent and the position

4103

<> * @param {Boolean} is_loaded internal parameter indicating if the parent node has been loaded

4104

<> * @param {Boolean} skip_redraw internal parameter indicating if the tree should be redrawn

4105

<> * @param {Boolean} instance internal parameter indicating if the node comes from another instance

4106

<> * @trigger model.jstree copy_node.jstree

4107

<> */

4108

<> copy_node : function (obj, par, pos, callback, is_loaded, skip_redraw, origin) {

4109

<> var t1, t2, dpc, tmp, i, j, node, old_par, new_par, old_ins, is_multi;

4110

4111

<> par = this.get_node(par);

4112

<> pos = pos === undefined ? 0 : pos;

4113

<> if(!par) { return false; }

4114

<> if(!pos.toString().match(/^(before|after)$/) && !is_loaded && !this.is_loaded(par)) {

4115

<> return this.load_node(par, function () { this.copy_node(obj, par, pos, callback, true, false, origin); });

4116

<> }

4117

4118

<> if($.isArray(obj)) {

4119

<> if(obj.length === 1) {

<> obj = obj[0];

<> }

<> else {

<> //obj = obj.slice();

4124

<> for(t1 = 0, t2 = obj.length; t1 < t2; t1++) {

4125

<> if((tmp = this.copy_node(obj[t1], par, pos, callback, is_loaded, true, origin))) {

<> par = tmp;

<> pos = "after";

<> }

<> }

<> this.redraw();

<> return true;

<> }

<> }

<> obj = obj && obj.id ? obj : this.get_node(obj);

4135

<> if(!obj || obj.id === $.jstree.root) { return false; }

4136

4137

<> old_par = (obj.parent || $.jstree.root).toString();

4138

<>			new_par = (!pos.toString().match(/^(before|after)$/) || par.id === $.jstree.root) ? par : this.get_node(par.parent);

4139

<> old_ins = origin ? origin : (this._model.data[obj.id] ? this : $.jstree.reference(obj.id));

4140

<> is_multi = !old_ins || !old_ins._id || (this._id !== old_ins._id);

4141

4142

<> if(old_ins && old_ins._id) {

4143

<> obj = old_ins._model.data[obj.id];

4144

<> }

4145

4146

<> if(par.id === $.jstree.root) {

4147

<> if(pos === "before") { pos = "first"; }

4148

<> if(pos === "after") { pos = "last"; }

<> }

<> switch(pos) {

<> case "before":

<> pos = $.inArray(par.id, new_par.children);

4153

<> break;

4154

<> case "after" :

4155

<> pos = $.inArray(par.id, new_par.children) + 1;

<> break;

<> case "inside":

<> case "first":

<> pos = 0;

<> break;

<> case "last":

<> pos = new_par.children.length;

4163

<> break;

4164

<> default:

4165

<> if(!pos) { pos = 0; }

4166

<> break;

4167

<> }

4168

<> if(pos > new_par.children.length) { pos = new_par.children.length; }

4169

<>			if(!this.check("copy_node", obj, new_par, pos, { 'core' : true, 'origin' : origin, 'is_multi' : (old_ins && old_ins._id && old_ins._id !== this._id), 'is_foreign' : (!old_ins || !old_ins._id) })) {

4170

<> this.settings.core.error.call(this, this._data.core.last_error);

4171

<> return false;

4172

<> }

4173

<> node = old_ins ? old_ins.get_json(obj, { no_id : true, no_data : true, no_state : true }) : obj;

4174

<> if(!node) { return false; }

4175

<> if(node.id === true) { delete node.id; }

4176

<> node = this._parse_model_from_json(node, new_par.id, new_par.parents.concat());

4177

<> if(!node) { return false; }

4178

<> tmp = this.get_node(node);

4179

<> if(obj && obj.state && obj.state.loaded === false) { tmp.state.loaded = false; }

4180

<> dpc = [];

4181

<> dpc.push(node);

4182

<> dpc = dpc.concat(tmp.children_d);

4183

<> this.trigger('model', { "nodes" : dpc, "parent" : new_par.id });

4184

4185

<> // insert into new parent and up

4186

<> for(i = 0, j = new_par.parents.length; i < j; i++) {

4187

<> this._model.data[new_par.parents[i]].children_d = this._model.data[new_par.parents[i]].children_d.concat(dpc);

4188

<> }

4189

<> dpc = [];

4190

<> for(i = 0, j = new_par.children.length; i < j; i++) {

4191

<> dpc[i >= pos ? i+1 : i] = new_par.children[i];

4192

<> }

4193

<> dpc[pos] = tmp.id;

4194

<> new_par.children = dpc;

4195

<> new_par.children_d.push(tmp.id);

4196

<> new_par.children_d = new_par.children_d.concat(tmp.children_d);

4197

4198

<> if(new_par.id === $.jstree.root) {

4199

<> this._model.force_full_redraw = true;

4200

<> }

4201

<> if(!this._model.force_full_redraw) {

4202

<> this._node_changed(new_par.id);

4203

<> }

4204

<> if(!skip_redraw) {

4205

<> this.redraw(new_par.id === $.jstree.root);

4206

<> }

4207

<> if(callback) { callback.call(this, tmp, new_par, pos); }

4208

<> /**

4209

<> * triggered when a node is copied

4210

<> * @event

4211

<> * @name copy_node.jstree

4212

<> * @param {Object} node the copied node

4213

<> * @param {Object} original the original node

4214

<> * @param {String} parent the parent's ID

4215

<> * @param {Number} position the position of the node among the parent's children

4216

<> * @param {String} old_parent the old parent of the node

4217

<> * @param {Number} old_position the position of the original node

4218

<> * @param {Boolean} is_multi do the node and new parent belong to different instances

4219

<> * @param {jsTree} old_instance the instance the node came from

4220

<> * @param {jsTree} new_instance the instance of the new parent

4221

<> */

4222

<>			this.trigger('copy_node', { "node" : tmp, "original" : obj, "parent" : new_par.id, "position" : pos, "old_parent" : old_par, "old_position" : old_ins && old_ins._id && old_par && old_ins._model.data[old_par] && old_ins._model.data[old_par].children ? $.inArray(obj.id, old_ins._model.data[old_par].children) : -1,'is_multi' : (old_ins && old_ins._id && old_ins._id !== this._id), 'is_foreign' : (!old_ins || !old_ins._id), 'old_instance' : old_ins, 'new_instance' : this });

<> return tmp.id;

<> },

<> /**

<> * cut a node (a later call to `paste(obj)` would move the node)

4227

<> * @name cut(obj)

4228

<> * @param {mixed} obj multiple objects can be passed using an array

4229

<> * @trigger cut.jstree

4230

<> */

4231

<> cut : function (obj) {

4232

<> if(!obj) { obj = this._data.core.selected.concat(); }

4233

<> if(!$.isArray(obj)) { obj = [obj]; }

4234

<> if(!obj.length) { return false; }

4235

<> var tmp = [], o, t1, t2;

4236

<> for(t1 = 0, t2 = obj.length; t1 < t2; t1++) {

4237

<> o = this.get_node(obj[t1]);

4238

<> if(o && o.id && o.id !== $.jstree.root) { tmp.push(o); }

4239

<> }

4240

<> if(!tmp.length) { return false; }

4241

<> ccp_node = tmp;

4242

<> ccp_inst = this;

4243

<> ccp_mode = 'move_node';

4244

<> /**

4245

<> * triggered when nodes are added to the buffer for moving

4246

<> * @event

4247

<> * @name cut.jstree

4248

<> * @param {Array} node

4249

<> */

4250

<> this.trigger('cut', { "node" : obj });

4251

<> },

4252

<> /**

4253

<> * copy a node (a later call to `paste(obj)` would copy the node)

4254

<> * @name copy(obj)

4255

<> * @param {mixed} obj multiple objects can be passed using an array

4256

<> * @trigger copy.jstree

4257

<> */

4258

<> copy : function (obj) {

4259

<> if(!obj) { obj = this._data.core.selected.concat(); }

4260

<> if(!$.isArray(obj)) { obj = [obj]; }

4261

<> if(!obj.length) { return false; }

4262

<> var tmp = [], o, t1, t2;

4263

<> for(t1 = 0, t2 = obj.length; t1 < t2; t1++) {

4264

<> o = this.get_node(obj[t1]);

4265

<> if(o && o.id && o.id !== $.jstree.root) { tmp.push(o); }

4266

<> }

4267

<> if(!tmp.length) { return false; }

4268

<> ccp_node = tmp;

4269

<> ccp_inst = this;

4270

<> ccp_mode = 'copy_node';

4271

<> /**

4272

<> * triggered when nodes are added to the buffer for copying

4273

<> * @event

4274

<> * @name copy.jstree

4275

<> * @param {Array} node

4276

<> */

4277

<> this.trigger('copy', { "node" : obj });

4278

<> },

4279

<> /**

4280

<> * get the current buffer (any nodes that are waiting for a paste operation)

4281

<> * @name get_buffer()

4282

<>		 * @return {Object} an object consisting of `mode` ("copy_node" or "move_node"), `node` (an array of objects) and `inst` (the instance)

4283

<> */

4284

<> get_buffer : function () {

4285

<> return { 'mode' : ccp_mode, 'node' : ccp_node, 'inst' : ccp_inst };

4286

<> },

4287

<> /**

4288

<> * check if there is something in the buffer to paste

4289

<> * @name can_paste()

4290

<> * @return {Boolean}

4291

<> */

4292

<> can_paste : function () {

4293

<> return ccp_mode !== false && ccp_node !== false; // && ccp_inst._model.data[ccp_node];

4294

<> },

4295

<> /**

4296

<> * copy or move the previously cut or copied nodes to a new parent

4297

<> * @name paste(obj [, pos])

4298

<> * @param {mixed} obj the new parent

4299

<>		 * @param  {mixed} pos the position to insert at (besides integer, "first" and "last" are supported), defaults to integer `0`

4300

<> * @trigger paste.jstree

4301

<> */

4302

<> paste : function (obj, pos) {

4303

<> obj = this.get_node(obj);

4304

<> if(!obj || !ccp_mode || !ccp_mode.match(/^(copy_node|move_node)$/) || !ccp_node) { return false; }

4305

<> if(this[ccp_mode](ccp_node, obj, pos, false, false, false, ccp_inst)) {

4306

<> /**

4307

<> * triggered when paste is invoked

4308

<> * @event

4309

<> * @name paste.jstree

4310

<> * @param {String} parent the ID of the receiving node

4311

<> * @param {Array} node the nodes in the buffer

4312

<> * @param {String} mode the performed operation - "copy_node" or "move_node"

4313

<> */

4314

<> this.trigger('paste', { "parent" : obj.id, "node" : ccp_node, "mode" : ccp_mode });

4315

<> }

4316

<> ccp_node = false;

4317

<> ccp_mode = false;

4318

<> ccp_inst = false;

4319

<> },

4320

<> /**

4321

<> * clear the buffer of previously copied or cut nodes

4322

<> * @name clear_buffer()

4323

<> * @trigger clear_buffer.jstree

4324

<> */

4325

<> clear_buffer : function () {

4326

<> ccp_node = false;

4327

<> ccp_mode = false;

4328

<> ccp_inst = false;

4329

<> /**

4330

<> * triggered when the copy / cut buffer is cleared

4331

<> * @event

4332

<> * @name clear_buffer.jstree

4333

<> */

4334

<> this.trigger('clear_buffer');

4335

<> },

4336

<> /**

4337

<> * put a node in edit mode (input field to rename the node)

4338

<> * @name edit(obj [, default_text, callback])

4339

<> * @param {mixed} obj

4340

<>		 * @param  {String} default_text the text to populate the input with (if omitted or set to a non-string value the node's text value is used)

4341

<>		 * @param  {Function} callback a function to be called once the text box is blurred, it is called in the instance's scope and receives the node, a status parameter (true if the rename is successful, false otherwise) and a boolean indicating if the user cancelled the edit. You can access the node's title using .text

4342

<> */

4343

<> edit : function (obj, default_text, callback) {

4344

<> var rtl, w, a, s, t, h1, h2, fn, tmp, cancel = false;

4345

<> obj = this.get_node(obj);

4346

<> if(!obj) { return false; }

4347

<> if(this.settings.core.check_callback === false) {

4348

<>				this._data.core.last_error = { 'error' : 'check', 'plugin' : 'core', 'id' : 'core_07', 'reason' : 'Could not edit node because of check_callback' };

4349

<> this.settings.core.error.call(this, this._data.core.last_error);

<> return false;

<> }

<> tmp = obj;

<> default_text = typeof default_text === 'string' ? default_text : obj.text;

4354

<> this.set_text(obj, "");

4355

<> obj = this._open_to(obj);

4356

<> tmp.text = default_text;

4357

4358

<> rtl = this._data.core.rtl;

4359

<> w = this.element.width();

4360

<> this._data.core.focused = tmp.id;

4361

<> a = obj.children('.jstree-anchor').focus();

4362

<> s = $('<span>');

4363

<> /*!

4364

<> oi = obj.children("i:visible"),

4365

<> ai = a.children("i:visible"),

4366

<> w1 = oi.width() * oi.length,

4367

<> w2 = ai.width() * ai.length,

4368

<> */

4369

<> t = default_text;

4370

<>			h1 = $("<"+"div />", { css : { "position" : "absolute", "top" : "-200px", "left" : (rtl ? "0px" : "-1000px"), "visibility" : "hidden" } }).appendTo("body");

4371

<> h2 = $("<"+"input />", {

4372

<> "value" : t,

4373

<> "class" : "jstree-rename-input",

4374

<> // "size" : t.length,

4375

<> "css" : {

4376

<> "padding" : "0",

4377

<> "border" : "1px solid silver",

4378

<> "box-sizing" : "border-box",

4379

<> "display" : "inline-block",

4380

<> "height" : (this._data.core.li_height) + "px",

4381

<> "lineHeight" : (this._data.core.li_height) + "px",

4382

<> "width" : "150px" // will be set a bit further down

4383

<> },

4384

<> "blur" : $.proxy(function (e) {

4385

<> e.stopImmediatePropagation();

4386

<> e.preventDefault();

4387

<> var i = s.children(".jstree-rename-input"),

4388

<> v = i.val(),

4389

<> f = this.settings.core.force_text,

4390

<> nv;

4391

<> if(v === "") { v = t; }

4392

<> h1.remove();

4393

<> s.replaceWith(a);

4394

<> s.remove();

4395

<> t = f ? t : $('<div></div>').append($.parseHTML(t)).html();

4396

<> this.set_text(obj, t);

4397

<>							nv = !!this.rename_node(obj, f ? $('<div></div>').text(v).text() : $('<div></div>').append($.parseHTML(v)).html());

4398

<> if(!nv) {

4399

<> this.set_text(obj, t); // move this up? and fix #483

4400

<> }

4401

<> this._data.core.focused = tmp.id;

4402

<> setTimeout($.proxy(function () {

4403

<> var node = this.get_node(tmp.id, true);

4404

<> if(node.length) {

4405

<> this._data.core.focused = tmp.id;

4406

<> node.children('.jstree-anchor').focus();

<> }

<> }, this), 0);

<> if(callback) {

<> callback.call(this, tmp, nv, cancel);

<> }

<> h2 = null;

<> }, this),

<> "keydown" : function (e) {

4415

<> var key = e.which;

4416

<> if(key === 27) {

<> cancel = true;

<> this.value = t;

<> }

<> if(key === 27 || key === 13 || key === 37 || key === 38 || key === 39 || key === 40 || key === 32) {

4421

<> e.stopImmediatePropagation();

4422

<> }

4423

<> if(key === 27 || key === 13) {

4424

<> e.preventDefault();

<> this.blur();

<> }

<> },

<> "click" : function (e) { e.stopImmediatePropagation(); },

4429

<> "mousedown" : function (e) { e.stopImmediatePropagation(); },

4430

<> "keyup" : function (e) {

4431

<> h2.width(Math.min(h1.text("pW" + this.value).width(),w));

4432

<> },

4433

<> "keypress" : function(e) {

4434

<> if(e.which === 13) { return false; }

<> }

<> });

<> fn = {

<> fontFamily : a.css('fontFamily') || '',

4439

<> fontSize : a.css('fontSize') || '',

4440

<> fontWeight : a.css('fontWeight') || '',

4441

<> fontStyle : a.css('fontStyle') || '',

4442

<> fontStretch : a.css('fontStretch') || '',

4443

<> fontVariant : a.css('fontVariant') || '',

4444

<> letterSpacing : a.css('letterSpacing') || '',

4445

<> wordSpacing : a.css('wordSpacing') || ''

4446

<> };

4447

<> s.attr('class', a.attr('class')).append(a.contents().clone()).append(h2);

4448

<> a.replaceWith(s);

4449

<> h1.css(fn);

4450

<> h2.css(fn).width(Math.min(h1.text("pW" + h2[0].value).width(),w))[0].select();

4451

<> $(document).one('mousedown.jstree touchstart.jstree dnd_start.vakata', function (e) {

4452

<> if (h2 && e.target !== h2) {

<> $(h2).blur();

<> }

<> });

<> },

<> /**

<> * changes the theme

4461

<> * @name set_theme(theme_name [, theme_url])

4462

<> * @param {String} theme_name the name of the new theme to apply

4463

<>		 * @param {mixed} theme_url  the location of the CSS file for this theme. Omit or set to `false` if you manually included the file. Set to `true` to autoload from the `core.themes.dir` directory.

4464

<> * @trigger set_theme.jstree

4465

<> */

4466

<> set_theme : function (theme_name, theme_url) {

4467

<> if(!theme_name) { return false; }

4468

<> if(theme_url === true) {

4469

<> var dir = this.settings.core.themes.dir;

4470

<> if(!dir) { dir = $.jstree.path + '/themes'; }

4471

<> theme_url = dir + '/' + theme_name + '/style.css';

4472

<> }

4473

<> if(theme_url && $.inArray(theme_url, themes_loaded) === -1) {

4474

<> $('head').append('<'+'link rel="stylesheet" href="' + theme_url + '" type="text/css" />');

4475

<> themes_loaded.push(theme_url);

4476

<> }

4477

<> if(this._data.core.themes.name) {

4478

<> this.element.removeClass('jstree-' + this._data.core.themes.name);

4479

<> }

4480

<> this._data.core.themes.name = theme_name;

4481

<> this.element.addClass('jstree-' + theme_name);

4482

<>			this.element[this.settings.core.themes.responsive ? 'addClass' : 'removeClass' ]('jstree-' + theme_name + '-responsive');

4483

<> /**

4484

<> * triggered when a theme is set

4485

<> * @event

4486

<> * @name set_theme.jstree

4487

<> * @param {String} theme the new theme

4488

<> */

4489

<> this.trigger('set_theme', { 'theme' : theme_name });

4490

<> },

4491

<> /**

4492

<> * gets the name of the currently applied theme name

4493

<> * @name get_theme()

4494

<> * @return {String}

4495

<> */

4496

<> get_theme : function () { return this._data.core.themes.name; },

4497

<> /**

4498

<> * changes the theme variant (if the theme has variants)

4499

<> * @name set_theme_variant(variant_name)

4500

<> * @param {String|Boolean} variant_name the variant to apply (if `false` is used the current variant is removed)

4501

<> */

4502

<> set_theme_variant : function (variant_name) {

4503

<> if(this._data.core.themes.variant) {

4504

<> this.element.removeClass('jstree-' + this._data.core.themes.name + '-' + this._data.core.themes.variant);

4505

<> }

4506

<> this._data.core.themes.variant = variant_name;

4507

<> if(variant_name) {

4508

<> this.element.addClass('jstree-' + this._data.core.themes.name + '-' + this._data.core.themes.variant);

<> }

<> },

<> /**

<> * gets the name of the currently applied theme variant

4513

<> * @name get_theme()

4514

<> * @return {String}

4515

<> */

4516

<> get_theme_variant : function () { return this._data.core.themes.variant; },

4517

<> /**

4518

<> * shows a striped background on the container (if the theme supports it)

4519

<> * @name show_stripes()

4520

<> */

4521

<>		show_stripes : function () { this._data.core.themes.stripes = true; this.get_container_ul().addClass("jstree-striped"); },

4522

<> /**

4523

<> * hides the striped background on the container

4524

<> * @name hide_stripes()

4525

<> */

4526

<>		hide_stripes : function () { this._data.core.themes.stripes = false; this.get_container_ul().removeClass("jstree-striped"); },

4527

<> /**

4528

<> * toggles the striped background on the container

4529

<> * @name toggle_stripes()

4530

<> */

4531

<>		toggle_stripes : function () { if(this._data.core.themes.stripes) { this.hide_stripes(); } else { this.show_stripes(); } },

4532

<> /**

4533

<> * shows the connecting dots (if the theme supports it)

4534

<> * @name show_dots()

4535

<> */

4536

<>		show_dots : function () { this._data.core.themes.dots = true; this.get_container_ul().removeClass("jstree-no-dots"); },

4537

<> /**

4538

<> * hides the connecting dots

4539

<> * @name hide_dots()

4540

<> */

4541

<>		hide_dots : function () { this._data.core.themes.dots = false; this.get_container_ul().addClass("jstree-no-dots"); },

4542

<> /**

4543

<> * toggles the connecting dots

4544

<> * @name toggle_dots()

4545

<> */

4546

<> toggle_dots : function () { if(this._data.core.themes.dots) { this.hide_dots(); } else { this.show_dots(); } },

4547

<> /**

4548

<> * show the node icons

4549

<> * @name show_icons()

4550

<> */

4551

<>		show_icons : function () { this._data.core.themes.icons = true; this.get_container_ul().removeClass("jstree-no-icons"); },

4552

<> /**

4553

<> * hide the node icons

4554

<> * @name hide_icons()

4555

<> */

4556

<>		hide_icons : function () { this._data.core.themes.icons = false; this.get_container_ul().addClass("jstree-no-icons"); },

4557

<> /**

4558

<> * toggle the node icons

4559

<> * @name toggle_icons()

4560

<> */

4561

<> toggle_icons : function () { if(this._data.core.themes.icons) { this.hide_icons(); } else { this.show_icons(); } },

4562

<> /**

4563

<> * set the node icon for a node

4564

<> * @name set_icon(obj, icon)

4565

<> * @param {mixed} obj

4566

<>		 * @param {String} icon the new icon - can be a path to an icon or a className, if using an image that is in the current directory use a `./` prefix, otherwise it will be detected as a class

4567

<> */

4568

<> set_icon : function (obj, icon) {

4569

<> var t1, t2, dom, old;

4570

<> if($.isArray(obj)) {

4571

<> obj = obj.slice();

4572

<> for(t1 = 0, t2 = obj.length; t1 < t2; t1++) {

4573

<> this.set_icon(obj[t1], icon);

<> }

<> return true;

<> }

<> obj = this.get_node(obj);

4578

<> if(!obj || obj.id === $.jstree.root) { return false; }

4579

<> old = obj.icon;

4580

<> obj.icon = icon === true || icon === null || icon === undefined || icon === '' ? true : icon;

4581

<> dom = this.get_node(obj, true).children(".jstree-anchor").children(".jstree-themeicon");

4582

<> if(icon === false) {

4583

<> this.hide_icon(obj);

4584

<> }

4585

<> else if(icon === true || icon === null || icon === undefined || icon === '') {

4586

<> dom.removeClass('jstree-themeicon-custom ' + old).css("background","").removeAttr("rel");

4587

<> if(old === false) { this.show_icon(obj); }

4588

<> }

4589

<> else if(icon.indexOf("/") === -1 && icon.indexOf(".") === -1) {

4590

<> dom.removeClass(old).css("background","");

4591

<> dom.addClass(icon + ' jstree-themeicon-custom').attr("rel",icon);

4592

<> if(old === false) { this.show_icon(obj); }

4593

<> }

4594

<> else {

4595

<> dom.removeClass(old).css("background","");

4596

<>				dom.addClass('jstree-themeicon-custom').css("background", "url('" + icon + "') center center no-repeat").attr("rel",icon);

4597

<> if(old === false) { this.show_icon(obj); }

<> }

<> return true;

<> },

<> /**

<> * get the node icon for a node

4603

<> * @name get_icon(obj)

4604

<> * @param {mixed} obj

4605

<> * @return {String}

4606

<> */

4607

<> get_icon : function (obj) {

4608

<> obj = this.get_node(obj);

4609

<> return (!obj || obj.id === $.jstree.root) ? false : obj.icon;

4610

<> },

4611

<> /**

4612

<> * hide the icon on an individual node

4613

<> * @name hide_icon(obj)

4614

<> * @param {mixed} obj

4615

<> */

4616

<> hide_icon : function (obj) {

4617

<> var t1, t2;

4618

<> if($.isArray(obj)) {

4619

<> obj = obj.slice();

4620

<> for(t1 = 0, t2 = obj.length; t1 < t2; t1++) {

4621

<> this.hide_icon(obj[t1]);

<> }

<> return true;

<> }

<> obj = this.get_node(obj);

4626

<> if(!obj || obj === $.jstree.root) { return false; }

4627

<> obj.icon = false;

4628

<>			this.get_node(obj, true).children(".jstree-anchor").children(".jstree-themeicon").addClass('jstree-themeicon-hidden');

<> return true;

<> },

<> /**

<> * show the icon on an individual node

4633

<> * @name show_icon(obj)

4634

<> * @param {mixed} obj

4635

<> */

4636

<> show_icon : function (obj) {

4637

<> var t1, t2, dom;

4638

<> if($.isArray(obj)) {

4639

<> obj = obj.slice();

4640

<> for(t1 = 0, t2 = obj.length; t1 < t2; t1++) {

4641

<> this.show_icon(obj[t1]);

<> }

<> return true;

<> }

<> obj = this.get_node(obj);

4646

<> if(!obj || obj === $.jstree.root) { return false; }

4647

<> dom = this.get_node(obj, true);

4648

<> obj.icon = dom.length ? dom.children(".jstree-anchor").children(".jstree-themeicon").attr('rel') : true;

4649

<> if(!obj.icon) { obj.icon = true; }

4650

<> dom.children(".jstree-anchor").children(".jstree-themeicon").removeClass('jstree-themeicon-hidden');

<> return true;

<> }

<> };

<> // helpers

<> $.vakata = {};

<> // collect attributes

4658

<> $.vakata.attributes = function(node, with_values) {

4659

<> node = $(node)[0];

4660

<> var attr = with_values ? {} : [];

4661

<> if(node && node.attributes) {

4662

<> $.each(node.attributes, function (i, v) {

4663

<> if($.inArray(v.name.toLowerCase(),['style','contenteditable','hasfocus','tabindex']) !== -1) { return; }

4664

<> if(v.value !== null && $.trim(v.value) !== '') {

4665

<> if(with_values) { attr[v.name] = v.value; }

4666

<> else { attr.push(v.name); }

<> }

<> });

<> }

<> return attr;

<> };

<> $.vakata.array_unique = function(array) {

4673

<> var a = [], i, j, l, o = {};

4674

<> for(i = 0, l = array.length; i < l; i++) {

4675

<> if(o[array[i]] === undefined) {

4676

<> a.push(array[i]);

4677

<> o[array[i]] = true;

<> }

<> }

<> return a;

<> };

<> // remove item from array

4683

<> $.vakata.array_remove = function(array, from) {

4684

<> array.splice(from, 1);

4685

<> return array;

4686

<> //var rest = array.slice((to || from) + 1 || array.length);

4687

<> //array.length = from < 0 ? array.length + from : from;

4688

<> //array.push.apply(array, rest);

4689

<> //return array;

4690

<> };

4691

<> // remove item from array

4692

<> $.vakata.array_remove_item = function(array, item) {

4693

<> var tmp = $.inArray(item, array);

4694

<> return tmp !== -1 ? $.vakata.array_remove(array, tmp) : array;

4695

<> };

4696

<> $.vakata.array_filter = function(c,a,b,d,e) {

4697

<> if (c.filter) {

4698

<> return c.filter(a, b);

<> }

<> d=[];

<> for (e in c) {

<> if (~~e+''===e+'' && e>=0 && a.call(b,c[e],+e,c)) {

<> d.push(c[e]);

<> }

<> }

<> return d;

<> };

<>/**

<> * ### Changed plugin

4712

<> *

4713

<> * This plugin adds more information to the `changed.jstree` event. The new data is contained in the `changed` event data property, and contains a lists of `selected` and `deselected` nodes.

4714

<> */

4715

4716

<> $.jstree.plugins.changed = function (options, parent) {

4717

<> var last = [];

4718

<> this.trigger = function (ev, data) {

<> var i, j;

<> if(!data) {

<> data = {};

<> }

<> if(ev.replace('.jstree','') === 'changed') {

4724

<> data.changed = { selected : [], deselected : [] };

4725

<> var tmp = {};

4726

<> for(i = 0, j = last.length; i < j; i++) {

4727

<> tmp[last[i]] = 1;

4728

<> }

4729

<> for(i = 0, j = data.selected.length; i < j; i++) {

4730

<> if(!tmp[data.selected[i]]) {

4731

<> data.changed.selected.push(data.selected[i]);

4732

<> }

4733

<> else {

4734

<> tmp[data.selected[i]] = 2;

4735

<> }

4736

<> }

4737

<> for(i = 0, j = last.length; i < j; i++) {

4738

<> if(tmp[last[i]] === 1) {

4739

<> data.changed.deselected.push(last[i]);

4740

<> }

4741

<> }

4742

<> last = data.selected.slice();

4743

<> }

4744

<> /**

4745

<> * triggered when selection changes (the "changed" plugin enhances the original event with more data)

4746

<> * @event

4747

<> * @name changed.jstree

4748

<> * @param {Object} node

4749

<> * @param {Object} action the action that caused the selection to change

4750

<> * @param {Array} selected the current selection

4751

<>			 * @param {Object} changed an object containing two properties `selected` and `deselected` - both arrays of node IDs, which were selected or deselected since the last changed event

4752

<> * @param {Object} event the event (if any) that triggered this changed event

4753

<> * @plugin changed

4754

<> */

4755

<> parent.trigger.call(this, ev, data);

4756

<> };

4757

<> this.refresh = function (skip_loading, forget_state) {

4758

<> last = [];

4759

<> return parent.refresh.apply(this, arguments);

<> };

<> };

<>/**

<> * ### Checkbox plugin

4765

<> *

4766

<> * This plugin renders checkbox icons in front of each node, making multiple selection much easier.

4767

<> * It also supports tri-state behavior, meaning that if a node has a few of its children checked it will be rendered as undetermined, and state will be propagated up.

4768

<> */

4769

4770

<> var _i = document.createElement('I');

4771

<> _i.className = 'jstree-icon jstree-checkbox';

4772

<> _i.setAttribute('role', 'presentation');

4773

<> /**

4774

<> * stores all defaults for the checkbox plugin

4775

<> * @name $.jstree.defaults.checkbox

4776

<> * @plugin checkbox

4777

<> */

4778

<> $.jstree.defaults.checkbox = {

4779

<> /**

4780

<>		 * a boolean indicating if checkboxes should be visible (can be changed at a later time using `show_checkboxes()` and `hide_checkboxes`). Defaults to `true`.

4781

<> * @name $.jstree.defaults.checkbox.visible

4782

<> * @plugin checkbox

<> */

<> visible : true,

<> /**

<> * a boolean indicating if checkboxes should cascade down and have an undetermined state. Defaults to `true`.

4787

<> * @name $.jstree.defaults.checkbox.three_state

4788

<> * @plugin checkbox

4789

<> */

4790

<> three_state : true,

4791

<> /**

4792

<> * a boolean indicating if clicking anywhere on the node should act as clicking on the checkbox. Defaults to `true`.

4793

<> * @name $.jstree.defaults.checkbox.whole_node

4794

<> * @plugin checkbox

4795

<> */

4796

<> whole_node : true,

4797

<> /**

4798

<> * a boolean indicating if the selected style of a node should be kept, or removed. Defaults to `true`.

4799

<> * @name $.jstree.defaults.checkbox.keep_selected_style

4800

<> * @plugin checkbox

4801

<> */

4802

<> keep_selected_style : true,

4803

<> /**

4804

<> * This setting controls how cascading and undetermined nodes are applied.

4805

<>		 * If 'up' is in the string - cascading up is enabled, if 'down' is in the string - cascading down is enabled, if 'undetermined' is in the string - undetermined nodes will be used.

4806

<> * If `three_state` is set to `true` this setting is automatically set to 'up+down+undetermined'. Defaults to ''.

4807

<> * @name $.jstree.defaults.checkbox.cascade

4808

<> * @plugin checkbox

<> */

<> cascade : '',

<> /**

<>		 * This setting controls if checkbox are bound to the general tree selection or to an internal array maintained by the checkbox plugin. Defaults to `true`, only set to `false` if you know exactly what you are doing.

4813

<> * @name $.jstree.defaults.checkbox.tie_selection

4814

<> * @plugin checkbox

4815

<> */

4816

<> tie_selection : true

4817

<> };

4818

<> $.jstree.plugins.checkbox = function (options, parent) {

4819

<> this.bind = function () {

4820

<> parent.bind.call(this);

4821

<> this._data.checkbox.uto = false;

4822

<> this._data.checkbox.selected = [];

4823

<> if(this.settings.checkbox.three_state) {

4824

<> this.settings.checkbox.cascade = 'up+down+undetermined';

4825

<> }

4826

<> this.element

4827

<> .on("init.jstree", $.proxy(function () {

4828

<> this._data.checkbox.visible = this.settings.checkbox.visible;

4829

<> if(!this.settings.checkbox.keep_selected_style) {

4830

<> this.element.addClass('jstree-checkbox-no-clicked');

4831

<> }

4832

<> if(this.settings.checkbox.tie_selection) {

4833

<> this.element.addClass('jstree-checkbox-selection');

4834

<> }

4835

<> }, this))

4836

<> .on("loading.jstree", $.proxy(function () {

4837

<> this[ this._data.checkbox.visible ? 'show_checkboxes' : 'hide_checkboxes' ]();

4838

<> }, this));

4839

<> if(this.settings.checkbox.cascade.indexOf('undetermined') !== -1) {

4840

<> this.element

4841

<>					.on('changed.jstree uncheck_node.jstree check_node.jstree uncheck_all.jstree check_all.jstree move_node.jstree copy_node.jstree redraw.jstree open_node.jstree', $.proxy(function () {

4842

<> // only if undetermined is in setting

4843

<> if(this._data.checkbox.uto) { clearTimeout(this._data.checkbox.uto); }

4844

<> this._data.checkbox.uto = setTimeout($.proxy(this._undetermined, this), 50);

4845

<> }, this));

4846

<> }

4847

<> if(!this.settings.checkbox.tie_selection) {

4848

<> this.element

4849

<> .on('model.jstree', $.proxy(function (e, data) {

4850

<> var m = this._model.data,

4851

<> p = m[data.parent],

4852

<> dpc = data.nodes,

4853

<> i, j;

4854

<> for(i = 0, j = dpc.length; i < j; i++) {

4855

<>							m[dpc[i]].state.checked = m[dpc[i]].state.checked || (m[dpc[i]].original && m[dpc[i]].original.state && m[dpc[i]].original.state.checked);

4856

<> if(m[dpc[i]].state.checked) {

4857

<> this._data.checkbox.selected.push(dpc[i]);

<> }

<> }

<> }, this));

<> }

<> if(this.settings.checkbox.cascade.indexOf('up') !== -1 || this.settings.checkbox.cascade.indexOf('down') !== -1) {

4863

<> this.element

4864

<> .on('model.jstree', $.proxy(function (e, data) {

4865

<> var m = this._model.data,

4866

<> p = m[data.parent],

4867

<> dpc = data.nodes,

4868

<> chd = [],

4869

<> c, i, j, k, l, tmp, s = this.settings.checkbox.cascade, t = this.settings.checkbox.tie_selection;

4870

4871

<> if(s.indexOf('down') !== -1) {

4872

<> // apply down

4873

<> if(p.state[ t ? 'selected' : 'checked' ]) {

4874

<> for(i = 0, j = dpc.length; i < j; i++) {

4875

<> m[dpc[i]].state[ t ? 'selected' : 'checked' ] = true;

4876

<> }

4877

<> this._data[ t ? 'core' : 'checkbox' ].selected = this._data[ t ? 'core' : 'checkbox' ].selected.concat(dpc);

4878

<> }

4879

<> else {

4880

<> for(i = 0, j = dpc.length; i < j; i++) {

4881

<> if(m[dpc[i]].state[ t ? 'selected' : 'checked' ]) {

4882

<> for(k = 0, l = m[dpc[i]].children_d.length; k < l; k++) {

4883

<> m[m[dpc[i]].children_d[k]].state[ t ? 'selected' : 'checked' ] = true;

4884

<> }

4885

<>											this._data[ t ? 'core' : 'checkbox' ].selected = this._data[ t ? 'core' : 'checkbox' ].selected.concat(m[dpc[i]].children_d);

<> }

<> }

<> }

<> }

<> if(s.indexOf('up') !== -1) {

4892

<> // apply up

4893

<> for(i = 0, j = p.children_d.length; i < j; i++) {

4894

<> if(!m[p.children_d[i]].children.length) {

4895

<> chd.push(m[p.children_d[i]].parent);

4896

<> }

4897

<> }

4898

<> chd = $.vakata.array_unique(chd);

4899

<> for(k = 0, l = chd.length; k < l; k++) {

4900

<> p = m[chd[k]];

4901

<> while(p && p.id !== $.jstree.root) {

4902

<> c = 0;

4903

<> for(i = 0, j = p.children.length; i < j; i++) {

4904

<> c += m[p.children[i]].state[ t ? 'selected' : 'checked' ];

4905

<> }

4906

<> if(c === j) {

4907

<> p.state[ t ? 'selected' : 'checked' ] = true;

4908

<> this._data[ t ? 'core' : 'checkbox' ].selected.push(p.id);

4909

<> tmp = this.get_node(p, true);

4910

<> if(tmp && tmp.length) {

4911

<>												tmp.attr('aria-selected', true).children('.jstree-anchor').addClass( t ? 'jstree-clicked' : 'jstree-checked');

<> }

<> }

<> else {

<> break;

<> }

<> p = this.get_node(p.parent);

<> }

<> }

<> }

<>							this._data[ t ? 'core' : 'checkbox' ].selected = $.vakata.array_unique(this._data[ t ? 'core' : 'checkbox' ].selected);

4923

<> }, this))

4924

<>					.on(this.settings.checkbox.tie_selection ? 'select_node.jstree' : 'check_node.jstree', $.proxy(function (e, data) {

4925

<> var obj = data.node,

4926

<> m = this._model.data,

4927

<> par = this.get_node(obj.parent),

4928

<> dom = this.get_node(obj, true),

4929

<> i, j, c, tmp, s = this.settings.checkbox.cascade, t = this.settings.checkbox.tie_selection,

4930

<> sel = {}, cur = this._data[ t ? 'core' : 'checkbox' ].selected;

4931

4932

<> for (i = 0, j = cur.length; i < j; i++) {

4933

<> sel[cur[i]] = true;

4934

<> }

4935

<> // apply down

4936

<> if(s.indexOf('down') !== -1) {

4937

<>								//this._data[ t ? 'core' : 'checkbox' ].selected = $.vakata.array_unique(this._data[ t ? 'core' : 'checkbox' ].selected.concat(obj.children_d));

4938

<> for(i = 0, j = obj.children_d.length; i < j; i++) {

4939

<> sel[obj.children_d[i]] = true;

4940

<> tmp = m[obj.children_d[i]];

4941

<> tmp.state[ t ? 'selected' : 'checked' ] = true;

4942

<> if(tmp && tmp.original && tmp.original.state && tmp.original.state.undetermined) {

4943

<> tmp.original.state.undetermined = false;

<> }

<> }

<> }

<> // apply up

<> if(s.indexOf('up') !== -1) {

4950

<> while(par && par.id !== $.jstree.root) {

4951

<> c = 0;

4952

<> for(i = 0, j = par.children.length; i < j; i++) {

4953

<> c += m[par.children[i]].state[ t ? 'selected' : 'checked' ];

4954

<> }

4955

<> if(c === j) {

4956

<> par.state[ t ? 'selected' : 'checked' ] = true;

4957

<> sel[par.id] = true;

4958

<> //this._data[ t ? 'core' : 'checkbox' ].selected.push(par.id);

4959

<> tmp = this.get_node(par, true);

4960

<> if(tmp && tmp.length) {

4961

<>											tmp.attr('aria-selected', true).children('.jstree-anchor').addClass(t ? 'jstree-clicked' : 'jstree-checked');

<> }

<> }

<> else {

<> break;

<> }

<> par = this.get_node(par.parent);

<> }

<> }

<> cur = [];

<> for (i in sel) {

4973

<> if (sel.hasOwnProperty(i)) {

<> cur.push(i);

<> }

<> }

<> this._data[ t ? 'core' : 'checkbox' ].selected = cur;

4978

4979

<> // apply down (process .children separately?)

4980

<> if(s.indexOf('down') !== -1 && dom.length) {

4981

<>								dom.find('.jstree-anchor').addClass(t ? 'jstree-clicked' : 'jstree-checked').parent().attr('aria-selected', true);

4982

<> }

4983

<> }, this))

4984

<>					.on(this.settings.checkbox.tie_selection ? 'deselect_all.jstree' : 'uncheck_all.jstree', $.proxy(function (e, data) {

4985

<> var obj = this.get_node($.jstree.root),

4986

<> m = this._model.data,

4987

<> i, j, tmp;

4988

<> for(i = 0, j = obj.children_d.length; i < j; i++) {

4989

<> tmp = m[obj.children_d[i]];

4990

<> if(tmp && tmp.original && tmp.original.state && tmp.original.state.undetermined) {

4991

<> tmp.original.state.undetermined = false;

<> }

<> }

<> }, this))

<>					.on(this.settings.checkbox.tie_selection ? 'deselect_node.jstree' : 'uncheck_node.jstree', $.proxy(function (e, data) {

4996

<> var obj = data.node,

4997

<> dom = this.get_node(obj, true),

4998

<> i, j, tmp, s = this.settings.checkbox.cascade, t = this.settings.checkbox.tie_selection,

4999

<> cur = this._data[ t ? 'core' : 'checkbox' ].selected, sel = {};

5000

<> if(obj && obj.original && obj.original.state && obj.original.state.undetermined) {

5001

<> obj.original.state.undetermined = false;

<> }

<> // apply down

<> if(s.indexOf('down') !== -1) {

5006

<> for(i = 0, j = obj.children_d.length; i < j; i++) {

5007

<> tmp = this._model.data[obj.children_d[i]];

5008

<> tmp.state[ t ? 'selected' : 'checked' ] = false;

5009

<> if(tmp && tmp.original && tmp.original.state && tmp.original.state.undetermined) {

5010

<> tmp.original.state.undetermined = false;

<> }

<> }

<> }

<> // apply up

<> if(s.indexOf('up') !== -1) {

5017

<> for(i = 0, j = obj.parents.length; i < j; i++) {

5018

<> tmp = this._model.data[obj.parents[i]];

5019

<> tmp.state[ t ? 'selected' : 'checked' ] = false;

5020

<> if(tmp && tmp.original && tmp.original.state && tmp.original.state.undetermined) {

5021

<> tmp.original.state.undetermined = false;

5022

<> }

5023

<> tmp = this.get_node(obj.parents[i], true);

5024

<> if(tmp && tmp.length) {

5025

<>										tmp.attr('aria-selected', false).children('.jstree-anchor').removeClass(t ? 'jstree-clicked' : 'jstree-checked');

<> }

<> }

<> }

<> sel = {};

<> for(i = 0, j = cur.length; i < j; i++) {

5031

<> // apply down + apply up

5032

<> if(

5033

<> (s.indexOf('down') === -1 || $.inArray(cur[i], obj.children_d) === -1) &&

5034

<> (s.indexOf('up') === -1 || $.inArray(cur[i], obj.parents) === -1)

5035

<> ) {

5036

<> sel[cur[i]] = true;

<> }

<> }

<> cur = [];

<> for (i in sel) {

5041

<> if (sel.hasOwnProperty(i)) {

<> cur.push(i);

<> }

<> }

<> this._data[ t ? 'core' : 'checkbox' ].selected = cur;

5046

5047

<> // apply down (process .children separately?)

5048

<> if(s.indexOf('down') !== -1 && dom.length) {

5049

<>								dom.find('.jstree-anchor').removeClass(t ? 'jstree-clicked' : 'jstree-checked').parent().attr('aria-selected', false);

<> }

<> }, this));

<> }

<> if(this.settings.checkbox.cascade.indexOf('up') !== -1) {

5054

<> this.element

5055

<> .on('delete_node.jstree', $.proxy(function (e, data) {

5056

<> // apply up (whole handler)

5057

<> var p = this.get_node(data.parent),

5058

<> m = this._model.data,

5059

<> i, j, c, tmp, t = this.settings.checkbox.tie_selection;

5060

<> while(p && p.id !== $.jstree.root && !p.state[ t ? 'selected' : 'checked' ]) {

5061

<> c = 0;

5062

<> for(i = 0, j = p.children.length; i < j; i++) {

5063

<> c += m[p.children[i]].state[ t ? 'selected' : 'checked' ];

5064

<> }

5065

<> if(j > 0 && c === j) {

5066

<> p.state[ t ? 'selected' : 'checked' ] = true;

5067

<> this._data[ t ? 'core' : 'checkbox' ].selected.push(p.id);

5068

<> tmp = this.get_node(p, true);

5069

<> if(tmp && tmp.length) {

5070

<>										tmp.attr('aria-selected', true).children('.jstree-anchor').addClass(t ? 'jstree-clicked' : 'jstree-checked');

<> }

<> }

<> else {

<> break;

<> }

<> p = this.get_node(p.parent);

5077

<> }

5078

<> }, this))

5079

<> .on('move_node.jstree', $.proxy(function (e, data) {

5080

<> // apply up (whole handler)

5081

<> var is_multi = data.is_multi,

5082

<> old_par = data.old_parent,

5083

<> new_par = this.get_node(data.parent),

5084

<> m = this._model.data,

5085

<> p, c, i, j, tmp, t = this.settings.checkbox.tie_selection;

5086

<> if(!is_multi) {

5087

<> p = this.get_node(old_par);

5088

<> while(p && p.id !== $.jstree.root && !p.state[ t ? 'selected' : 'checked' ]) {

5089

<> c = 0;

5090

<> for(i = 0, j = p.children.length; i < j; i++) {

5091

<> c += m[p.children[i]].state[ t ? 'selected' : 'checked' ];

5092

<> }

5093

<> if(j > 0 && c === j) {

5094

<> p.state[ t ? 'selected' : 'checked' ] = true;

5095

<> this._data[ t ? 'core' : 'checkbox' ].selected.push(p.id);

5096

<> tmp = this.get_node(p, true);

5097

<> if(tmp && tmp.length) {

5098

<>											tmp.attr('aria-selected', true).children('.jstree-anchor').addClass(t ? 'jstree-clicked' : 'jstree-checked');

<> }

<> }

<> else {

<> break;

<> }

<> p = this.get_node(p.parent);

<> }

<> }

<> p = new_par;

<> while(p && p.id !== $.jstree.root) {

5109

<> c = 0;

5110

<> for(i = 0, j = p.children.length; i < j; i++) {

5111

<> c += m[p.children[i]].state[ t ? 'selected' : 'checked' ];

5112

<> }

5113

<> if(c === j) {

5114

<> if(!p.state[ t ? 'selected' : 'checked' ]) {

5115

<> p.state[ t ? 'selected' : 'checked' ] = true;

5116

<> this._data[ t ? 'core' : 'checkbox' ].selected.push(p.id);

5117

<> tmp = this.get_node(p, true);

5118

<> if(tmp && tmp.length) {

5119

<>											tmp.attr('aria-selected', true).children('.jstree-anchor').addClass(t ? 'jstree-clicked' : 'jstree-checked');

<> }

<> }

<> }

<> else {

<> if(p.state[ t ? 'selected' : 'checked' ]) {

5125

<> p.state[ t ? 'selected' : 'checked' ] = false;

5126

<>										this._data[ t ? 'core' : 'checkbox' ].selected = $.vakata.array_remove_item(this._data[ t ? 'core' : 'checkbox' ].selected, p.id);

5127

<> tmp = this.get_node(p, true);

5128

<> if(tmp && tmp.length) {

5129

<>											tmp.attr('aria-selected', false).children('.jstree-anchor').removeClass(t ? 'jstree-clicked' : 'jstree-checked');

<> }

<> }

<> else {

<> break;

<> }

<> }

<> p = this.get_node(p.parent);

<> }

<> }, this));

<> }

<> };

<> /**

<> * set the undetermined state where and if necessary. Used internally.

5143

<> * @private

5144

<> * @name _undetermined()

5145

<> * @plugin checkbox

5146

<> */

5147

<> this._undetermined = function () {

5148

<> if(this.element === null) { return; }

5149

<>			var i, j, k, l, o = {}, m = this._model.data, t = this.settings.checkbox.tie_selection, s = this._data[ t ? 'core' : 'checkbox' ].selected, p = [], tt = this;

5150

<> for(i = 0, j = s.length; i < j; i++) {

5151

<> if(m[s[i]] && m[s[i]].parents) {

5152

<> for(k = 0, l = m[s[i]].parents.length; k < l; k++) {

5153

<> if(o[m[s[i]].parents[k]] !== undefined) {

5154

<> break;

5155

<> }

5156

<> if(m[s[i]].parents[k] !== $.jstree.root) {

5157

<> o[m[s[i]].parents[k]] = true;

5158

<> p.push(m[s[i]].parents[k]);

<> }

<> }

<> }

<> }

<> // attempt for server side undetermined state

5164

<> this.element.find('.jstree-closed').not(':has(.jstree-children)')

5165

<> .each(function () {

5166

<> var tmp = tt.get_node(this), tmp2;

5167

<> if(!tmp.state.loaded) {

5168

<>						if(tmp.original && tmp.original.state && tmp.original.state.undetermined && tmp.original.state.undetermined === true) {

5169

<> if(o[tmp.id] === undefined && tmp.id !== $.jstree.root) {

5170

<> o[tmp.id] = true;

5171

<> p.push(tmp.id);

5172

<> }

5173

<> for(k = 0, l = tmp.parents.length; k < l; k++) {

5174

<> if(o[tmp.parents[k]] === undefined && tmp.parents[k] !== $.jstree.root) {

5175

<> o[tmp.parents[k]] = true;

5176

<> p.push(tmp.parents[k]);

<> }

<> }

<> }

<> }

<> else {

<> for(i = 0, j = tmp.children_d.length; i < j; i++) {

5183

<> tmp2 = m[tmp.children_d[i]];

5184

<>							if(!tmp2.state.loaded && tmp2.original && tmp2.original.state && tmp2.original.state.undetermined && tmp2.original.state.undetermined === true) {

5185

<> if(o[tmp2.id] === undefined && tmp2.id !== $.jstree.root) {

5186

<> o[tmp2.id] = true;

5187

<> p.push(tmp2.id);

5188

<> }

5189

<> for(k = 0, l = tmp2.parents.length; k < l; k++) {

5190

<> if(o[tmp2.parents[k]] === undefined && tmp2.parents[k] !== $.jstree.root) {

5191

<> o[tmp2.parents[k]] = true;

5192

<> p.push(tmp2.parents[k]);

<> }

<> }

<> }

<> }

<> }

<> });

<> this.element.find('.jstree-undetermined').removeClass('jstree-undetermined');

5201

<> for(i = 0, j = p.length; i < j; i++) {

5202

<> if(!m[p[i]].state[ t ? 'selected' : 'checked' ]) {

5203

<> s = this.get_node(p[i], true);

5204

<> if(s && s.length) {

5205

<> s.children('.jstree-anchor').children('.jstree-checkbox').addClass('jstree-undetermined');

<> }

<> }

<> }

<> };

<> this.redraw_node = function(obj, deep, is_callback, force_render) {

5211

<> obj = parent.redraw_node.apply(this, arguments);

5212

<> if(obj) {

5213

<> var i, j, tmp = null, icon = null;

5214

<> for(i = 0, j = obj.childNodes.length; i < j; i++) {

5215

<>					if(obj.childNodes[i] && obj.childNodes[i].className && obj.childNodes[i].className.indexOf("jstree-anchor") !== -1) {

5216

<> tmp = obj.childNodes[i];

<> break;

<> }

<> }

<> if(tmp) {

<>					if(!this.settings.checkbox.tie_selection && this._model.data[obj.id].state.checked) { tmp.className += ' jstree-checked'; }

5222

<> icon = _i.cloneNode(false);

5223

<> if(this._model.data[obj.id].state.checkbox_disabled) { icon.className += ' jstree-checkbox-disabled'; }

5224

<> tmp.insertBefore(icon, tmp.childNodes[0]);

5225

<> }

5226

<> }

5227

<> if(!is_callback && this.settings.checkbox.cascade.indexOf('undetermined') !== -1) {

5228

<> if(this._data.checkbox.uto) { clearTimeout(this._data.checkbox.uto); }

5229

<> this._data.checkbox.uto = setTimeout($.proxy(this._undetermined, this), 50);

<> }

<> return obj;

<> };

<> /**

<> * show the node checkbox icons

5235

<> * @name show_checkboxes()

5236

<> * @plugin checkbox

5237

<> */

5238

<>		this.show_checkboxes = function () { this._data.core.themes.checkboxes = true; this.get_container_ul().removeClass("jstree-no-checkboxes"); };

5239

<> /**

5240

<> * hide the node checkbox icons

5241

<> * @name hide_checkboxes()

5242

<> * @plugin checkbox

5243

<> */

5244

<>		this.hide_checkboxes = function () { this._data.core.themes.checkboxes = false; this.get_container_ul().addClass("jstree-no-checkboxes"); };

5245

<> /**

5246

<> * toggle the node icons

5247

<> * @name toggle_checkboxes()

5248

<> * @plugin checkbox

5249

<> */

5250

<>		this.toggle_checkboxes = function () { if(this._data.core.themes.checkboxes) { this.hide_checkboxes(); } else { this.show_checkboxes(); } };

5251

<> /**

5252

<> * checks if a node is in an undetermined state

5253

<> * @name is_undetermined(obj)

5254

<> * @param {mixed} obj

5255

<> * @return {Boolean}

5256

<> */

5257

<> this.is_undetermined = function (obj) {

5258

<> obj = this.get_node(obj);

5259

<>			var s = this.settings.checkbox.cascade, i, j, t = this.settings.checkbox.tie_selection, d = this._data[ t ? 'core' : 'checkbox' ].selected, m = this._model.data;

5260

<>			if(!obj || obj.state[ t ? 'selected' : 'checked' ] === true || s.indexOf('undetermined') === -1 || (s.indexOf('down') === -1 && s.indexOf('up') === -1)) {

5261

<> return false;

5262

<> }

5263

<> if(!obj.state.loaded && obj.original.state.undetermined === true) {

5264

<> return true;

5265

<> }

5266

<> for(i = 0, j = obj.children_d.length; i < j; i++) {

5267

<>				if($.inArray(obj.children_d[i], d) !== -1 || (!m[obj.children_d[i]].state.loaded && m[obj.children_d[i]].original.state.undetermined)) {

<> return true;

<> }

<> }

<> return false;

<> };

<> /**

<> * disable a node's checkbox

5275

<> * @name disable_checkbox(obj)

5276

<> * @param {mixed} obj an array can be used too

5277

<> * @trigger disable_checkbox.jstree

5278

<> * @plugin checkbox

5279

<> */

5280

<> this.disable_checkbox = function (obj) {

5281

<> var t1, t2, dom;

5282

<> if($.isArray(obj)) {

5283

<> obj = obj.slice();

5284

<> for(t1 = 0, t2 = obj.length; t1 < t2; t1++) {

5285

<> this.disable_checkbox(obj[t1]);

<> }

<> return true;

<> }

<> obj = this.get_node(obj);

5290

<> if(!obj || obj.id === $.jstree.root) {

5291

<> return false;

5292

<> }

5293

<> dom = this.get_node(obj, true);

5294

<> if(!obj.state.checkbox_disabled) {

5295

<> obj.state.checkbox_disabled = true;

5296

<> if(dom && dom.length) {

5297

<> dom.children('.jstree-anchor').children('.jstree-checkbox').addClass('jstree-checkbox-disabled');

5298

<> }

5299

<> /**

5300

<> * triggered when an node's checkbox is disabled

5301

<> * @event

5302

<> * @name disable_checkbox.jstree

5303

<> * @param {Object} node

5304

<> * @plugin checkbox

5305

<> */

5306

<> this.trigger('disable_checkbox', { 'node' : obj });

<> }

<> };

<> /**

<> * enable a node's checkbox

5311

<> * @name disable_checkbox(obj)

5312

<> * @param {mixed} obj an array can be used too

5313

<> * @trigger enable_checkbox.jstree

5314

<> * @plugin checkbox

5315

<> */

5316

<> this.enable_checkbox = function (obj) {

5317

<> var t1, t2, dom;

5318

<> if($.isArray(obj)) {

5319

<> obj = obj.slice();

5320

<> for(t1 = 0, t2 = obj.length; t1 < t2; t1++) {

5321

<> this.enable_checkbox(obj[t1]);

<> }

<> return true;

<> }

<> obj = this.get_node(obj);

5326

<> if(!obj || obj.id === $.jstree.root) {

5327

<> return false;

5328

<> }

5329

<> dom = this.get_node(obj, true);

5330

<> if(obj.state.checkbox_disabled) {

5331

<> obj.state.checkbox_disabled = false;

5332

<> if(dom && dom.length) {

5333

<> dom.children('.jstree-anchor').children('.jstree-checkbox').removeClass('jstree-checkbox-disabled');

5334

<> }

5335

<> /**

5336

<> * triggered when an node's checkbox is enabled

5337

<> * @event

5338

<> * @name enable_checkbox.jstree

5339

<> * @param {Object} node

5340

<> * @plugin checkbox

5341

<> */

5342

<> this.trigger('enable_checkbox', { 'node' : obj });

<> }

<> };

<> this.activate_node = function (obj, e) {

5347

<> if($(e.target).hasClass('jstree-checkbox-disabled')) {

5348

<> return false;

5349

<> }

5350

<>			if(this.settings.checkbox.tie_selection && (this.settings.checkbox.whole_node || $(e.target).hasClass('jstree-checkbox'))) {

5351

<> e.ctrlKey = true;

5352

<> }

5353

<>			if(this.settings.checkbox.tie_selection || (!this.settings.checkbox.whole_node && !$(e.target).hasClass('jstree-checkbox'))) {

5354

<> return parent.activate_node.call(this, obj, e);

5355

<> }

5356

<> if(this.is_disabled(obj)) {

5357

<> return false;

5358

<> }

5359

<> if(this.is_checked(obj)) {

5360

<> this.uncheck_node(obj, e);

5361

<> }

5362

<> else {

5363

<> this.check_node(obj, e);

5364

<> }

5365

<> this.trigger('activate_node', { 'node' : this.get_node(obj) });

<> };

<> /**

<>		 * check a node (only if tie_selection in checkbox settings is false, otherwise select_node will be called internally)

5370

<> * @name check_node(obj)

5371

<> * @param {mixed} obj an array can be used to check multiple nodes

5372

<> * @trigger check_node.jstree

5373

<> * @plugin checkbox

5374

<> */

5375

<> this.check_node = function (obj, e) {

5376

<> if(this.settings.checkbox.tie_selection) { return this.select_node(obj, false, true, e); }

5377

<> var dom, t1, t2, th;

5378

<> if($.isArray(obj)) {

5379

<> obj = obj.slice();

5380

<> for(t1 = 0, t2 = obj.length; t1 < t2; t1++) {

5381

<> this.check_node(obj[t1], e);

<> }

<> return true;

<> }

<> obj = this.get_node(obj);

5386

<> if(!obj || obj.id === $.jstree.root) {

5387

<> return false;

5388

<> }

5389

<> dom = this.get_node(obj, true);

5390

<> if(!obj.state.checked) {

5391

<> obj.state.checked = true;

5392

<> this._data.checkbox.selected.push(obj.id);

5393

<> if(dom && dom.length) {

5394

<> dom.children('.jstree-anchor').addClass('jstree-checked');

5395

<> }

5396

<> /**

5397

<> * triggered when an node is checked (only if tie_selection in checkbox settings is false)

5398

<> * @event

5399

<> * @name check_node.jstree

5400

<> * @param {Object} node

5401

<> * @param {Array} selected the current selection

5402

<> * @param {Object} event the event (if any) that triggered this check_node

5403

<> * @plugin checkbox

5404

<> */

5405

<> this.trigger('check_node', { 'node' : obj, 'selected' : this._data.checkbox.selected, 'event' : e });

<> }

<> };

<> /**

<>		 * uncheck a node (only if tie_selection in checkbox settings is false, otherwise deselect_node will be called internally)

5410

<> * @name uncheck_node(obj)

5411

<> * @param {mixed} obj an array can be used to uncheck multiple nodes

5412

<> * @trigger uncheck_node.jstree

5413

<> * @plugin checkbox

5414

<> */

5415

<> this.uncheck_node = function (obj, e) {

5416

<> if(this.settings.checkbox.tie_selection) { return this.deselect_node(obj, false, e); }

5417

<> var t1, t2, dom;

5418

<> if($.isArray(obj)) {

5419

<> obj = obj.slice();

5420

<> for(t1 = 0, t2 = obj.length; t1 < t2; t1++) {

5421

<> this.uncheck_node(obj[t1], e);

<> }

<> return true;

<> }

<> obj = this.get_node(obj);

5426

<> if(!obj || obj.id === $.jstree.root) {

5427

<> return false;

5428

<> }

5429

<> dom = this.get_node(obj, true);

5430

<> if(obj.state.checked) {

5431

<> obj.state.checked = false;

5432

<> this._data.checkbox.selected = $.vakata.array_remove_item(this._data.checkbox.selected, obj.id);

5433

<> if(dom.length) {

5434

<> dom.children('.jstree-anchor').removeClass('jstree-checked');

5435

<> }

5436

<> /**

5437

<> * triggered when an node is unchecked (only if tie_selection in checkbox settings is false)

5438

<> * @event

5439

<> * @name uncheck_node.jstree

5440

<> * @param {Object} node

5441

<> * @param {Array} selected the current selection

5442

<> * @param {Object} event the event (if any) that triggered this uncheck_node

5443

<> * @plugin checkbox

5444

<> */

5445

<> this.trigger('uncheck_node', { 'node' : obj, 'selected' : this._data.checkbox.selected, 'event' : e });

<> }

<> };

<> /**

<>		 * checks all nodes in the tree (only if tie_selection in checkbox settings is false, otherwise select_all will be called internally)

5450

<> * @name check_all()

5451

<> * @trigger check_all.jstree, changed.jstree

5452

<> * @plugin checkbox

5453

<> */

5454

<> this.check_all = function () {

5455

<> if(this.settings.checkbox.tie_selection) { return this.select_all(); }

5456

<> var tmp = this._data.checkbox.selected.concat([]), i, j;

5457

<> this._data.checkbox.selected = this._model.data[$.jstree.root].children_d.concat();

5458

<> for(i = 0, j = this._data.checkbox.selected.length; i < j; i++) {

5459

<> if(this._model.data[this._data.checkbox.selected[i]]) {

5460

<> this._model.data[this._data.checkbox.selected[i]].state.checked = true;

5461

<> }

5462

<> }

5463

<> this.redraw(true);

5464

<> /**

5465

<> * triggered when all nodes are checked (only if tie_selection in checkbox settings is false)

5466

<> * @event

5467

<> * @name check_all.jstree

5468

<> * @param {Array} selected the current selection

5469

<> * @plugin checkbox

5470

<> */

5471

<> this.trigger('check_all', { 'selected' : this._data.checkbox.selected });

5472

<> };

5473

<> /**

5474

<>		 * uncheck all checked nodes (only if tie_selection in checkbox settings is false, otherwise deselect_all will be called internally)

5475

<> * @name uncheck_all()

5476

<> * @trigger uncheck_all.jstree

5477

<> * @plugin checkbox

5478

<> */

5479

<> this.uncheck_all = function () {

5480

<> if(this.settings.checkbox.tie_selection) { return this.deselect_all(); }

5481

<> var tmp = this._data.checkbox.selected.concat([]), i, j;

5482

<> for(i = 0, j = this._data.checkbox.selected.length; i < j; i++) {

5483

<> if(this._model.data[this._data.checkbox.selected[i]]) {

5484

<> this._model.data[this._data.checkbox.selected[i]].state.checked = false;

5485

<> }

5486

<> }

5487

<> this._data.checkbox.selected = [];

5488

<> this.element.find('.jstree-checked').removeClass('jstree-checked');

5489

<> /**

5490

<> * triggered when all nodes are unchecked (only if tie_selection in checkbox settings is false)

5491

<> * @event

5492

<> * @name uncheck_all.jstree

5493

<> * @param {Object} node the previous selection

5494

<> * @param {Array} selected the current selection

5495

<> * @plugin checkbox

5496

<> */

5497

<> this.trigger('uncheck_all', { 'selected' : this._data.checkbox.selected, 'node' : tmp });

5498

<> };

5499

<> /**

5500

<>		 * checks if a node is checked (if tie_selection is on in the settings this function will return the same as is_selected)

5501

<> * @name is_checked(obj)

5502

<> * @param {mixed} obj

5503

<> * @return {Boolean}

5504

<> * @plugin checkbox

5505

<> */

5506

<> this.is_checked = function (obj) {

5507

<> if(this.settings.checkbox.tie_selection) { return this.is_selected(obj); }

5508

<> obj = this.get_node(obj);

5509

<> if(!obj || obj.id === $.jstree.root) { return false; }

5510

<> return obj.state.checked;

5511

<> };

5512

<> /**

5513

<>		 * get an array of all checked nodes (if tie_selection is on in the settings this function will return the same as get_selected)

5514

<> * @name get_checked([full])

5515

<>		 * @param  {mixed}  full if set to `true` the returned array will consist of the full node objects, otherwise - only IDs will be returned

5516

<> * @return {Array}

5517

<> * @plugin checkbox

5518

<> */

5519

<> this.get_checked = function (full) {

5520

<> if(this.settings.checkbox.tie_selection) { return this.get_selected(full); }

5521

<>			return full ? $.map(this._data.checkbox.selected, $.proxy(function (i) { return this.get_node(i); }, this)) : this._data.checkbox.selected;

5522

<> };

5523

<> /**

5524

<>		 * get an array of all top level checked nodes (ignoring children of checked nodes) (if tie_selection is on in the settings this function will return the same as get_top_selected)

5525

<> * @name get_top_checked([full])

5526

<>		 * @param  {mixed}  full if set to `true` the returned array will consist of the full node objects, otherwise - only IDs will be returned

5527

<> * @return {Array}

5528

<> * @plugin checkbox

5529

<> */

5530

<> this.get_top_checked = function (full) {

5531

<> if(this.settings.checkbox.tie_selection) { return this.get_top_selected(full); }

5532

<> var tmp = this.get_checked(true),

5533

<> obj = {}, i, j, k, l;

5534

<> for(i = 0, j = tmp.length; i < j; i++) {

5535

<> obj[tmp[i].id] = tmp[i];

5536

<> }

5537

<> for(i = 0, j = tmp.length; i < j; i++) {

5538

<> for(k = 0, l = tmp[i].children_d.length; k < l; k++) {

5539

<> if(obj[tmp[i].children_d[k]]) {

5540

<> delete obj[tmp[i].children_d[k]];

<> }

<> }

<> }

<> tmp = [];

<> for(i in obj) {

<> if(obj.hasOwnProperty(i)) {

<> tmp.push(i);

<> }

<> }

<> return full ? $.map(tmp, $.proxy(function (i) { return this.get_node(i); }, this)) : tmp;

5551

<> };

5552

<> /**

5553

<>		 * get an array of all bottom level checked nodes (ignoring selected parents) (if tie_selection is on in the settings this function will return the same as get_bottom_selected)

5554

<> * @name get_bottom_checked([full])

5555

<>		 * @param  {mixed}  full if set to `true` the returned array will consist of the full node objects, otherwise - only IDs will be returned

5556

<> * @return {Array}

5557

<> * @plugin checkbox

5558

<> */

5559

<> this.get_bottom_checked = function (full) {

5560

<> if(this.settings.checkbox.tie_selection) { return this.get_bottom_selected(full); }

5561

<> var tmp = this.get_checked(true),

5562

<> obj = [], i, j;

5563

<> for(i = 0, j = tmp.length; i < j; i++) {

5564

<> if(!tmp[i].children.length) {

5565

<> obj.push(tmp[i].id);

5566

<> }

5567

<> }

5568

<> return full ? $.map(obj, $.proxy(function (i) { return this.get_node(i); }, this)) : obj;

5569

<> };

5570

<> this.load_node = function (obj, callback) {

5571

<> var k, l, i, j, c, tmp;

5572

<> if(!$.isArray(obj) && !this.settings.checkbox.tie_selection) {

5573

<> tmp = this.get_node(obj);

5574

<> if(tmp && tmp.state.loaded) {

5575

<> for(k = 0, l = tmp.children_d.length; k < l; k++) {

5576

<> if(this._model.data[tmp.children_d[k]].state.checked) {

5577

<> c = true;

5578

<> this._data.checkbox.selected = $.vakata.array_remove_item(this._data.checkbox.selected, tmp.children_d[k]);

<> }

<> }

<> }

<> }

<> return parent.load_node.apply(this, arguments);

5584

<> };

5585

<> this.get_state = function () {

5586

<> var state = parent.get_state.apply(this, arguments);

5587

<> if(this.settings.checkbox.tie_selection) { return state; }

5588

<> state.checkbox = this._data.checkbox.selected.slice();

5589

<> return state;

5590

<> };

5591

<> this.set_state = function (state, callback) {

5592

<> var res = parent.set_state.apply(this, arguments);

5593

<> if(res && state.checkbox) {

5594

<> if(!this.settings.checkbox.tie_selection) {

5595

<> this.uncheck_all();

5596

<> var _this = this;

5597

<> $.each(state.checkbox, function (i, v) {

5598

<> _this.check_node(v);

5599

<> });

5600

<> }

5601

<> delete state.checkbox;

5602

<> this.set_state(state, callback);

<> return false;

<> }

<> return res;

<> };

<> this.refresh = function (skip_loading, forget_state) {

5608

<> if(!this.settings.checkbox.tie_selection) {

5609

<> this._data.checkbox.selected = [];

5610

<> }

5611

<> return parent.refresh.apply(this, arguments);

<> };

<> };

<> // include the checkbox plugin by default

5616

<> // $.jstree.defaults.plugins.push("checkbox");

5617

5618

<>/**

5619

<> * ### Conditionalselect plugin

5620

<> *

5621

<> * This plugin allows defining a callback to allow or deny node selection by user input (activate node method).

<> */

<> /**

<>	 * a callback (function) which is invoked in the instance's scope and receives two arguments - the node and the event that triggered the `activate_node` call. Returning false prevents working with the node, returning true allows invoking activate_node. Defaults to returning `true`.

5626

<> * @name $.jstree.defaults.checkbox.visible

5627

<> * @plugin checkbox

5628

<> */

5629

<> $.jstree.defaults.conditionalselect = function () { return true; };

5630

<> $.jstree.plugins.conditionalselect = function (options, parent) {

5631

<> // own function

5632

<> this.activate_node = function (obj, e) {

5633

<> if(this.settings.conditionalselect.call(this, this.get_node(obj), e)) {

5634

<> parent.activate_node.call(this, obj, e);

<> }

<> };

<> };

<>/**

<> * ### Contextmenu plugin

5642

<> *

5643

<> * Shows a context menu when a node is right-clicked.

<> */

<> /**

<> * stores all defaults for the contextmenu plugin

5648

<> * @name $.jstree.defaults.contextmenu

5649

<> * @plugin contextmenu

5650

<> */

5651

<> $.jstree.defaults.contextmenu = {

5652

<> /**

5653

<> * a boolean indicating if the node should be selected when the context menu is invoked on it. Defaults to `true`.

5654

<> * @name $.jstree.defaults.contextmenu.select_node

5655

<> * @plugin contextmenu

5656

<> */

5657

<> select_node : true,

5658

<> /**

5659

<>		 * a boolean indicating if the menu should be shown aligned with the node. Defaults to `true`, otherwise the mouse coordinates are used.

5660

<> * @name $.jstree.defaults.contextmenu.show_at_node

5661

<> * @plugin contextmenu

5662

<> */

5663

<> show_at_node : true,

5664

<> /**

5665

<>		 * an object of actions, or a function that accepts a node and a callback function and calls the callback function with an object of actions available for that node (you can also return the items too).

5666

<> *

5667

<>		 * Each action consists of a key (a unique name) and a value which is an object with the following properties (only label and action are required). Once a menu item is activated the `action` function will be invoked with an object containing the following keys: item - the contextmenu item definition as seen below, reference - the DOM node that was used (the tree node), element - the contextmenu DOM element, position - an object with x/y properties indicating the position of the menu.

5668

<> *

5669

<> * * `separator_before` - a boolean indicating if there should be a separator before this item

5670

<> * * `separator_after` - a boolean indicating if there should be a separator after this item

5671

<> * * `_disabled` - a boolean indicating if this action should be disabled

5672

<> * * `label` - a string - the name of the action (could be a function returning a string)

5673

<> * * `title` - a string - an optional tooltip for the item

5674

<> * * `action` - a function to be executed if this item is chosen, the function will receive

5675

<>		 * * `icon` - a string, can be a path to an icon or a className, if using an image that is in the current directory use a `./` prefix, otherwise it will be detected as a class

5676

<>		 * * `shortcut` - keyCode which will trigger the action if the menu is open (for example `113` for rename, which equals F2)

5677

<> * * `shortcut_label` - shortcut label (like for example `F2` for rename)

5678

<>		 * * `submenu` - an object with the same structure as $.jstree.defaults.contextmenu.items which can be used to create a submenu - each key will be rendered as a separate option in a submenu that will appear once the current item is hovered

5679

<> *

5680

<> * @name $.jstree.defaults.contextmenu.items

5681

<> * @plugin contextmenu

5682

<> */

5683

<> items : function (o, cb) { // Could be an object directly

5684

<> return {

5685

<> "create" : {

5686

<> "separator_before" : false,

5687

<> "separator_after" : true,

5688

<> "_disabled" : false, //(this.check("create_node", data.reference, {}, "last")),

5689

<> "label" : "Create",

5690

<> "action" : function (data) {

5691

<> var inst = $.jstree.reference(data.reference),

5692

<> obj = inst.get_node(data.reference);

5693

<> inst.create_node(obj, {}, "last", function (new_node) {

5694

<> setTimeout(function () { inst.edit(new_node); },0);

<> });

<> }

<> },

<> "rename" : {

<> "separator_before" : false,

5700

<> "separator_after" : false,

5701

<> "_disabled" : false, //(this.check("rename_node", data.reference, this.get_parent(data.reference), "")),

5702

<> "label" : "Rename",

5703

<> /*!

5704

<> "shortcut" : 113,

5705

<> "shortcut_label" : 'F2',

5706

<> "icon" : "glyphicon glyphicon-leaf",

5707

<> */

5708

<> "action" : function (data) {

5709

<> var inst = $.jstree.reference(data.reference),

5710

<> obj = inst.get_node(data.reference);

<> inst.edit(obj);

<> }

<> },

<> "remove" : {

<> "separator_before" : false,

5716

<> "icon" : false,

5717

<> "separator_after" : false,

5718

<> "_disabled" : false, //(this.check("delete_node", data.reference, this.get_parent(data.reference), "")),

5719

<> "label" : "Delete",

5720

<> "action" : function (data) {

5721

<> var inst = $.jstree.reference(data.reference),

5722

<> obj = inst.get_node(data.reference);

5723

<> if(inst.is_selected(obj)) {

5724

<> inst.delete_node(inst.get_selected());

5725

<> }

5726

<> else {

5727

<> inst.delete_node(obj);

<> }

<> }

<> },

<> "ccp" : {

<> "separator_before" : true,

5733

<> "icon" : false,

5734

<> "separator_after" : false,

5735

<> "label" : "Edit",

5736

<> "action" : false,

5737

<> "submenu" : {

5738

<> "cut" : {

5739

<> "separator_before" : false,

5740

<> "separator_after" : false,

5741

<> "label" : "Cut",

5742

<> "action" : function (data) {

5743

<> var inst = $.jstree.reference(data.reference),

5744

<> obj = inst.get_node(data.reference);

5745

<> if(inst.is_selected(obj)) {

5746

<> inst.cut(inst.get_top_selected());

<> }

<> else {

<> inst.cut(obj);

<> }

<> }

<> },

<> "copy" : {

<> "separator_before" : false,

5755

<> "icon" : false,

5756

<> "separator_after" : false,

5757

<> "label" : "Copy",

5758

<> "action" : function (data) {

5759

<> var inst = $.jstree.reference(data.reference),

5760

<> obj = inst.get_node(data.reference);

5761

<> if(inst.is_selected(obj)) {

5762

<> inst.copy(inst.get_top_selected());

<> }

<> else {

<> inst.copy(obj);

<> }

<> }

<> },

<> "paste" : {

<> "separator_before" : false,

5771

<> "icon" : false,

5772

<> "_disabled" : function (data) {

5773

<> return !$.jstree.reference(data.reference).can_paste();

5774

<> },

5775

<> "separator_after" : false,

5776

<> "label" : "Paste",

5777

<> "action" : function (data) {

5778

<> var inst = $.jstree.reference(data.reference),

5779

<> obj = inst.get_node(data.reference);

5780

<> inst.paste(obj);

<> }

<> }

<> }

<> }

<> };

<> }

<> };

<> $.jstree.plugins.contextmenu = function (options, parent) {

5790

<> this.bind = function () {

5791

<> parent.bind.call(this);

5792

5793

<> var last_ts = 0, cto = null, ex, ey;

5794

<> this.element

5795

<> .on("contextmenu.jstree", ".jstree-anchor", $.proxy(function (e, data) {

5796

<> if (e.target.tagName.toLowerCase() === 'input') {

5797

<> return;

5798

<> }

5799

<> e.preventDefault();

5800

<> last_ts = e.ctrlKey ? +new Date() : 0;

5801

<> if(data || cto) {

5802

<> last_ts = (+new Date()) + 10000;

5803

<> }

5804

<> if(cto) {

5805

<> clearTimeout(cto);

5806

<> }

5807

<> if(!this.is_loading(e.currentTarget)) {

5808

<> this.show_contextmenu(e.currentTarget, e.pageX, e.pageY, e);

5809

<> }

5810

<> }, this))

5811

<> .on("click.jstree", ".jstree-anchor", $.proxy(function (e) {

5812

<>						if(this._data.contextmenu.visible && (!last_ts || (+new Date()) - last_ts > 250)) { // work around safari & macOS ctrl+click

5813

<> $.vakata.context.hide();

<> }

<> last_ts = 0;

<> }, this))

<> .on("touchstart.jstree", ".jstree-anchor", function (e) {

5818

<> if(!e.originalEvent || !e.originalEvent.changedTouches || !e.originalEvent.changedTouches[0]) {

5819

<> return;

5820

<> }

5821

<> ex = e.originalEvent.changedTouches[0].clientX;

5822

<> ey = e.originalEvent.changedTouches[0].clientY;

5823

<> cto = setTimeout(function () {

5824

<> $(e.currentTarget).trigger('contextmenu', true);

5825

<> }, 750);

5826

<> })

5827

<> .on('touchmove.vakata.jstree', function (e) {

5828

<>						if(cto && e.originalEvent && e.originalEvent.changedTouches && e.originalEvent.changedTouches[0] && (Math.abs(ex - e.originalEvent.changedTouches[0].clientX) > 50 || Math.abs(ey - e.originalEvent.changedTouches[0].clientY) > 50)) {

5829

<> clearTimeout(cto);

5830

<> }

5831

<> })

5832

<> .on('touchend.vakata.jstree', function (e) {

5833

<> if(cto) {

5834

<> clearTimeout(cto);

<> }

<> });

<> /*!

<> if(!('oncontextmenu' in document.body) && ('ontouchstart' in document.body)) {

5840

<> var el = null, tm = null;

5841

<> this.element

5842

<> .on("touchstart", ".jstree-anchor", function (e) {

5843

<> el = e.currentTarget;

5844

<> tm = +new Date();

5845

<> $(document).one("touchend", function (e) {

5846

<>							e.target = document.elementFromPoint(e.originalEvent.targetTouches[0].pageX - window.pageXOffset, e.originalEvent.targetTouches[0].pageY - window.pageYOffset);

5847

<> e.currentTarget = e.target;

5848

<> tm = ((+(new Date())) - tm);

5849

<> if(e.target === el && tm > 600 && tm < 1000) {

5850

<> e.preventDefault();

5851

<> $(el).trigger('contextmenu', e);

<> }

<> el = null;

<> tm = null;

<> });

<> });

<> }

<> */

<> $(document).on("context_hide.vakata.jstree", $.proxy(function (e, data) {

5860

<> this._data.contextmenu.visible = false;

5861

<> $(data.reference).removeClass('jstree-context');

5862

<> }, this));

5863

<> };

5864

<> this.teardown = function () {

5865

<> if(this._data.contextmenu.visible) {

5866

<> $.vakata.context.hide();

5867

<> }

5868

<> parent.teardown.call(this);

<> };

<> /**

<> * prepare and show the context menu for a node

5873

<> * @name show_contextmenu(obj [, x, y])

5874

<> * @param {mixed} obj the node

5875

<> * @param {Number} x the x-coordinate relative to the document to show the menu at

5876

<> * @param {Number} y the y-coordinate relative to the document to show the menu at

5877

<> * @param {Object} e the event if available that triggered the contextmenu

5878

<> * @plugin contextmenu

5879

<> * @trigger show_contextmenu.jstree

5880

<> */

5881

<> this.show_contextmenu = function (obj, x, y, e) {

5882

<> obj = this.get_node(obj);

5883

<> if(!obj || obj.id === $.jstree.root) { return false; }

5884

<> var s = this.settings.contextmenu,

5885

<> d = this.get_node(obj, true),

5886

<> a = d.children(".jstree-anchor"),

5887

<> o = false,

5888

<> i = false;

5889

<> if(s.show_at_node || x === undefined || y === undefined) {

5890

<> o = a.offset();

5891

<> x = o.left;

5892

<> y = o.top + this._data.core.li_height;

5893

<> }

5894

<> if(this.settings.contextmenu.select_node && !this.is_selected(obj)) {

5895

<> this.activate_node(obj, e);

<> }

<> i = s.items;

<> if($.isFunction(i)) {

5900

<> i = i.call(this, obj, $.proxy(function (i) {

5901

<> this._show_contextmenu(obj, x, y, i);

5902

<> }, this));

5903

<> }

5904

<> if($.isPlainObject(i)) {

5905

<> this._show_contextmenu(obj, x, y, i);

<> }

<> };

<> /**

<> * show the prepared context menu for a node

5910

<> * @name _show_contextmenu(obj, x, y, i)

5911

<> * @param {mixed} obj the node

5912

<> * @param {Number} x the x-coordinate relative to the document to show the menu at

5913

<> * @param {Number} y the y-coordinate relative to the document to show the menu at

5914

<> * @param {Number} i the object of items to show

5915

<> * @plugin contextmenu

5916

<> * @trigger show_contextmenu.jstree

5917

<> * @private

5918

<> */

5919

<> this._show_contextmenu = function (obj, x, y, i) {

5920

<> var d = this.get_node(obj, true),

5921

<> a = d.children(".jstree-anchor");

5922

<> $(document).one("context_show.vakata.jstree", $.proxy(function (e, data) {

5923

<> var cls = 'jstree-contextmenu jstree-' + this.get_theme() + '-contextmenu';

5924

<> $(data.element).addClass(cls);

5925

<> a.addClass('jstree-context');

5926

<> }, this));

5927

<> this._data.contextmenu.visible = true;

5928

<> $.vakata.context.show(a, { 'x' : x, 'y' : y }, i);

5929

<> /**

5930

<> * triggered when the contextmenu is shown for a node

5931

<> * @event

5932

<> * @name show_contextmenu.jstree

5933

<> * @param {Object} node the node

5934

<> * @param {Number} x the x-coordinate of the menu relative to the document

5935

<> * @param {Number} y the y-coordinate of the menu relative to the document

5936

<> * @plugin contextmenu

5937

<> */

5938

<> this.trigger('show_contextmenu', { "node" : obj, "x" : x, "y" : y });

<> };

<> };

<> // contextmenu helper

5943

<> (function ($) {

5944

<> var right_to_left = false,

5945

<> vakata_context = {

5946

<> element : false,

5947

<> reference : false,

<> position_x : 0,

<> position_y : 0,

<> items : [],

<> html : "",

<> is_visible : false

5953

<> };

5954

5955

<> $.vakata.context = {

5956

<> settings : {

5957

<> hide_onmouseleave : 0,

5958

<> icons : true

5959

<> },

5960

<> _trigger : function (event_name) {

5961

<> $(document).triggerHandler("context_" + event_name + ".vakata", {

5962

<> "reference" : vakata_context.reference,

5963

<> "element" : vakata_context.element,

5964

<> "position" : {

5965

<> "x" : vakata_context.position_x,

5966

<> "y" : vakata_context.position_y

<> }

<> });

<> },

<> _execute : function (i) {

5971

<> i = vakata_context.items[i];

5972

<>				return i && (!i._disabled || ($.isFunction(i._disabled) && !i._disabled({ "item" : i, "reference" : vakata_context.reference, "element" : vakata_context.element }))) && i.action ? i.action.call(null, {

5973

<> "item" : i,

5974

<> "reference" : vakata_context.reference,

5975

<> "element" : vakata_context.element,

5976

<> "position" : {

5977

<> "x" : vakata_context.position_x,

5978

<> "y" : vakata_context.position_y

<> }

<> }) : false;

<> },

<> _parse : function (o, is_callback) {

5983

<> if(!o) { return false; }

5984

<> if(!is_callback) {

5985

<> vakata_context.html = "";

5986

<> vakata_context.items = [];

<> }

<> var str = "",

<> sep = false,

<> tmp;

<> if(is_callback) { str += "<"+"ul>"; }

5993

<> $.each(o, function (i, val) {

5994

<> if(!val) { return true; }

5995

<> vakata_context.items.push(val);

5996

<> if(!sep && val.separator_before) {

5997

<>						str += "<"+"li class='vakata-context-separator'><"+"a href='#' " + ($.vakata.context.settings.icons ? '' : 'style="margin-left:0px;"') + ">&#160;<"+"/a><"+"/li>";

5998

<> }

5999

<> sep = false;

6000

<>					str += "<"+"li class='" + (val._class || "") + (val._disabled === true || ($.isFunction(val._disabled) && val._disabled({ "item" : val, "reference" : vakata_context.reference, "element" : vakata_context.element })) ? " vakata-contextmenu-disabled " : "") + "' "+(val.shortcut?" data-shortcut='"+val.shortcut+"' ":'')+">";

6001

<>					str += "<"+"a href='#' rel='" + (vakata_context.items.length - 1) + "' " + (val.title ? "title='" + val.title + "'" : "") + ">";

6002

<> if($.vakata.context.settings.icons) {

6003

<> str += "<"+"i ";

6004

<> if(val.icon) {

6005

<>							if(val.icon.indexOf("/") !== -1 || val.icon.indexOf(".") !== -1) { str += " style='background:url(\"" + val.icon + "\") center center no-repeat' "; }

6006

<> else { str += " class='" + val.icon + "' "; }

6007

<> }

6008

<> str += "><"+"/i><"+"span class='vakata-contextmenu-sep'> <"+"/span>";

6009

<> }

6010

<>					str += ($.isFunction(val.label) ? val.label({ "item" : i, "reference" : vakata_context.reference, "element" : vakata_context.element }) : val.label) + (val.shortcut?' <span class="vakata-contextmenu-shortcut vakata-contextmenu-shortcut-'+val.shortcut+'">'+ (val.shortcut_label || '') +'</span>':'') + "<"+"/a>";

6011

<> if(val.submenu) {

6012

<> tmp = $.vakata.context._parse(val.submenu, true);

6013

<> if(tmp) { str += tmp; }

6014

<> }

6015

<> str += "<"+"/li>";

6016

<> if(val.separator_after) {

6017

<>						str += "<"+"li class='vakata-context-separator'><"+"a href='#' " + ($.vakata.context.settings.icons ? '' : 'style="margin-left:0px;"') + ">&#160;<"+"/a><"+"/li>";

<> sep = true;

<> }

<> });

<> str = str.replace(/<\/li\>$/,"");

6022

<><\/li\> if(is_callback) { str += "</ul>"; }

6023

<><\/li\> /**

6024

<><\/li\> * triggered on the document when the contextmenu is parsed (HTML is built)

6025

<><\/li\> * @event

6026

<><\/li\> * @plugin contextmenu

6027

<><\/li\> * @name context_parse.vakata

6028

<><\/li\> * @param {jQuery} reference the element that was right clicked

6029

<><\/li\> * @param {jQuery} element the DOM element of the menu itself

6030

<><\/li\> * @param {Object} position the x & y coordinates of the menu

6031

<><\/li\> */

6032

<><\/li\> if(!is_callback) { vakata_context.html = str; $.vakata.context._trigger("parse"); }

6033

<><\/li\> return str.length > 10 ? str : false;

6034

<><\/li\> },

6035

<><\/li\> _show_submenu : function (o) {

6036

<><\/li\> o = $(o);

6037

<><\/li\> if(!o.length || !o.children("ul").length) { return; }

6038

<><\/li\> var e = o.children("ul"),

6039

<><\/li\> xl = o.offset().left,

6040

<><\/li\> x = xl + o.outerWidth(),

6041

<><\/li\> y = o.offset().top,

6042

<><\/li\> w = e.width(),

6043

<><\/li\> h = e.height(),

6044

<><\/li\> dw = $(window).width() + $(window).scrollLeft(),

6045

<><\/li\> dh = $(window).height() + $(window).scrollTop();

6046

<><\/li\>				// може да се спести е една проверка - дали няма някой от класовете вече нагоре

6047

<><\/li\> if(right_to_left) {

6048

<><\/li\> o[x - (w + 10 + o.outerWidth()) < 0 ? "addClass" : "removeClass"]("vakata-context-left");

6049

<><\/li\> }

6050

<><\/li\> else {

6051

<><\/li\> o[x + w > dw && xl > dw - x ? "addClass" : "removeClass"]("vakata-context-right");

6052

<><\/li\> }

6053

<><\/li\> if(y + h + 10 > dh) {

6054

<><\/li\> e.css("bottom","-1px");

6055

<><\/li\> }

6056

6057

<><\/li\> //if does not fit - stick it to the side

6058

<><\/li\> if (o.hasClass('vakata-context-right')) {

6059

<><\/li\> if (xl < w) {

6060

<><\/li\> e.css("margin-right", xl - w);

6061

<><\/li\> }

6062

<><\/li\> } else {

6063

<><\/li\> if (dw - x < w) {

6064

<><\/li\> e.css("margin-left", dw - x - w);

<><\/li\> }

<><\/li\> }

<><\/li\> e.show();

6069

<><\/li\> },

6070

<><\/li\> show : function (reference, position, data) {

6071

<><\/li\> var o, e, x, y, w, h, dw, dh, cond = true;

6072

<><\/li\> if(vakata_context.element && vakata_context.element.length) {

6073

<><\/li\> vakata_context.element.width('');

6074

<><\/li\> }

6075

<><\/li\> switch(cond) {

6076

<><\/li\> case (!position && !reference):

6077

<><\/li\> return false;

6078

<><\/li\> case (!!position && !!reference):

6079

<><\/li\> vakata_context.reference = reference;

6080

<><\/li\> vakata_context.position_x = position.x;

6081

<><\/li\> vakata_context.position_y = position.y;

6082

<><\/li\> break;

6083

<><\/li\> case (!position && !!reference):

6084

<><\/li\> vakata_context.reference = reference;

6085

<><\/li\> o = reference.offset();

6086

<><\/li\> vakata_context.position_x = o.left + reference.outerHeight();

6087

<><\/li\> vakata_context.position_y = o.top;

6088

<><\/li\> break;

6089

<><\/li\> case (!!position && !reference):

6090

<><\/li\> vakata_context.position_x = position.x;

6091

<><\/li\> vakata_context.position_y = position.y;

6092

<><\/li\> break;

6093

<><\/li\> }

6094

<><\/li\> if(!!reference && !data && $(reference).data('vakata_contextmenu')) {

6095

<><\/li\> data = $(reference).data('vakata_contextmenu');

6096

<><\/li\> }

6097

<><\/li\> if($.vakata.context._parse(data)) {

6098

<><\/li\> vakata_context.element.html(vakata_context.html);

6099

<><\/li\> }

6100

<><\/li\> if(vakata_context.items.length) {

6101

<><\/li\> vakata_context.element.appendTo("body");

6102

<><\/li\> e = vakata_context.element;

6103

<><\/li\> x = vakata_context.position_x;

6104

<><\/li\> y = vakata_context.position_y;

6105

<><\/li\> w = e.width();

6106

<><\/li\> h = e.height();

6107

<><\/li\> dw = $(window).width() + $(window).scrollLeft();

6108

<><\/li\> dh = $(window).height() + $(window).scrollTop();

6109

<><\/li\> if(right_to_left) {

6110

<><\/li\> x -= (e.outerWidth() - $(reference).outerWidth());

6111

<><\/li\> if(x < $(window).scrollLeft() + 20) {

6112

<><\/li\> x = $(window).scrollLeft() + 20;

6113

<><\/li\> }

6114

<><\/li\> }

6115

<><\/li\> if(x + w + 20 > dw) {

6116

<><\/li\> x = dw - (w + 20);

6117

<><\/li\> }

6118

<><\/li\> if(y + h + 20 > dh) {

6119

<><\/li\> y = dh - (h + 20);

6120

<><\/li\> }

6121

6122

<><\/li\> vakata_context.element

6123

<><\/li\> .css({ "left" : x, "top" : y })

6124

<><\/li\> .show()

6125

<><\/li\> .find('a').first().focus().parent().addClass("vakata-context-hover");

6126

<><\/li\> vakata_context.is_visible = true;

6127

<><\/li\> /**

6128

<><\/li\> * triggered on the document when the contextmenu is shown

6129

<><\/li\> * @event

6130

<><\/li\> * @plugin contextmenu

6131

<><\/li\> * @name context_show.vakata

6132

<><\/li\> * @param {jQuery} reference the element that was right clicked

6133

<><\/li\> * @param {jQuery} element the DOM element of the menu itself

6134

<><\/li\> * @param {Object} position the x & y coordinates of the menu

6135

<><\/li\> */

6136

<><\/li\> $.vakata.context._trigger("show");

6137

<><\/li\> }

6138

<><\/li\> },

6139

<><\/li\> hide : function () {

6140

<><\/li\> if(vakata_context.is_visible) {

6141

<><\/li\> vakata_context.element.hide().find("ul").hide().end().find(':focus').blur().end().detach();

6142

<><\/li\> vakata_context.is_visible = false;

6143

<><\/li\> /**

6144

<><\/li\> * triggered on the document when the contextmenu is hidden

6145

<><\/li\> * @event

6146

<><\/li\> * @plugin contextmenu

6147

<><\/li\> * @name context_hide.vakata

6148

<><\/li\> * @param {jQuery} reference the element that was right clicked

6149

<><\/li\> * @param {jQuery} element the DOM element of the menu itself

6150

<><\/li\> * @param {Object} position the x & y coordinates of the menu

6151

<><\/li\> */

6152

<><\/li\> $.vakata.context._trigger("hide");

<><\/li\> }

<><\/li\> }

<><\/li\> };

<><\/li\> $(function () {

6157

<><\/li\> right_to_left = $("body").css("direction") === "rtl";

6158

<><\/li\> var to = false;

6159

6160

<><\/li\> vakata_context.element = $("<ul class='vakata-context'></ul>");

6161

<><\/li\> vakata_context.element

6162

<><\/li\> .on("mouseenter", "li", function (e) {

6163

<><\/li\> e.stopImmediatePropagation();

6164

6165

<><\/li\> if($.contains(this, e.relatedTarget)) {

6166

<><\/li\> // премахнато заради delegate mouseleave по-долу

6167

<><\/li\> // $(this).find(".vakata-context-hover").removeClass("vakata-context-hover");

<><\/li\> return;

<><\/li\> }

<><\/li\> if(to) { clearTimeout(to); }

6172

<><\/li\> vakata_context.element.find(".vakata-context-hover").removeClass("vakata-context-hover").end();

6173

6174

<><\/li\> $(this)

6175

<><\/li\> .siblings().find("ul").hide().end().end()

6176

<><\/li\> .parentsUntil(".vakata-context", "li").addBack().addClass("vakata-context-hover");

6177

<><\/li\> $.vakata.context._show_submenu(this);

6178

<><\/li\> })

6179

<><\/li\> // тестово - дали не натоварва?

6180

<><\/li\> .on("mouseleave", "li", function (e) {

6181

<><\/li\> if($.contains(this, e.relatedTarget)) { return; }

6182

<><\/li\> $(this).find(".vakata-context-hover").addBack().removeClass("vakata-context-hover");

6183

<><\/li\> })

6184

<><\/li\> .on("mouseleave", function (e) {

6185

<><\/li\> $(this).find(".vakata-context-hover").removeClass("vakata-context-hover");

6186

<><\/li\> if($.vakata.context.settings.hide_onmouseleave) {

6187

<><\/li\> to = setTimeout(

6188

<><\/li\> (function (t) {

6189

<><\/li\> return function () { $.vakata.context.hide(); };

6190

<><\/li\> }(this)), $.vakata.context.settings.hide_onmouseleave);

6191

<><\/li\> }

6192

<><\/li\> })

6193

<><\/li\> .on("click", "a", function (e) {

6194

<><\/li\> e.preventDefault();

6195

<><\/li\> //})

6196

<><\/li\> //.on("mouseup", "a", function (e) {

6197

<><\/li\>					if(!$(this).blur().parent().hasClass("vakata-context-disabled") && $.vakata.context._execute($(this).attr("rel")) !== false) {

6198

<><\/li\> $.vakata.context.hide();

6199

<><\/li\> }

6200

<><\/li\> })

6201

<><\/li\> .on('keydown', 'a', function (e) {

6202

<><\/li\> var o = null;

6203

<><\/li\> switch(e.which) {

6204

<><\/li\> case 13:

6205

<><\/li\> case 32:

6206

<><\/li\> e.type = "mouseup";

6207

<><\/li\> e.preventDefault();

6208

<><\/li\> $(e.currentTarget).trigger(e);

6209

<><\/li\> break;

6210

<><\/li\> case 37:

6211

<><\/li\> if(vakata_context.is_visible) {

6212

<><\/li\>									vakata_context.element.find(".vakata-context-hover").last().closest("li").first().find("ul").hide().find(".vakata-context-hover").removeClass("vakata-context-hover").end().end().children('a').focus();

6213

<><\/li\> e.stopImmediatePropagation();

6214

<><\/li\> e.preventDefault();

<><\/li\> }

<><\/li\> break;

<><\/li\> case 38:

<><\/li\> if(vakata_context.is_visible) {

6219

<><\/li\>									o = vakata_context.element.find("ul:visible").addBack().last().children(".vakata-context-hover").removeClass("vakata-context-hover").prevAll("li:not(.vakata-context-separator)").first();

6220

<><\/li\>									if(!o.length) { o = vakata_context.element.find("ul:visible").addBack().last().children("li:not(.vakata-context-separator)").last(); }

6221

<><\/li\> o.addClass("vakata-context-hover").children('a').focus();

6222

<><\/li\> e.stopImmediatePropagation();

6223

<><\/li\> e.preventDefault();

<><\/li\> }

<><\/li\> break;

<><\/li\> case 39:

<><\/li\> if(vakata_context.is_visible) {

6228

<><\/li\>									vakata_context.element.find(".vakata-context-hover").last().children("ul").show().children("li:not(.vakata-context-separator)").removeClass("vakata-context-hover").first().addClass("vakata-context-hover").children('a').focus();

6229

<><\/li\> e.stopImmediatePropagation();

6230

<><\/li\> e.preventDefault();

<><\/li\> }

<><\/li\> break;

<><\/li\> case 40:

<><\/li\> if(vakata_context.is_visible) {

6235

<><\/li\>									o = vakata_context.element.find("ul:visible").addBack().last().children(".vakata-context-hover").removeClass("vakata-context-hover").nextAll("li:not(.vakata-context-separator)").first();

6236

<><\/li\>									if(!o.length) { o = vakata_context.element.find("ul:visible").addBack().last().children("li:not(.vakata-context-separator)").first(); }

6237

<><\/li\> o.addClass("vakata-context-hover").children('a').focus();

6238

<><\/li\> e.stopImmediatePropagation();

6239

<><\/li\> e.preventDefault();

<><\/li\> }

<><\/li\> break;

<><\/li\> case 27:

<><\/li\> $.vakata.context.hide();

6244

<><\/li\> e.preventDefault();

6245

<><\/li\> break;

6246

<><\/li\> default:

6247

<><\/li\> //console.log(e.which);

<><\/li\> break;

<><\/li\> }

<><\/li\> })

<><\/li\> .on('keydown', function (e) {

6252

<><\/li\> e.preventDefault();

6253

<><\/li\> var a = vakata_context.element.find('.vakata-contextmenu-shortcut-' + e.which).parent();

6254

<><\/li\> if(a.parent().not('.vakata-context-disabled')) {

6255

<><\/li\> a.click();

<><\/li\> }

<><\/li\> });

<><\/li\> $(document)

6260

<><\/li\> .on("mousedown.vakata.jstree", function (e) {

6261

<><\/li\> if(vakata_context.is_visible && !$.contains(vakata_context.element[0], e.target)) {

6262

<><\/li\> $.vakata.context.hide();

6263

<><\/li\> }

6264

<><\/li\> })

6265

<><\/li\> .on("context_show.vakata.jstree", function (e, data) {

6266

<><\/li\> vakata_context.element.find("li:has(ul)").children("a").addClass("vakata-context-parent");

6267

<><\/li\> if(right_to_left) {

6268

<><\/li\> vakata_context.element.addClass("vakata-context-rtl").css("direction", "rtl");

6269

<><\/li\> }

6270

<><\/li\> // also apply a RTL class?

6271

<><\/li\> vakata_context.element.find("ul").hide().end();

<><\/li\> });

<><\/li\> });

<><\/li\> }($));

<><\/li\> // $.jstree.defaults.plugins.push("contextmenu");

<><\/li\>/**

<><\/li\> * ### Drag'n'drop plugin

6280

<><\/li\> *

6281

<><\/li\> * Enables dragging and dropping of nodes in the tree, resulting in a move or copy operations.

<><\/li\> */

<><\/li\> /**

<><\/li\> * stores all defaults for the drag'n'drop plugin

6286

<><\/li\> * @name $.jstree.defaults.dnd

6287

<><\/li\> * @plugin dnd

6288

<><\/li\> */

6289

<><\/li\> $.jstree.defaults.dnd = {

6290

<><\/li\> /**

6291

<><\/li\>		 * a boolean indicating if a copy should be possible while dragging (by pressint the meta key or Ctrl). Defaults to `true`.

6292

<><\/li\> * @name $.jstree.defaults.dnd.copy

6293

<><\/li\> * @plugin dnd

6294

<><\/li\> */

6295

<><\/li\> copy : true,

6296

<><\/li\> /**

6297

<><\/li\> * a number indicating how long a node should remain hovered while dragging to be opened. Defaults to `500`.

6298

<><\/li\> * @name $.jstree.defaults.dnd.open_timeout

6299

<><\/li\> * @plugin dnd

6300

<><\/li\> */

6301

<><\/li\> open_timeout : 500,

6302

<><\/li\> /**

6303

<><\/li\>		 * a function invoked each time a node is about to be dragged, invoked in the tree's scope and receives the nodes about to be dragged as an argument (array) and the event that started the drag - return `false` to prevent dragging

6304

<><\/li\> * @name $.jstree.defaults.dnd.is_draggable

6305

<><\/li\> * @plugin dnd

6306

<><\/li\> */

6307

<><\/li\> is_draggable : true,

6308

<><\/li\> /**

6309

<><\/li\>		 * a boolean indicating if checks should constantly be made while the user is dragging the node (as opposed to checking only on drop), default is `true`

6310

<><\/li\> * @name $.jstree.defaults.dnd.check_while_dragging

6311

<><\/li\> * @plugin dnd

6312

<><\/li\> */

6313

<><\/li\> check_while_dragging : true,

6314

<><\/li\> /**

6315

<><\/li\>		 * a boolean indicating if nodes from this tree should only be copied with dnd (as opposed to moved), default is `false`

6316

<><\/li\> * @name $.jstree.defaults.dnd.always_copy

6317

<><\/li\> * @plugin dnd

6318

<><\/li\> */

6319

<><\/li\> always_copy : false,

6320

<><\/li\> /**

6321

<><\/li\>		 * when dropping a node "inside", this setting indicates the position the node should go to - it can be an integer or a string: "first" (same as 0) or "last", default is `0`

6322

<><\/li\> * @name $.jstree.defaults.dnd.inside_pos

6323

<><\/li\> * @plugin dnd

6324

<><\/li\> */

6325

<><\/li\> inside_pos : 0,

6326

<><\/li\> /**

6327

<><\/li\>		 * when starting the drag on a node that is selected this setting controls if all selected nodes are dragged or only the single node, default is `true`, which means all selected nodes are dragged when the drag is started on a selected node

6328

<><\/li\> * @name $.jstree.defaults.dnd.drag_selection

6329

<><\/li\> * @plugin dnd

6330

<><\/li\> */

6331

<><\/li\> drag_selection : true,

6332

<><\/li\> /**

6333

<><\/li\>		 * controls whether dnd works on touch devices. If left as boolean true dnd will work the same as in desktop browsers, which in some cases may impair scrolling. If set to boolean false dnd will not work on touch devices. There is a special third option - string "selected" which means only selected nodes can be dragged on touch devices.

6334

<><\/li\> * @name $.jstree.defaults.dnd.touch

6335

<><\/li\> * @plugin dnd

6336

<><\/li\> */

6337

<><\/li\> touch : true,

6338

<><\/li\> /**

6339

<><\/li\>		 * controls whether items can be dropped anywhere on the node, not just on the anchor, by default only the node anchor is a valid drop target. Works best with the wholerow plugin. If enabled on mobile depending on the interface it might be hard for the user to cancel the drop, since the whole tree container will be a valid drop target.

6340

<><\/li\> * @name $.jstree.defaults.dnd.large_drop_target

6341

<><\/li\> * @plugin dnd

6342

<><\/li\> */

6343

<><\/li\> large_drop_target : false,

6344

<><\/li\> /**

6345

<><\/li\>		 * controls whether a drag can be initiated from any part of the node and not just the text/icon part, works best with the wholerow plugin. Keep in mind it can cause problems with tree scrolling on mobile depending on the interface - in that case set the touch option to "selected".

6346

<><\/li\> * @name $.jstree.defaults.dnd.large_drag_target

6347

<><\/li\> * @plugin dnd

6348

<><\/li\> */

6349

<><\/li\> large_drag_target : false,

6350

<><\/li\> /**

6351

<><\/li\>		 * controls whether use HTML5 dnd api instead of classical. That will allow better integration of dnd events with other HTML5 controls.

6352

<><\/li\> * @reference http://caniuse.com/#feat=dragndrop

6353

<><\/li\> * @name $.jstree.defaults.dnd.use_html5

6354

<><\/li\> * @plugin dnd

6355

<><\/li\> */

6356

<><\/li\> use_html5: false

6357

<><\/li\> };

6358

<><\/li\> var drg, elm;

6359

<><\/li\> // TODO: now check works by checking for each node individually, how about max_children, unique, etc?

6360

<><\/li\> $.jstree.plugins.dnd = function (options, parent) {

6361

<><\/li\> this.init = function (el, options) {

6362

<><\/li\> parent.init.call(this, el, options);

6363

<><\/li\>			this.settings.dnd.use_html5 = this.settings.dnd.use_html5 && ('draggable' in document.createElement('span'));

6364

<><\/li\> };

6365

<><\/li\> this.bind = function () {

6366

<><\/li\> parent.bind.call(this);

6367

6368

<><\/li\> this.element

6369

<><\/li\>				.on(this.settings.dnd.use_html5 ? 'dragstart.jstree' : 'mousedown.jstree touchstart.jstree', this.settings.dnd.large_drag_target ? '.jstree-node' : '.jstree-anchor', $.proxy(function (e) {

6370

<><\/li\> if(this.settings.dnd.large_drag_target && $(e.target).closest('.jstree-node')[0] !== e.currentTarget) {

6371

<><\/li\> return true;

6372

<><\/li\> }

6373

<><\/li\>						if(e.type === "touchstart" && (!this.settings.dnd.touch || (this.settings.dnd.touch === 'selected' && !$(e.currentTarget).closest('.jstree-node').children('.jstree-anchor').hasClass('jstree-clicked')))) {

6374

<><\/li\> return true;

6375

<><\/li\> }

6376

<><\/li\> var obj = this.get_node(e.target),

6377

<><\/li\> mlt = this.is_selected(obj) && this.settings.dnd.drag_selection ? this.get_top_selected().length : 1,

6378

<><\/li\> txt = (mlt > 1 ? mlt + ' ' + this.get_string('nodes') : this.get_text(e.currentTarget));

6379

<><\/li\> if(this.settings.core.force_text) {

6380

<><\/li\> txt = $.vakata.html.escape(txt);

6381

<><\/li\> }

6382

<><\/li\>						if(obj && obj.id && obj.id !== $.jstree.root && (e.which === 1 || e.type === "touchstart" || e.type === "dragstart") &&

6383

<><\/li\>							(this.settings.dnd.is_draggable === true || ($.isFunction(this.settings.dnd.is_draggable) && this.settings.dnd.is_draggable.call(this, (mlt > 1 ? this.get_top_selected(true) : [obj]), e)))

6384

<><\/li\> ) {

6385

<><\/li\>							drg = { 'jstree' : true, 'origin' : this, 'obj' : this.get_node(obj,true), 'nodes' : mlt > 1 ? this.get_top_selected() : [obj.id] };

6386

<><\/li\> elm = e.currentTarget;

6387

<><\/li\> if (this.settings.dnd.use_html5) {

6388

<><\/li\> $.vakata.dnd._trigger('start', e, { 'helper': $(), 'element': elm, 'data': drg });

6389

<><\/li\> } else {

6390

<><\/li\> this.element.trigger('mousedown.jstree');

6391

<><\/li\>								return $.vakata.dnd.start(e, drg, '<div id="jstree-dnd" class="jstree-' + this.get_theme() + ' jstree-' + this.get_theme() + '-' + this.get_theme_variant() + ' ' + ( this.settings.core.themes.responsive ? ' jstree-dnd-responsive' : '' ) + '"><i class="jstree-icon jstree-er"></i>' + txt + '<ins class="jstree-copy" style="display:none;">+</ins></div>');

6392

<><\/li\> }

6393

<><\/li\> }

6394

<><\/li\> }, this));

6395

<><\/li\> if (this.settings.dnd.use_html5) {

6396

<><\/li\> this.element

6397

<><\/li\> .on('dragover.jstree', function (e) {

6398

<><\/li\> e.preventDefault();

6399

<><\/li\> $.vakata.dnd._trigger('move', e, { 'helper': $(), 'element': elm, 'data': drg });

6400

<><\/li\> return false;

6401

<><\/li\> })

6402

<><\/li\>					//.on('dragenter.jstree', this.settings.dnd.large_drop_target ? '.jstree-node' : '.jstree-anchor', $.proxy(function (e) {

6403

<><\/li\> // e.preventDefault();

6404

<><\/li\> // $.vakata.dnd._trigger('move', e, { 'helper': $(), 'element': elm, 'data': drg });

6405

<><\/li\> // return false;

6406

<><\/li\> // }, this))

6407

<><\/li\> .on('drop.jstree', $.proxy(function (e) {

6408

<><\/li\> e.preventDefault();

6409

<><\/li\> $.vakata.dnd._trigger('stop', e, { 'helper': $(), 'element': elm, 'data': drg });

6410

<><\/li\> return false;

6411

<><\/li\> }, this));

6412

<><\/li\> }

6413

<><\/li\> };

6414

<><\/li\> this.redraw_node = function(obj, deep, callback, force_render) {

6415

<><\/li\> obj = parent.redraw_node.apply(this, arguments);

6416

<><\/li\> if (obj && this.settings.dnd.use_html5) {

6417

<><\/li\> if (this.settings.dnd.large_drag_target) {

6418

<><\/li\> obj.setAttribute('draggable', true);

6419

<><\/li\> } else {

6420

<><\/li\> var i, j, tmp = null;

6421

<><\/li\> for(i = 0, j = obj.childNodes.length; i < j; i++) {

6422

<><\/li\>						if(obj.childNodes[i] && obj.childNodes[i].className && obj.childNodes[i].className.indexOf("jstree-anchor") !== -1) {

6423

<><\/li\> tmp = obj.childNodes[i];

<><\/li\> break;

<><\/li\> }

<><\/li\> }

<><\/li\> if(tmp) {

6428

<><\/li\> tmp.setAttribute('draggable', true);

<><\/li\> }

<><\/li\> }

<><\/li\> }

<><\/li\> return obj;

<><\/li\> };

<><\/li\> };

<><\/li\> $(function() {

6437

<><\/li\> // bind only once for all instances

6438

<><\/li\> var lastmv = false,

6439

<><\/li\> laster = false,

6440

<><\/li\> lastev = false,

6441

<><\/li\> opento = false,

6442

<><\/li\> marker = $('<div id="jstree-marker"> </div>').hide(); //.appendTo('body');

6443

6444

<><\/li\> $(document)

6445

<><\/li\> .on('dnd_start.vakata.jstree', function (e, data) {

6446

<><\/li\> lastmv = false;

6447

<><\/li\> lastev = false;

6448

<><\/li\> if(!data || !data.data || !data.data.jstree) { return; }

6449

<><\/li\> marker.appendTo('body'); //.show();

6450

<><\/li\> })

6451

<><\/li\> .on('dnd_move.vakata.jstree', function (e, data) {

6452

<><\/li\> if(opento) {

6453

<><\/li\> if (!data.event || data.event.type !== 'dragover' || data.event.target !== lastev.target) {

6454

<><\/li\> clearTimeout(opento);

6455

<><\/li\> }

6456

<><\/li\> }

6457

<><\/li\> if(!data || !data.data || !data.data.jstree) { return; }

6458

6459

<><\/li\> // if we are hovering the marker image do nothing (can happen on "inside" drags)

6460

<><\/li\> if(data.event.target.id && data.event.target.id === 'jstree-marker') {

6461

<><\/li\> return;

6462

<><\/li\> }

6463

<><\/li\> lastev = data.event;

6464

6465

<><\/li\> var ins = $.jstree.reference(data.event.target),

6466

<><\/li\> ref = false,

6467

<><\/li\> off = false,

6468

<><\/li\> rel = false,

6469

<><\/li\> tmp, l, t, h, p, i, o, ok, t1, t2, op, ps, pr, ip, tm, is_copy, pn;

6470

<><\/li\> // if we are over an instance

6471

<><\/li\> if(ins && ins._data && ins._data.dnd) {

6472

<><\/li\>					marker.attr('class', 'jstree-' + ins.get_theme() + ( ins.settings.core.themes.responsive ? ' jstree-dnd-responsive' : '' ));

6473

<><\/li\>					is_copy = data.data.origin && (data.data.origin.settings.dnd.always_copy || (data.data.origin.settings.dnd.copy && (data.event.metaKey || data.event.ctrlKey)));

6474

<><\/li\> data.helper

6475

<><\/li\>						.children().attr('class', 'jstree-' + ins.get_theme() + ' jstree-' + ins.get_theme() + '-' + ins.get_theme_variant() + ' ' + ( ins.settings.core.themes.responsive ? ' jstree-dnd-responsive' : '' ))

6476

<><\/li\> .find('.jstree-copy').first()[ is_copy ? 'show' : 'hide' ]();

6477

6478

<><\/li\> // if are hovering the container itself add a new root node

6479

<><\/li\> //console.log(data.event);

6480

<><\/li\>					if( (data.event.target === ins.element[0] || data.event.target === ins.get_container_ul()[0]) && ins.get_container_ul().children().length === 0) {

6481

<><\/li\> ok = true;

6482

<><\/li\> for(t1 = 0, t2 = data.data.nodes.length; t1 < t2; t1++) {

6483

<><\/li\>							ok = ok && ins.check( (data.data.origin && (data.data.origin.settings.dnd.always_copy || (data.data.origin.settings.dnd.copy && (data.event.metaKey || data.event.ctrlKey)) ) ? "copy_node" : "move_node"), (data.data.origin && data.data.origin !== ins ? data.data.origin.get_node(data.data.nodes[t1]) : data.data.nodes[t1]), $.jstree.root, 'last', { 'dnd' : true, 'ref' : ins.get_node($.jstree.root), 'pos' : 'i', 'origin' : data.data.origin, 'is_multi' : (data.data.origin && data.data.origin !== ins), 'is_foreign' : (!data.data.origin) });

6484

<><\/li\> if(!ok) { break; }

6485

<><\/li\> }

6486

<><\/li\> if(ok) {

6487

<><\/li\> lastmv = { 'ins' : ins, 'par' : $.jstree.root, 'pos' : 'last' };

6488

<><\/li\> marker.hide();

6489

<><\/li\> data.helper.find('.jstree-icon').first().removeClass('jstree-er').addClass('jstree-ok');

6490

<><\/li\> if (data.event.originalEvent && data.event.originalEvent.dataTransfer) {

6491

<><\/li\> data.event.originalEvent.dataTransfer.dropEffect = is_copy ? 'copy' : 'move';

<><\/li\> }

<><\/li\> return;

<><\/li\> }

<><\/li\> }

<><\/li\> else {

<><\/li\> // if we are hovering a tree node

6498

<><\/li\>						ref = ins.settings.dnd.large_drop_target ? $(data.event.target).closest('.jstree-node').children('.jstree-anchor') : $(data.event.target).closest('.jstree-anchor');

6499

<><\/li\> if(ref && ref.length && ref.parent().is('.jstree-closed, .jstree-open, .jstree-leaf')) {

6500

<><\/li\> off = ref.offset();

6501

<><\/li\> rel = (data.event.pageY !== undefined ? data.event.pageY : data.event.originalEvent.pageY) - off.top;

6502

<><\/li\> h = ref.outerHeight();

6503

<><\/li\> if(rel < h / 3) {

6504

<><\/li\> o = ['b', 'i', 'a'];

6505

<><\/li\> }

6506

<><\/li\> else if(rel > h - h / 3) {

6507

<><\/li\> o = ['a', 'i', 'b'];

6508

<><\/li\> }

6509

<><\/li\> else {

6510

<><\/li\> o = rel > h / 2 ? ['i', 'a', 'b'] : ['i', 'b', 'a'];

6511

<><\/li\> }

6512

<><\/li\> $.each(o, function (j, v) {

6513

<><\/li\> switch(v) {

6514

<><\/li\> case 'b':

6515

<><\/li\> l = off.left - 6;

6516

<><\/li\> t = off.top;

6517

<><\/li\> p = ins.get_parent(ref);

6518

<><\/li\> i = ref.parent().index();

6519

<><\/li\> break;

6520

<><\/li\> case 'i':

6521

<><\/li\> ip = ins.settings.dnd.inside_pos;

6522

<><\/li\> tm = ins.get_node(ref.parent());

6523

<><\/li\> l = off.left - 2;

6524

<><\/li\> t = off.top + h / 2 + 1;

6525

<><\/li\> p = tm.id;

6526

<><\/li\> i = ip === 'first' ? 0 : (ip === 'last' ? tm.children.length : Math.min(ip, tm.children.length));

6527

<><\/li\> break;

6528

<><\/li\> case 'a':

6529

<><\/li\> l = off.left - 6;

6530

<><\/li\> t = off.top + h;

6531

<><\/li\> p = ins.get_parent(ref);

6532

<><\/li\> i = ref.parent().index() + 1;

6533

<><\/li\> break;

6534

<><\/li\> }

6535

<><\/li\> ok = true;

6536

<><\/li\> for(t1 = 0, t2 = data.data.nodes.length; t1 < t2; t1++) {

6537

<><\/li\>									op = data.data.origin && (data.data.origin.settings.dnd.always_copy || (data.data.origin.settings.dnd.copy && (data.event.metaKey || data.event.ctrlKey))) ? "copy_node" : "move_node";

6538

<><\/li\> ps = i;

6539

<><\/li\>									if(op === "move_node" && v === 'a' && (data.data.origin && data.data.origin === ins) && p === ins.get_parent(data.data.nodes[t1])) {

6540

<><\/li\> pr = ins.get_node(p);

6541

<><\/li\> if(ps > $.inArray(data.data.nodes[t1], pr.children)) {

<><\/li\> ps -= 1;

<><\/li\> }

<><\/li\> }

<><\/li\>									ok = ok && ( (ins && ins.settings && ins.settings.dnd && ins.settings.dnd.check_while_dragging === false) || ins.check(op, (data.data.origin && data.data.origin !== ins ? data.data.origin.get_node(data.data.nodes[t1]) : data.data.nodes[t1]), p, ps, { 'dnd' : true, 'ref' : ins.get_node(ref.parent()), 'pos' : v, 'origin' : data.data.origin, 'is_multi' : (data.data.origin && data.data.origin !== ins), 'is_foreign' : (!data.data.origin) }) );

6546

<><\/li\> if(!ok) {

6547

<><\/li\> if(ins && ins.last_error) { laster = ins.last_error(); }

<><\/li\> break;

<><\/li\> }

<><\/li\> }

<><\/li\> if(v === 'i' && ref.parent().is('.jstree-closed') && ins.settings.dnd.open_timeout) {

6552

<><\/li\>									opento = setTimeout((function (x, z) { return function () { x.open_node(z); }; }(ins, ref)), ins.settings.dnd.open_timeout);

6553

<><\/li\> }

6554

<><\/li\> if(ok) {

6555

<><\/li\> pn = ins.get_node(p, true);

6556

<><\/li\> if (!pn.hasClass('.jstree-dnd-parent')) {

6557

<><\/li\> $('.jstree-dnd-parent').removeClass('jstree-dnd-parent');

6558

<><\/li\> pn.addClass('jstree-dnd-parent');

6559

<><\/li\> }

6560

<><\/li\>									lastmv = { 'ins' : ins, 'par' : p, 'pos' : v === 'i' && ip === 'last' && i === 0 && !ins.is_loaded(tm) ? 'last' : i };

6561

<><\/li\> marker.css({ 'left' : l + 'px', 'top' : t + 'px' }).show();

6562

<><\/li\> data.helper.find('.jstree-icon').first().removeClass('jstree-er').addClass('jstree-ok');

6563

<><\/li\> if (data.event.originalEvent && data.event.originalEvent.dataTransfer) {

6564

<><\/li\> data.event.originalEvent.dataTransfer.dropEffect = is_copy ? 'copy' : 'move';

6565

<><\/li\> }

6566

<><\/li\> laster = {};

6567

<><\/li\> o = true;

6568

<><\/li\> return false;

6569

<><\/li\> }

6570

<><\/li\> });

6571

<><\/li\> if(o === true) { return; }

<><\/li\> }

<><\/li\> }

<><\/li\> }

<><\/li\> $('.jstree-dnd-parent').removeClass('jstree-dnd-parent');

6576

<><\/li\> lastmv = false;

6577

<><\/li\> data.helper.find('.jstree-icon').removeClass('jstree-ok').addClass('jstree-er');

6578

<><\/li\> if (data.event.originalEvent && data.event.originalEvent.dataTransfer) {

6579

<><\/li\> data.event.originalEvent.dataTransfer.dropEffect = 'none';

6580

<><\/li\> }

6581

<><\/li\> marker.hide();

6582

<><\/li\> })

6583

<><\/li\> .on('dnd_scroll.vakata.jstree', function (e, data) {

6584

<><\/li\> if(!data || !data.data || !data.data.jstree) { return; }

6585

<><\/li\> marker.hide();

6586

<><\/li\> lastmv = false;

6587

<><\/li\> lastev = false;

6588

<><\/li\> data.helper.find('.jstree-icon').first().removeClass('jstree-ok').addClass('jstree-er');

6589

<><\/li\> })

6590

<><\/li\> .on('dnd_stop.vakata.jstree', function (e, data) {

6591

<><\/li\> $('.jstree-dnd-parent').removeClass('jstree-dnd-parent');

6592

<><\/li\> if(opento) { clearTimeout(opento); }

6593

<><\/li\> if(!data || !data.data || !data.data.jstree) { return; }

6594

<><\/li\> marker.hide().detach();

6595

<><\/li\> var i, j, nodes = [];

6596

<><\/li\> if(lastmv) {

6597

<><\/li\> for(i = 0, j = data.data.nodes.length; i < j; i++) {

6598

<><\/li\> nodes[i] = data.data.origin ? data.data.origin.get_node(data.data.nodes[i]) : data.data.nodes[i];

6599

<><\/li\> }

6600

<><\/li\>					lastmv.ins[ data.data.origin && (data.data.origin.settings.dnd.always_copy || (data.data.origin.settings.dnd.copy && (data.event.metaKey || data.event.ctrlKey))) ? 'copy_node' : 'move_node' ](nodes, lastmv.par, lastmv.pos, false, false, false, data.data.origin);

6601

<><\/li\> }

6602

<><\/li\> else {

6603

<><\/li\> i = $(data.event.target).closest('.jstree');

6604

<><\/li\> if(i.length && laster && laster.error && laster.error === 'check') {

6605

<><\/li\> i = i.jstree(true);

6606

<><\/li\> if(i) {

6607

<><\/li\> i.settings.core.error.call(this, laster);

<><\/li\> }

<><\/li\> }

<><\/li\> }

<><\/li\> lastev = false;

6612

<><\/li\> lastmv = false;

6613

<><\/li\> })

6614

<><\/li\> .on('keyup.jstree keydown.jstree', function (e, data) {

6615

<><\/li\> data = $.vakata.dnd._get();

6616

<><\/li\> if(data && data.data && data.data.jstree) {

6617

<><\/li\> if (e.type === "keyup" && e.which === 27) {

6618

<><\/li\> if (opento) { clearTimeout(opento); }

6619

<><\/li\> lastmv = false;

6620

<><\/li\> laster = false;

6621

<><\/li\> lastev = false;

6622

<><\/li\> opento = false;

6623

<><\/li\> marker.hide().detach();

6624

<><\/li\> $.vakata.dnd._clean();

6625

<><\/li\> } else {

6626

<><\/li\>						data.helper.find('.jstree-copy').first()[ data.data.origin && (data.data.origin.settings.dnd.always_copy || (data.data.origin.settings.dnd.copy && (e.metaKey || e.ctrlKey))) ? 'show' : 'hide' ]();

6627

<><\/li\> if(lastev) {

6628

<><\/li\> lastev.metaKey = e.metaKey;

6629

<><\/li\> lastev.ctrlKey = e.ctrlKey;

6630

<><\/li\> $.vakata.dnd._trigger('move', lastev);

<><\/li\> }

<><\/li\> }

<><\/li\> }

<><\/li\> });

<><\/li\> });

<><\/li\> // helpers

6638

<><\/li\> (function ($) {

6639

<><\/li\> $.vakata.html = {

6640

<><\/li\> div : $('<div />'),

6641

<><\/li\> escape : function (str) {

6642

<><\/li\> return $.vakata.html.div.text(str).html();

6643

<><\/li\> },

6644

<><\/li\> strip : function (str) {

6645

<><\/li\> return $.vakata.html.div.empty().append($.parseHTML(str)).text();

6646

<><\/li\> }

6647

<><\/li\> };

6648

<><\/li\> // private variable

6649

<><\/li\> var vakata_dnd = {

6650

<><\/li\> element : false,

6651

<><\/li\> target : false,

6652

<><\/li\> is_down : false,

6653

<><\/li\> is_drag : false,

6654

<><\/li\> helper : false,

6655

<><\/li\> helper_w: 0,

6656

<><\/li\> data : false,

6657

<><\/li\> init_x : 0,

6658

<><\/li\> init_y : 0,

6659

<><\/li\> scroll_l: 0,

6660

<><\/li\> scroll_t: 0,

6661

<><\/li\> scroll_e: false,

6662

<><\/li\> scroll_i: false,

6663

<><\/li\> is_touch: false

6664

<><\/li\> };

6665

<><\/li\> $.vakata.dnd = {

6666

<><\/li\> settings : {

6667

<><\/li\> scroll_speed : 10,

6668

<><\/li\> scroll_proximity : 20,

6669

<><\/li\> helper_left : 5,

6670

<><\/li\> helper_top : 10,

6671

<><\/li\> threshold : 5,

6672

<><\/li\> threshold_touch : 50

6673

<><\/li\> },

6674

<><\/li\> _trigger : function (event_name, e, data) {

6675

<><\/li\> if (data === undefined) {

6676

<><\/li\> data = $.vakata.dnd._get();

6677

<><\/li\> }

6678

<><\/li\> data.event = e;

6679

<><\/li\> $(document).triggerHandler("dnd_" + event_name + ".vakata", data);

6680

<><\/li\> },

6681

<><\/li\> _get : function () {

6682

<><\/li\> return {

6683

<><\/li\> "data" : vakata_dnd.data,

6684

<><\/li\> "element" : vakata_dnd.element,

6685

<><\/li\> "helper" : vakata_dnd.helper

6686

<><\/li\> };

6687

<><\/li\> },

6688

<><\/li\> _clean : function () {

6689

<><\/li\> if(vakata_dnd.helper) { vakata_dnd.helper.remove(); }

6690

<><\/li\> if(vakata_dnd.scroll_i) { clearInterval(vakata_dnd.scroll_i); vakata_dnd.scroll_i = false; }

6691

<><\/li\> vakata_dnd = {

6692

<><\/li\> element : false,

6693

<><\/li\> target : false,

6694

<><\/li\> is_down : false,

6695

<><\/li\> is_drag : false,

6696

<><\/li\> helper : false,

6697

<><\/li\> helper_w: 0,

6698

<><\/li\> data : false,

6699

<><\/li\> init_x : 0,

6700

<><\/li\> init_y : 0,

6701

<><\/li\> scroll_l: 0,

6702

<><\/li\> scroll_t: 0,

6703

<><\/li\> scroll_e: false,

6704

<><\/li\> scroll_i: false,

6705

<><\/li\> is_touch: false

6706

<><\/li\> };

6707

<><\/li\> $(document).off("mousemove.vakata.jstree touchmove.vakata.jstree", $.vakata.dnd.drag);

6708

<><\/li\> $(document).off("mouseup.vakata.jstree touchend.vakata.jstree", $.vakata.dnd.stop);

6709

<><\/li\> },

6710

<><\/li\> _scroll : function (init_only) {

6711

<><\/li\> if(!vakata_dnd.scroll_e || (!vakata_dnd.scroll_l && !vakata_dnd.scroll_t)) {

6712

<><\/li\> if(vakata_dnd.scroll_i) { clearInterval(vakata_dnd.scroll_i); vakata_dnd.scroll_i = false; }

6713

<><\/li\> return false;

6714

<><\/li\> }

6715

<><\/li\> if(!vakata_dnd.scroll_i) {

6716

<><\/li\> vakata_dnd.scroll_i = setInterval($.vakata.dnd._scroll, 100);

6717

<><\/li\> return false;

6718

<><\/li\> }

6719

<><\/li\> if(init_only === true) { return false; }

6720

6721

<><\/li\> var i = vakata_dnd.scroll_e.scrollTop(),

6722

<><\/li\> j = vakata_dnd.scroll_e.scrollLeft();

6723

<><\/li\> vakata_dnd.scroll_e.scrollTop(i + vakata_dnd.scroll_t * $.vakata.dnd.settings.scroll_speed);

6724

<><\/li\> vakata_dnd.scroll_e.scrollLeft(j + vakata_dnd.scroll_l * $.vakata.dnd.settings.scroll_speed);

6725

<><\/li\> if(i !== vakata_dnd.scroll_e.scrollTop() || j !== vakata_dnd.scroll_e.scrollLeft()) {

6726

<><\/li\> /**

6727

<><\/li\> * triggered on the document when a drag causes an element to scroll

6728

<><\/li\> * @event

6729

<><\/li\> * @plugin dnd

6730

<><\/li\> * @name dnd_scroll.vakata

6731

<><\/li\> * @param {Mixed} data any data supplied with the call to $.vakata.dnd.start

6732

<><\/li\> * @param {DOM} element the DOM element being dragged

6733

<><\/li\> * @param {jQuery} helper the helper shown next to the mouse

6734

<><\/li\> * @param {jQuery} event the element that is scrolling

6735

<><\/li\> */

6736

<><\/li\> $.vakata.dnd._trigger("scroll", vakata_dnd.scroll_e);

6737

<><\/li\> }

6738

<><\/li\> },

6739

<><\/li\> start : function (e, data, html) {

6740

<><\/li\>				if(e.type === "touchstart" && e.originalEvent && e.originalEvent.changedTouches && e.originalEvent.changedTouches[0]) {

6741

<><\/li\> e.pageX = e.originalEvent.changedTouches[0].pageX;

6742

<><\/li\> e.pageY = e.originalEvent.changedTouches[0].pageY;

6743

<><\/li\>					e.target = document.elementFromPoint(e.originalEvent.changedTouches[0].pageX - window.pageXOffset, e.originalEvent.changedTouches[0].pageY - window.pageYOffset);

6744

<><\/li\> }

6745

<><\/li\> if(vakata_dnd.is_drag) { $.vakata.dnd.stop({}); }

6746

<><\/li\> try {

6747

<><\/li\> e.currentTarget.unselectable = "on";

6748

<><\/li\> e.currentTarget.onselectstart = function() { return false; };

6749

<><\/li\> if(e.currentTarget.style) {

6750

<><\/li\> e.currentTarget.style.touchAction = "none";

6751

<><\/li\> e.currentTarget.style.msTouchAction = "none";

6752

<><\/li\> e.currentTarget.style.MozUserSelect = "none";

6753

<><\/li\> }

6754

<><\/li\> } catch(ignore) { }

6755

<><\/li\> vakata_dnd.init_x = e.pageX;

6756

<><\/li\> vakata_dnd.init_y = e.pageY;

6757

<><\/li\> vakata_dnd.data = data;

6758

<><\/li\> vakata_dnd.is_down = true;

6759

<><\/li\> vakata_dnd.element = e.currentTarget;

6760

<><\/li\> vakata_dnd.target = e.target;

6761

<><\/li\> vakata_dnd.is_touch = e.type === "touchstart";

6762

<><\/li\> if(html !== false) {

6763

<><\/li\> vakata_dnd.helper = $("<div id='vakata-dnd'></div>").html(html).css({

6764

<><\/li\> "display" : "block",

6765

<><\/li\> "margin" : "0",

6766

<><\/li\> "padding" : "0",

6767

<><\/li\> "position" : "absolute",

6768

<><\/li\> "top" : "-2000px",

6769

<><\/li\> "lineHeight" : "16px",

6770

<><\/li\> "zIndex" : "10000"

6771

<><\/li\> });

6772

<><\/li\> }

6773

<><\/li\> $(document).on("mousemove.vakata.jstree touchmove.vakata.jstree", $.vakata.dnd.drag);

6774

<><\/li\> $(document).on("mouseup.vakata.jstree touchend.vakata.jstree", $.vakata.dnd.stop);

6775

<><\/li\> return false;

6776

<><\/li\> },

6777

<><\/li\> drag : function (e) {

6778

<><\/li\>				if(e.type === "touchmove" && e.originalEvent && e.originalEvent.changedTouches && e.originalEvent.changedTouches[0]) {

6779

<><\/li\> e.pageX = e.originalEvent.changedTouches[0].pageX;

6780

<><\/li\> e.pageY = e.originalEvent.changedTouches[0].pageY;

6781

<><\/li\>					e.target = document.elementFromPoint(e.originalEvent.changedTouches[0].pageX - window.pageXOffset, e.originalEvent.changedTouches[0].pageY - window.pageYOffset);

6782

<><\/li\> }

6783

<><\/li\> if(!vakata_dnd.is_down) { return; }

6784

<><\/li\> if(!vakata_dnd.is_drag) {

6785

<><\/li\> if(

6786

<><\/li\>						Math.abs(e.pageX - vakata_dnd.init_x) > (vakata_dnd.is_touch ? $.vakata.dnd.settings.threshold_touch : $.vakata.dnd.settings.threshold) ||

6787

<><\/li\>						Math.abs(e.pageY - vakata_dnd.init_y) > (vakata_dnd.is_touch ? $.vakata.dnd.settings.threshold_touch : $.vakata.dnd.settings.threshold)

6788

<><\/li\> ) {

6789

<><\/li\> if(vakata_dnd.helper) {

6790

<><\/li\> vakata_dnd.helper.appendTo("body");

6791

<><\/li\> vakata_dnd.helper_w = vakata_dnd.helper.outerWidth();

6792

<><\/li\> }

6793

<><\/li\> vakata_dnd.is_drag = true;

6794

<><\/li\> $(vakata_dnd.target).one('click.vakata', false);

6795

<><\/li\> /**

6796

<><\/li\> * triggered on the document when a drag starts

6797

<><\/li\> * @event

6798

<><\/li\> * @plugin dnd

6799

<><\/li\> * @name dnd_start.vakata

6800

<><\/li\> * @param {Mixed} data any data supplied with the call to $.vakata.dnd.start

6801

<><\/li\> * @param {DOM} element the DOM element being dragged

6802

<><\/li\> * @param {jQuery} helper the helper shown next to the mouse

6803

<><\/li\> * @param {Object} event the event that caused the start (probably mousemove)

6804

<><\/li\> */

6805

<><\/li\> $.vakata.dnd._trigger("start", e);

6806

<><\/li\> }

6807

<><\/li\> else { return; }

6808

<><\/li\> }

6809

6810

<><\/li\> var d = false, w = false,

6811

<><\/li\> dh = false, wh = false,

6812

<><\/li\> dw = false, ww = false,

6813

<><\/li\> dt = false, dl = false,

6814

<><\/li\> ht = false, hl = false;

6815

6816

<><\/li\> vakata_dnd.scroll_t = 0;

6817

<><\/li\> vakata_dnd.scroll_l = 0;

6818

<><\/li\> vakata_dnd.scroll_e = false;

6819

<><\/li\> $($(e.target).parentsUntil("body").addBack().get().reverse())

6820

<><\/li\> .filter(function () {

6821

<><\/li\> return (/^auto|scroll$/).test($(this).css("overflow")) &&

6822

<><\/li\> (this.scrollHeight > this.offsetHeight || this.scrollWidth > this.offsetWidth);

6823

<><\/li\> })

6824

<><\/li\> .each(function () {

6825

<><\/li\> var t = $(this), o = t.offset();

6826

<><\/li\> if(this.scrollHeight > this.offsetHeight) {

6827

<><\/li\> if(o.top + t.height() - e.pageY < $.vakata.dnd.settings.scroll_proximity) { vakata_dnd.scroll_t = 1; }

6828

<><\/li\> if(e.pageY - o.top < $.vakata.dnd.settings.scroll_proximity) { vakata_dnd.scroll_t = -1; }

6829

<><\/li\> }

6830

<><\/li\> if(this.scrollWidth > this.offsetWidth) {

6831

<><\/li\> if(o.left + t.width() - e.pageX < $.vakata.dnd.settings.scroll_proximity) { vakata_dnd.scroll_l = 1; }

6832

<><\/li\> if(e.pageX - o.left < $.vakata.dnd.settings.scroll_proximity) { vakata_dnd.scroll_l = -1; }

6833

<><\/li\> }

6834

<><\/li\> if(vakata_dnd.scroll_t || vakata_dnd.scroll_l) {

6835

<><\/li\> vakata_dnd.scroll_e = $(this);

6836

<><\/li\> return false;

<><\/li\> }

<><\/li\> });

<><\/li\> if(!vakata_dnd.scroll_e) {

6841

<><\/li\> d = $(document); w = $(window);

6842

<><\/li\> dh = d.height(); wh = w.height();

6843

<><\/li\> dw = d.width(); ww = w.width();

6844

<><\/li\> dt = d.scrollTop(); dl = d.scrollLeft();

6845

<><\/li\> if(dh > wh && e.pageY - dt < $.vakata.dnd.settings.scroll_proximity) { vakata_dnd.scroll_t = -1; }

6846

<><\/li\> if(dh > wh && wh - (e.pageY - dt) < $.vakata.dnd.settings.scroll_proximity) { vakata_dnd.scroll_t = 1; }

6847

<><\/li\> if(dw > ww && e.pageX - dl < $.vakata.dnd.settings.scroll_proximity) { vakata_dnd.scroll_l = -1; }

6848

<><\/li\> if(dw > ww && ww - (e.pageX - dl) < $.vakata.dnd.settings.scroll_proximity) { vakata_dnd.scroll_l = 1; }

6849

<><\/li\> if(vakata_dnd.scroll_t || vakata_dnd.scroll_l) {

6850

<><\/li\> vakata_dnd.scroll_e = d;

6851

<><\/li\> }

6852

<><\/li\> }

6853

<><\/li\> if(vakata_dnd.scroll_e) { $.vakata.dnd._scroll(true); }

6854

6855

<><\/li\> if(vakata_dnd.helper) {

6856

<><\/li\> ht = parseInt(e.pageY + $.vakata.dnd.settings.helper_top, 10);

6857

<><\/li\> hl = parseInt(e.pageX + $.vakata.dnd.settings.helper_left, 10);

6858

<><\/li\> if(dh && ht + 25 > dh) { ht = dh - 50; }

6859

<><\/li\> if(dw && hl + vakata_dnd.helper_w > dw) { hl = dw - (vakata_dnd.helper_w + 2); }

6860

<><\/li\> vakata_dnd.helper.css({

6861

<><\/li\> left : hl + "px",

6862

<><\/li\> top : ht + "px"

<><\/li\> });

<><\/li\> }

<><\/li\> /**

<><\/li\> * triggered on the document when a drag is in progress

6867

<><\/li\> * @event

6868

<><\/li\> * @plugin dnd

6869

<><\/li\> * @name dnd_move.vakata

6870

<><\/li\> * @param {Mixed} data any data supplied with the call to $.vakata.dnd.start

6871

<><\/li\> * @param {DOM} element the DOM element being dragged

6872

<><\/li\> * @param {jQuery} helper the helper shown next to the mouse

6873

<><\/li\> * @param {Object} event the event that caused this to trigger (most likely mousemove)

6874

<><\/li\> */

6875

<><\/li\> $.vakata.dnd._trigger("move", e);

6876

<><\/li\> return false;

6877

<><\/li\> },

6878

<><\/li\> stop : function (e) {

6879

<><\/li\>				if(e.type === "touchend" && e.originalEvent && e.originalEvent.changedTouches && e.originalEvent.changedTouches[0]) {

6880

<><\/li\> e.pageX = e.originalEvent.changedTouches[0].pageX;

6881

<><\/li\> e.pageY = e.originalEvent.changedTouches[0].pageY;

6882

<><\/li\>					e.target = document.elementFromPoint(e.originalEvent.changedTouches[0].pageX - window.pageXOffset, e.originalEvent.changedTouches[0].pageY - window.pageYOffset);

6883

<><\/li\> }

6884

<><\/li\> if(vakata_dnd.is_drag) {

6885

<><\/li\> /**

6886

<><\/li\> * triggered on the document when a drag stops (the dragged element is dropped)

6887

<><\/li\> * @event

6888

<><\/li\> * @plugin dnd

6889

<><\/li\> * @name dnd_stop.vakata

6890

<><\/li\> * @param {Mixed} data any data supplied with the call to $.vakata.dnd.start

6891

<><\/li\> * @param {DOM} element the DOM element being dragged

6892

<><\/li\> * @param {jQuery} helper the helper shown next to the mouse

6893

<><\/li\> * @param {Object} event the event that caused the stop

6894

<><\/li\> */

6895

<><\/li\> if (e.target !== vakata_dnd.target) {

6896

<><\/li\> $(vakata_dnd.target).off('click.vakata');

6897

<><\/li\> }

6898

<><\/li\> $.vakata.dnd._trigger("stop", e);

6899

<><\/li\> }

6900

<><\/li\> else {

6901

<><\/li\> if(e.type === "touchend" && e.target === vakata_dnd.target) {

6902

<><\/li\> var to = setTimeout(function () { $(e.target).click(); }, 100);

6903

<><\/li\> $(e.target).one('click', function() { if(to) { clearTimeout(to); } });

6904

<><\/li\> }

6905

<><\/li\> }

6906

<><\/li\> $.vakata.dnd._clean();

6907

<><\/li\> return false;

<><\/li\> }

<><\/li\> };

<><\/li\> }($));

<><\/li\> // include the dnd plugin by default

6913

<><\/li\> // $.jstree.defaults.plugins.push("dnd");

<><\/li\>/**

<><\/li\> * ### Massload plugin

6918

<><\/li\> *

6919

<><\/li\> * Adds massload functionality to jsTree, so that multiple nodes can be loaded in a single request (only useful with lazy loading).

<><\/li\> */

<><\/li\> /**

<><\/li\> * massload configuration

6924

<><\/li\> *

6925

<><\/li\> * It is possible to set this to a standard jQuery-like AJAX config.

6926

<><\/li\>	 * In addition to the standard jQuery ajax options here you can supply functions for `data` and `url`, the functions will be run in the current instance's scope and a param will be passed indicating which node IDs need to be loaded, the return value of those functions will be used.

6927

<><\/li\> *

6928

<><\/li\>	 * You can also set this to a function, that function will receive the node IDs being loaded as argument and a second param which is a function (callback) which should be called with the result.

6929

<><\/li\> *

6930

<><\/li\>	 * Both the AJAX and the function approach rely on the same return value - an object where the keys are the node IDs, and the value is the children of that node as an array.

6931

<><\/li\> *

6932

<><\/li\> * {

6933

<><\/li\> * "id1" : [{ "text" : "Child of ID1", "id" : "c1" }, { "text" : "Another child of ID1", "id" : "c2" }],

6934

<><\/li\> * "id2" : [{ "text" : "Child of ID2", "id" : "c3" }]

6935

<><\/li\> * }

6936

<><\/li\> *

6937

<><\/li\> * @name $.jstree.defaults.massload

6938

<><\/li\> * @plugin massload

6939

<><\/li\> */

6940

<><\/li\> $.jstree.defaults.massload = null;

6941

<><\/li\> $.jstree.plugins.massload = function (options, parent) {

6942

<><\/li\> this.init = function (el, options) {

6943

<><\/li\> this._data.massload = {};

6944

<><\/li\> parent.init.call(this, el, options);

6945

<><\/li\> };

6946

<><\/li\> this._load_nodes = function (nodes, callback, is_callback, force_reload) {

6947

<><\/li\> var s = this.settings.massload,

6948

<><\/li\> nodesString = JSON.stringify(nodes),

6949

<><\/li\> toLoad = [],

6950

<><\/li\> m = this._model.data,

6951

<><\/li\> i, j, dom;

6952

<><\/li\> if (!is_callback) {

6953

<><\/li\> for(i = 0, j = nodes.length; i < j; i++) {

6954

<><\/li\> if(!m[nodes[i]] || ( (!m[nodes[i]].state.loaded && !m[nodes[i]].state.failed) || force_reload) ) {

6955

<><\/li\> toLoad.push(nodes[i]);

6956

<><\/li\> dom = this.get_node(nodes[i], true);

6957

<><\/li\> if (dom && dom.length) {

6958

<><\/li\> dom.addClass("jstree-loading").attr('aria-busy',true);

<><\/li\> }

<><\/li\> }

<><\/li\> }

<><\/li\> this._data.massload = {};

6963

<><\/li\> if (toLoad.length) {

6964

<><\/li\> if($.isFunction(s)) {

6965

<><\/li\> return s.call(this, toLoad, $.proxy(function (data) {

6966

<><\/li\> var i, j;

6967

<><\/li\> if(data) {

6968

<><\/li\> for(i in data) {

6969

<><\/li\> if(data.hasOwnProperty(i)) {

6970

<><\/li\> this._data.massload[i] = data[i];

<><\/li\> }

<><\/li\> }

<><\/li\> }

<><\/li\> for(i = 0, j = nodes.length; i < j; i++) {

6975

<><\/li\> dom = this.get_node(nodes[i], true);

6976

<><\/li\> if (dom && dom.length) {

6977

<><\/li\> dom.removeClass("jstree-loading").attr('aria-busy',false);

6978

<><\/li\> }

6979

<><\/li\> }

6980

<><\/li\> parent._load_nodes.call(this, nodes, callback, is_callback, force_reload);

6981

<><\/li\> }, this));

6982

<><\/li\> }

6983

<><\/li\> if(typeof s === 'object' && s && s.url) {

6984

<><\/li\> s = $.extend(true, {}, s);

6985

<><\/li\> if($.isFunction(s.url)) {

6986

<><\/li\> s.url = s.url.call(this, toLoad);

6987

<><\/li\> }

6988

<><\/li\> if($.isFunction(s.data)) {

6989

<><\/li\> s.data = s.data.call(this, toLoad);

6990

<><\/li\> }

6991

<><\/li\> return $.ajax(s)

6992

<><\/li\> .done($.proxy(function (data,t,x) {

6993

<><\/li\> var i, j;

6994

<><\/li\> if(data) {

6995

<><\/li\> for(i in data) {

6996

<><\/li\> if(data.hasOwnProperty(i)) {

6997

<><\/li\> this._data.massload[i] = data[i];

<><\/li\> }

<><\/li\> }

<><\/li\> }

<><\/li\> for(i = 0, j = nodes.length; i < j; i++) {

7002

<><\/li\> dom = this.get_node(nodes[i], true);

7003

<><\/li\> if (dom && dom.length) {

7004

<><\/li\> dom.removeClass("jstree-loading").attr('aria-busy',false);

7005

<><\/li\> }

7006

<><\/li\> }

7007

<><\/li\> parent._load_nodes.call(this, nodes, callback, is_callback, force_reload);

7008

<><\/li\> }, this))

7009

<><\/li\> .fail($.proxy(function (f) {

7010

<><\/li\> parent._load_nodes.call(this, nodes, callback, is_callback, force_reload);

7011

<><\/li\> }, this));

<><\/li\> }

<><\/li\> }

<><\/li\> }

<><\/li\> return parent._load_nodes.call(this, nodes, callback, is_callback, force_reload);

7016

<><\/li\> };

7017

<><\/li\> this._load_node = function (obj, callback) {

7018

<><\/li\> var data = this._data.massload[obj.id],

7019

<><\/li\> rslt = null, dom;

7020

<><\/li\> if(data) {

7021

<><\/li\> rslt = this[typeof data === 'string' ? '_append_html_data' : '_append_json_data'](

7022

<><\/li\> obj,

7023

<><\/li\>					typeof data === 'string' ? $($.parseHTML(data)).filter(function () { return this.nodeType !== 3; }) : data,

7024

<><\/li\> function (status) { callback.call(this, status); }

7025

<><\/li\> );

7026

<><\/li\> dom = this.get_node(obj.id, true);

7027

<><\/li\> if (dom && dom.length) {

7028

<><\/li\> dom.removeClass("jstree-loading").attr('aria-busy',false);

7029

<><\/li\> }

7030

<><\/li\> delete this._data.massload[obj.id];

7031

<><\/li\> return rslt;

7032

<><\/li\> }

7033

<><\/li\> return parent._load_node.call(this, obj, callback);

<><\/li\> };

<><\/li\> };

<><\/li\>/**

<><\/li\> * ### Search plugin

7039

<><\/li\> *

7040

<><\/li\> * Adds search functionality to jsTree.

<><\/li\> */

<><\/li\> /**

<><\/li\> * stores all defaults for the search plugin

7045

<><\/li\> * @name $.jstree.defaults.search

7046

<><\/li\> * @plugin search

7047

<><\/li\> */

7048

<><\/li\> $.jstree.defaults.search = {

7049

<><\/li\> /**

7050

<><\/li\> * a jQuery-like AJAX config, which jstree uses if a server should be queried for results.

7051

<><\/li\> *

7052

<><\/li\>		 * A `str` (which is the search string) parameter will be added with the request, an optional `inside` parameter will be added if the search is limited to a node id. The expected result is a JSON array with nodes that need to be opened so that matching nodes will be revealed.

7053

<><\/li\>		 * Leave this setting as `false` to not query the server. You can also set this to a function, which will be invoked in the instance's scope and receive 3 parameters - the search string, the callback to call with the array of nodes to load, and the optional node ID to limit the search to

7054

<><\/li\> * @name $.jstree.defaults.search.ajax

7055

<><\/li\> * @plugin search

7056

<><\/li\> */

7057

<><\/li\> ajax : false,

7058

<><\/li\> /**

7059

<><\/li\> * Indicates if the search should be fuzzy or not (should `chnd3` match `child node 3`). Default is `false`.

7060

<><\/li\> * @name $.jstree.defaults.search.fuzzy

7061

<><\/li\> * @plugin search

7062

<><\/li\> */

7063

<><\/li\> fuzzy : false,

7064

<><\/li\> /**

7065

<><\/li\> * Indicates if the search should be case sensitive. Default is `false`.

7066

<><\/li\> * @name $.jstree.defaults.search.case_sensitive

7067

<><\/li\> * @plugin search

7068

<><\/li\> */

7069

<><\/li\> case_sensitive : false,

7070

<><\/li\> /**

7071

<><\/li\>		 * Indicates if the tree should be filtered (by default) to show only matching nodes (keep in mind this can be a heavy on large trees in old browsers).

7072

<><\/li\> * This setting can be changed at runtime when calling the search method. Default is `false`.

7073

<><\/li\> * @name $.jstree.defaults.search.show_only_matches

7074

<><\/li\> * @plugin search

7075

<><\/li\> */

7076

<><\/li\> show_only_matches : false,

7077

<><\/li\> /**

7078

<><\/li\> * Indicates if the children of matched element are shown (when show_only_matches is true)

7079

<><\/li\> * This setting can be changed at runtime when calling the search method. Default is `false`.

7080

<><\/li\> * @name $.jstree.defaults.search.show_only_matches_children

7081

<><\/li\> * @plugin search

7082

<><\/li\> */

7083

<><\/li\> show_only_matches_children : false,

7084

<><\/li\> /**

7085

<><\/li\>		 * Indicates if all nodes opened to reveal the search result, should be closed when the search is cleared or a new search is performed. Default is `true`.

7086

<><\/li\> * @name $.jstree.defaults.search.close_opened_onclear

7087

<><\/li\> * @plugin search

7088

<><\/li\> */

7089

<><\/li\> close_opened_onclear : true,

7090

<><\/li\> /**

7091

<><\/li\> * Indicates if only leaf nodes should be included in search results. Default is `false`.

7092

<><\/li\> * @name $.jstree.defaults.search.search_leaves_only

7093

<><\/li\> * @plugin search

7094

<><\/li\> */

7095

<><\/li\> search_leaves_only : false,

7096

<><\/li\> /**

7097

<><\/li\>		 * If set to a function it wil be called in the instance's scope with two arguments - search string and node (where node will be every node in the structure, so use with caution).

7098

<><\/li\>		 * If the function returns a truthy value the node will be considered a match (it might not be displayed if search_only_leaves is set to true and the node is not a leaf). Default is `false`.

7099

<><\/li\> * @name $.jstree.defaults.search.search_callback

7100

<><\/li\> * @plugin search

7101

<><\/li\> */

7102

<><\/li\> search_callback : false

7103

<><\/li\> };

7104

7105

<><\/li\> $.jstree.plugins.search = function (options, parent) {

7106

<><\/li\> this.bind = function () {

7107

<><\/li\> parent.bind.call(this);

7108

7109

<><\/li\> this._data.search.str = "";

7110

<><\/li\> this._data.search.dom = $();

7111

<><\/li\> this._data.search.res = [];

7112

<><\/li\> this._data.search.opn = [];

7113

<><\/li\> this._data.search.som = false;

7114

<><\/li\> this._data.search.smc = false;

7115

<><\/li\> this._data.search.hdn = [];

7116

7117

<><\/li\> this.element

7118

<><\/li\> .on("search.jstree", $.proxy(function (e, data) {

7119

<><\/li\> if(this._data.search.som && data.res.length) {

7120

<><\/li\> var m = this._model.data, i, j, p = [], k, l;

7121

<><\/li\> for(i = 0, j = data.res.length; i < j; i++) {

7122

<><\/li\> if(m[data.res[i]] && !m[data.res[i]].state.hidden) {

7123

<><\/li\> p.push(data.res[i]);

7124

<><\/li\> p = p.concat(m[data.res[i]].parents);

7125

<><\/li\> if(this._data.search.smc) {

7126

<><\/li\> for (k = 0, l = m[data.res[i]].children_d.length; k < l; k++) {

7127

<><\/li\> if (m[m[data.res[i]].children_d[k]] && !m[m[data.res[i]].children_d[k]].state.hidden) {

7128

<><\/li\> p.push(m[data.res[i]].children_d[k]);

<><\/li\> }

<><\/li\> }

<><\/li\> }

<><\/li\> }

<><\/li\> }

<><\/li\> p = $.vakata.array_remove_item($.vakata.array_unique(p), $.jstree.root);

7135

<><\/li\> this._data.search.hdn = this.hide_all(true);

7136

<><\/li\> this.show_node(p, true);

7137

<><\/li\> this.redraw(true);

7138

<><\/li\> }

7139

<><\/li\> }, this))

7140

<><\/li\> .on("clear_search.jstree", $.proxy(function (e, data) {

7141

<><\/li\> if(this._data.search.som && data.res.length) {

7142

<><\/li\> this.show_node(this._data.search.hdn, true);

7143

<><\/li\> this.redraw(true);

7144

<><\/li\> }

7145

<><\/li\> }, this));

7146

<><\/li\> };

7147

<><\/li\> /**

7148

<><\/li\> * used to search the tree nodes for a given string

7149

<><\/li\> * @name search(str [, skip_async])

7150

<><\/li\> * @param {String} str the search string

7151

<><\/li\> * @param {Boolean} skip_async if set to true server will not be queried even if configured

7152

<><\/li\>		 * @param {Boolean} show_only_matches if set to true only matching nodes will be shown (keep in mind this can be very slow on large trees or old browsers)

7153

<><\/li\> * @param {mixed} inside an optional node to whose children to limit the search

7154

<><\/li\> * @param {Boolean} append if set to true the results of this search are appended to the previous search

7155

<><\/li\> * @plugin search

7156

<><\/li\> * @trigger search.jstree

7157

<><\/li\> */

7158

<><\/li\> this.search = function (str, skip_async, show_only_matches, inside, append, show_only_matches_children) {

7159

<><\/li\> if(str === false || $.trim(str.toString()) === "") {

7160

<><\/li\> return this.clear_search();

7161

<><\/li\> }

7162

<><\/li\> inside = this.get_node(inside);

7163

<><\/li\> inside = inside && inside.id ? inside.id : null;

7164

<><\/li\> str = str.toString();

7165

<><\/li\> var s = this.settings.search,

7166

<><\/li\> a = s.ajax ? s.ajax : false,

7167

<><\/li\> m = this._model.data,

7168

<><\/li\> f = null,

7169

<><\/li\> r = [],

7170

<><\/li\> p = [], i, j;

7171

<><\/li\> if(this._data.search.res.length && !append) {

7172

<><\/li\> this.clear_search();

7173

<><\/li\> }

7174

<><\/li\> if(show_only_matches === undefined) {

7175

<><\/li\> show_only_matches = s.show_only_matches;

7176

<><\/li\> }

7177

<><\/li\> if(show_only_matches_children === undefined) {

7178

<><\/li\> show_only_matches_children = s.show_only_matches_children;

7179

<><\/li\> }

7180

<><\/li\> if(!skip_async && a !== false) {

7181

<><\/li\> if($.isFunction(a)) {

7182

<><\/li\> return a.call(this, str, $.proxy(function (d) {

7183

<><\/li\> if(d && d.d) { d = d.d; }

7184

<><\/li\> this._load_nodes(!$.isArray(d) ? [] : $.vakata.array_unique(d), function () {

7185

<><\/li\> this.search(str, true, show_only_matches, inside, append);

7186

<><\/li\> });

7187

<><\/li\> }, this), inside);

7188

<><\/li\> }

7189

<><\/li\> else {

7190

<><\/li\> a = $.extend({}, a);

7191

<><\/li\> if(!a.data) { a.data = {}; }

7192

<><\/li\> a.data.str = str;

7193

<><\/li\> if(inside) {

7194

<><\/li\> a.data.inside = inside;

7195

<><\/li\> }

7196

<><\/li\> return $.ajax(a)

7197

<><\/li\> .fail($.proxy(function () {

7198

<><\/li\>							this._data.core.last_error = { 'error' : 'ajax', 'plugin' : 'search', 'id' : 'search_01', 'reason' : 'Could not load search parents', 'data' : JSON.stringify(a) };

7199

<><\/li\> this.settings.core.error.call(this, this._data.core.last_error);

7200

<><\/li\> }, this))

7201

<><\/li\> .done($.proxy(function (d) {

7202

<><\/li\> if(d && d.d) { d = d.d; }

7203

<><\/li\> this._load_nodes(!$.isArray(d) ? [] : $.vakata.array_unique(d), function () {

7204

<><\/li\> this.search(str, true, show_only_matches, inside, append);

7205

<><\/li\> });

7206

<><\/li\> }, this));

7207

<><\/li\> }

7208

<><\/li\> }

7209

<><\/li\> if(!append) {

7210

<><\/li\> this._data.search.str = str;

7211

<><\/li\> this._data.search.dom = $();

7212

<><\/li\> this._data.search.res = [];

7213

<><\/li\> this._data.search.opn = [];

7214

<><\/li\> this._data.search.som = show_only_matches;

7215

<><\/li\> this._data.search.smc = show_only_matches_children;

7216

<><\/li\> }

7217

7218

<><\/li\> f = new $.vakata.search(str, true, { caseSensitive : s.case_sensitive, fuzzy : s.fuzzy });

7219

<><\/li\> $.each(m[inside ? inside : $.jstree.root].children_d, function (ii, i) {

7220

<><\/li\> var v = m[i];

7221

<><\/li\>				if(v.text && !v.state.hidden && (!s.search_leaves_only || (v.state.loaded && v.children.length === 0)) && ( (s.search_callback && s.search_callback.call(this, str, v)) || (!s.search_callback && f.search(v.text).isMatch) ) ) {

7222

<><\/li\> r.push(i);

7223

<><\/li\> p = p.concat(v.parents);

7224

<><\/li\> }

7225

<><\/li\> });

7226

<><\/li\> if(r.length) {

7227

<><\/li\> p = $.vakata.array_unique(p);

7228

<><\/li\> for(i = 0, j = p.length; i < j; i++) {

7229

<><\/li\> if(p[i] !== $.jstree.root && m[p[i]] && this.open_node(p[i], null, 0) === true) {

7230

<><\/li\> this._data.search.opn.push(p[i]);

7231

<><\/li\> }

7232

<><\/li\> }

7233

<><\/li\> if(!append) {

7234

<><\/li\>					this._data.search.dom = $(this.element[0].querySelectorAll('#' + $.map(r, function (v) { return "0123456789".indexOf(v[0]) !== -1 ? '\\3' + v[0] + ' ' + v.substr(1).replace($.jstree.idregex,'\\$&') : v.replace($.jstree.idregex,'\\$&'); }).join(', #')));

7235

<><\/li\> this._data.search.res = r;

7236

<><\/li\> }

7237

<><\/li\> else {

7238

<><\/li\>					this._data.search.dom = this._data.search.dom.add($(this.element[0].querySelectorAll('#' + $.map(r, function (v) { return "0123456789".indexOf(v[0]) !== -1 ? '\\3' + v[0] + ' ' + v.substr(1).replace($.jstree.idregex,'\\$&') : v.replace($.jstree.idregex,'\\$&'); }).join(', #'))));

7239

<><\/li\> this._data.search.res = $.vakata.array_unique(this._data.search.res.concat(r));

7240

<><\/li\> }

7241

<><\/li\> this._data.search.dom.children(".jstree-anchor").addClass('jstree-search');

7242

<><\/li\> }

7243

<><\/li\> /**

7244

<><\/li\> * triggered after search is complete

7245

<><\/li\> * @event

7246

<><\/li\> * @name search.jstree

7247

<><\/li\> * @param {jQuery} nodes a jQuery collection of matching nodes

7248

<><\/li\> * @param {String} str the search string

7249

<><\/li\> * @param {Array} res a collection of objects represeing the matching nodes

7250

<><\/li\> * @plugin search

7251

<><\/li\> */

7252

<><\/li\>			this.trigger('search', { nodes : this._data.search.dom, str : str, res : this._data.search.res, show_only_matches : show_only_matches });

7253

<><\/li\> };

7254

<><\/li\> /**

7255

<><\/li\> * used to clear the last search (removes classes and shows all nodes if filtering is on)

7256

<><\/li\> * @name clear_search()

7257

<><\/li\> * @plugin search

7258

<><\/li\> * @trigger clear_search.jstree

7259

<><\/li\> */

7260

<><\/li\> this.clear_search = function () {

7261

<><\/li\> if(this.settings.search.close_opened_onclear) {

7262

<><\/li\> this.close_node(this._data.search.opn, 0);

7263

<><\/li\> }

7264

<><\/li\> /**

7265

<><\/li\> * triggered after search is complete

7266

<><\/li\> * @event

7267

<><\/li\> * @name clear_search.jstree

7268

<><\/li\> * @param {jQuery} nodes a jQuery collection of matching nodes (the result from the last search)

7269

<><\/li\> * @param {String} str the search string (the last search string)

7270

<><\/li\>			 * @param {Array} res a collection of objects represeing the matching nodes (the result from the last search)

7271

<><\/li\> * @plugin search

7272

<><\/li\> */

7273

<><\/li\>			this.trigger('clear_search', { 'nodes' : this._data.search.dom, str : this._data.search.str, res : this._data.search.res });

7274

<><\/li\> if(this._data.search.res.length) {

7275

<><\/li\>				this._data.search.dom = $(this.element[0].querySelectorAll('#' + $.map(this._data.search.res, function (v) {

7276

<><\/li\>					return "0123456789".indexOf(v[0]) !== -1 ? '\\3' + v[0] + ' ' + v.substr(1).replace($.jstree.idregex,'\\$&') : v.replace($.jstree.idregex,'\\$&');

7277

<><\/li\> }).join(', #')));

7278

<><\/li\> this._data.search.dom.children(".jstree-anchor").removeClass("jstree-search");

7279

<><\/li\> }

7280

<><\/li\> this._data.search.str = "";

7281

<><\/li\> this._data.search.res = [];

7282

<><\/li\> this._data.search.opn = [];

7283

<><\/li\> this._data.search.dom = $();

7284

<><\/li\> };

7285

7286

<><\/li\> this.redraw_node = function(obj, deep, callback, force_render) {

7287

<><\/li\> obj = parent.redraw_node.apply(this, arguments);

7288

<><\/li\> if(obj) {

7289

<><\/li\> if($.inArray(obj.id, this._data.search.res) !== -1) {

7290

<><\/li\> var i, j, tmp = null;

7291

<><\/li\> for(i = 0, j = obj.childNodes.length; i < j; i++) {

7292

<><\/li\>						if(obj.childNodes[i] && obj.childNodes[i].className && obj.childNodes[i].className.indexOf("jstree-anchor") !== -1) {

7293

<><\/li\> tmp = obj.childNodes[i];

<><\/li\> break;

<><\/li\> }

<><\/li\> }

<><\/li\> if(tmp) {

7298

<><\/li\> tmp.className += ' jstree-search';

<><\/li\> }

<><\/li\> }

<><\/li\> }

<><\/li\> return obj;

<><\/li\> };

<><\/li\> };

<><\/li\> // helpers

7307

<><\/li\> (function ($) {

7308

<><\/li\> // from http://kiro.me/projects/fuse.html

7309

<><\/li\> $.vakata.search = function(pattern, txt, options) {

7310

<><\/li\> options = options || {};

7311

<><\/li\> options = $.extend({}, $.vakata.search.defaults, options);

7312

<><\/li\> if(options.fuzzy !== false) {

7313

<><\/li\> options.fuzzy = true;

7314

<><\/li\> }

7315

<><\/li\> pattern = options.caseSensitive ? pattern : pattern.toLowerCase();

7316

<><\/li\> var MATCH_LOCATION = options.location,

7317

<><\/li\> MATCH_DISTANCE = options.distance,

7318

<><\/li\> MATCH_THRESHOLD = options.threshold,

7319

<><\/li\> patternLen = pattern.length,

7320

<><\/li\> matchmask, pattern_alphabet, match_bitapScore, search;

7321

<><\/li\> if(patternLen > 32) {

7322

<><\/li\> options.fuzzy = false;

7323

<><\/li\> }

7324

<><\/li\> if(options.fuzzy) {

7325

<><\/li\> matchmask = 1 << (patternLen - 1);

7326

<><\/li\> pattern_alphabet = (function () {

7327

<><\/li\> var mask = {},

7328

<><\/li\> i = 0;

7329

<><\/li\> for (i = 0; i < patternLen; i++) {

7330

<><\/li\> mask[pattern.charAt(i)] = 0;

7331

<><\/li\> }

7332

<><\/li\> for (i = 0; i < patternLen; i++) {

7333

<><\/li\> mask[pattern.charAt(i)] |= 1 << (patternLen - i - 1);

7334

<><\/li\> }

7335

<><\/li\> return mask;

7336

<><\/li\> }());

7337

<><\/li\> match_bitapScore = function (e, x) {

7338

<><\/li\> var accuracy = e / patternLen,

7339

<><\/li\> proximity = Math.abs(MATCH_LOCATION - x);

7340

<><\/li\> if(!MATCH_DISTANCE) {

7341

<><\/li\> return proximity ? 1.0 : accuracy;

7342

<><\/li\> }

7343

<><\/li\> return accuracy + (proximity / MATCH_DISTANCE);

7344

<><\/li\> };

7345

<><\/li\> }

7346

<><\/li\> search = function (text) {

7347

<><\/li\> text = options.caseSensitive ? text : text.toLowerCase();

7348

<><\/li\> if(pattern === text || text.indexOf(pattern) !== -1) {

7349

<><\/li\> return {

7350

<><\/li\> isMatch: true,

<><\/li\> score: 0

<><\/li\> };

<><\/li\> }

<><\/li\> if(!options.fuzzy) {

7355

<><\/li\> return {

7356

<><\/li\> isMatch: false,

<><\/li\> score: 1

<><\/li\> };

<><\/li\> }

<><\/li\> var i, j,

7361

<><\/li\> textLen = text.length,

7362

<><\/li\> scoreThreshold = MATCH_THRESHOLD,

7363

<><\/li\> bestLoc = text.indexOf(pattern, MATCH_LOCATION),

7364

<><\/li\> binMin, binMid,

7365

<><\/li\> binMax = patternLen + textLen,

7366

<><\/li\> lastRd, start, finish, rd, charMatch,

7367

<><\/li\> score = 1,

7368

<><\/li\> locations = [];

7369

<><\/li\> if (bestLoc !== -1) {

7370

<><\/li\> scoreThreshold = Math.min(match_bitapScore(0, bestLoc), scoreThreshold);

7371

<><\/li\> bestLoc = text.lastIndexOf(pattern, MATCH_LOCATION + patternLen);

7372

<><\/li\> if (bestLoc !== -1) {

7373

<><\/li\> scoreThreshold = Math.min(match_bitapScore(0, bestLoc), scoreThreshold);

7374

<><\/li\> }

7375

<><\/li\> }

7376

<><\/li\> bestLoc = -1;

7377

<><\/li\> for (i = 0; i < patternLen; i++) {

7378

<><\/li\> binMin = 0;

7379

<><\/li\> binMid = binMax;

7380

<><\/li\> while (binMin < binMid) {

7381

<><\/li\> if (match_bitapScore(i, MATCH_LOCATION + binMid) <= scoreThreshold) {

7382

<><\/li\> binMin = binMid;

7383

<><\/li\> } else {

7384

<><\/li\> binMax = binMid;

7385

<><\/li\> }

7386

<><\/li\> binMid = Math.floor((binMax - binMin) / 2 + binMin);

7387

<><\/li\> }

7388

<><\/li\> binMax = binMid;

7389

<><\/li\> start = Math.max(1, MATCH_LOCATION - binMid + 1);

7390

<><\/li\> finish = Math.min(MATCH_LOCATION + binMid, textLen) + patternLen;

7391

<><\/li\> rd = new Array(finish + 2);

7392

<><\/li\> rd[finish + 1] = (1 << i) - 1;

7393

<><\/li\><< i) - 1;< i) - 1; for (j = finish; j >= start; j--) {

7394

<><\/li\><< i) - 1;< i) - 1; charMatch = pattern_alphabet[text.charAt(j - 1)];

7395

<><\/li\><< i) - 1;< i) - 1; if (i === 0) {

7396

<><\/li\><< i) - 1;< i) - 1; rd[j] = ((rd[j + 1] << 1) | 1) & charMatch;

7397

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch; } else {

7398

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;							rd[j] = ((rd[j + 1] << 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];

7399

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];						}

7400

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];						if (rd[j] & matchmask) {

7401

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];							score = match_bitapScore(i, j - 1);

7402

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];							if (score <= scoreThreshold) {

7403

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {								scoreThreshold = score;

7404

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {								bestLoc = j - 1;

7405

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {								locations.push(bestLoc);

7406

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {								if (bestLoc > MATCH_LOCATION) {

7407

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {									start = Math.max(1, 2 * MATCH_LOCATION - bestLoc);

7408

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {								} else {

7409

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {									break;

7410

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {								}

7411

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {							}

7412

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {						}

7413

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {					}

7414

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {					if (match_bitapScore(i + 1, MATCH_LOCATION) > scoreThreshold) {

7415

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {						break;

7416

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {					}

7417

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {					lastRd = rd;

7418

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {				}

7419

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {				return {

7420

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {					isMatch: bestLoc >= 0,

7421

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {					score: score

7422

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {				};

7423

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {			};

7424

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {			return txt === true ? { 'search' : search } : search(txt);

7425

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {		};

7426

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {		$.vakata.search.defaults = {

7427

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {			location : 0,

7428

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {			distance : 100,

7429

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {			threshold : 0.6,

7430

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {			fuzzy : false,

7431

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {			caseSensitive : false

7432

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {		};

7433

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {	}($));

7434

7435

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {	// include the search plugin by default

7436

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {	// $.jstree.defaults.plugins.push("search");

7437

7438

7439

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {/**

7440

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) { * ### Sort plugin

7441

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) { *

7442

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) { * Automatically sorts all siblings in the tree according to a sorting function.

7443

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) { */

7444

7445

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {	/**

7446

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {	 * the settings function used to sort the nodes.

7447

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {	 * It is executed in the tree's context, accepts two nodes as arguments and should return `1` or `-1`.

7448

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {	 * @name $.jstree.defaults.sort

7449

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {	 * @plugin sort

7450

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {	 */

7451

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {	$.jstree.defaults.sort = function (a, b) {

7452

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {		//return this.get_type(a) === this.get_type(b) ? (this.get_text(a) > this.get_text(b) ? 1 : -1) : this.get_type(a) >= this.get_type(b);

7453

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {		return this.get_text(a) > this.get_text(b) ? 1 : -1;

7454

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {	};

7455

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {	$.jstree.plugins.sort = function (options, parent) {

7456

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {		this.bind = function () {

7457

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {			parent.bind.call(this);

7458

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {			this.element

7459

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {				.on("model.jstree", $.proxy(function (e, data) {

7460

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {						this.sort(data.parent, true);

7461

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {					}, this))

7462

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {				.on("rename_node.jstree create_node.jstree", $.proxy(function (e, data) {

7463

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {						this.sort(data.parent || data.node.parent, false);

7464

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {						this.redraw_node(data.parent || data.node.parent, true);

7465

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {					}, this))

7466

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {				.on("move_node.jstree copy_node.jstree", $.proxy(function (e, data) {

7467

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {						this.sort(data.parent, false);

7468

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {						this.redraw_node(data.parent, true);

7469

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {					}, this));

7470

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {		};

7471

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {		/**

7472

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {		 * used to sort a node's children

7473

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {		 * @private

7474

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {		 * @name sort(obj [, deep])

7475

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {		 * @param  {mixed} obj the node

7476

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {		 * @param {Boolean} deep if set to `true` nodes are sorted recursively.

7477

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {		 * @plugin sort

7478

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {		 * @trigger search.jstree

7479

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {		 */

7480

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {		this.sort = function (obj, deep) {

7481

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {			var i, j;

7482

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {			obj = this.get_node(obj);

7483

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {			if(obj && obj.children && obj.children.length) {

7484

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {				obj.children.sort($.proxy(this.settings.sort, this));

7485

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {				if(deep) {

7486

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {					for(i = 0, j = obj.children_d.length; i < j; i++) {

7487

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {						this.sort(obj.children_d[i], false);

7488

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {					}

7489

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {				}

7490

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			}

7491

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		};

7492

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {	};

7493

7494

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {	// include the sort plugin by default

7495

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {	// $.jstree.defaults.plugins.push("sort");

7496

7497

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {/**

7498

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) { * ### State plugin

7499

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) { *

7500

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) { * Saves the state of the tree (selected nodes, opened nodes) on the user's computer using available options (localStorage, cookies, etc)

7501

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) { */

7502

7503

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {	var to = false;

7504

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {	/**

7505

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {	 * stores all defaults for the state plugin

7506

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {	 * @name $.jstree.defaults.state

7507

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {	 * @plugin state

7508

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {	 */

7509

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {	$.jstree.defaults.state = {

7510

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		/**

7511

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		 * A string for the key to use when saving the current tree (change if using multiple trees in your project). Defaults to `jstree`.

7512

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		 * @name $.jstree.defaults.state.key

7513

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		 * @plugin state

7514

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		 */

7515

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		key		: 'jstree',

7516

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		/**

7517

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		 * A space separated list of events that trigger a state save. Defaults to `changed.jstree open_node.jstree close_node.jstree`.

7518

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		 * @name $.jstree.defaults.state.events

7519

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		 * @plugin state

7520

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		 */

7521

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		events	: 'changed.jstree open_node.jstree close_node.jstree check_node.jstree uncheck_node.jstree',

7522

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		/**

7523

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		 * Time in milliseconds after which the state will expire. Defaults to 'false' meaning - no expire.

7524

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		 * @name $.jstree.defaults.state.ttl

7525

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		 * @plugin state

7526

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		 */

7527

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		ttl		: false,

7528

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		/**

7529

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		 * A function that will be executed prior to restoring state with one argument - the state object. Can be used to clear unwanted parts of the state.

7530

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		 * @name $.jstree.defaults.state.filter

7531

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		 * @plugin state

7532

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		 */

7533

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		filter	: false

7534

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {	};

7535

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {	$.jstree.plugins.state = function (options, parent) {

7536

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		this.bind = function () {

7537

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			parent.bind.call(this);

7538

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			var bind = $.proxy(function () {

7539

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {				this.element.on(this.settings.state.events, $.proxy(function () {

7540

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {					if(to) { clearTimeout(to); }

7541

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {					to = setTimeout($.proxy(function () { this.save_state(); }, this), 100);

7542

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {				}, this));

7543

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {				/**

7544

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {				 * triggered when the state plugin is finished restoring the state (and immediately after ready if there is no state to restore).

7545

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {				 * @event

7546

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {				 * @name state_ready.jstree

7547

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {				 * @plugin state

7548

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {				 */

7549

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {				this.trigger('state_ready');

7550

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			}, this);

7551

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			this.element

7552

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {				.on("ready.jstree", $.proxy(function (e, data) {

7553

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {						this.element.one("restore_state.jstree", bind);

7554

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {						if(!this.restore_state()) { bind(); }

7555

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {					}, this));

7556

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		};

7557

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		/**

7558

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		 * save the state

7559

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		 * @name save_state()

7560

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		 * @plugin state

7561

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		 */

7562

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		this.save_state = function () {

7563

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			var st = { 'state' : this.get_state(), 'ttl' : this.settings.state.ttl, 'sec' : +(new Date()) };

7564

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			$.vakata.storage.set(this.settings.state.key, JSON.stringify(st));

7565

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		};

7566

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		/**

7567

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		 * restore the state from the user's computer

7568

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		 * @name restore_state()

7569

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		 * @plugin state

7570

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		 */

7571

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		this.restore_state = function () {

7572

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			var k = $.vakata.storage.get(this.settings.state.key);

7573

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			if(!!k) { try { k = JSON.parse(k); } catch(ex) { return false; } }

7574

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			if(!!k && k.ttl && k.sec && +(new Date()) - k.sec > k.ttl) { return false; }

7575

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			if(!!k && k.state) { k = k.state; }

7576

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			if(!!k && $.isFunction(this.settings.state.filter)) { k = this.settings.state.filter.call(this, k); }

7577

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			if(!!k) {

7578

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {				this.element.one("set_state.jstree", function (e, data) { data.instance.trigger('restore_state', { 'state' : $.extend(true, {}, k) }); });

7579

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {				this.set_state(k);

7580

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {				return true;

7581

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			}

7582

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			return false;

7583

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		};

7584

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		/**

7585

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		 * clear the state on the user's computer

7586

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		 * @name clear_state()

7587

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		 * @plugin state

7588

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		 */

7589

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		this.clear_state = function () {

7590

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			return $.vakata.storage.del(this.settings.state.key);

7591

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		};

7592

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {	};

7593

7594

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {	(function ($, undefined) {

7595

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		$.vakata.storage = {

7596

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			// simply specifying the functions in FF throws an error

7597

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			set : function (key, val) { return window.localStorage.setItem(key, val); },

7598

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			get : function (key) { return window.localStorage.getItem(key); },

7599

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			del : function (key) { return window.localStorage.removeItem(key); }

7600

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		};

7601

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {	}($));

7602

7603

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {	// include the state plugin by default

7604

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {	// $.jstree.defaults.plugins.push("state");

7605

7606

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {/**

7607

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) { * ### Types plugin

7608

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) { *

7609

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) { * Makes it possible to add predefined types for groups of nodes, which make it possible to easily control nesting rules and icon for each group.

7610

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) { */

7611

7612

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {	/**

7613

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {	 * An object storing all types as key value pairs, where the key is the type name and the value is an object that could contain following keys (all optional).

7614

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {	 *

7615

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {	 * * `max_children` the maximum number of immediate children this node type can have. Do not specify or set to `-1` for unlimited.

7616

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {	 * * `max_depth` the maximum number of nesting this node type can have. A value of `1` would mean that the node can have children, but no grandchildren. Do not specify or set to `-1` for unlimited.

7617

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {	 * * `valid_children` an array of node type strings, that nodes of this type can have as children. Do not specify or set to `-1` for no limits.

7618

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {	 * * `icon` a string - can be a path to an icon or a className, if using an image that is in the current directory use a `./` prefix, otherwise it will be detected as a class. Omit to use the default icon from your theme.

7619

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {	 * * `li_attr` an object of values which will be used to add HTML attributes on the resulting LI DOM node (merged with the node's own data)

7620

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {	 * * `a_attr` an object of values which will be used to add HTML attributes on the resulting A DOM node (merged with the node's own data)

7621

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {	 *

7622

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {	 * There are two predefined types:

7623

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {	 *

7624

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {	 * * `#` represents the root of the tree, for example `max_children` would control the maximum number of root nodes.

7625

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {	 * * `default` represents the default node - any settings here will be applied to all nodes that do not have a type specified.

7626

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {	 *

7627

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {	 * @name $.jstree.defaults.types

7628

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {	 * @plugin types

7629

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {	 */

7630

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {	$.jstree.defaults.types = {

7631

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		'default' : {}

7632

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {	};

7633

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {	$.jstree.defaults.types[$.jstree.root] = {};

7634

7635

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {	$.jstree.plugins.types = function (options, parent) {

7636

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		this.init = function (el, options) {

7637

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			var i, j;

7638

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			if(options && options.types && options.types['default']) {

7639

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {				for(i in options.types) {

7640

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {					if(i !== "default" && i !== $.jstree.root && options.types.hasOwnProperty(i)) {

7641

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {						for(j in options.types['default']) {

7642

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {							if(options.types['default'].hasOwnProperty(j) && options.types[i][j] === undefined) {

7643

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {								options.types[i][j] = options.types['default'][j];

7644

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {							}

7645

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {						}

7646

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {					}

7647

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {				}

7648

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			}

7649

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			parent.init.call(this, el, options);

7650

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			this._model.data[$.jstree.root].type = $.jstree.root;

7651

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		};

7652

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		this.refresh = function (skip_loading, forget_state) {

7653

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			parent.refresh.call(this, skip_loading, forget_state);

7654

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			this._model.data[$.jstree.root].type = $.jstree.root;

7655

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		};

7656

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		this.bind = function () {

7657

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			this.element

7658

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {				.on('model.jstree', $.proxy(function (e, data) {

7659

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {						var m = this._model.data,

7660

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {							dpc = data.nodes,

7661

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {							t = this.settings.types,

7662

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {							i, j, c = 'default', k;

7663

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {						for(i = 0, j = dpc.length; i < j; i++) {

7664

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {							c = 'default';

7665

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {							if(m[dpc[i]].original && m[dpc[i]].original.type && t[m[dpc[i]].original.type]) {

7666

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {								c = m[dpc[i]].original.type;

7667

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {							}

7668

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {							if(m[dpc[i]].data && m[dpc[i]].data.jstree && m[dpc[i]].data.jstree.type && t[m[dpc[i]].data.jstree.type]) {

7669

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {								c = m[dpc[i]].data.jstree.type;

7670

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {							}

7671

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {							m[dpc[i]].type = c;

7672

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {							if(m[dpc[i]].icon === true && t[c].icon !== undefined) {

7673

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {								m[dpc[i]].icon = t[c].icon;

7674

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {							}

7675

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {							if(t[c].li_attr !== undefined && typeof t[c].li_attr === 'object') {

7676

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {								for (k in t[c].li_attr) {

7677

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {									if (t[c].li_attr.hasOwnProperty(k)) {

7678

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {										if (k === 'id') {

7679

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {											continue;

7680

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {										}

7681

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {										else if (m[dpc[i]].li_attr[k] === undefined) {

7682

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {											m[dpc[i]].li_attr[k] = t[c].li_attr[k];

7683

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {										}

7684

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {										else if (k === 'class') {

7685

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {											m[dpc[i]].li_attr['class'] = t[c].li_attr['class'] + ' ' + m[dpc[i]].li_attr['class'];

7686

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {										}

7687

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {									}

7688

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {								}

7689

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {							}

7690

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {							if(t[c].a_attr !== undefined && typeof t[c].a_attr === 'object') {

7691

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {								for (k in t[c].a_attr) {

7692

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {									if (t[c].a_attr.hasOwnProperty(k)) {

7693

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {										if (k === 'id') {

7694

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {											continue;

7695

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {										}

7696

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {										else if (m[dpc[i]].a_attr[k] === undefined) {

7697

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {											m[dpc[i]].a_attr[k] = t[c].a_attr[k];

7698

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {										}

7699

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {										else if (k === 'href' && m[dpc[i]].a_attr[k] === '#') {

7700

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {											m[dpc[i]].a_attr['href'] = t[c].a_attr['href'];

7701

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {										}

7702

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {										else if (k === 'class') {

7703

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {											m[dpc[i]].a_attr['class'] = t[c].a_attr['class'] + ' ' + m[dpc[i]].a_attr['class'];

7704

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {										}

7705

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {									}

7706

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {								}

7707

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {							}

7708

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {						}

7709

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {						m[$.jstree.root].type = $.jstree.root;

7710

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {					}, this));

7711

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			parent.bind.call(this);

7712

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		};

7713

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		this.get_json = function (obj, options, flat) {

7714

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			var i, j,

7715

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {				m = this._model.data,

7716

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {				opt = options ? $.extend(true, {}, options, {no_id:false}) : {},

7717

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {				tmp = parent.get_json.call(this, obj, opt, flat);

7718

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			if(tmp === false) { return false; }

7719

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			if($.isArray(tmp)) {

7720

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {				for(i = 0, j = tmp.length; i < j; i++) {

7721

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {					tmp[i].type = tmp[i].id && m[tmp[i].id] && m[tmp[i].id].type ? m[tmp[i].id].type : "default";

7722

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {					if(options && options.no_id) {

7723

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {						delete tmp[i].id;

7724

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {						if(tmp[i].li_attr && tmp[i].li_attr.id) {

7725

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {							delete tmp[i].li_attr.id;

7726

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {						}

7727

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {						if(tmp[i].a_attr && tmp[i].a_attr.id) {

7728

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {							delete tmp[i].a_attr.id;

7729

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {						}

7730

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {					}

7731

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {				}

7732

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			}

7733

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			else {

7734

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {				tmp.type = tmp.id && m[tmp.id] && m[tmp.id].type ? m[tmp.id].type : "default";

7735

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {				if(options && options.no_id) {

7736

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {					tmp = this._delete_ids(tmp);

7737

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {				}

7738

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			}

7739

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			return tmp;

7740

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		};

7741

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		this._delete_ids = function (tmp) {

7742

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			if($.isArray(tmp)) {

7743

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {				for(var i = 0, j = tmp.length; i < j; i++) {

7744

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {					tmp[i] = this._delete_ids(tmp[i]);

7745

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {				}

7746

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {				return tmp;

7747

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			}

7748

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			delete tmp.id;

7749

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			if(tmp.li_attr && tmp.li_attr.id) {

7750

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {				delete tmp.li_attr.id;

7751

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			}

7752

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			if(tmp.a_attr && tmp.a_attr.id) {

7753

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {				delete tmp.a_attr.id;

7754

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			}

7755

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			if(tmp.children && $.isArray(tmp.children)) {

7756

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {				tmp.children = this._delete_ids(tmp.children);

7757

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			}

7758

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			return tmp;

7759

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		};

7760

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		this.check = function (chk, obj, par, pos, more) {

7761

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			if(parent.check.call(this, chk, obj, par, pos, more) === false) { return false; }

7762

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			obj = obj && obj.id ? obj : this.get_node(obj);

7763

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			par = par && par.id ? par : this.get_node(par);

7764

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			var m = obj && obj.id ? (more && more.origin ? more.origin : $.jstree.reference(obj.id)) : null, tmp, d, i, j;

7765

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			m = m && m._model && m._model.data ? m._model.data : null;

7766

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			switch(chk) {

7767

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {				case "create_node":

7768

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {				case "move_node":

7769

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {				case "copy_node":

7770

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {					if(chk !== 'move_node' || $.inArray(obj.id, par.children) === -1) {

7771

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {						tmp = this.get_rules(par);

7772

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {						if(tmp.max_children !== undefined && tmp.max_children !== -1 && tmp.max_children === par.children.length) {

7773

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {							this._data.core.last_error = { 'error' : 'check', 'plugin' : 'types', 'id' : 'types_01', 'reason' : 'max_children prevents function: ' + chk, 'data' : JSON.stringify({ 'chk' : chk, 'pos' : pos, 'obj' : obj && obj.id ? obj.id : false, 'par' : par && par.id ? par.id : false }) };

7774

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {							return false;

7775

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {						}

7776

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {						if(tmp.valid_children !== undefined && tmp.valid_children !== -1 && $.inArray((obj.type || 'default'), tmp.valid_children) === -1) {

7777

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {							this._data.core.last_error = { 'error' : 'check', 'plugin' : 'types', 'id' : 'types_02', 'reason' : 'valid_children prevents function: ' + chk, 'data' : JSON.stringify({ 'chk' : chk, 'pos' : pos, 'obj' : obj && obj.id ? obj.id : false, 'par' : par && par.id ? par.id : false }) };

7778

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {							return false;

7779

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {						}

7780

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {						if(m && obj.children_d && obj.parents) {

7781

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {							d = 0;

7782

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {							for(i = 0, j = obj.children_d.length; i < j; i++) {

7783

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {								d = Math.max(d, m[obj.children_d[i]].parents.length);

7784

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {							}

7785

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {							d = d - obj.parents.length + 1;

7786

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {						}

7787

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {						if(d <= 0 || d === undefined) { d = 1; }

7788

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {						do {

7789

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {							if(tmp.max_depth !== undefined && tmp.max_depth !== -1 && tmp.max_depth < d) {

7790

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {								this._data.core.last_error = { 'error' : 'check', 'plugin' : 'types', 'id' : 'types_03', 'reason' : 'max_depth prevents function: ' + chk, 'data' : JSON.stringify({ 'chk' : chk, 'pos' : pos, 'obj' : obj && obj.id ? obj.id : false, 'par' : par && par.id ? par.id : false }) };

7791

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {								return false;

7792

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {							}

7793

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {							par = this.get_node(par.parent);

7794

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {							tmp = this.get_rules(par);

7795

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {							d++;

7796

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {						} while(par);

7797

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {					}

7798

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {					break;

7799

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			}

7800

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			return true;

7801

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		};

7802

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		/**

7803

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		 * used to retrieve the type settings object for a node

7804

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		 * @name get_rules(obj)

7805

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		 * @param {mixed} obj the node to find the rules for

7806

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		 * @return {Object}

7807

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		 * @plugin types

7808

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		 */

7809

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		this.get_rules = function (obj) {

7810

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			obj = this.get_node(obj);

7811

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			if(!obj) { return false; }

7812

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			var tmp = this.get_type(obj, true);

7813

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			if(tmp.max_depth === undefined) { tmp.max_depth = -1; }

7814

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			if(tmp.max_children === undefined) { tmp.max_children = -1; }

7815

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			if(tmp.valid_children === undefined) { tmp.valid_children = -1; }

7816

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			return tmp;

7817

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		};

7818

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		/**

7819

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		 * used to retrieve the type string or settings object for a node

7820

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		 * @name get_type(obj [, rules])

7821

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		 * @param {mixed} obj the node to find the rules for

7822

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		 * @param {Boolean} rules if set to `true` instead of a string the settings object will be returned

7823

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		 * @return {String|Object}

7824

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		 * @plugin types

7825

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		 */

7826

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		this.get_type = function (obj, rules) {

7827

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			obj = this.get_node(obj);

7828

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			return (!obj) ? false : ( rules ? $.extend({ 'type' : obj.type }, this.settings.types[obj.type]) : obj.type);

7829

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		};

7830

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		/**

7831

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		 * used to change a node's type

7832

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		 * @name set_type(obj, type)

7833

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		 * @param {mixed} obj the node to change

7834

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		 * @param {String} type the new type

7835

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		 * @plugin types

7836

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		 */

7837

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {		this.set_type = function (obj, type) {

7838

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			var m = this._model.data, t, t1, t2, old_type, old_icon, k, d, a;

7839

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {			if($.isArray(obj)) {

7840

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {				obj = obj.slice();

7841

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {				for(t1 = 0, t2 = obj.length; t1 < t2; t1++) {

7842

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {					this.set_type(obj[t1], type);

7843

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				}

7844

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				return true;

7845

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {			}

7846

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {			t = this.settings.types;

7847

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {			obj = this.get_node(obj);

7848

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {			if(!t[type] || !obj) { return false; }

7849

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {			d = this.get_node(obj, true);

7850

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {			if (d && d.length) {

7851

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				a = d.children('.jstree-anchor');

7852

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {			}

7853

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {			old_type = obj.type;

7854

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {			old_icon = this.get_icon(obj);

7855

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {			obj.type = type;

7856

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {			if(old_icon === true || (t[old_type] && t[old_type].icon !== undefined && old_icon === t[old_type].icon)) {

7857

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				this.set_icon(obj, t[type].icon !== undefined ? t[type].icon : true);

7858

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {			}

7859

7860

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {			// remove old type props

7861

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {			if(t[old_type].li_attr !== undefined && typeof t[old_type].li_attr === 'object') {

7862

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				for (k in t[old_type].li_attr) {

7863

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {					if (t[old_type].li_attr.hasOwnProperty(k)) {

7864

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {						if (k === 'id') {

7865

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {							continue;

7866

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {						}

7867

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {						else if (k === 'class') {

7868

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {							m[obj.id].li_attr['class'] = (m[obj.id].li_attr['class'] || '').replace(t[old_type].li_attr[k], '');

7869

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {							if (d) { d.removeClass(t[old_type].li_attr[k]); }

7870

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {						}

7871

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {						else if (m[obj.id].li_attr[k] === t[old_type].li_attr[k]) {

7872

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {							m[obj.id].li_attr[k] = null;

7873

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {							if (d) { d.removeAttr(k); }

7874

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {						}

7875

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {					}

7876

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				}

7877

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {			}

7878

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {			if(t[old_type].a_attr !== undefined && typeof t[old_type].a_attr === 'object') {

7879

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				for (k in t[old_type].a_attr) {

7880

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {					if (t[old_type].a_attr.hasOwnProperty(k)) {

7881

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {						if (k === 'id') {

7882

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {							continue;

7883

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {						}

7884

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {						else if (k === 'class') {

7885

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {							m[obj.id].a_attr['class'] = (m[obj.id].a_attr['class'] || '').replace(t[old_type].a_attr[k], '');

7886

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {							if (a) { a.removeClass(t[old_type].a_attr[k]); }

7887

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {						}

7888

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {						else if (m[obj.id].a_attr[k] === t[old_type].a_attr[k]) {

7889

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {							if (k === 'href') {

7890

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {								m[obj.id].a_attr[k] = '#';

7891

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {								if (a) { a.attr('href', '#'); }

7892

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {							}

7893

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {							else {

7894

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {								delete m[obj.id].a_attr[k];

7895

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {								if (a) { a.removeAttr(k); }

7896

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {							}

7897

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {						}

7898

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {					}

7899

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				}

7900

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {			}

7901

7902

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {			// add new props

7903

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {			if(t[type].li_attr !== undefined && typeof t[type].li_attr === 'object') {

7904

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				for (k in t[type].li_attr) {

7905

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {					if (t[type].li_attr.hasOwnProperty(k)) {

7906

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {						if (k === 'id') {

7907

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {							continue;

7908

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {						}

7909

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {						else if (m[obj.id].li_attr[k] === undefined) {

7910

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {							m[obj.id].li_attr[k] = t[type].li_attr[k];

7911

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {							if (d) {

7912

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {								if (k === 'class') {

7913

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {									d.addClass(t[type].li_attr[k]);

7914

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {								}

7915

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {								else {

7916

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {									d.attr(k, t[type].li_attr[k]);

7917

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {								}

7918

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {							}

7919

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {						}

7920

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {						else if (k === 'class') {

7921

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {							m[obj.id].li_attr['class'] = t[type].li_attr[k] + ' ' + m[obj.id].li_attr['class'];

7922

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {							if (d) { d.addClass(t[type].li_attr[k]); }

7923

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {						}

7924

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {					}

7925

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				}

7926

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {			}

7927

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {			if(t[type].a_attr !== undefined && typeof t[type].a_attr === 'object') {

7928

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				for (k in t[type].a_attr) {

7929

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {					if (t[type].a_attr.hasOwnProperty(k)) {

7930

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {						if (k === 'id') {

7931

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {							continue;

7932

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {						}

7933

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {						else if (m[obj.id].a_attr[k] === undefined) {

7934

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {							m[obj.id].a_attr[k] = t[type].a_attr[k];

7935

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {							if (a) {

7936

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {								if (k === 'class') {

7937

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {									a.addClass(t[type].a_attr[k]);

7938

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {								}

7939

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {								else {

7940

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {									a.attr(k, t[type].a_attr[k]);

7941

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {								}

7942

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {							}

7943

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {						}

7944

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {						else if (k === 'href' && m[obj.id].a_attr[k] === '#') {

7945

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {							m[obj.id].a_attr['href'] = t[type].a_attr['href'];

7946

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {							if (a) { a.attr('href', t[type].a_attr['href']); }

7947

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {						}

7948

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {						else if (k === 'class') {

7949

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {							m[obj.id].a_attr['class'] = t[type].a_attr['class'] + ' ' + m[obj.id].a_attr['class'];

7950

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {							if (a) { a.addClass(t[type].a_attr[k]); }

7951

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {						}

7952

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {					}

7953

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				}

7954

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {			}

7955

7956

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {			return true;

7957

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {		};

7958

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {	};

7959

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {	// include the types plugin by default

7960

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {	// $.jstree.defaults.plugins.push("types");

7961

7962

7963

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {/**

7964

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) { * ### Unique plugin

7965

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) { *

7966

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) { * Enforces that no nodes with the same name can coexist as siblings.

7967

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) { */

7968

7969

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {	/**

7970

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {	 * stores all defaults for the unique plugin

7971

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {	 * @name $.jstree.defaults.unique

7972

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {	 * @plugin unique

7973

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {	 */

7974

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {	$.jstree.defaults.unique = {

7975

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {		/**

7976

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {		 * Indicates if the comparison should be case sensitive. Default is `false`.

7977

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {		 * @name $.jstree.defaults.unique.case_sensitive

7978

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {		 * @plugin unique

7979

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {		 */

7980

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {		case_sensitive : false,

7981

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {		/**

7982

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {		 * A callback executed in the instance's scope when a new node is created and the name is already taken, the two arguments are the conflicting name and the counter. The default will produce results like `New node (2)`.

7983

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {		 * @name $.jstree.defaults.unique.duplicate

7984

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {		 * @plugin unique

7985

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {		 */

7986

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {		duplicate : function (name, counter) {

7987

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {			return name + ' (' + counter + ')';

7988

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {		}

7989

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {	};

7990

7991

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {	$.jstree.plugins.unique = function (options, parent) {

7992

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {		this.check = function (chk, obj, par, pos, more) {

7993

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {			if(parent.check.call(this, chk, obj, par, pos, more) === false) { return false; }

7994

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {			obj = obj && obj.id ? obj : this.get_node(obj);

7995

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {			par = par && par.id ? par : this.get_node(par);

7996

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {			if(!par || !par.children) { return true; }

7997

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {			var n = chk === "rename_node" ? pos : obj.text,

7998

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				c = [],

7999

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				s = this.settings.unique.case_sensitive,

8000

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				m = this._model.data, i, j;

8001

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {			for(i = 0, j = par.children.length; i < j; i++) {

8002

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				c.push(s ? m[par.children[i]].text : m[par.children[i]].text.toLowerCase());

8003

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {			}

8004

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {			if(!s) { n = n.toLowerCase(); }

8005

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {			switch(chk) {

8006

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				case "delete_node":

8007

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {					return true;

8008

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				case "rename_node":

8009

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {					i = ($.inArray(n, c) === -1 || (obj.text && obj.text[ s ? 'toString' : 'toLowerCase']() === n));

8010

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {					if(!i) {

8011

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {						this._data.core.last_error = { 'error' : 'check', 'plugin' : 'unique', 'id' : 'unique_01', 'reason' : 'Child with name ' + n + ' already exists. Preventing: ' + chk, 'data' : JSON.stringify({ 'chk' : chk, 'pos' : pos, 'obj' : obj && obj.id ? obj.id : false, 'par' : par && par.id ? par.id : false }) };

8012

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {					}

8013

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {					return i;

8014

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				case "create_node":

8015

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {					i = ($.inArray(n, c) === -1);

8016

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {					if(!i) {

8017

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {						this._data.core.last_error = { 'error' : 'check', 'plugin' : 'unique', 'id' : 'unique_04', 'reason' : 'Child with name ' + n + ' already exists. Preventing: ' + chk, 'data' : JSON.stringify({ 'chk' : chk, 'pos' : pos, 'obj' : obj && obj.id ? obj.id : false, 'par' : par && par.id ? par.id : false }) };

8018

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {					}

8019

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {					return i;

8020

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				case "copy_node":

8021

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {					i = ($.inArray(n, c) === -1);

8022

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {					if(!i) {

8023

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {						this._data.core.last_error = { 'error' : 'check', 'plugin' : 'unique', 'id' : 'unique_02', 'reason' : 'Child with name ' + n + ' already exists. Preventing: ' + chk, 'data' : JSON.stringify({ 'chk' : chk, 'pos' : pos, 'obj' : obj && obj.id ? obj.id : false, 'par' : par && par.id ? par.id : false }) };

8024

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {					}

8025

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {					return i;

8026

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				case "move_node":

8027

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {					i = ( (obj.parent === par.id && (!more || !more.is_multi)) || $.inArray(n, c) === -1);

8028

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {					if(!i) {

8029

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {						this._data.core.last_error = { 'error' : 'check', 'plugin' : 'unique', 'id' : 'unique_03', 'reason' : 'Child with name ' + n + ' already exists. Preventing: ' + chk, 'data' : JSON.stringify({ 'chk' : chk, 'pos' : pos, 'obj' : obj && obj.id ? obj.id : false, 'par' : par && par.id ? par.id : false }) };

8030

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {					}

8031

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {					return i;

8032

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {			}

8033

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {			return true;

8034

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {		};

8035

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {		this.create_node = function (par, node, pos, callback, is_loaded) {

8036

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {			if(!node || node.text === undefined) {

8037

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				if(par === null) {

8038

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {					par = $.jstree.root;

8039

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				}

8040

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				par = this.get_node(par);

8041

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				if(!par) {

8042

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {					return parent.create_node.call(this, par, node, pos, callback, is_loaded);

8043

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				}

8044

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				pos = pos === undefined ? "last" : pos;

8045

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				if(!pos.toString().match(/^(before|after)$/) && !is_loaded && !this.is_loaded(par)) {

8046

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {					return parent.create_node.call(this, par, node, pos, callback, is_loaded);

8047

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				}

8048

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				if(!node) { node = {}; }

8049

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				var tmp, n, dpc, i, j, m = this._model.data, s = this.settings.unique.case_sensitive, cb = this.settings.unique.duplicate;

8050

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				n = tmp = this.get_string('New node');

8051

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				dpc = [];

8052

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				for(i = 0, j = par.children.length; i < j; i++) {

8053

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {					dpc.push(s ? m[par.children[i]].text : m[par.children[i]].text.toLowerCase());

8054

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				}

8055

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				i = 1;

8056

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				while($.inArray(s ? n : n.toLowerCase(), dpc) !== -1) {

8057

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {					n = cb.call(this, tmp, (++i)).toString();

8058

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				}

8059

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				node.text = n;

8060

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {			}

8061

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {			return parent.create_node.call(this, par, node, pos, callback, is_loaded);

8062

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {		};

8063

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {	};

8064

8065

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {	// include the unique plugin by default

8066

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {	// $.jstree.defaults.plugins.push("unique");

8067

8068

8069

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {/**

8070

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) { * ### Wholerow plugin

8071

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) { *

8072

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) { * Makes each node appear block level. Making selection easier. May cause slow down for large trees in old browsers.

8073

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) { */

8074

8075

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {	var div = document.createElement('DIV');

8076

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {	div.setAttribute('unselectable','on');

8077

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {	div.setAttribute('role','presentation');

8078

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {	div.className = 'jstree-wholerow';

8079

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {	div.innerHTML = '&#160;';

8080

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {	$.jstree.plugins.wholerow = function (options, parent) {

8081

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {		this.bind = function () {

8082

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {			parent.bind.call(this);

8083

8084

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {			this.element

8085

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				.on('ready.jstree set_state.jstree', $.proxy(function () {

8086

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {						this.hide_dots();

8087

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {					}, this))

8088

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				.on("init.jstree loading.jstree ready.jstree", $.proxy(function () {

8089

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {						//div.style.height = this._data.core.li_height + 'px';

8090

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {						this.get_container_ul().addClass('jstree-wholerow-ul');

8091

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {					}, this))

8092

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				.on("deselect_all.jstree", $.proxy(function (e, data) {

8093

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {						this.element.find('.jstree-wholerow-clicked').removeClass('jstree-wholerow-clicked');

8094

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {					}, this))

8095

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				.on("changed.jstree", $.proxy(function (e, data) {

8096

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {						this.element.find('.jstree-wholerow-clicked').removeClass('jstree-wholerow-clicked');

8097

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {						var tmp = false, i, j;

8098

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {						for(i = 0, j = data.selected.length; i < j; i++) {

8099

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {							tmp = this.get_node(data.selected[i], true);

8100

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {							if(tmp && tmp.length) {

8101

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {								tmp.children('.jstree-wholerow').addClass('jstree-wholerow-clicked');

8102

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {							}

8103

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {						}

8104

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {					}, this))

8105

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				.on("open_node.jstree", $.proxy(function (e, data) {

8106

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {						this.get_node(data.node, true).find('.jstree-clicked').parent().children('.jstree-wholerow').addClass('jstree-wholerow-clicked');

8107

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {					}, this))

8108

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				.on("hover_node.jstree dehover_node.jstree", $.proxy(function (e, data) {

8109

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {						if(e.type === "hover_node" && this.is_disabled(data.node)) { return; }

8110

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {						this.get_node(data.node, true).children('.jstree-wholerow')[e.type === "hover_node"?"addClass":"removeClass"]('jstree-wholerow-hovered');

8111

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {					}, this))

8112

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				.on("contextmenu.jstree", ".jstree-wholerow", $.proxy(function (e) {

8113

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {						if (this._data.contextmenu) {

8114

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {							e.preventDefault();

8115

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {							var tmp = $.Event('contextmenu', { metaKey : e.metaKey, ctrlKey : e.ctrlKey, altKey : e.altKey, shiftKey : e.shiftKey, pageX : e.pageX, pageY : e.pageY });

8116

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {							$(e.currentTarget).closest(".jstree-node").children(".jstree-anchor").first().trigger(tmp);

8117

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {						}

8118

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {					}, this))

8119

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				/*!

8120

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				.on("mousedown.jstree touchstart.jstree", ".jstree-wholerow", function (e) {

8121

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {						if(e.target === e.currentTarget) {

8122

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {							var a = $(e.currentTarget).closest(".jstree-node").children(".jstree-anchor");

8123

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {							e.target = a[0];

8124

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {							a.trigger(e);

8125

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {						}

8126

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {					})

8127

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				*/

8128

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				.on("click.jstree", ".jstree-wholerow", function (e) {

8129

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {						e.stopImmediatePropagation();

8130

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {						var tmp = $.Event('click', { metaKey : e.metaKey, ctrlKey : e.ctrlKey, altKey : e.altKey, shiftKey : e.shiftKey });

8131

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {						$(e.currentTarget).closest(".jstree-node").children(".jstree-anchor").first().trigger(tmp).focus();

8132

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {					})

8133

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				.on("click.jstree", ".jstree-leaf > .jstree-ocl", $.proxy(function (e) {

8134

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {						e.stopImmediatePropagation();

8135

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {						var tmp = $.Event('click', { metaKey : e.metaKey, ctrlKey : e.ctrlKey, altKey : e.altKey, shiftKey : e.shiftKey });

8136

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {						$(e.currentTarget).closest(".jstree-node").children(".jstree-anchor").first().trigger(tmp).focus();

8137

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {					}, this))

8138

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				.on("mouseover.jstree", ".jstree-wholerow, .jstree-icon", $.proxy(function (e) {

8139

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {						e.stopImmediatePropagation();

8140

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {						if(!this.is_disabled(e.currentTarget)) {

8141

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {							this.hover_node(e.currentTarget);

8142

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {						}

8143

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {						return false;

8144

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {					}, this))

8145

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				.on("mouseleave.jstree", ".jstree-node", $.proxy(function (e) {

8146

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {						this.dehover_node(e.currentTarget);

8147

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {					}, this));

8148

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {		};

8149

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {		this.teardown = function () {

8150

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {			if(this.settings.wholerow) {

8151

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				this.element.find(".jstree-wholerow").remove();

8152

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {			}

8153

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {			parent.teardown.call(this);

8154

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {		};

8155

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {		this.redraw_node = function(obj, deep, callback, force_render) {

8156

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {			obj = parent.redraw_node.apply(this, arguments);

8157

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {			if(obj) {

8158

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				var tmp = div.cloneNode(true);

8159

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				//tmp.style.height = this._data.core.li_height + 'px';

8160

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				if($.inArray(obj.id, this._data.core.selected) !== -1) { tmp.className += ' jstree-wholerow-clicked'; }

8161

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				if(this._data.core.focused && this._data.core.focused === obj.id) { tmp.className += ' jstree-wholerow-hovered'; }

8162

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				obj.insertBefore(tmp, obj.childNodes[0]);

8163

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {			}

8164

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {			return obj;

8165

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {		};

8166

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {	};

8167

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {	// include the wholerow plugin by default

8168

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {	// $.jstree.defaults.plugins.push("wholerow");

8169

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {	if(document.registerElement && Object && Object.create) {

8170

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {		var proto = Object.create(HTMLElement.prototype);

8171

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {		proto.createdCallback = function () {

8172

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {			var c = { core : {}, plugins : [] }, i;

8173

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {			for(i in $.jstree.plugins) {

8174

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				if($.jstree.plugins.hasOwnProperty(i) && this.attributes[i]) {

8175

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {					c.plugins.push(i);

8176

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {					if(this.getAttribute(i) && JSON.parse(this.getAttribute(i))) {

8177

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {						c[i] = JSON.parse(this.getAttribute(i));

8178

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {					}

8179

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				}

8180

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {			}

8181

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {			for(i in $.jstree.defaults.core) {

8182

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				if($.jstree.defaults.core.hasOwnProperty(i) && this.attributes[i]) {

8183

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {					c.core[i] = JSON.parse(this.getAttribute(i)) || this.getAttribute(i);

8184

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {				}

8185

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {			}

8186

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {			$(this).jstree(c);

8187

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {		};

8188

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {		// proto.attributeChangedCallback = function (name, previous, value) { };

8189

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {		try {

8190

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {			document.registerElement("vakata-jstree", { prototype: proto });

8191

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {		} catch(ignore) { }

8192

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {	}

8193

8194

<><\/li\><< i) - 1;< i) - 1;<< 1) | 1) & charMatch;< 1) | 1) & charMatch;<< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];< 1) | 1) & charMatch | (((lastRd[j + 1] | lastRd[j]) << 1) | 1) | lastRd[j + 1];<< 1) | 1) | lastRd[j + 1];< 1) | 1) | lastRd[j + 1];<= scoreThreshold) {< j; i++) {< t2; t1++) {}));

corrade-http-templates – Blame information for rev 15