55 | x- fix copy/paste
56 | x- fix ctrl-shift
57 | x- fix find rendering
58 | x- fix ctrl-shift rendering
59 | x- refactor move.js
60 | x- remember caret x
61 | x- follow caret and scroll horizontally
62 | x- fix shift+delete
63 | x- fix jazz.focus()
64 | x- fix edge case of inserting/deleting on ~empty file
65 | x- implement start working on empty file
66 | x- fix sometimes last character is missing from render
67 | x- fix delete/backspace mark on edges
68 | x- refactor syntax indents into method
69 | x- empty segments cache on raw
70 | x- fix find selects
71 | x- fix first line finds problem
72 | x- fix history (again, sigh..)
73 | x- cache segments
74 | x- highlight matching block
75 | x- undo/redo and caret off visible range, does not rerender
76 | x- fix follow caret on history change
77 | x- add history before delete
78 | x- have default bindings and allow merge on top
79 | x- syntax highlight theme editor
80 | x- ctrl+/, shift+ctrl+/ -> comments
81 | x- bug: sometimes when there's one line, it blinks below like a double line
82 | x- also sometimes is blank entirely
83 | x- indent align on enter
84 | x- autofill matching bracket/curly/parens on edit with caret inbetween
85 | x- support tabs, tab width, indent change
86 | x- unify segments/blocks/lines/skipstring indexing
87 | in a way that all support dynamic operations
88 | and never reindex
89 | x- fix render on single line editing
90 | x- bring back blocks
91 | x- adjust row view
92 | x- bring back autocomplete
93 | x- optimize blocks using tokens
94 | x- blinking caret
95 | x- fix find
96 | x- syntax:
97 | x- skip long lines entirely
98 | x- bug: indent on enter breaks half the times
99 | x- bring back history
100 | x- rewrite views
101 | x- optimize mark
102 | x- optimize ctrl-shift move area
103 | x- refactor template
104 | x- bring back find
105 |
106 |
107 | -- doing ---------------------
108 |
109 |
110 |
111 |
112 | -- todo ----------------------
113 |
114 | - move caret blink/solid methods from main to view
115 | - pageBounds/rows in one method
116 | - keyboard combos (i.e ctrl+k-ctrl+b)
117 | - review/cleanup main
118 | x- vertical centering
119 | !- issues when rendering edits
120 |
121 | -- later ---------------------
122 |
123 | - highlight html/css/text
124 | - tweak skipstring to split on newlines, so segments can index by
125 | iterating, without using .raw
126 | - bindings
127 | - cmd+d (mac for f3)
128 | - double click + continue selection select by words
129 | - on scroll, clear raw debounce,
130 | maybe also have a debounced jobs list to add tasks and clear in bulk
131 | ideally should be implicit but idk
132 | !attempt was breaking certain syntax highlight
133 | - syntax:
134 | - look behind for regexps (must be nothing, or ([=:;)
135 |
136 | -- very later (v2) -----------
137 |
138 | - multiple carets/selections
139 | - implement replace using select all matches + .insert()
140 | - code folding
141 |
--------------------------------------------------------------------------------
/lib/area.js:
--------------------------------------------------------------------------------
1 | var Point = require('./point');
2 |
3 | module.exports = Area;
4 |
5 | function Area(a) {
6 | if (a) {
7 | this.begin = new Point(a.begin);
8 | this.end = new Point(a.end);
9 | } else {
10 | this.begin = new Point;
11 | this.end = new Point;
12 | }
13 | }
14 |
15 | Area.prototype.copy = function() {
16 | return new Area(this);
17 | };
18 |
19 | Area.prototype.get = function() {
20 | var s = [this.begin, this.end].sort(Point.sort);
21 | return new Area({
22 | begin: new Point(s[0]),
23 | end: new Point(s[1])
24 | });
25 | };
26 |
27 | Area.prototype.set = function(area) {
28 | this.begin.set(area.begin);
29 | this.end.set(area.end);
30 | };
31 |
32 | Area.prototype.setLeft = function(x) {
33 | this.begin.x = x;
34 | this.end.x = x;
35 | return this;
36 | };
37 |
38 | Area.prototype.addRight = function(x) {
39 | if (this.begin.x) this.begin.x += x;
40 | if (this.end.x) this.end.x += x;
41 | return this;
42 | };
43 |
44 | Area.prototype.addBottom = function(y) {
45 | this.end.y += y;
46 | return this;
47 | };
48 |
49 | Area.prototype.shiftByLines = function(y) {
50 | this.begin.y += y;
51 | this.end.y += y;
52 | };
53 |
54 | Area.prototype['>'] =
55 | Area.prototype.greaterThan = function(a) {
56 | return this.begin.y === a.end.y
57 | ? this.begin.x > a.end.x
58 | : this.begin.y > a.end.y;
59 | };
60 |
61 | Area.prototype['>='] =
62 | Area.prototype.greaterThanOrEqual = function(a) {
63 | return this.begin.y === a.begin.y
64 | ? this.begin.x >= a.begin.x
65 | : this.begin.y > a.begin.y;
66 | };
67 |
68 | Area.prototype['<'] =
69 | Area.prototype.lessThan = function(a) {
70 | return this.end.y === a.begin.y
71 | ? this.end.x < a.begin.x
72 | : this.end.y < a.begin.y;
73 | };
74 |
75 | Area.prototype['<='] =
76 | Area.prototype.lessThanOrEqual = function(a) {
77 | return this.end.y === a.end.y
78 | ? this.end.x <= a.end.x
79 | : this.end.y < a.end.y;
80 | };
81 |
82 | Area.prototype['><'] =
83 | Area.prototype.inside = function(a) {
84 | return this['>'](a) && this['<'](a);
85 | };
86 |
87 | Area.prototype['<>'] =
88 | Area.prototype.outside = function(a) {
89 | return this['<'](a) || this['>'](a);
90 | };
91 |
92 | Area.prototype['>=<'] =
93 | Area.prototype.insideEqual = function(a) {
94 | return this['>='](a) && this['<='](a);
95 | };
96 |
97 | Area.prototype['<=>'] =
98 | Area.prototype.outsideEqual = function(a) {
99 | return this['<='](a) || this['>='](a);
100 | };
101 |
102 | Area.prototype['==='] =
103 | Area.prototype.equal = function(a) {
104 | return this.begin.x === a.begin.x && this.begin.y === a.begin.y
105 | && this.end.x === a.end.x && this.end.y === a.end.y;
106 | };
107 |
108 | Area.prototype['|='] =
109 | Area.prototype.beginLineEqual = function(a) {
110 | return this.begin.y === a.begin.y;
111 | };
112 |
113 | Area.prototype['=|'] =
114 | Area.prototype.endLineEqual = function(a) {
115 | return this.end.y === a.end.y;
116 | };
117 |
118 | Area.prototype['|=|'] =
119 | Area.prototype.linesEqual = function(a) {
120 | return this['|='](a) && this['=|'](a);
121 | };
122 |
123 | Area.prototype['=|='] =
124 | Area.prototype.sameLine = function(a) {
125 | return this.begin.y === this.end.y && this.begin.y === a.begin.y;
126 | };
127 |
128 | Area.prototype['-x-'] =
129 | Area.prototype.shortenByX = function(x) {
130 | return new Area({
131 | begin: {
132 | x: this.begin.x + x,
133 | y: this.begin.y
134 | },
135 | end: {
136 | x: this.end.x - x,
137 | y: this.end.y
138 | }
139 | });
140 | };
141 |
142 | Area.prototype['+x+'] =
143 | Area.prototype.widenByX = function(x) {
144 | return new Area({
145 | begin: {
146 | x: this.begin.x - x,
147 | y: this.begin.y
148 | },
149 | end: {
150 | x: this.end.x + x,
151 | y: this.end.y
152 | }
153 | });
154 | };
155 |
156 | Area.offset = function(b, a) {
157 | return {
158 | begin: point.offset(b.begin, a.begin),
159 | end: point.offset(b.end, a.end)
160 | };
161 | };
162 |
163 | Area.offsetX = function(x, a) {
164 | return {
165 | begin: point.offsetX(x, a.begin),
166 | end: point.offsetX(x, a.end)
167 | };
168 | };
169 |
170 | Area.offsetY = function(y, a) {
171 | return {
172 | begin: point.offsetY(y, a.begin),
173 | end: point.offsetY(y, a.end)
174 | };
175 | };
176 |
177 | Area.prototype.toString = function(a) {
178 | return '' + a.begin + '-' + a.end;
179 | };
180 |
181 | Area.sort = function(a, b) {
182 | return a.begin.y === b.begin.y
183 | ? a.begin.x - b.begin.x
184 | : a.begin.y - b.begin.y;
185 | };
186 |
187 | Area.toPointSort = function(a, b) {
188 | return a.begin.y <= b.y && a.end.y >= b.y
189 | ? a.begin.y === b.y
190 | ? a.begin.x - b.x
191 | : a.end.y === b.y
192 | ? a.end.x - b.x
193 | : 0
194 | : a.begin.y - b.y;
195 | };
196 |
--------------------------------------------------------------------------------
/src/move.js:
--------------------------------------------------------------------------------
1 | var Regexp = require('../lib/regexp');
2 | var Event = require('../lib/event');
3 | var Point = require('../lib/point');
4 |
5 | var WORDS = Regexp.create(['words'], 'g');
6 |
7 | module.exports = Move;
8 |
9 | function Move(editor) {
10 | Event.call(this);
11 | this.editor = editor;
12 | this.lastDeliberateX = 0;
13 | }
14 |
15 | Move.prototype.__proto__ = Event.prototype;
16 |
17 | Move.prototype.pageDown = function(div) {
18 | div = div || 1;
19 | var page = this.editor.page.height / div | 0;
20 | var size = this.editor.size.height / div | 0;
21 | var remainder = size - page * this.editor.char.height | 0;
22 | this.editor.animateScrollBy(0, size - remainder);
23 | return this.byLines(page);
24 | };
25 |
26 | Move.prototype.pageUp = function(div) {
27 | div = div || 1;
28 | var page = this.editor.page.height / div | 0;
29 | var size = this.editor.size.height / div | 0;
30 | var remainder = size - page * this.editor.char.height | 0;
31 | this.editor.animateScrollBy(0, -(size - remainder));
32 | return this.byLines(-page);
33 | };
34 |
35 | var move = {};
36 |
37 | move.byWord = function(buffer, p, dx) {
38 | var line = buffer.getLineText(p.y);
39 |
40 | if (dx > 0 && p.x >= line.length - 1) { // at end of line
41 | return move.byChars(buffer, p, +1); // move one char right
42 | } else if (dx < 0 && p.x === 0) { // at begin of line
43 | return move.byChars(buffer, p, -1); // move one char left
44 | }
45 |
46 | var words = Regexp.parse(line, WORDS);
47 | var word;
48 |
49 | if (dx < 0) words.reverse();
50 |
51 | for (var i = 0; i < words.length; i++) {
52 | word = words[i];
53 | if (dx > 0
54 | ? word.index > p.x
55 | : word.index < p.x) {
56 | return {
57 | x: word.index,
58 | y: p.y
59 | };
60 | }
61 | }
62 |
63 | // reached begin/end of file
64 | return dx > 0
65 | ? move.endOfLine(buffer, p)
66 | : move.beginOfLine(buffer, p);
67 | };
68 |
69 | move.byChars = function(buffer, p, dx) {
70 | var x = p.x;
71 | var y = p.y;
72 |
73 | if (dx < 0) { // going left
74 | x += dx; // move left
75 | if (x < 0) { // when past left edge
76 | if (y > 0) { // and lines above
77 | y -= 1; // move up a line
78 | x = buffer.getLine(y).length; // and go to the end of line
79 | } else {
80 | x = 0;
81 | }
82 | }
83 | } else if (dx > 0) { // going right
84 | x += dx; // move right
85 | while (x - buffer.getLine(y).length > 0) { // while past line length
86 | if (y === buffer.loc()) { // on end of file
87 | x = buffer.getLine(y).length; // go to end of line on last line
88 | break; // and exit
89 | }
90 | x -= buffer.getLine(y).length + 1; // wrap this line length
91 | y += 1; // and move down a line
92 | }
93 | }
94 |
95 | this.lastDeliberateX = x;
96 |
97 | return {
98 | x: x,
99 | y: y
100 | };
101 | };
102 |
103 | move.byLines = function(buffer, p, dy) {
104 | var x = p.x;
105 | var y = p.y;
106 |
107 | if (dy < 0) { // going up
108 | if (y + dy > 0) { // when lines above
109 | y += dy; // move up
110 | } else {
111 | y = 0;
112 | }
113 | } else if (dy > 0) { // going down
114 | if (y < buffer.loc() - dy) { // when lines below
115 | y += dy; // move down
116 | } else {
117 | y = buffer.loc();
118 | }
119 | }
120 |
121 | // if (x > lines.getLine(y).length) {
122 | // x = lines.getLine(y).length;
123 | // } else {
124 | // }
125 | x = Math.min(this.lastDeliberateX, buffer.getLine(y).length);
126 |
127 | return {
128 | x: x,
129 | y: y
130 | };
131 | };
132 |
133 | move.beginOfLine = function(_, p) {
134 | this.lastDeliberateX = 0;
135 | return {
136 | x: 0,
137 | y: p.y
138 | };
139 | };
140 |
141 | move.endOfLine = function(buffer, p) {
142 | var x = buffer.getLine(p.y).length;
143 | this.lastDeliberateX = Infinity;
144 | return {
145 | x: x,
146 | y: p.y
147 | };
148 | };
149 |
150 | move.beginOfFile = function() {
151 | this.lastDeliberateX = 0;
152 | return {
153 | x: 0,
154 | y: 0
155 | };
156 | };
157 |
158 | move.endOfFile = function(buffer) {
159 | var last = buffer.loc();
160 | var x = buffer.getLine(last).length
161 | this.lastDeliberateX = x;
162 | return {
163 | x: x,
164 | y: last
165 | };
166 | };
167 |
168 | move.isBeginOfFile = function(_, p) {
169 | return p.x === 0 && p.y === 0;
170 | };
171 |
172 | move.isEndOfFile = function(buffer, p) {
173 | var last = buffer.loc();
174 | return p.y === last && p.x === buffer.getLine(last).length;
175 | };
176 |
177 | Object.keys(move).forEach(function(method) {
178 | Move.prototype[method] = function(param, byEdit) {
179 | var result = move[method].call(
180 | this,
181 | this.editor.buffer,
182 | this.editor.caret,
183 | param
184 | );
185 |
186 | if ('is' === method.slice(0,2)) return result;
187 |
188 | this.emit('move', result, byEdit);
189 | };
190 | });
191 |
--------------------------------------------------------------------------------
/test/index.js:
--------------------------------------------------------------------------------
1 |
2 | var AUTORUN = true;
3 | var BENCH = false;
4 | var BENCH_TIMES = 10e1;
5 |
6 | require.paths.push('/test');
7 | var suite = require('suite');
8 | var assert = require('assert');
9 | var test = require('test');
10 | var _bench = require('bench');
11 |
12 | var el = setup({
13 | // 'src/buffer/skipstring.test': ['src/buffer/skipstring'],
14 | // 'src/buffer/parts.test': ['src/buffer/parts'],
15 | 'src/buffer/test': ['src/buffer'],
16 | // 'src/buffer/prefixtree.test': ['src/buffer/prefixtree'],
17 | // 'src/history.test': ['src/history'],
18 | });
19 |
20 | append(document.body, el);
21 |
22 | if (AUTORUN) {
23 | setTimeout(function() {
24 | [].forEach.call(document.querySelectorAll('.execall'), function(el) {
25 | el.click();
26 | });
27 | setTimeout(function() {
28 | window.scrollTo(0, document.body.offsetHeight);
29 | })
30 | });
31 | }
32 |
33 | var render = {
34 | test: function(results) {
35 | return results.map(function(res) {
36 | if (!res.pass) setTimeout(function() {
37 | throw res.error;
38 | }, 0);
39 | return res.pass
40 | ? 'pass✓
'
41 | : 'fail𝀘
'
42 | + '' + res.error.message + '
'
43 | + ''
44 | + (res.error.meta && res.error.meta.left != null && res.error.meta.right != null
45 | ? 'Expected: ' + safe(res.error.meta.left)
46 | + '\n Actual: ' + safe(res.error.meta.right)
47 | : '')
48 | + '
'
49 | }).join(' ');
50 | },
51 | bench: function(results) {
52 | var totals = results.map(function(res) {
53 | return res.perframe;
54 | });
55 | var max = Math.max.apply(Math, totals);
56 | var html = results.map(function(res, i) {
57 | return '' + res.perframe + ' o/f
';
58 | }).join('');
59 | return html;
60 | }
61 | };
62 |
63 | function bench(fn) {
64 | assert.disable = true;
65 | var res = _bench(BENCH_TIMES, fn);
66 | assert.disable = false;
67 | return res;
68 | }
69 |
70 | function run(tests, caseName, fn) {
71 | return tests.map(function(t) {
72 | return fn(t[caseName]);
73 | });
74 | }
75 |
76 | function setup(obj) {
77 | var t = {};
78 |
79 | for (var key in obj) {
80 | var s = suite('..', key, obj[key]);
81 |
82 | var execs = {};
83 | execs.test = [];
84 | if (BENCH) execs.bench = [];
85 |
86 | var runners = [];
87 | runners.push(test);
88 | if (BENCH) runners.push(bench);
89 |
90 | t[key] = {
91 | suite: s,
92 | execs: execs,
93 | runners: runners
94 | };
95 | }
96 |
97 | var el = h('div', 'suite',
98 | Object.keys(t).map(function(key) {
99 | return h('div', 'item', [
100 | h('div', 'header', key),
101 | h('table', 'cases',
102 | [h('tr', null,
103 | [h('th')].concat(
104 | t[key].runners.map(function(runner) {
105 | var button = h('button', 'execall', runner.name + ' all');
106 | button.onclick = runAll(t[key].execs[runner.name]);
107 | return h('th', null, [button]);
108 | })
109 | )
110 | )].concat(
111 | Object.keys(t[key].suite[0]).map(function(caseName) {
112 | return h('tr', 'case', [
113 | h('td', 'name', caseName)
114 | ].concat(t[key].runners.map(function(runner) {
115 | var resultEl = h('div', 'result');
116 | var execEl = h('button', 'exec', runner.name);
117 | var onclick = function() {
118 | var results = run(t[key].suite, caseName, runner);
119 | var html = render[runner.name](results);
120 | resultEl.innerHTML = html;
121 | };
122 | t[key].execs[runner.name].push(onclick);
123 | execEl.onclick = onclick;
124 | return h('td', 'runner', [resultEl, execEl]);
125 | })))
126 | })
127 | )
128 | )
129 | ])
130 | })
131 | );
132 |
133 | return el;
134 | }
135 |
136 | function runAll(array) {
137 | return function() {
138 | array.map(function(fn) { fn() });
139 | };
140 | }
141 |
142 | function h(tag, className, children) {
143 | var el = document.createElement(tag);
144 | if (className) el.className = className;
145 | if (Array.isArray(children)) {
146 | children.forEach(append.bind(null, el));
147 | } else if (children) {
148 | el.innerHTML = children;
149 | }
150 | return el;
151 | }
152 |
153 | function append(target, el) {
154 | target.appendChild(el);
155 | return el;
156 | }
157 |
158 | function safe(text) {
159 | return text
160 | .replace(/&/g, '&')
161 | .replace(//g, '>');
163 | }
164 |
--------------------------------------------------------------------------------
/src/input/text.js:
--------------------------------------------------------------------------------
1 | var dom = require('../../lib/dom');
2 | var debounce = require('../../lib/debounce');
3 | var throttle = require('../../lib/throttle');
4 | var Event = require('../../lib/event');
5 |
6 | var THROTTLE = 0 //1000/62;
7 |
8 | var map = {
9 | 8: 'backspace',
10 | 9: 'tab',
11 | 13: 'enter',
12 | 33: 'pageup',
13 | 34: 'pagedown',
14 | 35: 'end',
15 | 36: 'home',
16 | 37: 'left',
17 | 38: 'up',
18 | 39: 'right',
19 | 40: 'down',
20 | 46: 'delete',
21 | 48: '0',
22 | 49: '1',
23 | 50: '2',
24 | 51: '3',
25 | 52: '4',
26 | 53: '5',
27 | 54: '6',
28 | 55: '7',
29 | 56: '8',
30 | 57: '9',
31 | 65: 'a',
32 | 68: 'd',
33 | 70: 'f',
34 | 77: 'm',
35 | 78: 'n',
36 | 83: 's',
37 | 89: 'y',
38 | 90: 'z',
39 | 112: 'f1',
40 | 114: 'f3',
41 | 122: 'f11',
42 | 188: ',',
43 | 190: '.',
44 | 191: '/',
45 |
46 | // numpad
47 | 97: 'end',
48 | 98: 'down',
49 | 99: 'pagedown',
50 | 100: 'left',
51 | 102: 'right',
52 | 103: 'home',
53 | 104: 'up',
54 | 105: 'pageup',
55 | };
56 |
57 | module.exports = Text;
58 |
59 | Text.map = map;
60 |
61 | function Text() {
62 | Event.call(this);
63 |
64 | this.el = document.createElement('textarea');
65 |
66 | dom.style(this, {
67 | position: 'absolute',
68 | left: 0,
69 | top: 0,
70 | width: 1,
71 | height: 1,
72 | opacity: 0
73 | });
74 |
75 | dom.attrs(this, {
76 | autocapitalize: 'none',
77 | autocomplete: 'off',
78 | spellchecking: 'off',
79 | });
80 |
81 | this.throttleTime = 0;
82 | this.modifiers = {};
83 | this.bindEvent();
84 | }
85 |
86 | Text.prototype.__proto__ = Event.prototype;
87 |
88 | Text.prototype.bindEvent = function() {
89 | this.oncut = this.oncut.bind(this);
90 | this.oncopy = this.oncopy.bind(this);
91 | this.onpaste = this.onpaste.bind(this);
92 | this.oninput = this.oninput.bind(this);
93 | this.onkeydown = this.onkeydown.bind(this);
94 | this.onkeyup = this.onkeyup.bind(this);
95 | this.el.onblur = this.emit.bind(this, 'blur');
96 | this.el.onfocus = this.emit.bind(this, 'focus');
97 | this.el.oninput = this.oninput;
98 | this.el.onkeydown = this.onkeydown;
99 | this.el.onkeyup = this.onkeyup;
100 | this.el.oncut = this.oncut;
101 | this.el.oncopy = this.oncopy;
102 | this.el.onpaste = this.onpaste;
103 | };
104 |
105 | Text.prototype.reset = function() {
106 | this.set('');
107 | this.modifiers = {};
108 | }
109 |
110 | Text.prototype.get = function() {
111 | return this.el.value.substr(-1);
112 | };
113 |
114 | Text.prototype.set = function(value) {
115 | this.el.value = value;
116 | };
117 |
118 | //TODO: on mobile we need to clear without debounce
119 | // or the textarea content is displayed in hacker's keyboard
120 | // or you need to disable word suggestions in hacker's keyboard settings
121 | Text.prototype.clear = throttle(function() {
122 | this.set('');
123 | }, 2000);
124 |
125 | Text.prototype.blur = function() {
126 | // console.log('focus')
127 | this.el.blur();
128 | };
129 |
130 | Text.prototype.focus = function() {
131 | // console.log('focus')
132 | this.el.focus();
133 | };
134 |
135 | Text.prototype.oninput = function(e) {
136 | e.preventDefault();
137 | // forces caret to end of textarea so we can get .slice(-1) char
138 | setImmediate(() => this.el.selectionStart = this.el.value.length);
139 | this.emit('text', this.get());
140 | this.clear();
141 | return false;
142 | };
143 |
144 | Text.prototype.onkeydown = function(e) {
145 | // console.log(e.which);
146 | var now = Date.now();
147 | if (now - this.throttleTime < THROTTLE) {
148 | e.preventDefault();
149 | return false;
150 | }
151 | this.throttleTime = now;
152 |
153 | var m = this.modifiers;
154 | m.shift = e.shiftKey;
155 | m.ctrl = e.ctrlKey;
156 | m.alt = e.altKey;
157 |
158 | var keys = [];
159 | if (m.shift) keys.push('shift');
160 | if (m.ctrl) keys.push('ctrl');
161 | if (m.alt) keys.push('alt');
162 | if (e.which in map) keys.push(map[e.which]);
163 |
164 | if (keys.length) {
165 | var press = keys.join('+');
166 | this.emit('keys', press, e);
167 | this.emit(press, e);
168 | keys.forEach((press) => this.emit('key', press, e));
169 | }
170 | };
171 |
172 | Text.prototype.onkeyup = function(e) {
173 | this.throttleTime = 0;
174 |
175 | var m = this.modifiers;
176 |
177 | var keys = [];
178 | if (m.shift && !e.shiftKey) keys.push('shift:up');
179 | if (m.ctrl && !e.ctrlKey) keys.push('ctrl:up');
180 | if (m.alt && !e.altKey) keys.push('alt:up');
181 |
182 | m.shift = e.shiftKey;
183 | m.ctrl = e.ctrlKey;
184 | m.alt = e.altKey;
185 |
186 | if (m.shift) keys.push('shift');
187 | if (m.ctrl) keys.push('ctrl');
188 | if (m.alt) keys.push('alt');
189 | if (e.which in map) keys.push(map[e.which] + ':up');
190 |
191 | if (keys.length) {
192 | var press = keys.join('+');
193 | this.emit('keys', press, e);
194 | this.emit(press, e);
195 | keys.forEach((press) => this.emit('key', press, e));
196 | }
197 | };
198 |
199 | Text.prototype.oncut = function(e) {
200 | e.preventDefault();
201 | this.emit('cut', e);
202 | };
203 |
204 | Text.prototype.oncopy = function(e) {
205 | e.preventDefault();
206 | this.emit('copy', e);
207 | };
208 |
209 | Text.prototype.onpaste = function(e) {
210 | e.preventDefault();
211 | this.emit('paste', e);
212 | };
213 |
--------------------------------------------------------------------------------
/test/syntax.html.js:
--------------------------------------------------------------------------------
1 | function foo() {
2 | with(something) {
3 | inside(123);
4 | }
5 | }
6 |
7 | var Syntax = require('../src/syntax');
8 | var syntax = new Syntax;
9 |
10 | var x=5/5;
11 | var code = '/* above */\n\nvar foo = "bar";\n\n'
12 | // + broken3.toString() + '\n\n'
13 | // + broken2.toString() + '\n\n'
14 | + broken.toString() + '\n\n'
15 | + sample.toString();
16 |
17 | var div = document.createElement('div');
18 | div.className = 'code';
19 |
20 | syntax.set(code);
21 |
22 | var offset = 125;
23 | var html = syntax.highlight(code.slice(offset), offset);
24 |
25 | div.innerHTML = html;
26 |
27 | document.body.appendChild(div);
28 |
29 |
30 | function sample(block, cls) {
31 | try {
32 | if (cls.search(/\bno\-highlight\b/) != -1)
33 | return process(block, true, 0x0F) +
34 | // ` class="${cls}"`;
35 | } catch (e) {
36 | // handle exception
37 | }
38 |
39 | for (var i = 0 / 2; i < classes.length; i++) {
40 | if (checkCondition(classes[i]) === undefined)
41 | console.log('undefined');
42 | }
43 | }
44 |
45 | function broken() {
46 | // foo
47 | // foo
48 |
49 | /*
50 |
51 | something comment
52 |
53 | */
54 |
55 | var foo;
56 |
57 | /*
58 | some other comment
59 | */
60 |
61 | module.exports = Duplex;
62 |
63 | /**/
64 | var objectKeys = Object.keys || function (obj) {
65 | var keys = [];
66 | for (var key in obj) keys.push(key);
67 | return keys;
68 | }
69 | /**/
70 |
71 |
72 | /**/
73 | var util = require('core-util-is');
74 | util.inherits = require('inherits');
75 | /**/
76 |
77 | var Readable = require('./_stream_readable');
78 | var Writable = require('./_stream_writable');
79 |
80 | util.inherits(Duplex, Readable);
81 |
82 | forEach(objectKeys(Writable.prototype), function(method) {
83 | if (!Duplex.prototype[method])
84 | Duplex.prototype[method] = Writable.prototype[method];
85 | });
86 | }
87 |
88 | function broken2() {
89 | // Generated by `tools/generate-identifier-regex.js`.
90 |
91 | var nonASCIIidentifierStartChars = "ªµºÀ-ÖØ-öø-ˈ-Ë‘Ë -ˤˬˮͰ-ʹͶͷͺ-ͽͿΆΈ-ΊΌΎ-ΡΣ-ϵϷ-ÒÒŠ-Ô¯Ô±-Õ–Õ™Õ¡-Ö‡×-תװ-×²Ø -يٮٯٱ-Û“Û•Û¥Û¦Û®Û¯Ûº-Û¼Û¿ÜÜ’-ܯÝ-ޥޱߊ-ßªß´ßµßºà €-à •à šà ¤à ¨à¡€-ࡘࢠ-ࢲऄ-हऽà¥à¥˜-ॡॱ-ঀঅ-ঌà¦à¦à¦“-নপ-রলশ-হঽৎড়à§à§Ÿ-ৡৰৱਅ-ਊà¨à¨à¨“-ਨਪ-ਰਲਲ਼ਵਸ਼ਸਹਖ਼-ੜਫ਼ੲ-ੴઅ-àªàª-ઑઓ-નપ-રલળવ-હઽà«à« ૡଅ-ଌà¬à¬à¬“-ନପ-ରଲଳଵ-ହଽàœààŸ-à¡à±à®ƒà®…-ஊஎ-à®à®’-கஙசஜஞடணதந-பம-ஹà¯à°…-ఌఎ-à°à°’-నప-హఽౘౙౠౡಅ-ಌಎ-à²à²’-ನಪ-ಳವ-ಹಽೞೠೡೱೲഅ-ഌഎ-à´à´’-ഺഽൎൠൡൺ-ൿඅ-ඖක-නඳ-රලව-à·†à¸-ะาำเ-ๆàºàº‚ຄງຈຊàºàº”-ທນ-ຟມ-ຣລວສຫàº-ະາຳຽເ-ໄໆໜ-ໟༀཀ-ཇཉ-ཬྈ-ྌက-ဪဿá-á•áš-áá¡á¥á¦á®-á°áµ-á‚á‚Žá‚ -ჅჇáƒáƒ-ჺჼ-ቈቊ-á‰á‰-ቖቘቚ-á‰á‰ -ኈኊ-áŠáŠ-ኰኲ-ኵኸ-ኾዀዂ-ዅወ-ዖዘ-áŒáŒ’-ጕጘ-ášáŽ€-áŽáŽ -á´á-ᙬᙯ-ᙿáš-áššáš -ᛪᛮ-ᛸᜀ-ᜌᜎ-ᜑᜠ-ᜱá€-á‘á -á¬á®-á°áž€-ឳៗៜá -ᡷᢀ-ᢨᢪᢰ-ᣵᤀ-ᤞá¥-á¥á¥°-ᥴᦀ-ᦫá§-ᧇᨀ-ᨖᨠ-ᩔᪧᬅ-ᬳá…-á‹á®ƒ-ᮠᮮᮯᮺ-ᯥᰀ-á°£á±-á±á±š-ᱽᳩ-ᳬᳮ-ᳱᳵᳶᴀ-ᶿḀ-ἕἘ-á¼á¼ -ὅὈ-á½á½-ὗὙὛá½á½Ÿ-ώᾀ-ᾴᾶ-ᾼιῂ-ῄῆ-á¿Œá¿-á¿“á¿–-Ίῠ-Ῥῲ-ῴῶ-ῼâ±â¿â‚-ₜℂℇℊ-ℓℕ℘-â„ℤΩℨK-ℹℼ-â„¿â……-â…‰â…Žâ… -ↈⰀ-Ⱞⰰ-ⱞⱠ-ⳤⳫ-ⳮⳲⳳⴀ-ⴥⴧâ´â´°-ⵧⵯⶀ-ⶖⶠ-ⶦⶨ-ⶮⶰ-ⶶⶸ-ⶾⷀ-ⷆⷈ-â·Žâ·-â·–â·˜-ⷞ々-〇〡-〩〱-〵〸-〼ã-ã‚–ã‚›-ã‚Ÿã‚¡-ヺー-ヿㄅ-ã„ㄱ-ㆎㆠ-ㆺㇰ-ㇿã€-䶵一-鿌ꀀ-ê’Œê“-ꓽꔀ-ꘌê˜-ꘟꘪꘫꙀ-ꙮꙿ-êšêš -ꛯꜗ-ꜟꜢ-ꞈꞋ-ꞎêž-êžêž°êž±êŸ·-ê ê ƒ-ê …ê ‡-ê Šê Œ-ê ¢ê¡€-ꡳꢂ-ꢳꣲ-ꣷꣻꤊ-ꤥꤰ-ê¥†ê¥ -ꥼꦄ-ꦲê§ê§ -ꧤꧦ-ꧯꧺ-ꧾꨀ-ꨨꩀ-ê©‚ê©„-ê©‹ê© -ꩶꩺꩾ-ꪯꪱꪵꪶꪹ-ꪽꫀꫂꫛ-ê«ê« -ꫪꫲ-ê«´ê¬-ꬆꬉ-ꬎꬑ-ê¬–ê¬ -ꬦꬨ-ꬮꬰ-êšêœ-êŸê¤ê¥ê¯€-ꯢ가-힣ힰ-ퟆퟋ-ퟻ豈-ï©ï©°-龎ff-stﬓ-ﬗï¬ï¬Ÿ-ﬨשׁ-זּטּ-לּמּï€ïïƒï„ï†-ﮱﯓ-ï´½ïµ-ï¶ï¶’-ﷇﷰ-ﷻﹰ-ﹴﹶ-ﻼＡ-Ｚï½-ｚｦ-ﾾￂ-ￇￊ-ï¿ï¿’-ï¿—ï¿š-ï¿œ";
92 | var nonASCIIidentifierChars = "‌â€Â·Ì€-ͯ·҃-Ò‡Ö‘-Ö½Ö¿×ׇׂׅׄØ-ØšÙ‹-٩ٰۖ-ۜ۟-Û¤Û§Û¨Ûª-ÛÛ°-۹ܑܰ-ÝŠÞ¦-ް߀-߉߫-ß³à –-à ™à ›-à £à ¥-à §à ©-à à¡™-࡛ࣤ-ःऺ-़ा-à¥à¥‘-ॗॢॣ०-९à¦-ঃ়া-ৄেৈো-à§à§—ৢৣ০-৯à¨-ਃ਼ਾ-ੂੇੈੋ-à©à©‘੦-ੱੵàª-ઃ઼ા-ૅે-ૉો-à«à«¢à«£à«¦-૯à¬-ଃ଼ା-à„à‡àˆà‹-àà–à—à¢à£à¦-à¯à®‚ா-ூெ-ைொ-à¯à¯—௦-௯ఀ-ఃా-ౄె-ైొ-à±à±•à±–ౢౣ౦-౯à²-ಃ಼ಾ-ೄೆ-ೈೊ-à³à³•à³–ೢೣ೦-೯à´-ഃാ-ൄെ-ൈൊ-àµàµ—ൢൣ൦-൯ංඃ්à·-ුූෘ-à·Ÿà·¦-෯ෲෳัิ-ฺ็-๎à¹-๙ັິ-ູົຼ່-à»à»-໙༘༙༠-༩༹༵༷༾༿ཱ-྄྆྇à¾-ྗྙ-ྼ࿆ါ-ှá€-á‰á–-á™áž-á á¢-á¤á§-áá±-á´á‚‚-á‚á‚-á‚á-áŸá©-á±áœ’-᜔ᜲ-᜴á’á“á²á³áž´-៓áŸáŸ -áŸ©á ‹-á á -á ™á¢©á¤ -ᤫᤰ-᤻᥆-á¥á¦°-ᧀᧈᧉá§-᧚ᨗ-ᨛᩕ-á©žá© -᩿᩼-᪉áª-᪙᪰-᪽ᬀ-ᬄ᬴-á„á-á™á«-á³á®€-ᮂᮡ-á®á®°-᮹᯦-᯳ᰤ-á°·á±€-᱉á±-á±™á³-á³’á³”-᳨á³á³²-᳴᳸᳹᷀-᷵᷼-᷿‿â€â”âƒ-⃥⃜⃡-⃰⳯-⵿⳱ⷠ-〪ⷿ-ã€¯ã‚™ã‚šê˜ -꘩꙯ꙴ-ê™½êšŸê›°ê›±ê ‚ê †ê ‹ê £-ê §ê¢€ê¢ê¢´-꣄ê£-ê£™ê£ -꣱꤀-꤉ꤦ-ê¤ê¥‡-꥓ꦀ-ꦃ꦳-꧀ê§-꧙ꧥ꧰-꧹ꨩ-ꨶꩃꩌê©ê©-꩙ꩻ-ꩽꪰꪲ-ꪴꪷꪸꪾ꪿ê«ê««-ꫯꫵ꫶ꯣ-ꯪ꯬ê¯ê¯°-꯹ﬞ︀-ï¸ï¸ -ï¸ï¸³ï¸´ï¹-ï¹ï¼-９＿";
93 |
94 | var nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
95 | var nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
96 | }
97 |
98 | function broken3() {
99 | {
100 | if (e.find.isOpen) {
101 | e.onFindValue(e.findValue, true);
102 | }
103 | /*
104 | if ((!editShift) && textBefore) {
105 | if (textAfter) textBefore += textAfter;
106 | for (var i = 0; i < SPECIAL_SEGMENTS.length; i++) {
107 | if (~textBefore.indexOf(SPECIAL_SEGMENTS[i])) {
108 | this.views.code.clearBelow(e.editLine);
109 | this.buffer.updateRaw();
110 | break;
111 | }
112 | }
113 | }
114 | */
115 | // this.history.save();
116 | this.render();
117 | };
118 |
119 | }
--------------------------------------------------------------------------------
/src/buffer/parts.js:
--------------------------------------------------------------------------------
1 | var binarySearch = require('../../lib/binary-search');
2 |
3 | module.exports = Parts;
4 |
5 | function Parts(minSize) {
6 | minSize = minSize || 5000;
7 | this.minSize = minSize;
8 | this.parts = [];
9 | this.length = 0;
10 | }
11 |
12 | Parts.prototype.push = function(item) {
13 | this.append([item]);
14 | };
15 |
16 | Parts.prototype.append = function(items) {
17 | var part = last(this.parts);
18 |
19 | if (!part) {
20 | part = [];
21 | part.startIndex = 0;
22 | part.startOffset = 0;
23 | this.parts.push(part);
24 | }
25 | else if (part.length >= this.minSize) {
26 | var startIndex = part.startIndex + part.length;
27 | var startOffset = items[0];
28 |
29 | part = [];
30 | part.startIndex = startIndex;
31 | part.startOffset = startOffset;
32 | this.parts.push(part);
33 | }
34 |
35 | part.push.apply(part, items.map(offset => offset - part.startOffset));
36 |
37 | this.length += items.length;
38 | };
39 |
40 | Parts.prototype.get = function(index) {
41 | var part = this.findPartByIndex(index).item;
42 | return part[index - part.startIndex] + part.startOffset;
43 | };
44 |
45 | Parts.prototype.find = function(offset) {
46 | var p = this.findPartByOffset(offset);
47 | if (!p.item) return null;
48 |
49 | var part = p.item;
50 | var partIndex = p.index;
51 | var o = this.findOffsetInPart(offset, part);
52 | return {
53 | offset: o.item + part.startOffset,
54 | index: o.index + part.startIndex,
55 | local: o.index,
56 | part: part,
57 | partIndex: partIndex
58 | };
59 | };
60 |
61 | Parts.prototype.insert = function(offset, array) {
62 | var o = this.find(offset);
63 | if (!o) {
64 | return this.append(array);
65 | }
66 | if (o.offset > offset) o.local = -1;
67 | var length = array.length;
68 | //TODO: maybe subtract 'offset' instead ?
69 | array = array.map(el => el -= o.part.startOffset);
70 | insert(o.part, o.local + 1, array);
71 | this.shiftIndex(o.partIndex + 1, -length);
72 | this.length += length;
73 | };
74 |
75 | Parts.prototype.shiftOffset = function(offset, shift) {
76 | var parts = this.parts;
77 | var item = this.find(offset);
78 | if (!item) return;
79 | if (offset > item.offset) item.local += 1;
80 |
81 | var removed = 0;
82 | for (var i = item.local; i < item.part.length; i++) {
83 | item.part[i] += shift;
84 | if (item.part[i] + item.part.startOffset < offset) {
85 | removed++;
86 | item.part.splice(i--, 1);
87 | }
88 | }
89 | if (removed) {
90 | this.shiftIndex(item.partIndex + 1, removed);
91 | this.length -= removed;
92 | }
93 | for (var i = item.partIndex + 1; i < parts.length; i++) {
94 | parts[i].startOffset += shift;
95 | if (parts[i].startOffset < offset) {
96 | if (last(parts[i]) + parts[i].startOffset < offset) {
97 | removed = parts[i].length;
98 | this.shiftIndex(i + 1, removed);
99 | this.length -= removed;
100 | parts.splice(i--, 1);
101 | } else {
102 | this.removeBelowOffset(offset, parts[i]);
103 | }
104 | }
105 | }
106 | };
107 |
108 | Parts.prototype.removeRange = function(range) {
109 | var a = this.find(range[0]);
110 | var b = this.find(range[1]);
111 | if (!a && !b) return;
112 |
113 | if (a.partIndex === b.partIndex) {
114 | if (a.offset >= range[1] || a.offset < range[0]) a.local += 1;
115 | if (b.offset >= range[1] || b.offset < range[0]) b.local -= 1;
116 | var shift = remove(a.part, a.local, b.local + 1).length;
117 | this.shiftIndex(a.partIndex + 1, shift);
118 | this.length -= shift;
119 | } else {
120 | if (a.offset >= range[1] || a.offset < range[0]) a.local += 1;
121 | if (b.offset >= range[1] || b.offset < range[0]) b.local -= 1;
122 | var shiftA = remove(a.part, a.local).length;
123 | var shiftB = remove(b.part, 0, b.local + 1).length;
124 | if (b.partIndex - a.partIndex > 1) {
125 | var removed = remove(this.parts, a.partIndex + 1, b.partIndex);
126 | var shiftBetween = removed.reduce((p,n) => p + n.length, 0);
127 | b.part.startIndex -= shiftA + shiftBetween;
128 | this.shiftIndex(b.partIndex - removed.length + 1, shiftA + shiftB + shiftBetween);
129 | this.length -= shiftA + shiftB + shiftBetween;
130 | } else {
131 | b.part.startIndex -= shiftA;
132 | this.shiftIndex(b.partIndex + 1, shiftA + shiftB);
133 | this.length -= shiftA + shiftB;
134 | }
135 | }
136 |
137 | //TODO: this is inefficient as we can calculate the indexes ourselves
138 | if (!a.part.length) {
139 | this.parts.splice(this.parts.indexOf(a.part), 1);
140 | }
141 | if (!b.part.length) {
142 | this.parts.splice(this.parts.indexOf(b.part), 1);
143 | }
144 | };
145 |
146 | Parts.prototype.shiftIndex = function(startIndex, shift) {
147 | for (var i = startIndex; i < this.parts.length; i++) {
148 | this.parts[i].startIndex -= shift;
149 | }
150 | };
151 |
152 | Parts.prototype.removeBelowOffset = function(offset, part) {
153 | var o = this.findOffsetInPart(offset, part)
154 | var shift = remove(part, 0, o.index).length;
155 | this.shiftIndex(o.partIndex + 1, shift);
156 | this.length -= shift;
157 | };
158 |
159 | Parts.prototype.findOffsetInPart = function(offset, part) {
160 | offset -= part.startOffset;
161 | return binarySearch(part, o => o <= offset);
162 | };
163 |
164 | Parts.prototype.findPartByIndex = function(index) {
165 | return binarySearch(this.parts, s => s.startIndex <= index);
166 | };
167 |
168 | Parts.prototype.findPartByOffset = function(offset) {
169 | return binarySearch(this.parts, s => s.startOffset <= offset);
170 | };
171 |
172 | Parts.prototype.toArray = function() {
173 | return this.parts.reduce((p,n) => p.concat(n), []);
174 | };
175 |
176 | Parts.prototype.slice = function() {
177 | var parts = new Parts(this.minSize);
178 | this.parts.forEach(part => {
179 | var p = part.slice();
180 | p.startIndex = part.startIndex;
181 | p.startOffset = part.startOffset;
182 | parts.parts.push(p);
183 | });
184 | parts.length = this.length;
185 | return parts;
186 | };
187 |
188 | function last(array) {
189 | return array[array.length - 1];
190 | }
191 |
192 | function remove(array, a, b) {
193 | if (b == null) {
194 | return array.splice(a);
195 | } else {
196 | return array.splice(a, b - a);
197 | }
198 | }
199 |
200 | function insert(target, index, array) {
201 | var op = array.slice();
202 | op.unshift(index, 0);
203 | target.splice.apply(target, op);
204 | }
205 |
--------------------------------------------------------------------------------
/lib/dom.js:
--------------------------------------------------------------------------------
1 | var Point = require('./point');
2 | var bindRaf = require('./bind-raf');
3 | var memoize = require('./memoize');
4 | var merge = require('./merge');
5 | var diff = require('./diff');
6 | var slice = [].slice;
7 |
8 | var units = {
9 | left: 'px',
10 | top: 'px',
11 | right: 'px',
12 | bottom: 'px',
13 | width: 'px',
14 | height: 'px',
15 | maxHeight: 'px',
16 | paddingLeft: 'px',
17 | };
18 |
19 | module.exports = dom;
20 |
21 | function dom(name, children, attrs) {
22 | var el;
23 | var tag = 'div';
24 | var node;
25 |
26 | if ('string' === typeof name) {
27 | if ('<' === name.charAt(0)) {
28 | var matches = name.match(/(?:<)(.*)(?:>)(\S+)?/);
29 | if (matches) {
30 | tag = matches[1];
31 | name = matches[2] || tag;
32 | }
33 | }
34 | el = document.createElement(tag);
35 | node = {
36 | el: el,
37 | name: name.split(' ')[0]
38 | };
39 | dom.classes(node, name.split(' ').slice(1));
40 | } else if (Array.isArray(name)) {
41 | return dom.apply(null, name);
42 | } else {
43 | if ('dom' in name) {
44 | node = name.dom;
45 | } else {
46 | node = name;
47 | }
48 | }
49 |
50 | if (Array.isArray(children)) {
51 | children
52 | .map(dom)
53 | .map(function(child, i) {
54 | node[child.name] = child;
55 | return child;
56 | })
57 | .map(function(child) {
58 | node.el.appendChild(child.el);
59 | });
60 | } else if ('object' === typeof children) {
61 | dom.style(node, children);
62 | }
63 |
64 | if (attrs) {
65 | dom.attrs(node, attrs);
66 | }
67 |
68 | return node;
69 | }
70 |
71 | dom.style = memoize(function(el, _, style) {
72 | for (var name in style)
73 | if (name in units)
74 | if (style[name] !== 'auto')
75 | style[name] += units[name];
76 | Object.assign(el.style, style);
77 | }, diff, merge, function(node, style) {
78 | var el = dom.getElement(node);
79 | return [el, style];
80 | });
81 |
82 | /*
83 | dom.style = function(el, style) {
84 | el = dom.getElement(el);
85 | for (var name in style)
86 | if (name in units)
87 | style[name] += units[name];
88 | Object.assign(el.style, style);
89 | };
90 | */
91 | dom.classes = memoize(function(el, className) {
92 | el.className = className;
93 | }, null, null, function(node, classes) {
94 | var el = dom.getElement(node);
95 | return [el, classes.concat(node.name).filter(Boolean).join(' ')];
96 | });
97 |
98 | dom.attrs = function(el, attrs) {
99 | el = dom.getElement(el);
100 | Object.assign(el, attrs);
101 | };
102 |
103 | dom.html = function(el, html) {
104 | el = dom.getElement(el);
105 | el.innerHTML = html;
106 | };
107 |
108 | dom.text = function(el, text) {
109 | el = dom.getElement(el);
110 | el.textContent = text;
111 | };
112 |
113 | dom.focus = function(el) {
114 | el = dom.getElement(el);
115 | el.focus();
116 | };
117 |
118 | dom.getSize = function(el) {
119 | el = dom.getElement(el);
120 | return {
121 | width: el.clientWidth,
122 | height: el.clientHeight
123 | };
124 | };
125 |
126 | dom.getCharSize = function(el, className) {
127 | el = dom.getElement(el);
128 | var span = document.createElement('span');
129 | span.className = className;
130 |
131 | el.appendChild(span);
132 |
133 | span.innerHTML = ' ';
134 | var a = span.getBoundingClientRect();
135 |
136 | span.innerHTML = ' \n ';
137 | var b = span.getBoundingClientRect();
138 |
139 | el.removeChild(span);
140 |
141 | return {
142 | width: (b.width - a.width),
143 | height: (b.height - a.height)
144 | };
145 | };
146 |
147 | dom.getOffset = function(el) {
148 | el = dom.getElement(el);
149 | var rect = el.getBoundingClientRect();
150 | var style = window.getComputedStyle(el);
151 | var borderLeft = parseInt(style.borderLeftWidth);
152 | var borderTop = parseInt(style.borderTopWidth);
153 | return Point.low({ x: 0, y: 0 }, {
154 | x: (rect.left + borderLeft) | 0,
155 | y: (rect.top + borderTop) | 0
156 | });
157 | };
158 |
159 | dom.getScroll = function(el) {
160 | el = dom.getElement(el);
161 | return getScroll(el);
162 | };
163 |
164 | dom.onscroll = function onscroll(el, fn) {
165 | el = dom.getElement(el);
166 |
167 | if (document.body === el) {
168 | document.addEventListener('scroll', handler);
169 | } else {
170 | el.addEventListener('scroll', handler);
171 | }
172 |
173 | function handler(ev) {
174 | fn(getScroll(el));
175 | }
176 |
177 | return function offscroll() {
178 | el.removeEventListener('scroll', handler);
179 | }
180 | };
181 |
182 | dom.onoffset = function(el, fn) {
183 | el = dom.getElement(el);
184 | while (el = el.offsetParent) {
185 | dom.onscroll(el, fn);
186 | }
187 | };
188 |
189 | dom.onclick = function(el, fn) {
190 | return el.addEventListener('click', fn);
191 | };
192 |
193 | dom.onresize = function(fn) {
194 | return window.addEventListener('resize', fn);
195 | };
196 |
197 | dom.append = function(target, src, dict) {
198 | target = dom.getElement(target);
199 | if ('forEach' in src) src.forEach(dom.append.bind(null, target));
200 | // else if ('views' in src) dom.append(target, src.views, true);
201 | else if (dict === true) for (var key in src) dom.append(target, src[key]);
202 | else if ('function' != typeof src) target.appendChild(dom.getElement(src));
203 | };
204 |
205 | dom.remove = function(el) {
206 | el = dom.getElement(el);
207 | if (el.parentNode) el.parentNode.removeChild(el);
208 | };
209 |
210 | dom.getElement = function(el) {
211 | return el.dom && el.dom.el || el.el || el.node || el;
212 | };
213 |
214 | dom.scrollBy = function(el, x, y, scroll) {
215 | scroll = scroll || dom.getScroll(el);
216 | dom.scrollTo(el, scroll.x + x, scroll.y + y);
217 | };
218 |
219 | dom.scrollTo = function(el, x, y) {
220 | if (document.body === el) {
221 | window.scrollTo(x, y);
222 | } else {
223 | el.scrollLeft = x || 0;
224 | el.scrollTop = y || 0;
225 | }
226 | };
227 |
228 | dom.css = function(id, cssText) {
229 | if (!(id in dom.css.styles)) {
230 | dom.css.styles[id] = document.createElement('style');
231 | document.body.appendChild(dom.css.styles[id]);
232 | }
233 | dom.css.styles[id].textContent = cssText;
234 | };
235 |
236 | dom.css.styles = {};
237 |
238 | dom.getMousePoint = function(e) {
239 | return new Point({
240 | x: e.clientX,
241 | y: e.clientY
242 | });
243 | };
244 |
245 | function getScroll(el) {
246 | return document.body === el
247 | ? {
248 | x: window.scrollX || el.scrollLeft || document.documentElement.scrollLeft,
249 | y: window.scrollY || el.scrollTop || document.documentElement.scrollTop
250 | }
251 | : {
252 | x: el.scrollLeft,
253 | y: el.scrollTop
254 | };
255 | }
256 |
--------------------------------------------------------------------------------
/src/buffer/buffer.old.js:
--------------------------------------------------------------------------------
1 | var debounce = require('../../lib/debounce');
2 | var throttle = require('../../lib/throttle');
3 | var parse = require('../../lib/parse');
4 | var Point = require('../../lib/point');
5 | var Area = require('../../lib/area');
6 | var Range = require('../../lib/range');
7 | var Regexp = require('../../lib/regexp');
8 | var Event = require('../../lib/event');
9 | var Lines = require('./lines');
10 | var Syntax = require('./syntax');
11 | var Segments = require('./segments');
12 | var SkipString = require('./skipstring');
13 | var PrefixTree = require('./prefixtree');
14 | var Indexer = require('./indexer');
15 |
16 | exports = module.exports = Buffer;
17 |
18 | var EOL = exports.EOL = /\r\n|\r|\n/g;
19 | var N = exports.N = /\n/g;
20 | var CHUNK_SIZE = exports.CHUNK_SIZE = 5000;
21 | var WORDS = Regexp.create(['tokens'], 'g');
22 |
23 | function Buffer() {
24 | this.syntax = new Syntax;
25 | this.indexer = new Indexer(this);
26 | this.segments = new Segments(this);
27 | this.on('update', debounce(this.updateRaw.bind(this), 300));
28 | this.on('raw', this.segments.index.bind(this.segments));
29 | this.set('');
30 | }
31 |
32 | Buffer.prototype = {
33 | get loc() {
34 | return this.lines.length;
35 | }
36 | };
37 |
38 | Buffer.prototype.__proto__ = Event.prototype;
39 |
40 | Buffer.prototype.get = function(range) {
41 | if (!range) return this.text.getRange();
42 | var offsets = this.lines.getRange(range);
43 | var text = this.text.getRange(offsets);
44 | return text;
45 | };
46 |
47 | var BLOCK = {
48 | 'comment': '/*',
49 | 'string': '`',
50 | };
51 |
52 | var BLOCK_END = {
53 | 'comment': '*/',
54 | 'string': '`',
55 | };
56 |
57 | Buffer.prototype.getHighlighted = function(range) {
58 | var code = this.get(range);
59 | // return this.syntax.entities(code);
60 | // return this.syntax.highlight(code);
61 |
62 | var block = this.segments.get(range[0]);
63 | // console.timeEnd('get segment')
64 | if (block) {
65 | code = BLOCK[block] + '\uffba' + code + '\uffbe' + BLOCK_END[block];
66 | code = this.syntax.highlight(code);
67 | code = '<' + block + '>' +
68 | code.substring(
69 | code.indexOf('\uffba') + 1,
70 | code.lastIndexOf('\uffbe')
71 | );
72 | } else {
73 | code = this.syntax.highlight(code + '\uffbe*/`');
74 | code = code.substring(
75 | 0,
76 | code.lastIndexOf('\uffbe')
77 | );
78 | }
79 | return code;
80 | };
81 |
82 | //TODO: this defeats the purpose of having a skiplist
83 | // need to get rid of in the future
84 | Buffer.prototype.updateRaw = function() {
85 | this.raw = this.get();
86 | this.emit('raw', this.raw);
87 | };
88 |
89 | Buffer.prototype.getOffsetLine = function(offset) {
90 | var point = this.lines.getOffset(offset);
91 | var text = this.text.getRange(point.line.range);
92 | return {
93 | point: point,
94 | text: text
95 | };
96 | };
97 |
98 | Buffer.prototype.getLine = function(y) {
99 | return this.get([y,y]);
100 | };
101 |
102 | Buffer.prototype.set = function(text) {
103 | this.changes = 0;
104 |
105 | this.raw = text = normalizeEOL(text);
106 |
107 | this.text = new SkipString({ chunkSize: CHUNK_SIZE });
108 | this.text.set(text);
109 |
110 | this.prefix = new PrefixTree;
111 | this.prefix.index(this.raw);
112 |
113 | this.lines = new Lines;
114 | this.lines.insert({ x:0, y:0 }, this.raw);
115 |
116 | this.syntax.tab = ~this.raw.indexOf('\t') ? '\t' : ' ';
117 |
118 | // this.emit('raw', this.raw);
119 |
120 | this.emit('set');
121 | };
122 |
123 | Buffer.prototype.insert = function(point, text, shift, isCtrlShift) {
124 | var isEOL, lines, range, before, after;
125 |
126 | this.changes++;
127 |
128 | if (!isCtrlShift) this.emit('before update');
129 |
130 | text = normalizeEOL(text);
131 |
132 | isEOL = '\n' === text;
133 | shift = !isCtrlShift && (shift || isEOL);
134 |
135 | point = this.lines.getPoint(point);
136 | lines = this.lines.insert(point, text);
137 | range = [point.y, point.y + lines];
138 |
139 | before = this.get(range);
140 |
141 | this.text.insert(point.offset, text);
142 |
143 | after = this.get(range);
144 |
145 | this.prefix.index(after);
146 | if (isCtrlShift) range = [Math.max(0, range[0]-1), range[1]];
147 |
148 | this.segments.shift(point.offset, text.length);
149 |
150 | //TODO: i think shift should be 'lines'
151 | this.emit('update', range, shift, before, after);
152 |
153 | // this is to update caret position
154 | return text.length;
155 | };
156 |
157 | Buffer.prototype.deleteCharAt = function(point) {
158 | var isEOL, range, before, after;
159 |
160 | this.changes++;
161 |
162 | this.emit('before update');
163 |
164 | point = this.lines.getPoint(point);
165 | isEOL = this.lines.removeCharAt(point);
166 | range = Range.clamp([0, this.lines.length], [point.y, point.y + isEOL]);
167 |
168 | before = this.get(range);
169 |
170 | this.text.removeCharAt(point.offset);
171 |
172 | after = this.get(range);
173 |
174 | this.prefix.index(after);
175 |
176 | this.segments.shift(point.offset, -1);
177 |
178 | this.emit('update', range, -isEOL, before);
179 | };
180 |
181 | Buffer.prototype.wordAt = function(point, inclusive) {
182 | inclusive = inclusive || 0;
183 |
184 | point = this.lines.getPoint(point);
185 |
186 | var text = this.text.getRange(point.line.range);
187 |
188 | var words = Regexp.parse(text, WORDS);
189 |
190 | if (words.length === 1) {
191 | return new Area({
192 | begin: { x: 0, y: point.y },
193 | end: { x: point.line.length, y: point.y },
194 | });
195 | }
196 |
197 | var lastIndex = 0;
198 | var word = [];
199 | var end = text.length;
200 |
201 | for (var i = 0; i < words.length; i++) {
202 | word = words[i];
203 | if (word.index > point.x - inclusive) {
204 | end = word.index;
205 | break;
206 | }
207 | lastIndex = word.index;
208 | }
209 |
210 | return new Area({
211 | begin: { x: lastIndex, y: point.y },
212 | end: { x: end, y: point.y }
213 | });
214 | };
215 |
216 | Buffer.prototype.deleteArea = function(area, noUpdate) {
217 | var range, offsets, lines;
218 |
219 | this.changes++;
220 |
221 | this.emit('before update');
222 |
223 | offsets = this.lines.getAreaOffsetRange(area);
224 | lines = this.lines.removeArea(area);
225 | range = [area.begin.y, area.end.y];
226 |
227 | this.text.remove(offsets);
228 |
229 | this.segments.shift(offsets[0], offsets[0]-offsets[1]);
230 |
231 | if (!noUpdate) {
232 | this.emit('update', range);
233 | }
234 | };
235 |
236 | Buffer.prototype.getArea = function(area) {
237 | var offsets = this.lines.getAreaOffsetRange(area);
238 | var text = this.text.getRange(offsets);
239 | return text;
240 | };
241 |
242 | Buffer.prototype.moveAreaByLines = function(y, area) {
243 | if (area.end.x > 0 || area.begin.y === area.end.y) area.end.y += 1;
244 | if (area.begin.y + y < 0 || area.end.y + y > this.loc) return false;
245 |
246 | area.begin.x = 0;
247 | area.end.x = 0;
248 |
249 | var text = this.get([area.begin.y, area.end.y-1]);
250 | this.deleteArea(area, true);
251 |
252 | this.insert({ x:0, y:area.begin.y + y }, text, y, true);
253 |
254 | return true;
255 | };
256 |
257 | function normalizeEOL(s) {
258 | return s.replace(exports.EOL, '\n');
259 | }
260 |
--------------------------------------------------------------------------------
/src/buffer/segments.js:
--------------------------------------------------------------------------------
1 | var Point = require('../../lib/point');
2 | var binarySearch = require('../../lib/binary-search');
3 | var Tokens = require('./tokens');
4 | var Type = Tokens.Type;
5 |
6 | var Begin = /[\/'"`]/g;
7 |
8 | var Match = {
9 | 'single comment': ['//','\n'],
10 | 'double comment': ['/*','*/'],
11 | 'template string': ['`','`'],
12 | 'single quote string': ["'","'"],
13 | 'double quote string': ['"','"'],
14 | 'regexp': ['/','/'],
15 | };
16 |
17 | var Skip = {
18 | 'single quote string': "\\",
19 | 'double quote string': "\\",
20 | 'single comment': false,
21 | 'double comment': false,
22 | 'regexp': "\\",
23 | };
24 |
25 | var Token = {};
26 | for (var key in Match) {
27 | var M = Match[key];
28 | Token[M[0]] = key;
29 | }
30 |
31 | var Length = {
32 | 'open comment': 2,
33 | 'close comment': 2,
34 | 'template string': 1,
35 | };
36 |
37 | var NotOpen = {
38 | 'close comment': true
39 | };
40 |
41 | var Closes = {
42 | 'open comment': 'close comment',
43 | 'template string': 'template string',
44 | };
45 |
46 | var Tag = {
47 | 'open comment': 'comment',
48 | 'template string': 'string',
49 | };
50 |
51 | module.exports = Segments;
52 |
53 | function Segments(buffer) {
54 | this.buffer = buffer;
55 | this.cache = {};
56 | this.reset();
57 | }
58 |
59 | Segments.prototype.clearCache = function(offset) {
60 | if (offset) {
61 | var s = binarySearch(this.cache.state, s => s.offset < offset, true);
62 | this.cache.state.splice(s.index);
63 | } else {
64 | this.cache.state = [];
65 | }
66 | this.cache.offset = {};
67 | this.cache.range = {};
68 | this.cache.point = {};
69 | };
70 |
71 | Segments.prototype.reset = function() {
72 | this.clearCache();
73 | };
74 |
75 | Segments.prototype.get = function(y) {
76 | if (y in this.cache.point) {
77 | return this.cache.point[y];
78 | }
79 |
80 | var segments = this.buffer.tokens.getCollection('segments');
81 | var open = false;
82 | var state = null;
83 | var waitFor = '';
84 | var point = { x:-1, y:-1 };
85 | var close = 0;
86 | var offset;
87 | var segment;
88 | var range;
89 | var text;
90 | var valid;
91 | var last;
92 |
93 | var lastCacheStateOffset = 0;
94 |
95 | var i = 0;
96 |
97 | var cacheState = this.getCacheState(y);
98 | if (cacheState && cacheState.item) {
99 | open = true;
100 | state = cacheState.item;
101 | waitFor = Closes[state.type];
102 | i = state.index + 1;
103 | }
104 |
105 | for (; i < segments.length; i++) {
106 | offset = segments.get(i);
107 | segment = {
108 | offset: offset,
109 | type: Type[this.buffer.charAt(offset)]
110 | };
111 |
112 | // searching for close token
113 | if (open) {
114 | if (waitFor === segment.type) {
115 | point = this.getOffsetPoint(segment.offset);
116 |
117 | if (!point) {
118 | return (this.cache.point[y] = null);
119 | }
120 |
121 | if (point.y >= y) {
122 | return (this.cache.point[y] = Tag[state.type]);
123 | }
124 |
125 | last = segment;
126 | last.point = point;
127 | state = null;
128 | open = false;
129 |
130 | if (point.y >= y) break;
131 | }
132 | }
133 |
134 | // searching for open token
135 | else {
136 | point = this.getOffsetPoint(segment.offset);
137 |
138 | if (!point) {
139 | return (this.cache.point[y] = null);
140 | }
141 |
142 | range = this.buffer.getLine(point.y).offsetRange;
143 |
144 | if (last && last.point.y === point.y) {
145 | close = last.point.x + Length[last.type];
146 | } else {
147 | close = 0;
148 | }
149 |
150 | valid = this.isValidRange([range[0], range[1]+1], segment, close);
151 |
152 | if (valid) {
153 | if (NotOpen[segment.type]) continue;
154 | open = true;
155 | state = segment;
156 | state.index = i;
157 | state.point = point;
158 | // state.toString = function() { return this.offset };
159 | waitFor = Closes[state.type];
160 | if (!this.cache.state.length || this.cache.state.length && state.offset > this.cache.state[this.cache.state.length - 1].offset) {
161 | this.cache.state.push(state);
162 | }
163 | }
164 |
165 | if (point.y >= y) break;
166 | }
167 | }
168 |
169 | if (state && state.point.y < y) {
170 | return (this.cache.point[y] = Tag[state.type]);
171 | }
172 |
173 | return (this.cache.point[y] = null);
174 | };
175 |
176 | //TODO: cache in Buffer
177 | Segments.prototype.getOffsetPoint = function(offset) {
178 | if (offset in this.cache.offset) return this.cache.offset[offset];
179 | return (this.cache.offset[offset] = this.buffer.getOffsetPoint(offset));
180 | };
181 |
182 | Segments.prototype.isValidRange = function(range, segment, close) {
183 | var key = range.join();
184 | if (key in this.cache.range) return this.cache.range[key];
185 | var text = this.buffer.getOffsetRangeText(range);
186 | var valid = this.isValid(text, segment.offset - range[0], close);
187 | return (this.cache.range[key] = valid);
188 | };
189 |
190 | Segments.prototype.isValid = function(text, offset, lastIndex) {
191 | Begin.lastIndex = lastIndex;
192 |
193 | var match = Begin.exec(text);
194 | if (!match) return;
195 |
196 | var i = match.index;
197 |
198 | last = i;
199 |
200 | var valid = true;
201 |
202 | outer:
203 | for (; i < text.length; i++) {
204 | var one = text[i];
205 | var next = text[i + 1];
206 | var two = one + next;
207 | if (i === offset) return true;
208 |
209 | var o = Token[two];
210 | if (!o) o = Token[one];
211 | if (!o) {
212 | continue;
213 | }
214 |
215 | var waitFor = Match[o][1];
216 |
217 | last = i;
218 |
219 | switch (waitFor.length) {
220 | case 1:
221 | while (++i < text.length) {
222 | one = text[i];
223 |
224 | if (one === Skip[o]) {
225 | ++i;
226 | continue;
227 | }
228 |
229 | if (waitFor === one) {
230 | i += 1;
231 | break;
232 | }
233 |
234 | if ('\n' === one && !valid) {
235 | valid = true;
236 | i = last + 1;
237 | continue outer;
238 | }
239 |
240 | if (i === offset) {
241 | valid = false;
242 | continue;
243 | }
244 | }
245 | break;
246 | case 2:
247 | while (++i < text.length) {
248 |
249 | one = text[i];
250 | two = text[i] + text[i + 1];
251 |
252 | if (one === Skip[o]) {
253 | ++i;
254 | continue;
255 | }
256 |
257 | if (waitFor === two) {
258 | i += 2;
259 | break;
260 | }
261 |
262 | if ('\n' === one && !valid) {
263 | valid = true;
264 | i = last + 2;
265 | continue outer;
266 | }
267 |
268 | if (i === offset) {
269 | valid = false;
270 | continue;
271 | }
272 | }
273 | break;
274 | }
275 | }
276 | return valid;
277 | }
278 |
279 | Segments.prototype.getCacheState = function(y) {
280 | var s = binarySearch(this.cache.state, s => s.point.y < y);
281 | if (s.item && y - 1 < s.item.point.y) return null;
282 | else return s;
283 | // return s;
284 | };
285 |
--------------------------------------------------------------------------------
/src/buffer/test.js:
--------------------------------------------------------------------------------
1 |
2 | var assert = require('assert');
3 |
4 | module.exports = function(t, Buffer) {
5 |
6 | var fixture = `
7 | 1/*
8 | 2foo
9 | 3 */
10 |
11 | 5while (true) {
12 | 6 if (this[something]) {
13 | 7 return \`
14 | 8foo
15 | 9bar
16 | 0\`
17 | 1 }
18 | 2}
19 | 3123`;
20 |
21 | var b;
22 |
23 | function before(text) {
24 | b = new Buffer;
25 | b.setText(text || fixture);
26 | }
27 |
28 | t('setText', function() {
29 | before();
30 | assert.equal(fixture, b.raw);
31 | })
32 |
33 | t('toString', function() {
34 | before();
35 | assert.equal(fixture, b.toString());
36 | })
37 |
38 | t('loc', function() {
39 | before();
40 | assert.equal(13, b.loc());
41 |
42 | before('one\n');
43 | assert.equal(1, b.loc());
44 | })
45 |
46 | t('getLineOffset', function() {
47 | before('012\n45\n78\n');
48 | assert.equal(0, b.getLineOffset(0));
49 | assert.equal(4, b.getLineOffset(1));
50 | assert.equal(7, b.getLineOffset(2));
51 | assert.equal(10, b.getLineOffset(3));
52 | // assert.equal(10, b.getLineOffset(4));
53 | })
54 |
55 | t('getLineRangeOffsets', function() {
56 | before('012\n45\n78\n1');
57 | assert.equal([0,4], b.getLineRangeOffsets([0,0]));
58 | assert.equal([0,7], b.getLineRangeOffsets([0,1]));
59 | assert.equal([4,7], b.getLineRangeOffsets([1,1]));
60 | assert.equal([4,10], b.getLineRangeOffsets([1,2]));
61 | assert.equal([7,10], b.getLineRangeOffsets([2,2]));
62 | assert.equal([7,11], b.getLineRangeOffsets([2,3]));
63 | assert.equal([10,11], b.getLineRangeOffsets([3,3]));
64 | assert.equal([0,10], b.getLineRangeOffsets([0,2]));
65 | assert.equal([0,11], b.getLineRangeOffsets([0,3]));
66 | assert.equal([10,11], b.getLineRangeOffsets([3,4]));
67 | })
68 |
69 | t('getLine', function() {
70 | before('012\n45\n78\n1');
71 | assert.equal([0,4], b.getLine(0).offsetRange);
72 | assert.equal(0, b.getLine(0).offset);
73 | assert.equal(3, b.getLine(0).length);
74 | assert.equal({x:0,y:0}, b.getLine(0).point);
75 | assert.equal([4,7], b.getLine(1).offsetRange);
76 | assert.equal(4, b.getLine(1).offset);
77 | assert.equal(2, b.getLine(1).length);
78 | assert.equal({x:0,y:1}, b.getLine(1).point);
79 | assert.equal([10,11], b.getLine(3).offsetRange);
80 | assert.equal(10, b.getLine(3).offset);
81 | assert.equal(1, b.getLine(3).length);
82 | assert.equal({x:0,y:3}, b.getLine(3).point);
83 | })
84 |
85 | t('getLineRangeText', function() {
86 | before();
87 | assert.equal('\n', b.getLineRangeText([0,0]));
88 | assert.equal('1/*\n', b.getLineRangeText([1,1]));
89 | assert.equal('2foo\n', b.getLineRangeText([2,2]));
90 | assert.equal('2foo\n3 */\n', b.getLineRangeText([2,3]));
91 | assert.equal('\n1/*\n', b.getLineRangeText([0,1]));
92 | assert.equal('3123', b.getLineRangeText([13,13]));
93 | assert.equal('2}\n3123', b.getLineRangeText([12,13]));
94 | })
95 |
96 | t('getOffsetPoint', function() {
97 | // before('\n234\n67\n9012');
98 | // assert.equal({ x:0, y:0 }, b.getOffsetPoint(0));
99 | // assert.equal({ x:0, y:1 }, b.getOffsetPoint(1));
100 | // assert.equal({ x:1, y:1 }, b.getOffsetPoint(2));
101 | // assert.equal({ x:2, y:1 }, b.getOffsetPoint(3));
102 | // assert.equal({ x:0, y:2 }, b.getOffsetPoint(4));
103 |
104 | before('01\n345\n78\n012');
105 | assert.equal({ x:0, y:0 }, b.getOffsetPoint(0));
106 | assert.equal({ x:1, y:0 }, b.getOffsetPoint(1));
107 | assert.equal({ x:2, y:0 }, b.getOffsetPoint(2));
108 | assert.equal({ x:0, y:1 }, b.getOffsetPoint(3));
109 | assert.equal({ x:1, y:1 }, b.getOffsetPoint(4));
110 | assert.equal({ x:2, y:1 }, b.getOffsetPoint(5));
111 | assert.equal({ x:3, y:1 }, b.getOffsetPoint(6));
112 | assert.equal({ x:0, y:2 }, b.getOffsetPoint(7));
113 | })
114 |
115 | t('failing #1', function() {
116 | before('\n\n\n/*\ntwo\n*/\n');
117 | assert.equal([3,10], b.tokens.tokens.segments.toArray());
118 | b.removeCharAtPoint({x:0,y:1});
119 | assert.equal('\n\n/*\ntwo\n*/\n', b.text.toString());
120 | assert.equal([2,9], b.tokens.tokens.segments.toArray());
121 | })
122 |
123 | /*
124 | t('insert', function() {
125 | before('012\n45\n78\n1');
126 | assert.equal(4, b.getLineOffset(1));
127 | assert.equal(7, b.getLineOffset(2));
128 | assert.equal(3, b.insert({x:0,y:0},'foo'));
129 | assert.equal('foo012\n45\n78\n1', b.toString());
130 | assert.equal(7, b.getLineOffset(1));
131 | assert.equal(10, b.getLineOffset(2));
132 |
133 | before('012\n45\n78\n1');
134 | assert.equal(4, b.getLineOffset(1));
135 | assert.equal(7, b.getLineOffset(2));
136 | assert.equal(3, b.insert({x:0,y:1},'foo'));
137 | assert.equal('012\nfoo45\n78\n1', b.toString());
138 | assert.equal(4, b.getLineOffset(1));
139 | assert.equal(10, b.getLineOffset(2));
140 |
141 | before('012\n45\n78\n1');
142 | assert.equal(4, b.getLineOffset(1));
143 | assert.equal(7, b.getLineOffset(2));
144 | assert.equal(3, b.insert({x:3,y:0},'foo'));
145 | assert.equal('012foo\n45\n78\n1', b.toString());
146 | assert.equal(7, b.getLineOffset(1));
147 | assert.equal(10, b.getLineOffset(2));
148 | assert.equal(1, b.insert({x:3,y:0},'a'));
149 | assert.equal(8, b.getLineOffset(1));
150 |
151 | before('012\n45\n78\n');
152 | assert.equal(1, b.insert({x:0,y:3},'a'));
153 | assert.equal('012\n45\n78\na', b.toString());
154 | assert.equal(1, b.insert({x:1,y:3},'b'));
155 | assert.equal('012\n45\n78\nab', b.toString());
156 | })
157 |
158 | t('charAt', function() {
159 | before('012\n45\n78\n1');
160 | assert.equal('0', b.charAt(0));
161 | assert.equal('1', b.charAt(1));
162 | assert.equal('2', b.charAt(2));
163 | assert.equal('\n', b.charAt(3));
164 | assert.equal('1', b.charAt(10));
165 | })
166 |
167 | t('removeOffsetRange', function() {
168 | before('012\n45\n78\n1');
169 | b.remove([0,4]);
170 | assert.equal('45\n78\n1', b.toString());
171 | b.remove([2,3]);
172 | assert.equal('4578\n1', b.toString());
173 | })
174 |
175 | t('removeCharAtPoint', function() {
176 | before('012\n45\n78\n1');
177 | b.removeCharAtPoint({x:0,y:0});
178 | assert.equal('12\n45\n78\n1', b.toString());
179 | b.removeCharAtPoint({x:0,y:1});
180 | assert.equal('12\n5\n78\n1', b.toString());
181 | b.removeCharAtPoint({x:0,y:2});
182 | assert.equal('12\n5\n8\n1', b.toString());
183 | b.removeCharAtPoint({x:0,y:3});
184 | assert.equal('12\n5\n8\n', b.toString());
185 | b.removeCharAtPoint({x:0,y:0});
186 | assert.equal('2\n5\n8\n', b.toString());
187 | b.removeCharAtPoint({x:0,y:0});
188 | assert.equal('\n5\n8\n', b.toString());
189 | b.removeCharAtPoint({x:0,y:0});
190 | assert.equal('5\n8\n', b.toString());
191 |
192 | before('\n123\n\n123\n\n');
193 | b.removeCharAtPoint({x:0,y:2});
194 | assert.equal('\n123\n123\n\n', b.toString());
195 | b.removeCharAtPoint({x:0,y:2});
196 | assert.equal('\n123\n23\n\n', b.toString());
197 | b.removeCharAtPoint({x:0,y:2});
198 | assert.equal('\n123\n3\n\n', b.toString());
199 | b.removeCharAtPoint({x:0,y:2});
200 | assert.equal('\n123\n\n\n', b.toString());
201 | b.removeCharAtPoint({x:0,y:2});
202 | assert.equal('\n123\n\n', b.toString());
203 | b.removeCharAtPoint({x:0,y:2});
204 | assert.equal('\n123\n', b.toString());
205 | b.removeCharAtPoint({x:0,y:0});
206 | assert.equal('123\n', b.toString());
207 | b.removeCharAtPoint({x:0,y:0});
208 | assert.equal('23\n', b.toString());
209 | b.removeCharAtPoint({x:0,y:0});
210 | assert.equal('3\n', b.toString());
211 | b.removeCharAtPoint({x:0,y:0});
212 | assert.equal('\n', b.toString());
213 | b.removeCharAtPoint({x:0,y:0});
214 | assert.equal('', b.toString());
215 | })
216 | /**/
217 | };
218 |
--------------------------------------------------------------------------------
/src/input/bindings.js:
--------------------------------------------------------------------------------
1 | var throttle = require('../../lib/throttle');
2 |
3 | var PAGING_THROTTLE = 65;
4 |
5 | var keys = module.exports = {
6 | 'ctrl+z': function() {
7 | this.history.undo();
8 | },
9 | 'ctrl+y': function() {
10 | this.history.redo();
11 | },
12 |
13 | 'home': function() {
14 | this.move.beginOfLine();
15 | },
16 | 'end': function() {
17 | this.move.endOfLine();
18 | },
19 | 'pageup': throttle(function() {
20 | this.move.pageUp();
21 | }, PAGING_THROTTLE),
22 | 'pagedown': throttle(function() {
23 | this.move.pageDown();
24 | }, PAGING_THROTTLE),
25 | 'ctrl+up': throttle(function() {
26 | this.move.pageUp(6);
27 | }, PAGING_THROTTLE),
28 | 'ctrl+down': throttle(function() {
29 | this.move.pageDown(6);
30 | }, PAGING_THROTTLE),
31 | 'left': function() {
32 | this.move.byChars(-1);
33 | },
34 | 'up': function() {
35 | this.move.byLines(-1);
36 | },
37 | 'right': function() {
38 | this.move.byChars(+1);
39 | },
40 | 'down': function() {
41 | this.move.byLines(+1);
42 | },
43 |
44 | 'ctrl+left': function() {
45 | this.move.byWord(-1);
46 | },
47 | 'ctrl+right': function() {
48 | this.move.byWord(+1);
49 | },
50 |
51 | 'ctrl+a': function() {
52 | this.markClear(true);
53 | this.move.beginOfFile(null, true);
54 | this.markBegin();
55 | this.move.endOfFile(null, true);
56 | this.markSet();
57 | },
58 |
59 | 'ctrl+shift+up': function() {
60 | if (!this.mark.active) {
61 | this.buffer.moveAreaByLines(-1, { begin: this.caret.pos, end: this.caret.pos });
62 | this.move.byLines(-1, true);
63 | } else {
64 | this.buffer.moveAreaByLines(-1, this.mark.get());
65 | this.mark.shiftByLines(-1);
66 | this.move.byLines(-1, true);
67 | }
68 | },
69 | 'ctrl+shift+down': function() {
70 | if (!this.mark.active) {
71 | this.buffer.moveAreaByLines(+1, { begin: this.caret.pos, end: this.caret.pos });
72 | this.move.byLines(+1, true);
73 | } else {
74 | this.buffer.moveAreaByLines(+1, this.mark.get());
75 | this.mark.shiftByLines(+1);
76 | this.move.byLines(+1, true);
77 | }
78 | },
79 |
80 | 'enter': function() {
81 | this.insert('\n');
82 | },
83 |
84 | 'backspace': function() {
85 | this.backspace();
86 | },
87 | 'delete': function() {
88 | this.delete();
89 | },
90 | 'ctrl+backspace': function() {
91 | if (this.move.isBeginOfFile()) return;
92 | this.markClear(true);
93 | this.markBegin();
94 | this.move.byWord(-1, true);
95 | this.markSet();
96 | this.delete();
97 | },
98 | 'shift+ctrl+backspace': function() {
99 | this.markClear(true);
100 | this.markBegin();
101 | this.move.beginOfLine(null, true);
102 | this.markSet();
103 | this.delete();
104 | },
105 | 'ctrl+delete': function() {
106 | if (this.move.isEndOfFile()) return;
107 | this.markClear(true);
108 | this.markBegin();
109 | this.move.byWord(+1, true);
110 | this.markSet();
111 | this.backspace();
112 | },
113 | 'shift+ctrl+delete': function() {
114 | this.markClear(true);
115 | this.markBegin();
116 | this.move.endOfLine(null, true);
117 | this.markSet();
118 | this.backspace();
119 | },
120 | 'shift+delete': function() {
121 | this.markClear(true);
122 | this.move.beginOfLine(null, true);
123 | this.markBegin();
124 | this.move.endOfLine(null, true);
125 | this.move.byChars(+1, true);
126 | this.markSet();
127 | this.backspace();
128 | },
129 |
130 | 'shift+ctrl+d': function() {
131 | this.markBegin(false);
132 | var add = 0;
133 | var area = this.mark.get();
134 | var lines = area.end.y - area.begin.y;
135 | if (lines && area.end.x > 0) add += 1;
136 | if (!lines) add += 1;
137 | lines += add;
138 | var text = this.buffer.getAreaText(area.setLeft(0).addBottom(add));
139 | this.buffer.insert({ x: 0, y: area.end.y }, text);
140 | this.mark.shiftByLines(lines);
141 | this.move.byLines(lines, true);
142 | },
143 |
144 | 'shift+ctrl+up': function() {
145 | this.markBegin(false);
146 | var area = this.mark.get();
147 | if (this.buffer.moveAreaByLines(-1, area)) {
148 | this.mark.shiftByLines(-1);
149 | this.move.byLines(-1, true);
150 | }
151 | },
152 |
153 | 'shift+ctrl+down': function() {
154 | this.markBegin(false);
155 | var area = this.mark.get();
156 | if (this.buffer.moveAreaByLines(+1, area)) {
157 | this.mark.shiftByLines(+1);
158 | this.move.byLines(+1, true);
159 | }
160 | },
161 |
162 | 'tab': function() {
163 | var res = this.suggest();
164 | if (!res) {
165 | this.insert(this.tab);
166 | } else {
167 | this.markSetArea(res.area);
168 | this.insert(res.node.value);
169 | }
170 | },
171 |
172 | 'ctrl+f': function() {
173 | this.find.open();
174 | },
175 |
176 | 'f3': function() {
177 | this.findJump(+1);
178 | },
179 | 'shift+f3': function() {
180 | this.findJump(-1);
181 | },
182 |
183 | 'ctrl+/': function() {
184 | var add;
185 | var area;
186 | var text;
187 |
188 | var clear = false;
189 | var caret = this.caret.copy();
190 |
191 | if (!this.mark.active) {
192 | clear = true;
193 | this.markClear();
194 | this.move.beginOfLine(null, true);
195 | this.markBegin();
196 | this.move.endOfLine(null, true);
197 | this.markSet();
198 | area = this.mark.get();
199 | text = this.buffer.getArea(area);
200 | } else {
201 | area = this.mark.get();
202 | this.mark.addBottom(area.end.x > 0).setLeft(0);
203 | text = this.buffer.getArea(this.mark.get());
204 | }
205 |
206 | //TODO: should check if last line has // also
207 | if (text.trimLeft().substr(0,2) === '//') {
208 | add = -3;
209 | text = text.replace(/^(.*?)\/\/ (.+)/gm, '$1$2');
210 | } else {
211 | add = +3;
212 | text = text.replace(/^([\s]*)(.+)/gm, '$1// $2');
213 | }
214 |
215 | this.insert(text);
216 |
217 | this.mark.set(area.addRight(add));
218 | this.mark.active = !clear;
219 |
220 | if (caret.x) caret.addRight(add);
221 | this.setCaret(caret);
222 |
223 | if (clear) {
224 | this.markClear();
225 | }
226 | },
227 |
228 | 'shift+ctrl+/': function() {
229 | var clear = false;
230 | var add = 0;
231 | if (!this.mark.active) clear = true;
232 | var caret = this.caret.copy();
233 | this.markBegin(false);
234 | var area = this.mark.get();
235 | var text = this.buffer.getArea(area);
236 | if (text.slice(0,2) === '/*' && text.slice(-2) === '*/') {
237 | text = text.slice(2,-2);
238 | add -= 2;
239 | if (area.end.y === area.begin.y) add -= 2;
240 | } else {
241 | text = '/*' + text + '*/';
242 | add += 2;
243 | if (area.end.y === area.begin.y) add += 2;
244 | }
245 | this.insert(text);
246 | area.end.x += add;
247 | this.mark.set(area);
248 | this.mark.active = !clear;
249 | this.setCaret(caret.addRight(add));
250 | if (clear) {
251 | this.markClear();
252 | }
253 | },
254 | };
255 |
256 | keys.single = {
257 | //
258 | };
259 |
260 | // selection keys
261 | [ 'home','end',
262 | 'pageup','pagedown',
263 | 'left','up','right','down',
264 | 'ctrl+left','ctrl+right'
265 | ].forEach(function(key) {
266 | keys['shift+'+key] = function(e) {
267 | this.markBegin();
268 | keys[key].call(this, e);
269 | this.markSet();
270 | };
271 | });
272 |
--------------------------------------------------------------------------------
/src/views/code.js:
--------------------------------------------------------------------------------
1 | var Range = require('../../lib/range');
2 | var dom = require('../../lib/dom');
3 | var css = require('../style.css');
4 | var View = require('./view');
5 |
6 | var AheadThreshold = {
7 | animation: [.15, .4],
8 | normal: [.75, 1.5]
9 | };
10 |
11 | module.exports = CodeView;
12 |
13 | function CodeView(editor) {
14 | View.call(this, editor);
15 |
16 | this.name = 'code';
17 | this.dom = dom(css.code);
18 | this.parts = [];
19 | }
20 |
21 | CodeView.prototype.__proto__ = View.prototype;
22 |
23 | CodeView.prototype.use = function(target) {
24 | this.target = target;
25 | };
26 |
27 | CodeView.prototype.renderPart = function(range) {
28 | var part = new Part(this, range);
29 | this.parts.push(part);
30 | part.render();
31 | part.append();
32 | };
33 |
34 | CodeView.prototype.renderEdit = function(edit) {
35 | this.clearOutPageRange([0,0]);
36 | if (edit.shift > 0) this.renderInsert(edit);
37 | else if (edit.shift < 0) this.renderRemove(edit);
38 | else this.renderLine(edit);
39 | };
40 |
41 | CodeView.prototype.renderPage = function() {
42 | var page = this.editor.getPageRange([0,0]);
43 | var inParts = this.inRangeParts(page);
44 | var needRanges = Range.NOT(page, this.parts);
45 | needRanges.forEach(range => this.renderPart(range));
46 | inParts.forEach(part => part.render());
47 | };
48 |
49 | CodeView.prototype.renderRemove = function(edit) {
50 | var parts = this.parts.slice();
51 | for (var i = 0; i < parts.length; i++) {
52 | var part = parts[i];
53 | if (part[0] > edit.range[0] && part[1] < edit.range[1]) {
54 | this.removePart(part);
55 | }
56 | else if (part[0] < edit.line && part[1] >= edit.line) {
57 | part[1] = edit.line - 1;
58 | part.style();
59 | this.renderPart([edit.line, edit.line]);
60 | }
61 | else if (part[0] === edit.line && part[1] === edit.line) {
62 | part.render();
63 | }
64 | else if (part[0] === edit.line && part[1] > edit.line) {
65 | this.removePart(part);
66 | this.renderPart([edit.line, edit.line]);
67 | }
68 | else if (part[0] > edit.line && part[0] + edit.shift <= edit.line) {
69 | var offset = edit.line - (part[0] + edit.shift) + 1;
70 | part[0] += edit.shift + offset;
71 | part[1] += edit.shift + offset;
72 | part.offset(offset);
73 | if (part[0] >= part[1]) this.removePart(part);
74 | }
75 | else if (part[0] > edit.line) {
76 | part[0] += edit.shift;
77 | part[1] += edit.shift;
78 | part.style();
79 | }
80 | }
81 | this.renderPage();
82 | };
83 |
84 | CodeView.prototype.renderInsert = function(edit) {
85 | var parts = this.parts.slice();
86 | for (var i = 0; i < parts.length; i++) {
87 | var part = parts[i];
88 | if (part[0] < edit.line && part[1] >= edit.line) {
89 | part[1] = edit.line - 1;
90 | part.style();
91 | this.renderPart(edit.range);
92 | }
93 | else if (part[0] === edit.line) {
94 | part.render();
95 | }
96 | else if (part[0] > edit.line) {
97 | part[0] += edit.shift;
98 | part[1] += edit.shift;
99 | part.style();
100 | }
101 | }
102 | this.renderPage();
103 | };
104 |
105 | CodeView.prototype.renderLine = function(edit) {
106 | var parts = this.parts.slice();
107 | for (var i = 0; i < parts.length; i++) {
108 | var part = parts[i];
109 | if (part[0] === edit.line && part[1] === edit.line) {
110 | part.render();
111 | }
112 | else if (part[0] <= edit.line && part[1] >= edit.line) {
113 | part[1] = edit.line - 1;
114 | if (part[1] < part[0]) this.removePart(part)
115 | else part.style();
116 | this.renderPart(edit.range);
117 | }
118 | }
119 | this.renderPage();
120 | };
121 |
122 | CodeView.prototype.removePart = function(part) {
123 | part.clear();
124 | this.parts.splice(this.parts.indexOf(part), 1);
125 | };
126 |
127 | CodeView.prototype.clearOutPageRange = function(range) {
128 | this.outRangeParts(this.editor.getPageRange(range))
129 | .forEach(part => this.removePart(part));
130 | };
131 |
132 | CodeView.prototype.inRangeParts = function(range) {
133 | var parts = [];
134 | for (var i = 0; i < this.parts.length; i++) {
135 | var part = this.parts[i];
136 | if ( part[0] >= range[0] && part[0] <= range[1]
137 | || part[1] >= range[0] && part[1] <= range[1] ) {
138 | parts.push(part);
139 | }
140 | }
141 | return parts;
142 | };
143 |
144 | CodeView.prototype.outRangeParts = function(range) {
145 | var parts = [];
146 | for (var i = 0; i < this.parts.length; i++) {
147 | var part = this.parts[i];
148 | if ( part[1] < range[0]
149 | || part[0] > range[1] ) {
150 | parts.push(part);
151 | }
152 | }
153 | return parts;
154 | };
155 |
156 | CodeView.prototype.render = function() {
157 | if (this.editor.editing) return;
158 |
159 | var page = this.editor.getPageRange([0,0]);
160 |
161 | if (Range.NOT(page, this.parts).length === 0) {
162 | return;
163 | }
164 |
165 | if (Range.AND(page, this.parts).length === 0) {
166 | this.clearOutPageRange([0,0]);
167 | this.renderPart(page);
168 | return;
169 | }
170 |
171 | // check if we're past the threshold of view
172 | var threshold = this.editor.animationRunning
173 | ? [-AheadThreshold.animation[0], +AheadThreshold.animation[0]]
174 | : [-AheadThreshold.normal[0], +AheadThreshold.normal[0]];
175 |
176 | var aheadRange = this.editor.getPageRange(threshold);
177 | var aheadNeedRanges = Range.NOT(aheadRange, this.parts);
178 | if (aheadNeedRanges.length) {
179 | // if so, render further ahead to have some
180 | // margin to scroll without triggering new renders
181 |
182 | threshold = this.editor.animationRunning
183 | ? [-AheadThreshold.animation[1], +AheadThreshold.animation[1]]
184 | : [-AheadThreshold.normal[1], +AheadThreshold.normal[1]];
185 |
186 | this.clearOutPageRange(threshold);
187 |
188 | aheadRange = this.editor.getPageRange(threshold);
189 | aheadNeedRanges = Range.NOT(aheadRange, this.parts);
190 | aheadNeedRanges.forEach(range => {
191 | this.renderPart(range);
192 | });
193 | }
194 | };
195 |
196 | CodeView.prototype.clear = function() {
197 | this.parts.forEach(part => part.clear());
198 | this.parts = [];
199 | };
200 |
201 | function Part(view, range) {
202 | this.view = view;
203 | this.dom = dom(css.code);
204 | this.code = '';
205 | this.offsetTop = 0;
206 | this[0] = range[0];
207 | this[1] = range[1];
208 |
209 | var style = {};
210 |
211 | if (this.view.editor.options.debug_layers
212 | && ~this.view.editor.options.debug_layers.indexOf(this.view.name)) {
213 | style.background = '#'
214 | + (Math.random() * 12 | 0).toString(16)
215 | + (Math.random() * 12 | 0).toString(16)
216 | + (Math.random() * 12 | 0).toString(16);
217 | style.opacity = 0.5;
218 | }
219 |
220 | dom.style(this, style);
221 | }
222 |
223 | Part.prototype.offset = function(y) {
224 | this.offsetTop += y;
225 | this.code = this.code.split(/\n/g).slice(y).join('\n');
226 | this[1] -= y;
227 | this.style();
228 | this.dom.el.scrollTop = this.offsetTop * this.view.editor.char.height;
229 | };
230 |
231 | Part.prototype.append = function() {
232 | dom.append(this.view.target, this);
233 | };
234 |
235 | Part.prototype.render = function() {
236 | var code = this.view.editor.buffer.get(this);
237 | if (code !== this.code) {
238 | dom.html(this, code);
239 | this.code = code;
240 | }
241 | this.style();
242 | };
243 |
244 | Part.prototype.style = function() {
245 | dom.style(this, {
246 | height: (this[1] - this[0] + 1) * this.view.editor.char.height,
247 | top: this[0] * this.view.editor.char.height
248 | });
249 | };
250 |
251 | Part.prototype.clear = function() {
252 | dom.remove(this);
253 | };
254 |
--------------------------------------------------------------------------------
/src/buffer/buffer.old.test.js:
--------------------------------------------------------------------------------
1 |
2 | var assert = require('assert');
3 |
4 | module.exports = function(t, Buffer) {
5 | var times = 50;
6 |
7 | t('set', function() {
8 | var buffer = new Buffer;
9 | var a = '12345\r\n789\n\n234\n67';
10 | buffer.set(a);
11 | assert.equal(17, buffer.text.length);
12 | assert.equal(4, buffer.lines.length);
13 | var a = '12345\r\n789\n';
14 | buffer.set(a);
15 | assert.equal(10, buffer.text.length);
16 | assert.equal(2, buffer.lines.length);
17 | })
18 |
19 | t('get', function() {
20 | var buffer = new Buffer;
21 | var a = '12345\r\n789\n\n234\n67';
22 | buffer.set(a);
23 | assert.equal('12345\n789\n\n234\n67', buffer.get());
24 | assert.equal('12345\n', buffer.get([0,0]));
25 | assert.equal('12345\n789\n', buffer.get([0,1]));
26 | assert.equal('789\n', buffer.get([1,1]));
27 | assert.equal('789\n\n', buffer.get([1,2]));
28 | assert.equal('\n', buffer.get([2,2]));
29 | assert.equal('234\n', buffer.get([3,3]));
30 | assert.equal('67', buffer.get([4,4]));
31 | assert.equal('234\n67', buffer.get([3,4]));
32 | })
33 |
34 | t('insert', function() {
35 | var buffer = new Buffer;
36 | var a = '12345\r\n789\n\n234\n67';
37 | buffer.insert({x:0,y:0},a);
38 | assert.equal(17, buffer.text.length);
39 | assert.equal(4, buffer.lines.length);
40 | // buffer.insert({x:2,y:0},'ab');
41 | // assert.equal(19, buffer.text.length);
42 | // assert.equal(4, buffer.lines.length);
43 | assert.equal('12345\n', buffer.get([0,0]));
44 |
45 | buffer.insert({x:2,y:0},'ab');
46 | assert.equal('12ab345\n', buffer.get([0,0]));
47 | buffer.insert({x:0,y:2},'cd');
48 | assert.equal('12ab345\n789\ncd\n234\n67', buffer.get());
49 | buffer.insert({x:0,y:3},'ef');
50 | assert.equal('12ab345\n789\ncd\nef234\n67', buffer.get());
51 | buffer.insert({x:0,y:4},'gh');
52 | assert.equal('12ab345\n789\ncd\nef234\ngh67', buffer.get());
53 | buffer.insert({x:2,y:4},'ij');
54 | assert.equal('12ab345\n789\ncd\nef234\nghij67', buffer.get());
55 | buffer.insert({x:10,y:4},'kl');
56 | assert.equal('12ab345\n789\ncd\nef234\nghij67kl', buffer.get());
57 |
58 | var buffer = new Buffer;
59 | var a = '12345\n789';
60 | var b = 'ab\ncdef'
61 | buffer.insert({x:0,y:0}, a);
62 | buffer.insert({x:2,y:1}, b);
63 | assert.equal('12345\n78ab\ncdef9', buffer.get());
64 | buffer.insert({x:0,y:0}, '\n');
65 | assert.equal('\n12345\n78ab\ncdef9', buffer.get());
66 | })
67 |
68 | t('insert end newline', function() {
69 | var buffer = new Buffer;
70 | var a = '12345\n';
71 | buffer.insert({x:0,y:0},a);
72 | assert.equal(6, buffer.text.length);
73 | assert.equal(1, buffer.lines.length);
74 | buffer.insert({x:0,y:0},'abc');
75 | assert.equal(9, buffer.text.length);
76 | assert.equal(1, buffer.lines.length);
77 | buffer.insert({x:8,y:0},'def');
78 | assert.equal(12, buffer.text.length);
79 | assert.equal(1, buffer.lines.length);
80 | assert.equal('abc12345def\n', buffer.get());
81 | buffer.insert({x:100,y:1},'gh');
82 | buffer.insert({x:100,y:1},'ij');
83 | buffer.insert({x:100,y:1},'ml');
84 | assert.equal('abc12345def\nghijml', buffer.get())
85 | })
86 |
87 | t('deleteCharAt', function() {
88 | var buffer = new Buffer;
89 | var a = '12345\n789\n123';
90 | buffer.insert({x:0,y:0}, a);
91 | assert.equal('12345\n789\n123', buffer.get());
92 | buffer.deleteCharAt({x:1,y:0});
93 | assert.equal('1345\n789\n123', buffer.get());
94 | buffer.deleteCharAt({x:0,y:0});
95 | assert.equal('345\n789\n123', buffer.get());
96 | buffer.deleteCharAt({x:0,y:0});
97 | assert.equal('45\n789\n123', buffer.get());
98 | buffer.deleteCharAt({x:0,y:0});
99 | assert.equal('5\n789\n123', buffer.get());
100 | buffer.deleteCharAt({x:0,y:0});
101 | assert.equal('\n789\n123', buffer.get());
102 | buffer.deleteCharAt({x:0,y:0});
103 | assert.equal('789\n123', buffer.get());
104 | })
105 |
106 | t('edge case', function() {
107 | repeat(times, function() {
108 | for (var i = 1; i < 10; i++) {
109 | Buffer.CHUNK_SIZE = i;
110 | var buffer = new Buffer;
111 | buffer.set('1234567\n7890123\n456789012');
112 | assert.equal('1234567\n7890123\n456789012', buffer.get());
113 | buffer.insert({x:0,y:0}, '\n');
114 | buffer.insert({x:0,y:1}, '\n');
115 | assert.equal('\n\n1234567\n7890123\n456789012', buffer.get());
116 | buffer.deleteCharAt({x:0,y:1});
117 | buffer.deleteCharAt({x:0,y:0});
118 | assert.equal('1234567\n7890123\n456789012', buffer.get());
119 | buffer.insert({x:0,y:0}, '\n');
120 | buffer.insert({x:0,y:1}, '\n');
121 | assert.equal('\n\n1234567\n7890123\n456789012', buffer.get());
122 | buffer.deleteCharAt({x:0,y:1});
123 | buffer.deleteCharAt({x:0,y:0});
124 | assert.equal('1234567\n7890123\n456789012', buffer.get());
125 | buffer.insert({x:0,y:1}, '\n');
126 | assert.equal('1234567\n\n7890123\n456789012', buffer.get());
127 | // buffer.insert({x:0,y:2}, '\n');
128 | }
129 | })
130 | })
131 |
132 | t('edge case 2', function() {
133 | for (var i = 1; i < 15; i++) {
134 | Buffer.CHUNK_SIZE = i;
135 | var buffer = new Buffer;
136 | buffer.set('hello\none\nworld\n');
137 | assert.equal('one\n', buffer.get([1,1]));
138 | buffer.insert({x:3,y:1}, '1');
139 | assert.equal('one1\n', buffer.get([1,1]));
140 | }
141 | })
142 |
143 | t('edge case 3', function() {
144 | for (var i = 1; i < 15; i++) {
145 | Buffer.CHUNK_SIZE = i;
146 | var buffer = new Buffer;
147 | buffer.set('hello');
148 | assert.equal('hello', buffer.get());
149 | buffer.deleteCharAt({x:4,y:0});
150 | assert.equal('hell', buffer.get());
151 | buffer.deleteCharAt({x:3,y:0});
152 | assert.equal('hel', buffer.get());
153 | buffer.insert({x:3,y:0}, '\nlo');
154 | assert.equal('hel\nlo', buffer.get());
155 | buffer.deleteCharAt({x:1,y:1});
156 | assert.equal('hel\nl', buffer.get());
157 | buffer.deleteCharAt({x:0,y:1});
158 | assert.equal('hel\n', buffer.get());
159 | buffer.deleteCharAt({x:4,y:0});
160 | assert.equal('hel', buffer.get());
161 | buffer.deleteCharAt({x:2,y:0});
162 | assert.equal('he', buffer.get());
163 | buffer.deleteCharAt({x:1,y:0});
164 | assert.equal('h', buffer.get());
165 | buffer.deleteCharAt({x:0,y:0});
166 | assert.equal('', buffer.get());
167 | }
168 | })
169 |
170 | t('edge case 4', function() {
171 | for (var i = 1; i < 15; i++) {
172 | Buffer.CHUNK_SIZE = i;
173 | var buffer = new Buffer;
174 | buffer.set('hello');
175 | assert.equal('hello', buffer.get());
176 | buffer.deleteArea({
177 | begin: {x:0,y:0},
178 | end: {x:5,y:0}
179 | });
180 | assert.equal('', buffer.get());
181 | assert.equal([], buffer.lines.index);
182 | assert.equal('', buffer.lines.tail);
183 | }
184 | })
185 |
186 | t('deleteArea', function() {
187 | repeat(times, function() {
188 | for (var i = 1; i < 10; i++) {
189 | Buffer.CHUNK_SIZE = i;
190 |
191 | var buffer = new Buffer;
192 | buffer.set('1234567\n7890123\n456789012');
193 | assert.equal('1234567\n7890123\n456789012', buffer.get());
194 | buffer.deleteArea({
195 | begin: {x:3,y:0},
196 | end: {x:3,y:1}
197 | });
198 | assert.equal('1230123\n456789012', buffer.get());
199 | buffer.insert({x:3,y:0}, '456');
200 | assert.equal('1234560123\n456789012', buffer.get());
201 | buffer.insert({x:0,y:1}, '123');
202 | assert.equal('1234560123\n123456789012', buffer.get());
203 | buffer.deleteArea({
204 | begin: {x:3,y:0},
205 | end: {x:3,y:1}
206 | });
207 | assert.equal('123456789012', buffer.get());
208 | }
209 | })
210 | })
211 | /**/
212 | };
213 |
214 | function repeat(times, fn) {
215 | while (times--) fn();
216 | }
217 |
--------------------------------------------------------------------------------
/src/buffer/skipstring.js:
--------------------------------------------------------------------------------
1 | /*
2 |
3 | example search for offset `4` :
4 | `o` are node's levels, `x` are traversal steps
5 |
6 | x
7 | x
8 | o-->x o o
9 | o o x o o o o
10 | o o o-x o o o o o
11 | 1 2 3 4 5 6 7 8 9
12 |
13 | */
14 |
15 | log = console.log.bind(console);
16 |
17 | module.exports = SkipString;
18 |
19 | function Node(value, level) {
20 | this.value = value;
21 | this.level = level;
22 | this.width = new Array(this.level).fill(value && value.length || 0);
23 | this.next = new Array(this.level).fill(null);
24 | }
25 |
26 | Node.prototype = {
27 | get length() {
28 | return this.width[0];
29 | }
30 | };
31 |
32 | function SkipString(o) {
33 | o = o || {};
34 | this.levels = o.levels || 11;
35 | this.bias = o.bias || 1 / Math.E;
36 | this.head = new Node(null, this.levels);
37 | this.chunkSize = o.chunkSize || 5000;
38 | }
39 |
40 | SkipString.prototype = {
41 | get length() {
42 | return this.head.width[this.levels - 1];
43 | }
44 | };
45 |
46 | SkipString.prototype.get = function(offset) {
47 | // great hack to do offset >= for .search()
48 | // we don't have fractions anyway so..
49 | return this.search(offset, true);
50 | };
51 |
52 | SkipString.prototype.set = function(text) {
53 | this.insertChunked(0, text);
54 | };
55 |
56 | SkipString.prototype.search = function(offset, incl) {
57 | incl = incl ? .1 : 0;
58 |
59 | // prepare to hold steps
60 | var steps = new Array(this.levels);
61 | var width = new Array(this.levels);
62 |
63 | // iterate levels down, skipping top
64 | var i = this.levels;
65 | var node = this.head;
66 |
67 | while (i--) {
68 | while (offset + incl > node.width[i] && null != node.next[i]) {
69 | offset -= node.width[i];
70 | node = node.next[i];
71 | }
72 | steps[i] = node;
73 | width[i] = offset;
74 | }
75 |
76 | return {
77 | node: node,
78 | steps: steps,
79 | width: width,
80 | offset: offset
81 | };
82 | };
83 |
84 | SkipString.prototype.splice = function(s, offset, value, level) {
85 | var steps = s.steps; // skip steps left of the offset
86 | var width = s.width;
87 |
88 | var p; // left node or `p`
89 | var q; // right node or `q` (our new node)
90 | var len;
91 |
92 | // create new node
93 | level = level || this.randomLevel();
94 | q = new Node(value, level);
95 | length = q.width[0];
96 |
97 | // iterator
98 | var i;
99 |
100 | // iterate steps levels below new node level
101 | i = level;
102 | while (i--) {
103 | p = steps[i]; // get left node of this level step
104 | q.next[i] = p.next[i]; // insert so inherit left's next
105 | p.next[i] = q; // left's next is now our new node
106 | q.width[i] = p.width[i] - width[i] + length;
107 | p.width[i] = width[i];
108 | }
109 |
110 | // iterate steps all levels down until except new node level
111 | i = this.levels;
112 | while (i-- > level) {
113 | p = steps[i]; // get left node of this level
114 | p.width[i] += length; // add new node width
115 | }
116 |
117 | // return new node
118 | return q;
119 | };
120 |
121 | SkipString.prototype.insert = function(offset, value, level) {
122 | var s = this.search(offset);
123 |
124 | // if search falls in the middle of a string
125 | // insert it there instead of creating a new node
126 | if (s.offset && s.node.value && s.offset < s.node.value.length) {
127 | this.update(s, insert(s.offset, s.node.value, value));
128 | return s.node;
129 | }
130 |
131 | return this.splice(s, offset, value, level);
132 | };
133 |
134 | SkipString.prototype.update = function(s, value) {
135 | // values length difference
136 | var length = s.node.value.length - value.length;
137 |
138 | // update value
139 | s.node.value = value;
140 |
141 | // iterator
142 | var i;
143 |
144 | // fix widths on all levels
145 | i = this.levels;
146 |
147 | while (i--) {
148 | s.steps[i].width[i] -= length;
149 | }
150 |
151 | return length;
152 | };
153 |
154 | SkipString.prototype.remove = function(range) {
155 | if (range[1] > this.length) {
156 | throw new Error(
157 | 'range end over maximum length(' +
158 | this.length + '): [' + range.join() + ']'
159 | );
160 | }
161 |
162 | // remain distance to remove
163 | var x = range[1] - range[0];
164 |
165 | // search for node on left edge
166 | var s = this.search(range[0]);
167 | var offset = s.offset;
168 | var steps = s.steps;
169 | var node = s.node;
170 |
171 | // skip head
172 | if (this.head === node) node = node.next[0];
173 |
174 | // slice left edge when partial
175 | if (offset) {
176 | if (offset < node.width[0]) {
177 | x -= this.update(s,
178 | node.value.slice(0, offset) +
179 | node.value.slice(
180 | offset +
181 | Math.min(x, node.length - offset)
182 | )
183 | );
184 | }
185 |
186 | node = node.next[0];
187 |
188 | if (!node) return;
189 | }
190 |
191 | // remove all full nodes in range
192 | while (node && x >= node.width[0]) {
193 | x -= this.removeNode(steps, node);
194 | node = node.next[0];
195 | }
196 |
197 | // slice right edge when partial
198 | if (x) {
199 | this.replace(steps, node, node.value.slice(x));
200 | }
201 | };
202 |
203 | SkipString.prototype.removeNode = function(steps, node) {
204 | var length = node.width[0];
205 |
206 | var i;
207 |
208 | i = node.level;
209 | while (i--) {
210 | steps[i].width[i] -= length - node.width[i];
211 | steps[i].next[i] = node.next[i];
212 | }
213 |
214 | i = this.levels;
215 | while (i-- > node.level) {
216 | steps[i].width[i] -= length;
217 | }
218 |
219 | return length;
220 | };
221 |
222 | SkipString.prototype.replace = function(steps, node, value) {
223 | var length = node.value.length - value.length;
224 |
225 | node.value = value;
226 |
227 | var i;
228 | i = node.level;
229 | while (i--) {
230 | node.width[i] -= length;
231 | }
232 |
233 | i = this.levels;
234 | while (i-- > node.level) {
235 | steps[i].width[i] -= length;
236 | }
237 |
238 | return length;
239 | };
240 |
241 | SkipString.prototype.removeCharAt = function(offset) {
242 | return this.remove([offset, offset+1]);
243 | };
244 |
245 | SkipString.prototype.insertChunked = function(offset, text) {
246 | for (var i = 0; i < text.length; i += this.chunkSize) {
247 | var chunk = text.substr(i, this.chunkSize);
248 | this.insert(i + offset, chunk);
249 | }
250 | };
251 |
252 | SkipString.prototype.substring = function(a, b) {
253 | var length = b - a;
254 |
255 | var search = this.search(a, true);
256 | var node = search.node;
257 | if (this.head === node) node = node.next[0];
258 | var d = length + search.offset;
259 | var s = '';
260 | while (node && d >= 0) {
261 | d -= node.width[0];
262 | s += node.value;
263 | node = node.next[0];
264 | }
265 | if (node) {
266 | s += node.value;
267 | }
268 |
269 | return s.substr(search.offset, length);
270 | };
271 |
272 | SkipString.prototype.randomLevel = function() {
273 | var level = 1;
274 | while (level < this.levels - 1 && Math.random() < this.bias) level++;
275 | return level;
276 | };
277 |
278 | SkipString.prototype.getRange = function(range) {
279 | range = range || [];
280 | return this.substring(range[0], range[1]);
281 | };
282 |
283 | SkipString.prototype.copy = function() {
284 | var copy = new SkipString;
285 | var node = this.head;
286 | var offset = 0;
287 | while (node = node.next[0]) {
288 | copy.insert(offset, node.value);
289 | offset += node.width[0];
290 | }
291 | return copy;
292 | };
293 |
294 | SkipString.prototype.joinString = function(delimiter) {
295 | var parts = [];
296 | var node = this.head;
297 | while (node = node.next[0]) {
298 | parts.push(node.value);
299 | }
300 | return parts.join(delimiter);
301 | };
302 |
303 | SkipString.prototype.toString = function() {
304 | return this.substring(0, this.length);
305 | };
306 |
307 | function trim(s, left, right) {
308 | return s.substr(0, s.length - right).substr(left);
309 | }
310 |
311 | function insert(offset, string, part) {
312 | return string.slice(0, offset) + part + string.slice(offset);
313 | }
314 |
--------------------------------------------------------------------------------
/src/buffer/lines.js:
--------------------------------------------------------------------------------
1 |
2 | /*
3 | * _ = caret
4 | *
5 | * 0 1 2 3 4 5 0 1 2 3 4 5 0 1 2
6 | * | h | e | l | l | o | \n | w | o | r | l | d | \n | ! | ! | _ |
7 | * 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
8 | *
9 | * get(0) -> 0
10 | * get(1) -> 6
11 | * get(2) -> 12
12 | * get(3) -> throws
13 | *
14 | * left inclusive, right exclusive:
15 | *
16 | * getLine(x).offset === get(x)
17 | * getLine(0).range -> 0-6
18 | * getLine(1).range -> 6-12
19 | * getLine(2).range -> 12-13
20 | * getLine(3) -> throws
21 | *
22 | * getRange([0,0]) -> 0-6
23 | * getRange([0,1]) -> 0-12
24 | * getRange([1,1]) -> 6-12
25 | * getRange([1,2]) -> 6-13
26 | * getRange([2,2]) -> 12-13
27 | * getRange([2,3]) -> throws
28 | * getRange([0,3]) -> throws
29 | *
30 | * getPoint({ x:x, y:y }).line === getLine(y)
31 | * getPoint({ x:0, y:0 }).offset -> 0
32 | * getPoint({ x:0, y:0 }).point -> { x:0, y:0 }
33 | * getPoint({ x:2, y:0 }).offset -> 2
34 | * getPoint({ x:10, y:0 }).offset -> 5
35 | * getPoint({ x:10, y:0 }).point -> { x:5, y:0 }
36 | * getPoint({ x:0, y:1 }).offset -> 6
37 | * getPoint({ x:2, y:1 }).offset -> 8
38 | * getPoint({ x:10, y:1 }).offset -> 11
39 | * getPoint({ x:10, y:1 }).point -> { x:5, y:1 }
40 | * getPoint({ x:0, y:2 }).offset -> 12
41 | * getPoint({ x:10, y:2 }).offset -> 13
42 | * getPoint({ x:10, y:2 }).point -> { x:1, y:2 }
43 | * getRange({ x:100, y:100 }).offset -> 13
44 | * getRange({ x:100, y:100 }).point -> { x:1, y: 2 }
45 | *
46 | * getLineLength(0) -> 6
47 | * getLineLength(1) -> 6
48 | * getLineLength(2) -> 2
49 | * getLineLength(3) -> throws
50 | */
51 |
52 | var EOL = /\r\n|\r|\n/g;
53 | var N = /\n/g;
54 |
55 | module.exports = Lines;
56 |
57 | function Lines() {
58 | this.index = [];
59 | this.tail = '';
60 | this.length = 0;
61 | }
62 |
63 | Lines.prototype.get = function(y) {
64 | if (y > this.length) {
65 | return (this.index[this.length - 1] || 0) + this.tail.length + (this.length > 0);
66 | }
67 | var line = this.index[y - 1] || 0;
68 |
69 | return y > 0 ? line + 1 : 0;
70 | };
71 |
72 | Lines.prototype.getRange = function(range) {
73 | // var a = this.get(range[0]);
74 | // var b;
75 |
76 | // if (range[1] + 1 >= this.length + 1) {
77 | // b = this.get(this.length) + this.tail.length;
78 | // } else {
79 | // b = this.get(range[1] + 1);
80 | // }
81 |
82 | return [
83 | this.get(range[0]),
84 | this.get(range[1] + 1)
85 | ];
86 | };
87 |
88 | Lines.prototype.getDistance = function(range) {
89 | var r = this.getRange(range);
90 | return r[1] - r[0] - (range[1] < this.length);
91 |
92 | // var a = this.get(range[0]);
93 | // var b;
94 |
95 | // if (range[1] >= this.length + 1) {
96 | // b = this.get(range[1]); // + this.tail.length;
97 | // } else {
98 | // b = this.get(range[1]) - 1;
99 | // }
100 |
101 | // return b - a;
102 | };
103 |
104 | Lines.prototype.getLineLength = function(y) {
105 | return this.getDistance([y,y]);
106 | };
107 |
108 | Lines.prototype.getLongestLineLength = function() {
109 | var longest = 0;
110 | var d = 0;
111 | var p = this.index[this.length - 1];
112 | var i = this.length;
113 | while (i-- > 0) {
114 | d = this.index[i] - this.index[i - 1];
115 | longest = d > longest ? d : longest;
116 | }
117 | return longest;
118 | };
119 |
120 | Lines.prototype.getLine = function(y) {
121 | var offset = this.get(y);
122 | var point = { x: 0, y: y };
123 | var length = this.getLineLength(point.y);
124 | var range = [offset, offset + length];
125 |
126 | return {
127 | offset: offset,
128 | point: point,
129 | range: range,
130 | length: length,
131 | };
132 | };
133 |
134 | Lines.prototype.getPoint = function(point) {
135 | var line = this.getLine(point.y);
136 |
137 | var point = {
138 | x: Math.min(point.x, line.length),
139 | y: line.point.y
140 | };
141 |
142 | return {
143 | offset: line.offset + point.x,
144 | point: point,
145 | x: point.x,
146 | y: point.y,
147 | line: line,
148 | };
149 | };
150 |
151 | Lines.prototype.getOffset = function(offset) {
152 | var begin = 0;
153 | var end = this.length;
154 | if (!end) return;
155 |
156 | var p = -1;
157 | var i = -1;
158 |
159 | do {
160 | p = i;
161 | i = begin + (end - begin) / 2 | 0;
162 | if (this.get(i) <= offset) begin = i;
163 | else end = i;
164 | } while (p !== i);
165 |
166 | var line = this.getLine(i);
167 | var x = offset - line.offset;
168 | if ( x > line.length
169 | && i === this.length - 1) {
170 | x -= line.length + 1;
171 | i += 1;
172 | if (x > this.tail.length) return false;
173 | }
174 |
175 | return {
176 | x: x,
177 | y: i,
178 | line: line
179 | };
180 | };
181 |
182 | Lines.prototype.insert = function(p, text) {
183 | var point = this.getPoint(p);
184 | var x = point.x;
185 | var y = point.y;
186 | var offset = point.offset;
187 |
188 | if (y === this.length) {
189 | text = this.tail.substr(0,x) + text + this.tail.substr(x);
190 | this.tail = '';
191 | offset -= x;
192 | }
193 |
194 | var matches = [y, 0];
195 | var match = -1;
196 | var shift = 0;
197 | var last = -1;
198 |
199 | while (~(match = text.indexOf('\n', match + 1))) {
200 | matches.push(match + offset);
201 | last = match;
202 | }
203 |
204 | shift += last + 1;
205 |
206 | var tail = text.slice(last + 1);
207 | if (y === this.length) {
208 | this.tail += tail;
209 | }
210 |
211 | if (y < this.length) {
212 | shift += tail.length;
213 | this.shift(y, shift);
214 | }
215 |
216 | if (matches.length < 3) return 0;
217 |
218 | this.index.splice.apply(this.index, matches);
219 |
220 | var lines = this.index.length - this.length;
221 |
222 | this.length = this.index.length;
223 |
224 | return lines;
225 | };
226 |
227 | Lines.prototype.insertLine = function(y, text) {
228 | this.insert({ x:0, y:y }, text);
229 | };
230 |
231 | Lines.prototype.getArea = function(area) {
232 | return this.getRange([
233 | area.begin.y,
234 | area.end.y
235 | ]);
236 | };
237 |
238 | Lines.prototype.getAreaOffsetRange = function(area) {
239 | return [
240 | this.getPoint(area.begin).offset,
241 | this.getPoint(area.end).offset
242 | ];
243 | };
244 |
245 | Lines.prototype.removeCharAt = function(p) {
246 | var a = this.getPoint(p);
247 | if (a.point.y === this.length) {
248 | this.tail = this.tail.slice(0, -1);
249 | return false;
250 | } else {
251 | var isEndOfLine = a.line.length === a.point.x;
252 | if (isEndOfLine) {
253 | this.index.splice(a.point.y, 1);
254 | this.length = this.index.length;
255 | if (a.point.y === this.length) {
256 | this.tail += new Array(a.line.length+1).join('*');
257 | }
258 | }
259 | this.shift(a.point.y, -1);
260 | return isEndOfLine;
261 | }
262 | };
263 |
264 | Lines.prototype.removeArea = function(area) {
265 | var begin = this.getPoint(area.begin);
266 | var end = this.getPoint(area.end);
267 |
268 | var x = 0;
269 |
270 | var dist = end.y - begin.y;
271 | var sameLine = begin.y === end.y;
272 | if (sameLine) x = end.x - begin.x;
273 | else {
274 | this.index.splice(begin.y, dist);
275 | }
276 |
277 | if (!sameLine) {
278 | if (area.begin.y === this.length) {
279 | this.tail = this.tail.slice(0, -x);
280 | }
281 | if (area.end.y === this.length) {
282 | this.tail = this.tail.slice(end.x);
283 | this.tail += new Array(begin.x + 1).join('*');
284 | }
285 | } else {
286 | if (area.begin.y === this.length) {
287 | this.tail = this.tail.slice(0, begin.x) + this.tail.slice(end.x);
288 | }
289 | }
290 |
291 | this.shift(area.begin.y, -(end.offset - begin.offset));
292 |
293 | var diff = this.length - this.index.length;
294 |
295 | this.length = this.index.length;
296 |
297 | return diff;
298 | };
299 |
300 | Lines.prototype.shift = function(y, diff) {
301 | for (var i = y; i < this.index.length; i++) {
302 | this.index[i] += diff;
303 | }
304 | };
305 |
306 | Lines.prototype.copy = function() {
307 | var lines = new Lines;
308 | lines.index = this.index.slice();
309 | lines.tail = this.tail;
310 | lines.length = this.length;
311 | return lines;
312 | };
313 |
314 | Lines.count = function(text) {
315 | return this.text.match(N).length;
316 | };
317 |
318 | function add(b) {
319 | return function(a) {
320 | return a + b;
321 | };
322 | }
323 |
--------------------------------------------------------------------------------