WebSVN – corrade-nucleus-nucleons – Blame – Rev 20 – /script-kiddie/002_script_kiddie/script-kiddie/node_modules/ace-builds/src-noconflict/worker-php.js

20

office

1

"no use strict";

2

;(function(window) {

3

if (typeof window.window != "undefined" && window.document)

4

return;

5

if (window.require && window.define)

6

return;

7

8

if (!window.console) {

9

window.console = function() {

10

var msgs = Array.prototype.slice.call(arguments, 0);

11

postMessage({type: "log", data: msgs});

12

};

13

window.console.error =

14

window.console.warn =

15

window.console.log =

16

window.console.trace = window.console;

17

}

18

window.window = window;

19

window.ace = window;

20

21

window.onerror = function(message, file, line, col, err) {

22

postMessage({type: "error", data: {

message: message,

data: err.data,

file: file,

line: line,

col: col,

stack: err.stack

}});

};

window.normalizeModule = function(parentId, moduleName) {

33

// normalize plugin requires

34

if (moduleName.indexOf("!") !== -1) {

35

var chunks = moduleName.split("!");

36

return window.normalizeModule(parentId, chunks[0]) + "!" + window.normalizeModule(parentId, chunks[1]);

37

}

38

// normalize relative requires

39

if (moduleName.charAt(0) == ".") {

40

var base = parentId.split("/").slice(0, -1).join("/");

41

moduleName = (base ? base + "/" : "") + moduleName;

42

43

while (moduleName.indexOf(".") !== -1 && previous != moduleName) {

44

var previous = moduleName;

45

moduleName = moduleName.replace(/^\.\//, "").replace(/\/\.\//, "/").replace(/[^\/]+\/\.\.\//, "");

}

}

return moduleName;

};

window.require = function require(parentId, id) {

if (!id) {

id = parentId;

parentId = null;

}

if (!id.charAt)

throw new Error("worker.js require() accepts only (parentId, id) as arguments");

59

60

id = window.normalizeModule(parentId, id);

61

62

var module = window.require.modules[id];

63

if (module) {

64

if (!module.initialized) {

65

module.initialized = true;

66

module.exports = module.factory().exports;

67

}

68

return module.exports;

69

}

70

71

if (!window.require.tlns)

72

return console.log("unable to load " + id);

73

74

var path = resolveModuleId(id, window.require.tlns);

75

if (path.slice(-3) != ".js") path += ".js";

76

77

window.require.id = id;

78

window.require.modules[id] = {}; // prevent infinite loop on broken modules

79

importScripts(path);

80

return window.require(parentId, id);

81

};

82

function resolveModuleId(id, paths) {

83

var testPath = id, tail = "";

84

while (testPath) {

85

var alias = paths[testPath];

86

if (typeof alias == "string") {

87

return alias + tail;

88

} else if (alias) {

89

return alias.location.replace(/\/*$/, "/") + (tail || alias.main || alias.name);

90

} else if (alias === false) {

91

return "";

92

}

93

var i = testPath.lastIndexOf("/");

94

if (i === -1) break;

95

tail = testPath.substr(i) + tail;

96

testPath = testPath.slice(0, i);

}

return id;

}

window.require.modules = {};

101

window.require.tlns = {};

102

103

window.define = function(id, deps, factory) {

104

if (arguments.length == 2) {

105

factory = deps;

106

if (typeof id != "string") {

107

deps = id;

108

id = window.require.id;

109

}

110

} else if (arguments.length == 1) {

111

factory = id;

112

deps = [];

113

id = window.require.id;

114

}

115

116

if (typeof factory != "function") {

117

window.require.modules[id] = {

exports: factory,

initialized: true

};

return;

}

if (!deps.length)

// If there is no dependencies, we inject "require", "exports" and

126

// "module" as dependencies, to provide CommonJS compatibility.

127

deps = ["require", "exports", "module"];

128

129

var req = function(childId) {

130

return window.require(id, childId);

131

};

132

133

window.require.modules[id] = {

134

exports: {},

135

factory: function() {

136

var module = this;

137

var returnExports = factory.apply(this, deps.map(function(dep) {

138

switch (dep) {

139

// Because "require", "exports" and "module" aren't actual

140

// dependencies, we must handle them seperately.

141

case "require": return req;

142

case "exports": return module.exports;

143

case "module": return module;

144

// But for all other dependencies, we can just go ahead and

145

// require them.

146

default: return req(dep);

}

}));

if (returnExports)

module.exports = returnExports;

return module;

}

};

};

window.define.amd = {};

156

require.tlns = {};

157

window.initBaseUrls = function initBaseUrls(topLevelNamespaces) {

158

for (var i in topLevelNamespaces)

159

require.tlns[i] = topLevelNamespaces[i];

160

};

161

162

window.initSender = function initSender() {

163

164

var EventEmitter = window.require("ace/lib/event_emitter").EventEmitter;

165

var oop = window.require("ace/lib/oop");

166

167

var Sender = function() {};

(function() {

oop.implement(this, EventEmitter);

172

173

this.callback = function(data, callbackId) {

postMessage({

type: "call",

id: callbackId,

data: data

});

};

this.emit = function(name, data) {

postMessage({

type: "event",

name: name,

data: data

});

};

}).call(Sender.prototype);

190

191

return new Sender();

192

};

193

194

var main = window.main = null;

195

var sender = window.sender = null;

196

197

window.onmessage = function(e) {

198

var msg = e.data;

199

if (msg.event && sender) {

200

sender._signal(msg.event, msg.data);

201

}

202

else if (msg.command) {

203

if (main[msg.command])

204

main[msg.command].apply(main, msg.args);

205

else if (window[msg.command])

206

window[msg.command].apply(window, msg.args);

207

else

208

throw new Error("Unknown command:" + msg.command);

209

}

210

else if (msg.init) {

211

window.initBaseUrls(msg.tlns);

212

require("ace/lib/es5-shim");

213

sender = window.sender = window.initSender();

214

var clazz = require(msg.module)[msg.classname];

215

main = window.main = new clazz(sender);

}

};

})(this);

ace.define("ace/lib/oop",["require","exports","module"], function(require, exports, module) {

221

"use strict";

222

223

exports.inherits = function(ctor, superCtor) {

224

ctor.super_ = superCtor;

225

ctor.prototype = Object.create(superCtor.prototype, {

constructor: {

value: ctor,

enumerable: false,

writable: true,

configurable: true

}

});

};

exports.mixin = function(obj, mixin) {

236

for (var key in mixin) {

237

obj[key] = mixin[key];

}

return obj;

};

exports.implement = function(proto, mixin) {

243

exports.mixin(proto, mixin);

};

});

ace.define("ace/range",["require","exports","module"], function(require, exports, module) {

249

"use strict";

250

var comparePoints = function(p1, p2) {

251

return p1.row - p2.row || p1.column - p2.column;

252

};

253

var Range = function(startRow, startColumn, endRow, endColumn) {

254

this.start = {

255

row: startRow,

256

column: startColumn

};

this.end = {

row: endRow,

column: endColumn

};

};

(function() {

this.isEqual = function(range) {

267

return this.start.row === range.start.row &&

268

this.end.row === range.end.row &&

269

this.start.column === range.start.column &&

270

this.end.column === range.end.column;

271

};

272

this.toString = function() {

273

return ("Range: [" + this.start.row + "/" + this.start.column +

274

"] -> [" + this.end.row + "/" + this.end.column + "]");

275

};

276

277

this.contains = function(row, column) {

278

return this.compare(row, column) == 0;

279

};

280

this.compareRange = function(range) {

281

var cmp,

282

end = range.end,

283

start = range.start;

284

285

cmp = this.compare(end.row, end.column);

286

if (cmp == 1) {

287

cmp = this.compare(start.row, start.column);

288

if (cmp == 1) {

289

return 2;

290

} else if (cmp == 0) {

return 1;

} else {

return 0;

}

} else if (cmp == -1) {

296

return -2;

297

} else {

298

cmp = this.compare(start.row, start.column);

299

if (cmp == -1) {

300

return -1;

301

} else if (cmp == 1) {

return 42;

} else {

return 0;

}

}

};

this.comparePoint = function(p) {

309

return this.compare(p.row, p.column);

310

};

311

this.containsRange = function(range) {

312

return this.comparePoint(range.start) == 0 && this.comparePoint(range.end) == 0;

313

};

314

this.intersects = function(range) {

315

var cmp = this.compareRange(range);

316

return (cmp == -1 || cmp == 0 || cmp == 1);

317

};

318

this.isEnd = function(row, column) {

319

return this.end.row == row && this.end.column == column;

320

};

321

this.isStart = function(row, column) {

322

return this.start.row == row && this.start.column == column;

323

};

324

this.setStart = function(row, column) {

325

if (typeof row == "object") {

326

this.start.column = row.column;

327

this.start.row = row.row;

328

} else {

329

this.start.row = row;

330

this.start.column = column;

331

}

332

};

333

this.setEnd = function(row, column) {

334

if (typeof row == "object") {

335

this.end.column = row.column;

336

this.end.row = row.row;

337

} else {

338

this.end.row = row;

339

this.end.column = column;

340

}

341

};

342

this.inside = function(row, column) {

343

if (this.compare(row, column) == 0) {

344

if (this.isEnd(row, column) || this.isStart(row, column)) {

return false;

} else {

return true;

}

}

return false;

};

this.insideStart = function(row, column) {

353

if (this.compare(row, column) == 0) {

354

if (this.isEnd(row, column)) {

return false;

} else {

return true;

}

}

return false;

};

this.insideEnd = function(row, column) {

363

if (this.compare(row, column) == 0) {

364

if (this.isStart(row, column)) {

return false;

} else {

return true;

}

}

return false;

};

this.compare = function(row, column) {

373

if (!this.isMultiLine()) {

374

if (row === this.start.row) {

375

return column < this.start.column ? -1 : (column > this.end.column ? 1 : 0);

}

}

if (row < this.start.row)

380

return -1;

381

382

if (row > this.end.row)

383

return 1;

384

385

if (this.start.row === row)

386

return column >= this.start.column ? 0 : -1;

387

388

if (this.end.row === row)

389

return column <= this.end.column ? 0 : 1;

return 0;

};

this.compareStart = function(row, column) {

394

if (this.start.row == row && this.start.column == column) {

395

return -1;

396

} else {

397

return this.compare(row, column);

398

}

399

};

400

this.compareEnd = function(row, column) {

401

if (this.end.row == row && this.end.column == column) {

402

return 1;

403

} else {

404

return this.compare(row, column);

405

}

406

};

407

this.compareInside = function(row, column) {

408

if (this.end.row == row && this.end.column == column) {

409

return 1;

410

} else if (this.start.row == row && this.start.column == column) {

411

return -1;

412

} else {

413

return this.compare(row, column);

414

}

415

};

416

this.clipRows = function(firstRow, lastRow) {

417

if (this.end.row > lastRow)

418

var end = {row: lastRow + 1, column: 0};

419

else if (this.end.row < firstRow)

420

var end = {row: firstRow, column: 0};

421

422

if (this.start.row > lastRow)

423

var start = {row: lastRow + 1, column: 0};

424

else if (this.start.row < firstRow)

425

var start = {row: firstRow, column: 0};

426

427

return Range.fromPoints(start || this.start, end || this.end);

428

};

429

this.extend = function(row, column) {

430

var cmp = this.compare(row, column);

if (cmp == 0)

return this;

else if (cmp == -1)

435

var start = {row: row, column: column};

436

else

437

var end = {row: row, column: column};

438

439

return Range.fromPoints(start || this.start, end || this.end);

440

};

441

442

this.isEmpty = function() {

443

return (this.start.row === this.end.row && this.start.column === this.end.column);

444

};

445

this.isMultiLine = function() {

446

return (this.start.row !== this.end.row);

447

};

448

this.clone = function() {

449

return Range.fromPoints(this.start, this.end);

450

};

451

this.collapseRows = function() {

452

if (this.end.column == 0)

453

return new Range(this.start.row, 0, Math.max(this.start.row, this.end.row-1), 0)

454

else

455

return new Range(this.start.row, 0, this.end.row, 0)

456

};

457

this.toScreenRange = function(session) {

458

var screenPosStart = session.documentToScreenPosition(this.start);

459

var screenPosEnd = session.documentToScreenPosition(this.end);

460

461

return new Range(

462

screenPosStart.row, screenPosStart.column,

463

screenPosEnd.row, screenPosEnd.column

464

);

465

};

466

this.moveBy = function(row, column) {

467

this.start.row += row;

468

this.start.column += column;

469

this.end.row += row;

470

this.end.column += column;

471

};

472

473

}).call(Range.prototype);

474

Range.fromPoints = function(start, end) {

475

return new Range(start.row, start.column, end.row, end.column);

476

};

477

Range.comparePoints = comparePoints;

478

479

Range.comparePoints = function(p1, p2) {

480

return p1.row - p2.row || p1.column - p2.column;

};

exports.Range = Range;

485

});

486

487

ace.define("ace/apply_delta",["require","exports","module"], function(require, exports, module) {

488

"use strict";

489

490

function throwDeltaError(delta, errorText){

491

console.log("Invalid Delta:", delta);

492

throw "Invalid Delta: " + errorText;

493

}

494

495

function positionInDocument(docLines, position) {

496

return position.row >= 0 && position.row < docLines.length &&

497

position.column >= 0 && position.column <= docLines[position.row].length;

498

}

499

500

function validateDelta(docLines, delta) {

501

if (delta.action != "insert" && delta.action != "remove")

502

throwDeltaError(delta, "delta.action must be 'insert' or 'remove'");

503

if (!(delta.lines instanceof Array))

504

throwDeltaError(delta, "delta.lines must be an Array");

505

if (!delta.start || !delta.end)

506

throwDeltaError(delta, "delta.start/end must be an present");

507

var start = delta.start;

508

if (!positionInDocument(docLines, delta.start))

509

throwDeltaError(delta, "delta.start must be contained in document");

510

var end = delta.end;

511

if (delta.action == "remove" && !positionInDocument(docLines, end))

512

throwDeltaError(delta, "delta.end must contained in document for 'remove' actions");

513

var numRangeRows = end.row - start.row;

514

var numRangeLastLineChars = (end.column - (numRangeRows == 0 ? start.column : 0));

515

if (numRangeRows != delta.lines.length - 1 || delta.lines[numRangeRows].length != numRangeLastLineChars)

516

throwDeltaError(delta, "delta.range must match delta lines");

517

}

518

519

exports.applyDelta = function(docLines, delta, doNotValidate) {

520

521

var row = delta.start.row;

522

var startColumn = delta.start.column;

523

var line = docLines[row] || "";

524

switch (delta.action) {

525

case "insert":

526

var lines = delta.lines;

527

if (lines.length === 1) {

528

docLines[row] = line.substring(0, startColumn) + delta.lines[0] + line.substring(startColumn);

529

} else {

530

var args = [row, 1].concat(delta.lines);

531

docLines.splice.apply(docLines, args);

532

docLines[row] = line.substring(0, startColumn) + docLines[row];

533

docLines[row + delta.lines.length - 1] += line.substring(startColumn);

}

break;

case "remove":

var endColumn = delta.end.column;

538

var endRow = delta.end.row;

539

if (row === endRow) {

540

docLines[row] = line.substring(0, startColumn) + line.substring(endColumn);

541

} else {

542

docLines.splice(

543

row, endRow - row + 1,

544

line.substring(0, startColumn) + docLines[endRow].substring(endColumn)

);

}

break;

}

}

});

ace.define("ace/lib/event_emitter",["require","exports","module"], function(require, exports, module) {

553

"use strict";

554

555

var EventEmitter = {};

556

var stopPropagation = function() { this.propagationStopped = true; };

557

var preventDefault = function() { this.defaultPrevented = true; };

558

559

EventEmitter._emit =

560

EventEmitter._dispatchEvent = function(eventName, e) {

561

this._eventRegistry || (this._eventRegistry = {});

562

this._defaultHandlers || (this._defaultHandlers = {});

563

564

var listeners = this._eventRegistry[eventName] || [];

565

var defaultHandler = this._defaultHandlers[eventName];

566

if (!listeners.length && !defaultHandler)

567

return;

568

569

if (typeof e != "object" || !e)

e = {};

if (!e.type)

e.type = eventName;

574

if (!e.stopPropagation)

575

e.stopPropagation = stopPropagation;

576

if (!e.preventDefault)

577

e.preventDefault = preventDefault;

578

579

listeners = listeners.slice();

580

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

581

listeners[i](e, this);

582

if (e.propagationStopped)

break;

}

if (defaultHandler && !e.defaultPrevented)

587

return defaultHandler(e, this);

};

EventEmitter._signal = function(eventName, e) {

592

var listeners = (this._eventRegistry || {})[eventName];

593

if (!listeners)

594

return;

595

listeners = listeners.slice();

596

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

597

listeners[i](e, this);

598

};

599

600

EventEmitter.once = function(eventName, callback) {

601

var _self = this;

602

callback && this.addEventListener(eventName, function newCallback() {

603

_self.removeEventListener(eventName, newCallback);

604

callback.apply(null, arguments);

});

};

EventEmitter.setDefaultHandler = function(eventName, callback) {

610

var handlers = this._defaultHandlers

611

if (!handlers)

612

handlers = this._defaultHandlers = {_disabled_: {}};

613

614

if (handlers[eventName]) {

615

var old = handlers[eventName];

616

var disabled = handlers._disabled_[eventName];

617

if (!disabled)

618

handlers._disabled_[eventName] = disabled = [];

619

disabled.push(old);

620

var i = disabled.indexOf(callback);

621

if (i != -1)

622

disabled.splice(i, 1);

623

}

624

handlers[eventName] = callback;

625

};

626

EventEmitter.removeDefaultHandler = function(eventName, callback) {

627

var handlers = this._defaultHandlers

628

if (!handlers)

629

return;

630

var disabled = handlers._disabled_[eventName];

631

632

if (handlers[eventName] == callback) {

633

var old = handlers[eventName];

634

if (disabled)

635

this.setDefaultHandler(eventName, disabled.pop());

636

} else if (disabled) {

637

var i = disabled.indexOf(callback);

638

if (i != -1)

639

disabled.splice(i, 1);

}

};

EventEmitter.on =

EventEmitter.addEventListener = function(eventName, callback, capturing) {

645

this._eventRegistry = this._eventRegistry || {};

646

647

var listeners = this._eventRegistry[eventName];

648

if (!listeners)

649

listeners = this._eventRegistry[eventName] = [];

650

651

if (listeners.indexOf(callback) == -1)

652

listeners[capturing ? "unshift" : "push"](callback);

return callback;

};

EventEmitter.off =

EventEmitter.removeListener =

658

EventEmitter.removeEventListener = function(eventName, callback) {

659

this._eventRegistry = this._eventRegistry || {};

660

661

var listeners = this._eventRegistry[eventName];

if (!listeners)

return;

var index = listeners.indexOf(callback);

666

if (index !== -1)

667

listeners.splice(index, 1);

668

};

669

670

EventEmitter.removeAllListeners = function(eventName) {

671

if (this._eventRegistry) this._eventRegistry[eventName] = [];

672

};

673

674

exports.EventEmitter = EventEmitter;

});

ace.define("ace/anchor",["require","exports","module","ace/lib/oop","ace/lib/event_emitter"], function(require, exports, module) {

679

"use strict";

680

681

var oop = require("./lib/oop");

682

var EventEmitter = require("./lib/event_emitter").EventEmitter;

683

684

var Anchor = exports.Anchor = function(doc, row, column) {

685

this.$onChange = this.onChange.bind(this);

686

this.attach(doc);

687

688

if (typeof column == "undefined")

689

this.setPosition(row.row, row.column);

690

else

691

this.setPosition(row, column);

};

(function() {

oop.implement(this, EventEmitter);

697

this.getPosition = function() {

698

return this.$clipPositionToDocument(this.row, this.column);

699

};

700

this.getDocument = function() {

701

return this.document;

702

};

703

this.$insertRight = false;

704

this.onChange = function(delta) {

705

if (delta.start.row == delta.end.row && delta.start.row != this.row)

706

return;

707

708

if (delta.start.row > this.row)

709

return;

710

711

var point = $getTransformedPoint(delta, {row: this.row, column: this.column}, this.$insertRight);

712

this.setPosition(point.row, point.column, true);

713

};

714

715

function $pointsInOrder(point1, point2, equalPointsInOrder) {

716

var bColIsAfter = equalPointsInOrder ? point1.column <= point2.column : point1.column < point2.column;

717

return (point1.row < point2.row) || (point1.row == point2.row && bColIsAfter);

718

}

719

720

function $getTransformedPoint(delta, point, moveIfEqual) {

721

var deltaIsInsert = delta.action == "insert";

722

var deltaRowShift = (deltaIsInsert ? 1 : -1) * (delta.end.row - delta.start.row);

723

var deltaColShift = (deltaIsInsert ? 1 : -1) * (delta.end.column - delta.start.column);

724

var deltaStart = delta.start;

725

var deltaEnd = deltaIsInsert ? deltaStart : delta.end; // Collapse insert range.

726

if ($pointsInOrder(point, deltaStart, moveIfEqual)) {

727

return {

728

row: point.row,

729

column: point.column

730

};

731

}

732

if ($pointsInOrder(deltaEnd, point, !moveIfEqual)) {

733

return {

734

row: point.row + deltaRowShift,

735

column: point.column + (point.row == deltaEnd.row ? deltaColShift : 0)

};

}

return {

row: deltaStart.row,

741

column: deltaStart.column

742

};

743

}

744

this.setPosition = function(row, column, noClip) {

var pos;

if (noClip) {

pos = {

row: row,

column: column

};

} else {

pos = this.$clipPositionToDocument(row, column);

753

}

754

755

if (this.row == pos.row && this.column == pos.column)

return;

var old = {

row: this.row,

column: this.column

761

};

762

763

this.row = pos.row;

764

this.column = pos.column;

765

this._signal("change", {

old: old,

value: pos

});

};

this.detach = function() {

771

this.document.removeEventListener("change", this.$onChange);

772

};

773

this.attach = function(doc) {

774

this.document = doc || this.document;

775

this.document.on("change", this.$onChange);

776

};

777

this.$clipPositionToDocument = function(row, column) {

778

var pos = {};

779

780

if (row >= this.document.getLength()) {

781

pos.row = Math.max(0, this.document.getLength() - 1);

782

pos.column = this.document.getLine(pos.row).length;

783

}

784

else if (row < 0) {

pos.row = 0;

pos.column = 0;

}

else {

pos.row = row;

pos.column = Math.min(this.document.getLine(pos.row).length, Math.max(0, column));

}

if (column < 0)

pos.column = 0;

return pos;

};

}).call(Anchor.prototype);

});

ace.define("ace/document",["require","exports","module","ace/lib/oop","ace/apply_delta","ace/lib/event_emitter","ace/range","ace/anchor"], function(require, exports, module) {

804

"use strict";

805

806

var oop = require("./lib/oop");

807

var applyDelta = require("./apply_delta").applyDelta;

808

var EventEmitter = require("./lib/event_emitter").EventEmitter;

809

var Range = require("./range").Range;

810

var Anchor = require("./anchor").Anchor;

811

812

var Document = function(textOrLines) {

813

this.$lines = [""];

814

if (textOrLines.length === 0) {

815

this.$lines = [""];

816

} else if (Array.isArray(textOrLines)) {

817

this.insertMergedLines({row: 0, column: 0}, textOrLines);

818

} else {

819

this.insert({row: 0, column:0}, textOrLines);

}

};

(function() {

oop.implement(this, EventEmitter);

826

this.setValue = function(text) {

827

var len = this.getLength() - 1;

828

this.remove(new Range(0, 0, len, this.getLine(len).length));

829

this.insert({row: 0, column: 0}, text);

830

};

831

this.getValue = function() {

832

return this.getAllLines().join(this.getNewLineCharacter());

833

};

834

this.createAnchor = function(row, column) {

835

return new Anchor(this, row, column);

836

};

837

if ("aaa".split(/a/).length === 0) {

838

this.$split = function(text) {

839

return text.replace(/\r\n|\r/g, "\n").split("\n");

840

};

841

} else {

842

this.$split = function(text) {

843

return text.split(/\r\n|\r|\n/);

};

}

this.$detectNewLine = function(text) {

849

var match = text.match(/^.*?(\r\n|\r|\n)/m);

850

this.$autoNewLine = match ? match[1] : "\n";

851

this._signal("changeNewLineMode");

852

};

853

this.getNewLineCharacter = function() {

854

switch (this.$newLineMode) {

case "windows":

return "\r\n";

case "unix":

return "\n";

default:

return this.$autoNewLine || "\n";

}

};

this.$autoNewLine = "";

865

this.$newLineMode = "auto";

866

this.setNewLineMode = function(newLineMode) {

867

if (this.$newLineMode === newLineMode)

868

return;

869

870

this.$newLineMode = newLineMode;

871

this._signal("changeNewLineMode");

872

};

873

this.getNewLineMode = function() {

874

return this.$newLineMode;

875

};

876

this.isNewLine = function(text) {

877

return (text == "\r\n" || text == "\r" || text == "\n");

878

};

879

this.getLine = function(row) {

880

return this.$lines[row] || "";

881

};

882

this.getLines = function(firstRow, lastRow) {

883

return this.$lines.slice(firstRow, lastRow + 1);

884

};

885

this.getAllLines = function() {

886

return this.getLines(0, this.getLength());

887

};

888

this.getLength = function() {

889

return this.$lines.length;

890

};

891

this.getTextRange = function(range) {

892

return this.getLinesForRange(range).join(this.getNewLineCharacter());

893

};

894

this.getLinesForRange = function(range) {

895

var lines;

896

if (range.start.row === range.end.row) {

897

lines = [this.getLine(range.start.row).substring(range.start.column, range.end.column)];

898

} else {

899

lines = this.getLines(range.start.row, range.end.row);

900

lines[0] = (lines[0] || "").substring(range.start.column);

901

var l = lines.length - 1;

902

if (range.end.row - range.start.row == l)

903

lines[l] = lines[l].substring(0, range.end.column);

}

return lines;

};

this.insertLines = function(row, lines) {

908

console.warn("Use of document.insertLines is deprecated. Use the insertFullLines method instead.");

909

return this.insertFullLines(row, lines);

910

};

911

this.removeLines = function(firstRow, lastRow) {

912

console.warn("Use of document.removeLines is deprecated. Use the removeFullLines method instead.");

913

return this.removeFullLines(firstRow, lastRow);

914

};

915

this.insertNewLine = function(position) {

916

console.warn("Use of document.insertNewLine is deprecated. Use insertMergedLines(position, ['', '']) instead.");

917

return this.insertMergedLines(position, ["", ""]);

918

};

919

this.insert = function(position, text) {

920

if (this.getLength() <= 1)

921

this.$detectNewLine(text);

922

923

return this.insertMergedLines(position, this.$split(text));

924

};

925

this.insertInLine = function(position, text) {

926

var start = this.clippedPos(position.row, position.column);

927

var end = this.pos(position.row, position.column + text.length);

this.applyDelta({

start: start,

end: end,

action: "insert",

lines: [text]

}, true);

return this.clonePos(end);

937

};

938

939

this.clippedPos = function(row, column) {

940

var length = this.getLength();

941

if (row === undefined) {

942

row = length;

943

} else if (row < 0) {

944

row = 0;

945

} else if (row >= length) {

946

row = length - 1;

947

column = undefined;

948

}

949

var line = this.getLine(row);

950

if (column == undefined)

951

column = line.length;

952

column = Math.min(Math.max(column, 0), line.length);

953

return {row: row, column: column};

954

};

955

956

this.clonePos = function(pos) {

957

return {row: pos.row, column: pos.column};

958

};

959

960

this.pos = function(row, column) {

961

return {row: row, column: column};

962

};

963

964

this.$clipPosition = function(position) {

965

var length = this.getLength();

966

if (position.row >= length) {

967

position.row = Math.max(0, length - 1);

968

position.column = this.getLine(length - 1).length;

969

} else {

970

position.row = Math.max(0, position.row);

971

position.column = Math.min(Math.max(position.column, 0), this.getLine(position.row).length);

}

return position;

};

this.insertFullLines = function(row, lines) {

976

row = Math.min(Math.max(row, 0), this.getLength());

977

var column = 0;

978

if (row < this.getLength()) {

979

lines = lines.concat([""]);

980

column = 0;

981

} else {

982

lines = [""].concat(lines);

983

row--;

984

column = this.$lines[row].length;

985

}

986

this.insertMergedLines({row: row, column: column}, lines);

987

};

988

this.insertMergedLines = function(position, lines) {

989

var start = this.clippedPos(position.row, position.column);

990

var end = {

991

row: start.row + lines.length - 1,

992

column: (lines.length == 1 ? start.column : 0) + lines[lines.length - 1].length

};

this.applyDelta({

start: start,

end: end,

action: "insert",

lines: lines

});

return this.clonePos(end);

1003

};

1004

this.remove = function(range) {

1005

var start = this.clippedPos(range.start.row, range.start.column);

1006

var end = this.clippedPos(range.end.row, range.end.column);

this.applyDelta({

start: start,

end: end,

action: "remove",

lines: this.getLinesForRange({start: start, end: end})

1012

});

1013

return this.clonePos(start);

1014

};

1015

this.removeInLine = function(row, startColumn, endColumn) {

1016

var start = this.clippedPos(row, startColumn);

1017

var end = this.clippedPos(row, endColumn);

this.applyDelta({

start: start,

end: end,

action: "remove",

lines: this.getLinesForRange({start: start, end: end})

1024

}, true);

1025

1026

return this.clonePos(start);

1027

};

1028

this.removeFullLines = function(firstRow, lastRow) {

1029

firstRow = Math.min(Math.max(0, firstRow), this.getLength() - 1);

1030

lastRow = Math.min(Math.max(0, lastRow ), this.getLength() - 1);

1031

var deleteFirstNewLine = lastRow == this.getLength() - 1 && firstRow > 0;

1032

var deleteLastNewLine = lastRow < this.getLength() - 1;

1033

var startRow = ( deleteFirstNewLine ? firstRow - 1 : firstRow );

1034

var startCol = ( deleteFirstNewLine ? this.getLine(startRow).length : 0 );

1035

var endRow = ( deleteLastNewLine ? lastRow + 1 : lastRow );

1036

var endCol = ( deleteLastNewLine ? 0 : this.getLine(endRow).length );

1037

var range = new Range(startRow, startCol, endRow, endCol);

1038

var deletedLines = this.$lines.slice(firstRow, lastRow + 1);

1039

1040

this.applyDelta({

1041

start: range.start,

1042

end: range.end,

1043

action: "remove",

1044

lines: this.getLinesForRange(range)

1045

});

1046

return deletedLines;

1047

};

1048

this.removeNewLine = function(row) {

1049

if (row < this.getLength() - 1 && row >= 0) {

1050

this.applyDelta({

1051

start: this.pos(row, this.getLine(row).length),

1052

end: this.pos(row + 1, 0),

action: "remove",

lines: ["", ""]

});

}

};

this.replace = function(range, text) {

1059

if (!(range instanceof Range))

1060

range = Range.fromPoints(range.start, range.end);

1061

if (text.length === 0 && range.isEmpty())

1062

return range.start;

1063

if (text == this.getTextRange(range))

1064

return range.end;

1065

1066

this.remove(range);

1067

var end;

1068

if (text) {

1069

end = this.insert(range.start, text);

}

else {

end = range.start;

}

return end;

};

this.applyDeltas = function(deltas) {

1078

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

1079

this.applyDelta(deltas[i]);

1080

}

1081

};

1082

this.revertDeltas = function(deltas) {

1083

for (var i=deltas.length-1; i>=0; i--) {

1084

this.revertDelta(deltas[i]);

1085

}

1086

};

1087

this.applyDelta = function(delta, doNotValidate) {

1088

var isInsert = delta.action == "insert";

1089

if (isInsert ? delta.lines.length <= 1 && !delta.lines[0]

1090

: !Range.comparePoints(delta.start, delta.end)) {

return;

}

if (isInsert && delta.lines.length > 20000)

1095

this.$splitAndapplyLargeDelta(delta, 20000);

1096

applyDelta(this.$lines, delta, doNotValidate);

1097

this._signal("change", delta);

1098

};

1099

1100

this.$splitAndapplyLargeDelta = function(delta, MAX) {

1101

var lines = delta.lines;

1102

var l = lines.length;

1103

var row = delta.start.row;

1104

var column = delta.start.column;

1105

var from = 0, to = 0;

do {

from = to;

to += MAX - 1;

var chunk = lines.slice(from, to);

1110

if (to > l) {

1111

delta.lines = chunk;

1112

delta.start.row = row + from;

1113

delta.start.column = column;

break;

}

chunk.push("");

this.applyDelta({

start: this.pos(row + from, column),

1119

end: this.pos(row + to, column = 0),

1120

action: delta.action,

lines: chunk

}, true);

} while(true);

};

this.revertDelta = function(delta) {

1126

this.applyDelta({

1127

start: this.clonePos(delta.start),

1128

end: this.clonePos(delta.end),

1129

action: (delta.action == "insert" ? "remove" : "insert"),

1130

lines: delta.lines.slice()

1131

});

1132

};

1133

this.indexToPosition = function(index, startRow) {

1134

var lines = this.$lines || this.getAllLines();

1135

var newlineLength = this.getNewLineCharacter().length;

1136

for (var i = startRow || 0, l = lines.length; i < l; i++) {

1137

index -= lines[i].length + newlineLength;

1138

if (index < 0)

1139

return {row: i, column: index + lines[i].length + newlineLength};

1140

}

1141

return {row: l-1, column: lines[l-1].length};

1142

};

1143

this.positionToIndex = function(pos, startRow) {

1144

var lines = this.$lines || this.getAllLines();

1145

var newlineLength = this.getNewLineCharacter().length;

1146

var index = 0;

1147

var row = Math.min(pos.row, lines.length);

1148

for (var i = startRow || 0; i < row; ++i)

1149

index += lines[i].length + newlineLength;

1150

1151

return index + pos.column;

1152

};

1153

1154

}).call(Document.prototype);

1155

1156

exports.Document = Document;

1157

});

1158

1159

ace.define("ace/lib/lang",["require","exports","module"], function(require, exports, module) {

1160

"use strict";

1161

1162

exports.last = function(a) {

1163

return a[a.length - 1];

1164

};

1165

1166

exports.stringReverse = function(string) {

1167

return string.split("").reverse().join("");

1168

};

1169

1170

exports.stringRepeat = function (string, count) {

1171

var result = '';

1172

while (count > 0) {

if (count & 1)

result += string;

if (count >>= 1)

string += string;

}

return result;

};

var trimBeginRegexp = /^\s\s*/;

1183

var trimEndRegexp = /\s\s*$/;

1184

1185

exports.stringTrimLeft = function (string) {

1186

return string.replace(trimBeginRegexp, '');

1187

};

1188

1189

exports.stringTrimRight = function (string) {

1190

return string.replace(trimEndRegexp, '');

1191

};

1192

1193

exports.copyObject = function(obj) {

1194

var copy = {};

1195

for (var key in obj) {

1196

copy[key] = obj[key];

}

return copy;

};

exports.copyArray = function(array){

1202

var copy = [];

1203

for (var i=0, l=array.length; i<l; i++) {

1204

if (array[i] && typeof array[i] == "object")

1205

copy[i] = this.copyObject(array[i]);

1206

else

1207

copy[i] = array[i];

}

return copy;

};

exports.deepCopy = function deepCopy(obj) {

1213

if (typeof obj !== "object" || !obj)

1214

return obj;

1215

var copy;

1216

if (Array.isArray(obj)) {

1217

copy = [];

1218

for (var key = 0; key < obj.length; key++) {

1219

copy[key] = deepCopy(obj[key]);

}

return copy;

}

if (Object.prototype.toString.call(obj) !== "[object Object]")

return obj;

copy = {};

for (var key in obj)

1228

copy[key] = deepCopy(obj[key]);

return copy;

};

exports.arrayToMap = function(arr) {

1233

var map = {};

1234

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

map[arr[i]] = 1;

}

return map;

};

exports.createMap = function(props) {

1242

var map = Object.create(null);

1243

for (var i in props) {

map[i] = props[i];

}

return map;

};

exports.arrayRemove = function(array, value) {

1249

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

1250

if (value === array[i]) {

1251

array.splice(i, 1);

}

}

};

exports.escapeRegExp = function(str) {

1257

return str.replace(/([.*+?^${}()|[\]\/\\])/g, '\\$1');

1258

};

1259

1260

exports.escapeHTML = function(str) {

1261

return str.replace(/&/g, "&").replace(/"/g, """).replace(/'/g, "'").replace(/g, "<");

1262

};

1263

1264

exports.getMatchOffsets = function(string, regExp) {

1265

var matches = [];

1266

1267

string.replace(regExp, function(str) {

1268

matches.push({

1269

offset: arguments[arguments.length-2],

length: str.length

});

});

return matches;

};

exports.deferredCall = function(fcn) {

1277

var timer = null;

1278

var callback = function() {

timer = null;

fcn();

};

var deferred = function(timeout) {

1284

deferred.cancel();

1285

timer = setTimeout(callback, timeout || 0);

return deferred;

};

deferred.schedule = deferred;

1290

1291

deferred.call = function() {

this.cancel();

fcn();

return deferred;

};

deferred.cancel = function() {

1298

clearTimeout(timer);

timer = null;

return deferred;

};

deferred.isPending = function() {

return timer;

};

return deferred;

};

exports.delayedCall = function(fcn, defaultTimeout) {

1312

var timer = null;

1313

var callback = function() {

timer = null;

fcn();

};

var _self = function(timeout) {

1319

if (timer == null)

1320

timer = setTimeout(callback, timeout || defaultTimeout);

1321

};

1322

1323

_self.delay = function(timeout) {

1324

timer && clearTimeout(timer);

1325

timer = setTimeout(callback, timeout || defaultTimeout);

1326

};

1327

_self.schedule = _self;

1328

1329

_self.call = function() {

this.cancel();

fcn();

};

_self.cancel = function() {

1335

timer && clearTimeout(timer);

timer = null;

};

_self.isPending = function() {

return timer;

};

return _self;

};

});

ace.define("ace/worker/mirror",["require","exports","module","ace/range","ace/document","ace/lib/lang"], function(require, exports, module) {

1348

"use strict";

1349

1350

var Range = require("../range").Range;

1351

var Document = require("../document").Document;

1352

var lang = require("../lib/lang");

1353

1354

var Mirror = exports.Mirror = function(sender) {

1355

this.sender = sender;

1356

var doc = this.doc = new Document("");

1357

1358

var deferredUpdate = this.deferredUpdate = lang.delayedCall(this.onUpdate.bind(this));

1359

1360

var _self = this;

1361

sender.on("change", function(e) {

1362

var data = e.data;

1363

if (data[0].start) {

1364

doc.applyDeltas(data);

1365

} else {

1366

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

1367

if (Array.isArray(data[i+1])) {

1368

var d = {action: "insert", start: data[i], lines: data[i+1]};

1369

} else {

1370

var d = {action: "remove", start: data[i], end: data[i+1]};

1371

}

1372

doc.applyDelta(d, true);

1373

}

1374

}

1375

if (_self.$timeout)

1376

return deferredUpdate.schedule(_self.$timeout);

_self.onUpdate();

});

};

(function() {

this.$timeout = 500;

1384

1385

this.setTimeout = function(timeout) {

1386

this.$timeout = timeout;

1387

};

1388

1389

this.setValue = function(value) {

1390

this.doc.setValue(value);

1391

this.deferredUpdate.schedule(this.$timeout);

1392

};

1393

1394

this.getValue = function(callbackId) {

1395

this.sender.callback(this.doc.getValue(), callbackId);

1396

};

1397

1398

this.onUpdate = function() {

1399

};

1400

1401

this.isPending = function() {

1402

return this.deferredUpdate.isPending();

1403

};

1404

1405

}).call(Mirror.prototype);

});

ace.define("ace/mode/php/php",["require","exports","module"], function(require, exports, module) {

1410

1411

var PHP = {Constants:{}};

1412

1413

PHP.Constants.T_INCLUDE = 257;

1414

PHP.Constants.T_INCLUDE_ONCE = 258;

1415

PHP.Constants.T_EVAL = 259;

1416

PHP.Constants.T_REQUIRE = 260;

1417

PHP.Constants.T_REQUIRE_ONCE = 261;

1418

PHP.Constants.T_LOGICAL_OR = 262;

1419

PHP.Constants.T_LOGICAL_XOR = 263;

1420

PHP.Constants.T_LOGICAL_AND = 264;

1421

PHP.Constants.T_PRINT = 265;

1422

PHP.Constants.T_YIELD = 266;

1423

PHP.Constants.T_DOUBLE_ARROW = 267;

1424

PHP.Constants.T_YIELD_FROM = 268;

1425

PHP.Constants.T_PLUS_EQUAL = 269;

1426

PHP.Constants.T_MINUS_EQUAL = 270;

1427

PHP.Constants.T_MUL_EQUAL = 271;

1428

PHP.Constants.T_DIV_EQUAL = 272;

1429

PHP.Constants.T_CONCAT_EQUAL = 273;

1430

PHP.Constants.T_MOD_EQUAL = 274;

1431

PHP.Constants.T_AND_EQUAL = 275;

1432

PHP.Constants.T_OR_EQUAL = 276;

1433

PHP.Constants.T_XOR_EQUAL = 277;

1434

PHP.Constants.T_SL_EQUAL = 278;

1435

PHP.Constants.T_SR_EQUAL = 279;

1436

PHP.Constants.T_POW_EQUAL = 280;

1437

PHP.Constants.T_COALESCE = 281;

1438

PHP.Constants.T_BOOLEAN_OR = 282;

1439

PHP.Constants.T_BOOLEAN_AND = 283;

1440

PHP.Constants.T_IS_EQUAL = 284;

1441

PHP.Constants.T_IS_NOT_EQUAL = 285;

1442

PHP.Constants.T_IS_IDENTICAL = 286;

1443

PHP.Constants.T_IS_NOT_IDENTICAL = 287;

1444

PHP.Constants.T_SPACESHIP = 288;

1445

PHP.Constants.T_IS_SMALLER_OR_EQUAL = 289;

1446

PHP.Constants.T_IS_GREATER_OR_EQUAL = 290;

1447

PHP.Constants.T_SL = 291;

1448

PHP.Constants.T_SR = 292;

1449

PHP.Constants.T_INSTANCEOF = 293;

1450

PHP.Constants.T_INC = 294;

1451

PHP.Constants.T_DEC = 295;

1452

PHP.Constants.T_INT_CAST = 296;

1453

PHP.Constants.T_DOUBLE_CAST = 297;

1454

PHP.Constants.T_STRING_CAST = 298;

1455

PHP.Constants.T_ARRAY_CAST = 299;

1456

PHP.Constants.T_OBJECT_CAST = 300;

1457

PHP.Constants.T_BOOL_CAST = 301;

1458

PHP.Constants.T_UNSET_CAST = 302;

1459

PHP.Constants.T_POW = 303;

1460

PHP.Constants.T_NEW = 304;

1461

PHP.Constants.T_CLONE = 305;

1462

PHP.Constants.T_EXIT = 306;

1463

PHP.Constants.T_IF = 307;

1464

PHP.Constants.T_ELSEIF = 308;

1465

PHP.Constants.T_ELSE = 309;

1466

PHP.Constants.T_ENDIF = 310;

1467

PHP.Constants.T_LNUMBER = 311;

1468

PHP.Constants.T_DNUMBER = 312;

1469

PHP.Constants.T_STRING = 313;

1470

PHP.Constants.T_STRING_VARNAME = 314;

1471

PHP.Constants.T_VARIABLE = 315;

1472

PHP.Constants.T_NUM_STRING = 316;

1473

PHP.Constants.T_INLINE_HTML = 317;

1474

PHP.Constants.T_CHARACTER = 318;

1475

PHP.Constants.T_BAD_CHARACTER = 319;

1476

PHP.Constants.T_ENCAPSED_AND_WHITESPACE = 320;

1477

PHP.Constants.T_CONSTANT_ENCAPSED_STRING = 321;

1478

PHP.Constants.T_ECHO = 322;

1479

PHP.Constants.T_DO = 323;

1480

PHP.Constants.T_WHILE = 324;

1481

PHP.Constants.T_ENDWHILE = 325;

1482

PHP.Constants.T_FOR = 326;

1483

PHP.Constants.T_ENDFOR = 327;

1484

PHP.Constants.T_FOREACH = 328;

1485

PHP.Constants.T_ENDFOREACH = 329;

1486

PHP.Constants.T_DECLARE = 330;

1487

PHP.Constants.T_ENDDECLARE = 331;

1488

PHP.Constants.T_AS = 332;

1489

PHP.Constants.T_SWITCH = 333;

1490

PHP.Constants.T_ENDSWITCH = 334;

1491

PHP.Constants.T_CASE = 335;

1492

PHP.Constants.T_DEFAULT = 336;

1493

PHP.Constants.T_BREAK = 337;

1494

PHP.Constants.T_CONTINUE = 338;

1495

PHP.Constants.T_GOTO = 339;

1496

PHP.Constants.T_FUNCTION = 340;

1497

PHP.Constants.T_CONST = 341;

1498

PHP.Constants.T_RETURN = 342;

1499

PHP.Constants.T_TRY = 343;

1500

PHP.Constants.T_CATCH = 344;

1501

PHP.Constants.T_FINALLY = 345;

1502

PHP.Constants.T_THROW = 346;

1503

PHP.Constants.T_USE = 347;

1504

PHP.Constants.T_INSTEADOF = 348;

1505

PHP.Constants.T_GLOBAL = 349;

1506

PHP.Constants.T_STATIC = 350;

1507

PHP.Constants.T_ABSTRACT = 351;

1508

PHP.Constants.T_FINAL = 352;

1509

PHP.Constants.T_PRIVATE = 353;

1510

PHP.Constants.T_PROTECTED = 354;

1511

PHP.Constants.T_PUBLIC = 355;

1512

PHP.Constants.T_VAR = 356;

1513

PHP.Constants.T_UNSET = 357;

1514

PHP.Constants.T_ISSET = 358;

1515

PHP.Constants.T_EMPTY = 359;

1516

PHP.Constants.T_HALT_COMPILER = 360;

1517

PHP.Constants.T_CLASS = 361;

1518

PHP.Constants.T_TRAIT = 362;

1519

PHP.Constants.T_INTERFACE = 363;

1520

PHP.Constants.T_EXTENDS = 364;

1521

PHP.Constants.T_IMPLEMENTS = 365;

1522

PHP.Constants.T_OBJECT_OPERATOR = 366;

1523

PHP.Constants.T_LIST = 367;

1524

PHP.Constants.T_ARRAY = 368;

1525

PHP.Constants.T_CALLABLE = 369;

1526

PHP.Constants.T_CLASS_C = 370;

1527

PHP.Constants.T_TRAIT_C = 371;

1528

PHP.Constants.T_METHOD_C = 372;

1529

PHP.Constants.T_FUNC_C = 373;

1530

PHP.Constants.T_LINE = 374;

1531

PHP.Constants.T_FILE = 375;

1532

PHP.Constants.T_COMMENT = 376;

1533

PHP.Constants.T_DOC_COMMENT = 377;

1534

PHP.Constants.T_OPEN_TAG = 378;

1535

PHP.Constants.T_OPEN_TAG_WITH_ECHO = 379;

1536

PHP.Constants.T_CLOSE_TAG = 380;

1537

PHP.Constants.T_WHITESPACE = 381;

1538

PHP.Constants.T_START_HEREDOC = 382;

1539

PHP.Constants.T_END_HEREDOC = 383;

1540

PHP.Constants.T_DOLLAR_OPEN_CURLY_BRACES = 384;

1541

PHP.Constants.T_CURLY_OPEN = 385;

1542

PHP.Constants.T_PAAMAYIM_NEKUDOTAYIM = 386;

1543

PHP.Constants.T_NAMESPACE = 387;

1544

PHP.Constants.T_NS_C = 388;

1545

PHP.Constants.T_DIR = 389;

1546

PHP.Constants.T_NS_SEPARATOR = 390;

1547

PHP.Constants.T_ELLIPSIS = 391;

1548

1549

PHP.Lexer = function(src, ini) {

1550

var heredoc, heredocEndAllowed,

1551

1552

stateStack = ['INITIAL'], stackPos = 0,

1553

swapState = function(state) {

1554

stateStack[stackPos] = state;

1555

},

1556

pushState = function(state) {

1557

stateStack[++stackPos] = state;

1558

},

1559

popState = function() {

--stackPos;

},

shortOpenTag = ini === undefined || /^(on|true|1)$/i.test(ini.short_open_tag),

1564

openTag = shortOpenTag

1565

? /^(\<\?php(?:\r\n|[ \t\r\n])|<\?|\

1566