.config/coc/extensions/node_modules/coc-pairs/lib/index.js

   1 "use strict";
   2 Object.defineProperty(exports, "__esModule", { value: true });
   3 exports.isWord = exports.wait = exports.byteSlice = exports.activate = void 0;
   4 const coc_nvim_1 = require("coc.nvim");
   5 const pairs = new Map();
   6 pairs.set('{', '}');
   7 pairs.set('[', ']');
   8 pairs.set('(', ')');
   9 pairs.set('<', '>');
  10 pairs.set('"', '"');
  11 pairs.set("'", "'");
  12 pairs.set('`', '`');
  13 async function activate(context) {
  14     let { subscriptions } = context;
  15     const config = coc_nvim_1.workspace.getConfiguration('pairs');
  16     const disableLanguages = config.get('disableLanguages');
  17     const characters = config.get('enableCharacters');
  18     const alwaysPairCharacters = config.get('alwaysPairCharacters', []);
  19     let enableBackspace = config.get('enableBackspace');
  20     if (enableBackspace) {
  21         let map = (await coc_nvim_1.workspace.nvim.call('maparg', ['<bs>', 'i']));
  22         if (map && !map.startsWith('coc#_insert_key'))
  23             enableBackspace = false;
  24     }
  25     if (characters.length == 0)
  26         return;
  27     const { nvim } = coc_nvim_1.workspace;
  28     async function insertPair(character, pair) {
  29         let samePair = character == pair;
  30         let arr = await nvim.eval('[bufnr("%"),get(b:,"coc_pairs_disabled",[]),coc#util#cursor(),&filetype,getline("."),mode()]');
  31         let filetype = arr[3];
  32         if (disableLanguages.indexOf(filetype) !== -1)
  33             return character;
  34         let line = arr[4];
  35         let mode = arr[5];
  36         if (mode.startsWith('R'))
  37             return character;
  38         let chars = arr[1];
  39         if (chars && chars.length && chars.indexOf(character) !== -1)
  40             return character;
  41         let pos = { line: arr[2][0], character: arr[2][1] };
  42         let pre = line.slice(0, pos.character);
  43         let rest = line.slice(pos.character);
  44         let previous = pre.length ? pre[pre.length - 1] : '';
  45         if (alwaysPairCharacters.indexOf(character) == -1 && rest && isWord(rest[0]))
  46             return character;
  47         if (character == '<' && (previous == ' ' || previous == '<')) {
  48             return character;
  49         }
  50         if (samePair && rest[0] == character && rest[1] != character) {
  51             // move position
  52             await nvim.eval(`feedkeys("\\<C-G>U\\<Right>", 'in')`);
  53             return '';
  54         }
  55         if (samePair && pre && (isWord(previous) || previous == character))
  56             return character;
  57         // Only pair single quotes if previous character is not word.
  58         if (character === "'" && pre.match(/.*\w$/)) {
  59             return character;
  60         }
  61         // Rust: don't pair single quotes that are part of lifetime annotations such as `Foo::<'a, 'b>` or `bar: &'a str`
  62         if (filetype === 'rust' && character === "'" &&
  63             (pre.endsWith('<') || rest.startsWith('>') || pre.endsWith('&'))) {
  64             return character;
  65         }
  66         if ((filetype === 'vim' || filetype === 'help') && character === '"' && pos.character === 0) {
  67             return character;
  68         }
  69         if (samePair && pre.length >= 2 && previous == character && pre[pre.length - 2] == character) {
  70             if (pre[pre.length - 3] == character) {
  71                 if (character == '"') {
  72                     nvim.command(`call feedkeys('"""'."${'\\<C-G>U\\<Left>'.repeat(3)}", 'in')`, true);
  73                 }
  74                 else {
  75                     nvim.command(`call feedkeys("${character.repeat(3)}${'\\<C-G>U\\<Left>'.repeat(3)}", 'in')`, true);
  76                 }
  77                 return;
  78             }
  79             return character;
  80         }
  81         if (character == '"') {
  82             nvim.command(`call feedkeys('""'."\\<C-G>U\\<Left>", 'in')`, true);
  83         }
  84         else {
  85             nvim.command(`call feedkeys("${character}${pair}${'\\<C-G>U\\<Left>'.repeat(pair.length)}", 'in')`, true);
  86         }
  87         return '';
  88     }
  89     async function closePair(character) {
  90         let [cursor, filetype, line] = await nvim.eval('[coc#util#cursor(),&filetype,getline(".")]');
  91         if (disableLanguages.indexOf(filetype) !== -1)
  92             return character;
  93         let rest = line.slice(cursor[1]);
  94         if (rest[0] == character) {
  95             nvim.command(`call feedkeys("\\<C-G>U\\<Right>", 'in')`, true);
  96             return '';
  97         }
  98         return character;
  99     }
 100     nvim.pauseNotification();
 101     for (let character of characters) {
 102         if (pairs.has(character)) {
 103             subscriptions.push(coc_nvim_1.workspace.registerExprKeymap('i', character, insertPair.bind(null, character, pairs.get(character)), false));
 104         }
 105         let matched = pairs.get(character);
 106         if (matched != character) {
 107             subscriptions.push(coc_nvim_1.workspace.registerExprKeymap('i', matched, closePair.bind(null, matched), false));
 108         }
 109     }
 110     if (enableBackspace) {
 111         subscriptions.push(coc_nvim_1.workspace.registerExprKeymap('i', '<bs>', onBackspace, false));
 112     }
 113     // tslint:disable-next-line: no-floating-promises
 114     nvim.resumeNotification(false, true);
 115     async function createBufferKeymap(doc) {
 116         if (!doc)
 117             return;
 118         let pairs = doc.getVar('pairs', null);
 119         if (!pairs)
 120             return;
 121         if (coc_nvim_1.workspace.bufnr != doc.bufnr)
 122             return;
 123         nvim.pauseNotification();
 124         for (let p of pairs) {
 125             if (Array.isArray(p) && p.length == 2) {
 126                 let [character, matched] = p;
 127                 subscriptions.push(coc_nvim_1.workspace.registerExprKeymap('i', character, insertPair.bind(null, character, matched), true));
 128                 if (matched != character) {
 129                     subscriptions.push(coc_nvim_1.workspace.registerExprKeymap('i', matched, closePair.bind(null, matched), true));
 130                 }
 131             }
 132         }
 133         // tslint:disable-next-line: no-floating-promises
 134         nvim.resumeNotification(false, true);
 135     }
 136     await createBufferKeymap(coc_nvim_1.workspace.getDocument(coc_nvim_1.workspace.bufnr));
 137     coc_nvim_1.workspace.onDidOpenTextDocument(async (e) => {
 138         await createBufferKeymap(coc_nvim_1.workspace.getDocument(e.uri));
 139     });
 140 }
 141 exports.activate = activate;
 142 // remove paired characters when possible
 143 async function onBackspace() {
 144     let { nvim } = coc_nvim_1.workspace;
 145     let res = await nvim.eval('[getline("."),col("."),synIDattr(synID(line("."), col(".") - 2, 1), "name")]');
 146     if (res) {
 147         let [line, col, synname] = res;
 148         if (col > 1 && !/string/i.test(synname)) {
 149             let buf = Buffer.from(line, 'utf8');
 150             if (col - 1 < buf.length) {
 151                 let pre = buf.slice(col - 2, col - 1).toString('utf8');
 152                 let next = buf.slice(col - 1, col).toString('utf8');
 153                 if (pairs.has(pre) && pairs.get(pre) == next) {
 154                     await nvim.eval(`feedkeys("\\<C-G>U\\<right>\\<bs>\\<bs>", 'in')`);
 155                     return;
 156                 }
 157             }
 158         }
 159     }
 160     await nvim.eval(`feedkeys("\\<bs>", 'in')`);
 161     return '';
 162 }
 163 function byteSlice(content, start, end) {
 164     let buf = Buffer.from(content, 'utf8');
 165     return buf.slice(start, end).toString('utf8');
 166 }
 167 exports.byteSlice = byteSlice;
 168 function wait(ms) {
 169     return new Promise(resolve => {
 170         setTimeout(() => {
 171             resolve(undefined);
 172         }, ms);
 173     });
 174 }
 175 exports.wait = wait;
 176 function isWord(character) {
 177     let code = character.charCodeAt(0);
 178     if (code > 128)
 179         return false;
 180     if (code == 95)
 181         return true;
 182     if (code >= 48 && code <= 57)
 183         return true;
 184     if (code >= 65 && code <= 90)
 185         return true;
 186     if (code >= 97 && code <= 122)
 187         return true;
 188     return false;
 189 }
 190 exports.isWord = isWord;
 191 //# sourceMappingURL=index.js.map