.emacs.d.git - Gitblit

Chizi123

2018-11-17 5cb5f70b1872a757e93ea333b0e2dca50c6c8957

commit \| author \| age
5cb5f7	1	;;; smartparens.el --- Automatic insertion, wrapping and paredit-like navigation with user defined pairs. -- lexical-binding: t --
C	2
	3	;; Copyright (C) 2012-2016 Matus Goljer
	4
	5	;; Author: Matus Goljer <matus.goljer@gmail.com>
	6	;; Maintainer: Matus Goljer <matus.goljer@gmail.com>
	7	;; Created: 17 Nov 2012
	8	;; Keywords: abbrev convenience editing
	9	;; URL: https://github.com/Fuco1/smartparens
	10
	11	;; This file is not part of GNU Emacs.
	12
	13	;;; License:
	14
	15	;; This file is part of Smartparens.
	16
	17	;; Smartparens is free software; you can redistribute it and/or modify
	18	;; it under the terms of the GNU General Public License as published by
	19	;; the Free Software Foundation, either version 3 of the License, or
	20	;; (at your option) any later version.
	21
	22	;; Smartparens is distributed in the hope that it will be useful,
	23	;; but WITHOUT ANY WARRANTY; without even the implied warranty of
	24	;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	25	;; GNU General Public License for more details.
	26
	27	;; You should have received a copy of the GNU General Public License
	28	;; along with Smartparens. If not, see <http://www.gnu.org/licenses/>.
	29
	30	;;; Commentary:
	31
	32	;; Smartparens is minor mode for Emacs that deals with parens pairs
	33	;; and tries to be smart about it. It started as a unification effort
	34	;; to combine functionality of several existing packages in a single,
	35	;; compatible and extensible way to deal with parentheses, delimiters,
	36	;; tags and the like. Some of these packages include autopair,
	37	;; textmate, wrap-region, electric-pair-mode, paredit and others. With
	38	;; the basic features found in other packages it also brings many
	39	;; improvements as well as completely new features.
	40
	41	;; For a basic overview, see github readme at
	42	;; https://github.com/Fuco1/smartparens
	43
	44	;; For the complete documentation visit the documentation wiki located
	45	;; at https://github.com/Fuco1/smartparens/wiki
	46
	47	;; If you like this project, you can donate here:
	48	;; https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=CEYP5YVHDRX8C
	49
	50	;;; Code:
	51
	52	(eval-when-compile
	53	(require 'subr-x) ; for `string-trim'
	54	(require 'cl-lib))
	55
	56	(require 'dash)
	57	(require 'thingatpt)
	58	(require 'help-mode) ;; for help-xref-following #85
	59
	60	(declare-function cua-replace-region "cua-base") ; FIXME: remove this when we drop support for old emacs
	61	(declare-function cua-delete-region "cua-base")
	62	(declare-function cua--fallback "cua-base")
	63	(declare-function package-version-join "package")
	64	(declare-function package-desc-version "package")
	65
	66	(declare-function subword-kill "subword")
	67	(declare-function subword-forward "subword")
	68	(declare-function subword-backward "subword")
	69
	70	(declare-function hungry-delete-backward "hungry-delete")
	71	(declare-function hungry-delete-forward "hungry-delete")
	72
	73	(declare-function evil-get-register "evil-common")
	74	(declare-function evil-set-register "evil-common")
	75	(eval-when-compile
	76	(defvar evil-this-register)
	77	(defvar package-alist)
	78	(defvar sp-autoskip-closing-pair)
	79	(defvar sp-show-enclosing-pair-commands)
	80	(defvar show-smartparens-mode))
	81
	82
	83	;;; backport for older emacsen
	84
	85	;; introduced in 24.3
	86	(unless (fboundp 'defvar-local)
	87	(defmacro defvar-local (var val &optional docstring)
	88	"Define VAR as a buffer-local variable with default value VAL.
	89	Like `defvar' but additionally marks the variable as being automatically
	90	buffer-local wherever it is set."
	91	(declare (debug defvar) (doc-string 3))
	92	;; Can't use backquote here, it's too early in the bootstrap.
	93	(list 'progn (list 'defvar var val docstring)
	94	(list 'make-variable-buffer-local (list 'quote var)))))
	95
	96	;;;###autoload
	97	(defun sp-cheat-sheet (&optional arg)
	98	"Generate a cheat sheet of all the smartparens interactive functions.
	99
	100	Without a prefix argument, print only the short documentation and examples.
	101
	102	With non-nil prefix argument ARG, show the full documentation for each function.
	103
	104	You can follow the links to the function or variable help page.
	105	To get back to the full list, use \\[help-go-back].
	106
	107	You can use `beginning-of-defun' and `end-of-defun' to jump to
	108	the previous/next entry.
	109
	110	Examples are fontified using the `font-lock-string-face' for
	111	better orientation."
	112	(interactive "P")
	113	(setq arg (not arg))
	114	(let ((do-not-display '(
	115	smartparens-mode
	116	smartparens-global-mode
	117	turn-on-smartparens-mode
	118	turn-off-smartparens-mode
	119	sp-wrap-cancel
	120	sp-remove-active-pair-overlay
	121	sp-splice-sexp-killing-around ;; is aliased to `sp-raise-sexp'
	122	show-smartparens-mode
	123	show-smartparens-global-mode
	124	turn-on-show-smartparens-mode
	125	turn-off-show-smartparens-mode
	126	))
	127	(do-not-display-with-arg '(
	128	sp-use-paredit-bindings
	129	sp-use-smartparens-bindings
	130	))
	131	(commands (cl-loop for i in (cdr (assoc-string (file-truename (locate-library "smartparens")) load-history))
	132	if (and (consp i) (eq (car i) 'defun) (commandp (cdr i)))
	133	collect (cdr i))))
	134	(with-current-buffer (get-buffer-create "Smartparens cheat sheet")
	135	(let ((standard-output (current-buffer))
	136	(help-xref-following t))
	137	(read-only-mode -1)
	138	(erase-buffer)
	139	(help-mode)
	140	(smartparens-mode 1)
	141	(help-setup-xref (list #'sp-cheat-sheet)
	142	(called-interactively-p 'interactive))
	143	(read-only-mode -1)
	144	(--each (--remove (or (memq it do-not-display)
	145	(and arg (memq it do-not-display-with-arg)))
	146	commands)
	147	(unless (equal (symbol-name it) "advice-compilation")
	148	(let ((start (point)) kill-from)
	149	(insert (propertize (symbol-name it) 'face 'font-lock-function-name-face))
	150	(insert " is ")
	151	(describe-function-1 it)
	152	(save-excursion
	153	(when arg
	154	(goto-char start)
	155	(forward-paragraph 1)
	156	(forward-line 1)
	157	(if (looking-at "^It is bound")
	158	(forward-paragraph 2)
	159	(forward-paragraph 1))
	160	(setq kill-from (point))
	161	(when (re-search-forward "^Examples:" nil t)
	162	(delete-region kill-from
	163	(save-excursion
	164	(forward-line 1)
	165	(point))))))
	166	(insert (propertize (concat
	167	"\n\n"
	168	(make-string 72 ?―)
	169	"\n\n") 'face 'font-lock-function-name-face)))))
	170	(goto-char (point-min))
	171	(while (re-search-forward "\$->\\\|\$" nil t)
	172	(let ((thing (bounds-of-thing-at-point 'line)))
	173	(put-text-property (car thing) (cdr thing) 'face 'font-lock-string-face)))
	174	(goto-char (point-min))
	175	(while (re-search-forward "\|" nil t)
	176	(put-text-property (1- (point)) (point) 'face 'font-lock-warning-face))
	177	(goto-char (point-min))
	178	(while (re-search-forward "^It is bound to \$.*?\$\\." nil t)
	179	(put-text-property (match-beginning 1) (match-end 1) 'face 'font-lock-keyword-face))
	180	(goto-char (point-min))
	181	(while (re-search-forward ";;.*?$" nil t)
	182	(put-text-property (match-beginning 0) (match-end 0) 'face 'font-lock-comment-face))
	183	(help-make-xrefs)
	184	(goto-char (point-min))))
	185	(pop-to-buffer "Smartparens cheat sheet")))
	186
	187	(defun sp-describe-system (starterkit)
	188	"Describe user's system.
	189
	190	The output of this function can be used in bug reports."
	191	(interactive
	192	(list (completing-read "Starterkit/Distribution used: "
	193	(list
	194	"Spacemacs"
	195	"Evil"
	196	"Vanilla"
	197	))))
	198	(let ((text (format "- `smartparens` version: %s
	199	- Active `major-mode`: `%s`
	200	- Smartparens strict mode: %s
	201	- Emacs version (`M-x emacs-version`): %s
	202	- Starterkit/Distribution: %s
	203	- OS: %s"
	204	(--if-let (cadr (assoc 'smartparens package-alist))
	205	(package-version-join (package-desc-version it))
	206	"<Please specify manually>")
	207	(symbol-name major-mode)
	208	(bound-and-true-p smartparens-strict-mode)
	209	(replace-regexp-in-string "\n" "" (emacs-version))
	210	starterkit
	211	(symbol-name system-type))))
	212	(pop-to-buffer
	213	(with-current-buffer (get-buffer-create "sp-describe-system")
	214	(erase-buffer)
	215	(insert "The content of the buffer underneath the line was
	216	copied to your clipboard. You can also edit it in this buffer
	217	and then copy the results manually.
	218	------------------------------------------------
	219	")
	220	(insert text)
	221	(current-buffer)))
	222	(kill-new text)))
	223
	224
	225	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
	226	;; Variables
	227
	228	(defvar-local sp-forward-bound-fn nil
	229	"Function to restrict the forward search")
	230
	231	(defvar-local sp-backward-bound-fn nil
	232	"Function to restrict the backward search")
	233
	234	(defun sp--get-forward-bound ()
	235	"Get the bound to limit the forward search for looking for pairs.
	236
	237	If it returns nil, the original bound passed to the search
	238	function will be considered."
	239	(and sp-forward-bound-fn (funcall sp-forward-bound-fn)))
	240
	241	(defun sp--get-backward-bound ()
	242	"Get the bound to limit the backward search for looking for pairs.
	243
	244	If it returns nil, the original bound passed to the search
	245	function will be considered."
	246	(and sp-backward-bound-fn (funcall sp-backward-bound-fn)))
	247
	248
	249	;;;###autoload
	250	(defvar smartparens-mode-map (make-sparse-keymap)
	251	"Keymap used for `smartparens-mode'.")
	252	(defvaralias 'sp-keymap 'smartparens-mode-map)
	253	(make-obsolete-variable 'sp-keymap 'smartparens-mode-map "2015-01-01")
	254
	255	(defvar sp-paredit-bindings '(
	256	("C-M-f" . sp-forward-sexp) ;; navigation
	257	("C-M-b" . sp-backward-sexp)
	258	("C-M-u" . sp-backward-up-sexp)
	259	("C-M-d" . sp-down-sexp)
	260	("C-M-p" . sp-backward-down-sexp)
	261	("C-M-n" . sp-up-sexp)
	262	("M-s" . sp-splice-sexp) ;; depth-changing commands
	263	("M-<up>" . sp-splice-sexp-killing-backward)
	264	("M-<down>" . sp-splice-sexp-killing-forward)
	265	("M-r" . sp-splice-sexp-killing-around)
	266	("M-(" . sp-wrap-round)
	267	("C-)" . sp-forward-slurp-sexp) ;; barf/slurp
	268	("C-<right>" . sp-forward-slurp-sexp)
	269	("C-}" . sp-forward-barf-sexp)
	270	("C-<left>" . sp-forward-barf-sexp)
	271	("C-(" . sp-backward-slurp-sexp)
	272	("C-M-<left>" . sp-backward-slurp-sexp)
	273	("C-{" . sp-backward-barf-sexp)
	274	("C-M-<right>" . sp-backward-barf-sexp)
	275	("M-S" . sp-split-sexp) ;; misc
	276	("M-j" . sp-join-sexp)
	277	("M-?" . sp-convolute-sexp)
	278	)
	279	"Paredit inspired bindings.
	280
	281	Alist containing the default paredit bindings to corresponding
	282	smartparens functions.")
	283
	284	(defun sp--populate-keymap (bindings)
	285	"Populates the `smartparens-mode-map' from the BINDINGS alist."
	286	(--each bindings
	287	(define-key smartparens-mode-map (read-kbd-macro (car it)) (cdr it))))
	288
	289	;;;###autoload
	290	(defun sp-use-paredit-bindings ()
	291	"Initiate `smartparens-mode-map' with `sp-paredit-bindings'."
	292	(interactive)
	293	(sp--populate-keymap sp-paredit-bindings))
	294
	295	(defvar sp-smartparens-bindings '(
	296	("C-M-f" . sp-forward-sexp)
	297	("C-M-b" . sp-backward-sexp)
	298	("C-M-d" . sp-down-sexp)
	299	("C-M-a" . sp-backward-down-sexp)
	300	("C-S-d" . sp-beginning-of-sexp)
	301	("C-S-a" . sp-end-of-sexp)
	302	("C-M-e" . sp-up-sexp)
	303	("C-M-u" . sp-backward-up-sexp)
	304	("C-M-n" . sp-next-sexp)
	305	("C-M-p" . sp-previous-sexp)
	306	("C-M-k" . sp-kill-sexp)
	307	("C-M-w" . sp-copy-sexp)
	308	("M-<delete>" . sp-unwrap-sexp)
	309	("M-<backspace>" . sp-backward-unwrap-sexp)
	310	("C-<right>" . sp-forward-slurp-sexp)
	311	("C-<left>" . sp-forward-barf-sexp)
	312	("C-M-<left>" . sp-backward-slurp-sexp)
	313	("C-M-<right>" . sp-backward-barf-sexp)
	314	("M-D" . sp-splice-sexp)
	315	("C-M-<delete>" . sp-splice-sexp-killing-forward)
	316	("C-M-<backspace>" . sp-splice-sexp-killing-backward)
	317	("C-S-<backspace>" . sp-splice-sexp-killing-around)
	318	("C-]" . sp-select-next-thing-exchange)
	319	("C-M-]" . sp-select-next-thing)
	320	("C-M-SPC" . sp-mark-sexp)
	321	("M-F" . sp-forward-symbol)
	322	("M-B" . sp-backward-symbol)
	323	)
	324	"Alist containing the default smartparens bindings.")
	325
	326	;;;###autoload
	327	(defun sp-use-smartparens-bindings ()
	328	"Initiate `smartparens-mode-map' with `sp-smartparens-bindings'."
	329	(interactive)
	330	(sp--populate-keymap sp-smartparens-bindings))
	331
	332	(defun sp--set-base-key-bindings (&optional symbol value)
	333	"Set up the default keymap based on `sp-base-key-bindings'.
	334
	335	SYMBOL is the symbol being set, that is `sp-base-key-bindings'.
	336
	337	VALUE is the saved value (as a symbol), can be one of:
	338	- sp
	339	- paredit
	340
	341	This function is also used as a setter for this customize value."
	342	(when symbol (set-default symbol value))
	343	(cond
	344	((eq value 'sp)
	345	(sp-use-smartparens-bindings))
	346	((eq value 'paredit)
	347	(sp-use-paredit-bindings))))
	348
	349	(defun sp--update-override-key-bindings (&optional symbol value)
	350	"Override the key bindings with values from `sp-override-key-bindings'.
	351
	352	SYMBOL is `sp-override-key-bindings', VALUE is the value being set.
	353
	354	This function is also used as a setter for this customize value."
	355	(when symbol (set-default symbol value))
	356	;; this also needs to reload the base set, if any is present.
	357	(sp--set-base-key-bindings)
	358	(sp--populate-keymap value))
	359
	360	(defcustom sp-base-key-bindings nil
	361	"A default set of key bindings for commands provided by smartparens.
	362
	363	Paredit binding adds the bindings in `sp-paredit-bindings' to the
	364	corresponding smartparens commands. It does not add bindings to
	365	any other commands, or commands that do not have a paredit
	366	counterpart.
	367
	368	Smartparens binding adds the bindings in
	369	`sp-smartparens-bindings' to most common smartparens commands.
	370	These are somewhat inspired by paredit, but in many cases differ.
	371
	372	Note that neither \"paredit\" nor \"smartparens\" bindings add a
	373	binding for all the provided commands."
	374	:type '(radio
	375	(const :tag "Don't use any default set of bindings" nil)
	376	(const :tag "Use smartparens set of bindings" sp)
	377	(const :tag "Use paredit set of bindings" paredit))
	378	:set 'sp--set-base-key-bindings
	379	:group 'smartparens)
	380
	381	(defcustom sp-override-key-bindings nil
	382	"An alist of bindings and commands that should override the base key set.
	383
	384	If you wish to override a binding from the base set, set the
	385	value for the binding to the `kbd' recognizable string constant
	386	and command to the command symbol you wish to bind there.
	387
	388	If you wish to disable a binding from the base set, set the value
	389	for the command to nil.
	390
	391	Examples:
	392	(\"C-M-f\" . sp-forward-sexp)
	393	(\"C-<right>\" . nil)
	394
	395	See `sp-base-key-bindings'."
	396	:type '(alist
	397	:key-type string
	398	:value-type symbol)
	399	:set 'sp--update-override-key-bindings
	400	:group 'smartparens)
	401
	402	(defvar sp-escape-char nil
	403	"Character used to escape quotes inside strings.")
	404	(make-variable-buffer-local 'sp-escape-char)
	405
	406	(defvar sp-comment-char nil
	407	"Character used to start comments.")
	408	(make-variable-buffer-local 'sp-comment-char)
	409
	410	(defvar sp-pair-list nil
	411	"List of pairs for autoinsertion or wrapping.
	412
	413	Maximum length of opening or closing pair is
	414	`sp-max-pair-length' characters.")
	415	(make-variable-buffer-local 'sp-pair-list)
	416
	417	(defvar sp-local-pairs nil
	418	"List of pair definitions used for current buffer.")
	419	(make-variable-buffer-local 'sp-local-pairs)
	420
	421	(defvar sp-last-operation nil
	422	"Symbol holding the last successful operation.")
	423	(make-variable-buffer-local 'sp-last-operation)
	424
	425	(cl-defstruct sp-state
	426	"Smartparens state for the current buffer."
	427	;; A "counter" to track delayed hook. When a pair is inserted, a
	428	;; cons of the form (:next . pair) is stored. On the next
	429	;; (immediately after insertion) invocation of post-command-hook, it
	430	;; is changed to (:this . pair). When the `car' is :this, the
	431	;; post-command-hook checks the delayed hooks for `pair' and
	432	;; executes them, then reset the "counter".
	433	delayed-hook
	434	;; TODO
	435	delayed-insertion
	436	;; The last point checked by sp--syntax-ppss and its result, used for
	437	;; memoization
	438	last-syntax-ppss-point ;; a list (point point-min point-max)
	439	last-syntax-ppss-result
	440	;; Value of `sp-pair-list' for this buffer. Note that this might
	441	;; differ from `sp-pair-list' which is often changed by dynamic
	442	;; binding
	443	pair-list
	444	;; Value of `sp-local-pairs' for this buffer. Note that this might
	445	;; differ from `sp-local-pairs' which is often changed by dynamic
	446	;; binding
	447	local-pairs
	448	)
	449
	450	(defvar sp-state (make-sp-state)
	451	"Smartparens state for the current buffer.")
	452	(make-variable-buffer-local 'sp-state)
	453
	454	;; TODO: get rid of this
	455	(defvar sp-previous-point -1
	456	"Location of point before last command.
	457
	458	This is only updated when some pair-overlay is active. Do not
	459	rely on the value of this variable anywhere else!")
	460	(make-variable-buffer-local 'sp-previous-point)
	461
	462	;; TODO: get rid of this
	463	(defvar sp-wrap-point nil
	464	"Save the value of point before attemt to wrap a region.
	465
	466	Used for restoring the original state if the wrapping is
	467	cancelled.")
	468	(make-variable-buffer-local 'sp-wrap-point)
	469
	470	;; TODO: get rid of this
	471	(defvar sp-wrap-mark nil
	472	"Save the value of mark before attemt to wrap a region.
	473
	474	Used for restoring the original state if the wrapping is
	475	cancelled.")
	476	(make-variable-buffer-local 'sp-wrap-mark)
	477
	478	(defvar sp-last-inserted-characters ""
	479	"Characters typed during the wrapping selection.
	480
	481	If wrapping is cancelled, these characters are re-inserted to the
	482	location of point before the wrapping.")
	483	(make-variable-buffer-local 'sp-last-inserted-characters)
	484
	485	(defvar sp-last-inserted-pair nil
	486	"Last inserted pair.")
	487	(make-variable-buffer-local 'sp-last-inserted-pair)
	488
	489	(defvar sp-delayed-pair nil
	490	"The pair whose insertion is being delayed.
	491
	492	The insertion of this pair is delayed to be carried out in
	493	`sp--post-command-hook-handler'. The format is (opening delim
	494	. beg of the opening delim)")
	495	(make-variable-buffer-local 'sp-delayed-pair)
	496
	497	(defvar sp-last-wrapped-region nil
	498	"Information about the last wrapped region.
	499	The format is the same as returned by `sp-get-sexp'.")
	500	(make-variable-buffer-local 'sp-last-wrapped-region)
	501
	502	(defvar sp-point-inside-string nil
	503	"Non-nil if point is inside a string.
	504
	505	Used to remember the state from before `self-insert-command' is
	506	run.")
	507
	508	(defvar sp-buffer-modified-p nil
	509	"Non-nil if buffer was modified before `pre-command-hook'.")
	510
	511	(defvar sp-pre-command-point nil
	512	"Position of `point' before `this-command' gets executed.")
	513
	514	(defconst sp-max-pair-length 10
	515	"Maximum length of an opening or closing delimiter.
	516
	517	Only the pairs defined by `sp-pair' are considered. Tag pairs
	518	can be of any length.")
	519
	520	(defconst sp-max-prefix-length 100
	521	"Maximum length of a pair prefix.
	522
	523	Because prefixes for pairs can be specified using regular
	524	expressions, they can potentially be of arbitrary length. This
	525	settings solves the problem where the parser would decide to
	526	backtrack the entire buffer which would lock up Emacs.")
	527
	528	(defvar sp-pairs
	529	'((t
	530	.
	531	((:open "\\\$" :close "\\\$" :actions (insert wrap autoskip navigate))
	532	(:open "\\{" :close "\\}" :actions (insert wrap autoskip navigate))
	533	(:open "\$" :close "\$" :actions (insert wrap autoskip navigate))
	534	(:open "\\\"" :close "\\\"" :actions (insert wrap autoskip navigate))
	535	(:open "\"" :close "\""
	536	:actions (insert wrap autoskip navigate escape)
	537	:unless (sp-in-string-quotes-p)
	538	:post-handlers (sp-escape-wrapped-region sp-escape-quotes-after-insert))
	539	(:open "'" :close "'"
	540	:actions (insert wrap autoskip navigate escape)
	541	:unless (sp-in-string-quotes-p sp-point-after-word-p)
	542	:post-handlers (sp-escape-wrapped-region sp-escape-quotes-after-insert))
	543	(:open "(" :close ")" :actions (insert wrap autoskip navigate))
	544	(:open "[" :close "]" :actions (insert wrap autoskip navigate))
	545	(:open "{" :close "}" :actions (insert wrap autoskip navigate))
	546	(:open "`" :close "`" :actions (insert wrap autoskip navigate)))))
	547	"List of pair definitions.
	548
	549	Maximum length of opening or closing pair is
	550	`sp-max-pair-length' characters.")
	551
	552	(defvar sp-tags nil
	553	"List of tag definitions. See `sp-local-tag' for more information.")
	554
	555	(defvar sp-prefix-tag-object nil
	556	"If non-nil, only consider tags while searching for next thing.")
	557
	558	(defvar sp-prefix-pair-object nil
	559	"If non-nil, only consider pairs while searching for next thing.
	560
	561	Pairs are defined as expressions delimited by pairs from
	562	`sp-pair-list'.")
	563
	564	(defvar sp-prefix-symbol-object nil
	565	"If non-nil, only consider symbols while searching for next thing.
	566
	567	Symbol is defined as a chunk of text recognized by
	568	`sp-forward-symbol'.")
	569
	570	(define-obsolete-variable-alias 'sp--lisp-modes 'sp-lisp-modes "2015-11-08")
	571
	572	(defcustom sp-lisp-modes '(
	573	cider-repl-mode
	574	clojure-mode
	575	clojurec-mode
	576	clojurescript-mode
	577	clojurex-mode
	578	common-lisp-mode
	579	emacs-lisp-mode
	580	eshell-mode
	581	geiser-repl-mode
	582	gerbil-mode
	583	inf-clojure-mode
	584	inferior-emacs-lisp-mode
	585	inferior-lisp-mode
	586	inferior-scheme-mode
	587	lisp-interaction-mode
	588	lisp-mode
	589	monroe-mode
	590	racket-mode
	591	racket-repl-mode
	592	scheme-interaction-mode
	593	scheme-mode
	594	slime-repl-mode
	595	stumpwm-mode
	596	)
	597	"List of Lisp-related modes."
	598	:type '(repeat symbol)
	599	:group 'smartparens)
	600
	601	(defcustom sp-clojure-modes '(
	602	cider-repl-mode
	603	clojure-mode
	604	clojurec-mode
	605	clojurescript-mode
	606	clojurex-mode
	607	inf-clojure-mode
	608	)
	609	"List of Clojure-related modes."
	610	:type '(repeat symbol)
	611	:group 'smartparens)
	612
	613	(defcustom sp-no-reindent-after-kill-modes '(
	614	python-mode
	615	coffee-mode
	616	asm-mode
	617	makefile-gmake-mode
	618	haml-mode
	619	)
	620	"List of modes that should not reindent after kill."
	621	:type '(repeat symbol)
	622	:group 'smartparens)
	623
	624	(defcustom sp-no-reindent-after-kill-indent-line-functions
	625	'(
	626	insert-tab
	627	)
	628	"List of `indent-line-function's that should not reindent after kill."
	629	:type '(repeat symbol)
	630	:group 'smartparens)
	631
	632	(defvar sp--html-modes '(
	633	sgml-mode
	634	html-mode
	635	rhtml-mode
	636	nxhtml-mode
	637	nxml-mode
	638	web-mode
	639	jinja2-mode
	640	html-erb-mode
	641	js-jsx-mode
	642	js2-jsx-mode
	643	rjsx-mode
	644	)
	645	"List of HTML modes.")
	646
	647	(defvar sp-message-alist
	648	'((:unmatched-expression
	649	"Search failed: there is an unmatched expression somewhere or we are at the beginning/end of file"
	650	"Unmatched expression")
	651	(:unbalanced-region
	652	"Can not kill the region: the buffer would end up in an unbalanced state after deleting the active region"
	653	"Killing the region would make the buffer unbalanced"
	654	"Unbalanced region")
	655	(:delimiter-in-string
	656	"Ignored: opening or closing pair is inside a string or comment and matching pair is outside (or vice versa)")
	657	(:no-matching-tag
	658	"Search failed: no matching tag found"
	659	"No matching tag")
	660	(:invalid-context-prev
	661	"Invalid context: previous h-sexp ends after the next one"
	662	"Invalid context")
	663	(:invalid-context-cur
	664	"Invalid context: current h-sexp starts after the next one"
	665	"Invalid context")
	666	(:no-structure-found
	667	"Previous sexp starts after current h-sexp or no structure was found"
	668	"No valid structure found")
	669	(:invalid-structure
	670	"Ignored: this operation would result in invalid structure"
	671	"Ignored because of invalid structure")
	672	(:cant-slurp
	673	"Ignored: we can not slurp without breaking strictly balanced expression"
	674	"Can not slurp without breaking balance")
	675	(:cant-slurp-context
	676	"Ignored: we can not slurp into different context (comment -> code)"
	677	"Can not slurp into different context")
	678	(:cant-insert-closing-delimiter
	679	"We can not insert unbalanced closing delimiter in strict mode"
	680	"Can not insert unbalanced delimiter")
	681	(:blank-sexp
	682	"Point is in blank sexp, nothing to barf"
	683	"Point is in blank sexp")
	684	(:point-not-deep-enough
	685	"Point has to be at least two levels deep to swap the enclosing delimiters"
	686	"Point has to be at least two levels deep"
	687	"Point not deep enough")
	688	(:different-type
	689	"The expressions to be joined are of different type"
	690	"Expressions are of different type"))
	691	"List of predefined messages to be displayed by `sp-message'.
	692
	693	Each element is a list consisting of a keyword and one or more
	694	strings, which are chosen based on the `sp-message-width'
	695	variable. If the latter is t, the first string is chosen as
	696	default, which should be the most verbose option available.")
	697
	698
	699	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
	700	;; Customize & Mode definitions
	701
	702	(defgroup smartparens ()
	703	"Smartparens minor mode."
	704	:group 'editing
	705	:prefix "sp-")
	706
	707	;;;###autoload
	708	(define-minor-mode smartparens-mode
	709	"Toggle smartparens mode.
	710
	711	You can enable pre-set bindings by customizing
	712	`sp-base-key-bindings' variable. The current content of
	713	`smartparens-mode-map' is:
	714
	715	\\{smartparens-mode-map}"
	716	:init-value nil
	717	:lighter (" SP" (:eval (if smartparens-strict-mode "/s" "")))
	718	:group 'smartparens
	719	:keymap smartparens-mode-map
	720	(if smartparens-mode
	721	(progn
	722	(sp--init)
	723	(add-hook 'self-insert-uses-region-functions 'sp-wrap--can-wrap-p nil 'local)
	724	(run-hooks 'smartparens-enabled-hook))
	725	(remove-hook 'self-insert-uses-region-functions 'sp-wrap--can-wrap-p 'local)
	726	(run-hooks 'smartparens-disabled-hook)))
	727
	728	(defvar smartparens-strict-mode-map
	729	(let ((map (make-sparse-keymap)))
	730	(define-key map [remap delete-char] 'sp-delete-char)
	731	(define-key map [remap delete-forward-char] 'sp-delete-char)
	732	(define-key map [remap backward-delete-char-untabify] 'sp-backward-delete-char)
	733	(define-key map [remap backward-delete-char] 'sp-backward-delete-char)
	734	(define-key map [remap delete-backward-char] 'sp-backward-delete-char)
	735	(define-key map [remap kill-word] 'sp-kill-word)
	736	(define-key map [remap kill-line] 'sp-kill-hybrid-sexp)
	737	(define-key map [remap backward-kill-word] 'sp-backward-kill-word)
	738	(define-key map [remap kill-region] 'sp-kill-region)
	739	(define-key map [remap delete-region] 'sp-delete-region)
	740	(define-key map [remap kill-whole-line] 'sp-kill-whole-line)
	741	map)
	742	"Keymap used for `smartparens-strict-mode'.")
	743
	744	;;;###autoload
	745	(define-minor-mode smartparens-strict-mode
	746	"Toggle the strict smartparens mode.
	747
	748	When strict mode is active, `delete-char', `kill-word' and their
	749	backward variants will skip over the pair delimiters in order to
	750	keep the structure always valid (the same way as `paredit-mode'
	751	does). This is accomplished by remapping them to
	752	`sp-delete-char' and `sp-kill-word'. There is also function
	753	`sp-kill-symbol' that deletes symbols instead of words, otherwise
	754	working exactly the same (it is not bound to any key by default).
	755
	756	When strict mode is active, this is indicated with \"/s\"
	757	after the smartparens indicator in the mode list."
	758	:init-value nil
	759	:group 'smartparens
	760	(if smartparens-strict-mode
	761	(progn
	762	(unless smartparens-mode
	763	(smartparens-mode 1))
	764	(unless (-find-indices (lambda (it) (eq (car it) 'smartparens-strict-mode)) minor-mode-overriding-map-alist)
	765	(setq minor-mode-overriding-map-alist
	766	(cons `(smartparens-strict-mode . ,smartparens-strict-mode-map) minor-mode-overriding-map-alist)))
	767	(put 'sp-backward-delete-char 'delete-selection 'sp--delete-selection-supersede-p)
	768	(put 'sp-delete-char 'delete-selection 'sp--delete-selection-supersede-p)
	769	(add-hook 'self-insert-uses-region-functions 'sp--self-insert-uses-region-strict-p nil 'local)
	770	(setq sp-autoskip-closing-pair 'always))
	771	(setq minor-mode-overriding-map-alist
	772	(-remove (lambda (it) (eq (car it) 'smartparens-strict-mode)) minor-mode-overriding-map-alist))
	773	(put 'sp-backward-delete-char 'delete-selection 'supersede)
	774	(put 'sp-delete-char 'delete-selection 'supersede)
	775	(remove-hook 'self-insert-uses-region-functions 'sp--self-insert-uses-region-strict-p 'local)
	776	(let ((std-val (car (plist-get (symbol-plist 'sp-autoskip-closing-pair) 'standard-value)))
	777	(saved-val (car (plist-get (symbol-plist 'sp-autoskip-closing-pair) 'saved-value))))
	778	(setq sp-autoskip-closing-pair (eval (or saved-val std-val))))))
	779
	780	;;;###autoload
	781	(define-globalized-minor-mode smartparens-global-strict-mode
	782	smartparens-strict-mode
	783	turn-on-smartparens-strict-mode
	784	:group 'smartparens)
	785
	786	(defcustom sp-ignore-modes-list '(
	787	minibuffer-inactive-mode
	788	)
	789	"Modes where smartparens mode is inactive if allowed globally."
	790	:type '(repeat symbol)
	791	:group 'smartparens)
	792
	793	;;;###autoload
	794	(defun turn-on-smartparens-strict-mode ()
	795	"Turn on `smartparens-strict-mode'."
	796	(interactive)
	797	(unless (or (member major-mode sp-ignore-modes-list)
	798	(and (not (derived-mode-p 'comint-mode))
	799	(eq (get major-mode 'mode-class) 'special)))
	800	(smartparens-strict-mode 1)))
	801
	802	;;;###autoload
	803	(defun turn-off-smartparens-strict-mode ()
	804	"Turn off `smartparens-strict-mode'."
	805	(interactive)
	806	(smartparens-strict-mode -1))
	807
	808	(defun sp--init ()
	809	"Initialize the buffer local smartparens state.
	810
	811	This includes pair bindings and other buffer local variables
	812	that depend on the active `major-mode'."
	813	(setq sp-state (make-sp-state))
	814	;; setup local pair replacements
	815	(sp--update-local-pairs)
	816	;; set the escape char
	817	(dotimes (char 256)
	818	(unless sp-escape-char
	819	(when (= ?\\ (char-syntax char))
	820	(setq sp-escape-char (string char))))
	821	(unless sp-comment-char
	822	(when (= ?< (char-syntax char))
	823	(setq sp-comment-char (string char))))))
	824
	825	(defun sp--maybe-init ()
	826	"Initialize the buffer if it is not already initialized.
	827
	828	See `sp--init'."
	829	(unless sp-pair-list
	830	(sp--init)))
	831
	832	(defun sp--remove-local-pair (open)
	833	"Remove OPEN from `sp-local-pairs'."
	834	(setq sp-local-pairs
	835	(--remove (equal (plist-get it :open) open)
	836	sp-local-pairs)))
	837
	838	(defun sp--update-sp-pair-list ()
	839	"Update `sp-pair-list' according to current value of `sp-local-pairs'."
	840	(setq sp-pair-list
	841	(->> sp-local-pairs
	842	(--map (cons (plist-get it :open) (plist-get it :close)))
	843	(-sort (lambda (x y) (> (length (car x)) (length (car y))))))))
	844
	845	(defun sp--update-local-pairs ()
	846	"Update local pairs after change or at mode initialization.
	847
	848	This commands load all the parent major mode definitions and
	849	merges them into current buffer's `sp-local-pairs'."
	850	(let ((parent-modes (-fix (lambda (x)
	851	(--if-let (get (car x) 'derived-mode-parent)
	852	(cons it x)
	853	x))
	854	(list major-mode))))
	855	;; Combine all the definitions from the most ancient parent to the
	856	;; most recent parent
	857	(--each parent-modes (sp-update-local-pairs it))))
	858
	859	(defun sp-update-local-pairs (configuration)
	860	"Update `sp-local-pairs' with CONFIGURATION.
	861
	862	The pairs are only updated in current buffer not in all buffers
	863	with the same major mode! If you want to update all buffers of
	864	the specific major-modes use `sp-local-pair'.
	865
	866	CONFIGURATION can be a symbol to be looked up in `sp-pairs' or a
	867	property list corresponding to the arguments of `sp-local-pair'
	868	or a list of such property lists."
	869	(setq sp-local-pairs
	870	(cond
	871	((symbolp configuration)
	872	(sp--merge-pair-configurations (cdr (assq configuration sp-pairs))))
	873	((plist-member configuration :open)
	874	(sp--merge-pair-configurations (list configuration)))
	875	(t
	876	(sp--merge-pair-configurations configuration))))
	877
	878	;; Keep only those which have non-nil :actions
	879	(setq sp-local-pairs (--filter (plist-get it :actions) sp-local-pairs))
	880
	881	;; update the `sp-pair-list'. This is a list only containing
	882	;; (open.close) cons pairs for easier querying. We also must order
	883	;; it by length of opening delimiter in descending order (first
	884	;; value is the longest)
	885	(sp--update-sp-pair-list)
	886	(setf (sp-state-local-pairs sp-state) sp-local-pairs)
	887	(setf (sp-state-pair-list sp-state) sp-pair-list))
	888
	889	(defmacro sp-with-buffers-using-mode (mode &rest body)
	890	"Execute BODY in every existing buffer using `major-mode' MODE."
	891	(declare (indent 1))
	892	`(--each (buffer-list)
	893	(with-current-buffer it
	894	(when (derived-mode-p ,mode)
	895	,@body))))
	896
	897	(defun sp--update-local-pairs-everywhere (&rest modes)
	898	"Run `sp--update-local-pairs' in all buffers.
	899
	900	This is necessary to update all the buffer-local definitions. If
	901	MODES is non-nil, only update buffers with `major-mode' equal to
	902	MODES."
	903	(setq modes (-flatten modes))
	904	(--each (buffer-list)
	905	(with-current-buffer it
	906	(when (and smartparens-mode
	907	(or (not modes)
	908	(--any? (derived-mode-p it) modes)))
	909	(sp--update-local-pairs)))))
	910
	911	(defcustom smartparens-enabled-hook nil
	912	"Called after `smartparens-mode' is turned on."
	913	:type 'hook
	914	:group 'smartparens)
	915
	916	(defcustom smartparens-disabled-hook nil
	917	"Called after `smartparens-mode' is turned off."
	918	:type 'hook
	919	:group 'smartparens)
	920
	921	;;;###autoload
	922	(define-globalized-minor-mode smartparens-global-mode
	923	smartparens-mode
	924	turn-on-smartparens-mode)
	925
	926	;;;###autoload
	927	(defun turn-on-smartparens-mode ()
	928	"Turn on `smartparens-mode'.
	929
	930	This function is used to turn on `smartparens-global-mode'.
	931
	932	By default `smartparens-global-mode' ignores buffers with
	933	`mode-class' set to special, but only if they are also not comint
	934	buffers.
	935
	936	Additionally, buffers on `sp-ignore-modes-list' are ignored.
	937
	938	You can still turn on smartparens in these mode manually (or
	939	in mode's startup-hook etc.) by calling `smartparens-mode'."
	940	(interactive)
	941	(unless (or (member major-mode sp-ignore-modes-list)
	942	(and (not (derived-mode-p 'comint-mode))
	943	(eq (get major-mode 'mode-class) 'special)))
	944	(smartparens-mode t)))
	945
	946	;;;###autoload
	947	(defun turn-off-smartparens-mode ()
	948	"Turn off `smartparens-mode'."
	949	(interactive)
	950	(smartparens-mode -1))
	951
	952	;; insert custom
	953	(defcustom sp-autoinsert-pair t
	954	"If non-nil, autoinsert pairs. See `sp-insert-pair'."
	955	:type 'boolean
	956	:group 'smartparens)
	957
	958	;; TODO: remove this in 1.12
	959	(defcustom sp-autoinsert-quote-if-followed-by-closing-pair nil
	960	"If non-nil autoinsert quotes when the point is followed by closing delimiter.
	961
	962	This option only changes behaviour of the insertion process if
	963	point is inside a string. In other words, if string is not
	964	closed and next character is a closing pair.
	965
	966	For example, in a situation like this:
	967
	968	[\"some text\|]
	969
	970	after pressing \", one would probably want to insert the closing
	971	quote, not a nested pair (\\\"\\\"), to close the string literal
	972	in the array. To enable such behaviour, set this variable to
	973	nil.
	974
	975	Note: the values of this varible seem to be backward, i.e. it is
	976	\"enabled\" when the value is nil. This was an unfortunate
	977	choice of wording. It is kept this way to preserve backward
	978	compatibility. The intended meaning is \"insert the pair if
	979	followed by closing pair?\", t = yes."
	980	:type 'boolean
	981	:group 'smartparens)
	982	(make-obsolete-variable
	983	'sp-autoinsert-quote-if-followed-by-closing-pair
	984	"the option was removed and no longer has any effect." "1.10")
	985
	986	(defcustom sp-autoskip-closing-pair 'always-end
	987	"Determine the behaviour when skipping closing delimiters.
	988
	989	If t, skip the following closing pair if the expression is
	990	active (that is right after insertion). This is controlled by
	991	`sp-cancel-autoskip-on-backward-movement'.
	992
	993	If set to \"always-end\", skip the closing pair even if the
	994	expression is not active and point is at the end of the
	995	expression. This only works for expressions with
	996	single-character delimiters.
	997
	998	If set to \"always\", `sp-up-sexp' is called whenever the closing
	999	delimiter is typed inside a sexp of the same type. This is the
	1000	paredit-like behaviour. This setting only works for
	1001	single-character delimiters and does not work for string-like
	1002	delimiters.
	1003
	1004	See `sp-autoskip-opening-pair' for similar setting for
	1005	string-like delimiters.
	1006
	1007	See also `sp-skip-closing-pair'."
	1008	:type '(radio
	1009	(const :tag "Never skip closing delimiter" nil)
	1010	(const :tag "Skip closing delimiter in active expressions" t)
	1011	(const :tag "Always skip closing delimiter if at the end of sexp" always-end)
	1012	(const :tag "Always skip closing delimiter" always))
	1013	:group 'smartparens)
	1014	(make-variable-buffer-local 'sp-autoskip-closing-pair)
	1015
	1016	(defcustom sp-autoskip-opening-pair nil
	1017	"Determine the behaviour when skipping opening delimiters.
	1018
	1019	If non-nil, skip into the following string-like expression
	1020	instead of inserting a new pair."
	1021	:type 'boolean
	1022	:group 'smartparens)
	1023	(make-variable-buffer-local 'sp-autoskip-opening-pair)
	1024
	1025	;; TODO: rename to reflect what this actually does
	1026	(defcustom sp-cancel-autoskip-on-backward-movement t
	1027	"If non-nil, deactivate the active expression on backward movement.
	1028
	1029	Note: the name of this variable is a historic coincidence and
	1030	will change in some future release to reflect its real purpose.
	1031
	1032	See also `sp-skip-closing-pair'."
	1033	:type 'boolean
	1034	:group 'smartparens)
	1035
	1036	;; delete custom
	1037	(defcustom sp-autodelete-pair t
	1038	"If non-nil, auto delete pairs. See `sp-delete-pair'."
	1039	:type 'boolean
	1040	:group 'smartparens)
	1041
	1042	(defcustom sp-autodelete-closing-pair t
	1043	"If non-nil, auto delete the whole closing-pair. See `sp-delete-pair'."
	1044	:type 'boolean
	1045	:group 'smartparens)
	1046
	1047	(defcustom sp-autodelete-opening-pair t
	1048	"If non-nil, auto delete the whole opening-pair. See `sp-delete-pair'."
	1049	:type 'boolean
	1050	:group 'smartparens)
	1051
	1052	(defcustom sp-undo-pairs-separately nil
	1053	"If non-nil, put an `undo-boundary' before each inserted pair.
	1054
	1055	Calling undo after smartparens complete a pair will remove only
	1056	the pair before undoing any previous insertion.
	1057
	1058	WARNING: This option is implemented by hacking the
	1059	`buffer-undo-list'. Turning this option on might have
	1060	irreversible consequences on the buffer's undo information and in
	1061	some cases might remove important information. Usage of package
	1062	`undo-tree' is recommended if you ever need to revert to a state
	1063	unreachable by undo."
	1064	:type 'boolean
	1065	:group 'smartparens)
	1066
	1067	(defcustom sp-successive-kill-preserve-whitespace 1
	1068	"Control the behaviour of `sp-kill-sexp' on successive kills.
	1069
	1070	In the description, we consider more than one space
	1071	\"superfluous\", however, newlines are preserved."
	1072	:type '(radio
	1073	(const :tag "Always preserve the whitespace" 0)
	1074	(const :tag "Remove superfluous whitespace after last kill" 1)
	1075	(const :tag "Remove superfluous whitespace after all kills" 2))
	1076	:group 'smartparens)
	1077
	1078	;; wrap custom
	1079	(defcustom sp-autowrap-region t
	1080	"If non-nil, wrap the active region with pair."
	1081	:type 'boolean
	1082	:group 'smartparens)
	1083
	1084	(defcustom sp-wrap-show-possible-pairs t
	1085	"If non-nil, show possible pairs which can complete the wrapping."
	1086	:type 'boolean
	1087	:group 'smartparens)
	1088
	1089	(defcustom sp-autodelete-wrap t
	1090	"If non-nil, autodelete opening and closing pair of most recent wrapping.
	1091
	1092	Deletion command must be the very first command after the
	1093	insertion, otherwise normal behaviour is applied."
	1094	:type 'boolean
	1095	:group 'smartparens)
	1096
	1097	(defcustom sp-wrap-repeat-last 1
	1098	"Context in which smartparens repeats the last wrap.
	1099
	1100	If the last operation was a wrap and we insert another pair at
	1101	the beginning or end of the last wrapped region, repeat the
	1102	wrap on this region with current pair."
	1103	:type '(radio
	1104	(const :tag "Do not repeat wrapping" 0)
	1105	(const :tag "Only repeat if current tag is the same as the last one" 1)
	1106	(const :tag "Always repeat if the point is after the opening/closing delimiter of last wrapped region" 2))
	1107	:group 'smartparens)
	1108
	1109	(defcustom sp-wrap-entire-symbol nil
	1110	"If non-nil, do NOT wrap the entire symbol, only the part after point.
	1111
	1112	If set to \"Enable globally\", smart symbol wrapping is active
	1113	everywhere. This is the default option.
	1114
	1115	If set to \"Disable globally\", smart symbol wrapping is disabled
	1116	everywhere.
	1117
	1118	Otherwise, a list of major modes where smart symbol wrapping is
	1119	disabled can be supplied.
	1120
	1121	Examples:
	1122
	1123	foo-ba\|r-baz -> (\|foo-bar-baz) ;; if enabled
	1124
	1125	foo-ba\|r-baz -> foo-ba(\|r-baz) ;; if disabled"
	1126	:type '(choice
	1127	(const :tag "Enable globally" nil)
	1128	(const :tag "Disable globally" globally)
	1129	(repeat :tag "Disable in these major modes" symbol))
	1130	:group 'smartparens)
	1131
	1132	(defcustom sp-wrap-from-point nil
	1133	"If non-nil, do not wrap from the beginning of next expression but from point.
	1134
	1135	However, if the point is inside a symbol/word, the entire
	1136	symbol/word is wrapped. To customize this behaviour, see
	1137	variable `sp-wrap-entire-symbol'."
	1138	:type 'boolean
	1139	:group 'smartparens)
	1140
	1141	(defcustom sp-wrap-respect-direction nil
	1142	"When non-nil respect the wrap direction.
	1143
	1144	When non-nil, wrapping with opening pair always jumps to the
	1145	beginning of the region and wrapping with closing pair always
	1146	jumps to the end of the region.
	1147
	1148	\|fooM -> [ -> \|[foo]M
	1149	Mfoo\| -> [ -> \|[foo]M
	1150	\|fooM -> ] -> M[foo]\|
	1151	Mfoo\| -> ] -> M[foo]\|
	1152
	1153	When nil, closing pair places the point at the end of the region
	1154	and the opening pair leaves the point at its original
	1155	position (before or after the region).
	1156
	1157	\|fooM -> [ -> [\|fooM]
	1158	Mfoo\| -> [ -> M[foo]\|
	1159	\|fooM -> ] -> M[foo]\|
	1160	Mfoo\| -> ] -> M[foo]\|"
	1161	:type 'boolean
	1162	:group 'smartparens)
	1163
	1164	;; escaping custom
	1165	(defcustom sp-escape-wrapped-region t
	1166	"If non-nil, escape special chars inside the just wrapped region."
	1167	:type 'boolean
	1168	:group 'smartparens)
	1169
	1170	(defcustom sp-escape-quotes-after-insert t
	1171	"If non-nil, escape string quotes if typed inside string."
	1172	:type 'boolean
	1173	:group 'smartparens)
	1174
	1175	;; navigation & manip custom
	1176	(defcustom sp-navigate-consider-sgml-tags '(
	1177	html-mode
	1178	)
	1179	"List of modes where sgml tags are considered to be sexps."
	1180	:type '(repeat symbol)
	1181	:group 'smartparens)
	1182
	1183
	1184	(defcustom sp-navigate-use-textmode-stringlike-parser '((derived . text-mode))
	1185	"List of modes where textmode stringlike parser is used.
	1186
	1187	See `sp-get-textmode-stringlike-expression'.
	1188
	1189	Each element of the list can either be a symbol which is then
	1190	checked against `major-mode', or a cons (derived . PARENT-MODE),
	1191	where PARENT-MODE is checked using `derived-mode-p'."
	1192	:type '(repeat (choice
	1193	(symbol :tag "Major mode")
	1194	(cons :tag "Derived mode"
	1195	(const derived)
	1196	(symbol :tag "Parent major mode name"))))
	1197	:group 'smartparens)
	1198
	1199	(defcustom sp-navigate-consider-symbols t
	1200	"If non-nil, consider symbols outside balanced expressions as such.
	1201
	1202	Symbols are recognized by function `sp-forward-symbol'. This
	1203	setting affect all the navigation and manipulation functions
	1204	where it make sense.
	1205
	1206	Also, special handling of strings is enabled, where the whole
	1207	string delimited with \"\" is considered as one token.
	1208
	1209	WARNING: This is a legacy setting and changing its value to NIL
	1210	may break many things. It is kept only for backward
	1211	compatibility and will be removed in the next major release."
	1212	:type 'boolean
	1213	:group 'smartparens)
	1214
	1215	(defcustom sp-navigate-comments-as-sexps t
	1216	"If non-nil, consider comments as sexps in `sp-get-enclosing-sexp'.
	1217
	1218	If this option is enabled, unbalanced expressions in comments are
	1219	never automatically closed (see `sp-navigate-close-if-unbalanced')."
	1220	:type 'boolean
	1221	:group 'smartparens)
	1222
	1223	;; TODO: add -alist suffix
	1224	(defcustom sp-navigate-skip-match `(
	1225	(,sp-lisp-modes . sp--elisp-skip-match)
	1226	)
	1227	"Major-mode dependent specifications of skip functions.
	1228
	1229	Alist where the key is a list of major-modes and the value is a
	1230	function used to skip over matches in `sp-get-paired-expression'.
	1231	This function takes three arguments: the currently matched
	1232	delimiter, beginning of match and end of match. If this function
	1233	returns true, the current match will be skipped.
	1234
	1235	You can use this to skip over expressions that serve multiple
	1236	functions, such as if/end pair or unary if in Ruby or * in
	1237	markdown when it signifies list item instead of emphasis. If the
	1238	exception is only relevant to one pair, you should rather
	1239	use :skip-match option in `sp-local-pair'."
	1240	:type '(alist
	1241	:key-type (repeat symbol)
	1242	:value-type symbol)
	1243	:group 'smartparens)
	1244
	1245	(defcustom sp-navigate-reindent-after-up `(
	1246	(interactive
	1247	,@sp-lisp-modes
	1248	)
	1249	)
	1250	"Modes where sexps should be reindented after `sp-up-sexp'.
	1251
	1252	The whitespace between the closing delimiter and last \"thing\"
	1253	inside the expression is removed. It works analogically for the
	1254	`sp-backward-up-sexp'.
	1255
	1256	Note that this also happens when `sp-skip-closing-pair' is
	1257	invoked (usually in strict mode when the closing delimiter is
	1258	typed) as it calls `sp-up-sexp' internally. This behaviour can
	1259	be customized by various settings of `sp-autoskip-closing-pair'
	1260	and `sp-autoskip-opening-pair'.
	1261
	1262	If the mode is in the list \"interactive\", only reindent the sexp
	1263	if the command was called interactively. This is recommended for
	1264	general use.
	1265
	1266	If the mode is in the list \"always\", reindend the sexp even if the
	1267	command was called programatically."
	1268	:type '(alist
	1269	:options (interactive always)
	1270	:value-type (repeat symbol))
	1271	:group 'smartparens)
	1272
	1273	(defcustom sp-navigate-reindent-after-up-in-string t
	1274	"If non-nil, `sp-up-sexp' will reindent inside strings.
	1275
	1276	If `sp-navigate-reindent-after-up' is enabled and the point is
	1277	inside a string, this setting determines if smartparens should
	1278	reindent the current (string) sexp or not."
	1279	:type 'boolean
	1280	:group 'smartparens)
	1281
	1282	(defcustom sp-navigate-close-if-unbalanced nil
	1283	"If non-nil, insert the closing pair of the un-matched pair on `sp-up-sexp'.
	1284
	1285	The closing delimiter is inserted after the symbol at
	1286	point (using `sp-previous-sexp')."
	1287	:type 'boolean
	1288	:group 'smartparens)
	1289
	1290	(defcustom sp-navigate-interactive-always-progress-point nil
	1291	"Make point always move in the direction of navigation.
	1292
	1293	If non-nil and the function is called interactively,
	1294	`sp-next-sexp' and `sp-previous-sexp' will always move the point
	1295	to the end/beg of such an expression where the point would end up
	1296	being further in the direction of travel.
	1297
	1298	Note: this behaviour will become default in release 2.0 and will
	1299	cease to be configurable."
	1300	:type 'boolean
	1301	:group 'smartparens)
	1302
	1303	(defcustom sp-sexp-prefix nil
	1304	"Alist of `major-mode' specific prefix specification.
	1305
	1306	Each item is a list with three properties:
	1307	- major mode
	1308	- a constant symbol 'regexp or 'syntax
	1309	- a regexp or a string containing syntax class codes.
	1310
	1311	If the second argument is 'regexp, the third argument is
	1312	interpreted as a regexp to search backward from the start of an
	1313	expression.
	1314
	1315	If the second argument is 'syntax, the third argument is
	1316	interpreted as string containing syntax codes that will be
	1317	skipped.
	1318
	1319	You can also override this property locally for a specific pair
	1320	by specifying its :prefix property."
	1321	:type '(repeat
	1322	(list symbol
	1323	(choice
	1324	(const :tag "Regexp" regexp)
	1325	(const :tag "Syntax class codes" syntax))
	1326	string))
	1327	:group 'smartparens)
	1328
	1329	(defcustom sp-sexp-suffix nil
	1330	"Alist of `major-mode' specific suffix specification.
	1331
	1332	Each item is a list with three properties:
	1333	- major mode
	1334	- a constant symbol 'regexp or 'syntax
	1335	- a regexp or a string containing syntax class codes.
	1336
	1337	If the second argument is 'regexp, the third argument is
	1338	interpreted as a regexp to search forward from the end of an
	1339	expression.
	1340
	1341	If the second argument is 'syntax, the third argument is
	1342	interpreted as string containing syntax codes that will be
	1343	skipped.
	1344
	1345	You can also override this property locally for a specific pair
	1346	by specifying its :suffix property."
	1347	:type '(repeat
	1348	(list symbol
	1349	(choice
	1350	(const :tag "Regexp" regexp)
	1351	(const :tag "Syntax class codes" syntax))
	1352	string))
	1353	:group 'smartparens)
	1354
	1355	(defcustom sp-split-sexp-always-split-as-string t
	1356	"Determine if sexp inside string is split.
	1357
	1358	If the point is inside a sexp inside a string, the default
	1359	behaviour is now to split the string, such that:
	1360
	1361	\"foo (\|) bar\"
	1362
	1363	becomes
	1364
	1365	\"foo (\"\|\") bar\"
	1366
	1367	instead of
	1368
	1369	\"foo ()\|() bar\".
	1370
	1371	Note: the old default behaviour was the reverse, it would split
	1372	the sexp, but this is hardly ever what you want.
	1373
	1374	You can add a post-handler on string pair and check for
	1375	'split-string action to add concatenation operators of the
	1376	language you work in (in each `major-mode' you can have a separate
	1377	hook).
	1378
	1379	For example, in PHP the string concatenation operator is a
	1380	dot (.), so you would add:
	1381
	1382	(defun my-php-post-split-handler (_ action _)
	1383	(when (eq action 'split-sexp)
	1384	(just-one-space)
	1385	(insert \". . \")
	1386	(backward-char 3)))
	1387
	1388	(sp-local-pair 'php-mode \"'\" nil
	1389	:post-handlers '(my-php-post-split-handler))
	1390
	1391	Then
	1392
	1393	echo 'foo \|baz';
	1394
	1395	results in
	1396
	1397	echo 'foo' . \| . 'baz';"
	1398	:type 'boolean
	1399	:group 'smartparens)
	1400
	1401	;; hybrid lines
	1402	(defcustom sp-hybrid-kill-excessive-whitespace nil
	1403	"Determine how `sp-kill-hybrid-sexp' kills excessive whitespace.
	1404
	1405	If non-nil, `sp-kill-hybrid-sexp' will delete all whitespace
	1406	up until next hybrid sexp if the point is at the end of line or
	1407	on a blank line.
	1408
	1409	When it is set to 'kill, whitespace will be appended to the sexp
	1410	in kill ring."
	1411	:type '(choice
	1412	(const :tag "Delete" t)
	1413	(const :tag "Kill" kill)
	1414	(const :tag "Off" nil))
	1415	:group 'smartparens)
	1416
	1417	(defcustom sp-hybrid-kill-entire-symbol nil
	1418	"Governs how symbols under point are treated by `sp-kill-hybrid-sexp'.
	1419
	1420	If t, always kill the symbol under point.
	1421
	1422	If nil, never kill the entire symbol and only kill the part after point.
	1423
	1424	If a function, this should be a zero-arg predicate. When it
	1425	returns non-nil value, we should kill from point."
	1426	:type '(radio
	1427	(const :tag "Always kill entire symbol" t)
	1428	(const :tag "Always kill from point" nil)
	1429	(const :tag "Kill from point only inside strings" sp-point-in-string)
	1430	(function :tag "Custom predicate"))
	1431	:group 'smartparens)
	1432
	1433	(defcustom sp-comment-string nil
	1434	"String that is inserted after calling `sp-comment'.
	1435
	1436	It is an alist of list of major modes to a string.
	1437
	1438	The value of `comment-start' is used if the major mode is not found."
	1439	:type '(alist
	1440	:key-type (repeat symbol)
	1441	:value-type string)
	1442	:group 'smartparens)
	1443
	1444	;; ui custom
	1445	(defcustom sp-highlight-pair-overlay t
	1446	"If non-nil, autoinserted pairs are highlighted while point is inside the pair."
	1447	:type 'boolean
	1448	:group 'smartparens)
	1449
	1450	(defcustom sp-highlight-wrap-overlay t
	1451	"If non-nil, wrap overlays are highlighted during editing of the wrapping pair."
	1452	:type 'boolean
	1453	:group 'smartparens)
	1454
	1455	(defcustom sp-highlight-wrap-tag-overlay t
	1456	"If non-nil, wrap tag overlays are highlighted during editing of the wrapping tag pair."
	1457	:type 'boolean
	1458	:group 'smartparens)
	1459
	1460	(defcustom sp-echo-match-when-invisible t
	1461	"If non-nil, show-smartparens-mode prints the line of the
	1462	matching paren in the echo area if not visible on screen."
	1463	:type 'boolean
	1464	:group 'smartparens)
	1465
	1466	(defcustom sp-message-width 'frame
	1467	"Length of information and error messages to display.
	1468
	1469	If set to 'frame (the default), messages are chosen based of the
	1470	frame width. t means chose the default (verbose) message, nil
	1471	means mute. Integers specify the maximum width."
	1472	:type '(choice (const :tag "Fit to frame" frame)
	1473	(const :tag "Verbose" t)
	1474	(const :tag "Mute" nil)
	1475	(integer :tag "Max width"))
	1476	:group 'smartparens)
	1477
	1478	;; TODO: this should be true by default > then the behaviour is
	1479	;; controlled by subword-mode... and this is a hard override
	1480	(defcustom sp-use-subword nil
	1481	"Override of `subword-mode' killing behaviour.
	1482
	1483	If non-nill, `sp-kill-word' and `sp-backward-kill-word' only
	1484	kill \"subwords\" when `subword-mode' is active."
	1485	:type 'boolean
	1486	:group 'smartparens)
	1487
	1488
	1489	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
	1490	;; Selection mode handling
	1491
	1492	(defun sp--delete-selection-p ()
	1493	"Return t if `delete-selection-mode' or `cua-delete-selection' is enabled."
	1494	(or (and (boundp 'delete-selection-mode) delete-selection-mode)
	1495	(and (boundp 'cua-delete-selection) cua-delete-selection cua-mode)))
	1496
	1497	(defun sp--delete-selection-supersede-p ()
	1498	"Decide if the current command should delete the region or not.
	1499
	1500	This check is used as value of 'delete-selection property on the
	1501	command symbol."
	1502	(if (or (equal current-prefix-arg '(4))
	1503	(sp-region-ok-p (region-beginning) (region-end)))
	1504	'supersede
	1505	(sp-message :unbalanced-region)
	1506	;; Since this check runs in the pre-command-hook we can change the
	1507	;; command to be executed... in this case we set it to ignore
	1508	;; because we don't want to do anything.
	1509	(setq this-command 'ignore)
	1510	nil))
	1511
	1512	(defun sp--self-insert-uses-region-strict-p ()
	1513	"Decide if the current `self-insert-command' should be able to
	1514	replace the region.
	1515
	1516	This check is added to the special hook
	1517	`self-insert-uses-region-functions' which is checked by
	1518	`delete-selection-uses-region-p'."
	1519	(if (or (equal current-prefix-arg '(4))
	1520	(sp-region-ok-p (region-beginning) (region-end)))
	1521	;; region is OK or we are allowed to replace it, just say nil so
	1522	;; that delsel handles this
	1523	nil
	1524	;; in case region is bad we interrupt the insertion
	1525	(setq this-command 'ignore)
	1526	t))
	1527
	1528	;; TODO: this function was removed from Emacs, we should get rid of
	1529	;; the advice in time.
	1530	(defadvice cua-replace-region (around fix-sp-wrap activate)
	1531	"Fix `sp-wrap' in `cua-selection-mode'."
	1532	(if (sp-wrap--can-wrap-p)
	1533	(cua--fallback)
	1534	ad-do-it))
	1535
	1536	(defadvice cua-delete-region (around fix-sp-delete-region activate)
	1537	"If `smartparens-strict-mode' is enabled, perform a region
	1538	check before deleting."
	1539	(if smartparens-strict-mode
	1540	(progn
	1541	(unless (or current-prefix-arg
	1542	(sp-region-ok-p (region-beginning) (region-end)))
	1543	(user-error (sp-message :unbalanced-region :return)))
	1544	ad-do-it)
	1545	ad-do-it))
	1546
	1547
	1548
	1549	(cl-eval-when (compile eval load)
	1550	(defun sp--get-substitute (struct list)
	1551	"Only ever call this from sp-get! This function does the
	1552	replacement of all the keywords with actual calls to sp-get."
	1553	(if (listp list)
	1554	(if (eq (car list) 'sp-get)
	1555	list
	1556	(mapcar (lambda (x) (sp--get-substitute struct x))
	1557	(let ((command (car list)))
	1558	(cond
	1559	((eq command 'sp-do-move-op)
	1560	(let ((argument (make-symbol "--sp-argument--")))
	1561	`(let ((,argument ,(cadr list)))
	1562	(if (< ,argument :beg-prf)
	1563	(progn
	1564	(goto-char :beg-prf)
	1565	(delete-char (+ :op-l :prefix-l))
	1566	(goto-char ,argument)
	1567	(insert :prefix :op))
	1568	(goto-char ,argument)
	1569	(insert :prefix :op)
	1570	(goto-char :beg-prf)
	1571	(delete-char (+ :op-l :prefix-l))))))
	1572	((eq command 'sp-do-move-cl)
	1573	(let ((argument (make-symbol "--sp-argument--")))
	1574	`(let ((,argument ,(cadr list)))
	1575	(if (> ,argument :end-in)
	1576	(progn
	1577	(goto-char ,argument)
	1578	(insert :cl :suffix)
	1579	(goto-char :end-in)
	1580	(delete-char (+ :cl-l :suffix-l)))
	1581	(goto-char :end-in)
	1582	(delete-char (+ :cl-l :suffix-l))
	1583	(goto-char ,argument)
	1584	(insert :cl :suffix)))))
	1585	((eq command 'sp-do-del-op)
	1586	`(progn
	1587	(goto-char :beg-prf)
	1588	(delete-char (+ :op-l :prefix-l))))
	1589	((eq command 'sp-do-del-cl)
	1590	`(progn
	1591	(goto-char :end-in)
	1592	(delete-char (+ :cl-l :suffix-l))))
	1593	((eq command 'sp-do-put-op)
	1594	`(progn
	1595	(goto-char ,(cadr list))
	1596	(insert :prefix :op)))
	1597	((eq command 'sp-do-put-cl)
	1598	`(progn
	1599	(goto-char ,(cadr list))
	1600	(insert :cl :suffix)))
	1601	(t list)))))
	1602	(if (keywordp list)
	1603	(sp--get-replace-keyword struct list)
	1604	list)))
	1605
	1606	(defun sp--get-replace-keyword (struct keyword)
	1607	(cl-case keyword
	1608	;; point in buffer before the opening delimiter
	1609	(:beg `(plist-get ,struct :beg))
	1610	;; point in the buffer after the closing delimiter
	1611	(:end `(plist-get ,struct :end))
	1612	;; point in buffer after the opening delimiter
	1613	(:beg-in `(+ (plist-get ,struct :beg) (length (plist-get ,struct :op))))
	1614	;; point in buffer before the closing delimiter
	1615	(:end-in `(- (plist-get ,struct :end) (length (plist-get ,struct :cl))))
	1616	;; point in buffer before the prefix of this expression
	1617	(:beg-prf `(- (plist-get ,struct :beg) (length (plist-get ,struct :prefix))))
	1618	;; point in the buffer after the suffix of this expression
	1619	(:end-suf `(+ (plist-get ,struct :end) (length (plist-get ,struct :suffix))))
	1620	;; opening delimiter
	1621	(:op `(plist-get ,struct :op))
	1622	;; closing delimiter
	1623	(:cl `(plist-get ,struct :cl))
	1624	;; length of the opening pair
	1625	(:op-l `(length (plist-get ,struct :op)))
	1626	;; length of the closing pair
	1627	(:cl-l `(length (plist-get ,struct :cl)))
	1628	;; length of the entire expression, including enclosing
	1629	;; delimiters and the prefix and suffix
	1630	(:len `(- (plist-get ,struct :end)
	1631	(plist-get ,struct :beg)
	1632	(- (length (plist-get ,struct :prefix)))
	1633	(- (length (plist-get ,struct :suffix)))))
	1634	;; length of the the pair ignoring the prefix, including delimiters
	1635	(:len-out `(- (plist-get ,struct :end) (plist-get ,struct :beg)))
	1636	;; length of the pair inside the delimiters
	1637	(:len-in `(- (plist-get ,struct :end)
	1638	(plist-get ,struct :beg)
	1639	(length (plist-get ,struct :op))
	1640	(length (plist-get ,struct :cl))))
	1641	;; expression prefix
	1642	(:prefix `(plist-get ,struct :prefix))
	1643	;; expression prefix length
	1644	(:prefix-l `(length (plist-get ,struct :prefix)))
	1645	(:suffix `(plist-get ,struct :suffix))
	1646	(:suffix-l `(length (plist-get ,struct :suffix)))
	1647	;; combined op/cl and suffix/prefix
	1648	(:opp `(concat (plist-get ,struct :prefix)
	1649	(plist-get ,struct :op)))
	1650	(:opp-l `(+ (length (plist-get ,struct :prefix))
	1651	(length (plist-get ,struct :op))))
	1652	(:cls `(concat (plist-get ,struct :cl)
	1653	(plist-get ,struct :suffix)))
	1654	(:cls-l `(+ (length (plist-get ,struct :cl))
	1655	(length (plist-get ,struct :suffix))))
	1656	(t keyword))))
	1657
	1658
	1659	;; TODO: rewrite this in terms of `symbol-macrolet' ??
	1660	(defmacro sp-get (struct &rest forms)
	1661	"Get a property from a structure.
	1662
	1663	STRUCT is a plist with the format as returned by `sp-get-sexp'.
	1664	Which means this macro also works with `sp-get-symbol',
	1665	`sp-get-string' and `sp-get-thing'.
	1666
	1667	FORMS is an attribute we want to query. Currently supported
	1668	attributes are:
	1669
	1670	:beg - point in buffer before the opening delimiter
	1671	:end - point in the buffer after the closing delimiter
	1672	:beg-in - point in buffer after the opening delimiter
	1673	:end-in - point in buffer before the closing delimiter
	1674	:beg-prf - point in buffer before the prefix of this expression
	1675	:end-suf - point in buffer after the suffix of this expression
	1676	:op - opening delimiter
	1677	:cl - closing delimiter
	1678	:op-l - length of the opening pair
	1679	:cl-l - length of the closing pair
	1680	:len - length of the entire expression, including enclosing
	1681	delimiters, the prefix and the suffix
	1682	:len-out - length of the the pair ignoring the prefix and suffix,
	1683	including delimiters
	1684	:len-in - length of the pair inside the delimiters
	1685	:prefix - expression prefix
	1686	:prefix-l - expression prefix length
	1687	:suffix - expression suffix
	1688	:suffix-l - expression suffix length
	1689
	1690	These special \"functions\" are expanded to do the selected
	1691	action in the context of currently queried pair:
	1692
	1693	Nullary:
	1694	\(sp-do-del-op) - remove prefix and opening delimiter
	1695	\(sp-do-del-cl) - remove closing delimiter and suffix
	1696
	1697	Unary:
	1698	\(sp-do-move-op p) - move prefix and opening delimiter to point p
	1699	\(sp-do-move-cl p) - move closing delimiter and suffix to point p
	1700	\(sp-do-put-op p) - put prefix and opening delimiter at point p
	1701	\(sp-do-put-cl p) - put closing delimiter and suffix at point p
	1702
	1703	In addition to these simple queries and commands, this macro
	1704	understands arbitrary forms where any of the aforementioned
	1705	attributes are used. Therefore, you can for example query for
	1706	\"(+ :op-l :cl-l)\". This query would return the sum of lengths
	1707	of opening and closing delimiter. A query
	1708	\"(concat :prefix :op)\" would return the string containing
	1709	expression prefix and the opening delimiter.
	1710
	1711	Special care is taken to only evaluate the STRUCT argument once."
	1712	(declare (indent 1)
	1713	(debug (form body)))
	1714	(let ((st (make-symbol "struct")))
	1715	(sp--get-substitute st `(let ((,st ,struct)) ,@forms))))
	1716
	1717
	1718	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
	1719	;; Misc/Utility functions
	1720
	1721	(defun sp--indent-region (start end &optional column)
	1722	"Call `indent-region' unless `aggressive-indent-mode' is enabled.
	1723
	1724	START, END and COLUMN are the same as in `indent-region'."
	1725	(unless (bound-and-true-p aggressive-indent-mode)
	1726	;; Don't issue "Indenting region..." message.
	1727	(cl-letf (((symbol-function 'message) #'ignore))
	1728	(indent-region start end column))))
	1729
	1730	(defmacro sp-with-modes (arg &rest forms)
	1731	"Add ARG as first argument to each form in FORMS.
	1732
	1733	This can be used with `sp-local-pair' calls to automatically
	1734	insert the modes."
	1735	(declare (indent 1)
	1736	(debug (form body)))
	1737	(let ((modes (make-symbol "modes")))
	1738	`(let ((,modes ,arg))
	1739	(progn
	1740	,@(mapcar (lambda (form) (append (list (car form) modes) (cdr form))) forms)))))
	1741
	1742	(font-lock-add-keywords 'emacs-lisp-mode `((,(concat "("
	1743	(regexp-opt '("sp-with-modes"
	1744	"sp-get"
	1745	"sp-compare-sexps") t)
	1746	"\\_>")
	1747	(1 font-lock-keyword-face))))
	1748
	1749	(defmacro sp--with-case-sensitive (&rest body)
	1750	"Ensure that searching done within BODY is case-sensitive.
	1751
	1752	Bind `case-fold-search' to nil if it is not already and avoid the
	1753	bind if it is already. Any function that needs to use any of the
	1754	sp--looking-* functions more than once should wrap them all in
	1755	`sp--with-case-sensitive'."
	1756	(declare (indent 0)
	1757	(debug (body)))
	1758	`(if case-fold-search
	1759	(let ((case-fold-search nil))
	1760	,@body)
	1761	,@body))
	1762
	1763	(defun sp--evil-normal-state-p ()
	1764	"Check to see if the current `evil-state' is in normal mode."
	1765	(and (fboundp 'evil-normal-state-p) (evil-normal-state-p)))
	1766
	1767	(defun sp--evil-motion-state-p ()
	1768	"Check to see if the current `evil-state' is in motion mode."
	1769	(and (fboundp 'evil-motion-state-p) (evil-motion-state-p)))
	1770
	1771	(defun sp--evil-visual-state-p ()
	1772	"Check to see if the current `evil-state' is in visual mode."
	1773	(and (fboundp 'evil-visual-state-p) (evil-visual-state-p)))
	1774
	1775	(defun sp-point-in-blank-line (&optional p)
	1776	"Return non-nil if line at point is blank (whitespace only).
	1777
	1778	If optional argument P is present test this instead of point."
	1779	(save-excursion
	1780	(when p (goto-char p))
	1781	(beginning-of-line)
	1782	(looking-at "[ \t]*$")))
	1783
	1784	(defun sp-point-in-blank-sexp (&optional p)
	1785	"Return non-nil if point is inside blank (whitespace only) sexp.
	1786
	1787	If optional argument P is present test this instead of point.
	1788
	1789	Warning: it is only safe to call this when point is inside a
	1790	sexp, otherwise the call may be very slow."
	1791	(save-excursion
	1792	(when p (goto-char p))
	1793	(-when-let (enc (sp-get-enclosing-sexp))
	1794	(sp-get enc (string-match-p
	1795	"\\`[ \t\n]*\\'"
	1796	(buffer-substring-no-properties :beg-in :end-in))))))
	1797
	1798	(defun sp-char-is-escaped-p (&optional point)
	1799	"Test if the char at POINT is escaped or not.
	1800
	1801	POINT defaults to `point'."
	1802	(setq point (or point (point)))
	1803	(save-match-data
	1804	(when (save-excursion
	1805	(goto-char point)
	1806	(looking-back (concat sp-escape-char sp-escape-char "+") nil t))
	1807	(eq (logand (length (match-string 0)) 1) 1))))
	1808
	1809	(defun sp--syntax-ppss (&optional p)
	1810	"Memoize the last result of `syntax-ppss'.
	1811
	1812	P is the point at which we run `syntax-ppss'"
	1813	(let ((p (or p (point)))
	1814	(mem-p (sp-state-last-syntax-ppss-point sp-state)))
	1815	(if (and (eq p (nth 0 mem-p))
	1816	(eq (point-min) (nth 1 mem-p))
	1817	(eq (point-max) (nth 2 mem-p)))
	1818	(sp-state-last-syntax-ppss-result sp-state)
	1819	;; Add hook to reset memoization if necessary
	1820	(unless (sp-state-last-syntax-ppss-point sp-state)
	1821	(add-hook 'before-change-functions 'sp--reset-memoization t t))
	1822	(setf (sp-state-last-syntax-ppss-point sp-state)
	1823	(list p (point-min) (point-max))
	1824	(sp-state-last-syntax-ppss-result sp-state) (syntax-ppss p)))))
	1825
	1826	(defun sp-point-in-string (&optional p)
	1827	"Return non-nil if point is inside string or documentation string.
	1828
	1829	This function actually returns the 3rd element of `syntax-ppss'
	1830	which can be a number if the string is delimited by that
	1831	character or t if the string is delimited by general string
	1832	fences.
	1833
	1834	If optional argument P is present test this instead of point."
	1835	(ignore-errors
	1836	(save-excursion
	1837	(nth 3 (sp--syntax-ppss p)))))
	1838
	1839	(defun sp-point-in-comment (&optional p)
	1840	"Return non-nil if point is inside comment.
	1841
	1842	If optional argument P is present test this instead off point."
	1843	(setq p (or p (point)))
	1844	(ignore-errors
	1845	(save-excursion
	1846	;; We cannot be in a comment if we are inside a string
	1847	(unless (nth 3 (sp--syntax-ppss p))
	1848	(or (nth 4 (sp--syntax-ppss p))
	1849	;; this also test opening and closing comment delimiters... we
	1850	;; need to chack that it is not newline, which is in "comment
	1851	;; ender" class in elisp-mode, but we just want it to be
	1852	;; treated as whitespace
	1853	(and (< p (point-max))
	1854	(memq (char-syntax (char-after p)) '(?< ?>))
	1855	(not (eq (char-after p) ?\n)))
	1856	;; we also need to test the special syntax flag for comment
	1857	;; starters and enders, because `syntax-ppss' does not yet
	1858	;; know if we are inside a comment or not (e.g. / can be a
	1859	;; division or comment starter...).
	1860	(-when-let (s (car (syntax-after p)))
	1861	(or (and (/= 0 (logand (lsh 1 16) s))
	1862	(nth 4 (syntax-ppss (+ p 2))))
	1863	(and (/= 0 (logand (lsh 1 17) s))
	1864	(nth 4 (syntax-ppss (+ p 1))))
	1865	(and (/= 0 (logand (lsh 1 18) s))
	1866	(nth 4 (syntax-ppss (- p 1))))
	1867	(and (/= 0 (logand (lsh 1 19) s))
	1868	(nth 4 (syntax-ppss (- p 2)))))))))))
	1869
	1870	(defun sp-point-in-string-or-comment (&optional p)
	1871	"Return non-nil if point is inside string, documentation string or a comment.
	1872
	1873	If optional argument P is present, test this instead of point."
	1874	(or (sp-point-in-string p)
	1875	(sp-point-in-comment p)))
	1876
	1877	;; TODO: add -p suffix
	1878	(defun sp-point-in-symbol (&optional p)
	1879	"Return non-nil if `point' is inside symbol.
	1880
	1881	If P is non-nil, interpret it as buffer position and test there.
	1882
	1883	Point is inside symbol if characters on both sides of the point
	1884	are in either word or symbol class."
	1885	(setq p (or p (point)))
	1886	(save-excursion
	1887	(goto-char p)
	1888	(and (/= 0 (following-char))
	1889	(memq (char-syntax (following-char)) '(?w ?_))
	1890	(memq (char-syntax (preceding-char)) '(?w ?_)))))
	1891
	1892	(defun sp--single-key-description (event)
	1893	"Return a description of the last EVENT.
	1894
	1895	Replace all the function key symbols with garbage character (ň).
	1896
	1897	TODO: fix this!"
	1898	(let ((original (single-key-description event)))
	1899	(cond
	1900	((string-match-p "<.*?>" original) "ň")
	1901	((string-match-p "SPC" original) " ")
	1902	(t original))))
	1903
	1904	;; see https://github.com/Fuco1/smartparens/issues/125#issuecomment-20356176
	1905	(defun sp--current-indentation ()
	1906	"Get the indentation offset of the current line."
	1907	(save-excursion
	1908	(back-to-indentation)
	1909	(current-column)))
	1910
	1911	(defun sp--calculate-indentation-offset (old-column old-indentation)
	1912	"Calculate correct indentation after re-indent.
	1913
	1914	OLD-COLUMN is the column before reindent.
	1915
	1916	OLD-INDENTATION is the indentation depth before reindent."
	1917	(let ((indentation (sp--current-indentation)))
	1918	(cond
	1919	;; Point was in code, so move it along with the re-indented code
	1920	((>= old-column old-indentation)
	1921	(+ old-column (- indentation old-indentation)))
	1922	;; Point was indentation, but would be in code now, so move to
	1923	;; the beginning of indentation
	1924	((<= indentation old-column) indentation)
	1925	;; Point was in indentation, and still is, so leave it there
	1926	(:else old-column))))
	1927
	1928	(defun sp--back-to-indentation (old-column old-indentation)
	1929	"Set the current column to proper value.
	1930
	1931	See `sp--keep-indentation'.
	1932
	1933	OLD-COLUMN is the column before reindent.
	1934
	1935	OLD-INDENTATION is the indentation depth before reindent."
	1936	(let ((offset (sp--calculate-indentation-offset old-column old-indentation)))
	1937	(move-to-column offset)))
	1938
	1939	;; TODO: rename to preserve-current-column
	1940	(defmacro sp--keep-indentation (&rest body)
	1941	"Execute BODY and restore the column.
	1942
	1943	If point was in code move it along if the line is reinvented so
	1944	it is the same distance relative to first code column.
	1945
	1946	If point was previously in the indentation region but would end
	1947	up in code, move it to the first code column.
	1948
	1949	If point was in the indentation region and is still there after
	1950	BODY, do nothing."
	1951	(declare (indent 0)
	1952	(debug (body)))
	1953	(let ((c (make-symbol "c"))
	1954	(i (make-symbol "i")))
	1955	`(let ((,c (current-column))
	1956	(,i (sp--current-indentation)))
	1957	,@body
	1958	(sp--back-to-indentation ,c ,i))))
	1959
	1960	;; Please contribute these if you come across some!
	1961	(defvar sp--self-insert-commands
	1962	'(self-insert-command
	1963	org-self-insert-command
	1964	LaTeX-insert-left-brace)
	1965	"List of commands that are some sort of `self-insert-command'.
	1966
	1967	Many modes rebind \"self-inserting\" keys to \"smart\" versions
	1968	which do some additional processing before delegating the
	1969	insertion to `self-insert-command'. Smartparens needs to be able
	1970	to distinguish these to properly handle insertion and reinsertion
	1971	of pairs and wraps.")
	1972
	1973	;; Please contribute these if you come across some!
	1974	(defvar sp--special-self-insert-commands
	1975	'(
	1976	TeX-insert-dollar
	1977	TeX-insert-quote
	1978	quack-insert-opening-paren
	1979	quack-insert-closing-paren
	1980	quack-insert-opening-bracket
	1981	quack-insert-closing-bracket
	1982	racket-insert-closing-paren
	1983	racket-insert-closing-bracket
	1984	racket-insert-closing-brace
	1985	)
	1986	"List of commands which are handled as if they were `self-insert-command's.
	1987
	1988	Some modes redefine \"self-inserting\" keys to \"smart\" versions
	1989	which do some additional processing but do _not_ delegate the
	1990	insertion to `self-insert-command', instead inserting via
	1991	`insert'. Smartparens needs to be able to distinguish these to
	1992	properly handle insertion and reinsertion of pairs and wraps.
	1993
	1994	The `sp--post-self-insert-hook-handler' is called in the
	1995	`post-command-hook' for these commands.")
	1996
	1997	(defun sp--self-insert-command-p ()
	1998	"Return non-nil if `this-command' is some sort of `self-insert-command'."
	1999	(memq this-command sp--self-insert-commands))
	2000
	2001	(defun sp--special-self-insert-command-p ()
	2002	"Return non-nil if `this-command' is \"special\" self insert command.
	2003
	2004	A special self insert command is one that inserts a character but
	2005	does not trigger `post-self-insert-hook'."
	2006	(memq this-command sp--special-self-insert-commands))
	2007
	2008	(defun sp--signum (x)
	2009	"Return 1 if X is positive, -1 if negative, 0 if zero."
	2010	(cond ((> x 0) 1) ((< x 0) -1) (t 0)))
	2011
	2012	;; The structure returned by sp-get-sexp is a plist with following properties:
	2013	;;
	2014	;; :beg - point in the buffer before the opening delimiter (ignoring prefix)
	2015	;; :end - point in the buffer after the closing delimiter
	2016	;; :op - opening delimiter
	2017	;; :cl - closing delimiter
	2018	;; :prefix - expression prefix
	2019	;;
	2020	;; This structure should never be accessed directly and should only be
	2021	;; exposed by the sp-get macro. This way, we can later change the
	2022	;; internal representation without much trouble.
	2023
	2024	(defmacro sp-compare-sexps (a b &optional fun what-a what-b)
	2025	"Return non-nil if the expressions A and B are equal.
	2026
	2027	Two expressions are equal if their :beg property is the same.
	2028
	2029	If optional argument FUN is non-nil, it is the comparison
	2030	function.
	2031
	2032	If optional argument WHAT-A is non-nil, use it as a keyword on
	2033	which to do the comparsion (default to :beg).
	2034
	2035	If optional argument WHAT-B is non-nil, use it as a keyword on
	2036	which to do the comparsion (default to WHAT-A)."
	2037	(declare (debug (form form &optional functionp keywordp keywordp)))
	2038	(setq fun (or fun 'equal))
	2039	(setq what-a (or what-a :beg))
	2040	(setq what-b (or what-b what-a))
	2041	`(,fun (sp-get ,a ,what-a) (sp-get ,b ,what-b)))
	2042
	2043	(defun sp-message (key &optional return)
	2044	"Display a message.
	2045
	2046	KEY is either a string or list of strings, or a keyword,
	2047	in which case the string list is looked up in
	2048	`sp-message-alist'. The string to be displayed is chosen based on
	2049	the `sp-message-width' variable.
	2050
	2051	If RETURN is non-nil return the string instead of printing it."
	2052	(let ((msgs (cond ((listp key) key)
	2053	((stringp key) (list key))
	2054	(t (cdr (assq key sp-message-alist))))))
	2055	(when (and msgs sp-message-width)
	2056	(if (eq sp-message-width t)
	2057	(if return (car msgs) (message "%s." (car msgs)))
	2058	(let ((maxlen (if (eq sp-message-width 'frame)
	2059	(frame-width)
	2060	sp-message-width))
	2061	(s nil))
	2062	(dolist (msg msgs)
	2063	(if (and (<= (length msg) maxlen)
	2064	(> (length msg) (length s)))
	2065	(setf s msg)))
	2066	(when s
	2067	(if return s (message "%s." s))))))))
	2068
	2069
	2070	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
	2071	;; Adding/removing of pairs/bans/allows etc.
	2072
	2073	(defun sp--merge-prop (prop new-pair old-pair)
	2074	"Merge a property PROP from NEW-PAIR into OLD-PAIR.
	2075
	2076	The list OLD-PAIR must not be nil."
	2077	(let ((new-val (plist-get new-pair prop)))
	2078	(cl-case prop
	2079	(:close (plist-put old-pair :close new-val))
	2080	(:prefix (plist-put old-pair :prefix new-val))
	2081	(:suffix (plist-put old-pair :suffix new-val))
	2082	(:skip-match (plist-put old-pair :skip-match new-val))
	2083	(:trigger (plist-put old-pair :trigger new-val))
	2084	(:trigger-wrap (plist-put old-pair :trigger-wrap new-val))
	2085	((:actions :when :unless :pre-handlers :post-handlers)
	2086	(cl-case (car new-val)
	2087	(:add (plist-put old-pair prop (-union (plist-get old-pair prop) (cdr new-val))))
	2088	(:rem (plist-put old-pair prop (-difference (plist-get old-pair prop) (cdr new-val))))
	2089	(t
	2090	(cond
	2091	;; this means we have ((:add ...) (:rem ...)) argument
	2092	((and new-val
	2093	(listp (car new-val))
	2094	(memq (caar new-val) '(:add :rem)))
	2095	(let ((a (assq :add new-val))
	2096	(r (assq :rem new-val)))
	2097	(plist-put old-pair prop (-union (plist-get old-pair prop) (cdr a)))
	2098	(plist-put old-pair prop (-difference (plist-get old-pair prop) (cdr r)))))
	2099	(t
	2100	(plist-put old-pair prop (plist-get new-pair prop))))))))))
	2101
	2102	(defun sp--merge-pairs (old-pair new-pair)
	2103	"Merge OLD-PAIR and NEW-PAIR.
	2104	This modifies the OLD-PAIR by side effect."
	2105	(let ((ind 0))
	2106	(--each new-pair
	2107	(when (= 0 (% ind 2))
	2108	(sp--merge-prop it new-pair old-pair))
	2109	(setq ind (1+ ind))))
	2110	old-pair)
	2111
	2112	(defun sp--update-pair (new-pair old-pair)
	2113	"Copy properties from NEW-PAIR to OLD-PAIR.
	2114
	2115	The list OLD-PAIR must not be nil."
	2116	(let ((ind 0))
	2117	(--each new-pair
	2118	(when (= 0 (% ind 2))
	2119	(when (or (not (plist-get old-pair it))
	2120	;; HACK: we don't want to overwrite list properties
	2121	;; that aren't just :add with :add because this
	2122	;; would break the "idempotency".
	2123	(not (equal '(:add) (plist-get new-pair it))))
	2124	(plist-put old-pair it (plist-get new-pair it))))
	2125	(setq ind (1+ ind))))
	2126	old-pair)
	2127
	2128	(defun sp--update-pair-list (pair mode)
	2129	"Update the PAIR for major mode MODE.
	2130
	2131	If this pair is not defined yet for this major mode, add it. If
	2132	this pair is already defined, replace all the properties in the
	2133	old definition with values from PAIR."
	2134	;; get the structure relevant to mode. t means global setting
	2135	(let ((struct (--first (eq mode (car it)) sp-pairs)))
	2136	(if (not struct)
	2137	(!cons (cons mode (list pair)) sp-pairs)
	2138	;; this does NOT merge changes, only replace the values at
	2139	;; properties. Open delimiter works as ID as usual.
	2140	(let ((old-pair (--first (equal (plist-get pair :open)
	2141	(plist-get it :open))
	2142	(cdr struct)))
	2143	(open (plist-get pair :open)))
	2144	(if (not old-pair)
	2145	(progn
	2146	(unless (or (plist-get pair :close)
	2147	(sp--get-pair open (assq t sp-pairs)))
	2148	(error "Pair %s was never defined, please specify closing delimiter in instead of passing `nil'" open))
	2149	(setcdr struct (cons pair (cdr struct))))
	2150	(sp--update-pair pair old-pair)))))
	2151	sp-pairs)
	2152
	2153	(defun sp--get-pair (open list)
	2154	"Get the pair with id OPEN from list LIST."
	2155	(--first (equal open (plist-get it :open)) list))
	2156
	2157	(defun sp--get-pair-definition (open list &optional prop)
	2158	"Get the definition of a pair identified by OPEN from list LIST.
	2159
	2160	If PROP is non-nil, return the value of that property instead."
	2161	(let ((pair (sp--get-pair open list)))
	2162	(if prop
	2163	(cond
	2164	((eq prop :op-l)
	2165	(length (plist-get pair :open)))
	2166	((eq prop :cl-l)
	2167	(length (plist-get pair :close)))
	2168	((eq prop :len)
	2169	(+ (length (plist-get pair :open)) (length (plist-get pair :close))))
	2170	((eq prop :post-handlers)
	2171	(--filter (not (listp it)) (plist-get pair prop)))
	2172	((eq prop :post-handlers-cond)
	2173	(--filter (listp it) (plist-get pair :post-handlers)))
	2174	((eq prop :when)
	2175	(--filter (not (listp it)) (plist-get pair :when)))
	2176	((eq prop :when-cond)
	2177	(-flatten (-concat (--filter (listp it) (plist-get pair :when)))))
	2178	(t (plist-get pair prop)))
	2179	pair)))
	2180
	2181	(defun sp-get-pair-definition (open mode &optional prop)
	2182	"Get the definition of pair identified by OPEN.
	2183
	2184	OPEN is the opening delimiter, MODE is the major mode symbol or t
	2185	for global definition.
	2186
	2187	If PROP is non-nil, return the value of that property instead."
	2188	(sp--get-pair-definition open (cdr (assq mode sp-pairs)) prop))
	2189
	2190	(defun sp-get-pair (open &optional prop)
	2191	"Return the definition of pair defined by OPEN in the current buffer.
	2192
	2193	The value is fetched from `sp-local-pairs'.
	2194
	2195	If PROP is non-nil, return the value of that property instead."
	2196	(sp--get-pair-definition open sp-local-pairs prop))
	2197
	2198	(defun sp--merge-pair-configurations (specific &optional current)
	2199	"Merge SPECIFIC pair configuration to the CURRENT configuration.
	2200
	2201	CURRENT defaults to `sp-local-pairs' if it is non-nil or the
	2202	global definition from `sp-pairs' if `sp-local-pairs' is nil."
	2203	(let* ((global (or current sp-local-pairs (cdr (assq t sp-pairs))))
	2204	(local specific)
	2205	(result nil))
	2206	;; copy the pairs on global list first. This creates new plists
	2207	;; so we can modify them without changing the global "template"
	2208	;; values.
	2209	(dolist (old-pair global)
	2210	(!cons (list :open (plist-get old-pair :open)) result))
	2211
	2212	;; merge the global list with result. This basically "deep copy"
	2213	;; global list. We use `sp--merge-pairs' because it also clones
	2214	;; the list properties (actions, filters etc.)
	2215	(dolist (new-pair global)
	2216	(let ((old-pair (sp--get-pair (plist-get new-pair :open) result)))
	2217	(sp--merge-pairs old-pair new-pair)))
	2218
	2219	;; for each local pair, merge it into the global definition
	2220	(dolist (new-pair local)
	2221	(let ((old-pair (sp--get-pair (plist-get new-pair :open) result)))
	2222	(if old-pair
	2223	(sp--merge-pairs old-pair new-pair)
	2224	;; pair does not have global definition, simply copy it over
	2225	(!cons
	2226	;; this "deep copy" the new-pair
	2227	(sp--merge-pairs (list :open (plist-get new-pair :open)) new-pair)
	2228	;; TODO: remove the nil lists from the definitions
	2229	result))))
	2230	result))
	2231
	2232	(defun sp-wrap-with-pair (pair)
	2233	"Wrap the following expression with PAIR.
	2234
	2235	This function is a non-interactive helper. To use this function
	2236	interactively, bind the following lambda to a key:
	2237
	2238	(lambda (&optional arg) (interactive \"P\") (sp-wrap-with-pair \"(\"))
	2239
	2240	This lambda accepts the same prefix arguments as
	2241	`sp-select-next-thing'.
	2242
	2243	If region is active and `use-region-p' returns true, the region
	2244	is wrapped instead. This is useful with selection functions in
	2245	`evil-mode' to wrap regions with pairs."
	2246	(let* ((arg (or current-prefix-arg 1))
	2247	(sel (and (not (use-region-p))
	2248	(sp-select-next-thing-exchange
	2249	arg
	2250	(cond
	2251	;; point is inside symbol and smart symbol wrapping is disabled
	2252	((and (sp-point-in-symbol)
	2253	(or (eq sp-wrap-entire-symbol 'globally)
	2254	(memq major-mode sp-wrap-entire-symbol)))
	2255	(point))
	2256	;; wrap from point, not the start of the next expression
	2257	((and sp-wrap-from-point
	2258	(not (sp-point-in-symbol)))
	2259	(point))))))
	2260	(active-pair (--first (equal (car it) pair) sp-pair-list))
	2261	(rb (region-beginning))
	2262	(re (region-end)))
	2263	(goto-char re)
	2264	(insert (cdr active-pair))
	2265	(goto-char rb)
	2266	(insert (car active-pair))
	2267	(if (use-region-p)
	2268	(sp--indent-region rb re)
	2269	(sp-get sel (sp--indent-region :beg :end)))))
	2270
	2271	(cl-defun sp-pair (open
	2272	close
	2273	&key
	2274	trigger
	2275	trigger-wrap
	2276	(actions '(wrap insert autoskip navigate))
	2277	when
	2278	unless
	2279	pre-handlers
	2280	post-handlers
	2281	wrap
	2282	bind
	2283	insert)
	2284	"Add a pair definition.
	2285
	2286	OPEN is the opening delimiter. Every pair is uniquely determined
	2287	by this string.
	2288
	2289	CLOSE is the closing delimiter. You can use nil for this
	2290	argument if you are updating an existing definition. In this
	2291	case, the old value is retained.
	2292
	2293	TRIGGER is an optional trigger for the pair. The pair will be
	2294	inserted if either OPEN or TRIGGER is typed. This is usually
	2295	used as a shortcut for longer pairs or for pairs that can't be
	2296	typed easily.
	2297
	2298	TRIGGER-WRAP is the same as TRIGGER but used for wrapping.
	2299
	2300	ACTIONS is a list of actions that smartparens will perform with
	2301	this pair. Possible values are:
	2302
	2303	- insert - autoinsert the closing pair when opening pair is
	2304	typed.
	2305	- wrap - wrap an active region with the pair defined by opening
	2306	delimiter if this is typed while region is active.
	2307	- autoskip - if the sexp is active or `sp-autoskip-closing-pair' is
	2308	set to 'always, skip over the closing delimiter if user types its
	2309	characters in order.
	2310	- navigate - enable this pair for navigation/highlight and strictness
	2311	checks
	2312	- escape - allow autoescaping of this delimiter in string contexts
	2313
	2314	If the ACTIONS argument has value :rem, the pair is removed.
	2315	This can be used to remove default pairs you don't want to use.
	2316	For example: (sp-pair \"[\" nil :actions :rem)
	2317
	2318	WHEN is a list of predicates that test whether the action
	2319	should be performed in current context. The values in the list
	2320	should be names of the predicates (that is symbols, not
	2321	lambdas!). They should accept three arguments: opening
	2322	delimiter (which uniquely determines the pair), action and
	2323	context. The context argument can have values:
	2324
	2325	- string - if point is inside string.
	2326	- comment - if point is inside comment.
	2327	- code - if point is inside code. This context is only
	2328	recognized in programming modes that define string semantics.
	2329
	2330	If any filter returns t, the action WILL be performed. A number
	2331	of filters are predefined: `sp-point-after-word-p',
	2332	`sp-point-before-word-p', `sp-in-string-p',
	2333	`sp-point-before-eol-p' etc.
	2334
	2335	When clause also supports a special format for delayed insertion.
	2336	The condition is a list with commands, predicates (with three
	2337	arguments as regular when form) or strings specifying the last
	2338	event. All three types can be combined in one list. The pair
	2339	will be inserted after the next command if it matches the any
	2340	command on the list, if the last event matches any string on the
	2341	list or if any predicate returns true. If the pair's :when
	2342	clause contains this special form, it will never be immediately
	2343	inserted and will always test for delayed insertion.
	2344
	2345	UNLESS is a list of predicates. The conventions are the same as
	2346	for the WHEN list. If any filter on this list returns t, the
	2347	action WILL NOT be performed. The predicates in the WHEN list
	2348	are checked first, and if any of them succeeds, the UNLESS list
	2349	is not checked.
	2350
	2351	Note: the functions on the WHEN/UNLESS lists are also called
	2352	\"filters\" in the documentation.
	2353
	2354	All the filters are run after the trigger character is
	2355	inserted.
	2356
	2357	PRE-HANDLERS is a list of functions that are called before there
	2358	has been some action caused by this pair. The arguments are the
	2359	same as for filters. Context is relative to the point before
	2360	the last inserted character. Because of the nature of the
	2361	wrapping operation, this hook is not called if the action is
	2362	wrapping.
	2363
	2364	POST-HANDLERS is a list of functions that are called after there
	2365	has been some action caused by this pair. The arguments are the
	2366	same as for filters. Context is relative to current position of
	2367	point after the closing pair was inserted.
	2368
	2369	After a wrapping action, the point might end on either side of
	2370	the wrapped region, depending on the original direction. You can
	2371	use the variable `sp-last-wrapped-region' to retrieve information
	2372	about the wrapped region and position the point to suit your
	2373	needs.
	2374
	2375	A special syntax for conditional execution of hooks is also
	2376	supported. If the added item is a list (function command1
	2377	command2...), where function is a 3 argument function described
	2378	above and command(s) can be either name of a command or a string
	2379	representing an event. If the last command or event as described
	2380	by `single-key-description' matches any on the list, the hook
	2381	will be executed. This means these hooks are run not after the
	2382	insertion, but after the next command is executed.
	2383
	2384	Example:
	2385	((lambda (id act con)
	2386	(save-excursion
	2387	(newline))) \"RET\" newline)
	2388
	2389	This function will move the closing pair on its own line only if
	2390	the next command is `newline' or is triggered by RET. Otherwise
	2391	the pairs stay on the same line.
	2392
	2393	WRAP is a key binding to which a \"wrapping\" action is bound.
	2394	The key should be in format that is accepted by `kbd'. This
	2395	option binds a lambda form:
	2396
	2397	`(lambda (&optional arg)
	2398	(interactive \"P\")
	2399	(sp-wrap-with-pair ,OPEN))
	2400
	2401	to the specified key sequence. The binding is added to global
	2402	keymap. When executed, it wraps ARG (default 1) expressions with
	2403	this pair (like `paredit-wrap-round' and friends). Additionally,
	2404	it accepts the same prefix arguments as `sp-select-next-thing'.
	2405
	2406	BIND is equivalent to WRAP. It is a legacy setting and will be
	2407	removed soon.
	2408
	2409	INSERT is a key binding to which an \"insert\" action is bound.
	2410	The key should be in format that is accepted by `kbd'. This is
	2411	achieved by binding a lambda form:
	2412
	2413	(lambda () (interactive) (sp-insert-pair \"pair-id\"))
	2414
	2415	to the supplied key, where pair-id is the open delimiter of the
	2416	pair. The binding is added to the global map. You can also bind
	2417	a similar lambda manually. To only bind this in specific major
	2418	modes, use this property on `sp-local-pair' instead."
	2419	(if (eq actions :rem)
	2420	(let ((global-list (assq t sp-pairs)))
	2421	(setcdr global-list (--remove (equal (plist-get it :open) open) (cdr global-list)))
	2422	(--each (buffer-list)
	2423	(with-current-buffer it (sp--remove-local-pair open))))
	2424	(let ((pair nil))
	2425	(setq pair (plist-put pair :open open))
	2426	(when close (plist-put pair :close close))
	2427	(when trigger (plist-put pair :trigger trigger))
	2428	(when trigger-wrap (plist-put pair :trigger-wrap trigger-wrap))
	2429	(dolist (arg `((:actions . ,actions)
	2430	(:when . ,when)
	2431	(:unless . ,unless)
	2432	(:pre-handlers . ,pre-handlers)
	2433	(:post-handlers . ,post-handlers)))
	2434	;; We only consider "nil" as a proper value if the property
	2435	;; already exists in the pair. In that case, we will set it to
	2436	;; nil. This allows for removing properties in global
	2437	;; definitions.
	2438	(when (or (cdr arg)
	2439	(sp-get-pair-definition open t (car arg)))
	2440	(plist-put pair (car arg) (cdr arg))))
	2441	(sp--update-pair-list pair t))
	2442	(when (or wrap bind) (global-set-key (read-kbd-macro (or wrap bind))
	2443	`(lambda (&optional arg)
	2444	(interactive "P")
	2445	(sp-wrap-with-pair ,open))))
	2446	(when insert (global-set-key (kbd insert) `(lambda () (interactive) (sp-insert-pair ,open)))))
	2447	(sp--update-local-pairs-everywhere)
	2448	sp-pairs)
	2449
	2450	(cl-defun sp-local-pair (modes
	2451	open
	2452	close
	2453	&key
	2454	trigger
	2455	trigger-wrap
	2456	(actions '(:add))
	2457	(when '(:add))
	2458	(unless '(:add))
	2459	(pre-handlers '(:add))
	2460	(post-handlers '(:add))
	2461	wrap
	2462	bind
	2463	insert
	2464	prefix
	2465	suffix
	2466	skip-match)
	2467	"Add a local pair definition or override a global definition.
	2468
	2469	MODES can be a single mode or a list of modes where these settings
	2470	should be applied.
	2471
	2472	PREFIX is a regular expression matching an optional prefix for
	2473	this pair in the specified major modes. If not specified, the
	2474	characters of expression prefix syntax class are automatically
	2475	considered instead. This can be used to attach custom prefixes
	2476	to pairs, such as prefix \"\\function\" in \\function{arg} in
	2477	`LaTeX-mode'.
	2478
	2479	SUFFIX is a regular expression matching an optional suffix for
	2480	this pair in the specified major modes. If not specified, the
	2481	characters of punctuation syntax class are automatically
	2482	considered instead.
	2483
	2484	The rest of the arguments have same semantics as in `sp-pair'.
	2485
	2486	If the pair is not defined globally, ACTIONS defaults to (wrap
	2487	insert) instead of (:add) (which inherits global settings)
	2488
	2489	The pairs are uniquely identified by the opening delimiter. If you
	2490	replace the closing one with a different string in the local
	2491	definition, this will override the global closing delimiter.
	2492
	2493	The list arguments can optionally be of form starting with
	2494	\":add\" or \":rem\" when these mean \"add to the global list\"
	2495	and \"remove from the global list\" respectively. Otherwise,
	2496	the global list is replaced. If you wish to both add and remove
	2497	things with single call, use \"((:add ...) (:rem ...))\" as an
	2498	argument. Therefore,
	2499
	2500	:when '(:add my-test)
	2501
	2502	would mean \"use the global settings for this pair, but also this
	2503	additional test\". If no value is provided for list arguments,
	2504	they default to \"(:add)\" which means they inherit the list from
	2505	the global definition.
	2506
	2507	To disable a pair in a major mode, simply set its actions set to
	2508	nil. This will ensure the pair is not even loaded when the mode is
	2509	activated.
	2510
	2511	If WRAP is non-nil, the binding is added into major mode keymap
	2512	called \"foo-mode-map\". If the mode does not follow this
	2513	convention, you will need to bind the function manually (see
	2514	`sp-pair' to how the function is named for each particular pair).
	2515	The bindings are not added into `smartparens-mode-map' to prevent
	2516	clashes between different modes.
	2517
	2518	BIND is equivalent to WRAP. It is a legacy setting and will be
	2519	removed soon.
	2520
	2521	The binding for INSERT follows the same convention as BIND. See
	2522	`sp-pair' for more info.
	2523
	2524	You can provide a function SKIP-MATCH, that will take three
	2525	arguments: the currently matched delimiter, beginning of match
	2526	and end of match. If this function returns true, the
	2527	`sp-get-paired-expression' matcher will ignore this match. You
	2528	can use this to skip over expressions that serve multiple
	2529	functions, such as if/end pair or unary if in Ruby or * in
	2530	markdown when it signifies list item instead of emphasis. In
	2531	addition, there is a global per major-mode option, see
	2532	`sp-navigate-skip-match'."
	2533	(if (eq actions :rem)
	2534	(dolist (m (-flatten (list modes)))
	2535	(let ((mode-pairs (assq m sp-pairs)))
	2536	(setcdr mode-pairs
	2537	(--remove (equal (plist-get it :open) open)
	2538	(cdr mode-pairs))))
	2539	(sp-with-buffers-using-mode m
	2540	(sp--remove-local-pair open)))
	2541	(dolist (m (-flatten (list modes)))
	2542	(let* ((pair nil))
	2543	(setq pair (plist-put pair :open open))
	2544	(when close (plist-put pair :close close))
	2545	(when trigger (plist-put pair :trigger trigger))
	2546	(when trigger-wrap (plist-put pair :trigger-wrap trigger-wrap))
	2547	(when prefix (plist-put pair :prefix prefix))
	2548	(when suffix (plist-put pair :suffix suffix))
	2549	(when skip-match (plist-put pair :skip-match skip-match))
	2550	(when (and (not (sp-get-pair-definition open t))
	2551	(equal actions '(:add)))
	2552	(setq actions '(wrap insert autoskip navigate)))
	2553	(plist-put pair :actions actions)
	2554	(plist-put pair :when when)
	2555	(plist-put pair :unless unless)
	2556	(plist-put pair :pre-handlers pre-handlers)
	2557	(plist-put pair :post-handlers post-handlers)
	2558	(sp--update-pair-list pair m)
	2559	(-when-let* ((symbol (intern (concat (symbol-name m) "-map")))
	2560	(map (and (boundp symbol) (symbol-value symbol))))
	2561	(when (or wrap bind) (define-key map
	2562	(read-kbd-macro (or wrap bind))
	2563	`(lambda (&optional arg)
	2564	(interactive "P")
	2565	(sp-wrap-with-pair ,open))))
	2566	(when insert (define-key map
	2567	(kbd insert)
	2568	`(lambda () (interactive) (sp-insert-pair ,open))))))))
	2569	(sp--update-local-pairs-everywhere (-flatten (list modes)))
	2570	sp-pairs)
	2571
	2572	(cl-defun sp-local-tag (modes trig open close &key
	2573	(transform 'identity)
	2574	(actions '(wrap insert))
	2575	post-handlers)
	2576	"Add a tag definition.
	2577
	2578	MODES is a mode or a list of modes where this tag should
	2579	activate. It is impossible to define global tags.
	2580
	2581	TRIG is the trigger sequence. It can be a string of any length.
	2582	If more triggers share a common prefix, the shortest trigger is
	2583	executed.
	2584
	2585	OPEN is the format of the opening tag. This is inserted before
	2586	the active region.
	2587
	2588	CLOSE is the format of the closing tag. This is inserted after
	2589	the active region.
	2590
	2591	Opening and closing tags can optionally contain the _ character.
	2592
	2593	If the opening tag contains the _ character, after you type the
	2594	trigger, the region is wrapped with \"skeleton\" tags and a
	2595	special tag editing mode is entered. The text you now type is
	2596	substituted for the _ character in the opening tag.
	2597
	2598	If the closing tag contains the _ character, the text from the
	2599	opening pair is mirrored to the closing pair and substituted for
	2600	the _ character.
	2601
	2602	TRANSFORM is a function name (symbol) that is called to perform a
	2603	transformation of the opening tag text before this is inserted to
	2604	the closing tag. For example, in html tag it might simply select
	2605	the name of the tag and cut off the tag attributes (like
	2606	class/style etc.). Defaults to identity.
	2607
	2608	ACTIONS is a list of actions this tag should support. Currently,
	2609	only \"wrap\" action is supported. Usually, you don't need to
	2610	specify this argument.
	2611
	2612	POST-HANDLERS is a list of functions that are called after the
	2613	tag is inserted. If the tag does contain the _ character, these
	2614	functions are called after the tag editing mode is exited. Each
	2615	function on this list should accept two arguments: the trigger
	2616	string and the action."
	2617	(dolist (mode (-flatten (list modes)))
	2618	(let* ((tag-list (assq mode sp-tags))
	2619	(tag (--first (equal trig (plist-get it :trigger)) (cdr tag-list)))
	2620	(new-tag nil))
	2621	(setq new-tag (plist-put new-tag :trigger trig))
	2622	(plist-put new-tag :open open)
	2623	(plist-put new-tag :close close)
	2624	(when transform (plist-put new-tag :transform transform))
	2625	(when actions (plist-put new-tag :actions actions))
	2626	(when post-handlers (plist-put new-tag :post-handlers post-handlers))
	2627	(if tag-list
	2628	(if (not actions)
	2629	(setcdr tag-list (--remove (equal trig (plist-get it :trigger)) (cdr tag-list)))
	2630	(if (not tag)
	2631	(setcdr tag-list (cons new-tag (cdr tag-list)))
	2632	(sp--update-pair new-tag tag)))
	2633	;; mode doesn't exist
	2634	(when actions
	2635	(!cons (cons mode (list new-tag)) sp-tags))))))
	2636
	2637
	2638	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
	2639	;; Overlay management
	2640
	2641	;; burlywood4
	2642	(defface sp-pair-overlay-face
	2643	'((t (:inherit highlight)))
	2644	"The face used to highlight pair overlays."
	2645	:group 'smartparens)
	2646
	2647	(defface sp-wrap-overlay-face
	2648	'((t (:inherit sp-pair-overlay-face)))
	2649	"The face used to highlight wrap overlays.
	2650
	2651	When the user wraps a region with multi-character pair a special
	2652	insertion mode is entered. This face is used for the overlays
	2653	where the possible wrappings are displayed.
	2654
	2655	The opening and closing delimiters use
	2656	`sp-wrap-overlay-opening-pair' and `sp-wrap-overlay-closing-pair'
	2657	respectively."
	2658	:group 'smartparens)
	2659
	2660	(defface sp-wrap-overlay-opening-pair
	2661	'((t (:inherit sp-wrap-overlay-face
	2662	:foreground "green")))
	2663	"The face used to highlight opening pairs for wrapping.
	2664
	2665	See `sp-wrap-overlay-face'."
	2666	:group 'smartparens)
	2667
	2668	(defface sp-wrap-overlay-closing-pair
	2669	'((t (:inherit sp-wrap-overlay-face
	2670	:foreground "red")))
	2671	"The face used to highlight closing pairs for wrapping.
	2672
	2673	See `sp-wrap-overlay-face'."
	2674	:group 'smartparens)
	2675
	2676	(defface sp-wrap-tag-overlay-face
	2677	'((t (:inherit sp-pair-overlay-face)))
	2678	"The face used to highlight wrap tag overlays."
	2679	:group 'smartparens)
	2680
	2681	(defvar sp-pair-overlay-list '()
	2682	"List of overlays used for tracking inserted pairs.
	2683
	2684	When a pair is inserted, an overlay is created over it. When the
	2685	user starts typing the closing pair we will not insert it again.
	2686	If user leaves the overlay, it is canceled and the insertion
	2687	works again as usual.")
	2688	(make-variable-buffer-local 'sp-pair-overlay-list)
	2689
	2690	(defvar sp-wrap-overlays nil
	2691	"Cons pair of wrap overlays.")
	2692	(make-variable-buffer-local 'sp-wrap-overlays)
	2693
	2694	(defvar sp-wrap-tag-overlays nil
	2695	"Cons pair of tag wrap overlays.")
	2696	(make-variable-buffer-local 'sp-wrap-tag-overlays)
	2697
	2698	(defvar sp-pair-overlay-keymap (make-sparse-keymap)
	2699	"Keymap for the pair overlays.")
	2700	(define-key sp-pair-overlay-keymap (kbd "C-g")
	2701	'(menu-item nil sp-remove-active-pair-overlay :filter
	2702	(lambda (cmd)
	2703	(unless (bound-and-true-p company-my-keymap)
	2704	cmd))))
	2705
	2706	(defvar sp-wrap-overlay-keymap (make-sparse-keymap)
	2707	"Keymap for the wrap overlays.")
	2708	(define-key sp-wrap-overlay-keymap (kbd "C-g") 'sp-wrap-cancel)
	2709
	2710	(defun sp--overlays-at (&optional pos)
	2711	"Wrapper around `overlays-at' to get smartparens overlays.
	2712
	2713	POS is the same as for `overlays-at'.
	2714
	2715	Smartparens functions must use this function instead of
	2716	`overlays-at' directly."
	2717	;; TODO: we should probably also check the returned value
	2718	(--filter (overlay-get it 'type) (overlays-at (or pos (point)))))
	2719
	2720	(defun sp--point-in-overlay-p (overlay)
	2721	"Return t if point is in OVERLAY."
	2722	(and (< (point) (overlay-end overlay))
	2723	(> (point) (overlay-start overlay))))
	2724
	2725	(defun sp--get-overlay-length (overlay)
	2726	"Compute the length of OVERLAY."
	2727	(- (overlay-end overlay) (overlay-start overlay)))
	2728
	2729	(defun sp--get-active-overlay (&optional type)
	2730	"Get active overlay.
	2731
	2732	Active overlay is the shortest overlay at point. Optional
	2733	argument TYPE restrict overlays to only those with given type."
	2734	(let ((overlays (sp--overlays-at)))
	2735	(when type
	2736	(setq overlays (--filter (eq (overlay-get it 'type) type) overlays)))
	2737	(cond
	2738	((not overlays) nil)
	2739	((not (cdr overlays)) (car overlays))
	2740	(t
	2741	(--reduce (if (< (sp--get-overlay-length it) (sp--get-overlay-length acc)) it acc) overlays)))))
	2742
	2743	(defun sp--pair-overlay-create (start end id)
	2744	"Create an overlay over the currently inserted pair.
	2745
	2746	This overlay is used for tracking the position of the point and
	2747	marks the active expression. START and END are the boundaries of
	2748	the overlay, ID is the id of the pair."
	2749	(let ((overlay (make-overlay start end)))
	2750	;; set priority to 99 so that yasnippet with 100 overloads the
	2751	;; keymap #625
	2752	(overlay-put overlay 'priority 99)
	2753	(overlay-put overlay 'keymap sp-pair-overlay-keymap)
	2754	(overlay-put overlay 'pair-id id)
	2755	(overlay-put overlay 'type 'pair)
	2756	(!cons overlay sp-pair-overlay-list)
	2757	(sp--pair-overlay-fix-highlight)
	2758	(add-hook 'post-command-hook 'sp--pair-overlay-post-command-handler nil t)))
	2759
	2760	(defun sp-wrap-cancel ()
	2761	"Cancel the active wrapping."
	2762	(interactive)
	2763	(unwind-protect
	2764	(-let (((obeg . oend) sp-wrap-overlays))
	2765	(when (and (not (called-interactively-p 'any))
	2766	(sp--delete-selection-p))
	2767	(kill-region (overlay-end obeg) (overlay-start oend)))
	2768	(delete-region (overlay-start oend) (overlay-end oend))
	2769	(when (> sp-wrap-point sp-wrap-mark)
	2770	(let ((beg (delete-and-extract-region (overlay-start obeg) (overlay-end obeg))))
	2771	(goto-char (overlay-start oend))
	2772	(insert beg))))
	2773	(sp-wrap--clean-overlays)))
	2774
	2775	(defun sp-wrap--clean-overlays ()
	2776	"Delete wrap overlays."
	2777	(-let [(obeg . oend) sp-wrap-overlays]
	2778	(delete-overlay obeg)
	2779	(delete-overlay oend)
	2780	(setq sp-wrap-overlays nil)))
	2781
	2782	(defun sp--pair-overlay-fix-highlight ()
	2783	"Fix highlighting of the pair overlays.
	2784
	2785	Only the active overlay should be highlighted."
	2786	(--each (sp--overlays-at) (overlay-put it 'face nil))
	2787	(let* ((active (sp--get-active-overlay))
	2788	(type (and active (overlay-get active 'type))))
	2789	(if active
	2790	(cond
	2791	((eq 'wrap-tag type)
	2792	(when sp-highlight-wrap-tag-overlay
	2793	(overlay-put active 'face 'sp-wrap-tag-overlay-face)))
	2794	((eq 'pair type)
	2795	(when sp-highlight-pair-overlay
	2796	(overlay-put active 'face 'sp-pair-overlay-face))))
	2797	;; edge case where we're at the end of active overlay. If
	2798	;; there is a wrap-tag overlay, restore it's face
	2799	(when sp-wrap-tag-overlays
	2800	(overlay-put (car sp-wrap-tag-overlays) 'face 'sp-wrap-tag-overlay-face)))))
	2801
	2802	(defun sp--pair-overlay-post-command-handler ()
	2803	"Remove all invalid pair overlays.
	2804
	2805	An invalid overlay is one that doesn't have point inside it or
	2806	is of zero length.
	2807
	2808	Also remove all pair overlays if point moved backwards and
	2809	`sp-cancel-autoskip-on-backward-movement' is non-nil."
	2810	;; if the point moved backwards, remove all overlays
	2811	(if (and sp-cancel-autoskip-on-backward-movement
	2812	(< (point) sp-previous-point))
	2813	(dolist (o sp-pair-overlay-list) (sp--remove-overlay o))
	2814	;; else only remove the overlays where point is outside them or
	2815	;; their length is zero
	2816	(dolist (o (--remove (and (sp--point-in-overlay-p it)
	2817	(> (sp--get-overlay-length it) 0))
	2818	sp-pair-overlay-list))
	2819	(sp--remove-overlay o)))
	2820	(when sp-pair-overlay-list
	2821	(setq sp-previous-point (point))))
	2822
	2823	(defun sp--reset-memoization (&rest ignored)
	2824	"Reset memoization as a safety precaution.
	2825
	2826	IGNORED is a dummy argument used to eat up arguments passed from
	2827	the hook where this is executed."
	2828	(setf (sp-state-last-syntax-ppss-point sp-state) nil
	2829	(sp-state-last-syntax-ppss-result sp-state) nil))
	2830
	2831	(defun sp-remove-active-pair-overlay ()
	2832	"Deactivate the active overlay. See `sp--get-active-overlay'."
	2833	(interactive)
	2834	(-when-let (active-overlay (sp--get-active-overlay 'pair))
	2835	(sp--remove-overlay active-overlay)))
	2836
	2837	(defun sp--remove-overlay (overlay)
	2838	"Remove OVERLAY."
	2839	;; if it's not a pair overlay, nothing happens here anyway
	2840	(setq sp-pair-overlay-list (--remove (equal it overlay) sp-pair-overlay-list))
	2841	;; if we have zero pair overlays, remove the post-command hook
	2842	(when (not sp-pair-overlay-list)
	2843	(remove-hook 'post-command-hook 'sp--pair-overlay-post-command-handler t)
	2844	;; this is only updated when sp--pair-overlay-post-command-handler
	2845	;; is active. Therefore, we need to reset this to 1. If not, newly
	2846	;; created overlay could be removed right after creation - if
	2847	;; sp-previous-point was greater than actual point
	2848	(setq sp-previous-point -1))
	2849	(delete-overlay overlay)
	2850	(sp--pair-overlay-fix-highlight))
	2851
	2852	(defun sp--replace-overlay-text (o string)
	2853	"Replace text inside overlay O with STRING."
	2854	(save-excursion
	2855	(goto-char (overlay-start o))
	2856	(insert string)
	2857	(delete-region (point) (overlay-end o))))
	2858
	2859	(defun sp--get-overlay-text (o)
	2860	"Get text inside overlay O."
	2861	(buffer-substring (overlay-start o) (overlay-end o)))
	2862
	2863
	2864	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
	2865	;; Action predicates
	2866
	2867	(defun sp-in-string-p (_id _action context)
	2868	"Return t if point is inside string or comment, nil otherwise."
	2869	(eq context 'string))
	2870
	2871	(defun sp-in-string-quotes-p (_id action context)
	2872	"Special string test for quotes.
	2873
	2874	On insert action, test the string context one character back from
	2875	point. Return nil at `bobp'.
	2876
	2877	On escape action use the value of CONTEXT."
	2878	(cond
	2879	((eq action 'insert)
	2880	(if (bobp) nil
	2881	(save-excursion (backward-char 1) (sp-point-in-string))))
	2882	((eq action 'escape)
	2883	(eq context 'string))))
	2884
	2885	(defun sp-in-docstring-p (_id _action context)
	2886	"Return t if point is inside elisp docstring, nil otherwise."
	2887	(and (eq context 'string)
	2888	(save-excursion
	2889	(--when-let (car (sp-get-quoted-string-bounds))
	2890	(goto-char it)
	2891	(ignore-errors (backward-sexp 3))
	2892	(looking-at-p (regexp-opt '("defun" "defmacro"
	2893	"cl-defun" "cl-defmacro"
	2894	"defun" "defmacro"
	2895	"lambda" "-lambda")))))))
	2896
	2897	(defun sp-in-code-p (_id _action context)
	2898	"Return t if point is inside code, nil otherwise."
	2899	(eq context 'code))
	2900
	2901	(defun sp-in-comment-p (_id _action context)
	2902	"Return t if point is inside comment, nil otherwise."
	2903	(eq context 'comment))
	2904
	2905	(defun sp-in-math-p (_id _action _context)
	2906	"Return t if point is inside code, nil otherwise."
	2907	(when (functionp 'texmathp)
	2908	(texmathp)))
	2909
	2910	(defun sp-point-before-eol-p (_id action _context)
	2911	"Return t if point is followed by optional white spaces and end of line, nil otherwise.
	2912	This predicate is only tested on \"insert\" action."
	2913	(when (eq action 'insert)
	2914	(sp--looking-at-p "\\s-*$")))
	2915
	2916	(defun sp-point-after-bol-p (id action _context)
	2917	"Return t if point follows beginning of line and possibly white spaces, nil otherwise.
	2918	This predicate is only tested on \"insert\" action."
	2919	(when (eq action 'insert)
	2920	(sp--looking-back-p (concat "^\\s-*" (regexp-quote id)))))
	2921
	2922	(defun sp-point-at-bol-p (id action _context)
	2923	"Return t if point is at the beginning of line, nil otherwise.
	2924	This predicate is only tested on \"insert\" action."
	2925	(when (eq action 'insert)
	2926	(sp--looking-back-p (concat "^" (regexp-quote id)))))
	2927
	2928	(defun sp-point-before-symbol-p (_id action _context)
	2929	"Return t if point is followed by a symbol, nil otherwise.
	2930	This predicate is only tested on \"insert\" action."
	2931	(when (eq action 'insert)
	2932	(sp--looking-at-p "\\s_")))
	2933
	2934	(defun sp-point-before-word-p (_id action _context)
	2935	"Return t if point is followed by a word, nil otherwise.
	2936	This predicate is only tested on \"insert\" action."
	2937	(when (eq action 'insert)
	2938	(sp--looking-at-p "\\sw\\\|\\s_")))
	2939
	2940	(defun sp-point-after-word-p (id action _context)
	2941	"Return t if point is after a word, nil otherwise.
	2942	This predicate is only tested on \"insert\" action."
	2943	;; TODO: remove condition with sp-defpair
	2944	(when (memq action '(insert escape))
	2945	(sp--looking-back-p (concat "\$\\sw\\\|\\s_\$" (regexp-quote id)))))
	2946
	2947	(defun sp-point-before-same-p (id action _context)
	2948	"Return t if point is followed by ID, nil otherwise.
	2949	This predicate is only tested on \"insert\" action."
	2950	(when (eq action 'insert)
	2951	(sp--looking-at-p (regexp-quote id))))
	2952
	2953	(defun sp-point-in-empty-line-p (id _action _context)
	2954	"Return t if point is on an empty line, nil otherwise."
	2955	(and (sp--looking-at-p "\\s-*$")
	2956	(sp--looking-back-p (concat "^\\s-*" (regexp-quote id)))))
	2957
	2958	(defun sp-char-escaped-p (_id action _context)
	2959	"Return non-nil if character before point is escaped with \\."
	2960	(when (eq action 'insert)
	2961	(save-excursion
	2962	(backward-char 1)
	2963	(looking-back "\\\\" 1))))
	2964
	2965
	2966	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
	2967	;; Pair insertion/deletion/skipping
	2968
	2969	(defun sp--do-action-p (id action &optional use-inside-string)
	2970	"Return t if pair ID can perform ACTION.
	2971
	2972	If ACTION is a list, return t if at least one action from the
	2973	list can be performed.
	2974
	2975	If USE-INSIDE-STRING is non-nil, use value of
	2976	`sp-point-inside-string' instead of testing with
	2977	`sp-point-in-string-or-comment'."
	2978	(setq action (-flatten (list action)))
	2979	(let* ((actions (sp-get-pair id :actions))
	2980	(when-l (sp-get-pair id :when))
	2981	(unless-l (sp-get-pair id :unless))
	2982	(in-string (if use-inside-string
	2983	sp-point-inside-string
	2984	(sp-point-in-string)))
	2985	(context (cond
	2986	(in-string 'string)
	2987	((sp-point-in-comment) 'comment)
	2988	(t 'code)))
	2989	a r)
	2990	(while (and action (not r))
	2991	(setq a (car action))
	2992	(setq r (when (memq a actions)
	2993	;;(and (when-clause) (not (unless-clause)))
	2994	(and (or (not when-l)
	2995	(--some (funcall it id a context) when-l))
	2996	(or (not unless-l)
	2997	(not (--some (funcall it id a context) unless-l))))))
	2998	(!cdr action))
	2999	r))
	3000
	3001	(defun sp--get-handler-context (type)
	3002	"Return the context constant. TYPE is type of the handler."
	3003	(let ((in-string (cl-case type
	3004	(:pre-handlers
	3005	(save-excursion
	3006	(unless (bobp) (backward-char 1))
	3007	(sp-point-in-string-or-comment)))
	3008	(:post-handlers
	3009	(sp-point-in-string-or-comment)))))
	3010	(if in-string 'string 'code)))
	3011
	3012	(defun sp--get-context (&optional point in-string in-comment)
	3013	"Return the context of POINT.
	3014
	3015	If the optional arguments IN-STRING or IN-COMMENT non-nil, their
	3016	value is used instead of a test."
	3017	(save-excursion
	3018	(goto-char (or point (point)))
	3019	(cond
	3020	((or in-string (sp-point-in-string)) 'string)
	3021	((or in-comment (sp-point-in-comment)) 'comment)
	3022	(t 'code))))
	3023
	3024	(defun sp--parse-insertion-spec (fun)
	3025	"Parse the insertion specification FUN and return a form to evaluate."
	3026	(let ((spec nil)
	3027	(after nil)
	3028	(last 1))
	3029	(cl-labels ((push-non-empty
	3030	(what)
	3031	(unless (equal (cadr what) "")
	3032	(push what spec))))
	3033	(with-temp-buffer
	3034	(insert fun)
	3035	(goto-char (point-min))
	3036	(while (re-search-forward "\$\|\\\|\\[\$" nil t)
	3037	(cond
	3038	((equal (match-string 0) "[")
	3039	(if (save-excursion (backward-char 1) (eq (preceding-char) 92))
	3040	(push-non-empty `(insert ,(concat (buffer-substring-no-properties last (- (point) 2)) "[")))
	3041	(push-non-empty `(insert ,(buffer-substring-no-properties last (1- (point)))))
	3042	(let* ((p (point))
	3043	(fun-end (progn
	3044	(re-search-forward "]" nil t)
	3045	(1- (point))))
	3046	(fun-spec (buffer-substring-no-properties p fun-end))
	3047	(instruction (cond
	3048	((equal fun-spec "i")
	3049	'(indent-according-to-mode))
	3050	((equal (aref fun-spec 0) ?d)
	3051	`(delete-char ,(string-to-number (substring fun-spec 1)))))))
	3052	(when instruction (push instruction spec)))))
	3053	((equal (match-string 0) "\|")
	3054	(cond
	3055	((save-excursion (backward-char 1) (eq (preceding-char) 92))
	3056	(push-non-empty `(insert ,(concat (buffer-substring-no-properties last (- (point) 2)) "\|"))))
	3057	(t
	3058	(push-non-empty `(insert ,(buffer-substring-no-properties last (1- (point)))))
	3059	(push 'save-excursion spec)
	3060	(when (eq (following-char) 124)
	3061	(forward-char 1)
	3062	(setq after '(indent-according-to-mode)))))))
	3063	(setq last (point)))
	3064	(push-non-empty `(insert ,(buffer-substring-no-properties last (point-max)))))
	3065	(let* ((specr (nreverse spec))
	3066	(specsplit (--split-with (not (eq it 'save-excursion)) specr))
	3067	(re (-concat (car specsplit) (if (cadr specsplit) (cdr specsplit) nil))))
	3068	(cons 'progn (if after (-snoc re after) re))))))
	3069
	3070	(defun sp--run-function-or-insertion (fun id action context)
	3071	"Run a function or insertion.
	3072
	3073	If FUN is a function, call it with `funcall' with ID, ACTION and
	3074	CONTEXT as arguments.
	3075
	3076	If FUN is a string, interpret it as \"insertion specification\",
	3077	see `sp-pair' for description."
	3078	(cond
	3079	((functionp fun)
	3080	(funcall fun id action context))
	3081	((stringp fun)
	3082	(eval (sp--parse-insertion-spec fun)))))
	3083
	3084
	3085	(defvar sp-handler-context nil
	3086	"Special variable holding context during handler execution.")
	3087
	3088	;; TODO: get rid of `sp-handler-context' and make all the handlers (we
	3089	;; should call them hooks) take better arguments, what we pass now is
	3090	;; useless almost always
	3091	(defun sp--run-hook-with-args (id type action &optional context-values)
	3092	"Run all the hooks for pair ID of type TYPE on action ACTION.
	3093
	3094	CONTEXT-VALUES is a plist with arbitrary values (depending on the
	3095	action). A dynamic varable `sp-handler-context' will be bound to
	3096	this value during execution of the handler."
	3097	(ignore-errors
	3098	(let ((hook (sp-get-pair id type))
	3099	(context (sp--get-handler-context type)))
	3100	(if hook
	3101	(let ((sp-handler-context context-values))
	3102	(--each hook (sp--run-function-or-insertion it id action context)))
	3103	(run-hook-with-args 'tag-hook id action context)))))
	3104
	3105	;; TODO: add a test for a symbol property that would tell this handler
	3106	;; not to re=set `sp-last-operation'. Useful for example in "macro
	3107	;; functions" like `my-wrap-with-paren'.
	3108	(defun sp--post-command-hook-handler ()
	3109	"Handle the situation after some command has executed."
	3110	(sp--with-case-sensitive
	3111	(when (sp--special-self-insert-command-p)
	3112	(sp--post-self-insert-hook-handler))
	3113	(ignore-errors
	3114	(when smartparens-mode
	3115	;; handle the wrap overlays
	3116	(when sp-wrap-overlays
	3117	(let* ((overlay (car sp-wrap-overlays))
	3118	(start (overlay-start overlay))
	3119	(end (overlay-end overlay))
	3120	(p (point)))
	3121	(when (or (< p sp-previous-point)
	3122	(> p end)
	3123	(< p start))
	3124	(sp-wrap-cancel))))
	3125	(when sp-wrap-overlays
	3126	(setq sp-previous-point (point)))
	3127
	3128	;; Here we run the delayed hooks. See issue #80
	3129	(cond
	3130	((eq (car-safe (sp-state-delayed-hook sp-state)) :next)
	3131	(setf (car (sp-state-delayed-hook sp-state)) :this))
	3132	((eq (car-safe (sp-state-delayed-hook sp-state)) :this)
	3133	(let* ((pair (cdr (sp-state-delayed-hook sp-state)))
	3134	(hooks (sp-get-pair pair :post-handlers-cond)))
	3135	(--each hooks
	3136	(let ((fun (car it))
	3137	(conds (cdr it)))
	3138	(when (or (--any? (eq this-command it) conds)
	3139	(--any? (equal (single-key-description last-command-event) it) conds))
	3140	(sp--run-function-or-insertion
	3141	fun pair 'insert
	3142	(sp--get-handler-context :post-handlers)))))
	3143	(setf (sp-state-delayed-hook sp-state) nil)
	3144	(setq sp-last-inserted-pair nil))))
	3145
	3146	;; Here we run the delayed insertion. Some details in issue #113
	3147	(when (and (not (eq sp-last-operation 'sp-insert-pair-delayed))
	3148	sp-delayed-pair)
	3149	(let* ((pair (car sp-delayed-pair))
	3150	(beg (cdr sp-delayed-pair))
	3151	(conds (sp-get-pair pair :when-cond))
	3152	(open-pair pair)
	3153	(close-pair (sp-get-pair pair :close)))
	3154	(when (and conds
	3155	(--any? (cond
	3156	((and (commandp it)
	3157	(not (stringp it)))
	3158	(eq this-command it))
	3159	((stringp it)
	3160	(equal (single-key-description last-command-event) it))
	3161	((ignore-errors (funcall it pair 'insert (sp--get-handler-context :post-handlers))))) conds))
	3162	;; TODO: refactor this and the same code in
	3163	;; `sp-insert-pair' to a separate function
	3164	(sp--run-hook-with-args open-pair :pre-handlers 'insert)
	3165	(insert close-pair)
	3166	(backward-char (length close-pair))
	3167	(sp--pair-overlay-create beg
	3168	(+ (point) (length close-pair))
	3169	open-pair)
	3170	;; no auto-escape here? Should be fairly safe
	3171	(sp--run-hook-with-args open-pair :post-handlers 'insert)
	3172	(setq sp-last-inserted-pair open-pair)
	3173	;; TODO: this is probably useless
	3174	(setq sp-last-operation 'sp-insert-pair)))
	3175	(setq sp-delayed-pair nil))
	3176
	3177	(when (eq sp-last-operation 'sp-insert-pair-delayed)
	3178	(setq sp-last-operation nil))
	3179
	3180	(unless (or (sp--self-insert-command-p)
	3181	(sp--special-self-insert-command-p))
	3182	;; unless the last command was a self-insert, remove the
	3183	;; information about the last wrapped region. It is only used
	3184	;; for: 1. deleting the wrapping immediately after the wrap,
	3185	;; 2. re-wrapping region immediatelly after a sucessful wrap.
	3186	;; Therefore, the deletion should have no ill-effect. If the
	3187	;; necessity will arise, we can add a different flag.
	3188	(setq sp-last-wrapped-region nil)
	3189	(setq sp-last-operation nil))
	3190
	3191	(when show-smartparens-mode
	3192	(if (member this-command sp-show-enclosing-pair-commands)
	3193	(sp-show--pair-enc-function)
	3194	(when (not (eq this-command 'sp-highlight-current-sexp))
	3195	(sp-show--pair-delete-enc-overlays))))))))
	3196
	3197	(defmacro sp--setaction (action &rest forms)
	3198	"Use ACTION as a flag to evaluating FORMS.
	3199
	3200	If ACTION is nil, evaluate FORMS and set it to the value of the
	3201	last form; otherwise do nothing."
	3202	(declare (debug (form body)))
	3203	`(unless ,action
	3204	(setq ,action (progn ,@forms))))
	3205
	3206	;; TODO: this introduces a regression, where doing C-4 [ inserts [[[[]
	3207	;; figure out how to detect the argument to self-insert-command that
	3208	;; resulted to this insertion
	3209	(defun sp--post-self-insert-hook-handler ()
	3210	"Handler for `post-self-insert-hook'."
	3211	(with-demoted-errors "sp--post-self-insert-hook-handler: %S"
	3212	(when smartparens-mode
	3213	(sp--with-case-sensitive
	3214	(catch 'done
	3215	(let (action)
	3216	(when (region-active-p)
	3217	(condition-case err
	3218	(sp-wrap--initialize)
	3219	(user-error
	3220	(message (error-message-string err))
	3221	;; we need to remove the undo record of the insertion
	3222	(unless (eq buffer-undo-list t)
	3223	;; pop all undo info until we hit an insertion node
	3224	(sp--undo-pop-to-last-insertion-node)
	3225	;; get rid of it and insert an undo boundary marker
	3226	(pop buffer-undo-list)
	3227	(undo-boundary))
	3228	(restore-buffer-modified-p sp-buffer-modified-p)
	3229	(throw 'done nil))))
	3230	(cond
	3231	(sp-wrap-overlays
	3232	(sp-wrap))
	3233	(t
	3234	;; TODO: this does not pick correct pair!! it uses insert and not wrapping code
	3235	(sp--setaction
	3236	action
	3237	(-when-let ((_ . open-pairs) (sp--all-pairs-to-insert nil 'wrap))
	3238	(catch 'done
	3239	(-each open-pairs
	3240	(-lambda ((&keys :open open :close close))
	3241	(--when-let (sp--wrap-repeat-last (cons open close))
	3242	(throw 'done it)))))))
	3243	(unless overwrite-mode (sp--setaction action (sp-insert-pair)))
	3244	(sp--setaction action (sp-skip-closing-pair))
	3245	(unless action (sp-escape-open-delimiter))
	3246	;; if nothing happened, we just inserted a character, so
	3247	;; set the apropriate operation.
	3248	(unless action
	3249	(setq sp-last-operation 'sp-self-insert))))))))))
	3250
	3251	;; Unfortunately, some modes rebind "inserting" keys to their own
	3252	;; handlers but do not hand over the insertion back to
	3253	;; `self-insert-command', rather, they insert via `insert'.
	3254	;; Therefore, we need to call this handler in `post-command-hook' too.
	3255	;; The list `sp--special-self-insert-commands' specifies which
	3256	;; commands to handle specially.
	3257	(add-hook 'post-self-insert-hook 'sp--post-self-insert-hook-handler)
	3258
	3259	;; TODO: make a proper data structure for state tracking and describe
	3260	;; why we need each of these.
	3261	(defun sp--save-pre-command-state ()
	3262	"Save some of the buffer state before `pre-command-hook'."
	3263	(setq sp-point-inside-string (sp-point-in-string))
	3264	(setq sp-pre-command-point (point))
	3265	(setq sp-buffer-modified-p (buffer-modified-p)))
	3266
	3267	(add-hook 'pre-command-hook 'sp--save-pre-command-state)
	3268
	3269	(defun sp--get-pair-list ()
	3270	"Get all non-stringlike pairs.
	3271
	3272	Return all pairs that are recognized in this `major-mode' and do
	3273	not have same opening and closing delimiter. This is used for
	3274	navigation functions."
	3275	(--filter (not (string= (car it) (cdr it))) sp-pair-list))
	3276
	3277	(defun sp--get-stringlike-list ()
	3278	"Get all string-like pairs.
	3279
	3280	Return all pairs that are recognized in this `major-mode' that
	3281	have same opening and closing delimiter."
	3282	(--filter (string= (car it) (cdr it)) sp-pair-list))
	3283
	3284	(defun sp--get-allowed-pair-list ()
	3285	"Get all allowed non string-like pairs.
	3286
	3287	Return all pairs that are recognized in this `major-mode', do not
	3288	have same opening and closing delimiter and are allowed in the
	3289	current context. See also `sp--get-pair-list'."
	3290	(--filter (and (sp--do-action-p (car it) 'navigate)
	3291	(not (equal (car it) (cdr it)))) sp-pair-list))
	3292
	3293	(defun sp--get-allowed-stringlike-list ()
	3294	"Get all allowed string-like pairs.
	3295
	3296	Return all pairs that are recognized in this `major-mode',
	3297	have the same opening and closing delimiter and are allowed in
	3298	the current context."
	3299	(--filter (and (sp--do-action-p (car it) 'navigate)
	3300	(equal (car it) (cdr it))) sp-pair-list))
	3301
	3302	(defun sp--get-pair-list-context (&optional action)
	3303	"Return all pairs that are recognized in this `major-mode' and
	3304	are allowed in the current context."
	3305	(setq action (or action 'insert))
	3306	(--filter (sp--do-action-p (car it) action) sp-pair-list))
	3307
	3308	(defun sp--get-pair-list-wrap ()
	3309	"Return the list of all pairs that can be used for wrapping."
	3310	(--filter (sp--do-action-p (car it) 'wrap) sp-pair-list))
	3311
	3312	(defun sp--wrap-regexp (string start end)
	3313	"Wraps regexp with start and end boundary conditions to avoid
	3314	matching symbols in symbols."
	3315	(concat "\$?:" (when start "\\<") string (when end "\\>") "\$"))
	3316
	3317	(defun sp--regexp-for-group (parens &rest strings)
	3318	"Generates an optimized regexp matching all string, but with
	3319	extra boundary conditions depending on parens."
	3320	(let* ((start (car parens))
	3321	(end (cadr parens)))
	3322	(sp--wrap-regexp (regexp-opt strings) start end)))
	3323
	3324	(defun sp--strict-regexp-opt (strings &optional ignored)
	3325	"Like regexp-opt, but with extra boundary conditions to ensure
	3326	that the strings are not matched in-symbol."
	3327	(if strings
	3328	(with-syntax-table
	3329	;; HACK: this is a terrible hack to make ' be treated as a
	3330	;; punctuation. Many text modes set it as word character which
	3331	;; messes up the regexps
	3332	(let ((table (make-syntax-table (syntax-table))))
	3333	(modify-syntax-entry ?' "." table)
	3334	table)
	3335	(--> strings
	3336	(-group-by (lambda (string)
	3337	(list (and (string-match-p "\\`\\<" string) t)
	3338	(and (string-match-p "\\>\\'" string) t)))
	3339	it)
	3340	(mapconcat (lambda (g) (apply 'sp--regexp-for-group g)) it "\\\|")
	3341	(concat "\$?:" it "\$")))
	3342	"^\\<$"))
	3343
	3344	(defun sp--strict-regexp-quote (string)
	3345	"Like regexp-quote, but make sure that the string is not
	3346	matched in-symbol."
	3347	(sp--wrap-regexp (regexp-quote string)
	3348	(string-match-p "\\`\\<" string)
	3349	(string-match-p "\\>\\'" string)))
	3350
	3351	(cl-defun sp--get-opening-regexp (&optional (pair-list (sp--get-pair-list)))
	3352	"Return regexp matching any opening pair."
	3353	(sp--strict-regexp-opt (--map (car it) pair-list)))
	3354
	3355	(cl-defun sp--get-closing-regexp (&optional (pair-list (sp--get-pair-list)))
	3356	"Return regexp matching any closing pair."
	3357	(sp--strict-regexp-opt (--map (cdr it) pair-list)))
	3358
	3359	(cl-defun sp--get-allowed-regexp (&optional (pair-list (sp--get-allowed-pair-list)))
	3360	"Return regexp matching any opening or closing
	3361	delimiter for any pair allowed in current context."
	3362	(sp--strict-regexp-opt (--mapcat (list (car it) (cdr it)) pair-list)))
	3363
	3364	(cl-defun sp--get-stringlike-regexp (&optional (pair-list (sp--get-allowed-stringlike-list)))
	3365	"Return a regexp matching any string-like delimiter.
	3366
	3367	In case PAIR-LIST is empty return a regexp that never matches
	3368	anything."
	3369	(if (consp pair-list)
	3370	(regexp-opt (--map (car it) pair-list))
	3371	"^\\<$"))
	3372
	3373	(defun sp--get-last-wraped-region (beg end open close)
	3374	"Return `sp-get-sexp' style plist about the last wrapped region.
	3375
	3376	Note: this function does not retrieve the actual value of
	3377	`sp-last-wrapped-region', it merely construct the plist from the
	3378	provided values."
	3379	(let ((b (make-marker))
	3380	(e (make-marker)))
	3381	(set-marker b beg)
	3382	(set-marker e end)
	3383	(set-marker-insertion-type e t)
	3384	`(:beg ,b :end ,e :op ,open :cl ,close :prefix "")))
	3385
	3386	;; Wrapping is basically the same thing as insertion, only the closing
	3387	;; pair is placed at a distance.
	3388
	3389	;; However, we want to be able to insert the closing delimiter and
	3390	;; go to the end of block. This will only work with delimiters which
	3391	;; are unique wrt their opening one. For more complex wrapping, there
	3392	;; will probably be an IDO/minibuffer interface. Openings are checked
	3393	;; first.
	3394
	3395	;; Inserting the opening delimiter should put the point wherever it
	3396	;; was when we started insertion.
	3397
	3398	(defun sp-wrap--can-wrap-p ()
	3399	"Return non-nil if we can wrap a region.
	3400
	3401	This is used in advices on various pre-command-hooks from
	3402	\"selection deleting\" modes to intercept their actions.
	3403
	3404	Also added to `self-insert-uses-region-functions' to prevent
	3405	`delete-selection-mode' from replacing the region."
	3406	(let* ((list (sp--get-pair-list-wrap))
	3407	(desc (sp--single-key-description last-command-event)))
	3408	(--any? (or (string-prefix-p desc (car it))
	3409	(string-prefix-p desc (cdr it)))
	3410	list)))
	3411
	3412	(defun sp--pair-to-wrap-comparator (prop a b)
	3413	"Comparator for wrapping pair selection.
	3414
	3415	PROP specifies wrapping-end. A and B are pairs to be compared."
	3416	(< (length (plist-get a prop)) (length (plist-get b prop))))
	3417
	3418	(defun sp--pair-to-wrap (&optional prefix)
	3419	"Return information about possible wrapping pairs.
	3420
	3421	If optional PREFIX is non-nil, this is used to determine the
	3422	possible wrapping pairs instead of the text in the wrapping
	3423	overlay."
	3424	(let* ((working-pairs
	3425	;; TODO: abstract this into a new "sp--get-..." hierarchy
	3426	(--filter (sp--do-action-p (plist-get it :open) 'wrap) sp-local-pairs))
	3427	(obeg (car sp-wrap-overlays))
	3428	(prefix (or prefix (sp--get-overlay-text obeg)))
	3429	(opening-pairs (--filter (string-prefix-p prefix (plist-get it :open)) working-pairs))
	3430	;; HACK: Here, we will add special "trigger pairs" to the
	3431	;; opening list. We set the opening delimiter to the
	3432	;; trigger, leave the rest alone and put the real open into
	3433	;; :open-real property. When we get the pair back, we will
	3434	;; check this property, and if present, fix the pair back to
	3435	;; the regular form
	3436	(wrapper-pairs (->> (--filter (string-prefix-p prefix (or (plist-get it :trigger-wrap) "")) working-pairs)
	3437	(-map (-lambda ((pair &as &plist :open open :trigger-wrap trigger-wrap))
	3438	(setq pair (copy-sequence pair))
	3439	(setq pair (plist-put pair :open trigger-wrap))
	3440	(setq pair (plist-put pair :open-real open))
	3441	pair))))
	3442	(opening-pairs (-concat wrapper-pairs opening-pairs))
	3443	(closing-pairs (--filter (string-prefix-p prefix (plist-get it :close)) working-pairs))
	3444	(open (car (--sort (sp--pair-to-wrap-comparator :open it other) opening-pairs)))
	3445	;; TODO: do we need the special sorting here?
	3446	(close (car (--sort (sp--pair-to-wrap-comparator :close it other) closing-pairs))))
	3447	(list :open open
	3448	:close close
	3449	:opening opening-pairs
	3450	:closing closing-pairs)))
	3451
	3452	(defun sp-wrap--initialize ()
	3453	"Initialize wrapping."
	3454	(when (and sp-autowrap-region
	3455	(sp-wrap--can-wrap-p))
	3456	;; This is the length of string which was inserted by the last
	3457	;; "self-insert" action. Typically this is 1, but sometimes a
	3458	;; single key inserts two or more characters, such as " in latex
	3459	;; where it translates into `` or ''.
	3460	(let ((inserted-string-length (- (point) sp-pre-command-point)))
	3461	;; TODO: get rid of the following variables
	3462	(setq sp-wrap-point (- (point) inserted-string-length))
	3463	(setq sp-wrap-mark (mark))
	3464	;; balance check
	3465	(with-silent-modifications
	3466	(let ((inserted-string
	3467	(prog1 (delete-and-extract-region sp-wrap-point (point))
	3468	;; HACK: in modes with string fences, the insertion
	3469	;; of the delimiter causes `syntax-propertize' to
	3470	;; fire, but the above deletion doesn't re-run it
	3471	;; because the cache tells it the state is OK. We
	3472	;; need to destroy the cache and re-run the
	3473	;; `syntax-propertize' on the buffer. This might be
	3474	;; expensive, but we only done this on wrap-init so
	3475	;; it's fine, I guess.
	3476	(setq syntax-propertize--done -1)
	3477	(syntax-propertize (point-max))))
	3478	(point-string-context (sp-get-quoted-string-bounds sp-wrap-point))
	3479	(mark-string-context (sp-get-quoted-string-bounds (mark))))
	3480	;; If point and mark are inside the same string, we don't
	3481	;; need to check if the region is OK. If both are outisde
	3482	;; strings, we have to. If one is inside and the other is
	3483	;; not, no matter what we would break, so we exit.
	3484	(cond
	3485	;; inside the same string
	3486	((and point-string-context mark-string-context
	3487	(eq (car point-string-context)
	3488	(car mark-string-context))))
	3489	;; neither is inside string
	3490	((and (not point-string-context)
	3491	(not mark-string-context))
	3492	(unless (sp-region-ok-p sp-wrap-point (mark))
	3493	(user-error "Mismatched sexp state: wrapping would break structure")))
	3494	;; one is in and the other isn't
	3495	((if point-string-context (not mark-string-context) mark-string-context)
	3496	(user-error "Mismatched string state: point %sin string, mark %sin string"
	3497	(if (car-safe point-string-context) "" "not ")
	3498	(if (car-safe mark-string-context) "" "not ")))
	3499	;; both are in but in different strings
	3500	(t (user-error "Mismatched string state: point and mark are inside different strings")))
	3501	(insert inserted-string)))
	3502	;; if point > mark, we need to move point to mark and reinsert the
	3503	;; just inserted character.
	3504	(when (> (point) (mark))
	3505	(let ((char (delete-and-extract-region (- (point) inserted-string-length) (point))))
	3506	(exchange-point-and-mark)
	3507	(insert char)))
	3508	(let* ((oleft (make-overlay (- (region-beginning) inserted-string-length)
	3509	(region-beginning) nil nil t))
	3510	(oright (make-overlay (region-end) (region-end) nil nil t)))
	3511	(setq sp-wrap-overlays (cons oleft oright))
	3512	(when sp-highlight-wrap-overlay
	3513	(overlay-put oleft 'face 'sp-wrap-overlay-face)
	3514	(overlay-put oright 'face 'sp-wrap-overlay-face))
	3515	(overlay-put oleft 'priority 100)
	3516	(overlay-put oright 'priority 100)
	3517	(overlay-put oleft 'keymap sp-wrap-overlay-keymap)
	3518	(overlay-put oleft 'type 'wrap)
	3519	(setq sp-previous-point (point))
	3520	(goto-char (1+ (overlay-start oleft)))))))
	3521
	3522	(defun sp-wrap--finalize (wrapping-end open close)
	3523	"Finalize a successful wrapping.
	3524
	3525	WRAPPING-END specifies the wrapping end. If we wrapped using
	3526	opening delimiter it is :open. If we wrapped using closing
	3527	delimiter it is :close. Position of point after wrapping depends
	3528	on this value---if :open, go where the wrapping was initalized,
	3529	if :close, go after the newly-formed sexp.
	3530
	3531	OPEN and CLOSE are the delimiters."
	3532	(-let (((obeg . oend) sp-wrap-overlays))
	3533	(sp--replace-overlay-text obeg open)
	3534	(sp--replace-overlay-text oend close)
	3535	(setq sp-last-operation 'sp-wrap-region)
	3536	(setq sp-last-wrapped-region
	3537	(sp--get-last-wraped-region
	3538	(overlay-start obeg) (overlay-end oend)
	3539	open close))
	3540	(cond
	3541	((eq wrapping-end :open)
	3542	(if sp-wrap-respect-direction
	3543	(progn
	3544	(set-mark (overlay-end oend))
	3545	(goto-char (overlay-start obeg)))
	3546	(when (> sp-wrap-point sp-wrap-mark)
	3547	(set-mark (overlay-start obeg))
	3548	(goto-char (overlay-end oend)))))
	3549	((eq wrapping-end :close)
	3550	(set-mark (overlay-start obeg))
	3551	(goto-char (overlay-end oend))))
	3552	(sp-wrap--clean-overlays)
	3553	(sp--run-hook-with-args open :post-handlers 'wrap)))
	3554
	3555	(defun sp-wrap ()
	3556	"Try to wrap the active region with some pair.
	3557
	3558	This function is not ment to be used to wrap sexps with pairs
	3559	programatically. Use `sp-wrap-with-pair' instead."
	3560	(-let* (((&plist :open open :close close
	3561	:opening opening-pairs
	3562	:closing closing-pairs) (sp--pair-to-wrap))
	3563	((obeg . oend) sp-wrap-overlays))
	3564	(cond
	3565	(open
	3566	(-let (((&plist :open open :close close :open-real open-real) open))
	3567	(when sp-wrap-show-possible-pairs
	3568	(overlay-put
	3569	oend 'after-string
	3570	(mapconcat (lambda (x)
	3571	(if sp-highlight-wrap-overlay
	3572	(concat
	3573	(propertize
	3574	(plist-get x :open) 'face
	3575	'sp-wrap-overlay-opening-pair)
	3576	(propertize
	3577	(plist-get x :close)
	3578	'face 'sp-wrap-overlay-closing-pair))
	3579	(concat (plist-get x :open) (plist-get x :close))))
	3580	opening-pairs " ")))
	3581	(when (equal (sp--get-overlay-text obeg) open)
	3582	(sp-wrap--finalize :open (or open-real open) close))))
	3583	((and close (= 1 (length closing-pairs)))
	3584	(-let (((&plist :open open :close close) close))
	3585	(when (equal (sp--get-overlay-text obeg) close)
	3586	(sp-wrap--finalize :close open close))))
	3587	(t
	3588	(sp-wrap-cancel)))))
	3589
	3590	(defun sp--escape-region (chars-to-escape beg end)
	3591	"Escape instances of CHARS-TO-ESCAPE between BEG and END.
	3592
	3593	Return non-nil if at least one escaping was performed."
	3594	(save-excursion
	3595	(goto-char beg)
	3596	(let ((pattern (regexp-opt chars-to-escape))
	3597	(end-marker (set-marker (make-marker) end))
	3598	(re nil))
	3599	(while (re-search-forward pattern end-marker t)
	3600	(setq re t)
	3601	(save-excursion
	3602	(goto-char (match-beginning 0))
	3603	(insert sp-escape-char)))
	3604	re)))
	3605
	3606	;; TODO: refactor the rewrap-sexp dependent parts out so that this
	3607	;; function has less dependencies on the action
	3608	;; TODO: add mode-dependent escape/unescape actions?
	3609	(defun sp-escape-wrapped-region (id action _context)
	3610	"Escape quotes and special chars when a region is (re)wrapped."
	3611	(when (and sp-escape-wrapped-region
	3612	(memq action '(wrap rewrap-sexp)))
	3613	(sp-get sp-last-wrapped-region
	3614	(let* ((parent-delim (save-excursion
	3615	(goto-char :beg)
	3616	(sp-get (sp-get-string)
	3617	(cond
	3618	((and (< :beg (point))
	3619	(< (point) :end))
	3620	:op)
	3621	((eq action 'rewrap-sexp)
	3622	(plist-get sp-handler-context :parent)))))))
	3623	(cond
	3624	((equal parent-delim id)
	3625	(sp--escape-region (list id sp-escape-char) :beg :end))
	3626	(parent-delim
	3627	(sp--escape-region (list id) :beg-in :end-in))
	3628	(t
	3629	(sp--escape-region (list id sp-escape-char) :beg-in :end-in)))))))
	3630
	3631	(defun sp-escape-quotes-after-insert (id action context)
	3632	"Escape quotes inserted via `sp-insert-pair'."
	3633	(when (and sp-escape-quotes-after-insert
	3634	(eq action 'insert)
	3635	;; we test not being inside string because if we were
	3636	;; before inserting the "" pair it is now split into two
	3637	;; -> which moves us outside the pair
	3638	(not (eq context 'string))
	3639	;; the inserted character must have string syntax, otherwise no "context" flip happens
	3640	(eq (char-syntax (aref id 0)) ?\"))
	3641	(let ((open id)
	3642	(close (sp-get-pair id :close)))
	3643	(sp--escape-region (list open close)
	3644	(- (point) (length open))
	3645	(+ (point) (length close))))))
	3646
	3647	(defun sp--buffer-is-string-balanced-p ()
	3648	"Check if the buffer is string-balanced.
	3649
	3650	A string-balanced buffer is one where where is no unclosed
	3651	string, that is, the string state at the end of the buffer is
	3652	\"closed\"."
	3653	(save-excursion
	3654	(save-restriction
	3655	(widen)
	3656	(goto-char (point-max))
	3657	(let ((syntax (sp--syntax-ppss)))
	3658	(or (< (car syntax) 0)
	3659	(nth 3 syntax))))))
	3660
	3661	(defun sp-escape-open-delimiter ()
	3662	"Escape just inserted opening pair if `sp-insert-pair' was skipped.
	3663
	3664	This is useful for escaping of \" inside strings when its pairing
	3665	is disabled. This way, we can control autoescape and closing
	3666	delimiter insertion separately."
	3667	(-when-let (open (plist-get (sp--pair-to-insert 'escape) :open))
	3668	(when (and (sp--do-action-p open 'escape)
	3669	sp-point-inside-string
	3670	;; do not escape if we are looking at a closing
	3671	;; delimiter, that means we closed an opened string,
	3672	;; most likely.
	3673	(sp--buffer-is-string-balanced-p))
	3674	(sp--escape-region (list open) (- (point) (length open)) (point)))))
	3675
	3676	;; kept to not break people's config... remove later
	3677	(defun sp-match-sgml-tags (tag)
	3678	"Split the html tag TAG at the first space and return its name."
	3679	(let* ((split (split-string tag " "))
	3680	(close (car split)))
	3681	close))
	3682	(make-obsolete 'sp-match-sgml-tags "do not use this function as the tag system has been removed." "2015-02-07")
	3683
	3684	(defun sp--is-number-cons (c)
	3685	"Return non-nil if C is a cons cell with numbers at `car' and `cdr'."
	3686	(and (consp c) (numberp (car c)) (numberp (cdr c))))
	3687
	3688	;; TODO: more research is needed
	3689	(defun sp--undo-pop-to-last-insertion-node ()
	3690	"Pop all undo info until an insertion node (beg . end) is found.
	3691
	3692	This can potentially remove some undo important information."
	3693	(while (and buffer-undo-list
	3694	(or (null (car buffer-undo-list)) ;; is nil
	3695	;; is not undo action we're interested in
	3696	(not (sp--is-number-cons (car buffer-undo-list)))))
	3697	(pop buffer-undo-list)))
	3698
	3699	;; modified from: https://github.com/Fuco1/smartparens/issues/90#issuecomment-18800369
	3700	(defun sp--split-last-insertion-undo (len)
	3701	"Split the last insertion node in the `buffer-undo-list' to
	3702	include separate pair node."
	3703	(sp--undo-pop-to-last-insertion-node)
	3704	(when buffer-undo-list
	3705	(let* ((previous-undo-actions (cdr buffer-undo-list))
	3706	(beg (caar buffer-undo-list))
	3707	(end (cdar buffer-undo-list))
	3708	first-action second-action)
	3709	(unless (< beg (- end len))
	3710	;; We need to go back more than one action. Given the pairs
	3711	;; are limited to 10 chars now and the chunks seem to be 20
	3712	;; chars, we probably wouldn't need more.
	3713	(pop buffer-undo-list)
	3714	(sp--undo-pop-to-last-insertion-node)
	3715	(when buffer-undo-list
	3716	(setq beg (caar buffer-undo-list))
	3717	(setq previous-undo-actions (cdr buffer-undo-list))))
	3718	(setq first-action (cons beg (- end len)))
	3719	(setq second-action (cons (- end len) end))
	3720	(setq buffer-undo-list
	3721	(append (list nil second-action nil first-action)
	3722	previous-undo-actions)))))
	3723
	3724	;; TODO: remove ACTION argument and make the selection process more
	3725	;; unified (see also sp--pair-to-wrap which depends on buffer state
	3726	;; among other things)
	3727	(defun sp--all-pairs-to-insert (&optional looking-fn action)
	3728	"Return all pairs that can be inserted at point.
	3729
	3730	Return nil if such pair does not exist.
	3731
	3732	Pairs inserted using a trigger have higher priority over pairs
	3733	without a trigger and only one or the other list is returned.
	3734
	3735	In other words, if any pair can be inserted using a trigger, only
	3736	pairs insertable by trigger are returned.
	3737
	3738	ACTION is an implementation detail. Usually it has the value
	3739	'insert when we determine pairs to insert. On repeated wrapping
	3740	however we pass the value 'wrap. This will be refactored away in
	3741	the upcoming version."
	3742	(setq looking-fn (or looking-fn 'sp--looking-back-p))
	3743	(setq action (or action 'insert))
	3744	(let ((working-pairs
	3745	;; TODO: abstract this into a new "sp--get-..." hierarchy
	3746	(--filter (sp--do-action-p (plist-get it :open) action) sp-local-pairs)))
	3747	(-if-let (trigs (--filter (and (plist-get it :trigger)
	3748	(funcall looking-fn (sp--strict-regexp-quote (plist-get it :trigger))))
	3749	working-pairs))
	3750	(cons :trigger trigs)
	3751	(-when-let (pairs (--filter (funcall looking-fn (sp--strict-regexp-quote (plist-get it :open))) working-pairs))
	3752	(cons :open pairs)))))
	3753
	3754	(defun sp--pair-to-insert-comparator (prop a b)
	3755	(cond
	3756	;; in case of triggers shorter always wins
	3757	((eq prop :trigger)
	3758	(< (length (plist-get a :trigger)) (length (plist-get b :trigger))))
	3759	;; Shorter wins only if the shorter's closing is a prefix of the
	3760	;; longer's closing. In other words, if we are looking at
	3761	;; shorter's closing and we are trying to nest it.
	3762	(t
	3763	(if (< (length (plist-get a :open)) (length (plist-get b :open)))
	3764	(and (string-prefix-p (plist-get a :close) (plist-get b :close))
	3765	(sp--looking-at-p (plist-get a :close)))
	3766	(not (and (string-prefix-p (plist-get b :close) (plist-get a :close))
	3767	(sp--looking-at-p (plist-get b :close))))))))
	3768
	3769	(defun sp--pair-to-insert (&optional action)
	3770	"Return pair that can be inserted at point.
	3771
	3772	Return nil if such pair does not exist.
	3773
	3774	If more triggers or opening pairs are possible select the
	3775	shortest one."
	3776	(-when-let ((property . pairs) (sp--all-pairs-to-insert nil action))
	3777	(car (--sort (sp--pair-to-insert-comparator property it other) pairs))))
	3778
	3779	(defun sp--longest-prefix-to-insert ()
	3780	"Return pair with the longest :open which can be inserted at point."
	3781	(-when-let (pairs (--filter (sp--looking-back-p (sp--strict-regexp-quote (plist-get it :open))) sp-local-pairs))
	3782	(car (--sort (> (length (plist-get it :open)) (length (plist-get other :open))) pairs))))
	3783
	3784	(defun sp--pair-to-uninsert ()
	3785	"Return pair to uninsert.
	3786
	3787	If the current to-be-inserted pair shares a prefix with
	3788	another (shorter) pair, we must first remove the effect of
	3789	inserting its closing pair before inserting the current one.
	3790
	3791	The previously inserted pair must be the one with the longest
	3792	common prefix excluding the current pair."
	3793	(-when-let (lp (sp--longest-prefix-to-insert))
	3794	(save-excursion
	3795	(backward-char (length (plist-get lp :open)))
	3796	(-when-let ((property . pairs) (sp--all-pairs-to-insert 'sp--looking-at-p))
	3797	(car (--sort (> (length (plist-get it property)) (length (plist-get other property)))
	3798	;; remove pairs whose open is longer than the
	3799	;; current longest possible prefix---otherwise
	3800	;; they would overflow to the closing pair
	3801	;; TODO: this ignores the possibility when lp is
	3802	;; inserted by trigger. We assume triggers are
	3803	;; shorter than the openings and this situation,
	3804	;; if ever, should be very rare
	3805	(--remove (>= (length (plist-get it :open))
	3806	(length (plist-get lp :open))) pairs)))))))
	3807
	3808	(defun sp--insert-pair-get-pair-info (active-pair)
	3809	"Get basic info about the to-be-inserted pair."
	3810	(let ((open-pair (plist-get active-pair :open)))
	3811	(list
	3812	open-pair
	3813	(plist-get active-pair :close)
	3814	(-if-let (tr (plist-get active-pair :trigger))
	3815	(if (sp--looking-back-p (sp--strict-regexp-quote tr)) tr open-pair)
	3816	open-pair))))
	3817
	3818	(defun sp-insert-pair (&optional pair)
	3819	"Automatically insert the closing pair if it is allowed in current context.
	3820
	3821	If PAIR is provided, use this as pair ID instead of looking
	3822	through the recent history of pressed keys.
	3823
	3824	You can disable this feature completely for all modes and all pairs by
	3825	setting `sp-autoinsert-pair' to nil.
	3826
	3827	You can globally disable insertion of closing pair if point is
	3828	followed by the matching opening pair. It is disabled by
	3829	default."
	3830	(sp--with-case-sensitive
	3831	(catch 'done
	3832	(-let* ((active-pair (unwind-protect
	3833	;; This fake insertion manufactures proper
	3834	;; context for the tests below... in effect
	3835	;; we must make it look as if the user
	3836	;; typed in the opening part themselves
	3837	;; TODO: it is duplicated in the test
	3838	;; below, maybe it wouldn't hurt to
	3839	;; restructure this function a bit
	3840	(progn
	3841	(when pair (insert pair))
	3842	(sp--pair-to-insert))
	3843	(when pair (delete-char (- (length pair))))))
	3844	((open-pair close-pair trig) (sp--insert-pair-get-pair-info active-pair)))
	3845	;; We are not looking at a closing delimiter which might mean we
	3846	;; are in an already existing sexp. If the to-be-inserted pair
	3847	;; has a prefix which is also a pair we migth be extending the
	3848	;; opener of a sexp with this opener. In which case we should
	3849	;; probably rewrap.
	3850	(unless (sp--looking-at-p (sp--get-closing-regexp))
	3851	(when (and open-pair
	3852	(= 1 (- (point) sp-pre-command-point)))
	3853	(-when-let (prefix-pair (sp-get-pair (substring open-pair 0 -1)))
	3854	(let ((last-char-of-open-pair (substring open-pair -1)))
	3855	(unwind-protect
	3856	(progn
	3857	(delete-char -1)
	3858	(--when-let (sp-get-thing t)
	3859	(save-excursion
	3860	(sp-get it
	3861	(delete-region :end-in :end)
	3862	(goto-char :end-in)
	3863	(insert close-pair)))
	3864	(throw 'done t)))
	3865	(insert last-char-of-open-pair))))))
	3866	(if (not (unwind-protect
	3867	(progn
	3868	(when pair (insert pair))
	3869	;; TODO: all these tests must go into `sp--pair-to-insert'
	3870	(and sp-autoinsert-pair
	3871	active-pair
	3872	(if (memq sp-autoskip-closing-pair '(always always-end))
	3873	(or (not (equal open-pair close-pair))
	3874	(not (sp-skip-closing-pair nil t)))
	3875	t)
	3876	(sp--do-action-p open-pair 'insert t)
	3877	;; was sp-autoinsert-if-followed-by-same
	3878	(or (not (sp--get-active-overlay 'pair))
	3879	(not (sp--looking-at (sp--strict-regexp-quote open-pair)))
	3880	(and (equal open-pair close-pair)
	3881	(eq sp-last-operation 'sp-insert-pair)
	3882	(save-excursion
	3883	(backward-char (length trig))
	3884	(sp--looking-back (sp--strict-regexp-quote open-pair))))
	3885	(not (equal open-pair close-pair)))))
	3886	(when pair (delete-char (- (length pair))))))
	3887	;; if this pair could not be inserted, we try the procedure
	3888	;; again with this pair removed from sp-pair-list to give
	3889	;; chance to other pairs sharing a common suffix (for
	3890	;; example \[ and [)
	3891	(let ((new-sp-pair-list (--remove (equal (car it) open-pair) sp-pair-list))
	3892	(new-sp-local-pairs (--remove (equal (plist-get it :open) open-pair) sp-local-pairs)))
	3893	(when (> (length sp-pair-list) (length new-sp-pair-list))
	3894	(let ((sp-pair-list new-sp-pair-list)
	3895	(sp-local-pairs new-sp-local-pairs))
	3896	(sp-insert-pair))))
	3897	;; setup the delayed insertion here.
	3898	(if (sp-get-pair open-pair :when-cond)
	3899	(progn
	3900	(setq sp-delayed-pair (cons open-pair (- (point) (length open-pair))))
	3901	(setq sp-last-operation 'sp-insert-pair-delayed))
	3902	(unless pair (delete-char (- (length trig))))
	3903	(insert open-pair)
	3904	(sp--run-hook-with-args open-pair :pre-handlers 'insert)
	3905	;; The re-binding of these dynamic variables is a hack to
	3906	;; combat the similar rebinding in the branch above where
	3907	;; we retry `sp-insert-pair' with some pairs removed.
	3908	;; This however causes them to be uninserted improperly,
	3909	;; so for this one operation we need to restore the state
	3910	;; to the "full" pair list. TODO: in the future we might
	3911	;; want to pass the state around explicitly so we have
	3912	;; better control.
	3913	(--when-let (let ((sp-pair-list (sp-state-pair-list sp-state))
	3914	(sp-local-pairs (sp-state-local-pairs sp-state)))
	3915	(sp--pair-to-uninsert))
	3916	(let ((cl (plist-get it :close)))
	3917	(when (and (sp--looking-at-p (sp--strict-regexp-quote cl))
	3918	(> (- (length close-pair) (length cl)) 0))
	3919	(delete-char (length cl)))))
	3920	(insert close-pair)
	3921	(backward-char (length close-pair))
	3922	(sp--pair-overlay-create (- (point) (length open-pair))
	3923	(+ (point) (length close-pair))
	3924	open-pair)
	3925	(when sp-undo-pairs-separately
	3926	(sp--split-last-insertion-undo (+ (length open-pair) (length close-pair)))
	3927	;; TODO: abc\{abc\} undo undo \{asd\} . next undo removes the
	3928	;; entire \{asd\} if we do not insert two nils here.
	3929	;; Normally, repeated nils are ignored so it shouldn't
	3930	;; matter. It would still be useful to inspect further.
	3931	(push nil buffer-undo-list)
	3932	(push nil buffer-undo-list))
	3933	(sp--run-hook-with-args open-pair :post-handlers 'insert)
	3934	(setq sp-last-inserted-pair open-pair)
	3935	(setf (sp-state-delayed-hook sp-state) (cons :next open-pair))
	3936	(setq sp-last-operation 'sp-insert-pair)))))))
	3937
	3938	(defun sp--wrap-repeat-last (active-pair)
	3939	"If the last operation was a wrap and `sp-wrap-repeat-last' is
	3940	non-nil, repeat the wrapping with this pair around the last
	3941	active region."
	3942	(unless (= 0 sp-wrap-repeat-last)
	3943	(when sp-last-wrapped-region
	3944	(let* ((b (sp-get sp-last-wrapped-region :beg))
	3945	(e (sp-get sp-last-wrapped-region :end))
	3946	(op (sp-get sp-last-wrapped-region :op))
	3947	(oplen (length op))
	3948	(cllen (sp-get sp-last-wrapped-region :cl-l))
	3949	(acolen (length (car active-pair))))
	3950	(when (and
	3951	(cond
	3952	((= 1 sp-wrap-repeat-last)
	3953	(equal (car active-pair) op))
	3954	((= 2 sp-wrap-repeat-last)))
	3955	(memq sp-last-operation '(sp-self-insert sp-wrap-region))
	3956	(or (= (point) (+ b oplen acolen))
	3957	(= (point) e)))
	3958	(delete-char (- acolen))
	3959	(if (< (point) e)
	3960	(progn (goto-char (+ b oplen))
	3961	(insert (car active-pair))
	3962	(goto-char (- e cllen))
	3963	(insert (cdr active-pair))
	3964	(setq sp-last-wrapped-region
	3965	(sp--get-last-wraped-region
	3966	(+ b oplen) (point)
	3967	(car active-pair) (cdr active-pair)))
	3968	(goto-char (+ b oplen acolen)))
	3969	(goto-char b)
	3970	(insert (car active-pair))
	3971	(goto-char e)
	3972	(insert (cdr active-pair))
	3973	(setq sp-last-wrapped-region
	3974	(sp--get-last-wraped-region
	3975	b e (car active-pair) (cdr active-pair))))
	3976	(setq sp-last-operation 'sp-wrap-region)
	3977	(sp--run-hook-with-args (car active-pair) :post-handlers 'wrap)
	3978	sp-last-operation)))))
	3979
	3980	(defun sp--char-is-part-of-stringlike (char)
	3981	"Return non-nil if CHAR is part of a string-like delimiter of length 1."
	3982	(->> (sp--get-stringlike-list)
	3983	(--filter (= 1 (length (cdr it))))
	3984	(-map 'car)
	3985	(--any? (string-match-p (regexp-quote char) it))))
	3986
	3987	(defun sp--char-is-part-of-closing (char &optional pair-list)
	3988	"Return non-nil if CHAR is part of a pair delimiter of length 1.
	3989	Specifically, return the pair for which CHAR is the closing
	3990	delimiter."
	3991	(let ((regexp (regexp-quote char)))
	3992	(->> (or pair-list (sp--get-pair-list))
	3993	(--filter (= 1 (length (cdr it))))
	3994	(--find (string-match-p regexp (cdr it))))))
	3995
	3996	;; TODO: this only supports single-char delimiters. Maybe it should
	3997	;; that that way.
	3998	(defun sp-skip-closing-pair (&optional last test-only)
	3999	"Automatically skip the closing delimiters of pairs.
	4000
	4001	If point is inside an inserted pair, and the user only moved
	4002	forward with point (that is, only inserted text), if the closing
	4003	pair is typed, we shouldn't insert it again but skip forward. We
	4004	call this state \"active sexp\". The setting
	4005	`sp-cancel-autoskip-on-backward-movement' controls when an active
	4006	expression become inactive.
	4007
	4008	For example, pressing ( is followed by inserting the pair (\|). If
	4009	we then type 'word' and follow by ), the result should be (word)\|
	4010	instead of (word)\|).
	4011
	4012	This behaviour can be customized by various settings of
	4013	`sp-autoskip-closing-pair' and `sp-autoskip-opening-pair'.
	4014
	4015	Additionally, this behaviour can be selectively disabled for
	4016	specific pairs by removing their \"autoskip\" action. You can
	4017	achieve this by using `sp-pair' or `sp-local-pair' with
	4018	\":actions '(:rem autoskip)\"."
	4019	(sp--with-case-sensitive
	4020	(when (or (and (eq sp-autoskip-closing-pair t)
	4021	sp-pair-overlay-list
	4022	(sp--get-active-overlay 'pair))
	4023	(memq sp-autoskip-closing-pair '(always always-end)))
	4024	;; TODO: ugly hack to override 'navigate with 'autoskip. Each of
	4025	;; these submodules should set-up their own environment somehow
	4026	;; and thread it through the entire computation
	4027	(cl-letf (((symbol-function 'sp--get-allowed-stringlike-list)
	4028	(lambda ()
	4029	(--filter (and (sp--do-action-p (car it) 'autoskip)
	4030	(equal (car it) (cdr it))) sp-pair-list))))
	4031	;; these two are pretty hackish ~_~
	4032	(cl-labels ((get-sexp
	4033	(last)
	4034	(delete-char -1)
	4035	(insert " ")
	4036	(prog1 (sp-get-sexp)
	4037	(delete-char -1)
	4038	(insert last)))
	4039	(get-enclosing-sexp
	4040	(last)
	4041	(delete-char -1)
	4042	(insert " ")
	4043	(prog1 (sp-get-enclosing-sexp)
	4044	(delete-char -1)
	4045	(insert last))))
	4046	(let ((last (or last (sp--single-key-description last-command-event))))
	4047	(-if-let (active-sexp
	4048	(cond
	4049	((-when-let* ((ov (sp--get-active-overlay 'pair))
	4050	(op (overlay-get ov 'pair-id))
	4051	(cl (cdr (assoc op sp-pair-list))))
	4052	;; if the sexp is active, we are inside it.
	4053	(when (and (= 1 (length op))
	4054	(equal last cl))
	4055	(list :beg (overlay-start ov)
	4056	:end (overlay-end ov)
	4057	:op op
	4058	:cl cl
	4059	:prefix ""
	4060	:suffix ""))))
	4061	((sp--char-is-part-of-stringlike last)
	4062	;; a part of closing delimiter is typed. There are four
	4063	;; options now:
	4064	;; - we are inside the sexp, at its end
	4065	;; - we are inside the sexp, somewhere in the middle
	4066	;; - we are outside, in front of a sexp
	4067	;; - we are outside, somewhere between sexps
	4068	(cond
	4069	((and (sp--looking-at (sp--get-stringlike-regexp))
	4070	(not (sp--skip-match-p (match-string-no-properties 0)
	4071	(match-beginning 0)
	4072	(match-end 0))))
	4073	;; if we're looking at the delimiter, and it is valid in
	4074	;; current context, get the sexp.
	4075	(get-sexp last))
	4076	;; here comes the feature when we're somewhere in the
	4077	;; middle of the sexp (or outside), if ever supported.
	4078	))
	4079	((sp--char-is-part-of-closing last)
	4080	(cond
	4081	((and (sp--looking-at (sp--get-closing-regexp))
	4082	(not (sp--skip-match-p (match-string-no-properties 0)
	4083	(match-beginning 0)
	4084	(match-end 0))))
	4085	(get-sexp last))
	4086	((eq sp-autoskip-closing-pair 'always)
	4087	(get-enclosing-sexp last))))))
	4088	(if (and active-sexp
	4089	(equal (sp-get active-sexp :cl) last)
	4090	(sp--do-action-p (sp-get active-sexp :op) 'autoskip)
	4091	;; if the point is inside string and preceded
	4092	;; by an odd number of `sp-escape-char's, we
	4093	;; should not skip as that would leave the
	4094	;; string broken.
	4095	(or (not (sp-point-in-string))
	4096	(not (sp-char-is-escaped-p (1- (point))))))
	4097	(-when-let (re (cond
	4098	((= (point) (sp-get active-sexp :beg))
	4099	;; we are in front of a string-like sexp
	4100	(when sp-autoskip-opening-pair
	4101	(if test-only t
	4102	(delete-char -1)
	4103	(forward-char)
	4104	(setq sp-last-operation 'sp-skip-closing-pair))))
	4105	((= (point) (sp-get active-sexp :end-in))
	4106	(if test-only t
	4107	(delete-char 1)
	4108	(setq sp-last-operation 'sp-skip-closing-pair)))
	4109	((sp-get active-sexp
	4110	(and (> (point) :beg-in)
	4111	(< (point) :end-in)))
	4112	(if test-only t
	4113	(delete-char -1)
	4114	(sp-up-sexp nil t)))))
	4115	(unless (or test-only
	4116	sp-buffer-modified-p)
	4117	(set-buffer-modified-p nil))
	4118	(unless test-only
	4119	(sp--run-hook-with-args (sp-get active-sexp :op) :post-handlers 'skip-closing-pair))
	4120	re)
	4121	;; if we can't skip and are in strict mode we must not
	4122	;; insert anything if it is a closing character
	4123	(sp--inhibit-insertion-of-closing-delim last))
	4124	(sp--inhibit-insertion-of-closing-delim last))))))))
	4125
	4126	(defun sp--inhibit-insertion-of-closing-delim (last)
	4127	"Inhibit insertion of closing delimiter in `smartparens-strict-mode'.
	4128
	4129	If we are not inserting inside string or a comment, and the LAST
	4130	inserted character is closing delimiter for a pair that performs
	4131	autoskip, and we can not jump out of its enclosing sexp (i.e. it
	4132	does not match), we are not allowed to insert it literally
	4133	because it would break the balance; so we delete the
	4134	just-inserted character."
	4135	(when (and smartparens-strict-mode
	4136	(-when-let (pair (sp--char-is-part-of-closing
	4137	last (sp--get-allowed-pair-list)))
	4138	(memq 'autoskip (sp-get-pair (car pair) :actions)))
	4139	(not (sp-point-in-string-or-comment)))
	4140	(delete-char -1)
	4141	(set-buffer-modified-p sp-buffer-modified-p)
	4142	(sp-message :cant-insert-closing-delimiter)
	4143	nil))
	4144
	4145	(defun sp-delete-pair (&optional arg)
	4146	"Automatically delete opening or closing pair, or both, depending on
	4147	position of point.
	4148
	4149	If the point is inside an empty pair, automatically delete both. That
	4150	is, [(\|) turns to [\|, [\{\|\} turns to [\|. Can be disabled by setting
	4151	`sp-autodelete-pair' to nil.
	4152
	4153	If the point is behind a closing pair or behind an opening pair delete
	4154	it as a whole. That is, \{\}\| turns to \{\|, \{\| turns to \|. Can be
	4155	disabled by setting `sp-autodelete-closing-pair' and
	4156	`sp-autodelete-opening-pair' to nil.
	4157
	4158	If the last operation was a wrap and `sp-autodelete-wrap' is
	4159	enabled, invoking this function will unwrap the expression, that
	4160	is remove the just added wrapping."
	4161	;; NOTE: Only use delete-char inside this function, so we
	4162	;; don't activate the advice recursively!
	4163
	4164	;; only activate if argument is 1 (this is 0-th argument of the
	4165	;; delete-backward-char), otherwise the user wants to delete
	4166	;; multiple character, so let him do that
	4167	(sp--with-case-sensitive
	4168	(when (and (= arg 1)
	4169	smartparens-mode)
	4170	(if (and sp-autodelete-wrap
	4171	(eq sp-last-operation 'sp-wrap-region))
	4172	(let ((p (point))
	4173	(b (sp-get sp-last-wrapped-region :beg))
	4174	(e (sp-get sp-last-wrapped-region :end))
	4175	(o (sp-get sp-last-wrapped-region :op-l))
	4176	(c (sp-get sp-last-wrapped-region :cl-l)))
	4177	;; if the last operation was `sp-wrap-region', and we are at
	4178	;; the position of either opening or closing pair, delete the
	4179	;; just-inserted pair
	4180	(when (or (= p (+ b o))
	4181	(= p e))
	4182	(insert "x") ;dummy char to account for the regularly deleted one
	4183	(save-excursion
	4184	(goto-char e)
	4185	(delete-char (- c))
	4186	(goto-char b)
	4187	(delete-char o))
	4188	(setq sp-last-operation 'sp-delete-pair-wrap)))
	4189	(let ((p (point))
	4190	(inside-pair (--first (and (sp--looking-back (sp--strict-regexp-quote (car it)))
	4191	(sp--looking-at (concat "[ \n\t]*" (sp--strict-regexp-quote (cdr it)))))
	4192	sp-pair-list))
	4193	(behind-pair (--first (sp--looking-back (sp--strict-regexp-quote (cdr it))) sp-pair-list))
	4194	(opening-pair (--first (sp--looking-back (sp--strict-regexp-quote (car it))) sp-pair-list)))
	4195
	4196	(cond
	4197	;; we're just before the closing quote of a string. If there
	4198	;; is an opening or closing pair behind the point, remove
	4199	;; it. This is only really relevant if the pair ends in the
	4200	;; same character as string quote. We almost never want to
	4201	;; delete it as an autopair (it would "open up the string").
	4202	;; So, word\"\|" and <backspace> should produce word\\|" or
	4203	;; word\|" (if \" is autopair) instead of word\\|.
	4204	((and (sp-point-in-string)
	4205	(not (sp-point-in-string (1+ p)))
	4206	(sp-point-in-string (1- p))) ;; the string isn't empty
	4207	(cond ;; oh, you ugly duplication :/
	4208	((and behind-pair sp-autodelete-closing-pair)
	4209	(delete-char (- (1- (length (car behind-pair)))))
	4210	(setq sp-last-operation 'sp-delete-pair-closing))
	4211	((and opening-pair sp-autodelete-opening-pair)
	4212	(delete-char (- (1- (length (car opening-pair)))))
	4213	(setq sp-last-operation 'sp-delete-pair-opening))))
	4214	;; we're inside a pair
	4215	((and inside-pair sp-autodelete-pair)
	4216	(let* ((beg (save-excursion
	4217	(search-backward (car inside-pair))))
	4218	(end (save-excursion
	4219	(search-forward (cdr inside-pair))))
	4220	(cs (sp--get-context p))
	4221	(ce (sp--get-context end))
	4222	(current-sexp (sp-get-sexp)))
	4223	(when (and (or (not (eq cs 'comment)) ;; a => b <=> ~a v b
	4224	(eq ce 'comment))
	4225	(eq beg (sp-get current-sexp :beg))
	4226	(eq end (sp-get current-sexp :end))
	4227	(equal (sp-get current-sexp :op) (car inside-pair))
	4228	(equal (sp-get current-sexp :cl) (cdr inside-pair)))
	4229	(delete-char (- end p))
	4230	(delete-char (- (1- (length (car inside-pair)))))
	4231	(setq sp-last-operation 'sp-delete-pair))))
	4232	;; we're behind a closing pair
	4233	((and behind-pair sp-autodelete-closing-pair)
	4234	(delete-char (- (1- (length (cdr behind-pair)))))
	4235	(setq sp-last-operation 'sp-delete-pair-closing))
	4236	;; we're behind an opening pair and there's no closing pair
	4237	((and opening-pair sp-autodelete-opening-pair)
	4238	(delete-char (- (1- (length (car opening-pair)))))
	4239	(setq sp-last-operation 'sp-delete-pair-opening))))))))
	4240
	4241
	4242	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
	4243	;; Navigation
	4244
	4245	(defun sp--looking-at (regexp)
	4246	"Like `looking-at', but always case sensitive."
	4247	(sp--with-case-sensitive
	4248	(looking-at regexp)))
	4249
	4250	(defun sp--looking-at-p (regexp)
	4251	"Like `looking-at-p', but always case sensitive."
	4252	(sp--with-case-sensitive
	4253	(looking-at-p regexp)))
	4254
	4255	(defun sp--looking-back (regexp &optional limit not-greedy)
	4256	"Return non-nil if text before point matches regular expression REGEXP.
	4257
	4258	With optional argument LIMIT search only that many characters
	4259	backward. If LIMIT is nil, default to `sp-max-pair-length'.
	4260
	4261	If optional argument NON-GREEDY is t search for any matching
	4262	sequence, not necessarily the longest possible."
	4263	(setq limit (or limit sp-max-pair-length))
	4264	(sp--with-case-sensitive
	4265	(let ((from (max 1 (- (point) limit)))
	4266	(to (point))
	4267	(greedy (not not-greedy))
	4268	has-match)
	4269	(if greedy
	4270	(save-excursion
	4271	(goto-char from)
	4272	(save-match-data
	4273	(while (and (not has-match) (< (point) to))
	4274	;; don't use looking-at because we can't limit that search
	4275	(if (and (save-excursion (re-search-forward regexp to t))
	4276	(= (match-end 0) to))
	4277	(setq has-match (match-data))
	4278	(forward-char 1))))
	4279	(when has-match
	4280	(set-match-data has-match)
	4281	t))
	4282	(save-excursion
	4283	(not (null (search-backward-regexp (concat "\$?:" regexp "\$\\=") from t))))))))
	4284
	4285	(defun sp--looking-back-p (regexp &optional limit not-greedy)
	4286	"Same as `sp--looking-back' but do not change the match data."
	4287	(save-match-data
	4288	(sp--looking-back regexp limit not-greedy)))
	4289
	4290	(defun sp--search-backward-regexp (regexp &optional bound noerror count)
	4291	"Works just like `search-backward-regexp', but returns the
	4292	longest possible match. That means that searching for
	4293	\"defun\|fun\" backwards would return \"defun\" instead of
	4294	\"fun\", which would be matched first.
	4295
	4296	This is an internal function. Only use this for searching for
	4297	pairs!"
	4298	(setq count (or count 1))
	4299	(setq bound (or (sp--get-backward-bound) bound))
	4300	(sp--with-case-sensitive
	4301	(let (r)
	4302	(while (> count 0)
	4303	(when (search-backward-regexp regexp bound noerror)
	4304	(goto-char (match-end 0))
	4305	(if (sp--looking-back regexp)
	4306	(setq r (goto-char (match-beginning 0)))
	4307	(if noerror nil (error "Search failed: %s" regexp))))
	4308	(setq count (1- count)))
	4309	r)))
	4310
	4311	(defun sp--search-forward-regexp (regexp &optional bound noerror count)
	4312	"Just like `search-forward-regexp', but always case sensitive."
	4313	(setq bound (or (sp--get-forward-bound) bound))
	4314	(sp--with-case-sensitive
	4315	(search-forward-regexp regexp bound noerror count)))
	4316
	4317	(defun sp--search-forward-in-context (regexp &optional bound noerror count)
	4318	"Just like `sp--search-forward-regexp' but only accept results in same context.
	4319
	4320	The context at point is considered the reference context."
	4321	(let ((context (sp--get-context))
	4322	(re))
	4323	(--dotimes (or count 1)
	4324	(save-excursion
	4325	(while (and (setq re (sp--search-forward-regexp regexp bound noerror))
	4326	(not (eq (sp--get-context) context)))))
	4327	(when re (goto-char re)))
	4328	re))
	4329
	4330	(defun sp--search-backward-in-context (regexp &optional bound noerror count)
	4331	"Just like `sp--search-backward-regexp' but only accept results in same context.
	4332
	4333	The context at point is considered the reference context."
	4334	(let ((context (sp--get-context))
	4335	(re))
	4336	(--dotimes (or count 1)
	4337	(save-excursion
	4338	(while (and (setq re (sp--search-backward-regexp regexp bound noerror))
	4339	(not (eq (sp--get-context) context))))
	4340	(when re (goto-char re))))
	4341	re))
	4342
	4343	(defun sp-get-quoted-string-bounds (&optional point)
	4344	"Return the bounds of the string around POINT.
	4345
	4346	POINT defaults to `point'.
	4347
	4348	If the point is not inside a quoted string, return nil."
	4349	(setq point (or point (point)))
	4350	(save-excursion
	4351	(goto-char point)
	4352	(let ((parse-data (syntax-ppss)))
	4353	(when (nth 3 parse-data)
	4354	(let* ((open (nth 8 parse-data))
	4355	(close (save-excursion
	4356	(parse-partial-sexp
	4357	(point) (point-max)
	4358	nil nil parse-data 'syntax-table)
	4359	(point))))
	4360	(cons open close))))))
	4361
	4362	;; TODO: the repeated conditions are ugly, refactor this!
	4363	(defun sp-get-comment-bounds ()
	4364	"If the point is inside a comment, return its bounds."
	4365	(when (or (sp-point-in-comment)
	4366	(looking-at "[[:space:]]+\\s<"))
	4367	(let ((open (save-excursion
	4368	(--when-let (nth 8 (sp--syntax-ppss))
	4369	(goto-char it))
	4370	(while (and (not (bobp))
	4371	(or (when (sp-point-in-comment)
	4372	(backward-char 1)
	4373	t)
	4374	(when (save-excursion
	4375	(beginning-of-line)
	4376	(looking-at "^[[:space:]]+\\s<"))
	4377	(when (>= (forward-line -1) 0)
	4378	(end-of-line))
	4379	t))))
	4380	;; this means we got here by `sp-point-in-comment' condition
	4381	(unless (and (bobp) (sp-point-in-comment))
	4382	(forward-char))
	4383	(point)))
	4384	(close (save-excursion
	4385	(while (and (not (eobp))
	4386	(or (sp-point-in-comment)
	4387	(looking-at "[[:space:]]+\\s<")))
	4388	(forward-char 1))
	4389	(let ((pp (1- (point))))
	4390	(when (not (or (eobp)
	4391	(sp-point-in-comment)
	4392	(looking-at "[[:space:]]+\\s<")
	4393	(and (eq (char-syntax
	4394	(char-after pp)) ?>)
	4395	(not (eq (char-after pp) ?\n)))
	4396	(/= (logand
	4397	(lsh 1 18)
	4398	(car (syntax-after pp))) 0)
	4399	(/= (logand
	4400	(lsh 1 19)
	4401	(car (syntax-after pp))) 0)))
	4402	(backward-char 1)))
	4403	(point))))
	4404	(cons open close))))
	4405
	4406	(defun sp--get-string-or-comment-bounds ()
	4407	"Get the bounds of string or comment the point is in."
	4408	(or (sp-get-quoted-string-bounds)
	4409	(sp-get-comment-bounds)))
	4410
	4411	(defmacro sp--search-and-save-match (search-fn pattern bound res beg end str)
	4412	"Save the last match info."
	4413	`(progn
	4414	(setq ,res (funcall ,search-fn ,pattern ,bound t))
	4415	(when ,res
	4416	(setq ,beg (match-beginning 0))
	4417	(setq ,end (match-end 0))
	4418	(setq ,str (match-string 0)))
	4419	,res))
	4420
	4421	(cl-defun sp--skip-match-p (ms mb me
	4422	&key
	4423	(global-skip (cdr (--first (memq major-mode (car it)) sp-navigate-skip-match)))
	4424	(pair-skip (sp-get-pair ms :skip-match)))
	4425	"Return non-nil if this match should be skipped.
	4426
	4427	This function uses two tests, one specified in
	4428	`sp-navigate-skip-match' (this is global setting for all pairs in
	4429	given major mode) and by a function specified in :skip-match
	4430	property of the pair.
	4431
	4432	If you are calling this function in a heavy loop, you can supply
	4433	the test functions as keyword arguments to speed up the lookup."
	4434	(save-match-data
	4435	(or (when global-skip (funcall global-skip ms mb me))
	4436	(when pair-skip (funcall pair-skip ms mb me)))))
	4437
	4438	(defmacro sp--valid-initial-delimiter-p (form)
	4439	"Test the last match using `sp--skip-match-p'. The form should
	4440	be a function call that sets the match data."
	4441	(declare (debug (form)))
	4442	(let ((match (make-symbol "match"))
	4443	(pair-skip (make-symbol "pair-skip")))
	4444	`(and ,form
	4445	(let* ((,match (match-string 0))
	4446	(,pair-skip (or (sp-get-pair ,match :skip-match)
	4447	(sp-get-pair (car (--first
	4448	(equal (cdr it) ,match)
	4449	sp-pair-list))
	4450	:skip-match))))
	4451	(not (sp--skip-match-p
	4452	,match
	4453	(match-beginning 0)
	4454	(match-end 0)
	4455	:pair-skip ,pair-skip))))))
	4456
	4457	(defun sp--elisp-skip-match (ms mb _me)
	4458	"Function used to test for escapes in lisp modes.
	4459
	4460	Non-nil return value means to skip the result."
	4461	(and ms
	4462	(> mb 1)
	4463	(save-excursion
	4464	(goto-char mb)
	4465	(save-match-data
	4466	(or (and (sp--looking-back "\\\\" 1 t)
	4467	;; it might be a part of ?\\ token
	4468	(not (sp--looking-back "\\?\\\\\\\\" 3 t)))
	4469	(and (not (sp-point-in-string-or-comment))
	4470	(sp--looking-back "\\?" 1 t) ;;TODO surely we can do better
	4471	(not (sp--looking-back "\\\\\\?" 2 t))
	4472	(not (sp--looking-back "\\s_\\?" 2 t))
	4473	(not (sp--looking-back "\\sw\\?" 2 t))))))))
	4474
	4475	(defun sp--backslash-skip-match (ms mb _me)
	4476	(and ms
	4477	(save-excursion
	4478	(goto-char mb)
	4479	(sp--looking-back "\\\\" 1 t))))
	4480
	4481	;; TODO: since this function is used for all the navigation, we should
	4482	;; optimize it a lot! Get some elisp profiler! Also, we should split
	4483	;; this into smaller functions (esp. the "first expression search"
	4484	;; business)
	4485	(defun sp-get-paired-expression (&optional back)
	4486	"Find the nearest balanced pair expression after point.
	4487
	4488	The expressions considered are those delimited by pairs on
	4489	`sp-pair-list'."
	4490	(sp--with-case-sensitive
	4491	(save-excursion
	4492	(let* ((search-fn (if (not back) 'sp--search-forward-regexp 'sp--search-backward-regexp))
	4493	(global-skip-fn (cdr (--first (memq major-mode (car it)) sp-navigate-skip-match)))
	4494	(pair-list (sp--get-allowed-pair-list))
	4495	;; TODO UGLY HACK!!! When the situation is:
	4496	;; ..)\|;; comment
	4497	;; the context the point gets is the comment. But if we
	4498	;; are searching backward, that is incorrect, because in
	4499	;; that case we want the context of the closing pair.
	4500	;; Therefore, if the direction is backward, we need to move
	4501	;; one point backward, then test the comment/string thing,
	4502	;; then compute the correct bounds, and then restore the
	4503	;; point so the search will pick up the )
	4504
	4505	;; However, we need to distinguish the cases where we are
	4506	;; in comment and trying to get out, and when we are in any
	4507	;; context and we jump into string (in that case, we should
	4508	;; report code context!). For example:
	4509	;; "foo"\|;bar
	4510	;; or
	4511	;; "foo"\|bar
	4512	;; should both report code context
	4513	;; and "\|(foo)" should report string context.
	4514
	4515	;; Beware the case when we have a string inside a comment, like
	4516	;; (foo) ;; bar "baz"\| qux
	4517	;; In this case we want to report comment context even when
	4518	;; backing into the "" (which however is commented)
	4519
	4520	;; Yet another case is when we are not in a comment but
	4521	;; directly after one and we search backwards, consider:
	4522	;; /* foo bar */\|
	4523	;; in C-like language. In this case, we want to report the
	4524	;; context as comment.
	4525
	4526	;; In some languages, special paren syntax with a prefix
	4527	;; serves to mark strings. This means that regular
	4528	;; delimiters, like () are used to delimit strings. For
	4529	;; example, in ruby the sequence %w(...) signifies a
	4530	;; string. If the point is after such a sequence and we
	4531	;; are searching back, we must use the string context,
	4532	;; because the paren is now a string delimiter. This is
	4533	;; usually implemented with "string fence" syntax, so we
	4534	;; will simply check for that.
	4535
	4536	;; Thanks for being consistent at handling syntax bounds Emacs!
	4537	(in-string-or-comment (if back
	4538	(let ((in-comment (sp-point-in-comment))
	4539	(in-string (sp-point-in-string)))
	4540	(save-excursion
	4541	(unless (= (point) (point-min))
	4542	(backward-char)
	4543	(cond
	4544	((eq (car (syntax-after (point))) 15) (point))
	4545	(in-comment (when (sp-point-in-comment) (1+ (point))))
	4546	((and (not in-comment) (sp-point-in-comment)) (1+ (point)))
	4547	((or in-comment in-string) (1+ (point)))))))
	4548	(when (sp-point-in-string-or-comment) (point))))
	4549	(string-bounds (and in-string-or-comment
	4550	(progn
	4551	(goto-char in-string-or-comment)
	4552	(sp--get-string-or-comment-bounds))))
	4553	(fw-bound (if in-string-or-comment (cdr string-bounds) (point-max)))
	4554	(bw-bound (if in-string-or-comment (car string-bounds) (point-min)))
	4555	s e forward mb me ms r done
	4556	possible-pairs possible-interfering-pairs possible-ops possible-cls)
	4557	(while (and (not done)
	4558	(sp--search-and-save-match
	4559	search-fn
	4560	;; #556 The regexp we use here might exclude or
	4561	;; include extra pairs in case the next match is in
	4562	;; a different context. There's no way to know
	4563	;; beforehand where we land, so we need to consider
	4564	;; all pairs in the search and then re-check with
	4565	;; a regexp based on the context of the found pair
	4566	(sp--get-allowed-regexp
	4567	;; use all the pairs!
	4568	(sp--get-pair-list))
	4569	(if back bw-bound fw-bound)
	4570	r mb me ms))
	4571	;; search for the first opening pair. Here, only consider tags
	4572	;; that are allowed in the current context.
	4573	(unless (or (not (save-excursion
	4574	(if back
	4575	(progn
	4576	(goto-char me)
	4577	(sp--looking-back-p (sp--get-allowed-regexp)))
	4578	(goto-char mb)
	4579	(sp--looking-at-p (sp--get-allowed-regexp)))))
	4580	(sp--skip-match-p ms mb me :global-skip global-skip-fn))
	4581	;; if the point originally wasn't inside of a string or comment
	4582	;; but now is, jump out of the string/comment and only search
	4583	;; the code. This ensures that the comments and strings are
	4584	;; skipped if we search inside code.
	4585	(if (and (not in-string-or-comment)
	4586	(if back
	4587	;; When searching back, the point lands on the
	4588	;; first character of whatever pair we've found
	4589	;; and it is in the proper context, for example
	4590	;; "\|(foo)"
	4591	(sp-point-in-string-or-comment)
	4592	;; However, when searching forward, the point
	4593	;; lands after the last char of the pair so to get
	4594	;; its context we must back up one character
	4595	(sp-point-in-string-or-comment (1- (point)))))
	4596	(-if-let (bounds (sp--get-string-or-comment-bounds))
	4597	(let ((jump-to (if back (car bounds) (cdr bounds))))
	4598	(goto-char jump-to)
	4599	;; Can't move out of comment because eob, #427
	4600	(when (eobp)
	4601	(setq done t)))
	4602	(setq done t))
	4603	(setq done t))))
	4604	(when r
	4605	(setq possible-pairs (--filter (or (equal ms (car it))
	4606	(equal ms (cdr it)))
	4607	pair-list))
	4608	(setq possible-ops (-map 'car possible-pairs))
	4609	(setq possible-cls (-map 'cdr possible-pairs))
	4610	(setq pair-list (-difference pair-list possible-pairs))
	4611	(setq possible-interfering-pairs pair-list)
	4612	(while possible-interfering-pairs
	4613	(setq possible-interfering-pairs
	4614	(--filter (or (-contains? possible-ops (car it))
	4615	(-contains? possible-cls (cdr it)))
	4616	pair-list))
	4617	(setq pair-list (-difference pair-list possible-interfering-pairs))
	4618	(setq possible-ops (append possible-ops (-map 'car possible-interfering-pairs)))
	4619	(setq possible-cls (append possible-cls (-map 'cdr possible-interfering-pairs))))
	4620	(when (--any? (equal ms it) possible-ops)
	4621	(setq forward t)
	4622	(setq s mb)
	4623	(when back
	4624	(forward-char (length ms))))
	4625	(when (--any? (equal ms it) possible-cls)
	4626	(setq forward nil)
	4627	(setq e me)
	4628	(when (not back)
	4629	(backward-char (length ms))))
	4630	(let* ((opens (if forward possible-ops possible-cls))
	4631	(closes (if forward possible-cls possible-ops))
	4632	(needle (sp--strict-regexp-opt (append possible-ops possible-cls)))
	4633	(search-fn (if forward 'sp--search-forward-regexp 'sp--search-backward-regexp))
	4634	(depth 1)
	4635	(eof (if forward 'eobp 'bobp))
	4636	(b (if forward fw-bound bw-bound))
	4637	(open (substring-no-properties ms))
	4638	(close (substring-no-properties ms))
	4639	(failure (funcall eof))
	4640	(skip-match-pair-fns (->> possible-ops
	4641	(--mapcat (-when-let (smf (sp-get-pair it :skip-match))
	4642	(list (cons it smf) (cons (sp-get-pair it :close) smf)))))))
	4643	(while (and (> depth 0) (not (funcall eof)))
	4644	(sp--search-and-save-match search-fn needle b r mb me ms)
	4645	(if r
	4646	(unless (or (and (not in-string-or-comment)
	4647	(if forward (save-excursion
	4648	(backward-char)
	4649	(sp-point-in-string-or-comment))
	4650	(sp-point-in-string-or-comment)))
	4651	;; check the individual pair skipper. We
	4652	;; need to test all the possible-ops,
	4653	;; which makes it a bit ugly :/
	4654	(let ((skip-match-pair-fn
	4655	(cdr (--first (equal (car it) ms) skip-match-pair-fns))))
	4656	(sp--skip-match-p ms mb me :global-skip global-skip-fn :pair-skip skip-match-pair-fn)))
	4657	(when (--any? (equal ms it) opens) (setq depth (1+ depth)))
	4658	(when (--any? (equal ms it) closes) (setq depth (1- depth))))
	4659	(unless (minibufferp)
	4660	(sp-message :unmatched-expression))
	4661	(setq depth -1)
	4662	(setq failure t)))
	4663	(if forward
	4664	(setq e me)
	4665	(setq s mb))
	4666	(setq close (substring-no-properties ms))
	4667	(if (or failure
	4668	(/= depth 0))
	4669	(progn
	4670	(unless (minibufferp)
	4671	(sp-message :unmatched-expression))
	4672	nil)
	4673	(let ((end-in-cos (sp-point-in-string-or-comment (1- e)))) ;; fix the "point on comment" issue
	4674	(cond
	4675	((or (and (sp-point-in-string-or-comment s) (not end-in-cos))
	4676	(and (not (sp-point-in-string-or-comment s)) end-in-cos))
	4677	(unless (minibufferp)
	4678	(sp-message :delimiter-in-string))
	4679	nil)
	4680	(t
	4681	(let* ((op (if forward open close)))
	4682	(list :beg s
	4683	:end e
	4684	:op op
	4685	:cl (if forward close open)
	4686	:prefix (sp--get-prefix s op)
	4687	:suffix (sp--get-suffix e op)))))))))))))
	4688
	4689	;; TODO: this does not consider unbalanced quotes in comments!!!
	4690	(defun sp--find-next-stringlike-delimiter (needle search-fn-f &optional limit skip-fn)
	4691	"Find the next string-like delimiter, considering the escapes
	4692	and the skip-match predicate."
	4693	(let (hit match)
	4694	(while (and (not hit)
	4695	(funcall search-fn-f needle limit t))
	4696	(save-match-data
	4697	(setq match (match-string-no-properties 0))
	4698	(unless (or (save-match-data
	4699	(save-excursion
	4700	(goto-char (match-beginning 0))
	4701	(or (sp--looking-back-p "\\\\" 2) ;; assumes \ is always the escape... bad?
	4702	(and (eq major-mode 'emacs-lisp-mode)
	4703	(not (sp-point-in-string))
	4704	(sp--looking-back-p "?" 1)))))
	4705	;; TODO: HACK: global-skip is hack here!!!
	4706	(sp--skip-match-p match (match-beginning 0) (match-end 0)
	4707	:pair-skip (or skip-fn
	4708	(sp-get-pair match :skip-match))
	4709	:global-skip nil))
	4710	(setq hit (match-data)))))
	4711	hit))
	4712
	4713	(defun sp-get-stringlike-expression (&optional back)
	4714	"Find the nearest string-like expression after point.
	4715
	4716	String-like expression is expression enclosed with the same
	4717	opening and closing delimiter, such as ..., \"...\", `...` etc."
	4718	(sp--with-case-sensitive
	4719	(save-excursion
	4720	(let ((needle (sp--get-stringlike-regexp))
	4721	(search-fn-f (if (not back) 'sp--search-forward-regexp 'sp--search-backward-regexp))
	4722	(search-fn-b (if back 'sp--search-forward-regexp 'sp--search-backward-regexp))
	4723	(count 0)
	4724	m b e skip-match-fn limit ok)
	4725	(when (not (equal needle ""))
	4726	(when (sp--find-next-stringlike-delimiter needle search-fn-f)
	4727	;; assumes \ is always the escape... bad?
	4728	(setq m (match-string-no-properties 0))
	4729	(setq needle (regexp-quote m))
	4730	(setq skip-match-fn (sp-get-pair m :skip-match))
	4731	(cond
	4732	((sp-point-in-string)
	4733	(setq limit (sp-get-quoted-string-bounds)))
	4734	((sp-point-in-comment)
	4735	(setq limit (sp-get-comment-bounds))))
	4736	(save-excursion
	4737	(while (sp--find-next-stringlike-delimiter needle 'search-backward-regexp (car limit) skip-match-fn)
	4738	(setq count (1+ count))))
	4739	(when (= (mod count 2) 0)
	4740	(sp--find-next-stringlike-delimiter needle search-fn-b nil))
	4741	(save-excursion
	4742	(setq ok (sp--find-next-stringlike-delimiter needle 'sp--search-backward-regexp (car limit)))
	4743	(setq e (match-beginning 0)))
	4744	(setq ok (and ok (sp--find-next-stringlike-delimiter needle 'search-forward-regexp (cdr limit))))
	4745	(setq b (match-end 0))
	4746	(when ok
	4747	(let ((mb b) (me e))
	4748	(setq b (min mb me))
	4749	(setq e (max mb me)))
	4750	(list :beg b :end e :op m :cl m :prefix (sp--get-prefix b m) :suffix (sp--get-suffix e m)))))))))
	4751
	4752	(defun sp--textmode-stringlike-regexp (delimiters &optional direction)
	4753	"Get a regexp matching text-mode string-like DELIMITERS.
	4754
	4755	Capture group 1 or 2 has the delimiter itself, depending on the
	4756	direction (forward, backward).
	4757
	4758	If DIRECTION is :open, create a regexp matching opening only.
	4759
	4760	If DIRECTION is :close, create a regexp matching closing only.
	4761
	4762	If DIRECTION is nil, create a regexp matching both directions."
	4763	(let* ((delims (regexp-opt delimiters))
	4764	(re (concat
	4765	(if (or (not direction)
	4766	(eq direction :open))
	4767	(concat "\$?:" "\\(?:\\`\\\|[ \t\n\r]\$" "\$" delims "\$" "[^ \t\n\r]\\)") "")
	4768	(if (not direction) "\\\|" "")
	4769	(if (or (not direction)
	4770	(eq direction :close))
	4771	(concat "\$?:[^ \t\n\r]" "\\(" delims "\$" "\$?:[ \t\n\r[:punct:]]\\\|\\'\$" "\\)") ""))))
	4772	re))
	4773
	4774	(defun sp--find-next-textmode-stringlike-delimiter (needle search-fn-f &optional limit)
	4775	"Find the next string-like delimiter, considering the escapes
	4776	and the skip-match predicate."
	4777	(let (hit)
	4778	(while (and (not hit)
	4779	(funcall search-fn-f needle limit t))
	4780	(save-match-data
	4781	(let* ((group (if (match-string 1) 1 2))
	4782	(match (match-string-no-properties group))
	4783	(mb (match-beginning group))
	4784	(me (match-end group))
	4785	(skip-fn (sp-get-pair match :skip-match)))
	4786	(unless (sp--skip-match-p match mb me :pair-skip skip-fn :global-skip nil)
	4787	(setq hit (list match (if (= group 1) :open :close)))))))
	4788	hit))
	4789
	4790	(defun sp-get-textmode-stringlike-expression (&optional back)
	4791	"Find the nearest text-mode string-like expression.
	4792
	4793	If BACK is non-nil search in the backwards direction.
	4794
	4795	Text-mode string-like expression is one where the delimiters must
	4796	be surrounded by whitespace from the outside. For example,
	4797
	4798	foo bar baz
	4799
	4800	is a valid expression enclosed in ** pair, but
	4801
	4802	foobarbaz OR foo barbaz OR foobar baz
	4803
	4804	are not.
	4805
	4806	This is the case in almost every markup language, and so we will
	4807	adjust the parsing to only consider such pairs as delimiters.
	4808	This makes the parsing much faster as it transforms the problem
	4809	to non-stringlike matching and we can use a simple
	4810	counting (stack) algorithm."
	4811	(save-excursion
	4812	(let ((restart-from (point))
	4813	(bounds (or (sp-get-comment-bounds)
	4814	(cons (point-min) (point-max))))
	4815	hit re)
	4816	(while (not hit)
	4817	(goto-char restart-from)
	4818	(save-excursion
	4819	(ignore-errors
	4820	(if back (forward-char) (backward-char)))
	4821	(let* ((delimiters (-map 'car (sp--get-allowed-stringlike-list)))
	4822	(needle (sp--textmode-stringlike-regexp delimiters))
	4823	(search-fn-f (if (not back) 'sp--search-forward-regexp 'sp--search-backward-regexp))
	4824	(limit-f (if (not back) (cdr bounds) (car bounds))))
	4825	(-if-let ((delim type) (sp--find-next-textmode-stringlike-delimiter needle search-fn-f limit-f))
	4826	(let ((search-fn (if (eq type :open) 'sp--search-forward-regexp 'sp--search-backward-regexp))
	4827	(limit (if (eq type :open) (cdr bounds) (car bounds)))
	4828	(needle (sp--textmode-stringlike-regexp (list delim) (if (eq type :open) :close :open))))
	4829	(setq restart-from (point))
	4830	;; this adjustments are made because elisp regexp
	4831	;; can't do lookahead assertions... so we match and
	4832	;; then back up.
	4833	(ignore-errors
	4834	(when (and (not back) (eq type :open)) (backward-char (1+ (length delim))))
	4835	(when (and (not back) (eq type :close) (not (eobp))) (backward-char 1))
	4836	(when (and back (eq type :close)) (forward-char (1+ (length delim))))
	4837	(when (and back (eq type :open) (not (bobp))) (forward-char 1)))
	4838	(let ((other-end (point)))
	4839	(when (sp--find-next-textmode-stringlike-delimiter needle search-fn limit)
	4840	;; Beware, we also need to test the beg/end of
	4841	;; buffer, because we have that variant in the
	4842	;; regexp. In that case the match does not
	4843	;; consume anything and we needn't do any
	4844	;; correction.
	4845	(let* ((this-end (if (eq type :open)
	4846	(max (point-min) (if (eobp) (point) (1- (point))))
	4847	(min (point-max) (if (bobp) (point) (1+ (point))))))
	4848	(b (min this-end other-end))
	4849	(e (max this-end other-end)))
	4850	(setq re (list :beg b
	4851	:end e
	4852	:op delim
	4853	:cl delim
	4854	:prefix (sp--get-prefix b delim) :suffix (sp--get-suffix e delim)))
	4855	(setq hit t)
	4856	;; We ignore matches that contain two
	4857	;; consecutive newlines, as that usually means
	4858	;; there's a new paragraph somewhere inbetween
	4859	;; TODO: make this customizable
	4860	(when (sp-get re
	4861	(save-excursion
	4862	(goto-char :beg)
	4863	(re-search-forward "\n\n\\\|\r\r" :end t)))
	4864	(setq re nil)
	4865	(setq hit nil))))))
	4866	(setq hit :no-more)))))
	4867	re)))
	4868
	4869	(defun sp-use-textmode-stringlike-parser-p ()
	4870	"Test if we should use textmode stringlike parser or not."
	4871	(let ((modes (-filter 'symbolp sp-navigate-use-textmode-stringlike-parser))
	4872	(derived (-map 'cdr (-remove 'symbolp sp-navigate-use-textmode-stringlike-parser))))
	4873	(or (--any? (eq major-mode it) modes)
	4874	(apply 'derived-mode-p derived))))
	4875
	4876	(defun sp-get-stringlike-or-textmode-expression (&optional back delimiter)
	4877	"Return a stringlike expression using stringlike or textmode parser.
	4878
	4879	DELIMITER is a candidate in case we performed a search before
	4880	calling this function and we know it's the closest string
	4881	delimiter to try. This is purely a performance hack, do not rely
	4882	on it when calling directly."
	4883	(if (sp-use-textmode-stringlike-parser-p)
	4884	(sp-get-textmode-stringlike-expression back)
	4885	;; performance hack. If the delimiter is a character in
	4886	;; syntax class 34, grab the string-like expression using
	4887	;; `sp-get-string'
	4888	(if (and delimiter
	4889	(= (length delimiter) 1)
	4890	;; TODO: this "smart" behaviour is duplicated in
	4891	;; `sp-get-thing', maybe the whole string parsing could
	4892	;; be extracted to some common function (actually we
	4893	;; should probably use this one from `sp-get-thing')
	4894	(eq (char-syntax (string-to-char delimiter)) 34))
	4895	(if (eq t (sp-point-in-string))
	4896	;; TODO: this is duplicated in `sp-get-thing', move to a function
	4897	(save-excursion
	4898	(save-restriction
	4899	(widen)
	4900	(-let (((beg . end) (sp-get-quoted-string-bounds)))
	4901	(narrow-to-region beg end))
	4902	(sp-get-stringlike-expression back)))
	4903	(sp-get-string back))
	4904	(sp-get-stringlike-expression back))))
	4905
	4906	(defun sp-get-expression (&optional back)
	4907	"Find the nearest balanced expression of any kind.
	4908
	4909	For markup and text modes a special, more efficient stringlike
	4910	parser is available, see `sp-get-textmode-stringlike-expression'.
	4911	By default, this is enabled in all modes derived from
	4912	`text-mode'. You can change it by customizing
	4913	`sp-navigate-use-textmode-stringlike-parser'."
	4914	(let ((pre (sp--get-allowed-regexp))
	4915	(sre (sp--get-stringlike-regexp))
	4916	(search-fn (if (not back) 'sp--search-forward-regexp 'sp--search-backward-regexp))
	4917	(ps (if back (1- (point-min)) (1+ (point-max))))
	4918	(ss (if back (1- (point-min)) (1+ (point-max))))
	4919	(string-delim nil))
	4920	(setq ps (if (equal pre "") ps
	4921	(or (save-excursion (funcall search-fn pre nil t)) ps)))
	4922	(setq ss (if (equal sre "") ss
	4923	(or (--when-let (save-excursion
	4924	(sp--find-next-stringlike-delimiter sre search-fn))
	4925	(setq string-delim (match-string 0))
	4926	(save-match-data
	4927	(set-match-data it)
	4928	(if back (match-beginning 0) (match-end 0))))
	4929	ss)))
	4930	;; TODO: simplify this logic somehow... (this really depends
	4931	;; on a rewrite of the core parser logic: separation of "find
	4932	;; the valid opening" and "parse it")
	4933
	4934	;; Here, we sacrifice readability for performance. Because we
	4935	;; only use regexp to look forward for the closest pair, it
	4936	;; might occasionally happen that what we picked in fact
	4937	;; can't form a pair and it returns error (for example, it
	4938	;; is an unclosed pair or a quote between words like'so, which
	4939	;; doesn't form a pair). In such a case, or when the pair
	4940	;; found is further than the other possible pair type (for
	4941	;; example, we think we should parse stringlike, but we skip
	4942	;; the first occurrence and the next one is only after a
	4943	;; regular pair, which we should've picked instead), we must
	4944	;; try the other parser as well.
	4945	(-let (((type . re) (if (or (and (not back) (< ps ss))
	4946	(and back (> ps ss)))
	4947	(cons :regular (sp-get-paired-expression back))
	4948	(cons :string (sp-get-stringlike-or-textmode-expression back string-delim)))))
	4949	(when re
	4950	(sp-get re
	4951	(cond
	4952	;; If the returned sexp is regular, but the
	4953	;; to-be-tried-string-expression is before it, we try
	4954	;; to parse it as well, it might be a complete sexp in
	4955	;; which case it should be returned.
	4956	((and (eq type :regular)
	4957	(or (and (not back) (< ss :beg))
	4958	(and back (> ss :end))))
	4959	(or (sp-get-stringlike-or-textmode-expression back string-delim) re))
	4960	((and (eq type :string)
	4961	(or (and (not back) (< ps :beg))
	4962	(and back (> ps :end))))
	4963	(or (sp-get-paired-expression back) re))
	4964	(t re)))))))
	4965
	4966	(defun sp-get-sexp (&optional back)
	4967	"Find the nearest balanced expression that is after (before) point.
	4968
	4969	Search backward if BACK is non-nil. This also means, if the
	4970	point is inside an expression, this expression is returned.
	4971
	4972	If `major-mode' is member of `sp-navigate-consider-sgml-tags',
	4973	sgml tags will also be considered as sexps in current buffer.
	4974
	4975	If the search starts outside a comment, all subsequent comments
	4976	are skipped.
	4977
	4978	If the search starts inside a string or comment, it tries to find
	4979	the first balanced expression that is completely contained inside
	4980	the string or comment. If no such expression exist, a warning is
	4981	raised (for example, when you comment out imbalanced expression).
	4982	However, if you start a search from within a string and the next
	4983	complete sexp lies completely outside, this is returned. Note
	4984	that this only works in modes where strings and comments are
	4985	properly defined via the syntax tables.
	4986
	4987	The return value is a plist with following keys:
	4988
	4989	:beg - point in the buffer before the opening
	4990	delimiter (ignoring prefix)
	4991	:end - point in the buffer after the closing delimiter
	4992	:op - opening delimiter
	4993	:cl - closing delimiter
	4994	:prefix - expression prefix
	4995	:suffix - expression suffix
	4996
	4997	However, you should never access this structure directly as it is
	4998	subject to change. Instead, use the macro `sp-get' which also
	4999	provide shortcuts for many commonly used queries (such as length
	5000	of opening/closing delimiter or prefix)."
	5001	(sp--maybe-init)
	5002	(sp--with-case-sensitive
	5003	(cond
	5004	(sp-prefix-tag-object
	5005	(sp-get-sgml-tag back))
	5006	(sp-prefix-pair-object
	5007	(sp-get-paired-expression back))
	5008	((memq major-mode sp-navigate-consider-sgml-tags)
	5009	(let ((paired (sp-get-expression back)))
	5010	(if (and paired
	5011	(equal "<" (sp-get paired :op)))
	5012	;; if the point is inside the tag delimiter, return the pair.
	5013	(if (sp-get paired (and (<= :beg-in (point)) (>= :end-in (point))))
	5014	paired
	5015	;; if the tag can't be completed, we can at least return
	5016	;; the <> pair
	5017	(or (sp-get-sgml-tag back) paired))
	5018	;; we can still try the tag if the first < or > is closer than
	5019	;; the pair. This is a bit too complicated... seems like a
	5020	;; more clever solution would be needed in the future, esp if
	5021	;; we add the python hack.
	5022	(cond
	5023	((and (not back)
	5024	(< (save-excursion
	5025	(or (search-forward "<" nil t) (point-max)))
	5026	(or (sp-get paired :beg) (point-max))))
	5027	(or (sp-get-sgml-tag) paired))
	5028	((and back
	5029	(> (save-excursion
	5030	(or (search-backward ">" nil t) (point-min)))
	5031	(or (sp-get paired :end) (point-max))))
	5032	(or (sp-get-sgml-tag t) paired))
	5033	(t paired)))))
	5034	(t (sp-get-expression back)))))
	5035
	5036	(defun sp--get-hybrid-sexp-beg ()
	5037	"Get the beginning of hybrid sexp.
	5038	See `sp-get-hybrid-sexp' for definition."
	5039	(save-excursion
	5040	(cl-labels ((indent-or-beg-of-line
	5041	(lb)
	5042	(if (sp-point-in-blank-line)
	5043	lb
	5044	(back-to-indentation)
	5045	(point))))
	5046	(let ((p (progn (when (sp-point-in-symbol) (sp-backward-sexp)) (point)))
	5047	(lb (line-beginning-position))
	5048	(cur (--if-let (save-excursion (sp-backward-sexp)) it (list :end 0))) ;hack
	5049	last)
	5050	(if (< (sp-get cur :end) lb)
	5051	;; if the line is not empty, we move the beg to the indent
	5052	(indent-or-beg-of-line lb)
	5053	(while (sp-get cur
	5054	(and cur
	5055	(> :end lb)
	5056	(<= :end p)))
	5057	(setq last cur)
	5058	(setq cur (sp-backward-sexp)))
	5059	(if last
	5060	(sp-get last :beg-prf)
	5061	;; happens when there is no sexp before the opening delim of
	5062	;; the enclosing sexp. In case it is on line above, we take
	5063	;; the maximum wrt lb.
	5064	(sp-get cur (max :beg-in (indent-or-beg-of-line lb)))))))))
	5065
	5066	(defun sp--narrow-to-line ()
	5067	"Narrow to the current line."
	5068	(narrow-to-region (line-beginning-position) (line-end-position)))
	5069
	5070	(defun sp--get-hybrid-sexp-end ()
	5071	"Get the end of hybrid sexp.
	5072	See `sp-get-hybrid-sexp' for definition."
	5073	(save-excursion
	5074	(cl-labels ((skip-prefix-backward
	5075	(p)
	5076	(save-excursion
	5077	(goto-char p)
	5078	(save-restriction
	5079	(sp--narrow-to-line)
	5080	(skip-syntax-backward " .")
	5081	(point)))))
	5082	(let ((p (progn (when (sp-point-in-symbol) (sp-backward-sexp)) (point)))
	5083	(le (line-end-position))
	5084	(cur (--if-let (save-excursion (sp-forward-sexp)) it (list :beg (1+ (point-max))))) ;hack
	5085	last)
	5086	(if (> (sp-get cur :beg) le)
	5087	(if (sp-point-in-blank-line) le (skip-prefix-backward le))
	5088	(while (sp-get cur
	5089	(and cur
	5090	(< :beg le)
	5091	(>= :beg p)))
	5092	(setq last cur)
	5093	(setq cur (sp-forward-sexp)))
	5094	(let ((r (skip-prefix-backward
	5095	(if last
	5096	(sp-get last :end)
	5097	;; happens when there is no sexp before the closing delim of
	5098	;; the enclosing sexp. In case it is on line below, we take
	5099	;; the minimum wrt le.
	5100	(sp-get cur (min :end-in le))))))
	5101	(goto-char r)
	5102	;; fix the situation when point ends in comment
	5103	(cond
	5104	((sp-point-in-comment)
	5105	(if (= (line-number-at-pos p)
	5106	(line-number-at-pos r))
	5107	(line-end-position)
	5108	(goto-char p)
	5109	(line-end-position)))
	5110	(t r))))))))
	5111
	5112	(defun sp--get-hybrid-suffix (p)
	5113	"Get the hybrid sexp suffix, which is any punctuation after
	5114	the end, possibly preceded by whitespace."
	5115	(save-excursion
	5116	(goto-char p)
	5117	(buffer-substring-no-properties
	5118	p
	5119	(save-restriction
	5120	(sp--narrow-to-line)
	5121	(skip-syntax-forward " ")
	5122	(if (not (looking-at "\\s."))
	5123	p
	5124	(skip-syntax-forward ".")
	5125	(point))))))
	5126
	5127	(defun sp-get-hybrid-sexp ()
	5128	"Return the hybrid sexp around point.
	5129
	5130	A hybrid sexp is defined as the smallest balanced region containing
	5131	the point while not expanding further than the current line. That is,
	5132	any hanging sexps will be included, but the expansion stops at the
	5133	enclosing list boundaries or line boundaries."
	5134	(let ((end (sp--get-hybrid-sexp-end)))
	5135	(list :beg (sp--get-hybrid-sexp-beg)
	5136	:end end
	5137	:op ""
	5138	:cl ""
	5139	:prefix ""
	5140	:suffix (sp--get-hybrid-suffix end))))
	5141
	5142	(defun sp-get-enclosing-sexp (&optional arg)
	5143	"Return the balanced expression that wraps point at the same level.
	5144
	5145	With ARG, ascend that many times. This function expects a positive
	5146	argument."
	5147	(setq arg (or arg 1))
	5148	(save-excursion
	5149	(let ((n arg)
	5150	(ok t)
	5151	(okr))
	5152	(while (and (> n 0) ok)
	5153	(setq ok t)
	5154	(setq okr nil)
	5155	;; if we are inside string, get the string bounds and "string
	5156	;; expression"
	5157	(when (sp-point-in-string)
	5158	(setq okr (sp-get-string)))
	5159	;; get the "normal" expression defined by pairs
	5160	(let ((p (point)))
	5161	(setq ok (sp-get-sexp))
	5162	(cond
	5163	((and ok (= (sp-get ok :beg) p))
	5164	(goto-char (sp-get ok :end))
	5165	(setq n (1+ n)))
	5166	((and ok (< (sp-get ok :beg) p))
	5167	(goto-char (sp-get ok :end)))
	5168	(t
	5169	(while (and ok (>= (sp-get ok :beg) p))
	5170	(setq ok (sp-get-sexp))
	5171	(when ok (goto-char (sp-get ok :end)))))))
	5172	;; if the pair expression is enclosed inside a string, return
	5173	;; the pair expression, otherwise return the string expression
	5174	(when okr
	5175	(unless (and ok
	5176	(sp-compare-sexps ok okr >=)
	5177	(sp-compare-sexps ok okr <= :end))
	5178	(setq ok okr)
	5179	(goto-char (sp-get ok :end))))
	5180	(setq n (1- n)))
	5181	(if (not (and (not ok)
	5182	sp-navigate-comments-as-sexps))
	5183	ok
	5184	(when (sp-point-in-comment)
	5185	(let* ((cb (sp-get-comment-bounds))
	5186	(b (save-excursion
	5187	(goto-char (car cb))
	5188	(sp-skip-backward-to-symbol t)
	5189	(point)))
	5190	(e (save-excursion
	5191	(goto-char (cdr cb))
	5192	(sp-skip-forward-to-symbol t)
	5193	(point))))
	5194	(list :beg b :end e :op "" :cl "" :prefix sp-comment-char)))))))
	5195
	5196	(defun sp-get-list-items (&optional lst)
	5197	"Return the information about expressions inside LST.
	5198
	5199	LST should be a data structure in format as returned by
	5200	`sp-get-sexp'.
	5201
	5202	The return value is a list of such structures in order as they
	5203	occur inside LST describing each expression, with LST itself
	5204	prepended to the front.
	5205
	5206	If LST is nil, the list at point is used (that is the list
	5207	following point after `sp-backward-up-sexp' is called)."
	5208	(let ((r nil))
	5209	(save-excursion
	5210	(unless lst
	5211	(setq lst (sp-backward-up-sexp)))
	5212	(when lst
	5213	(goto-char (sp-get lst :beg-in))
	5214	(while (< (point) (sp-get lst :end))
	5215	(!cons (sp-forward-sexp) r))
	5216	(cons lst (nreverse (cdr r)))))))
	5217
	5218	(cl-defun sp--get-prefix (&optional (p (point)) op)
	5219	"Get the prefix of EXPR.
	5220
	5221	Prefix is any continuous sequence of characters in \"expression
	5222	prefix\" syntax class. You can also specify a set of syntax code
	5223	characters or a regexp for a specific major mode. See
	5224	`sp-sexp-prefix'.
	5225
	5226	The point is expected to be at the opening delimiter of the sexp
	5227	and the prefix is searched backwards.
	5228
	5229	If the prefix property is defined for OP, the associated regexp
	5230	is used to retrieve the prefix instead of the global setting."
	5231	(sp--with-case-sensitive
	5232	(save-excursion
	5233	(goto-char p)
	5234	(let* ((pref (sp-get-pair op :prefix))
	5235	(prefix
	5236	(if pref
	5237	(when (sp--looking-back pref sp-max-prefix-length)
	5238	(match-string-no-properties 0))
	5239	(-if-let (mmode-prefix (cdr (assoc major-mode sp-sexp-prefix)))
	5240	(cond
	5241	((and (eq (car mmode-prefix) 'regexp)
	5242	(sp--looking-back (cadr mmode-prefix)))
	5243	(match-string-no-properties 0))
	5244	((eq (car mmode-prefix) 'syntax)
	5245	(skip-syntax-backward (cadr mmode-prefix))
	5246	(buffer-substring-no-properties (point) p))
	5247	(t ""))
	5248	(backward-prefix-chars)
	5249	(buffer-substring-no-properties (point) p)))))
	5250	;; do not consider it a prefix if it matches some opening or
	5251	;; closing delimiter which is allowed for parsing in current
	5252	;; context
	5253	(goto-char p)
	5254	(if (and (< 0 (length prefix))
	5255	(or (sp--do-action-p prefix 'navigate)
	5256	(sp--do-action-p
	5257	(car (--first (equal (cdr it) prefix)
	5258	sp-pair-list))
	5259	'navigate)))
	5260	""
	5261	prefix)))))
	5262
	5263	(cl-defun sp--get-suffix (&optional (p (point)) op)
	5264	"Get the suffix of EXPR.
	5265
	5266	Suffix is any continuous sequence of characters in the
	5267	\"punctuation suffix\" syntax class. You can also specify a set
	5268	of syntax code characters or a regexp for a specific major mode.
	5269	See `sp-sexp-suffix'.
	5270
	5271	If the suffix property is defined for OP, the associated regexp
	5272	is used to retrieve the suffix instead of the global setting."
	5273	(sp--with-case-sensitive
	5274	(save-excursion
	5275	(goto-char p)
	5276	(let* ((suff (sp-get-pair op :suffix))
	5277	(suffix
	5278	(if suff
	5279	(when (sp--looking-at suff)
	5280	(match-string-no-properties 0))
	5281	(-if-let (mmode-suffix (cdr (assoc major-mode sp-sexp-suffix)))
	5282	(cond
	5283	((and (eq (car mmode-suffix) 'regexp)
	5284	(sp--looking-at (cadr mmode-suffix)))
	5285	(match-string-no-properties 0))
	5286	((eq (car mmode-suffix) 'syntax)
	5287	(skip-syntax-forward (cadr mmode-suffix))
	5288	(buffer-substring-no-properties p (point)))
	5289	(t ""))
	5290	(skip-syntax-forward ".")
	5291	(buffer-substring-no-properties p (point))))))
	5292	;; do not consider it a suffix if it matches some opening or
	5293	;; closing delimiter which is allowed for parsing in current
	5294	;; context
	5295	(goto-char p)
	5296	(if (and (< 0 (length suffix))
	5297	(or (sp--do-action-p suffix 'navigate)
	5298	(sp--do-action-p
	5299	(car (--first (equal (cdr it) suffix)
	5300	sp-pair-list))
	5301	'navigate)))
	5302	""
	5303	suffix)))))
	5304
	5305	(defun sp-get-symbol (&optional back)
	5306	"Find the nearest symbol that is after point, or before point if BACK is non-nil.
	5307
	5308	This also means, if the point is inside a symbol, this symbol is
	5309	returned. Symbol is defined as a chunk of text recognized by
	5310	`sp-forward-symbol'.
	5311
	5312	The return value is a plist with the same format as the value
	5313	returned by `sp-get-sexp'."
	5314	(sp--maybe-init)
	5315	(let (b e last-or-first)
	5316	(save-excursion
	5317	(if back
	5318	(progn
	5319	(sp-skip-backward-to-symbol)
	5320	(when (= (point) (point-min)) (setq last-or-first t))
	5321	(sp-forward-symbol -1)
	5322	(setq b (point))
	5323	(sp-forward-symbol 1)
	5324	(setq e (point)))
	5325	(sp-skip-forward-to-symbol)
	5326	(when (= (point) (point-max)) (setq last-or-first t))
	5327	(sp-forward-symbol 1)
	5328	(setq e (point))
	5329	(sp-forward-symbol -1)
	5330	(setq b (point))))
	5331	(unless last-or-first
	5332	(list :beg b :end e :op "" :cl "" :prefix (sp--get-prefix b) :suffix (sp--get-suffix e)))))
	5333
	5334	(defun sp--get-string (bounds)
	5335	"Return the `sp-get-sexp' format info about the string.
	5336
	5337	This function simply transforms BOUNDS, which is a cons (BEG
	5338	. END) into format compatible with `sp-get-sexp'."
	5339	(let* ((op (char-to-string (char-after (car bounds))))
	5340	(cl (char-to-string (char-before (cdr bounds)))))
	5341	;; if the closing and opening isn't the same token, we should
	5342	;; return nil
	5343	(when (equal op cl)
	5344	(list :beg (car bounds)
	5345	:end (cdr bounds)
	5346	:op cl
	5347	:cl cl
	5348	:prefix (sp--get-prefix (car bounds) op)
	5349	:suffix (sp--get-suffix (cdr bounds) cl)))))
	5350
	5351	(defun sp-get-string (&optional back)
	5352	"Find the nearest string after point, or before if BACK is non-nil.
	5353
	5354	This also means if the point is inside a string, this string is
	5355	returned. If there are another symbols between point and the
	5356	string, nil is returned. That means that this function only
	5357	return non-nil if the string is the very next meaningful
	5358	expression.
	5359
	5360	The return value is a plist with the same format as the value
	5361	returned by `sp-get-sexp'."
	5362	(sp--maybe-init)
	5363	(if (sp-point-in-comment)
	5364	(sp-get-stringlike-expression back)
	5365	(if (sp-point-in-string)
	5366	(let ((r (sp-get-quoted-string-bounds)))
	5367	(sp--get-string r))
	5368	(save-excursion
	5369	(sp-skip-into-string back)
	5370	(--when-let (sp-get-quoted-string-bounds)
	5371	(sp--get-string it))))))
	5372
	5373	(defun sp-get-whitespace ()
	5374	"Get the whitespace around point.
	5375
	5376	Whitespace here is defined as any of the characters: space, tab
	5377	and newline."
	5378	(list :beg (save-excursion (skip-chars-backward " \t\n") (point))
	5379	:end (save-excursion (skip-chars-forward " \t\n") (point))
	5380	:op ""
	5381	:cl ""
	5382	:prefix ""
	5383	:suffix ""))
	5384
	5385	(defun sp--sgml-get-tag-name (match)
	5386	(let ((sub (if (equal "/" (substring match 1 2))
	5387	(substring match 2)
	5388	(substring match 1))))
	5389	(car (split-string sub "\$ \\\|>\$"))))
	5390
	5391	(defun sp--sgml-opening-p (tag)
	5392	(not (equal "/" (substring tag 1 2))))
	5393
	5394	(defun sp--sgml-ignore-tag (tag)
	5395	"Return non-nil if tag should be ignored in search, nil otherwise."
	5396	(member tag '("!--" "!DOCTYPE")))
	5397
	5398	(defun sp-get-sgml-tag (&optional back)
	5399	(sp--maybe-init)
	5400	(sp--with-case-sensitive
	5401	(save-excursion
	5402	(let ((search-fn (if (not back) 'sp--search-forward-regexp 'search-backward-regexp))
	5403	tag tag-name needle
	5404	open-start open-end
	5405	close-start close-end)
	5406	(when (and (funcall search-fn "</?.?\\s-?.?>" nil t)
	5407	(progn
	5408	(setq tag (substring-no-properties (match-string 0)))
	5409	(setq tag-name (sp--sgml-get-tag-name tag))
	5410	(not (sp--sgml-ignore-tag tag-name))))
	5411	(setq needle (concat "</?" tag-name))
	5412	(let* ((forward (sp--sgml-opening-p tag))
	5413	(search-fn (if forward 'sp--search-forward-regexp 'search-backward-regexp))
	5414	(depth 1))
	5415	(save-excursion
	5416	(if (not back)
	5417	(progn
	5418	(setq open-end (point))
	5419	(search-backward-regexp "<" nil t)
	5420	(setq open-start (point)))
	5421	(setq open-start (point))
	5422	(search-forward-regexp ">" nil t)
	5423	(setq open-end (point))))
	5424	(cond
	5425	((and (not back) (not forward))
	5426	(goto-char (match-beginning 0)))
	5427	((and back forward)
	5428	(goto-char (match-end 0))))
	5429	(while (> depth 0)
	5430	(if (funcall search-fn needle nil t)
	5431	(if (sp--sgml-opening-p (match-string 0))
	5432	(if forward (setq depth (1+ depth)) (setq depth (1- depth)))
	5433	(if forward (setq depth (1- depth)) (setq depth (1+ depth))))
	5434	(setq depth -1)))
	5435	(if (eq depth -1)
	5436	(progn (sp-message :no-matching-tag) nil)
	5437	(save-excursion
	5438	(if forward
	5439	(progn
	5440	(setq close-start (match-beginning 0))
	5441	(search-forward-regexp ">" nil t)
	5442	(setq close-end (point)))
	5443	(setq close-start (point))
	5444	(search-forward-regexp ">" nil t)
	5445	(setq close-end (point))))
	5446	(let ((op (buffer-substring-no-properties open-start open-end))
	5447	(cl (buffer-substring-no-properties close-start close-end)))
	5448	(list :beg (if forward open-start close-start)
	5449	:end (if forward close-end open-end)
	5450	:op (if forward op cl)
	5451	:cl (if forward cl op)
	5452	:prefix ""
	5453	:suffix "")))))))))
	5454
	5455	(defun sp--end-delimiter-closure (pairs pair-list)
	5456	"Compute the \"end-delimiter\" closure of set PAIRS.
	5457
	5458	PAIRS can be:
	5459	- single pair ID
	5460	- single cons with opening and closing delimiter
	5461	- list of pair IDs
	5462	- list of conses of opening and closing delimiters
	5463
	5464	For example, if we have pairs (if . end) and (def . end), then
	5465	the closure of \"if\" pair are both of these because they share
	5466	the closing delimiter. Therefore, in the navigation functions,
	5467	both have to be considered by the parser."
	5468	(let* ((pairs (-flatten (list pairs)))
	5469	(pairs (if (consp (car pairs)) (-map 'car pairs) pairs))
	5470	(pairs (--filter (member (car it) pairs) pair-list))
	5471	(closure (-mapcat
	5472	(lambda (x)
	5473	(--filter (equal (cdr x) (cdr it)) pair-list))
	5474	pairs)))
	5475	closure))
	5476
	5477	(defun sp-restrict-to-pairs (pairs function)
	5478	"Call the FUNCTION restricted to PAIRS.
	5479
	5480	PAIRS is either an opening delimiter of a list of opening
	5481	delimiters.
	5482
	5483	FUNCTION is a function symbol.
	5484
	5485	For example, you can restrict function `sp-down-sexp' to the
	5486	pair (\"{\" . \"}\") for easier navigation of blocks in C-like
	5487	languages."
	5488	(let* ((pairs (-flatten (list pairs)))
	5489	(new-pairs (--filter (member (car it) pairs) sp-pair-list))
	5490	(sp-pair-list (sp--end-delimiter-closure new-pairs sp-pair-list)))
	5491	(call-interactively function)))
	5492
	5493	(defun sp-restrict-to-object (object function)
	5494	"Call the FUNCTION restricted to OBJECT.
	5495
	5496	OBJECT is one of following symbols (you have to quote it!):
	5497	- `sp-prefix-pair-object'
	5498	- `sp-prefix-tag-object'
	5499	- `sp-prefix-symbol-object'
	5500
	5501	This function will enable this prefix and then call FUNCTION.
	5502
	5503	FUNCTION is a function symbol.
	5504
	5505	This function is equivalent to doing:
	5506
	5507	(let ((sp-prefix-object t))
	5508	(call-interactively function))
	5509
	5510	For example, you can restrict function `sp-forward-sexp' to just
	5511	the pairs for easier navigation of blocks in C-like languages."
	5512	(cl-letf (((symbol-value object) t))
	5513	(call-interactively function)))
	5514
	5515	;; TODO: add shorter alias?
	5516	(defun sp-restrict-to-pairs-interactive (pairs function)
	5517	"Return an interactive lambda that calls FUNCTION restricted to PAIRS.
	5518
	5519	See `sp-restrict-to-pairs'.
	5520
	5521	This function implements a \"decorator pattern\", that is, you
	5522	can apply another scoping function to the output of this function
	5523	and the effects will added together. In particular, you can
	5524	combine it with:
	5525
	5526	- `sp-restrict-to-object-interactive'
	5527
	5528	You can also bind the output of this function directly to a key, like:
	5529
	5530	(global-set-key (kbd ...) (sp-restrict-to-pairs-interactive \"{\" 'sp-down-sexp))
	5531
	5532	This will be a function that descends down only into { } pair,
	5533	ignoring all others."
	5534	(lambda (&optional _arg)
	5535	(interactive "P")
	5536	(sp-restrict-to-pairs pairs function)))
	5537
	5538	(defun sp-restrict-to-object-interactive (object function)
	5539	"Return an interactive lambda that calls FUNCTION restricted to OBJECT.
	5540
	5541	See `sp-restrict-to-object'.
	5542
	5543	This function implements a \"decorator pattern\", that is, you
	5544	can apply another scoping function to the output of this function
	5545	and the effects will added together. In particular, you can
	5546	combine it with:
	5547
	5548	- `sp-restrict-to-pairs-interactive'
	5549
	5550	You can also bind the output of this function directly to a key, like:
	5551
	5552	(global-set-key (kbd ...) (sp-restrict-to-object-interactive
	5553	'sp-prefix-pair-object
	5554	'sp-forward-sexp))
	5555
	5556	This will be a function that navigates only by using paired
	5557	expressions, ignoring strings and sgml tags."
	5558	(lambda (&optional _arg)
	5559	(interactive "P")
	5560	(sp-restrict-to-object object function)))
	5561
	5562	(defun sp-prefix-tag-object (&optional _arg)
	5563	"Read the command and invoke it on the next tag object.
	5564
	5565	If you specify a regular emacs prefix argument this is passed to
	5566	the executed command. Therefore, executing
	5567	\"\\[universal-argument] 2 \\[sp-prefix-tag-object] \\[sp-forward-sexp]\" will move two tag
	5568	expressions forward, ignoring possible symbols or paired
	5569	expressions inbetween.
	5570
	5571	Tag object is anything delimited by sgml tag."
	5572	(interactive "P")
	5573	(let* ((cmd (read-key-sequence "" t))
	5574	(com (key-binding cmd))
	5575	(sp-prefix-tag-object t))
	5576	(if (commandp com)
	5577	(call-interactively com)
	5578	(execute-kbd-macro cmd))))
	5579
	5580	(defun sp-prefix-pair-object (&optional _arg)
	5581	"Read the command and invoke it on the next pair object.
	5582
	5583	If you specify a regular emacs prefix argument this is passed to
	5584	the executed command. Therefore, executing
	5585	\"\\[universal-argument] 2 \\[sp-prefix-pair-object] \\[sp-forward-sexp]\" will move two paired
	5586	expressions forward, ignoring possible symbols inbetween.
	5587
	5588	Pair object is anything delimited by pairs from `sp-pair-list'."
	5589	(interactive "P")
	5590	(let* ((cmd (read-key-sequence "" t))
	5591	(com (key-binding cmd))
	5592	(sp-prefix-pair-object t))
	5593	(if (commandp com)
	5594	(call-interactively com)
	5595	(execute-kbd-macro cmd))))
	5596
	5597	(defun sp-prefix-symbol-object (&optional _arg)
	5598	"Read the command and invoke it on the next pair object.
	5599
	5600	If you specify a regular emacs prefix argument this is passed to
	5601	the executed command. Therefore, executing
	5602	\"\\[universal-argument] 2 \\[sp-prefix-symbol-object] \\[sp-forward-sexp]\" will move two symbols
	5603	forward, ignoring any structure.
	5604
	5605	Symbol is defined as a chunk of text recognized by
	5606	`sp-forward-symbol'."
	5607	(interactive "P")
	5608	(let* ((cmd (read-key-sequence "" t))
	5609	(com (key-binding cmd))
	5610	(sp-prefix-symbol-object t))
	5611	(if (commandp com)
	5612	(call-interactively com)
	5613	(execute-kbd-macro cmd))))
	5614
	5615	(defun sp-prefix-save-excursion (&optional _arg)
	5616	"Execute the command keeping the point fixed.
	5617
	5618	If you specify a regular emacs prefix argument this is passed to
	5619	the executed command."
	5620	(interactive "P")
	5621	(let* ((cmd (read-key-sequence "" t))
	5622	(com (key-binding cmd)))
	5623	(sp--keep-indentation
	5624	(save-excursion
	5625	(if (commandp com)
	5626	(call-interactively com)
	5627	(execute-kbd-macro cmd))))))
	5628
	5629	(defun sp-get-thing (&optional back)
	5630	"Find next thing after point, or before if BACK is non-nil.
	5631
	5632	Thing is either symbol (`sp-get-symbol'),
	5633	string (`sp-get-string') or balanced expression recognized by
	5634	`sp-get-sexp'.
	5635
	5636	If `sp-navigate-consider-symbols' is nil, only balanced
	5637	expressions are considered."
	5638	(sp--maybe-init)
	5639	(sp--with-case-sensitive
	5640	(cond
	5641	(sp-prefix-tag-object (sp-get-sgml-tag back))
	5642	(sp-prefix-pair-object (sp-get-paired-expression back))
	5643	(sp-prefix-symbol-object (sp-get-symbol back))
	5644	(t
	5645	(if back
	5646	(if (not sp-navigate-consider-symbols)
	5647	(sp-get-sexp t)
	5648	(save-excursion
	5649	(cond
	5650	((sp-point-in-empty-string)
	5651	(sp-get-string t))
	5652	(t
	5653	(sp-skip-backward-to-symbol t nil t)
	5654	(cond
	5655	;; this is an optimization, we do not need to look up
	5656	;; the "pair" expression first. If this fails, follow
	5657	;; up with regular sexps
	5658	((and (memq major-mode sp-navigate-consider-sgml-tags)
	5659	(or (sp--looking-back ">")
	5660	;; sp-skip-backward-to-symbol moves the
	5661	;; point to the end of an element name in
	5662	;; js2-jsx-mode
	5663	(looking-at ">"))
	5664	(sp-get-sgml-tag t)))
	5665	((sp--valid-initial-delimiter-p (sp--looking-back (sp--get-closing-regexp (sp--get-allowed-pair-list)) nil))
	5666	(sp-get-sexp t))
	5667	((sp--valid-initial-delimiter-p (sp--looking-back (sp--get-opening-regexp (sp--get-allowed-pair-list)) nil))
	5668	(sp-get-sexp t))
	5669	((and (eq (syntax-class (syntax-after (1- (point)))) 7)
	5670	(not (sp-char-is-escaped-p (1- (point)))))
	5671	(if (eq t (sp-point-in-string))
	5672	(save-excursion
	5673	(save-restriction
	5674	(widen)
	5675	(-let (((beg . end) (sp-get-quoted-string-bounds)))
	5676	(narrow-to-region beg end))
	5677	(sp-get-stringlike-expression t)))
	5678	(sp-get-string t)))
	5679	((sp--valid-initial-delimiter-p (sp--looking-back (sp--get-stringlike-regexp) nil))
	5680	(sp-get-expression t))
	5681	;; We might be somewhere inside the prefix of the
	5682	;; sexp after the point. Since the prefix can be
	5683	;; specified as regexp and not syntax class, it might
	5684	;; itself by a symbol which would invalidly get
	5685	;; picked here.
	5686	(t (-when-let (sym (sp-get-symbol t))
	5687	(save-excursion
	5688	(sp-get sym (goto-char :end))
	5689	(if (sp--valid-initial-delimiter-p (sp--looking-at (sp--get-opening-regexp (sp--get-allowed-pair-list))))
	5690	(let* ((ms (match-string 0))
	5691	(pref (sp--get-prefix (point) ms)))
	5692	(if (and pref
	5693	(not (equal pref "")))
	5694	(sp-get-sexp t)
	5695	sym))
	5696	sym)))))))))
	5697	(if (not sp-navigate-consider-symbols)
	5698	(sp-get-sexp nil)
	5699	(save-excursion
	5700	(cond
	5701	((sp-point-in-empty-string)
	5702	(sp-get-string nil))
	5703	(t
	5704	(sp-skip-forward-to-symbol t nil t)
	5705	(cond
	5706	((and (memq major-mode sp-navigate-consider-sgml-tags)
	5707	(or (looking-at "<")
	5708	;; sp-skip-forward-to-symbol moves the point
	5709	;; to the beginning of an element name in
	5710	;; js2-jsx-mode
	5711	(and (sp--looking-back "</?" (- (point) 2))
	5712	(goto-char (match-beginning 0))))
	5713	(sp-get-sgml-tag)))
	5714	((sp--valid-initial-delimiter-p (sp--looking-at (sp--get-opening-regexp (sp--get-allowed-pair-list))))
	5715	(sp-get-sexp nil))
	5716	((sp--valid-initial-delimiter-p (sp--looking-at (sp--get-closing-regexp (sp--get-allowed-pair-list))))
	5717	(sp-get-sexp nil))
	5718	;; TODO: merge the following two conditions and use
	5719	;; `sp-get-stringlike-or-textmode-expression'
	5720	((and (eq (syntax-class (syntax-after (point))) 7)
	5721	(not (sp-char-is-escaped-p)))
	5722	;; It might happen that the string delimiter we are
	5723	;; looking at is nested inside another string
	5724	;; delimited by string fences (for example nested "
	5725	;; and ' in python). In this case we can't use
	5726	;; `sp-get-string' parser because it would pick up the
	5727	;; outer string. So if we are inside a string and
	5728	;; `syntax-ppss' returns t as delimiter we need to use
	5729	;; `sp-get-stringlike-expression'
	5730	(if (eq t (sp-point-in-string))
	5731	(save-excursion
	5732	(save-restriction
	5733	(widen)
	5734	(-let (((beg . end) (sp-get-quoted-string-bounds)))
	5735	(narrow-to-region beg end))
	5736	(sp-get-stringlike-expression nil)))
	5737	(sp-get-string nil)))
	5738	((sp--valid-initial-delimiter-p (sp--looking-at (sp--get-stringlike-regexp)))
	5739	(sp-get-expression nil))
	5740	;; it can still be that we are looking at a /prefix/ of a
	5741	;; sexp. We should skip a symbol forward and check if it
	5742	;; is a sexp, and then maybe readjust the output.
	5743	(t (let* ((sym (sp-get-symbol nil))
	5744	(sym-string (and sym (sp-get sym (buffer-substring-no-properties :beg :end))))
	5745	(point-before-prefix (point)))
	5746	(when sym-string
	5747	(if (sp--valid-initial-delimiter-p (sp--search-forward-regexp (sp--get-opening-regexp (sp--get-pair-list-context 'navigate)) nil t))
	5748	(let* ((ms (match-string 0))
	5749	(pref (progn
	5750	;; need to move before the
	5751	;; opening, so (point) evals
	5752	;; there.
	5753	(backward-char (length ms))
	5754	(sp--get-prefix (point) ms))))
	5755	;; We use >= because the first skip to
	5756	;; symbol might have skipped some prefix
	5757	;; chars which make prefix of the symbol
	5758	;; which together make prefix of a sexp.
	5759	;; For example \foo{} in latex, where \ is
	5760	;; prefix of symbol foo and \foo is prefix
	5761	;; of {
	5762	(if (and pref
	5763	(not (equal pref ""))
	5764	(>= point-before-prefix (- (point) (length pref))))
	5765	(sp-get-sexp nil)
	5766	sym))
	5767	sym))))))))))))))
	5768
	5769	(defun sp-narrow-to-sexp (arg)
	5770	"Make text outside current balanced expression invisible.
	5771	A numeric arg specifies to move up by that many enclosing expressions.
	5772
	5773	See also `narrow-to-region' and `narrow-to-defun'."
	5774	(interactive "p")
	5775	(-when-let (enc (sp-get-enclosing-sexp arg))
	5776	(sp-get enc (narrow-to-region :beg-prf :end))))
	5777
	5778	(defun sp-forward-sexp (&optional arg)
	5779	"Move forward across one balanced expression.
	5780
	5781	With ARG, do it that many times. Negative arg -N means move
	5782	backward across N balanced expressions. If there is no forward
	5783	expression, jump out of the current one (effectively doing
	5784	`sp-up-sexp').
	5785
	5786	With `sp-navigate-consider-symbols' symbols and strings are also
	5787	considered balanced expressions.
	5788
	5789	Examples: (prefix arg in comment)
	5790
	5791	\|(foo bar baz) -> (foo bar baz)\|
	5792
	5793	(\|foo bar baz) -> (foo\| bar baz)
	5794
	5795	(\|foo bar baz) -> (foo bar\| baz) ;; 2
	5796
	5797	(foo (bar baz\|)) -> (foo (bar baz)\|)"
	5798	(interactive "^p")
	5799	(setq arg (or arg 1))
	5800	(if (< arg 0)
	5801	(sp-backward-sexp (- arg))
	5802	(let* ((n arg)
	5803	(ok t))
	5804	(while (and ok (> n 0))
	5805	(setq ok (sp-get-thing))
	5806	(setq n (1- n))
	5807	(when ok (goto-char (sp-get ok :end))))
	5808	ok)))
	5809
	5810	(put 'sp-forward-sexp 'CUA 'move)
	5811
	5812	(defun sp-backward-sexp (&optional arg)
	5813	"Move backward across one balanced expression (sexp).
	5814
	5815	With ARG, do it that many times. Negative arg -N means move
	5816	forward across N balanced expressions. If there is no previous
	5817	expression, jump out of the current one (effectively doing
	5818	`sp-backward-up-sexp').
	5819
	5820	With `sp-navigate-consider-symbols' symbols and strings are also
	5821	considered balanced expressions.
	5822
	5823	Examples: (prefix arg in comment)
	5824
	5825	(foo bar baz)\| -> \|(foo bar baz)
	5826
	5827	(foo\| bar baz) -> (\|foo bar baz)
	5828
	5829	(foo bar\| baz) -> (\|foo bar baz) ;; 2
	5830
	5831	(\|(foo bar) baz) -> ((\|foo bar) baz)"
	5832	(interactive "^p")
	5833	(setq arg (or arg 1))
	5834	(if (< arg 0)
	5835	(sp-forward-sexp (- arg))
	5836	(let* ((n arg)
	5837	(ok t))
	5838	(while (and ok (> n 0))
	5839	(setq ok (sp-get-thing t))
	5840	(setq n (1- n))
	5841	(when ok (goto-char (sp-get ok :beg))))
	5842	ok)))
	5843
	5844	(put 'sp-backward-sexp 'CUA 'move)
	5845
	5846	(defun sp-next-sexp (&optional arg)
	5847	"Move forward to the beginning of next balanced expression.
	5848
	5849	With ARG, do it that many times. If there is no next expression
	5850	at current level, jump one level up (effectively doing
	5851	`sp-backward-up-sexp'). Negative arg -N means move to the
	5852	beginning of N-th previous balanced expression.
	5853
	5854	If `sp-navigate-interactive-always-progress-point' is non-nil,
	5855	and this is called interactively, the point will move to the
	5856	first expression in forward direction where it will end up
	5857	greater than the current location.
	5858
	5859	With `sp-navigate-consider-symbols' symbols and strings are also
	5860	considered balanced expressions.
	5861
	5862	Examples:
	5863
	5864	((foo) \|bar (baz quux)) -> ((foo) bar \|(baz quux))
	5865
	5866	((foo) bar \|(baz quux)) -> \|((foo) bar (baz quux))
	5867
	5868	and with non-nil `sp-navigate-interactive-always-progress-point'
	5869
	5870	(f\|oo bar) -> (foo \|bar)
	5871
	5872	((fo\|o) (bar)) -> ((foo) \|(bar))"
	5873	(interactive "^p")
	5874	(setq arg (or arg 1))
	5875	(if (<= arg 0)
	5876	(sp-backward-sexp (- arg))
	5877	(if (and sp-navigate-interactive-always-progress-point
	5878	(called-interactively-p 'any))
	5879	(progn
	5880	(while (< 0 arg)
	5881	(let ((point-start (point)))
	5882	(while (--when-let (sp-forward-sexp)
	5883	(<= (sp-get it :beg) point-start))))
	5884	(setq arg (1- arg)))
	5885	(goto-char (sp-get (sp-get-thing t) :beg)))
	5886	(if (= arg 1)
	5887	(-when-let (ok (sp-get-thing))
	5888	(if (= (point) (sp-get ok :beg))
	5889	(progn (sp-forward-sexp 2)
	5890	(sp-backward-sexp))
	5891	(goto-char (sp-get ok :beg))
	5892	ok))
	5893	(sp-forward-sexp arg)
	5894	(sp-backward-sexp)))))
	5895
	5896	(put 'sp-next-sexp 'CUA 'move)
	5897
	5898	(defun sp-previous-sexp (&optional arg)
	5899	"Move backward to the end of previous balanced expression.
	5900
	5901	With ARG, do it that many times. If there is no next
	5902	expression at current level, jump one level up (effectively
	5903	doing `sp-up-sexp'). Negative arg -N means move to the end of
	5904	N-th following balanced expression.
	5905
	5906	With `sp-navigate-consider-symbols' symbols and strings are also
	5907	considered balanced expressions.
	5908
	5909	If `sp-navigate-interactive-always-progress-point' is non-nil,
	5910	and this is called interactively, the point will move to the
	5911	first expression in backward direction where it will end up
	5912	less than the current location.
	5913
	5914	Examples:
	5915
	5916	((foo) bar\| (baz quux)) -> ((foo)\| bar (baz quux))
	5917
	5918	((foo)\| bar (baz quux)) -> ((foo) bar (baz quux))\|
	5919
	5920	and if `sp-navigate-interactive-always-progress-point' is non-nil
	5921
	5922	(foo b\|ar baz) -> (foo\| bar baz)
	5923
	5924	(foo (b\|ar baz)) -> (foo\| (bar baz))"
	5925	(interactive "^p")
	5926	(setq arg (or arg 1))
	5927	(if (<= arg 0)
	5928	(sp-forward-sexp (- arg))
	5929	(if (and sp-navigate-interactive-always-progress-point
	5930	;; (called-interactively-p 'any)
	5931	)
	5932	(progn
	5933	(while (< 0 arg)
	5934	(let ((point-start (point)))
	5935	(while (--when-let (sp-backward-sexp)
	5936	(>= (sp-get it :end) point-start))))
	5937	(setq arg (1- arg)))
	5938	(goto-char (sp-get (sp-get-thing) :end)))
	5939	(if (= arg 1)
	5940	(-when-let (ok (sp-get-thing t))
	5941	(if (= (point) (sp-get ok :end))
	5942	(progn (sp-backward-sexp 2)
	5943	(sp-forward-sexp))
	5944	(goto-char (sp-get ok :end))
	5945	ok))
	5946	(sp-backward-sexp arg)
	5947	(sp-forward-sexp)))))
	5948
	5949	(put 'sp-previous-sexp 'CUA 'move)
	5950
	5951	(defun sp-forward-parallel-sexp (&optional arg)
	5952	"Move forward across one balanced expressions at the same depth.
	5953
	5954	If calling `sp-forward-sexp' at point would result in raising a
	5955	level up, loop back to the first expression at current level,
	5956	that is the first child of the enclosing sexp as defined by
	5957	`sp-get-enclosing-sexp'."
	5958	(interactive "^p")
	5959	(setq arg (or arg 1))
	5960	(if (< arg 0)
	5961	(sp-backward-parallel-sexp (- arg))
	5962	(let (re)
	5963	(while (> arg 0)
	5964	(setq arg (1- arg))
	5965	(let ((next (sp-get-thing))
	5966	(prev (sp-get-thing t)))
	5967	(setq
	5968	re
	5969	(cond
	5970	((eq next nil)
	5971	(goto-char (point-min))
	5972	(sp-forward-sexp))
	5973	((eq prev nil)
	5974	(goto-char (sp-get next :end))
	5975	next)
	5976	(t (if (> (sp-get next :beg) (sp-get prev :beg))
	5977	(progn
	5978	(goto-char (sp-get next :end))
	5979	next)
	5980	(goto-char (sp-get next :beg-in))
	5981	(sp-forward-sexp)))))))
	5982	re)))
	5983
	5984	(defun sp-backward-parallel-sexp (&optional arg)
	5985	"Move backward across one balanced expressions at the same depth.
	5986
	5987	If calling `sp-backward-sexp' at point would result in raising a
	5988	level up, loop back to the last expression at current level, that
	5989	is the last child of the enclosing sexp as defined by
	5990	`sp-get-enclosing-sexp'."
	5991	(interactive "^p")
	5992	(setq arg (or arg 1))
	5993	(if (< arg 0)
	5994	(sp-forward-parallel-sexp (- arg))
	5995	(let (re)
	5996	(while (> arg 0)
	5997	(setq arg (1- arg))
	5998	(let ((next (sp-get-thing))
	5999	(prev (sp-get-thing t)))
	6000	(setq
	6001	re
	6002	(cond
	6003	((eq prev nil)
	6004	(goto-char (point-max))
	6005	(sp-backward-sexp))
	6006	((eq next nil)
	6007	(goto-char (sp-get prev :beg))
	6008	prev)
	6009	(t (if (< (sp-get prev :end) (sp-get next :end))
	6010	(progn
	6011	(goto-char (sp-get prev :beg))
	6012	prev)
	6013	(goto-char (sp-get prev :end-in))
	6014	(sp-backward-sexp)))))))
	6015	re)))
	6016
	6017	(defun sp--raw-argument-p (arg)
	6018	"Return t if ARG represents raw argument, that is a non-empty list."
	6019	(and (listp arg) (car arg)))
	6020
	6021	(defun sp--negate-argument (arg)
	6022	"Return the argument ARG but negated.
	6023
	6024	If the argument is a raw prefix argument (cons num nil) return a
	6025	list with its car negated. If the argument is just the - symbol,
	6026	return 1. If the argument is nil, return -1. Otherwise negate
	6027	the input number."
	6028	(cond
	6029	((sp--raw-argument-p arg) (list (- (car arg))))
	6030	((eq arg '-) 1)
	6031	((not arg) -1)
	6032	(t (- arg))))
	6033
	6034	(defun sp-down-sexp (&optional arg)
	6035	"Move forward down one level of sexp.
	6036
	6037	With ARG, do this that many times. A negative argument -N means
	6038	move backward but still go down a level.
	6039
	6040	If ARG is raw prefix argument \\[universal-argument], descend forward as much as
	6041	possible.
	6042
	6043	If ARG is raw prefix argument \\[universal-argument] \\[universal-argument], jump to the beginning of
	6044	current list.
	6045
	6046	If the point is inside sexp and there is no down expression to
	6047	descend to, jump to the beginning of current one. If moving
	6048	backwards, jump to end of current one.
	6049
	6050	Examples:
	6051
	6052	\|foo (bar (baz quux)) -> foo (\|bar (baz quux))
	6053
	6054	\|foo (bar (baz quux)) -> foo (bar (\|baz quux)) ;; 2
	6055
	6056	\|foo (bar (baz (quux) blab)) -> foo (bar (baz (\|quux) blab)) ;; \\[universal-argument]
	6057
	6058	(foo (bar baz) \|quux) -> (\|foo (bar baz) quux)
	6059
	6060	(blab foo \|(bar baz) quux) -> (\|blab foo (bar baz) quux) ;; \\[universal-argument] \\[universal-argument]"
	6061	(interactive "^P")
	6062	(let* ((raw (sp--raw-argument-p arg))
	6063	(arg (prefix-numeric-value arg))
	6064	(n (abs arg))
	6065	(ok t)
	6066	(last-point -1))
	6067	(if (and raw (= (abs arg) 16))
	6068	;; jump to the beginning/end of current list
	6069	(-when-let (enc (sp-get-enclosing-sexp))
	6070	(if (> arg 0)
	6071	(goto-char (sp-get enc :beg-in))
	6072	(goto-char (sp-get enc :end-in)))
	6073	(setq ok enc))
	6074	;; otherwise descend normally
	6075	(while (and ok (> n 0))
	6076	(setq ok (sp-get-sexp (< arg 0)))
	6077	;; if the prefix was C-u, we do not decrease n and instead set
	6078	;; it to -1 when (point) == "last ok"
	6079	(if raw
	6080	(when (= (point) last-point)
	6081	(setq n -1))
	6082	(setq n (1- n)))
	6083	(when ok
	6084	(setq last-point (point))
	6085	(if (< arg 0)
	6086	(goto-char (sp-get ok :end-in))
	6087	(goto-char (sp-get ok :beg-in))))))
	6088	ok))
	6089
	6090	(put 'sp-down-sexp 'CUA 'move)
	6091
	6092	(defun sp-backward-down-sexp (&optional arg)
	6093	"Move backward down one level of sexp.
	6094
	6095	With ARG, do this that many times. A negative argument -N means
	6096	move forward but still go down a level.
	6097
	6098	If ARG is raw prefix argument \\[universal-argument], descend backward as much as
	6099	possible.
	6100
	6101	If ARG is raw prefix argument \\[universal-argument] \\[universal-argument], jump to the end of current
	6102	list.
	6103
	6104	If the point is inside sexp and there is no down expression to
	6105	descend to, jump to the end of current one. If moving forward,
	6106	jump to beginning of current one.
	6107
	6108	Examples:
	6109
	6110	foo (bar (baz quux))\| -> foo (bar (baz quux)\|)
	6111
	6112	(bar (baz quux)) foo\| -> (bar (baz quux\|)) foo ;; 2
	6113
	6114	foo (bar (baz (quux) blab))\| -> foo (bar (baz (quux\|) blab)) ;; \\[universal-argument]
	6115
	6116	(foo\| (bar baz) quux) -> (foo (bar baz) quux\|)
	6117
	6118	(foo (bar baz) \|quux blab) -> (foo (bar baz) quux blab\|) ;; \\[universal-argument] \\[universal-argument]"
	6119	(interactive "^P")
	6120	(sp-down-sexp (sp--negate-argument arg)))
	6121
	6122	(put 'sp-backward-down-sexp 'CUA 'move)
	6123
	6124	(defun sp-beginning-of-sexp (&optional arg)
	6125	"Jump to beginning of the sexp the point is in.
	6126
	6127	The beginning is the point after the opening delimiter.
	6128
	6129	With no argument, this is the same as calling
	6130	\\[universal-argument] \\[universal-argument] `sp-down-sexp'
	6131
	6132	With ARG positive N > 1, move forward out of the current
	6133	expression, move N-2 expressions forward and move down one level
	6134	into next expression.
	6135
	6136	With ARG negative -N < 1, move backward out of the current
	6137	expression, move N-1 expressions backward and move down one level
	6138	into next expression.
	6139
	6140	With ARG raw prefix argument \\[universal-argument] move out of the current expressions
	6141	and then to the beginning of enclosing expression.
	6142
	6143	Examples:
	6144
	6145	(foo (bar baz) quux\| (blab glob)) -> (\|foo (bar baz) quux (blab glob))
	6146
	6147	(foo (bar baz\|) quux (blab glob)) -> (foo (\|bar baz) quux (blab glob))
	6148
	6149	(\|foo) (bar) (baz quux) -> (foo) (bar) (\|baz quux) ;; 3
	6150
	6151	(foo bar) (baz) (quux\|) -> (\|foo bar) (baz) (quux) ;; -3
	6152
	6153	((foo bar) (baz \|quux) blab) -> (\|(foo bar) (baz quux) blab) ;; \\[universal-argument]"
	6154	(interactive "^P")
	6155	(let* ((raw (sp--raw-argument-p arg))
	6156	(arg (prefix-numeric-value arg))
	6157	(re (cond
	6158	((and raw (= arg 4))
	6159	(sp-up-sexp)
	6160	(sp-beginning-of-sexp))
	6161	((= arg 1)
	6162	(sp-down-sexp '(16)))
	6163	((< arg 0)
	6164	(sp-backward-up-sexp)
	6165	(sp-forward-sexp (1+ arg))
	6166	(sp-down-sexp))
	6167	((> arg 0)
	6168	(sp-up-sexp)
	6169	(sp-forward-sexp (- arg 2))
	6170	(sp-down-sexp)))))
	6171	(sp--run-hook-with-args (sp-get re :op) :post-handlers 'beginning-of-sexp)
	6172	re))
	6173
	6174	(put 'sp-beginning-of-sexp 'CUA 'move)
	6175
	6176	(defun sp-end-of-sexp (&optional arg)
	6177	"Jump to end of the sexp the point is in.
	6178
	6179	The end is the point before the closing delimiter.
	6180
	6181	With no argument, this is the same as calling
	6182	\\[universal-argument] \\[universal-argument] `sp-backward-down-sexp'.
	6183
	6184	With ARG positive N > 1, move forward out of the current
	6185	expression, move N-1 expressions forward and move down backward
	6186	one level into previous expression.
	6187
	6188	With ARG negative -N < 1, move backward out of the current
	6189	expression, move N-2 expressions backward and move down backward
	6190	one level into previous expression.
	6191
	6192	With ARG raw prefix argument \\[universal-argument] move out of the current expressions
	6193	and then to the end of enclosing expression.
	6194
	6195	Examples:
	6196
	6197	(foo \|(bar baz) quux (blab glob)) -> (foo (bar baz) quux (blab glob)\|)
	6198
	6199	(foo (\|bar baz) quux (blab glob)) -> (foo (bar baz\|) quux (blab glob))
	6200
	6201	(\|foo) (bar) (baz quux) -> (foo) (bar) (baz quux\|) ;; 3
	6202
	6203	(foo bar) (baz) (quux\|) -> (foo bar\|) (baz) (quux) ;; -3
	6204
	6205	((foo \|bar) (baz quux) blab) -> ((foo bar) (baz quux) blab\|) ;; \\[universal-argument]"
	6206	(interactive "^P")
	6207	(let* ((raw (sp--raw-argument-p arg))
	6208	(arg (prefix-numeric-value arg))
	6209	(re (cond
	6210	((and raw (= arg 4))
	6211	(sp-up-sexp)
	6212	(sp-end-of-sexp))
	6213	((= arg 1)
	6214	(sp-down-sexp '(-16)))
	6215	((< arg 0)
	6216	(sp-backward-up-sexp)
	6217	(sp-forward-sexp (+ 2 arg))
	6218	(sp-backward-down-sexp))
	6219	((> arg 0)
	6220	(sp-up-sexp)
	6221	(sp-forward-sexp (1- arg))
	6222	(sp-backward-down-sexp)))))
	6223	(sp--run-hook-with-args (sp-get re :op) :post-handlers 'end-of-sexp)
	6224	re))
	6225
	6226	(put 'sp-end-of-sexp 'CUA 'move)
	6227
	6228	(defun sp-beginning-of-next-sexp (&optional arg)
	6229	"Jump to the beginning of next sexp on the same depth.
	6230
	6231	Optional argument ARG defaults to 1 and means how many times we
	6232	should repeat.
	6233
	6234	This acts exactly as `sp-beginning-of-sexp' but adds 1 to the
	6235	numeric argument.
	6236
	6237	Examples:
	6238
	6239	(f\|oo) (bar) (baz) -> (foo) (\|bar) (baz)
	6240
	6241	(f\|oo) (bar) (baz) -> (foo) (bar) (\|baz) ;; 2"
	6242	(interactive "^P")
	6243	(if (sp--raw-argument-p arg)
	6244	(sp-beginning-of-sexp arg)
	6245	(let ((arg (prefix-numeric-value arg)))
	6246	(if (> arg 0)
	6247	(sp-beginning-of-sexp (1+ arg))
	6248	(sp-beginning-of-sexp (1- arg))))))
	6249
	6250	(put 'sp-beginning-of-next-sexp 'CUA 'move)
	6251
	6252	(defun sp-beginning-of-previous-sexp (&optional arg)
	6253	"Jump to the beginning of previous sexp on the same depth.
	6254
	6255	Optional argument ARG defaults to 1 and means how many times we
	6256	should repeat.
	6257
	6258	This acts exactly as `sp-beginning-of-sexp' with negative
	6259	argument but subtracts 1 from it.
	6260
	6261	Examples:
	6262
	6263	(foo) (b\|ar) (baz) -> (\|foo) (bar) (baz)
	6264
	6265	(foo) (bar) (b\|az) -> (\|foo) (bar) (baz) ;; 2"
	6266	(interactive "^P")
	6267	(if (sp--raw-argument-p arg)
	6268	(sp-beginning-of-sexp (sp--negate-argument arg))
	6269	(let ((arg (prefix-numeric-value arg)))
	6270	(if (> arg 0)
	6271	(sp-beginning-of-sexp (- (1+ arg)))
	6272	(sp-beginning-of-sexp (- (1- arg)))))))
	6273
	6274	(put 'sp-beginning-of-previous-sexp 'CUA 'move)
	6275
	6276	(defun sp-end-of-next-sexp (&optional arg)
	6277	"Jump to the end of next sexp on the same depth.
	6278
	6279	Optional argument ARG defaults to 1 and means how many times we
	6280	should repeat.
	6281
	6282	This acts exactly as `sp-end-of-sexp' but adds 1 to the
	6283	numeric argument.
	6284
	6285	Examples:
	6286
	6287	(f\|oo) (bar) (baz) -> (foo) (bar\|) (baz)
	6288
	6289	(f\|oo) (bar) (baz) -> (foo) (bar) (baz\|) ;; 2"
	6290	(interactive "^P")
	6291	(if (sp--raw-argument-p arg)
	6292	(sp-end-of-sexp arg)
	6293	(let ((arg (prefix-numeric-value arg)))
	6294	(if (> arg 0)
	6295	(sp-end-of-sexp (1+ arg))
	6296	(sp-end-of-sexp (1- arg))))))
	6297
	6298	(put 'sp-end-of-next-sexp 'CUA 'move)
	6299
	6300	(defun sp-end-of-previous-sexp (&optional arg)
	6301	"Jump to the end of previous sexp on the same depth.
	6302
	6303	Optional argument ARG defaults to 1 and means how many times we
	6304	should repeat.
	6305
	6306	This acts exactly as `sp-end-of-sexp' with negative
	6307	argument but subtracts 1 from it.
	6308
	6309	Examples:
	6310
	6311	(foo) (b\|ar) (baz) -> (foo\|) (bar) (baz)
	6312
	6313	(foo) (bar) (b\|az) -> (foo\|) (bar) (baz) ;; 2"
	6314	(interactive "^P")
	6315	(if (sp--raw-argument-p arg)
	6316	(sp-end-of-sexp (sp--negate-argument arg))
	6317	(let ((arg (prefix-numeric-value arg)))
	6318	(if (> arg 0)
	6319	(sp-end-of-sexp (- (1+ arg)))
	6320	(sp-end-of-sexp (- (1- arg)))))))
	6321
	6322	(put 'sp-end-of-previous-sexp 'CUA 'move)
	6323
	6324	;; TODO: split the reindent code so we can call it inside strings on
	6325	;; sexps like [foo ]... We can't reindent that by default because it
	6326	;; can be a regular expression or something where the whitespace
	6327	;; matters. For now, disable reindent in strings if the sexp is not
	6328	;; the string quote itself.
	6329	(defun sp-up-sexp (&optional arg interactive)
	6330	"Move forward out of one level of parentheses.
	6331
	6332	With ARG, do this that many times. A negative argument means
	6333	move backward but still to a less deep spot.
	6334
	6335	The argument INTERACTIVE is for internal use only.
	6336
	6337	If called interactively and `sp-navigate-reindent-after-up' is
	6338	enabled for current major-mode, remove the whitespace between end
	6339	of the expression and the last \"thing\" inside the expression.
	6340
	6341	If `sp-navigate-close-if-unbalanced' is non-nil, close the
	6342	unbalanced expressions automatically.
	6343
	6344	Examples:
	6345
	6346	(foo \|(bar baz) quux blab) -> (foo (bar baz) quux blab)\|
	6347
	6348	(foo (bar \|baz) quux blab) -> (foo (bar baz) quux blab)\| ;; 2
	6349
	6350	(foo bar \|baz -> (foo bar baz)\| ;; re-indent the expression
	6351	)
	6352
	6353	(foo \|(bar baz) -> (foo)\| (bar baz) ;; close unbalanced expr."
	6354	(interactive "^p\np")
	6355	(setq arg (or arg 1))
	6356	(sp--with-case-sensitive
	6357	(let ((ok (sp-get-enclosing-sexp (abs arg))))
	6358	(if ok
	6359	(progn
	6360	(if (> arg 0)
	6361	(goto-char (sp-get ok :end))
	6362	(goto-char (sp-get ok :beg)))
	6363	(when (and (= (abs arg) 1)
	6364	(not (equal (sp-get ok :prefix) sp-comment-char))
	6365	(or (memq major-mode (assq 'always sp-navigate-reindent-after-up))
	6366	(and (memq major-mode (assq 'interactive sp-navigate-reindent-after-up))
	6367	interactive))
	6368	(or sp-navigate-reindent-after-up-in-string
	6369	(sp-get ok (not (sp-point-in-string :end-in))))
	6370	;; if the sexp to be reindented is not a string
	6371	;; but is inside a string, we should rather do
	6372	;; nothing than break semantics (in e.g. regexp
	6373	;; [...])
	6374	(let ((str (sp-point-in-string)))
	6375	(or (not str)
	6376	;; op must be the delimiter of the string we're in
	6377	(eq (sp-get ok :op)
	6378	(or (eq str t)
	6379	(char-to-string str))))))
	6380	;; TODO: this needs different indent rules for different
	6381	;; modes. Should we concern with such things? Lisp rules are
	6382	;; funny in HTML... :/
	6383	(save-excursion
	6384	(if (> arg 0)
	6385	(progn
	6386	(goto-char (sp-get ok :end-in))
	6387	(let ((prev (sp-get-thing t)))
	6388	;; if the expression is empty remove everything inside
	6389	(if (sp-compare-sexps ok prev)
	6390	(sp-get ok (delete-region :beg-in :end-in))
	6391	(when (save-excursion
	6392	(skip-chars-backward " \t\n")
	6393	(= (point) (sp-get prev :end-suf)))
	6394	(delete-region (sp-get prev :end-suf) (point))))))
	6395	(goto-char (sp-get ok :beg-in))
	6396	(let ((next (sp-get-thing)))
	6397	(if (sp-compare-sexps ok next)
	6398	(sp-get ok (delete-region :beg-in :end-in))
	6399	(when (save-excursion
	6400	(skip-chars-forward " \t\n")
	6401	(= (point) (sp-get next :beg-prf)))
	6402	(delete-region (point) (sp-get next :beg-prf)))))))))
	6403	;; on forward up, we can detect that the pair was not closed.
	6404	;; Therefore, jump sexps backwards until we hit the error, then
	6405	;; extract the opening pair and insert it at point. Only works
	6406	;; for pairs defined in `sp-pair-list'.
	6407	(when (and (> arg 0)
	6408	sp-navigate-close-if-unbalanced)
	6409	(let (active-pair)
	6410	(save-excursion
	6411	;; add support for SGML tags here
	6412	(while (sp-backward-sexp))
	6413	(sp-skip-backward-to-symbol t)
	6414	(when (sp--looking-back (sp--get-opening-regexp))
	6415	(let* ((op (match-string 0)))
	6416	(setq active-pair (assoc op sp-pair-list)))))
	6417	(when active-pair
	6418	(sp-backward-sexp)
	6419	(sp-forward-sexp)
	6420	(insert (cdr active-pair))))))
	6421	ok)))
	6422
	6423	(put 'sp-up-sexp 'CUA 'move)
	6424
	6425	(defun sp-backward-up-sexp (&optional arg interactive)
	6426	"Move backward out of one level of parentheses.
	6427
	6428	With ARG, do this that many times. A negative argument means
	6429	move forward but still to a less deep spot.
	6430
	6431	The argument INTERACTIVE is for internal use only.
	6432
	6433	If called interactively and `sp-navigate-reindent-after-up' is
	6434	enabled for current major-mode, remove the whitespace between
	6435	beginning of the expression and the first \"thing\" inside the
	6436	expression.
	6437
	6438	Examples:
	6439
	6440	(foo (bar baz) quux\| blab) -> \|(foo (bar baz) quux blab)
	6441
	6442	(foo (bar \|baz) quux blab) -> \|(foo (bar baz) quux blab) ;; 2
	6443
	6444	( -> \|(foo bar baz)
	6445	foo \|bar baz)"
	6446	(interactive "^p\np")
	6447	(setq arg (or arg 1))
	6448	(sp-up-sexp (- arg) interactive))
	6449
	6450	(put 'sp-backward-up-sexp 'CUA 'move)
	6451
	6452	(defvar sp-last-kill-whitespace nil
	6453	"Save the whitespace cleaned after the last kill.
	6454
	6455	If the next command is `sp-kill-sexp', append the whitespace
	6456	between the successive kills.")
	6457
	6458	(defun sp--kill-or-copy-region (beg end &optional dont-kill)
	6459	"Kill or copy region between BEG and END according to DONT-KILL.
	6460	If `evil-mode' is active, copying a region will also add it to the 0 register.
	6461	Additionally, if command was prefixed with a register, copy the region
	6462	to that register."
	6463	(interactive)
	6464	(let ((result
	6465	(if dont-kill
	6466	(copy-region-as-kill beg end)
	6467	(kill-region beg end))))
	6468	(when (bound-and-true-p evil-mode)
	6469	(when dont-kill
	6470	(evil-set-register ?0 (evil-get-register ?1)))
	6471	(when evil-this-register
	6472	(evil-set-register evil-this-register (evil-get-register ?1))
	6473	(setq evil-this-register nil)))
	6474	result))
	6475
	6476	(defun sp-kill-sexp (&optional arg dont-kill)
	6477	"Kill the balanced expression following point.
	6478
	6479	If point is inside an expression and there is no following
	6480	expression, kill the topmost enclosing expression.
	6481
	6482	With ARG being positive number N, repeat that many times.
	6483
	6484	With ARG being Negative number -N, repeat that many times in
	6485	backward direction.
	6486
	6487	With ARG being raw prefix \\[universal-argument], kill all the expressions from
	6488	point up until the end of current list. With raw prefix \\[negative-argument] \\[universal-argument],
	6489	kill all the expressions from beginning of current list up until
	6490	point. If point is inside a symbol, this is also killed. If
	6491	there is no expression after/before the point, just delete the
	6492	whitespace up until the closing/opening delimiter.
	6493
	6494	With ARG being raw prefix \\[universal-argument] \\[universal-argument], kill current list (the list
	6495	point is inside).
	6496
	6497	With ARG numeric prefix 0 (zero) kill the insides of the current
	6498	list, that is everything from after the opening delimiter to
	6499	before the closing delimiter.
	6500
	6501	If ARG is nil, default to 1 (kill single expression forward)
	6502
	6503	If second optional argument DONT-KILL is non-nil, save the to be
	6504	killed region in the kill ring, but do not kill the region from
	6505	buffer.
	6506
	6507	With `sp-navigate-consider-symbols', symbols and strings are also
	6508	considered balanced expressions.
	6509
	6510	Examples:
	6511
	6512	(foo \|(abc) bar) -> (foo \| bar) ;; nil, defaults to 1
	6513
	6514	(foo (bar) \| baz) -> \| ;; 2
	6515
	6516	(foo \|(bar) baz) -> \| ;; \\[universal-argument] \\[universal-argument]
	6517
	6518	(1 \|2 3 4 5 6) -> (1\|) ;; \\[universal-argument]
	6519
	6520	(1 \|2 3 4 5 6) -> (1 \| 5 6) ;; 3
	6521
	6522	(1 2 3 4 5\| 6) -> (1 2 3 \| 6) ;; -2
	6523
	6524	(1 2 3 4\| 5 6) -> (\|5 6) ;; - \\[universal-argument]
	6525
	6526	(1 2 \| ) -> (1 2\|) ;; \\[universal-argument], kill useless whitespace
	6527
	6528	(1 2 3 \|4 5 6) -> (\|) ;; 0
	6529
	6530	Note: prefix argument is shown after the example in
	6531	\"comment\". Assumes `sp-navigate-consider-symbols' equal to t."
	6532	(interactive "P")
	6533	(let* ((raw (sp--raw-argument-p arg))
	6534	(arg (prefix-numeric-value arg))
	6535	(n (abs arg))
	6536	(ok t)
	6537	(b (point-max))
	6538	(e (point)))
	6539	(cond
	6540	;; kill to the end or beginning of list
	6541	((and raw
	6542	(= n 4))
	6543	(let ((next (sp-get-thing (< arg 0)))
	6544	(enc (sp-get-enclosing-sexp)))
	6545	(if (sp-compare-sexps next enc)
	6546	(when (not dont-kill)
	6547	(let ((del (sp-get-whitespace)))
	6548	(sp-get del (delete-region :beg :end))))
	6549	(if (> arg 0)
	6550	(sp--kill-or-copy-region
	6551	(sp-get next :beg-prf) (sp-get enc :end-in) dont-kill)
	6552	(sp--kill-or-copy-region
	6553	(sp-get next :end) (sp-get enc :beg-in) dont-kill))
	6554	(when (not dont-kill)
	6555	(let ((del (sp-get-whitespace)))
	6556	(sp-get del (delete-region :beg :end)))))))
	6557	;; kill the enclosing list
	6558	((and raw
	6559	(= n 16))
	6560	(let ((lst (sp-backward-up-sexp)))
	6561	(sp-get lst (sp--kill-or-copy-region
	6562	:beg-prf :end dont-kill))))
	6563	;; kill inside of sexp
	6564	((= n 0)
	6565	(let ((e (sp-get-enclosing-sexp)))
	6566	(when e
	6567	(sp-get e (sp--kill-or-copy-region
	6568	:beg-in :end-in dont-kill)))))
	6569	;; regular kill
	6570	(t
	6571	(save-excursion
	6572	(while (and (> n 0) ok)
	6573	(setq ok (sp-forward-sexp (sp--signum arg)))
	6574	(sp-get ok
	6575	(when (< :beg-prf b) (setq b :beg-prf))
	6576	(when (> :end e) (setq e :end)))
	6577	(setq n (1- n))))
	6578	(when ok
	6579	(let ((bm (set-marker (make-marker) b)))
	6580	(if (eq last-command 'kill-region)
	6581	(progn
	6582	(when (member sp-successive-kill-preserve-whitespace '(1 2))
	6583	(kill-append sp-last-kill-whitespace nil))
	6584	(sp--kill-or-copy-region
	6585	(if (> b (point)) (point) b) e dont-kill))
	6586	(sp--kill-or-copy-region b e dont-kill))
	6587	;; kill useless junk whitespace, but only if we're actually
	6588	;; killing the region
	6589	(when (not dont-kill)
	6590	(sp--cleanup-after-kill)
	6591	;; kill useless newlines
	6592	(when (string-match-p "\n" (buffer-substring-no-properties bm (point)))
	6593	(setq sp-last-kill-whitespace
	6594	(concat sp-last-kill-whitespace
	6595	(buffer-substring-no-properties bm (point))))
	6596	(delete-region bm (point)))
	6597	(when (= 0 sp-successive-kill-preserve-whitespace)
	6598	(kill-append sp-last-kill-whitespace nil)))))))))
	6599
	6600	(defun sp--cleanup-after-kill ()
	6601	(unless (save-match-data (looking-back "^[\t\s]+" (1- (line-beginning-position))))
	6602	(let ((bdel (save-excursion
	6603	(when (sp--looking-back-p " " 1)
	6604	(skip-chars-backward " \t")
	6605	(when (not (sp--looking-back-p (sp--get-opening-regexp)))
	6606	(forward-char)))
	6607	(point)))
	6608	(edel (save-excursion
	6609	(when (looking-at " ")
	6610	(skip-chars-forward " \t")
	6611	(when (not (or (sp--looking-at (sp--get-closing-regexp))
	6612	(looking-at "$")))
	6613	(backward-char)))
	6614	(point))))
	6615	(when (eq this-command 'kill-region)
	6616	(setq sp-last-kill-whitespace
	6617	(if (/= 2 sp-successive-kill-preserve-whitespace)
	6618	(buffer-substring-no-properties bdel edel)
	6619	"")))
	6620	(delete-region bdel edel)))
	6621	(if (memq major-mode sp-lisp-modes)
	6622	;; WARNING: The above white-space killing routine might preserve
	6623	;; less whitespace than there actually is because the indent
	6624	;; might further eat some up
	6625	(indent-according-to-mode)
	6626	(unless (or (memq major-mode sp-no-reindent-after-kill-modes)
	6627	(memq indent-line-function
	6628	sp-no-reindent-after-kill-indent-line-functions))
	6629	(save-excursion
	6630	(sp--indent-region (line-beginning-position) (line-end-position)))
	6631	(when (> (save-excursion
	6632	(back-to-indentation)
	6633	(current-indentation))
	6634	(current-column))
	6635	(back-to-indentation)))))
	6636
	6637	(defun sp-backward-kill-sexp (&optional arg dont-kill)
	6638	"Kill the balanced expression preceding point.
	6639
	6640	This is exactly like calling `sp-kill-sexp' with minus ARG.
	6641	In other words, the direction of all commands is reversed. For
	6642	more information, see the documentation of `sp-kill-sexp'.
	6643
	6644	Examples:
	6645
	6646	(foo (abc)\| bar) -> (foo \| bar)
	6647
	6648	blab (foo (bar baz) quux)\| -> blab \|
	6649
	6650	(1 2 3 \|4 5 6) -> (\|4 5 6) ;; \\[universal-argument]"
	6651	(interactive "P")
	6652	(sp-kill-sexp (sp--negate-argument arg) dont-kill))
	6653
	6654	(defun sp-copy-sexp (&optional arg)
	6655	"Copy the following ARG expressions to the kill-ring.
	6656
	6657	This is exactly like calling `sp-kill-sexp' with second argument
	6658	t. All the special prefix arguments work the same way."
	6659	(interactive "P")
	6660	(save-excursion
	6661	(sp-kill-sexp arg t)))
	6662
	6663	(defun sp-backward-copy-sexp (&optional arg)
	6664	"Copy the previous ARG expressions to the kill-ring.
	6665
	6666	This is exactly like calling `sp-backward-kill-sexp' with second argument
	6667	t. All the special prefix arguments work the same way."
	6668	(interactive "P")
	6669	(save-excursion
	6670	(sp-kill-sexp (sp--negate-argument arg) t)))
	6671
	6672	(defun sp-clone-sexp ()
	6673	"Clone sexp after or around point.
	6674
	6675	If the form immediately after point is a sexp, clone it below the
	6676	current one and put the point in front of it.
	6677
	6678	Otherwise get the enclosing sexp and clone it below the current
	6679	enclosing sexp."
	6680	(interactive)
	6681	(-when-let (ok (let ((sexp (sp-get-thing)))
	6682	(if (not (equal (sp-get sexp :op) ""))
	6683	sexp
	6684	(sp-get-enclosing-sexp))))
	6685	(sp-get ok
	6686	(undo-boundary)
	6687	(if (< :beg-prf (point))
	6688	;; this is the case where point is inside a sexp, we place
	6689	;; the "clone" before the current enclosing sexp and move
	6690	;; the old one below. Note that the "net result" is the
	6691	;; same as the other case, but the implementation must
	6692	;; reflect different relative position of the point wrt
	6693	;; "current" sexp.
	6694	(save-excursion
	6695	(goto-char :beg-prf)
	6696	(insert-buffer-substring-no-properties
	6697	(current-buffer) :beg-prf :end-suf)
	6698	(newline-and-indent))
	6699	;; in this case we are in front, so we move after the current
	6700	;; one, place the clone and move it below
	6701	(goto-char :end-suf)
	6702	(save-excursion
	6703	(insert-buffer-substring-no-properties
	6704	(current-buffer) :beg-prf :end-suf))
	6705	(newline-and-indent))
	6706	(sp-indent-defun))))
	6707
	6708	(defun sp-kill-hybrid-sexp (arg)
	6709	"Kill a line as if with `kill-line', but respecting delimiters.
	6710
	6711	With ARG being raw prefix \\[universal-argument] \\[universal-argument], kill the hybrid sexp
	6712	the point is in (see `sp-get-hybrid-sexp').
	6713
	6714	With ARG numeric prefix 0 (zero) just call `kill-line'.
	6715
	6716	You can customize the behaviour of this command by toggling
	6717	`sp-hybrid-kill-excessive-whitespace'.
	6718
	6719	Examples:
	6720
	6721	foo \| bar baz -> foo \| ;; nil
	6722
	6723	foo (bar \| baz) quux -> foo (bar \|) quux ;; nil
	6724
	6725	foo \| bar (baz -> foo \| ;; nil
	6726	quux)
	6727
	6728	foo \"bar \|baz quux\" quack -> foo \"bar \|\" quack ;; nil
	6729
	6730	foo (bar
	6731	baz) qu\|ux (quack -> foo \| hoo ;; \\[universal-argument] \\[universal-argument]
	6732	zaq) hoo
	6733
	6734	foo \| (bar -> foo \| ;; C-0
	6735	baz) baz)"
	6736	(interactive "P")
	6737	(let* ((raw (sp--raw-argument-p arg))
	6738	(arg (prefix-numeric-value arg))
	6739	(orig-indent (save-excursion
	6740	(back-to-indentation)
	6741	(current-column)))
	6742	(orig-column (current-column)))
	6743	(cond
	6744	((= arg 0) (kill-line))
	6745	((and raw (= arg 16))
	6746	(let ((hl (sp-get-hybrid-sexp)))
	6747	(sp-get hl (kill-region :beg-prf :end-suf))))
	6748	(t
	6749	(let ((hl (sp-get-hybrid-sexp)))
	6750	(save-excursion
	6751	(when (and (or (eq sp-hybrid-kill-entire-symbol t)
	6752	(and (functionp sp-hybrid-kill-entire-symbol)
	6753	(not (funcall sp-hybrid-kill-entire-symbol))))
	6754	(sp-point-in-symbol))
	6755	(sp-backward-sexp))
	6756	(sp-get hl
	6757	(let ((end (min (point-max) (if (looking-at "[ \t]*$")
	6758	(1+ :end-suf)
	6759	:end-suf))))
	6760	(when sp-hybrid-kill-excessive-whitespace
	6761	(save-excursion
	6762	(goto-char end)
	6763	(skip-chars-forward "\n\t\r\s")
	6764	(cond
	6765	((eq 'kill sp-hybrid-kill-excessive-whitespace)
	6766	(setq end (point)))
	6767	(t (delete-region end (point))))))
	6768	(kill-region (point) end)))))
	6769	(sp--cleanup-after-kill)
	6770	;; if we've killed the entire line, do not contract the indent
	6771	;; to just one space
	6772	(when (sp-point-in-blank-line)
	6773	(delete-region (line-beginning-position) (line-end-position))
	6774	(if (and (= 0 orig-column)
	6775	kill-whole-line)
	6776	(delete-char 1) ;; delete the newline
	6777	(let ((need-indent (- orig-indent (current-column))))
	6778	(when (> need-indent 0)
	6779	(insert (make-string need-indent ?\ ))))))))))
	6780
	6781	(defun sp-kill-whole-line ()
	6782	"Kill current line in sexp-aware manner.
	6783
	6784	First, go to the beginning of current line and then try to kill
	6785	as much as possible on the current line but without breaking
	6786	balance.
	6787
	6788	If there is a hanging sexp at the end of line the it is killed as
	6789	well.
	6790
	6791	If there is a closing delimiter for a sexp \"up\" current sexp,
	6792	the kill is not extended after it. For more details see
	6793	`sp-kill-hybrid-sexp'.
	6794
	6795	Examples:
	6796
	6797	(progn (progn
	6798	(some \|long sexp)) -> \|)"
	6799	(interactive)
	6800	(beginning-of-line)
	6801	(sp-kill-hybrid-sexp nil)
	6802	(let ((empty-last-line (save-excursion (beginning-of-line) (eobp))))
	6803	;; We can't kill the line if it is empty and the last line
	6804	(when (and (sp-point-in-blank-line) (not empty-last-line))
	6805	(kill-whole-line))))
	6806
	6807	(defun sp--transpose-objects (first second)
	6808	"Transpose FIRST and SECOND object while preserving the
	6809	whitespace between them."
	6810	(save-excursion
	6811	(goto-char (sp-get second :beg-prf))
	6812	(let ((ins (sp-get second (delete-and-extract-region :beg-prf :end)))
	6813	(between (delete-and-extract-region (sp-get first :end) (point))))
	6814	(goto-char (sp-get first :beg-prf))
	6815	(insert ins between))))
	6816
	6817	(defun sp-transpose-sexp (&optional arg)
	6818	"Transpose the expressions around point.
	6819
	6820	The operation will move the point after the transposed block, so
	6821	the next transpose will \"drag\" it forward.
	6822
	6823	With arg positive N, apply that many times, dragging the
	6824	expression forward.
	6825
	6826	With arg negative -N, apply N times backward, pushing the word
	6827	before cursor backward. This will therefore not transpose the
	6828	expressions before and after point, but push the expression
	6829	before point over the one before it.
	6830
	6831	Examples:
	6832
	6833	foo \|bar baz -> bar foo\| baz
	6834
	6835	foo \|bar baz -> bar baz foo\| ;; 2
	6836
	6837	(foo) \|(bar baz) -> (bar baz) (foo)\|
	6838
	6839	(foo bar) -> (baz quux) ;; keeps the formatting
	6840	\|(baz quux) \|(foo bar)
	6841
	6842	foo bar baz\| -> foo baz\| bar ;; -1"
	6843	(interactive "P")
	6844	(let* ((arg (prefix-numeric-value arg))
	6845	(n (abs arg)))
	6846	;; if we're inside a symbol, we need to move out of it first
	6847	(when (> arg 0)
	6848	(when (sp-point-in-symbol)
	6849	(sp-forward-symbol)))
	6850	(while (> n 0)
	6851	(when (< arg 0) (sp-backward-sexp))
	6852	(let* ((next (save-excursion (sp-forward-sexp)))
	6853	(prev (save-excursion (goto-char (sp-get next :beg-prf)) (sp-backward-sexp))))
	6854	(sp--transpose-objects prev next)
	6855	(when (< arg 0)
	6856	(goto-char (+ (sp-get prev :beg-prf) (sp-get next :len))))
	6857	(setq n (1- n))))))
	6858
	6859	(defun sp-transpose-hybrid-sexp (&optional arg)
	6860	"Transpose the hybrid sexps around point.
	6861
	6862	`sp-backward-sexp' is used to enter the previous hybrid sexp.
	6863
	6864	With ARG numeric prefix call `transpose-lines' with this
	6865	argument.
	6866
	6867	The operation will move the point at the next line after the
	6868	transposed block if it is at the end of line already.
	6869
	6870	Examples:
	6871
	6872	foo bar baz (quux
	6873	\|baz (quux -> quack)
	6874	quack) foo bar\\n\|
	6875
	6876
	6877	[(foo) (bar) -> [(baz)
	6878	\|(baz)] (foo) (bar)\|]
	6879
	6880	foo bar baz -> quux flux
	6881	\|quux flux foo bar baz\\n\|"
	6882	(interactive "P")
	6883	(if (numberp arg)
	6884	(transpose-lines arg)
	6885	(let* ((next (save-excursion
	6886	(sp-forward-sexp)
	6887	(sp-backward-sexp)
	6888	(sp-get-hybrid-sexp)))
	6889	(prev (save-excursion
	6890	(goto-char (sp-get next :beg))
	6891	(sp-backward-sexp)
	6892	(sp-get-hybrid-sexp))))
	6893	(if (sp-compare-sexps prev next > :end)
	6894	(sp-message :invalid-context-prev)
	6895	(sp--transpose-objects prev next))
	6896	(when (looking-at "[\n\t ]+")
	6897	(forward-line)
	6898	(back-to-indentation)))))
	6899
	6900	(defun sp-push-hybrid-sexp ()
	6901	"Push the hybrid sexp after point over the following one.
	6902
	6903	`sp-forward-sexp' is used to enter the following hybrid sexp.
	6904
	6905	Examples:
	6906
	6907	\|x = big_function_call(a, \|(a,
	6908	b) b) = read_user_input()
	6909	->
	6910	(a, x = big_function_call(a,
	6911	b) = read_user_input() b)"
	6912	(interactive)
	6913	(let* ((cur (sp-get-hybrid-sexp))
	6914	(next (save-excursion
	6915	(goto-char (sp-get cur :end))
	6916	(sp-forward-sexp)
	6917	(sp-get-hybrid-sexp))))
	6918	(if (sp-compare-sexps cur next >)
	6919	(sp-message :invalid-context-cur)
	6920	(sp--transpose-objects cur next))))
	6921
	6922	;; The following two functions are inspired by "adjust-parens.el"
	6923	;; package available at
	6924	;; http://elpa.gnu.org/packages/adjust-parens-1.0.el
	6925	(defun sp-indent-adjust-sexp ()
	6926	"Add the hybrid sexp at line into previous sexp. All forms
	6927	between the two are also inserted. Specifically, if the point is
	6928	on empty line, move the closing delimiter there, so the next
	6929	typed text will become the last item of the previous sexp.
	6930
	6931	This acts similarly to `sp-add-to-previous-sexp' but with special
	6932	handling of empty lines."
	6933	(interactive)
	6934	(let* ((hsexp (sp-get-hybrid-sexp))
	6935	(prev-sexp (save-excursion
	6936	(goto-char (sp-get hsexp :beg))
	6937	(sp-get-sexp t))))
	6938	(if (not (and prev-sexp hsexp
	6939	(sp-compare-sexps prev-sexp hsexp < :end :beg)))
	6940	(sp-message :no-structure-found)
	6941	(save-excursion
	6942	(sp-get prev-sexp
	6943	(goto-char (sp-get hsexp :end))
	6944	(insert :cl)
	6945	(goto-char :end-in)
	6946	(delete-char :cl-l)))
	6947	(sp-get (sp-get-enclosing-sexp) (sp--indent-region :beg :end))
	6948	(indent-according-to-mode)
	6949	(sp--run-hook-with-args (sp-get prev-sexp :op) :post-handlers 'indent-adjust-sexp))))
	6950
	6951	(defun sp-dedent-adjust-sexp ()
	6952	"Remove the hybrid sexp at line from previous sexp. All
	6953	sibling forms after it are also removed (not deleted, just placed
	6954	outside of the enclosing list). Specifically, if the point is on
	6955	empty line followed by closing delimiter of enclosing list, move
	6956	the closing delimiter after the last item in the list.
	6957
	6958	This acts similarly to `sp-forward-barf-sexp' but with special
	6959	handling of empty lines."
	6960	(interactive)
	6961	(-when-let (enc (sp-get-enclosing-sexp))
	6962	(save-excursion
	6963	;; if we're looking at whitespace and end of sexp, move the
	6964	;; closing paren over the whitespace but after the last item
	6965	;; in the list (barf would also go before the last item)
	6966	(sp-skip-forward-to-symbol t)
	6967	(if (= (point) (sp-get enc :end-in))
	6968	(let ((prev-sexp (sp-get-thing t)))
	6969	(sp-get enc
	6970	(delete-char :cl-l)
	6971	(goto-char (sp-get prev-sexp :end))
	6972	;; see next TODO
	6973	(save-restriction
	6974	(sp--narrow-to-line)
	6975	(skip-syntax-forward " ")
	6976	(skip-syntax-forward "."))
	6977	(insert :cl)))
	6978	;; otherwise just C-u barf
	6979	(sp-skip-backward-to-symbol t)
	6980	(sp-forward-barf-sexp '(4))
	6981	;; we need to take special care of any hanging
	6982	;; punctuation. TODO: this should be a sexp suffix? HACK until
	6983	;; we fix barf to get the info.
	6984	(save-restriction
	6985	(sp-get (sp-backward-down-sexp)
	6986	(goto-char :end)
	6987	(delete-char (- :cl-l))
	6988	(sp--narrow-to-line)
	6989	(skip-syntax-forward " ")
	6990	(skip-syntax-forward ".")
	6991	(insert :cl)))
	6992	(sp-get enc (sp--indent-region :beg :end))))
	6993	(indent-according-to-mode)
	6994	(sp--run-hook-with-args (sp-get enc :op) :post-handlers 'dedent-adjust-sexp)))
	6995
	6996	;; "When the hook is called point is after the just moved closing delimiter."
	6997	;; TODO: add hook
	6998	(defun sp-slurp-hybrid-sexp ()
	6999	"Add hybrid sexp following the current list in it by moving the
	7000	closing delimiter.
	7001
	7002	This is philosophically similar to `sp-forward-slurp-sexp' but
	7003	works better in \"line-based\" languages like C or Java.
	7004
	7005	Because the structure is much looser in these languages, this
	7006	command currently does not support all the prefix argument
	7007	triggers that `sp-forward-slurp-sexp' does."
	7008	(interactive)
	7009	(let (slurped-within-line)
	7010	(-if-let* ((enc (sp-get-enclosing-sexp))
	7011	(bsexp (save-excursion
	7012	(sp-get enc (goto-char :end))
	7013	(when (sp-compare-sexps (sp-forward-sexp) enc >)
	7014	(sp-get-hybrid-sexp)))))
	7015	(save-excursion
	7016	(sp-get enc
	7017	(goto-char :end-suf)
	7018	(delete-char (- (+ :cl-l :suffix-l)))
	7019	;; TODO: move to hook
	7020	(when (sp-point-in-blank-line)
	7021	(delete-region (line-beginning-position) (1+ (line-end-position))))
	7022	(sp-forward-sexp)
	7023
	7024	(when (eq (line-number-at-pos :beg)
	7025	(line-number-at-pos :end))
	7026	(setq slurped-within-line t))
	7027	;; If we're slurping over multiple lines, include the suffix on the next line.
	7028	;; I.e. while () {\|} -> while () {\n foo(); \n}
	7029	(unless slurped-within-line
	7030	(sp-get (sp-get-hybrid-sexp) (goto-char :end-suf)))
	7031	(insert :cl :suffix))
	7032	;; TODO: move to hook
	7033	(sp-get (sp--next-thing-selection -1)
	7034	(save-excursion
	7035	(if (save-excursion
	7036	(goto-char :beg-in)
	7037	(looking-at "[ \t]*$"))
	7038	(progn
	7039	(goto-char :end-in)
	7040	(newline))
	7041	;; copy the whitespace after opening delim and put it in
	7042	;; front of the closing. This will ensure pretty { foo }
	7043	;; or {foo}
	7044	(goto-char :end-in)
	7045	(insert (buffer-substring-no-properties
	7046	:beg-in
	7047	(+ :beg-in (save-excursion
	7048	(goto-char :beg-in)
	7049	(skip-syntax-forward " ")))))))
	7050	(unless (or (looking-at "[ \t]*$")
	7051	(looking-at (sp--get-stringlike-regexp))
	7052	(looking-at (sp--get-closing-regexp))
	7053	slurped-within-line)
	7054	(newline)))
	7055	(sp-get (sp--next-thing-selection -1) (sp--indent-region :beg :end))
	7056	;; we need to call this again to get the new structure after
	7057	;; indent.
	7058	(sp--next-thing-selection -1))
	7059	(sp-message :invalid-structure)
	7060	nil)))
	7061
	7062
	7063	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
	7064	;; "paredit" operations
	7065
	7066	(defun sp-forward-slurp-sexp (&optional arg)
	7067	"Add sexp following the current list in it by moving the closing delimiter.
	7068
	7069	If the current list is the last in a parent list, extend that
	7070	list (and possibly apply recursively until we can extend a list
	7071	or end of file).
	7072
	7073	If ARG is N, apply this function that many times.
	7074
	7075	If ARG is negative -N, extend the opening pair instead (that is,
	7076	backward).
	7077
	7078	If ARG is raw prefix \\[universal-argument], extend all the way to the end of the parent list.
	7079
	7080	If both the current expression and the expression to be slurped
	7081	are strings, they are joined together.
	7082
	7083	See also `sp-slurp-hybrid-sexp' which is similar but handles
	7084	C-style syntax better.
	7085
	7086	Examples:
	7087
	7088	(foo \|bar) baz -> (foo \|bar baz)
	7089
	7090	[(foo \|bar)] baz -> [(foo \|bar) baz]
	7091
	7092	[(foo \|bar) baz] -> [(foo \|bar baz)]
	7093
	7094	((\|foo) bar baz quux) -> ((\|foo bar baz quux)) ;; with \\[universal-argument]
	7095
	7096	\"foo\| bar\" \"baz quux\" -> \"foo\| bar baz quux\""
	7097	(interactive "P")
	7098	(if (> (prefix-numeric-value arg) 0)
	7099	(let ((n (abs (prefix-numeric-value arg)))
	7100	(enc (sp-get-enclosing-sexp))
	7101	(in-comment (sp-point-in-comment))
	7102	next-thing ok)
	7103	(when enc
	7104	(save-excursion
	7105	(if (sp--raw-argument-p arg)
	7106	(progn
	7107	(goto-char (sp-get enc :end-suf))
	7108	(setq next-thing (sp-get-enclosing-sexp))
	7109	(when next-thing
	7110	(goto-char (sp-get next-thing :end-in))
	7111	(sp--run-hook-with-args (sp-get enc :op) :pre-handlers 'slurp-forward
	7112	(list :arg arg :enc enc :next-thing next-thing))
	7113	(sp-get enc (insert :cl :suffix))
	7114	(goto-char (sp-get enc :end-suf))
	7115	(delete-char (sp-get enc (- (+ :cl-l :suffix-l))))
	7116	(sp--indent-region (sp-get enc :beg-prf) (sp-get next-thing :end))
	7117	(sp--run-hook-with-args (sp-get enc :op) :post-handlers 'slurp-forward
	7118	(list :arg arg :enc enc :next-thing next-thing))))
	7119	(while (> n 0)
	7120	(goto-char (sp-get enc :end-suf))
	7121	(setq ok enc)
	7122	(setq next-thing (sp-get-thing nil))
	7123	(while (sp-compare-sexps next-thing ok <)
	7124	(goto-char (sp-get next-thing :end-suf))
	7125	(setq ok next-thing)
	7126	(setq next-thing (sp-get-thing nil)))
	7127	;; do not allow slurping into a different context from
	7128	;; inside a comment
	7129	(if (and in-comment
	7130	(save-excursion
	7131	(sp-get next-thing
	7132	(goto-char :beg)
	7133	(not (sp-point-in-comment)))))
	7134	(progn
	7135	(sp-message :cant-slurp-context)
	7136	(setq n -1))
	7137	(if ok
	7138	(progn
	7139	(if (and (equal (sp-get next-thing :cl) "\"")
	7140	(equal (sp-get ok :cl) "\""))
	7141	(progn
	7142	(sp--join-sexp ok next-thing)
	7143	(goto-char (- (sp-get next-thing :end) 2))
	7144	(plist-put enc :end (- (sp-get next-thing :end) 2)))
	7145	(let ((inner-sexp
	7146	(save-excursion
	7147	(goto-char (sp-get ok :end-in))
	7148	(sp-get-thing t))))
	7149	(delete-char (sp-get ok (- (+ :cl-l :suffix-l))))
	7150	;; this calculation corrects the absence
	7151	;; of already deleted cls
	7152	(goto-char (- (sp-get next-thing :end-suf)
	7153	(sp-get ok (+ :cl-l :suffix-l))))
	7154	;; only insert space if not inserting it
	7155	;; would merge two sexps together
	7156	(when (and (sp-get ok (/= :len-in 0))
	7157	(sp-compare-sexps
	7158	inner-sexp
	7159	(sp-get-thing t))
	7160	(= (sp-get ok :end-suf)
	7161	(sp-get next-thing :beg-prf)))
	7162	(save-excursion
	7163	(goto-char (sp-get ok :end-in))
	7164	(insert " "))))
	7165	(sp--run-hook-with-args
	7166	(sp-get enc :op) :pre-handlers 'slurp-forward
	7167	(list :arg arg :enc enc :ok ok :next-thing next-thing))
	7168	(sp-get ok (insert :cl :suffix))
	7169	(sp--indent-region (sp-get ok :beg-prf) (point))
	7170	;; HACK: update the "enc" data structure if ok==enc
	7171	(when (= (sp-get enc :beg) (sp-get ok :beg)) (plist-put enc :end (point)))
	7172	(sp--run-hook-with-args
	7173	(sp-get enc :op) :post-handlers 'slurp-forward
	7174	(list :arg arg :enc enc :ok ok :next-thing next-thing)))
	7175	(setq n (1- n)))
	7176	(sp-message :cant-slurp)
	7177	(setq n -1))))))))
	7178	(sp-backward-slurp-sexp (sp--negate-argument arg))))
	7179
	7180	(defun sp-backward-slurp-sexp (&optional arg)
	7181	"Add the sexp preceding the current list in it by moving the opening delimiter.
	7182
	7183	If the current list is the first in a parent list, extend that
	7184	list (and possibly apply recursively until we can extend a list
	7185	or beginning of file).
	7186
	7187	If arg is N, apply this function that many times.
	7188
	7189	If arg is negative -N, extend the closing pair instead (that is,
	7190	forward).
	7191
	7192	If ARG is raw prefix \\[universal-argument], extend all the way to the beginning of the parent list.
	7193
	7194	If both the current expression and the expression to be slurped
	7195	are strings, they are joined together.
	7196
	7197	Examples:
	7198
	7199	foo (bar\| baz) -> (foo bar\| baz)
	7200
	7201	foo [(bar\| baz)] -> [foo (bar\| baz)]
	7202
	7203	[foo (bar\| baz)] -> [(foo bar\| baz)]
	7204
	7205	(foo bar baz (\|quux)) -> ((foo bar baz \|quux)) ;; with \\[universal-argument]
	7206
	7207	\"foo bar\" \"baz \|quux\" -> \"foo bar baz \|quux\""
	7208	(interactive "P")
	7209	(if (> (prefix-numeric-value arg) 0)
	7210	(let ((n (abs (prefix-numeric-value arg)))
	7211	(enc (sp-get-enclosing-sexp))
	7212	(in-comment (sp-point-in-comment))
	7213	next-thing ok)
	7214	(when enc
	7215	(save-excursion
	7216	(if (sp--raw-argument-p arg)
	7217	(progn
	7218	(goto-char (sp-get enc :beg-prf))
	7219	(setq next-thing (sp-get-enclosing-sexp))
	7220	(when next-thing
	7221	(delete-char (sp-get enc (+ :op-l :prefix-l)))
	7222	(goto-char (sp-get next-thing :beg-in))
	7223	(sp--run-hook-with-args
	7224	(sp-get enc :op) :pre-handlers 'slurp-backward
	7225	(list :arg arg :enc enc :next-thing next-thing))
	7226	(sp-get enc (insert :prefix :op))
	7227	(sp--indent-region (sp-get next-thing :beg-in) (sp-get enc :end))
	7228	(sp--run-hook-with-args
	7229	(sp-get enc :op) :post-handlers 'slurp-backward
	7230	(list :arg arg :enc enc :next-thing next-thing))))
	7231	(while (> n 0)
	7232	(goto-char (sp-get enc :beg-prf))
	7233	(setq ok enc)
	7234	(setq next-thing (sp-get-thing t))
	7235	(while (sp-compare-sexps next-thing ok > :end)
	7236	(goto-char (sp-get next-thing :beg-prf))
	7237	(setq ok next-thing)
	7238	(setq next-thing (sp-get-thing t)))
	7239	;; do not allow slurping into a different context from
	7240	;; inside a comment
	7241	(if (and in-comment
	7242	(save-excursion
	7243	(sp-get next-thing
	7244	(goto-char :beg)
	7245	(not (sp-point-in-comment)))))
	7246	(progn
	7247	(sp-message :cant-slurp-context)
	7248	(setq n -1))
	7249	(if ok
	7250	(progn
	7251	(if (and (equal (sp-get next-thing :cl) "\"")
	7252	(equal (sp-get ok :cl) "\""))
	7253	(progn
	7254	(sp--join-sexp next-thing ok)
	7255	(goto-char (sp-get next-thing :beg-prf))
	7256	(plist-put enc :beg (sp-get next-thing :beg)))
	7257	(let ((inner-sexp
	7258	(save-excursion
	7259	(goto-char (sp-get ok :beg-in))
	7260	(sp-get-thing))))
	7261	(delete-char (sp-get ok (+ :op-l :prefix-l)))
	7262	(goto-char (sp-get next-thing :beg-prf))
	7263	;; only insert space if not inserting it
	7264	;; would merge two sexps together
	7265	(when (and (sp-get ok (/= :len-in 0))
	7266	(= (sp-get ok (- (sp-get inner-sexp :end)
	7267	:op-l :prefix-l))
	7268	(sp-get (sp-get-thing) :end))
	7269	(= (sp-get ok :beg-prf)
	7270	(sp-get next-thing :end-suf)))
	7271	(save-excursion
	7272	(goto-char (sp-get ok (- :beg-in :op-l :prefix-l)))
	7273	(insert " "))))
	7274	(sp--run-hook-with-args
	7275	(sp-get enc :op) :pre-handlers 'slurp-backward
	7276	(list :arg arg :enc enc :ok ok :next-thing next-thing))
	7277	(sp-get ok (insert :prefix :op))
	7278	(sp--indent-region (point) (sp-get ok :end))
	7279	;; HACK: update the "enc" data structure if ok==enc
	7280	(when (sp-compare-sexps enc ok) (plist-put enc :beg (- (point) (sp-get ok :op-l))))
	7281	(sp--run-hook-with-args
	7282	(sp-get enc :op) :post-handlers 'slurp-backward
	7283	(list :arg arg :enc enc :ok ok :next-thing next-thing)))
	7284	(setq n (1- n)))
	7285	(sp-message :cant-slurp)
	7286	(setq n -1))))))))
	7287	(sp-forward-slurp-sexp (sp--negate-argument arg))))
	7288
	7289	(defun sp-add-to-previous-sexp (&optional arg)
	7290	"Add the expression around point to the first list preceding point.
	7291
	7292	With ARG positive N add that many expressions to the preceding
	7293	list.
	7294
	7295	If ARG is raw prefix argument \\[universal-argument] add all expressions until
	7296	the end of enclosing list to the previous list.
	7297
	7298	If ARG is raw prefix argument \\[universal-argument] \\[universal-argument] add the current
	7299	list into the previous list.
	7300
	7301	Examples:
	7302
	7303	(foo bar) \|baz quux -> (foo bar \|baz) quux
	7304
	7305	(foo bar) \|baz quux -> (foo bar \|baz quux) ;; 2
	7306
	7307	(blab (foo bar) \|baz quux) -> (blab (foo bar \|baz quux)) ;; \\[universal-argument]
	7308
	7309	(foo bar) (baz \|quux) -> (foo bar (baz \|quux)) ;; \\[universal-argument] \\[universal-argument]"
	7310	(interactive "P")
	7311	(save-excursion
	7312	(cond
	7313	((equal arg '(16))
	7314	(sp-backward-up-sexp)
	7315	(sp-backward-down-sexp)
	7316	(sp-forward-slurp-sexp))
	7317	(t
	7318	(sp-backward-down-sexp)
	7319	(sp-forward-slurp-sexp arg))))
	7320	(indent-according-to-mode))
	7321
	7322	(defun sp-add-to-next-sexp (&optional arg)
	7323	"Add the expressions around point to the first list following point.
	7324
	7325	With ARG positive N add that many expressions to the following
	7326	list.
	7327
	7328	If ARG is raw prefix argument \\[universal-argument] add all expressions until
	7329	the beginning of enclosing list to the following list.
	7330
	7331	If ARG is raw prefix argument \\[universal-argument] \\[universal-argument] add the current
	7332	list into the following list.
	7333
	7334	Examples:
	7335
	7336	foo bar\| (baz quux) -> foo (bar\| baz quux)
	7337
	7338	foo bar\| (baz quux) -> (foo bar\| baz quux) ;; 2
	7339
	7340	(foo bar \|(bar quux) blab) -> ((foo bar \|bar quux) blab) ;; \\[universal-argument]
	7341
	7342	(foo \|bar) (baz quux) -> ((foo \|bar) baz quux) ;; \\[universal-argument] \\[universal-argument]"
	7343	(interactive "P")
	7344	(save-excursion
	7345	(cond
	7346	((equal arg '(16))
	7347	(sp-up-sexp)
	7348	(sp-down-sexp)
	7349	(sp-backward-slurp-sexp))
	7350	(t
	7351	(sp-down-sexp)
	7352	(sp-backward-slurp-sexp arg)))))
	7353
	7354	(defun sp-forward-barf-sexp (&optional arg)
	7355	"Remove the last sexp in the current list by moving the closing delimiter.
	7356
	7357	If ARG is positive number N, barf that many expressions.
	7358
	7359	If ARG is negative number -N, contract the opening pair instead.
	7360
	7361	If ARG is raw prefix \\[universal-argument], barf all expressions from the one after
	7362	point to the end of current list and place the point before the
	7363	closing delimiter of the list.
	7364
	7365	If the current list is empty, do nothing.
	7366
	7367	Examples: (prefix arg in comment)
	7368
	7369	(foo bar\| baz) -> (foo bar\|) baz ;; nil (defaults to 1)
	7370
	7371	(foo\| [bar baz]) -> (foo\|) [bar baz] ;; 1
	7372
	7373	(1 2 3\| 4 5 6) -> (1 2 3\|) 4 5 6 ;; \\[universal-argument] (or numeric prefix 3)
	7374
	7375	(foo bar\| baz) -> foo (bar\| baz) ;; -1"
	7376	(interactive "P")
	7377	(let* ((raw (sp--raw-argument-p arg))
	7378	(old-arg arg)
	7379	(arg (prefix-numeric-value arg)))
	7380	(if (> arg 0)
	7381	(if (sp-point-in-blank-sexp)
	7382	(sp-message :blank-sexp)
	7383	(save-excursion
	7384	(let ((enc (sp-get-enclosing-sexp)))
	7385	(sp-get enc
	7386	(cond
	7387	((and raw (= arg 4))
	7388	(sp-get (sp-get-thing t)
	7389	(goto-char :end-suf)))
	7390	(t
	7391	(goto-char :end-in)
	7392	(sp-backward-sexp arg)
	7393	(when (<= (point) :beg)
	7394	(goto-char :beg-in))))
	7395	;; we know for sure there is at least one thing in the list
	7396	(let ((back (sp-get-thing t)))
	7397	(if (sp-compare-sexps back enc)
	7398	(goto-char :beg-in)
	7399	(goto-char (sp-get back :end-suf))))
	7400	(sp--run-hook-with-args :op :pre-handlers 'barf-forward
	7401	(list :arg arg :enc enc)))
	7402	(sp-get (sp-get-enclosing-sexp)
	7403	(sp-do-move-cl (point))
	7404	(sp--indent-region :beg :end)
	7405	(sp--run-hook-with-args :op :post-handlers 'barf-forward
	7406	(list :arg arg :enc enc))))))
	7407	(sp-backward-barf-sexp (sp--negate-argument old-arg)))))
	7408
	7409	(defun sp-backward-barf-sexp (&optional arg)
	7410	"This is exactly like calling `sp-forward-barf-sexp' with minus ARG.
	7411	In other words, instead of contracting the closing pair, the
	7412	opening pair is contracted. For more information, see the
	7413	documentation of `sp-forward-barf-sexp'.
	7414
	7415	Examples:
	7416
	7417	(foo bar\| baz) -> foo (bar\| baz)
	7418
	7419	([foo bar] \|baz) -> [foo bar] (\|baz)
	7420
	7421	(1 2 3 \|4 5 6) -> 1 2 3 (\|4 5 6) ;; \\[universal-argument] (or 3)"
	7422	(interactive "P")
	7423	(let* ((raw (sp--raw-argument-p arg))
	7424	(old-arg arg)
	7425	(arg (prefix-numeric-value arg)))
	7426	(if (> arg 0)
	7427	(if (sp-point-in-blank-sexp)
	7428	(sp-message :blank-sexp)
	7429	(save-excursion
	7430	(let ((enc (sp-get-enclosing-sexp)))
	7431	(sp-get enc
	7432	(cond
	7433	((and raw (= arg 4))
	7434	(sp-get (sp-get-thing)
	7435	(goto-char :beg-prf)))
	7436	(t
	7437	(goto-char :beg-in)
	7438	(sp-forward-sexp arg)
	7439	(when (>= (point) :end)
	7440	(goto-char :end-in))))
	7441	;; we know for sure there is at least one thing in the list
	7442	(let ((next (sp-get-thing)))
	7443	(if (sp-compare-sexps next enc)
	7444	(goto-char :end-in)
	7445	(goto-char (sp-get next :beg-prf))))
	7446	(sp--run-hook-with-args :op :pre-handlers 'barf-backward
	7447	(list :arg arg :enc enc)))
	7448	(sp-get (sp-get-enclosing-sexp)
	7449	(sp-do-move-op (point))
	7450	(sp--indent-region :beg :end)
	7451	(sp--run-hook-with-args :op :post-handlers 'barf-backward
	7452	(list :arg arg :enc enc))))))
	7453	(sp-forward-barf-sexp (sp--negate-argument old-arg)))))
	7454
	7455	;; TODO: get rid of the macro anyway, it's stupid!
	7456	(defmacro sp--skip-to-symbol-1 (forward)
	7457	"Generate `sp-skip-forward-to-symbol' or `sp-skip-backward-to-symbol'."
	7458	(let ((inc (if forward '1+ '1-))
	7459	(dec (if forward '1- '1+))
	7460	(forward-fn (if forward 'forward-char 'backward-char))
	7461	(next-char-fn (if forward 'following-char 'preceding-char))
	7462	(looking (if forward 'sp--looking-at 'sp--looking-back))
	7463	(prefix-fn (if forward 'sp--get-suffix 'sp--get-prefix))
	7464	(eob-test (if forward '(eobp) '(bobp)))
	7465	(comment-bound (if forward 'cdr 'car)))
	7466	`(let ((in-comment (sp-point-in-comment))
	7467	;; HACK: if we run out of current context this might skip a
	7468	;; pair that was not allowed before. However, such a call is
	7469	;; never made in SP, so it's OK for now
	7470	(allowed-pairs (sp--get-allowed-regexp))
	7471	(allowed-open (sp--get-opening-regexp (sp--get-allowed-pair-list)))
	7472	(allowed-close (sp--get-closing-regexp (sp--get-allowed-pair-list)))
	7473	(allowed-strings (sp--get-stringlike-regexp))
	7474	(prefix nil))
	7475	(while (and (not (or ,eob-test
	7476	(and stop-after-string
	7477	(not (sp-point-in-string))
	7478	(sp-point-in-string (,dec (point))))
	7479	(and stop-at-string
	7480	(not (sp-point-in-string))
	7481	(sp-point-in-string (,inc (point))))
	7482	(and stop-inside-string
	7483	(sp-point-in-string)
	7484	(not (sp-point-in-string (,inc (point)))))
	7485	(and (,looking allowed-pairs)
	7486	(or in-comment (not (sp-point-in-comment))))
	7487	(and (,looking allowed-strings)
	7488	(or in-comment (not (sp-point-in-comment))))))
	7489	(or (member (char-syntax (,next-char-fn)) '(?< ?> ?! ?\| ?\ ?\\ ?\" ?' ?.))
	7490	(/= 0 (logand (lsh 1 20) (car (syntax-after
	7491	,(if forward
	7492	'(point)
	7493	'(1- (point)))))))
	7494	(unless in-comment (sp-point-in-comment))
	7495	;; This is the case where we are starting at
	7496	;; pair (looking at it) and there is some
	7497	;; prefix which is not recognized by syntax,
	7498	;; i.e. defined by regexp. This should only be
	7499	;; tested once in principle before the next
	7500	;; time we land on a delimiter this whole loop
	7501	;; stops based on the first branch of the `and'
	7502	;; condition in `while' so using expensive
	7503	;; functions here is not a bg deal.
	7504	(and (or (,(if forward 'sp--looking-back 'sp--looking-at)
	7505	,(if forward 'allowed-close 'allowed-open))
	7506	(,(if forward 'sp--looking-back 'sp--looking-at) allowed-strings))
	7507	(progn
	7508	(setq prefix (,prefix-fn))
	7509	(> (length prefix) 0)))))
	7510	(if (and (not in-comment)
	7511	(sp-point-in-comment))
	7512	(progn
	7513	(goto-char (,comment-bound (sp-get-comment-bounds)))
	7514	(unless ,eob-test (,forward-fn 1)))
	7515	(unless ,eob-test
	7516	(,forward-fn (max (length prefix) 1))))))))
	7517
	7518	(defun sp-skip-forward-to-symbol (&optional stop-at-string stop-after-string stop-inside-string)
	7519	"Skip whitespace and comments moving forward.
	7520
	7521	If STOP-AT-STRING is non-nil, stop before entering a string (if
	7522	not already in a string).
	7523
	7524	If STOP-AFTER-STRING is non-nil, stop after exiting a string.
	7525
	7526	If STOP-INSIDE-STRING is non-nil, stop before exiting a string.
	7527
	7528	Examples:
	7529
	7530	foo\| bar -> foo \|bar
	7531
	7532	foo\| [bar baz] -> foo \|[bar baz]"
	7533	(interactive "^")
	7534	(sp--skip-to-symbol-1 t))
	7535
	7536	(put 'sp-skip-forward-to-symbol 'CUA 'move)
	7537
	7538	(defun sp-skip-backward-to-symbol (&optional stop-at-string stop-after-string stop-inside-string)
	7539	"Skip whitespace and comments moving backward.
	7540	If STOP-AT-STRING is non-nil, stop before entering a string (if
	7541	not already in a string).
	7542
	7543	If STOP-AFTER-STRING is non-nil, stop after exiting a string.
	7544
	7545	If STOP-INSIDE-STRING is non-nil, stop before exiting a string.
	7546
	7547	Examples:
	7548
	7549	foo \|bar -> foo\| bar
	7550
	7551	[bar baz] \|foo -> [bar baz]\| foo"
	7552	(interactive "^")
	7553	(sp--skip-to-symbol-1 nil))
	7554
	7555	(put 'sp-skip-backward-to-symbol 'CUA 'move)
	7556
	7557	(defun sp-skip-into-string (&optional back)
	7558	"Move the point into the next string.
	7559
	7560	With BACK non-nil, move backwards."
	7561	(if back
	7562	(while (not (sp-point-in-string))
	7563	(backward-char))
	7564	(while (not (sp-point-in-string))
	7565	(forward-char))))
	7566
	7567	;; TODO: in ruby, "foo \|if bar" now moves correctly, but there's a
	7568	;; noticable lag before it jumps over "if". This is probably caused
	7569	;; by :skip-match handlers. Investigate!
	7570	(defun sp-forward-symbol (&optional arg)
	7571	"Move point to the next position that is the end of a symbol.
	7572
	7573	With ARG being positive number N, repeat that many times.
	7574
	7575	With ARG being Negative number -N, repeat that many times in
	7576	backward direction.
	7577
	7578	A symbol is any sequence of characters that are in either the
	7579	word constituent or symbol constituent syntax class. Current
	7580	symbol only extend to the possible opening or closing delimiter
	7581	as defined by `sp-add-pair' even if part of this delimiter
	7582	would match \"symbol\" syntax classes.
	7583
	7584	Examples:
	7585
	7586	\|foo bar baz -> foo\| bar baz
	7587
	7588	\|foo (bar (baz)) -> foo (bar\| (baz)) ;; 2
	7589
	7590	\|foo (bar (baz) quux) -> foo (bar (baz) quux\|) ;; 4"
	7591	(interactive "^p")
	7592	(setq arg (or arg 1))
	7593	(sp--with-case-sensitive
	7594	(let* ((n (abs arg))
	7595	(fw (> arg 0))
	7596	(allowed (sp--get-allowed-pair-list))
	7597	(open (sp--get-opening-regexp allowed))
	7598	(close (sp--get-closing-regexp allowed)))
	7599	(if fw
	7600	(while (> n 0)
	7601	;; First we need to get to the beginning of a symbol. This means
	7602	;; skipping all whitespace and pair delimiters until we hit
	7603	;; something in \sw or \s_
	7604	(while (cond
	7605	((eobp) nil)
	7606	((not (memq (char-syntax (following-char)) '(?w ?_)))
	7607	(forward-char)
	7608	t)
	7609	;; if allowed is empty, the regexp matches anything
	7610	;; and we go into infinite loop, cf. Issue #400
	7611	((and allowed (sp--valid-initial-delimiter-p (sp--looking-at open)))
	7612	(goto-char (match-end 0)))
	7613	((and allowed (sp--valid-initial-delimiter-p (sp--looking-at close)))
	7614	(goto-char (match-end 0)))))
	7615	(while (and (not (eobp))
	7616	(or (not allowed)
	7617	(not (or (sp--valid-initial-delimiter-p (sp--looking-at open))
	7618	(sp--valid-initial-delimiter-p (sp--looking-at close)))))
	7619	(memq (char-syntax (following-char)) '(?w ?_)))
	7620	(forward-char))
	7621	(setq n (1- n)))
	7622	(sp-backward-symbol n)))))
	7623
	7624	(put 'sp-forward-symbol 'CUA 'move)
	7625
	7626	(defun sp-backward-symbol (&optional arg)
	7627	"Move point to the next position that is the beginning of a symbol.
	7628
	7629	With ARG being positive number N, repeat that many times.
	7630
	7631	With ARG being Negative number -N, repeat that many times in
	7632	forward direction.
	7633
	7634	A symbol is any sequence of characters that are in either the word
	7635	constituent or symbol constituent syntax class. Current symbol only
	7636	extend to the possible opening or closing delimiter as defined by
	7637	`sp-add-pair' even if part of this delimiter would match \"symbol\"
	7638	syntax classes.
	7639
	7640	Examples:
	7641
	7642	foo bar\| baz -> foo \|bar baz
	7643
	7644	((foo bar) baz)\| -> ((foo \|bar) baz) ;; 2
	7645
	7646	(quux ((foo) bar) baz)\| -> (\|quux ((foo) bar) baz) ;; 4"
	7647	(interactive "^p")
	7648	(setq arg (or arg 1))
	7649	(sp--with-case-sensitive
	7650	(let ((n (abs arg))
	7651	(fw (> arg 0))
	7652	(open (sp--get-opening-regexp (sp--get-allowed-pair-list)))
	7653	(close (sp--get-closing-regexp (sp--get-allowed-pair-list))))
	7654	(if fw
	7655	(while (> n 0)
	7656	(while (cond
	7657	((bobp) nil)
	7658	((not (memq (char-syntax (preceding-char)) '(?w ?_)))
	7659	(backward-char)
	7660	t)
	7661	((sp--valid-initial-delimiter-p (sp--looking-back open))
	7662	(goto-char (match-beginning 0)))
	7663	((sp--valid-initial-delimiter-p (sp--looking-back close))
	7664	(goto-char (match-beginning 0)))))
	7665	(while (and (not (bobp))
	7666	(not (or (sp--valid-initial-delimiter-p (sp--looking-back open))
	7667	(sp--valid-initial-delimiter-p (sp--looking-back close))))
	7668	(memq (char-syntax (preceding-char)) '(?w ?_)))
	7669	(backward-char))
	7670	;; skip characters which are symbols with prefix flag
	7671	(while (and (not (eobp))
	7672	(/= 0 (logand (lsh 1 20) (car (syntax-after (point))))))
	7673	(forward-char 1))
	7674	(setq n (1- n)))
	7675	(sp-forward-symbol n)))))
	7676
	7677	(put 'sp-backward-symbol 'CUA 'move)
	7678
	7679	(defun sp-rewrap-sexp (pair &optional keep-old)
	7680	"Rewrap the enclosing expression with a different pair.
	7681
	7682	PAIR is the new enclosing pair.
	7683
	7684	If optional argument KEEP-OLD is set, keep old delimiter and wrap
	7685	with PAIR on the outside of the current expression.
	7686
	7687	When used interactively, the new pair is specified in minibuffer
	7688	by typing the opening delimiter, same way as with pair
	7689	wrapping.
	7690
	7691	When used interactively with raw prefix argument \\[universal-argument], KEEP-OLD
	7692	is set to non-nil.
	7693
	7694	Examples:
	7695
	7696	(foo \|bar baz) -> [foo \|bar baz] ;; [
	7697
	7698	(foo \|bar baz) -> [(foo \|bar baz)] ;; \\[universal-argument] ["
	7699	(interactive (list
	7700	(catch 'done
	7701	(let ((available-pairs (sp--get-pair-list-context 'wrap))
	7702	ev ac (pair-prefix ""))
	7703	(while (not ac)
	7704	(setq ev (read-event (format "Rewrap with: %s" pair-prefix) t))
	7705	(if (and (equal pair-prefix "")
	7706	(eq ev 'return))
	7707	(throw 'done nil))
	7708	(setq pair-prefix (concat pair-prefix (format-kbd-macro (vector ev))))
	7709	(unless (--any? (string-prefix-p pair-prefix (car it)) available-pairs)
	7710	(user-error "Impossible pair prefix selected: %s" pair-prefix))
	7711	(setq ac (--first (equal pair-prefix (car it)) available-pairs)))
	7712	ac))
	7713	current-prefix-arg))
	7714	(if (not pair)
	7715	(sp-unwrap-sexp)
	7716	(-when-let (enc (sp-get-enclosing-sexp))
	7717	(save-excursion
	7718	(sp-get enc
	7719	(goto-char :end)
	7720	(unless keep-old
	7721	(delete-char (- :cl-l)))
	7722	(insert (cdr pair))
	7723	(goto-char :beg)
	7724	(insert (car pair))
	7725	(unless keep-old
	7726	(delete-char :op-l))
	7727	(setq sp-last-wrapped-region
	7728	(sp--get-last-wraped-region
	7729	:beg (+ :end
	7730	(length (car pair))
	7731	(length (cdr pair))
	7732	(- :op-l)
	7733	(- :cl-l))
	7734	(car pair) (cdr pair)))))
	7735	(sp--run-hook-with-args (car pair) :post-handlers 'rewrap-sexp
	7736	(list :parent (sp-get enc :op))))))
	7737
	7738	(defun sp-swap-enclosing-sexp (&optional arg)
	7739	"Swap the enclosing delimiters of this and the parent expression.
	7740
	7741	With N > 0 numeric argument, ascend that many levels before
	7742	swapping.
	7743
	7744	Examples:
	7745
	7746	(foo [\|bar] baz) -> [foo (\|bar) baz] ;; 1
	7747
	7748	(foo {bar [\|baz] quux} quack) -> [foo {bar (\|baz) quux} quack] ;; 2"
	7749	(interactive "p")
	7750	(let ((enc (sp-get-enclosing-sexp))
	7751	(encp (sp-get-enclosing-sexp (1+ arg))))
	7752	(if (and enc encp)
	7753	(save-excursion
	7754	(sp-get encp
	7755	(goto-char :end)
	7756	(delete-char (- :cl-l)))
	7757	(sp-get enc
	7758	(insert :cl)
	7759	(goto-char :end)
	7760	(delete-char (- :cl-l)))
	7761	(sp-get encp (insert :cl))
	7762	(sp-get enc (goto-char :beg-prf))
	7763	(sp-get encp (insert :prefix :op))
	7764	(sp-get enc (delete-char (+ :op-l :prefix-l)))
	7765	(sp-get encp (goto-char :beg-prf))
	7766	(sp-get enc (insert :prefix :op))
	7767	(sp-get encp (delete-char (+ :op-l :prefix-l))))
	7768	(sp-message :point-not-deep-enough))))
	7769
	7770	(defun sp--unwrap-sexp (sexp &optional no-cleanup)
	7771	"Unwrap expression defined by SEXP.
	7772
	7773	Warning: this function remove possible empty lines and reindents
	7774	the unwrapped sexp, so the SEXP structure will no longer
	7775	represent a valid object in a buffer!"
	7776	(sp-get sexp
	7777	(delete-region :end-in :end)
	7778	(delete-region :beg-prf :beg-in))
	7779	;; if the delimiters were the only thing on the line, we should also
	7780	;; get rid of the (possible) empty line that will be the result of
	7781	;; their removal. This is especially nice in HTML mode or
	7782	;; long-running tags like \[\] in latex.
	7783	(unless no-cleanup
	7784	(let ((new-start (sp-get sexp :beg-prf))
	7785	(new-end (sp-get sexp (- :end-in :op-l :prefix-l)))
	7786	indent-from indent-to)
	7787	(save-excursion
	7788	(goto-char new-end)
	7789	(when (string-match-p "^[\n\t ]+\\'" (thing-at-point 'line))
	7790	(let ((b (bounds-of-thing-at-point 'line)))
	7791	(delete-region (car b) (cdr b))))
	7792	(setq indent-to (point))
	7793	(goto-char new-start)
	7794	(when (string-match-p "^[\n\t ]+\\'" (thing-at-point 'line))
	7795	(let ((b (bounds-of-thing-at-point 'line)))
	7796	(delete-region (car b) (cdr b))))
	7797	(setq indent-from (point)))
	7798	(unless (or (memq major-mode sp-no-reindent-after-kill-modes)
	7799	(memq indent-line-function
	7800	sp-no-reindent-after-kill-indent-line-functions))
	7801	(sp--keep-indentation
	7802	(sp--indent-region indent-from indent-to))))))
	7803
	7804	(defun sp-change-inner ()
	7805	"Change the inside of the next expression.
	7806
	7807	First, kill the inside of the next balanced expression, then move
	7808	point just after the opening delimiter.
	7809
	7810	Examples:
	7811
	7812	(f\|oo [bar] baz) -> (foo [\|] baz)
	7813
	7814	{\|'foo': 'bar'} -> {'\|': 'bar'}"
	7815	(interactive)
	7816	(-when-let (ok (sp-get-sexp))
	7817	(sp-get ok
	7818	(kill-region :beg-in :end-in)
	7819	(goto-char :beg-in))))
	7820
	7821	(defun sp-change-enclosing ()
	7822	"Change the inside of the enclosing expression.
	7823
	7824	Whitespace on both sides of the inner items is preserved if it
	7825	contains newlines. Invoking this function on a blank sexp will
	7826	wipe out remaining whitespace (see `sp-point-in-blank-sexp').
	7827
	7828	Move the point to the beginning of the original content.
	7829
	7830	Examples:
	7831
	7832	(f\|oo [bar] baz) -> (\|)
	7833
	7834	{'f\|oo': 'bar'} -> {'\|': 'bar'}"
	7835	(interactive)
	7836	(-when-let (ok (sp-get-enclosing-sexp))
	7837	(sp-get ok
	7838	(if (sp-point-in-blank-sexp)
	7839	(progn
	7840	(kill-region :beg-in :end-in)
	7841	(goto-char :beg-in))
	7842	(let ((beg (progn
	7843	(goto-char :beg-in)
	7844	(skip-chars-forward "\t\n ")
	7845	(point)))
	7846	(end (progn
	7847	(goto-char :end-in)
	7848	(skip-chars-backward "\t\n ")
	7849	(point))))
	7850	(kill-region beg end)
	7851	(goto-char beg))))))
	7852
	7853	(defun sp-unwrap-sexp (&optional arg)
	7854	"Unwrap the following expression.
	7855
	7856	With ARG N, unwrap Nth expression as returned by
	7857	`sp-forward-sexp'. If ARG is negative -N, unwrap Nth expression
	7858	backwards as returned by `sp-backward-sexp'.
	7859
	7860	Return the information about the just unwrapped expression. Note
	7861	that this structure does not represent a valid expression in the
	7862	buffer.
	7863
	7864	Examples:
	7865
	7866	\|(foo bar baz) -> \|foo bar baz
	7867
	7868	(foo bar\| baz) -> foo bar\| baz
	7869
	7870	\|(foo) (bar) (baz) -> \|(foo) bar (baz) ;; 2"
	7871	(interactive "p")
	7872	(setq arg (or arg 1))
	7873	(let ((sp-navigate-consider-symbols nil))
	7874	(let ((ok (save-excursion (sp-forward-sexp arg))))
	7875	(when ok (sp--unwrap-sexp ok))
	7876	ok)))
	7877
	7878	(defun sp-backward-unwrap-sexp (&optional arg)
	7879	"Unwrap the previous expression.
	7880
	7881	With ARG N, unwrap Nth expression as returned by
	7882	`sp-backward-sexp'. If ARG is negative -N, unwrap Nth expression
	7883	forward as returned by `sp-forward-sexp'.
	7884
	7885	Examples:
	7886
	7887	(foo bar baz)\| -> foo bar baz\|
	7888
	7889	(foo bar)\| (baz) -> foo bar\| (baz)
	7890
	7891	(foo) (bar) (baz)\| -> foo (bar) (baz) ;; 3"
	7892	(interactive "p")
	7893	(sp-unwrap-sexp (- (or arg 1))))
	7894
	7895	(defun sp-splice-sexp (&optional arg)
	7896	"Unwrap the current list.
	7897
	7898	With ARG N, unwrap Nth list as returned by applying `sp-up-sexp'
	7899	N times. This function expect positive arg.
	7900
	7901	Examples:
	7902
	7903	(foo (bar\| baz) quux) -> (foo bar\| baz quux)
	7904
	7905	(foo \|(bar baz) quux) -> foo \|(bar baz) quux
	7906
	7907	(foo (bar\| baz) quux) -> foo (bar\| baz) quux ;; 2"
	7908	(interactive "p")
	7909	(setq arg (or arg 1))
	7910	(-when-let (ok (sp-get-enclosing-sexp arg))
	7911	(if (equal ";" (sp-get ok :prefix))
	7912	(sp-get ok
	7913	(save-excursion
	7914	(goto-char :beg)
	7915	(-when-let (enc (sp-get-enclosing-sexp arg))
	7916	(sp--unwrap-sexp enc))))
	7917	(sp--unwrap-sexp ok))))
	7918
	7919	(defun sp--splice-sexp-do-killing (beg end expr &optional jump-end)
	7920	"Save the text in the region between BEG and END inside EXPR,
	7921	then delete EXPR and insert the saved text.
	7922
	7923	If optional argument JUPM-END is equal to the symbol 'end move
	7924	the point after the re-inserted text."
	7925	(let (str p)
	7926	(setq str (buffer-substring-no-properties beg end))
	7927	(delete-region (sp-get expr :beg-prf) (sp-get expr :end))
	7928	(save-excursion
	7929	(insert str)
	7930	(sp--indent-region (sp-get expr :beg-prf) (point))
	7931	(setq p (point)))
	7932	(when (eq jump-end 'end) (goto-char p))))
	7933
	7934	(defun sp-splice-sexp-killing-backward (&optional arg)
	7935	"Unwrap the current list and kill all the expressions
	7936	between start of this list and the point.
	7937
	7938	With the optional argument ARG, repeat that many times. This
	7939	argument should be positive number.
	7940
	7941	Examples:
	7942
	7943	(foo (let ((x 5)) \|(sqrt n)) bar) -> (foo \|(sqrt n) bar)
	7944
	7945	(when ok\| \|(perform-operation-1)
	7946	(perform-operation-1) -> (perform-operation-2)
	7947	(perform-operation-2))
	7948
	7949	(save-excursion -> \|(awesome-stuff-happens) ;; 2
	7950	(unless (test)
	7951	\|(awesome-stuff-happens)))
	7952
	7953	Note that to kill only the content and not the enclosing
	7954	delimiters you can use \\[universal-argument] \\[sp-backward-kill-sexp].
	7955	See `sp-backward-kill-sexp' for more information."
	7956	(interactive "p")
	7957	(while (> arg 0)
	7958	(sp-splice-sexp-killing-around '(4))
	7959	(setq arg (1- arg))))
	7960
	7961	;; TODO: write in terms of `sp-splice-sexp-killing-around'.
	7962	(defun sp-splice-sexp-killing-forward (&optional arg)
	7963	"Unwrap the current list and kill all the expressions between
	7964	the point and the end of this list.
	7965
	7966	With the optional argument ARG, repeat that many times. This
	7967	argument should be positive number.
	7968
	7969	Examples:
	7970
	7971	(a (b c\| d e) f) -> (a b c\| f)
	7972
	7973	(+ (x \|y z) w) -> (+ x\| w)
	7974
	7975	Note that to kill only the content and not the enclosing
	7976	delimiters you can use \\[universal-argument] \\[sp-kill-sexp].
	7977	See `sp-kill-sexp' for more information."
	7978	(interactive "p")
	7979	(while (> arg 0)
	7980	(let ((ok (sp-get-enclosing-sexp 1)))
	7981	(if ok
	7982	(let ((next (sp-get-thing t)))
	7983	(if (sp-compare-sexps next ok)
	7984	(sp-kill-sexp '(16))
	7985	(sp--splice-sexp-do-killing
	7986	(sp-get next :end) ;search backward
	7987	(sp-get ok :beg-in)
	7988	ok 'end)))
	7989	(setq arg -1)))
	7990	(setq arg (1- arg))))
	7991
	7992	(defun sp-splice-sexp-killing-around (&optional arg)
	7993	"Unwrap the current list and kill everything inside except next expression.
	7994
	7995	With ARG save that many next expressions. With ARG negative -N,
	7996	save that many expressions backward.
	7997
	7998	If ARG is raw prefix argument \\[universal-argument] this function behaves exactly
	7999	the same as `sp-splice-sexp-killing-backward'.
	8000
	8001	If ARG is negative raw prefix argument \\[negative-argument] \\[universal-argument] this function
	8002	behaves exactly the same as `sp-splice-sexp-killing-forward'.
	8003
	8004	Note that the behaviour with the prefix argument seems to be
	8005	reversed. This is because the backward variant is much more
	8006	common and hence deserve shorter binding.
	8007
	8008	If ARG is raw prefix argument \\[universal-argument] \\[universal-argument] raise the expression the point
	8009	is inside of. This is the same as `sp-backward-up-sexp' followed by
	8010	`sp-splice-sexp-killing-around'.
	8011
	8012	Examples:
	8013
	8014	(a b \|(c d) e f) -> \|(c d) ;; with arg = 1
	8015
	8016	(a b \|c d e f) -> \|c d ;; with arg = 2
	8017
	8018	(- (car x) \|a 3) -> (car x)\| ;; with arg = -1
	8019
	8020	(foo (bar \|baz) quux) -> \|(bar baz) ;; with arg = \\[universal-argument] \\[universal-argument]"
	8021	(interactive "P")
	8022	(cond
	8023	((equal arg '(-4))
	8024	(sp-splice-sexp-killing-forward 1))
	8025	(t
	8026	(if (equal arg '(16))
	8027	(progn
	8028	(sp-backward-up-sexp)
	8029	(setq arg 1)))
	8030	(let* (inside-comment-inside-sexp
	8031	(num-arg (prefix-numeric-value arg))
	8032	(ok ;; (sp-get-enclosing-sexp 1)
	8033	(save-excursion
	8034	(sp-skip-backward-to-symbol)
	8035	;; if the point is inside a comment, we want to
	8036	;; operate on the sexp that contains it. however,
	8037	;; if we are inside a sexp inside a comment, we
	8038	;; should operate on that instead.
	8039	(if (sp-point-in-comment)
	8040	(let ((enc (sp-get-enclosing-sexp 1))
	8041	(cb (sp-get-comment-bounds)))
	8042	(if (> (sp-get enc :beg) (car cb))
	8043	(progn
	8044	(setq inside-comment-inside-sexp t)
	8045	enc)
	8046	(goto-char (cdr cb))
	8047	;; todo: replace with something more
	8048	;; abstract
	8049	(skip-chars-forward "\t\n ")
	8050	(sp-get-enclosing-sexp 1)))
	8051	(sp-get-enclosing-sexp 1)))))
	8052	(when ok
	8053	(when (and (sp-point-in-comment)
	8054	(not inside-comment-inside-sexp))
	8055	(let ((cb (sp-get-comment-bounds)))
	8056	(goto-char (if (> num-arg 0) (car cb) (cdr cb)))))
	8057	(sp-skip-backward-to-symbol)
	8058	(-let* ((next (sp--next-thing-selection arg))
	8059	((from . to)
	8060	(cond
	8061	((and (sp-point-in-comment)
	8062	(not inside-comment-inside-sexp))
	8063	(if (> num-arg 0)
	8064	;; only extends to keep the comment if raising
	8065	;; towards the end.
	8066	(cons (car (sp-get-comment-bounds))
	8067	(sp-get next :end-suf))
	8068	(sp-get next (cons :beg-prf :end-suf))))
	8069	((and (sp-point-in-comment)
	8070	inside-comment-inside-sexp)
	8071	(sp-get next (cons :beg-prf :end-suf)))
	8072	;; If we are splicing before a comment, the
	8073	;; comment might be connected to the sexp
	8074	;; after it, so we better don't kill it. Only
	8075	;; do that if the comment is on its own line
	8076	;; though, otherwise it is connected to the
	8077	;; sexp before it.
	8078	((save-excursion
	8079	(skip-chars-forward "\t\n ")
	8080	(when (and (> num-arg 0)
	8081	(sp-point-in-comment)
	8082	(save-excursion
	8083	(skip-chars-backward "\t ")
	8084	(bolp)))
	8085	(cons (point) (sp-get next :end-suf)))))
	8086	;; similarly, if there is a comment before
	8087	;; this sexp, keep it.
	8088	((save-excursion
	8089	(sp-backward-symbol)
	8090	(when (and (> num-arg 0)
	8091	(sp-point-in-comment)
	8092	(goto-char (car (sp-get-comment-bounds)))
	8093	(> (point) (sp-get ok :beg))
	8094	(save-excursion
	8095	(skip-chars-backward "\t ")
	8096	(bolp)))
	8097	(cons (point) (sp-get next :end-suf)))))
	8098	(t (sp-get next (cons :beg-prf :end-suf))))))
	8099	(sp--splice-sexp-do-killing from to
	8100	ok (if (> num-arg 0) nil 'end))))))))
	8101
	8102	(defalias 'sp-raise-sexp 'sp-splice-sexp-killing-around)
	8103
	8104	(defun sp-convolute-sexp (&optional arg)
	8105	"Convolute balanced expressions.
	8106
	8107	Save the expressions preceding point and delete them. Then
	8108	splice the resulting expression. Wrap the current enclosing list
	8109	with the delimiters of the spliced list and insert the saved
	8110	expressions.
	8111
	8112	If point is in a symbol, move to end of symbol before convolving.
	8113
	8114	With ARG positive N, move up N lists before wrapping.
	8115
	8116	Examples:
	8117
	8118	We want to move the `while' before the `let'.
	8119
	8120	(let ((stuff 1) (while (we-are-good)
	8121	(other 2)) (let ((stuff 1)
	8122	(while (we-are-good) -> (other 2))
	8123	\|(do-thing 1) \|(do-thing 1)
	8124	(do-thing 2) (do-thing 2)
	8125	(do-thing 3))) (do-thing 3)))
	8126
	8127	(forward-char (sp-get env \|:op-l)) -> (sp-get env (forward-char \|:op-l))"
	8128	(interactive "p")
	8129	(save-excursion
	8130	(when (sp-point-in-symbol)
	8131	(sp-forward-symbol))
	8132	(when (looking-at-p " ")
	8133	(just-one-space))
	8134	(let* ((old-buffer-size (buffer-size))
	8135	(enc (sp-get-enclosing-sexp))
	8136	(inner-close (sp-get enc (delete-and-extract-region
	8137	(save-excursion
	8138	(goto-char :end-in)
	8139	(sp-backward-whitespace))
	8140	:end)))
	8141	(inner-raise (sp-get enc (delete-and-extract-region
	8142	:beg-prf
	8143	(save-excursion
	8144	(sp-forward-whitespace)))))
	8145	(whitespace (sp-get enc
	8146	;; this happens when the entire inside sexp was removed.
	8147	(when (= old-buffer-size (+ (buffer-size) :len))
	8148	(delete-and-extract-region
	8149	(save-excursion
	8150	(goto-char :beg-prf)
	8151	(max (line-beginning-position) (sp-backward-whitespace)))
	8152	:beg-prf))))
	8153	(encp (sp-get-enclosing-sexp arg)))
	8154	(sp-get encp
	8155	(goto-char :end)
	8156	(insert inner-close)
	8157	(goto-char :beg-prf)
	8158	(insert inner-raise (if whitespace whitespace ""))
	8159	(sp-get (sp-get-enclosing-sexp)
	8160	(sp--indent-region :beg :end)))))
	8161	(indent-according-to-mode))
	8162
	8163	(defun sp-absorb-sexp (&optional arg)
	8164	"Absorb previous expression.
	8165
	8166	Save the expressions preceding point and delete them. Then slurp
	8167	an expression backward and insert the saved expressions.
	8168
	8169	With ARG positive N, absorb that many expressions.
	8170
	8171	Examples:
	8172
	8173	(do-stuff 1) (save-excursion
	8174	(save-excursion -> \|(do-stuff 1)
	8175	\|(do-stuff 2)) (do-stuff 2))
	8176
	8177	foo bar (concat \|baz quux) -> (concat \|foo bar baz quux) ;; 2"
	8178	(interactive "p")
	8179	(sp-forward-whitespace)
	8180	(let* ((old (point))
	8181	(raise (progn
	8182	(sp-beginning-of-sexp)
	8183	(buffer-substring (point) old))))
	8184	(delete-region (point) old)
	8185	(sp-backward-slurp-sexp arg)
	8186	(sp-forward-whitespace)
	8187	(sp-beginning-of-sexp)
	8188	(insert raise)
	8189	(save-excursion
	8190	(sp-backward-up-sexp)
	8191	(indent-sexp)))
	8192	(sp-forward-whitespace))
	8193
	8194	(defun sp-emit-sexp (&optional arg)
	8195	"Move all expression preceding point except the first one out of the current list.
	8196
	8197	With ARG positive N, keep that many expressions from the start of
	8198	the current list.
	8199
	8200	This is similar as `sp-backward-barf-sexp' but it also drags the
	8201	first N expressions with the delimiter.
	8202
	8203	Examples:
	8204
	8205	(save-excursion (do-stuff 1)
	8206	(do-stuff 1) (do-stuff 2)
	8207	(do-stuff 2) -> (save-excursion
	8208	\|(do-stuff 3)) \|(do-stuff 3))
	8209
	8210	(while not-done-yet (execute-only-once)
	8211	(execute-only-once) -> (while not-done-yet ;; arg = 2
	8212	\|(execute-in-loop)) \|(execute-in-loop))"
	8213	(interactive "p")
	8214	(let (save-text)
	8215	(save-excursion
	8216	(sp-beginning-of-sexp)
	8217	(let* ((start (point)))
	8218	(sp-forward-sexp arg)
	8219	(sp-skip-forward-to-symbol t)
	8220	(setq save-text (buffer-substring start (point)))
	8221	(delete-region start (point))))
	8222	(save-excursion (sp-backward-barf-sexp '(4)))
	8223	(sp-down-sexp)
	8224	(insert save-text)
	8225	(save-excursion
	8226	(sp-backward-up-sexp)
	8227	(indent-sexp))))
	8228
	8229	(defun sp-extract-before-sexp (&optional arg)
	8230	"Move the expression after point before the enclosing balanced expression.
	8231
	8232	The point moves with the extracted expression.
	8233
	8234	With ARG positive N, extract N expressions after point.
	8235
	8236	With ARG negative -N, extract N expressions before point.
	8237
	8238	With ARG being raw prefix argument \\[universal-argument], extract all the expressions
	8239	up until the end of enclosing list.
	8240
	8241	If the raw prefix is negative, this behaves as \\[universal-argument] `sp-backward-barf-sexp'."
	8242	(interactive "P")
	8243	(if (equal arg '(-4))
	8244	(sp-backward-barf-sexp '(4))
	8245	(sp-select-next-thing arg)
	8246	(let ((enc (sp-get-enclosing-sexp))
	8247	save-text b e nl)
	8248	(save-excursion
	8249	;; TODO: extract this use pattern into general "get X things
	8250	;; with or without surrounding whitespace."
	8251	(setq b (region-beginning))
	8252	(setq e (region-end))
	8253	(goto-char (sp-get enc :end-in))
	8254	(if (save-excursion
	8255	(skip-chars-backward "\t ")
	8256	(bolp))
	8257	(let ((whitespace (sp-get-whitespace)))
	8258	(sp-get whitespace (when (= :beg e)
	8259	(delete-region :beg :end))))
	8260	(setq nl t))
	8261	(setq save-text (delete-and-extract-region b e))
	8262	(when nl
	8263	(let ((whitespace (sp-get-whitespace)))
	8264	(sp-get whitespace (delete-region :beg :end))))
	8265	(goto-char (sp-get enc :beg-prf))
	8266	(insert save-text "\n")
	8267	(sp-get enc (sp--indent-region :beg-prf :end)))
	8268	;; if we're at an empty line, remove it
	8269	(when (string-match-p "^[\n\t ]+\\'" (thing-at-point 'line))
	8270	(let ((b (bounds-of-thing-at-point 'line)))
	8271	(delete-region (car b) (cdr b))))
	8272	(goto-char (sp-get enc :beg-prf)))))
	8273
	8274	(defun sp-extract-after-sexp (&optional arg)
	8275	"Move the expression after point after the enclosing balanced expression.
	8276
	8277	The point moves with the extracted expression.
	8278
	8279	With ARG positive N, extract N expressions after point.
	8280
	8281	With ARG negative -N, extract N expressions before point.
	8282
	8283	With ARG being raw prefix argument \\[universal-argument], extract all the
	8284	expressions up until the end of enclosing list.
	8285
	8286	With ARG being negative raw prefix argument \\[negative-argument] \\[universal-argument], extract all the
	8287	expressions up until the start of enclosing list."
	8288	;; this is uch uglier than the "before" version, since the
	8289	;; calculations forward have to account for the deleted text. Figure
	8290	;; out a way to make it smoother.
	8291	(interactive "P")
	8292	(sp-select-next-thing arg)
	8293	(sp--with-case-sensitive
	8294	(let ((enc (sp-get-enclosing-sexp))
	8295	(dws 0) ;length of deleted whitespace
	8296	save-text b e nl)
	8297	(save-excursion
	8298	(setq b (region-beginning))
	8299	(setq e (region-end))
	8300	(goto-char (sp-get enc :end-in))
	8301	(if (save-excursion
	8302	(skip-chars-backward "\t ")
	8303	(bolp))
	8304	(let ((whitespace (sp-get-whitespace)))
	8305	(sp-get whitespace
	8306	(when (= :beg e)
	8307	(delete-region :beg :end)
	8308	(setq dws (- :end :beg)))))
	8309	(setq nl t))
	8310	(setq save-text (delete-and-extract-region b e))
	8311	(when nl
	8312	(let ((whitespace (sp-get-whitespace)))
	8313	(sp-get whitespace (delete-region :beg :end))
	8314	(sp-get whitespace (setq dws (+ dws (- :end :beg))))))
	8315	(sp-get enc (goto-char (- :end (length save-text) dws)))
	8316	(insert "\n" save-text)
	8317	(sp-get enc (sp--indent-region :beg-prf :end))
	8318	(setq e (point)))
	8319	;; if we're at an empty line, remove it
	8320	(setq dws 0) ; variable reuse, ugly :/
	8321	(when (string-match-p "^[\n\t ]+\\'" (thing-at-point 'line))
	8322	(let ((b (bounds-of-thing-at-point 'line)))
	8323	(delete-region (car b) (cdr b))
	8324	(setq dws (- (cdr b) (car b)))))
	8325	(when (sp--looking-back (sp--get-opening-regexp) nil t)
	8326	(let ((whitespace (sp-get-whitespace)))
	8327	(sp-get whitespace
	8328	(delete-region :beg :end)
	8329	(setq dws (- :end :beg)))))
	8330	(goto-char (- e dws)))))
	8331
	8332	(defun sp-forward-whitespace (&optional arg)
	8333	"Skip forward past the whitespace characters.
	8334	With non-nil ARG return number of characters skipped."
	8335	(interactive "^P")
	8336	(let ((rel-move (skip-chars-forward " \t\n")))
	8337	(if arg rel-move (point))))
	8338
	8339	(put 'sp-forward-whitespace 'CUA 'move)
	8340
	8341	(defun sp-backward-whitespace (&optional arg)
	8342	"Skip backward past the whitespace characters.
	8343	With non-nil ARG return number of characters skipped."
	8344	(interactive "^P")
	8345	(let ((rel-move (skip-chars-backward " \t\n")))
	8346	(if arg rel-move (point))))
	8347
	8348	(put 'sp-backward-whitespace 'CUA 'move)
	8349
	8350	(defun sp-split-sexp (arg)
	8351	"Split the list or string the point is on into two.
	8352
	8353	If ARG is a raw prefix \\[universal-argument] split all the sexps in current expression
	8354	in separate lists enclosed with delimiters of the current
	8355	expression.
	8356
	8357	See also setting `sp-split-sexp-always-split-as-string' which
	8358	determines how sexps inside strings are treated and also for a
	8359	discussion of how to automatically add concatenation operators to
	8360	string splitting.
	8361
	8362	Examples:
	8363
	8364	(foo bar \|baz quux) -> (foo bar) \|(baz quux)
	8365
	8366	\"foo bar \|baz quux\" -> \"foo bar\" \|\"baz quux\"
	8367
	8368	([foo \|bar baz] quux) -> ([foo] \|[bar baz] quux)
	8369
	8370	(foo bar\| baz quux) -> (foo) (bar\|) (baz) (quux) ;; \\[universal-argument]"
	8371	(interactive "P")
	8372	(cond
	8373	((equal arg '(4))
	8374	(-when-let (items (sp-get-list-items))
	8375	(let ((op (sp-get (car items) :op))
	8376	(cl (sp-get (car items) :cl))
	8377	(beg (sp-get (car items) :beg))
	8378	(end (sp-get (car items) :end)))
	8379	(!cdr items)
	8380	(setq items (nreverse items))
	8381	(save-excursion
	8382	(goto-char end)
	8383	(delete-char (- (length cl)))
	8384	(while items
	8385	(sp-get (car items)
	8386	(goto-char :end)
	8387	(insert cl)
	8388	(goto-char :beg)
	8389	(insert op))
	8390	(!cdr items))
	8391	(goto-char beg)
	8392	(delete-char (length op))))))
	8393	(t
	8394	(let ((should-split-as-string
	8395	(and sp-split-sexp-always-split-as-string
	8396	(sp-point-in-string))))
	8397	(-when-let (ok (if should-split-as-string
	8398	(save-excursion
	8399	(goto-char (1- (cdr (sp-get-quoted-string-bounds))))
	8400	(sp-get-enclosing-sexp 1))
	8401	(sp-get-enclosing-sexp 1)))
	8402	(sp-get ok
	8403	(sp--run-hook-with-args :op :pre-handlers 'split-sexp)
	8404	(if should-split-as-string
	8405	(progn
	8406	(insert :cl)
	8407	(save-excursion (insert :op)))
	8408	(forward-char (- (prog1 (sp-backward-whitespace t) (insert :cl))))
	8409	(save-excursion (sp-forward-whitespace) (insert :op)))
	8410	(sp--run-hook-with-args :op :post-handlers 'split-sexp)))))))
	8411
	8412	(defun sp--join-sexp (prev next)
	8413	"Join the expressions PREV and NEXT if they are of the same type.
	8414
	8415	The expression with smaller :beg is considered the previous one,
	8416	so the input order does not actually matter.
	8417
	8418	Return the information about resulting expression."
	8419	(if (and (sp-compare-sexps prev next equal :op)
	8420	(sp-compare-sexps prev next equal :cl))
	8421	;; if there's some prefix on the second expression, remove it.
	8422	;; We do not move it to the first expression, it is assumed
	8423	;; there's one already
	8424	(progn
	8425	(if (sp-compare-sexps prev next >)
	8426	(let ((tmp prev))
	8427	(setq prev next)
	8428	(setq next tmp)))
	8429	(sp-get next (delete-region :beg-prf :beg-in))
	8430	(sp-get prev (delete-region :end-in :end))
	8431	(list :beg (sp-get prev :beg)
	8432	:end (- (sp-get next (- :end :op-l :prefix-l)) (sp-get prev :cl-l))
	8433	:op (sp-get prev :op)
	8434	:cl (sp-get prev :cl)
	8435	:prefix (sp-get prev :prefix)))
	8436	(sp-message :different-type)))
	8437
	8438	(defun sp-join-sexp (&optional arg)
	8439	"Join the sexp before and after point if they are of the same type.
	8440
	8441	If ARG is positive N, join N expressions after the point with the
	8442	one before the point.
	8443
	8444	If ARG is negative -N, join N expressions before the point with
	8445	the one after the point.
	8446
	8447	If ARG is a raw prefix \\[universal-argument] join all the things up until the end
	8448	of current expression.
	8449
	8450	The joining stops at the first expression of different type.
	8451
	8452	Examples:
	8453
	8454	(foo bar) \|(baz) -> (foo bar \|baz)
	8455
	8456	(foo) \|(bar) (baz) -> (foo \|bar baz) ;; 2
	8457
	8458	[foo] [bar] \|[baz] -> [foo bar \|baz] ;; -2
	8459
	8460	(foo bar (baz)\| (quux) (blob bluq)) -> (foo bar (baz\| quux blob bluq)) ;; \\[universal-argument]"
	8461	(interactive "P")
	8462	(let* ((raw (sp--raw-argument-p arg))
	8463	(arg (prefix-numeric-value arg))
	8464	(n (abs arg))
	8465	(prev (save-excursion (sp-backward-sexp (sp--signum arg))))
	8466	next)
	8467	(save-excursion
	8468	(cond
	8469	((and raw (= n 4))
	8470	(setq next (sp-forward-sexp (sp--signum arg)))
	8471	(while (cond
	8472	((> arg 0)
	8473	(sp-compare-sexps next prev > :beg :end))
	8474	((< arg 0)
	8475	(sp-compare-sexps next prev < :end :beg)))
	8476	(setq prev (sp--join-sexp prev next))
	8477	(setq next (sp-forward-sexp (sp--signum arg)))))
	8478	(t (while (> n 0)
	8479	(setq next (sp-forward-sexp (sp--signum arg)))
	8480	(setq prev (sp--join-sexp prev next))
	8481	(setq n (1- n)))))
	8482	prev)))
	8483
	8484	(defun sp--next-thing-selection (&optional arg point)
	8485	"Return the bounds of selection over next thing.
	8486
	8487	See `sp-select-next-thing' for the meaning of ARG.
	8488
	8489	If POINT is non-nil, it is assumed it's a point inside the buffer
	8490	from which the selection extends, either forward or backward,
	8491	depending on the value of ARG.
	8492
	8493	The return value has the same format as `sp-get-sexp'. This does
	8494	not necessarily represent a valid balanced expression!"
	8495	(save-excursion
	8496	(let* ((raw (sp--raw-argument-p arg))
	8497	(arg (prefix-numeric-value arg))
	8498	(beg point) (end point)
	8499	(op "") (cl "")
	8500	(prefix "")
	8501	(suffix ""))
	8502	(cond
	8503	;; select up until end of list
	8504	((and raw (= arg 4))
	8505	(let ((enc (sp-get-enclosing-sexp)))
	8506	(if (not enc)
	8507	(error "No enclosing expression")
	8508	(save-excursion
	8509	(goto-char (sp-get enc :end-in))
	8510	(-when-let (ok (sp-get-thing t))
	8511	(sp-get ok
	8512	(setq end :end)
	8513	(setq cl :cl)
	8514	(setq suffix :suffix)))))
	8515	(unless point
	8516	(-when-let (ok (sp-get-thing))
	8517	(if (sp-compare-sexps ok enc)
	8518	(progn
	8519	(setq beg end)
	8520	(setq end (sp-get enc :end-in)))
	8521	(sp-get ok
	8522	(setq beg :beg)
	8523	(setq op :op)
	8524	(setq prefix :prefix)))))))
	8525	;; select up until beg of list
	8526	((and raw (= arg -4))
	8527	(let ((enc (sp-get-enclosing-sexp)))
	8528	(if (not enc)
	8529	(error "No enclosing expression")
	8530	(save-excursion
	8531	(goto-char (sp-get enc :beg-in))
	8532	(-when-let (ok (sp-get-thing))
	8533	(sp-get ok
	8534	(setq beg :beg)
	8535	(setq op :op)
	8536	(setq prefix :prefix))))))
	8537	(unless point
	8538	(-when-let (ok (sp-get-thing t))
	8539	(sp-get ok
	8540	(setq end :end)
	8541	(setq cl :cl)
	8542	(setq suffix :suffix)))))
	8543	;; select the enclosing expression
	8544	((and raw (= (abs arg) 16))
	8545	(let ((enc (sp-get-enclosing-sexp)))
	8546	(if (not enc)
	8547	(error "No enclosing expression")
	8548	(sp-get enc (setq beg :beg) (setq end :end)
	8549	(setq op :op) (setq cl :cl)
	8550	(setq prefix :prefix)
	8551	(setq suffix :suffix)))))
	8552	;; normal selection, select N expressions
	8553	((> arg 0)
	8554	(let* ((first (sp-forward-sexp))
	8555	(last first))
	8556	(setq arg (1- arg))
	8557	(setq beg (or point (sp-get first :beg)))
	8558	(while (and (> arg 0) last)
	8559	(setq last (sp-forward-sexp))
	8560	(let ((nb (sp-get last :beg))) (when (< nb beg)
	8561	(setq first last)
	8562	(setq beg nb)))
	8563	(setq arg (1- arg)))
	8564	(unless (and point (= point beg))
	8565	(sp-get first
	8566	(setq beg :beg)
	8567	(setq op :op)
	8568	(setq prefix :prefix)))
	8569	(sp-get last
	8570	(setq end :end)
	8571	(setq cl :cl)
	8572	(setq suffix :suffix))))
	8573	;; normal select, select -N expressions
	8574	((< arg 0)
	8575	(let* ((first (sp-backward-sexp))
	8576	(last first))
	8577	(setq arg (1+ arg))
	8578	(setq end (or point (sp-get first :end)))
	8579	(while (and (< arg 0) last)
	8580	(setq last (sp-backward-sexp))
	8581	(let ((ne (sp-get last :end))) (when (> ne end)
	8582	(setq first last)
	8583	(setq end ne)))
	8584	(setq arg (1+ arg)))
	8585	(sp-get last
	8586	(setq beg :beg)
	8587	(setq op :op)
	8588	(setq prefix :prefix))
	8589	(unless (and point (= point end))
	8590	(sp-get first
	8591	(setq end :end)
	8592	(setq cl :cl)
	8593	(setq suffix :suffix)))))
	8594	;; N = 0, select insides
	8595	((= arg 0)
	8596	(let ((enc (sp-get-enclosing-sexp)))
	8597	(if (not enc)
	8598	(error "No enclosing expression")
	8599	(save-excursion
	8600	(goto-char (sp-get enc :beg-in))
	8601	(-when-let (ok (sp-get-thing))
	8602	(sp-get ok
	8603	(setq beg :beg)
	8604	(setq op :op)
	8605	(setq prefix :prefix))))
	8606	(save-excursion
	8607	(goto-char (sp-get enc :end-in))
	8608	(-when-let (ok (sp-get-thing t))
	8609	(sp-get ok
	8610	(setq end :end)
	8611	(setq cl :cl)
	8612	(setq suffix :suffix))))))))
	8613	(list :beg beg :end end :op op :cl cl :prefix prefix :suffix suffix))))
	8614
	8615	(defun sp-select-next-thing (&optional arg point)
	8616	"Set active region over next thing as recognized by `sp-get-thing'.
	8617
	8618	If ARG is positive N, select N expressions forward.
	8619
	8620	If ARG is negative -N, select N expressions backward.
	8621
	8622	If ARG is a raw prefix \\[universal-argument] select all the things up until the
	8623	end of current expression.
	8624
	8625	If ARG is a raw prefix \\[universal-argument] \\[universal-argument] select the current expression (as
	8626	if doing `sp-backward-up-sexp' followed by
	8627	`sp-select-next-thing').
	8628
	8629	If ARG is number 0 (zero), select all the things inside the
	8630	current expression.
	8631
	8632	If POINT is non-nil, it is assumed it's a point inside the buffer
	8633	from which the selection extends, either forward or backward,
	8634	depending on the value of ARG.
	8635
	8636	If the currently active region contains a balanced expression,
	8637	following invocation of `sp-select-next-thing' will select the
	8638	inside of this expression . Therefore calling this function
	8639	twice with no active region will select the inside of the next
	8640	expression.
	8641
	8642	If the point is right in front of the expression any potential
	8643	prefix is ignored. For example, '\|(foo) would only select (foo)
	8644	and not include ' in the selection. If you wish to also select
	8645	the prefix, you have to move the point backwards.
	8646
	8647	With `sp-navigate-consider-symbols' symbols and strings are also
	8648	considered balanced expressions."
	8649	(interactive "P")
	8650	(let* ((selection (sp--next-thing-selection arg point))
	8651	(p (point))
	8652	(b (sp-get selection :beg))
	8653	(e (sp-get selection :end))
	8654	contracted)
	8655	;; Show a helpful error if we're trying to move beyond the
	8656	;; beginning or end of the buffer.
	8657	(when (or (null b) (null e))
	8658	(user-error (if (bobp) "At beginning of buffer" "At end of buffer")))
	8659	;; if region is active and ready to use, check if this selection
	8660	;; == old selection. If so, reselect the insides
	8661	(when (region-active-p)
	8662	(let ((rb (region-beginning))
	8663	(re (region-end)))
	8664	(when (and (sp-get selection
	8665	(or (= rb :beg)
	8666	(= rb :beg-prf)))
	8667	(= re (sp-get selection :end)))
	8668	(sp-get selection
	8669	(setq b :beg-in)
	8670	(setq e :end-in))
	8671	(setq contracted t))))
	8672	;; if we moved forward check if the old-point was in front of an
	8673	;; expression and after a prefix. If so, remove the prefix from
	8674	;; the selection
	8675	(unless (and (> (prefix-numeric-value arg) 0)
	8676	(not (sp--raw-argument-p arg))
	8677	(= b p))
	8678	(unless contracted (setq b (sp-get selection :beg-prf))))
	8679	(push-mark b t t)
	8680	(goto-char e)
	8681	selection))
	8682
	8683	(defun sp-select-previous-thing (&optional arg point)
	8684	"Set active region over ARG previous things as recognized by `sp-get-thing'.
	8685
	8686	If ARG is negative -N, select that many expressions forward.
	8687
	8688	With `sp-navigate-consider-symbols' symbols and strings are also
	8689	considered balanced expressions."
	8690	(interactive "P")
	8691	(sp-select-next-thing (sp--negate-argument arg) point))
	8692
	8693	(defun sp-select-next-thing-exchange (&optional arg point)
	8694	"Just like `sp-select-next-thing' but run `exchange-point-and-mark' afterwards."
	8695	(interactive "P")
	8696	(prog1
	8697	(sp-select-next-thing arg point)
	8698	(exchange-point-and-mark)))
	8699
	8700	(defun sp-select-previous-thing-exchange (&optional arg point)
	8701	"Just like `sp-select-previous-thing' but run `exchange-point-and-mark' afterwards."
	8702	(interactive "P")
	8703	(prog1
	8704	(sp-select-previous-thing arg point)
	8705	(exchange-point-and-mark)))
	8706
	8707	(defun sp-mark-sexp (&optional arg allow-extend)
	8708	"Set mark ARG balanced expressions from point.
	8709	The place mark goes is the same place \\[sp-forward-sexp] would
	8710	move to with the same argument.
	8711	Interactively, if this command is repeated
	8712	or (in Transient Mark mode) if the mark is active,
	8713	it marks the next ARG sexps after the ones already marked.
	8714	This command assumes point is not in a string or comment."
	8715	(interactive "P\np")
	8716	(cond ((and allow-extend
	8717	(or (and (eq last-command this-command) (mark t))
	8718	(and transient-mark-mode mark-active)))
	8719	(setq arg (if arg (prefix-numeric-value arg)
	8720	(if (< (mark) (point)) -1 1)))
	8721	(set-mark
	8722	(save-excursion
	8723	(let ((p (point)))
	8724	(goto-char (mark))
	8725	(sp-forward-sexp arg)
	8726	(unless (sp-region-ok-p p (point))
	8727	(user-error "Can not extend selection: region invalid"))
	8728	(point)))))
	8729	(t
	8730	(push-mark
	8731	(save-excursion
	8732	(sp-forward-sexp (prefix-numeric-value arg))
	8733	(point))
	8734	nil t))))
	8735
	8736	(defun sp-delete-char (&optional arg)
	8737	"Delete a character forward or move forward over a delimiter.
	8738
	8739	If on an opening delimiter, move forward into balanced expression.
	8740
	8741	If on a closing delimiter, refuse to delete unless the balanced
	8742	expression is empty, in which case delete the entire expression.
	8743
	8744	If the delimiter does not form a balanced expression, it will be
	8745	deleted normally.
	8746
	8747	With a numeric prefix argument N > 0, delete N characters forward.
	8748
	8749	With a numeric prefix argument N < 0, delete N characters backward.
	8750
	8751	With a numeric prefix argument N = 0, simply delete a character
	8752	forward, without regard for delimiter balancing.
	8753
	8754	If ARG is raw prefix argument \\[universal-argument], delete
	8755	characters forward until a closing delimiter whose deletion would
	8756	break the proper pairing is hit.
	8757
	8758	Examples:
	8759
	8760	(quu\|x \"zot\") -> (quu\| \"zot\")
	8761
	8762	(quux \|\"zot\") -> (quux \"\|zot\") -> (quux \"\|ot\")
	8763
	8764	(foo (\|) bar) -> (foo \| bar)
	8765
	8766	\|(foo bar) -> (\|foo bar)"
	8767	(interactive "P")
	8768	(sp--with-case-sensitive
	8769	(let* ((raw (sp--raw-argument-p arg))
	8770	;; if you edit 10 gigabyte files in Emacs, you're gonna have
	8771	;; a bad time.
	8772	(n (if raw 100000000
	8773	(prefix-numeric-value arg))))
	8774	(cond
	8775	((> n 0)
	8776	(while (> n 0)
	8777	(cond
	8778	((let ((ok (sp-point-in-empty-sexp)))
	8779	(when ok
	8780	(backward-char (length (car ok)))
	8781	(delete-char (+ (length (car ok)) (length (cdr ok)))))
	8782	ok)
	8783	;; make this customizable
	8784	(setq n (1- n)))
	8785	((and (sp-point-in-string)
	8786	(save-excursion (forward-char) (not (sp-point-in-string))))
	8787	(setq n 0))
	8788	((sp--looking-at (sp--get-opening-regexp (sp--get-pair-list-context 'navigate)))
	8789	(-if-let (thing (save-match-data (sp-get-thing)))
	8790	(cond
	8791	((= (sp-get thing :end-in) (point))
	8792	(setq n 0))
	8793	((= (sp-get thing :beg) (point))
	8794	(goto-char (sp-get thing :beg-in)))
	8795	(t
	8796	(delete-char (length (match-string 0)))))
	8797	(delete-char (length (match-string 0))))
	8798	;; make this customizable
	8799	(setq n (1- n)))
	8800	((and (not (sp-point-in-string))
	8801	(save-excursion (forward-char) (sp-point-in-string)))
	8802	(forward-char)
	8803	;; make this customizable
	8804	(setq n (1- n)))
	8805	((sp--looking-at (sp--get-closing-regexp (sp--get-pair-list-context 'navigate)))
	8806	(if (save-match-data (sp-get-thing))
	8807	;; make this customizable -- maybe we want to skip and
	8808	;; continue deleting
	8809	(setq n 0)
	8810	(delete-char (length (match-string 0)))
	8811	(setq n (1- n))))
	8812	((bound-and-true-p hungry-delete-mode)
	8813	(hungry-delete-forward 1)
	8814	(setq n (1- n)))
	8815	(t
	8816	(delete-char 1)
	8817	(setq n (1- n))))))
	8818	((= n 0) (delete-char 1))
	8819	(t (sp-backward-delete-char (sp--negate-argument arg)))))))
	8820
	8821	(defun sp-backward-delete-char (&optional arg)
	8822	"Delete a character backward or move backward over a delimiter.
	8823
	8824	If on a closing delimiter, move backward into balanced expression.
	8825
	8826	If on a opening delimiter, refuse to delete unless the balanced
	8827	expression is empty, in which case delete the entire expression.
	8828
	8829	If the delimiter does not form a balanced expression, it will be
	8830	deleted normally.
	8831
	8832	With a numeric prefix argument N > 0, delete N characters backward.
	8833
	8834	With a numeric prefix argument N < 0, delete N characters forward.
	8835
	8836	With a numeric prefix argument N = 0, simply delete a character
	8837	backward, without regard for delimiter balancing.
	8838
	8839	If ARG is raw prefix argument \\[universal-argument], delete
	8840	characters backward until a opening delimiter whose deletion would
	8841	break the proper pairing is hit.
	8842
	8843	Examples:
	8844
	8845	(\"zot\" q\|uux) -> (\"zot\" \|uux)
	8846
	8847	(\"zot\"\| quux) -> (\"zot\|\" quux) -> (\"zo\|\" quux)
	8848
	8849	(foo (\|) bar) -> (foo \| bar)
	8850
	8851	(foo bar)\| -> (foo bar\|)"
	8852	(interactive "P")
	8853	(if (and sp-autodelete-wrap
	8854	(eq sp-last-operation 'sp-wrap-region))
	8855	(sp-backward-unwrap-sexp)
	8856	(sp--with-case-sensitive
	8857	(let* ((raw (sp--raw-argument-p arg))
	8858	;; if you edit 10 gigabyte files in Emacs, you're gonna have
	8859	;; a bad time.
	8860	(n (if raw 100000000
	8861	(prefix-numeric-value arg))))
	8862	(cond
	8863	((> n 0)
	8864	(while (> n 0)
	8865	(cond
	8866	((let ((ok (sp-point-in-empty-sexp)))
	8867	(when ok
	8868	(backward-char (length (car ok)))
	8869	(delete-char (+ (length (car ok)) (length (cdr ok)))))
	8870	ok)
	8871	;; make this customizable
	8872	(setq n (1- n)))
	8873	((and (sp-point-in-string)
	8874	(save-excursion (backward-char) (not (sp-point-in-string))))
	8875	(setq n 0))
	8876	((sp--looking-back (sp--get-closing-regexp (sp--get-pair-list-context 'navigate)))
	8877	(-if-let (thing (save-match-data (sp-get-thing t)))
	8878	(cond
	8879	((= (sp-get thing :end) (point))
	8880	(goto-char (sp-get thing :end-in)))
	8881	((= (sp-get thing :beg-in) (point))
	8882	(setq n 0))
	8883	(t
	8884	(delete-char (- (length (match-string 0))))))
	8885	(delete-char (- (length (match-string 0)))))
	8886	;; make this customizable
	8887	(setq n (1- n)))
	8888	((and (not (sp-point-in-string))
	8889	(save-excursion (backward-char) (sp-point-in-string)))
	8890	(backward-char)
	8891	;; make this customizable
	8892	(setq n (1- n)))
	8893	((sp--looking-back (sp--get-opening-regexp (sp--get-pair-list-context 'navigate)))
	8894	(if (save-match-data (sp-get-thing t))
	8895	;; make this customizable -- maybe we want to skip and
	8896	;; continue deleting
	8897	(setq n 0)
	8898	(delete-char (- (length (match-string 0))))
	8899	(setq n (1- n))))
	8900	((bound-and-true-p hungry-delete-mode)
	8901	(hungry-delete-backward 1)
	8902	(setq n (1- n)))
	8903	(t
	8904	(delete-char -1)
	8905	(setq n (1- n))))))
	8906	((= n 0) (delete-char -1))
	8907	(t (sp-delete-char (sp--negate-argument arg))))))))
	8908
	8909	(put 'sp-backward-delete-char 'delete-selection 'supersede)
	8910	(put 'sp-delete-char 'delete-selection 'supersede)
	8911
	8912	(defun sp-point-in-empty-sexp (&optional pos)
	8913	"Return non-nil if point is in empty sexp or string.
	8914
	8915	The return value is active cons pair of opening and closing sexp
	8916	delimiter enclosing this sexp."
	8917	(setq pos (or pos (point)))
	8918	(let (op act)
	8919	(cond
	8920	((sp--looking-back (sp--get-opening-regexp (sp--get-pair-list-context 'navigate)))
	8921	(setq op (match-string 0))
	8922	(setq act (--first (equal (car it) op) sp-pair-list))
	8923	(when (sp--looking-at (regexp-quote (cdr act))) act))
	8924	((sp-point-in-empty-string pos)))))
	8925
	8926	(defun sp-point-in-empty-string (&optional pos)
	8927	"Return non-nil if point is in empty string.
	8928
	8929	The return value is actually cons pair of opening and closing
	8930	string delimiter enclosing this string."
	8931	(setq pos (or pos (point)))
	8932	(when (and (sp-point-in-string)
	8933	(save-excursion (if (= (point-max) (point))
	8934	t
	8935	(forward-char) (not (sp-point-in-string))))
	8936	(save-excursion (backward-char) (not (sp-point-in-string))))
	8937	(save-excursion
	8938	(let* ((syntax (nth 3 (syntax-ppss pos)))
	8939	(c (char-to-string (if (eq syntax t) (following-char) syntax))))
	8940	(cons c c)))))
	8941
	8942	(defun sp--use-subword ()
	8943	"Return non-nil if word killing commands should kill subwords.
	8944	This is the case if `subword-mode' is enabled and
	8945	`sp-use-subword' is non-nil."
	8946	(and sp-use-subword (bound-and-true-p subword-mode)))
	8947
	8948	(defun sp--kill-word (&optional n)
	8949	"Kill N words or subwords."
	8950	(let ((n (or n 1)))
	8951	(if (sp--use-subword)
	8952	(subword-kill n)
	8953	(kill-word n))))
	8954
	8955	(defun sp--forward-word (&optional n)
	8956	"Move forward N words or subwords."
	8957	(let ((n (or n 1)))
	8958	(if (sp--use-subword)
	8959	(subword-forward n)
	8960	(forward-word n))))
	8961
	8962	(defun sp--backward-word (&optional n)
	8963	"Move backward N words or subwords."
	8964	(let ((n (or n 1)))
	8965	(if (sp--use-subword)
	8966	(subword-backward n)
	8967	(backward-word n))))
	8968
	8969	(defun sp-kill-symbol (&optional arg word)
	8970	"Kill a symbol forward, skipping over any intervening delimiters.
	8971
	8972	With ARG being positive number N, repeat that many times.
	8973
	8974	With ARG being Negative number -N, repeat that many times in
	8975	backward direction.
	8976
	8977	See `sp-forward-symbol' for what constitutes a symbol."
	8978	(interactive "p")
	8979	(sp--with-case-sensitive
	8980	(if (> arg 0)
	8981	(while (> arg 0)
	8982	(-when-let (s (sp-get-symbol))
	8983	(sp-get s
	8984	(let* ((beg
	8985	(if (< :beg-prf (point))
	8986	(if word (point) :beg)
	8987	(if (= (save-excursion
	8988	(sp-skip-forward-to-symbol)
	8989	(point))
	8990	:beg-prf)
	8991	(point)
	8992	:beg-prf)))
	8993	(end (if word
	8994	(let ((fw-end
	8995	(save-excursion
	8996	(sp--forward-word)
	8997	(point))))
	8998	(if (sp-region-ok-p beg fw-end)
	8999	fw-end
	9000	:end-suf))
	9001	:end-suf)))
	9002	(goto-char beg)
	9003	(kill-region beg end))))
	9004	(sp--cleanup-after-kill)
	9005	(setq arg (1- arg)))
	9006	(sp-backward-kill-symbol (sp--negate-argument arg) word))))
	9007
	9008	(defun sp-kill-word (&optional arg)
	9009	"Kill a word forward, skipping over intervening delimiters.
	9010
	9011	With ARG being positive number N, repeat that many times.
	9012
	9013	With ARG being Negative number -N, repeat that many times in
	9014	backward direction."
	9015	(interactive "p")
	9016	(sp-kill-symbol arg t))
	9017
	9018	(defun sp-delete-symbol (&optional arg word)
	9019	"Delete a symbol forward, skipping over any intervening delimiters.
	9020
	9021	Deleted symbol does not go to the clipboard or kill ring.
	9022
	9023	With ARG being positive number N, repeat that many times.
	9024
	9025	With ARG being Negative number -N, repeat that many times in
	9026	backward direction.
	9027
	9028	See `sp-forward-symbol' for what constitutes a symbol."
	9029	(interactive "p")
	9030	(let* ((kill-ring kill-ring)
	9031	(select-enable-clipboard nil))
	9032	(sp-kill-symbol arg word)))
	9033
	9034	(defun sp-delete-word (&optional arg)
	9035	"Delete a word forward, skipping over intervening delimiters.
	9036
	9037	Deleted word does not go to the clipboard or kill ring.
	9038
	9039	With ARG being positive number N, repeat that many times.
	9040
	9041	With ARG being Negative number -N, repeat that many times in
	9042	backward direction."
	9043	(interactive "p")
	9044	(sp-delete-symbol arg t))
	9045
	9046	(defun sp-backward-kill-symbol (&optional arg word)
	9047	"Kill a symbol backward, skipping over any intervening delimiters.
	9048
	9049	With ARG being positive number N, repeat that many times.
	9050
	9051	With ARG being Negative number -N, repeat that many times in
	9052	forward direction.
	9053
	9054	See `sp-backward-symbol' for what constitutes a symbol."
	9055	(interactive "p")
	9056	(sp--with-case-sensitive
	9057	(if (> arg 0)
	9058	(while (> arg 0)
	9059	(-when-let (s (sp-get-symbol t))
	9060	(sp-get s
	9061	(let* ((end
	9062	(if (< (point) :end-suf)
	9063	(if word (point) :end-suf)
	9064	(if (= (save-excursion
	9065	(sp-skip-backward-to-symbol)
	9066	(point))
	9067	:end-suf)
	9068	(point)
	9069	:end-suf)))
	9070	(beg (if word
	9071	(let ((bw-start
	9072	(save-excursion
	9073	(sp--backward-word)
	9074	(point))))
	9075	(if (sp-region-ok-p bw-start end)
	9076	bw-start
	9077	:beg-prf))
	9078	:beg-prf)))
	9079	(goto-char end)
	9080	(kill-region end beg))))
	9081	(sp--cleanup-after-kill)
	9082	(setq arg (1- arg)))
	9083	(sp-kill-symbol (sp--negate-argument arg) word))))
	9084
	9085	(defun sp-backward-kill-word (&optional arg)
	9086	"Kill a word backward, skipping over intervening delimiters.
	9087
	9088	With ARG being positive number N, repeat that many times.
	9089
	9090	With ARG being Negative number -N, repeat that many times in
	9091	backward direction."
	9092	(interactive "p")
	9093	(sp-backward-kill-symbol arg t))
	9094
	9095	(defun sp-backward-delete-symbol (&optional arg word)
	9096	"Delete a symbol backward, skipping over any intervening delimiters.
	9097
	9098	Deleted symbol does not go to the clipboard or kill ring.
	9099
	9100	With ARG being positive number N, repeat that many times.
	9101
	9102	With ARG being Negative number -N, repeat that many times in
	9103	forward direction.
	9104
	9105	See `sp-backward-symbol' for what constitutes a symbol."
	9106	(interactive "p")
	9107	(let* ((kill-ring kill-ring)
	9108	(select-enable-clipboard nil))
	9109	(sp-backward-kill-symbol arg word)))
	9110
	9111	(defun sp-backward-delete-word (&optional arg)
	9112	"Delete a word backward, skipping over intervening delimiters.
	9113
	9114	Deleted word does not go to the clipboard or kill ring.
	9115
	9116	With ARG being positive number N, repeat that many times.
	9117
	9118	With ARG being Negative number -N, repeat that many times in
	9119	backward direction."
	9120	(interactive "p")
	9121	(sp-backward-delete-symbol arg t))
	9122
	9123	(defun sp-delete-region (beg end)
	9124	"Delete the text between point and mark, like `delete-region'.
	9125
	9126	BEG and END are the bounds of region to be deleted.
	9127
	9128	If that text is unbalanced, signal an error instead.
	9129	With a prefix argument, skip the balance check."
	9130	(interactive "r")
	9131	(when (or current-prefix-arg
	9132	(sp-region-ok-p beg end)
	9133	(user-error (sp-message :unbalanced-region :return)))
	9134	(setq this-command 'delete-region)
	9135	(delete-region beg end)))
	9136
	9137	(defun sp-kill-region (beg end)
	9138	"Kill the text between point and mark, like `kill-region'.
	9139
	9140	BEG and END are the bounds of region to be killed.
	9141
	9142	If that text is unbalanced, signal an error instead.
	9143	With a prefix argument, skip the balance check."
	9144	(interactive "r")
	9145	(when (or current-prefix-arg
	9146	(sp-region-ok-p beg end)
	9147	(user-error (sp-message :unbalanced-region :return)))
	9148	(setq this-command 'kill-region)
	9149	(kill-region beg end)))
	9150
	9151	(defun sp-indent-defun (&optional arg)
	9152	"Reindent the current defun.
	9153
	9154	If point is inside a string or comment, fill the current
	9155	paragraph instead, and with ARG, justify as well.
	9156
	9157	Otherwise, reindent the current defun, and adjust the position
	9158	of the point."
	9159	(interactive "P")
	9160	(if (sp-point-in-string-or-comment)
	9161	(fill-paragraph arg)
	9162	(let ((column (current-column))
	9163	(indentation (sp--current-indentation)))
	9164	(save-excursion
	9165	(end-of-defun)
	9166	(beginning-of-defun)
	9167	(indent-sexp))
	9168	(sp--back-to-indentation column indentation))))
	9169
	9170	(cl-defun sp-region-ok-p (start end)
	9171	"Test if region between START and END is balanced.
	9172
	9173	A balanced region is one where all opening delimiters are matched
	9174	by closing delimiters.
	9175
	9176	This function does not check that the delimiters are correctly
	9177	ordered, that is [(]) is correct even though it is not logically
	9178	properly balanced."
	9179	(interactive "r")
	9180	(save-excursion
	9181	(save-restriction
	9182	(when (eq (sp-point-in-string start) (sp-point-in-string end))
	9183	(narrow-to-region start end)
	9184	(let ((regex (sp--get-allowed-regexp (-difference sp-pair-list (sp--get-allowed-pair-list)))))
	9185	(goto-char (point-min))
	9186	(while (or (prog1 (sp-forward-sexp)
	9187	(sp-skip-forward-to-symbol))
	9188	;; skip impossible delimiters
	9189	(when (looking-at-p regex)
	9190	(goto-char (match-end 0)))))
	9191	(looking-at-p "[[:blank:]\n]*\\'"))))))
	9192
	9193	(defun sp-newline ()
	9194	"Insert a newline and indent it.
	9195
	9196	This is like `newline-and-indent', but it not only indents the
	9197	line that the point is on but also the S-expression following the
	9198	point, if there is one.
	9199
	9200	If in a string, just insert a literal newline.
	9201
	9202	If in a comment and if followed by invalid structure, call
	9203	`indent-new-comment-line' to keep the invalid structure in a
	9204	comment."
	9205	(interactive)
	9206	(cond
	9207	((sp-point-in-string)
	9208	(newline))
	9209	((sp-point-in-comment)
	9210	(if (sp-region-ok-p (point) (point-at-eol))
	9211	(progn (newline-and-indent) (ignore-errors (indent-sexp)))
	9212	(indent-new-comment-line)))
	9213	(t
	9214	(newline-and-indent)
	9215	(ignore-errors (indent-sexp)))))
	9216
	9217	(defun sp-comment ()
	9218	"Insert the comment character and adjust hanging sexps such
	9219	that it doesn't break structure."
	9220	(interactive)
	9221	(if (sp-point-in-string-or-comment)
	9222	(if (= 1 (length (single-key-description last-command-event))) ;; pretty hacky
	9223	(insert (single-key-description last-command-event))
	9224	(insert comment-start))
	9225	(sp--with-case-sensitive
	9226	(let ((old-point (point))
	9227	(column (current-column))
	9228	(indentation (sp--current-indentation))
	9229	(old-line (line-number-at-pos))
	9230	(hsexp (sp-get-hybrid-sexp))
	9231	(newline-inserted 0))
	9232	(goto-char (sp-get hsexp :end))
	9233	(if (and (sp--looking-at-p (concat "\\s-*" (sp--get-closing-regexp)))
	9234	(= old-line (line-number-at-pos)))
	9235	(progn
	9236	(setq old-point (point))
	9237	(newline)
	9238	(setq newline-inserted (1+ (- (line-end-position) (point)))))
	9239	(when (/= old-line (line-number-at-pos))
	9240	(sp-backward-sexp)
	9241	(setq old-point (+ old-point (skip-syntax-backward " ")))
	9242	(newline)
	9243	(setq newline-inserted (- (line-end-position) (point)))))
	9244	;; @{ indenting madness
	9245	(goto-char old-point)
	9246	(sp-get hsexp (sp--indent-region :beg (+ :end newline-inserted)))
	9247	(sp--back-to-indentation column indentation)
	9248	;; @}
	9249	(let ((comment-delim (or (cdr (--first (memq major-mode (car it)) sp-comment-string))
	9250	comment-start)))
	9251	(when (and (/= 0 (current-column))
	9252	(not (sp--looking-back-p "\\s-")))
	9253	(insert " "))
	9254	(insert comment-delim)
	9255	(when (/= newline-inserted 0)
	9256	(save-excursion
	9257	(forward-line 1)
	9258	(indent-according-to-mode))))))))
	9259
	9260	(defun sp-wrap-round ()
	9261	"Wrap following sexp in round parentheses."
	9262	(interactive)
	9263	(sp-wrap-with-pair "("))
	9264
	9265	(defun sp-wrap-square ()
	9266	"Wrap following sexp in square brackets."
	9267	(interactive)
	9268	(sp-wrap-with-pair "["))
	9269
	9270	(defun sp-wrap-curly ()
	9271	"Wrap following sexp in curly braces."
	9272	(interactive)
	9273	(sp-wrap-with-pair "{"))
	9274
	9275
	9276	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
	9277	;; show-smartparens-mode
	9278
	9279	(defgroup show-smartparens nil
	9280	"Show smartparens minor mode."
	9281	:group 'smartparens)
	9282
	9283	(defcustom sp-show-pair-delay 0.125
	9284	"Time in seconds to delay before showing a matching pair."
	9285	:type '(number :tag "seconds")
	9286	:group 'show-smartparens)
	9287
	9288	(defcustom sp-show-enclosing-pair-commands '(
	9289	sp-show-enclosing-pair
	9290	sp-forward-slurp-sexp
	9291	sp-backward-slurp-sexp
	9292	sp-forward-barf-sexp
	9293	sp-backward-barf-sexp
	9294	)
	9295	"List of commands after which the enclosing pair is highlighted.
	9296
	9297	After the next command the pair will automatically disappear."
	9298	:type '(repeat symbol)
	9299	:group 'show-smartparens)
	9300
	9301	(defcustom sp-show-pair-from-inside nil
	9302	"If non-nil, highlight the enclosing pair if immediately after
	9303	the opening delimiter or before the closing delimiter."
	9304	:type 'boolean
	9305	:group 'show-smartparens)
	9306
	9307	(defface sp-show-pair-match-face
	9308	'((t (:inherit show-paren-match)))
	9309	"`show-smartparens-mode' face used for a matching pair."
	9310	:group 'show-smartparens)
	9311
	9312	(defface sp-show-pair-mismatch-face
	9313	'((t (:inherit show-paren-mismatch)))
	9314	"`show-smartparens-mode' face used for a mismatching pair."
	9315	:group 'show-smartparens)
	9316
	9317	(defface sp-show-pair-enclosing
	9318	'((t (:inherit highlight)))
	9319	"The face used to highlight pair overlays."
	9320	:group 'show-smartparens)
	9321
	9322	(defface sp-show-pair-match-content-face
	9323	'()
	9324	"`show-smartparens-mode' face used for a matching pair's content."
	9325	:group 'show-smartparens)
	9326
	9327	(defvar sp-show-pair-idle-timer nil)
	9328
	9329	(defvar sp-show-pair-overlays nil)
	9330
	9331	(defvar sp-show-pair-previous-match-positions nil)
	9332
	9333	(defvar sp-show-pair-previous-point nil)
	9334
	9335	(defvar sp-show-pair-enc-overlays nil)
	9336
	9337	;;;###autoload
	9338	(define-minor-mode show-smartparens-mode
	9339	"Toggle visualization of matching pairs. When enabled, any
	9340	matching pair is highlighted after `sp-show-pair-delay' seconds
	9341	of Emacs idle time if the point is immediately in front or after
	9342	a pair. This mode works similarly to `show-paren-mode', but
	9343	support custom pairs."
	9344	:init-value nil
	9345	:group 'show-smartparens
	9346	(if show-smartparens-mode
	9347	(unless sp-show-pair-idle-timer
	9348	(setq sp-show-pair-idle-timer
	9349	(run-with-idle-timer sp-show-pair-delay t
	9350	'sp-show--pair-function)))
	9351	(when sp-show-pair-overlays
	9352	(sp-show--pair-delete-overlays))))
	9353
	9354	;;;###autoload
	9355	(define-globalized-minor-mode show-smartparens-global-mode
	9356	show-smartparens-mode
	9357	turn-on-show-smartparens-mode)
	9358
	9359	;;;###autoload
	9360	(defun turn-on-show-smartparens-mode ()
	9361	"Turn on `show-smartparens-mode'."
	9362	(interactive)
	9363	(unless (or (member major-mode sp-ignore-modes-list)
	9364	(and (not (derived-mode-p 'comint-mode))
	9365	(eq (get major-mode 'mode-class) 'special)))
	9366	(show-smartparens-mode t)))
	9367
	9368	;;;###autoload
	9369	(defun turn-off-show-smartparens-mode ()
	9370	"Turn off `show-smartparens-mode'."
	9371	(interactive)
	9372	(show-smartparens-mode -1))
	9373
	9374	(defun sp-show-enclosing-pair ()
	9375	"Highlight the enclosing pair around point."
	9376	(interactive))
	9377
	9378	(defun sp-highlight-current-sexp (_arg)
	9379	"Highlight the expression returned by the next command, preserving point position."
	9380	(interactive "P")
	9381	(let* ((cmd (read-key-sequence "" t))
	9382	(com (key-binding cmd)))
	9383	(if (commandp com)
	9384	(save-excursion
	9385	(let ((ok (call-interactively com)))
	9386	(sp-show--pair-enc-function ok)))
	9387	(execute-kbd-macro cmd))))
	9388
	9389	(defun sp-show--pair-function ()
	9390	"Display the show pair overlays and print the line of the
	9391	matching paren in the echo area if not visible on screen."
	9392	(when show-smartparens-mode
	9393	(sp--with-case-sensitive
	9394	(save-match-data
	9395	(cl-labels ((scan-and-place-overlays
	9396	(match &optional back)
	9397	;; we can use `sp-get-thing' here because we are at some
	9398	;; pair opening, and so only the tag or the sexp can trigger.
	9399	(-if-let (ok (sp-get-thing back))
	9400	(sp-get ok
	9401	(when (or (and back
	9402	(or (= :end (point))
	9403	(= :beg-in (point))))
	9404	(and (not back)
	9405	(or (= :beg (point))
	9406	(= :end-in (point)))))
	9407	(sp-show--pair-create-overlays :beg :end :op-l :cl-l)
	9408	(when (and sp-echo-match-when-invisible
	9409	(not (or (active-minibuffer-window) cursor-in-echo-area)))
	9410	(sp-show--pair-echo-match :beg :end :op-l :cl-l))))
	9411	(if back
	9412	(sp-show--pair-create-mismatch-overlay (- (point) (length match))
	9413	(length match))
	9414	(sp-show--pair-create-mismatch-overlay (point) (length match)))
	9415	(setq sp-show-pair-previous-match-positions nil)
	9416	(setq sp-show-pair-previous-point nil))))
	9417	(let* ((pair-list (sp--get-allowed-pair-list))
	9418	(opening (sp--get-opening-regexp pair-list))
	9419	(closing (sp--get-closing-regexp pair-list))
	9420	(allowed (and sp-show-pair-from-inside (sp--get-allowed-regexp))))
	9421	(cond
	9422	;; if we are in a situation "()\|", we should highlight the
	9423	;; regular pair and not the string pair "from inside"
	9424	((and (not (sp--evil-normal-state-p))
	9425	(not (sp--evil-motion-state-p))
	9426	(not (sp--evil-visual-state-p))
	9427	(sp--looking-back (if sp-show-pair-from-inside allowed closing)))
	9428	(scan-and-place-overlays (match-string 0) :back))
	9429	((or (and (or (sp--evil-normal-state-p)
	9430	(sp--evil-motion-state-p)
	9431	(sp--evil-visual-state-p))
	9432	(sp--looking-at (sp--get-allowed-regexp)))
	9433	(sp--looking-at (if sp-show-pair-from-inside allowed opening))
	9434	(looking-at (sp--get-stringlike-regexp))
	9435	(and (memq major-mode sp-navigate-consider-sgml-tags)
	9436	(looking-at "<")))
	9437	(scan-and-place-overlays (match-string 0)))
	9438	((or (sp--looking-back (if sp-show-pair-from-inside allowed closing))
	9439	(sp--looking-back (sp--get-stringlike-regexp))
	9440	(and (memq major-mode sp-navigate-consider-sgml-tags)
	9441	(sp--looking-back ">")))
	9442	(scan-and-place-overlays (match-string 0) :back))
	9443	(sp-show-pair-overlays
	9444	(sp-show--pair-delete-overlays)
	9445	(setq sp-show-pair-previous-match-positions nil)
	9446	(setq sp-show-pair-previous-point nil)))))))))
	9447
	9448	(defun sp-show--pair-enc-function (&optional thing)
	9449	"Display the show pair overlays for enclosing expression."
	9450	(when show-smartparens-mode
	9451	(-when-let (enc (or thing (sp-get-enclosing-sexp)))
	9452	(sp-get enc (sp-show--pair-create-enc-overlays :beg :end :op-l :cl-l)))))
	9453
	9454	(defun sp-show--pair-create-overlays (start end olen clen)
	9455	"Create the show pair overlays."
	9456	(when sp-show-pair-overlays
	9457	(sp-show--pair-delete-overlays))
	9458	(let* ((oleft (make-overlay start (+ start olen) nil t nil))
	9459	(omiddle (make-overlay (+ start olen) (- end clen) nil t nil))
	9460	(oright (make-overlay (- end clen) end nil t nil)))
	9461	(setq sp-show-pair-overlays (list oleft omiddle oright))
	9462	(overlay-put oleft 'face 'sp-show-pair-match-face)
	9463	(unless (use-region-p)
	9464	(overlay-put omiddle 'face 'sp-show-pair-match-content-face))
	9465	(overlay-put oright 'face 'sp-show-pair-match-face)
	9466	(overlay-put oleft 'priority 1000)
	9467	(overlay-put omiddle 'priority 1000)
	9468	(overlay-put oright 'priority 1000)
	9469	(overlay-put oleft 'type 'show-pair)))
	9470
	9471	(defun sp-show--pair-echo-match (start end olen clen)
	9472	"Print the line of the matching paren in the echo area if not
	9473	visible on screen. Needs to be called after the show-pair overlay
	9474	has been created."
	9475	(let ((match-positions (list start end olen clen)))
	9476	(when (not (and (equal sp-show-pair-previous-match-positions match-positions)
	9477	(equal sp-show-pair-previous-point (point))))
	9478	(setq sp-show-pair-previous-match-positions match-positions)
	9479	(setq sp-show-pair-previous-point (point))
	9480	(let* ((visible-start (pos-visible-in-window-p start))
	9481	(visible-end (pos-visible-in-window-p end))
	9482	(where (cond
	9483	((not visible-start) start)
	9484	((not visible-end) end))))
	9485	(when where
	9486	(save-excursion
	9487	(let* ((from (progn (goto-char where) (beginning-of-line) (point)))
	9488	(to (progn (end-of-line) (point)))
	9489	(line (buffer-substring from to))
	9490	(message-log-max)) ;; don't log in messages
	9491	;; Add smartparens overlay for opening parens
	9492	(let* ((i1 (- start from))
	9493	(i2 (+ i1 olen)))
	9494	(when (and (< i1 (length line)) (>= i2 0))
	9495	(add-face-text-property (max i1 0) (min i2 (length line))
	9496	'sp-show-pair-match-face nil line)))
	9497	;; Add smartparens overlay for closing parens
	9498	(let* ((i1 (- end from 1))
	9499	(i2 (+ i1 clen)))
	9500	(when (and (< i1 (length line)) (>= i2 0))
	9501	(add-face-text-property (max i1 0) (min i2 (length line))
	9502	'sp-show-pair-match-face nil line)))
	9503	;; echo line of match
	9504	(message "Matches: %s" (string-trim line)))))))))
	9505
	9506	(defun sp-show--pair-create-enc-overlays (start end olen clen)
	9507	"Create the show pair enclosing overlays"
	9508	(when sp-show-pair-enc-overlays
	9509	(sp-show--pair-delete-enc-overlays))
	9510	(let* ((oleft (make-overlay start (+ start olen) nil t nil))
	9511	(oright (make-overlay (- end clen) end nil t nil)))
	9512	(setq sp-show-pair-enc-overlays (cons oleft oright))
	9513	(overlay-put oleft 'face 'sp-show-pair-enclosing)
	9514	(overlay-put oright 'face 'sp-show-pair-enclosing)
	9515	(overlay-put oleft 'priority 1000)
	9516	(overlay-put oright 'priority 1000)
	9517	(overlay-put oleft 'type 'show-pair-enc)))
	9518
	9519	(defun sp-show--pair-create-mismatch-overlay (start len)
	9520	"Create the mismatch pair overlay."
	9521	(when sp-show-pair-overlays
	9522	(sp-show--pair-delete-overlays))
	9523	(let ((o (make-overlay start (+ start len) nil t nil)))
	9524	(setq sp-show-pair-overlays (list o))
	9525	(overlay-put o 'face 'sp-show-pair-mismatch-face)
	9526	(overlay-put o 'priority 1000)
	9527	(overlay-put o 'type 'show-pair)))
	9528
	9529	(defun sp-show--pair-delete-overlays ()
	9530	"Remove both show pair overlays."
	9531	(when sp-show-pair-overlays
	9532	(dolist (overlay sp-show-pair-overlays)
	9533	(delete-overlay overlay))
	9534	(setq sp-show-pair-overlays nil)))
	9535
	9536	(defun sp-show--pair-delete-enc-overlays ()
	9537	"Remove both show pair enclosing overlays."
	9538	(when sp-show-pair-enc-overlays
	9539	(when (car sp-show-pair-enc-overlays)
	9540	(delete-overlay (car sp-show-pair-enc-overlays)))
	9541	(when (cdr sp-show-pair-enc-overlays)
	9542	(delete-overlay (cdr sp-show-pair-enc-overlays)))
	9543	(setq sp-show-pair-enc-overlays nil)))
	9544
	9545
	9546	;; global initialization
	9547	(defadvice delete-backward-char (before sp-delete-pair-advice activate)
	9548	(save-match-data
	9549	(sp-delete-pair (ad-get-arg 0))))
	9550	(defadvice haskell-indentation-delete-backward-char (before sp-delete-pair-advice activate)
	9551	(save-match-data
	9552	(sp-delete-pair (ad-get-arg 0))))
	9553	(add-hook 'post-command-hook 'sp--post-command-hook-handler)
	9554	(sp--set-base-key-bindings)
	9555	(sp--update-override-key-bindings)
	9556
	9557	(defadvice company--insert-candidate (after sp-company--insert-candidate activate)
	9558	"If `smartparens-mode' is active, we check if the completed string
	9559	has a pair definition. If so, we insert the closing pair."
	9560	(when smartparens-mode
	9561	(sp-insert-pair))
	9562	ad-return-value)
	9563
	9564	(defadvice hippie-expand (after sp-auto-complete-advice activate)
	9565	(when smartparens-mode
	9566	(sp-insert-pair)))
	9567
	9568	(defvar sp--mc/cursor-specific-vars
	9569	'(
	9570	sp-wrap-point
	9571	sp-wrap-mark
	9572	sp-last-wrapped-region
	9573	sp-pair-overlay-list
	9574	sp-wrap-overlays
	9575	sp-wrap-tag-overlays
	9576	sp-last-operation
	9577	sp-previous-point
	9578	)
	9579	"A list of vars that need to be tracked on a per-cursor basis.")
	9580
	9581	(defvar mc/cursor-specific-vars)
	9582	(eval-after-load 'multiple-cursors
	9583	'(dolist (it sp--mc/cursor-specific-vars)
	9584	(add-to-list 'mc/cursor-specific-vars it)))
	9585
	9586	(provide 'smartparens)
	9587
	9588	;; Local Variables:
	9589	;; coding: utf-8
	9590	;; eval: (font-lock-add-keywords nil `((,(concat "(" (regexp-opt '("sp-do-move-op" "sp-do-move-cl" "sp-do-put-op" "sp-do-put-cl" "sp-do-del-op" "sp-do-del-cl") t) "\\_>") 1 'font-lock-variable-name-face)))
	9591	;; End:
	9592
	9593	;;; smartparens.el ends here